2 * Mesa 3-D graphics library
5 * Copyright (C) 2006 Tungsten Graphics All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 * Create a vertex program to execute the current fixed function T&L pipeline.
29 * \author Keith Whitwell
36 #include "main/ffvertex_prog.h"
37 #include "shader/program.h"
38 #include "shader/prog_instruction.h"
39 #include "shader/prog_parameter.h"
40 #include "shader/prog_print.h"
41 #include "shader/prog_statevars.h"
42 #include "t_context.h" /* NOTE: very light dependency on this */
43 #include "t_vp_build.h"
47 unsigned light_global_enabled
:1;
48 unsigned light_local_viewer
:1;
49 unsigned light_twoside
:1;
50 unsigned light_color_material
:1;
51 unsigned light_color_material_mask
:12;
52 unsigned light_material_mask
:12;
55 unsigned rescale_normals
:1;
56 unsigned fog_source_is_depth
:1;
57 unsigned tnl_do_vertex_fog
:1;
58 unsigned separate_specular
:1;
60 unsigned point_attenuated
:1;
61 unsigned texture_enabled_global
:1;
62 unsigned fragprog_inputs_read
:12;
65 unsigned light_enabled
:1;
66 unsigned light_eyepos3_is_zero
:1;
67 unsigned light_spotcutoff_is_180
:1;
68 unsigned light_attenuated
:1;
69 unsigned texunit_really_enabled
:1;
70 unsigned texmat_enabled
:1;
71 unsigned texgen_enabled
:4;
72 unsigned texgen_mode0
:4;
73 unsigned texgen_mode1
:4;
74 unsigned texgen_mode2
:4;
75 unsigned texgen_mode3
:4;
86 static GLuint
translate_fog_mode( GLenum mode
)
89 case GL_LINEAR
: return FOG_LINEAR
;
90 case GL_EXP
: return FOG_EXP
;
91 case GL_EXP2
: return FOG_EXP2
;
92 default: return FOG_NONE
;
97 #define TXG_OBJ_LINEAR 1
98 #define TXG_EYE_LINEAR 2
99 #define TXG_SPHERE_MAP 3
100 #define TXG_REFLECTION_MAP 4
101 #define TXG_NORMAL_MAP 5
103 static GLuint
translate_texgen( GLboolean enabled
, GLenum mode
)
109 case GL_OBJECT_LINEAR
: return TXG_OBJ_LINEAR
;
110 case GL_EYE_LINEAR
: return TXG_EYE_LINEAR
;
111 case GL_SPHERE_MAP
: return TXG_SPHERE_MAP
;
112 case GL_REFLECTION_MAP_NV
: return TXG_REFLECTION_MAP
;
113 case GL_NORMAL_MAP_NV
: return TXG_NORMAL_MAP
;
114 default: return TXG_NONE
;
120 * Returns bitmask of flags indicating which materials are set per-vertex
122 * XXX get these from the VBO...
125 tnl_get_per_vertex_materials(GLcontext
*ctx
)
127 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
128 struct vertex_buffer
*VB
= &tnl
->vb
;
130 GLbitfield mask
= 0x0;
132 for (i
= _TNL_FIRST_MAT
; i
<= _TNL_LAST_MAT
; i
++)
133 if (VB
->AttribPtr
[i
] && VB
->AttribPtr
[i
]->stride
)
134 mask
|= 1 << (i
- _TNL_FIRST_MAT
);
140 * Should fog be computed per-vertex?
143 tnl_get_per_vertex_fog(GLcontext
*ctx
)
145 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
146 return tnl
->_DoVertexFog
;
150 static struct state_key
*make_state_key( GLcontext
*ctx
)
152 const struct gl_fragment_program
*fp
;
153 struct state_key
*key
= CALLOC_STRUCT(state_key
);
156 fp
= ctx
->FragmentProgram
._Current
;
158 /* This now relies on texenvprogram.c being active:
162 key
->fragprog_inputs_read
= fp
->Base
.InputsRead
;
164 if (ctx
->RenderMode
== GL_FEEDBACK
) {
165 /* make sure the vertprog emits color and tex0 */
166 key
->fragprog_inputs_read
|= (FRAG_BIT_COL0
| FRAG_BIT_TEX0
);
169 key
->separate_specular
= (ctx
->Light
.Model
.ColorControl
==
170 GL_SEPARATE_SPECULAR_COLOR
);
172 if (ctx
->Light
.Enabled
) {
173 key
->light_global_enabled
= 1;
175 if (ctx
->Light
.Model
.LocalViewer
)
176 key
->light_local_viewer
= 1;
178 if (ctx
->Light
.Model
.TwoSide
)
179 key
->light_twoside
= 1;
181 if (ctx
->Light
.ColorMaterialEnabled
) {
182 key
->light_color_material
= 1;
183 key
->light_color_material_mask
= ctx
->Light
.ColorMaterialBitmask
;
186 key
->light_material_mask
= tnl_get_per_vertex_materials(ctx
);
188 for (i
= 0; i
< MAX_LIGHTS
; i
++) {
189 struct gl_light
*light
= &ctx
->Light
.Light
[i
];
191 if (light
->Enabled
) {
192 key
->unit
[i
].light_enabled
= 1;
194 if (light
->EyePosition
[3] == 0.0)
195 key
->unit
[i
].light_eyepos3_is_zero
= 1;
197 if (light
->SpotCutoff
== 180.0)
198 key
->unit
[i
].light_spotcutoff_is_180
= 1;
200 if (light
->ConstantAttenuation
!= 1.0 ||
201 light
->LinearAttenuation
!= 0.0 ||
202 light
->QuadraticAttenuation
!= 0.0)
203 key
->unit
[i
].light_attenuated
= 1;
208 if (ctx
->Transform
.Normalize
)
211 if (ctx
->Transform
.RescaleNormals
)
212 key
->rescale_normals
= 1;
214 key
->fog_mode
= translate_fog_mode(fp
->FogOption
);
216 if (ctx
->Fog
.FogCoordinateSource
== GL_FRAGMENT_DEPTH_EXT
)
217 key
->fog_source_is_depth
= 1;
219 key
->tnl_do_vertex_fog
= tnl_get_per_vertex_fog(ctx
);
221 if (ctx
->Point
._Attenuated
)
222 key
->point_attenuated
= 1;
224 if (ctx
->Texture
._TexGenEnabled
||
225 ctx
->Texture
._TexMatEnabled
||
226 ctx
->Texture
._EnabledUnits
)
227 key
->texture_enabled_global
= 1;
229 for (i
= 0; i
< MAX_TEXTURE_UNITS
; i
++) {
230 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[i
];
232 if (texUnit
->_ReallyEnabled
)
233 key
->unit
[i
].texunit_really_enabled
= 1;
235 if (ctx
->Texture
._TexMatEnabled
& ENABLE_TEXMAT(i
))
236 key
->unit
[i
].texmat_enabled
= 1;
238 if (texUnit
->TexGenEnabled
) {
239 key
->unit
[i
].texgen_enabled
= 1;
241 key
->unit
[i
].texgen_mode0
=
242 translate_texgen( texUnit
->TexGenEnabled
& (1<<0),
244 key
->unit
[i
].texgen_mode1
=
245 translate_texgen( texUnit
->TexGenEnabled
& (1<<1),
247 key
->unit
[i
].texgen_mode2
=
248 translate_texgen( texUnit
->TexGenEnabled
& (1<<2),
250 key
->unit
[i
].texgen_mode3
=
251 translate_texgen( texUnit
->TexGenEnabled
& (1<<3),
261 /* Very useful debugging tool - produces annotated listing of
262 * generated program with line/function references for each
263 * instruction back into this file:
265 #define DISASSEM (MESA_VERBOSE&VERBOSE_DISASSEM)
267 /* Should be tunable by the driver - do we want to do matrix
268 * multiplications with DP4's or with MUL/MAD's? SSE works better
269 * with the latter, drivers may differ.
275 /* Use uregs to represent registers internally, translate to Mesa's
276 * expected formats on emit.
278 * NOTE: These are passed by value extensively in this file rather
279 * than as usual by pointer reference. If this disturbs you, try
280 * remembering they are just 32bits in size.
282 * GCC is smart enough to deal with these dword-sized structures in
283 * much the same way as if I had defined them as dwords and was using
284 * macros to access and set the fields. This is much nicer and easier
289 GLint idx
:8; /* relative addressing may be negative */
297 const struct state_key
*state
;
298 struct gl_vertex_program
*program
;
301 GLuint temp_reserved
;
303 struct ureg eye_position
;
304 struct ureg eye_position_normalized
;
305 struct ureg eye_normal
;
306 struct ureg identity
;
309 GLuint color_materials
;
313 static const struct ureg undef
= {
331 static struct ureg
make_ureg(GLuint file
, GLint idx
)
337 reg
.swz
= SWIZZLE_NOOP
;
344 static struct ureg
negate( struct ureg reg
)
351 static struct ureg
swizzle( struct ureg reg
, int x
, int y
, int z
, int w
)
353 reg
.swz
= MAKE_SWIZZLE4(GET_SWZ(reg
.swz
, x
),
356 GET_SWZ(reg
.swz
, w
));
361 static struct ureg
swizzle1( struct ureg reg
, int x
)
363 return swizzle(reg
, x
, x
, x
, x
);
366 static struct ureg
get_temp( struct tnl_program
*p
)
368 int bit
= _mesa_ffs( ~p
->temp_in_use
);
370 _mesa_problem(NULL
, "%s: out of temporaries\n", __FILE__
);
374 if ((GLuint
) bit
> p
->program
->Base
.NumTemporaries
)
375 p
->program
->Base
.NumTemporaries
= bit
;
377 p
->temp_in_use
|= 1<<(bit
-1);
378 return make_ureg(PROGRAM_TEMPORARY
, bit
-1);
381 static struct ureg
reserve_temp( struct tnl_program
*p
)
383 struct ureg temp
= get_temp( p
);
384 p
->temp_reserved
|= 1<<temp
.idx
;
388 static void release_temp( struct tnl_program
*p
, struct ureg reg
)
390 if (reg
.file
== PROGRAM_TEMPORARY
) {
391 p
->temp_in_use
&= ~(1<<reg
.idx
);
392 p
->temp_in_use
|= p
->temp_reserved
; /* can't release reserved temps */
396 static void release_temps( struct tnl_program
*p
)
398 p
->temp_in_use
= p
->temp_reserved
;
403 static struct ureg
register_input( struct tnl_program
*p
, GLuint input
)
405 p
->program
->Base
.InputsRead
|= (1<<input
);
406 return make_ureg(PROGRAM_INPUT
, input
);
409 static struct ureg
register_output( struct tnl_program
*p
, GLuint output
)
411 p
->program
->Base
.OutputsWritten
|= (1<<output
);
412 return make_ureg(PROGRAM_OUTPUT
, output
);
415 static struct ureg
register_const4f( struct tnl_program
*p
,
428 idx
= _mesa_add_unnamed_constant( p
->program
->Base
.Parameters
, values
, 4,
430 ASSERT(swizzle
== SWIZZLE_NOOP
);
431 return make_ureg(PROGRAM_STATE_VAR
, idx
);
434 #define register_const1f(p, s0) register_const4f(p, s0, 0, 0, 1)
435 #define register_scalar_const(p, s0) register_const4f(p, s0, s0, s0, s0)
436 #define register_const2f(p, s0, s1) register_const4f(p, s0, s1, 0, 1)
437 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
439 static GLboolean
is_undef( struct ureg reg
)
441 return reg
.file
== PROGRAM_UNDEFINED
;
444 static struct ureg
get_identity_param( struct tnl_program
*p
)
446 if (is_undef(p
->identity
))
447 p
->identity
= register_const4f(p
, 0,0,0,1);
452 static struct ureg
register_param5(struct tnl_program
*p
,
459 gl_state_index tokens
[STATE_LENGTH
];
466 idx
= _mesa_add_state_reference( p
->program
->Base
.Parameters
, tokens
);
467 return make_ureg(PROGRAM_STATE_VAR
, idx
);
471 #define register_param1(p,s0) register_param5(p,s0,0,0,0,0)
472 #define register_param2(p,s0,s1) register_param5(p,s0,s1,0,0,0)
473 #define register_param3(p,s0,s1,s2) register_param5(p,s0,s1,s2,0,0)
474 #define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
477 static void register_matrix_param5( struct tnl_program
*p
,
478 GLint s0
, /* modelview, projection, etc */
479 GLint s1
, /* texture matrix number */
480 GLint s2
, /* first row */
481 GLint s3
, /* last row */
482 GLint s4
, /* inverse, transpose, etc */
483 struct ureg
*matrix
)
487 /* This is a bit sad as the support is there to pull the whole
488 * matrix out in one go:
490 for (i
= 0; i
<= s3
- s2
; i
++)
491 matrix
[i
] = register_param5( p
, s0
, s1
, i
, i
, s4
);
495 static void emit_arg( struct prog_src_register
*src
,
498 src
->File
= reg
.file
;
499 src
->Index
= reg
.idx
;
500 src
->Swizzle
= reg
.swz
;
501 src
->NegateBase
= reg
.negate
? NEGATE_XYZW
: 0;
507 static void emit_dst( struct prog_dst_register
*dst
,
508 struct ureg reg
, GLuint mask
)
510 dst
->File
= reg
.file
;
511 dst
->Index
= reg
.idx
;
512 /* allow zero as a shorthand for xyzw */
513 dst
->WriteMask
= mask
? mask
: WRITEMASK_XYZW
;
514 dst
->CondMask
= COND_TR
; /* always pass cond test */
515 dst
->CondSwizzle
= SWIZZLE_NOOP
;
520 static void debug_insn( struct prog_instruction
*inst
, const char *fn
,
524 static const char *last_fn
;
528 _mesa_printf("%s:\n", fn
);
531 _mesa_printf("%d:\t", line
);
532 _mesa_print_instruction(inst
);
537 static void emit_op3fn(struct tnl_program
*p
,
547 GLuint nr
= p
->program
->Base
.NumInstructions
++;
548 struct prog_instruction
*inst
= &p
->program
->Base
.Instructions
[nr
];
550 if (p
->program
->Base
.NumInstructions
> MAX_INSN
) {
551 _mesa_problem(0, "Out of instructions in emit_op3fn\n");
555 inst
->Opcode
= (enum prog_opcode
) op
;
559 emit_arg( &inst
->SrcReg
[0], src0
);
560 emit_arg( &inst
->SrcReg
[1], src1
);
561 emit_arg( &inst
->SrcReg
[2], src2
);
563 emit_dst( &inst
->DstReg
, dest
, mask
);
565 debug_insn(inst
, fn
, line
);
569 #define emit_op3(p, op, dst, mask, src0, src1, src2) \
570 emit_op3fn(p, op, dst, mask, src0, src1, src2, __FUNCTION__, __LINE__)
572 #define emit_op2(p, op, dst, mask, src0, src1) \
573 emit_op3fn(p, op, dst, mask, src0, src1, undef, __FUNCTION__, __LINE__)
575 #define emit_op1(p, op, dst, mask, src0) \
576 emit_op3fn(p, op, dst, mask, src0, undef, undef, __FUNCTION__, __LINE__)
579 static struct ureg
make_temp( struct tnl_program
*p
, struct ureg reg
)
581 if (reg
.file
== PROGRAM_TEMPORARY
&&
582 !(p
->temp_reserved
& (1<<reg
.idx
)))
585 struct ureg temp
= get_temp(p
);
586 emit_op1(p
, OPCODE_MOV
, temp
, 0, reg
);
592 /* Currently no tracking performed of input/output/register size or
593 * active elements. Could be used to reduce these operations, as
594 * could the matrix type.
596 static void emit_matrix_transform_vec4( struct tnl_program
*p
,
598 const struct ureg
*mat
,
601 emit_op2(p
, OPCODE_DP4
, dest
, WRITEMASK_X
, src
, mat
[0]);
602 emit_op2(p
, OPCODE_DP4
, dest
, WRITEMASK_Y
, src
, mat
[1]);
603 emit_op2(p
, OPCODE_DP4
, dest
, WRITEMASK_Z
, src
, mat
[2]);
604 emit_op2(p
, OPCODE_DP4
, dest
, WRITEMASK_W
, src
, mat
[3]);
607 /* This version is much easier to implement if writemasks are not
608 * supported natively on the target or (like SSE), the target doesn't
609 * have a clean/obvious dotproduct implementation.
611 static void emit_transpose_matrix_transform_vec4( struct tnl_program
*p
,
613 const struct ureg
*mat
,
618 if (dest
.file
!= PROGRAM_TEMPORARY
)
623 emit_op2(p
, OPCODE_MUL
, tmp
, 0, swizzle1(src
,X
), mat
[0]);
624 emit_op3(p
, OPCODE_MAD
, tmp
, 0, swizzle1(src
,Y
), mat
[1], tmp
);
625 emit_op3(p
, OPCODE_MAD
, tmp
, 0, swizzle1(src
,Z
), mat
[2], tmp
);
626 emit_op3(p
, OPCODE_MAD
, dest
, 0, swizzle1(src
,W
), mat
[3], tmp
);
628 if (dest
.file
!= PROGRAM_TEMPORARY
)
629 release_temp(p
, tmp
);
632 static void emit_matrix_transform_vec3( struct tnl_program
*p
,
634 const struct ureg
*mat
,
637 emit_op2(p
, OPCODE_DP3
, dest
, WRITEMASK_X
, src
, mat
[0]);
638 emit_op2(p
, OPCODE_DP3
, dest
, WRITEMASK_Y
, src
, mat
[1]);
639 emit_op2(p
, OPCODE_DP3
, dest
, WRITEMASK_Z
, src
, mat
[2]);
643 static void emit_normalize_vec3( struct tnl_program
*p
,
647 struct ureg tmp
= get_temp(p
);
648 emit_op2(p
, OPCODE_DP3
, tmp
, 0, src
, src
);
649 emit_op1(p
, OPCODE_RSQ
, tmp
, 0, tmp
);
650 emit_op2(p
, OPCODE_MUL
, dest
, 0, src
, tmp
);
651 release_temp(p
, tmp
);
654 static void emit_passthrough( struct tnl_program
*p
,
658 struct ureg out
= register_output(p
, output
);
659 emit_op1(p
, OPCODE_MOV
, out
, 0, register_input(p
, input
));
662 static struct ureg
get_eye_position( struct tnl_program
*p
)
664 if (is_undef(p
->eye_position
)) {
665 struct ureg pos
= register_input( p
, VERT_ATTRIB_POS
);
666 struct ureg modelview
[4];
668 p
->eye_position
= reserve_temp(p
);
671 register_matrix_param5( p
, STATE_MODELVIEW_MATRIX
, 0, 0, 3,
674 emit_matrix_transform_vec4(p
, p
->eye_position
, modelview
, pos
);
677 register_matrix_param5( p
, STATE_MODELVIEW_MATRIX
, 0, 0, 3,
678 STATE_MATRIX_TRANSPOSE
, modelview
);
680 emit_transpose_matrix_transform_vec4(p
, p
->eye_position
, modelview
, pos
);
684 return p
->eye_position
;
688 static struct ureg
get_eye_position_normalized( struct tnl_program
*p
)
690 if (is_undef(p
->eye_position_normalized
)) {
691 struct ureg eye
= get_eye_position(p
);
692 p
->eye_position_normalized
= reserve_temp(p
);
693 emit_normalize_vec3(p
, p
->eye_position_normalized
, eye
);
696 return p
->eye_position_normalized
;
700 static struct ureg
get_eye_normal( struct tnl_program
*p
)
702 if (is_undef(p
->eye_normal
)) {
703 struct ureg normal
= register_input(p
, VERT_ATTRIB_NORMAL
);
704 struct ureg mvinv
[3];
706 register_matrix_param5( p
, STATE_MODELVIEW_MATRIX
, 0, 0, 2,
707 STATE_MATRIX_INVTRANS
, mvinv
);
709 p
->eye_normal
= reserve_temp(p
);
711 /* Transform to eye space:
713 emit_matrix_transform_vec3( p
, p
->eye_normal
, mvinv
, normal
);
715 /* Normalize/Rescale:
717 if (p
->state
->normalize
) {
718 emit_normalize_vec3( p
, p
->eye_normal
, p
->eye_normal
);
720 else if (p
->state
->rescale_normals
) {
721 struct ureg rescale
= register_param2(p
, STATE_INTERNAL
,
724 emit_op2( p
, OPCODE_MUL
, p
->eye_normal
, 0, p
->eye_normal
,
725 swizzle1(rescale
, X
));
729 return p
->eye_normal
;
734 static void build_hpos( struct tnl_program
*p
)
736 struct ureg pos
= register_input( p
, VERT_ATTRIB_POS
);
737 struct ureg hpos
= register_output( p
, VERT_RESULT_HPOS
);
741 register_matrix_param5( p
, STATE_MVP_MATRIX
, 0, 0, 3,
743 emit_matrix_transform_vec4( p
, hpos
, mvp
, pos
);
746 register_matrix_param5( p
, STATE_MVP_MATRIX
, 0, 0, 3,
747 STATE_MATRIX_TRANSPOSE
, mvp
);
748 emit_transpose_matrix_transform_vec4( p
, hpos
, mvp
, pos
);
753 static GLuint
material_attrib( GLuint side
, GLuint property
)
755 return ((property
- STATE_AMBIENT
) * 2 +
759 /* Get a bitmask of which material values vary on a per-vertex basis.
761 static void set_material_flags( struct tnl_program
*p
)
763 p
->color_materials
= 0;
766 if (p
->state
->light_color_material
) {
768 p
->color_materials
= p
->state
->light_color_material_mask
;
771 p
->materials
|= p
->state
->light_material_mask
;
775 static struct ureg
get_material( struct tnl_program
*p
, GLuint side
,
778 GLuint attrib
= material_attrib(side
, property
);
780 if (p
->color_materials
& (1<<attrib
))
781 return register_input(p
, VERT_ATTRIB_COLOR0
);
782 else if (p
->materials
& (1<<attrib
))
783 return register_input( p
, attrib
+ _TNL_ATTRIB_MAT_FRONT_AMBIENT
);
785 return register_param3( p
, STATE_MATERIAL
, side
, property
);
788 #define SCENE_COLOR_BITS(side) (( MAT_BIT_FRONT_EMISSION | \
789 MAT_BIT_FRONT_AMBIENT | \
790 MAT_BIT_FRONT_DIFFUSE) << (side))
792 /* Either return a precalculated constant value or emit code to
793 * calculate these values dynamically in the case where material calls
794 * are present between begin/end pairs.
796 * Probably want to shift this to the program compilation phase - if
797 * we always emitted the calculation here, a smart compiler could
798 * detect that it was constant (given a certain set of inputs), and
799 * lift it out of the main loop. That way the programs created here
800 * would be independent of the vertex_buffer details.
802 static struct ureg
get_scenecolor( struct tnl_program
*p
, GLuint side
)
804 if (p
->materials
& SCENE_COLOR_BITS(side
)) {
805 struct ureg lm_ambient
= register_param1(p
, STATE_LIGHTMODEL_AMBIENT
);
806 struct ureg material_emission
= get_material(p
, side
, STATE_EMISSION
);
807 struct ureg material_ambient
= get_material(p
, side
, STATE_AMBIENT
);
808 struct ureg material_diffuse
= get_material(p
, side
, STATE_DIFFUSE
);
809 struct ureg tmp
= make_temp(p
, material_diffuse
);
810 emit_op3(p
, OPCODE_MAD
, tmp
, WRITEMASK_XYZ
, lm_ambient
,
811 material_ambient
, material_emission
);
815 return register_param2( p
, STATE_LIGHTMODEL_SCENECOLOR
, side
);
819 static struct ureg
get_lightprod( struct tnl_program
*p
, GLuint light
,
820 GLuint side
, GLuint property
)
822 GLuint attrib
= material_attrib(side
, property
);
823 if (p
->materials
& (1<<attrib
)) {
824 struct ureg light_value
=
825 register_param3(p
, STATE_LIGHT
, light
, property
);
826 struct ureg material_value
= get_material(p
, side
, property
);
827 struct ureg tmp
= get_temp(p
);
828 emit_op2(p
, OPCODE_MUL
, tmp
, 0, light_value
, material_value
);
832 return register_param4(p
, STATE_LIGHTPROD
, light
, side
, property
);
835 static struct ureg
calculate_light_attenuation( struct tnl_program
*p
,
840 struct ureg attenuation
= register_param3(p
, STATE_LIGHT
, i
,
842 struct ureg att
= get_temp(p
);
844 /* Calculate spot attenuation:
846 if (!p
->state
->unit
[i
].light_spotcutoff_is_180
) {
847 struct ureg spot_dir_norm
= register_param3(p
, STATE_INTERNAL
,
848 STATE_SPOT_DIR_NORMALIZED
, i
);
849 struct ureg spot
= get_temp(p
);
850 struct ureg slt
= get_temp(p
);
852 emit_op2(p
, OPCODE_DP3
, spot
, 0, negate(VPpli
), spot_dir_norm
);
853 emit_op2(p
, OPCODE_SLT
, slt
, 0, swizzle1(spot_dir_norm
,W
), spot
);
854 emit_op2(p
, OPCODE_POW
, spot
, 0, spot
, swizzle1(attenuation
, W
));
855 emit_op2(p
, OPCODE_MUL
, att
, 0, slt
, spot
);
857 release_temp(p
, spot
);
858 release_temp(p
, slt
);
861 /* Calculate distance attenuation:
863 if (p
->state
->unit
[i
].light_attenuated
) {
866 emit_op1(p
, OPCODE_RCP
, dist
, WRITEMASK_YZ
, dist
);
868 emit_op2(p
, OPCODE_MUL
, dist
, WRITEMASK_XZ
, dist
, swizzle1(dist
,Y
));
870 emit_op2(p
, OPCODE_DP3
, dist
, 0, attenuation
, dist
);
872 if (!p
->state
->unit
[i
].light_spotcutoff_is_180
) {
874 emit_op1(p
, OPCODE_RCP
, dist
, 0, dist
);
875 /* spot-atten * dist-atten */
876 emit_op2(p
, OPCODE_MUL
, att
, 0, dist
, att
);
879 emit_op1(p
, OPCODE_RCP
, att
, 0, dist
);
890 /* Need to add some addtional parameters to allow lighting in object
891 * space - STATE_SPOT_DIRECTION and STATE_HALF_VECTOR implicitly assume eye
894 static void build_lighting( struct tnl_program
*p
)
896 const GLboolean twoside
= p
->state
->light_twoside
;
897 const GLboolean separate
= p
->state
->separate_specular
;
898 GLuint nr_lights
= 0, count
= 0;
899 struct ureg normal
= get_eye_normal(p
);
900 struct ureg lit
= get_temp(p
);
901 struct ureg dots
= get_temp(p
);
902 struct ureg _col0
= undef
, _col1
= undef
;
903 struct ureg _bfc0
= undef
, _bfc1
= undef
;
906 for (i
= 0; i
< MAX_LIGHTS
; i
++)
907 if (p
->state
->unit
[i
].light_enabled
)
910 set_material_flags(p
);
913 struct ureg shininess
= get_material(p
, 0, STATE_SHININESS
);
914 emit_op1(p
, OPCODE_MOV
, dots
, WRITEMASK_W
, swizzle1(shininess
,X
));
915 release_temp(p
, shininess
);
917 _col0
= make_temp(p
, get_scenecolor(p
, 0));
919 _col1
= make_temp(p
, get_identity_param(p
));
926 struct ureg shininess
= get_material(p
, 1, STATE_SHININESS
);
927 emit_op1(p
, OPCODE_MOV
, dots
, WRITEMASK_Z
,
928 negate(swizzle1(shininess
,X
)));
929 release_temp(p
, shininess
);
931 _bfc0
= make_temp(p
, get_scenecolor(p
, 1));
933 _bfc1
= make_temp(p
, get_identity_param(p
));
939 /* If no lights, still need to emit the scenecolor.
942 struct ureg res0
= register_output( p
, VERT_RESULT_COL0
);
943 emit_op1(p
, OPCODE_MOV
, res0
, 0, _col0
);
947 struct ureg res1
= register_output( p
, VERT_RESULT_COL1
);
948 emit_op1(p
, OPCODE_MOV
, res1
, 0, _col1
);
952 struct ureg res0
= register_output( p
, VERT_RESULT_BFC0
);
953 emit_op1(p
, OPCODE_MOV
, res0
, 0, _bfc0
);
956 if (twoside
&& separate
) {
957 struct ureg res1
= register_output( p
, VERT_RESULT_BFC1
);
958 emit_op1(p
, OPCODE_MOV
, res1
, 0, _bfc1
);
961 if (nr_lights
== 0) {
967 for (i
= 0; i
< MAX_LIGHTS
; i
++) {
968 if (p
->state
->unit
[i
].light_enabled
) {
969 struct ureg half
= undef
;
970 struct ureg att
= undef
, VPpli
= undef
;
974 if (p
->state
->unit
[i
].light_eyepos3_is_zero
) {
975 /* Can used precomputed constants in this case.
976 * Attenuation never applies to infinite lights.
978 VPpli
= register_param3(p
, STATE_LIGHT
, i
,
979 STATE_POSITION_NORMALIZED
);
980 if (p
->state
->light_local_viewer
) {
981 struct ureg eye_hat
= get_eye_position_normalized(p
);
983 emit_op2(p
, OPCODE_SUB
, half
, 0, VPpli
, eye_hat
);
984 emit_normalize_vec3(p
, half
, half
);
986 half
= register_param3(p
, STATE_LIGHT
, i
, STATE_HALF_VECTOR
);
990 struct ureg Ppli
= register_param3(p
, STATE_LIGHT
, i
,
992 struct ureg V
= get_eye_position(p
);
993 struct ureg dist
= get_temp(p
);
998 /* Calulate VPpli vector
1000 emit_op2(p
, OPCODE_SUB
, VPpli
, 0, Ppli
, V
);
1002 /* Normalize VPpli. The dist value also used in
1003 * attenuation below.
1005 emit_op2(p
, OPCODE_DP3
, dist
, 0, VPpli
, VPpli
);
1006 emit_op1(p
, OPCODE_RSQ
, dist
, 0, dist
);
1007 emit_op2(p
, OPCODE_MUL
, VPpli
, 0, VPpli
, dist
);
1010 /* Calculate attenuation:
1012 if (!p
->state
->unit
[i
].light_spotcutoff_is_180
||
1013 p
->state
->unit
[i
].light_attenuated
) {
1014 att
= calculate_light_attenuation(p
, i
, VPpli
, dist
);
1018 /* Calculate viewer direction, or use infinite viewer:
1020 if (p
->state
->light_local_viewer
) {
1021 struct ureg eye_hat
= get_eye_position_normalized(p
);
1022 emit_op2(p
, OPCODE_SUB
, half
, 0, VPpli
, eye_hat
);
1025 struct ureg z_dir
= swizzle(get_identity_param(p
),X
,Y
,W
,Z
);
1026 emit_op2(p
, OPCODE_ADD
, half
, 0, VPpli
, z_dir
);
1029 emit_normalize_vec3(p
, half
, half
);
1031 release_temp(p
, dist
);
1034 /* Calculate dot products:
1036 emit_op2(p
, OPCODE_DP3
, dots
, WRITEMASK_X
, normal
, VPpli
);
1037 emit_op2(p
, OPCODE_DP3
, dots
, WRITEMASK_Y
, normal
, half
);
1040 /* Front face lighting:
1043 struct ureg ambient
= get_lightprod(p
, i
, 0, STATE_AMBIENT
);
1044 struct ureg diffuse
= get_lightprod(p
, i
, 0, STATE_DIFFUSE
);
1045 struct ureg specular
= get_lightprod(p
, i
, 0, STATE_SPECULAR
);
1046 struct ureg res0
, res1
;
1047 GLuint mask0
, mask1
;
1049 emit_op1(p
, OPCODE_LIT
, lit
, 0, dots
);
1052 emit_op2(p
, OPCODE_MUL
, lit
, 0, lit
, att
);
1055 if (count
== nr_lights
) {
1057 mask0
= WRITEMASK_XYZ
;
1058 mask1
= WRITEMASK_XYZ
;
1059 res0
= register_output( p
, VERT_RESULT_COL0
);
1060 res1
= register_output( p
, VERT_RESULT_COL1
);
1064 mask1
= WRITEMASK_XYZ
;
1066 res1
= register_output( p
, VERT_RESULT_COL0
);
1075 emit_op3(p
, OPCODE_MAD
, _col0
, 0, swizzle1(lit
,X
), ambient
, _col0
);
1076 emit_op3(p
, OPCODE_MAD
, res0
, mask0
, swizzle1(lit
,Y
), diffuse
, _col0
);
1077 emit_op3(p
, OPCODE_MAD
, res1
, mask1
, swizzle1(lit
,Z
), specular
, _col1
);
1079 release_temp(p
, ambient
);
1080 release_temp(p
, diffuse
);
1081 release_temp(p
, specular
);
1084 /* Back face lighting:
1087 struct ureg ambient
= get_lightprod(p
, i
, 1, STATE_AMBIENT
);
1088 struct ureg diffuse
= get_lightprod(p
, i
, 1, STATE_DIFFUSE
);
1089 struct ureg specular
= get_lightprod(p
, i
, 1, STATE_SPECULAR
);
1090 struct ureg res0
, res1
;
1091 GLuint mask0
, mask1
;
1093 emit_op1(p
, OPCODE_LIT
, lit
, 0, negate(swizzle(dots
,X
,Y
,W
,Z
)));
1096 emit_op2(p
, OPCODE_MUL
, lit
, 0, lit
, att
);
1098 if (count
== nr_lights
) {
1100 mask0
= WRITEMASK_XYZ
;
1101 mask1
= WRITEMASK_XYZ
;
1102 res0
= register_output( p
, VERT_RESULT_BFC0
);
1103 res1
= register_output( p
, VERT_RESULT_BFC1
);
1107 mask1
= WRITEMASK_XYZ
;
1109 res1
= register_output( p
, VERT_RESULT_BFC0
);
1118 emit_op3(p
, OPCODE_MAD
, _bfc0
, 0, swizzle1(lit
,X
), ambient
, _bfc0
);
1119 emit_op3(p
, OPCODE_MAD
, res0
, mask0
, swizzle1(lit
,Y
), diffuse
, _bfc0
);
1120 emit_op3(p
, OPCODE_MAD
, res1
, mask1
, swizzle1(lit
,Z
), specular
, _bfc1
);
1122 release_temp(p
, ambient
);
1123 release_temp(p
, diffuse
);
1124 release_temp(p
, specular
);
1127 release_temp(p
, half
);
1128 release_temp(p
, VPpli
);
1129 release_temp(p
, att
);
1137 static void build_fog( struct tnl_program
*p
)
1139 struct ureg fog
= register_output(p
, VERT_RESULT_FOGC
);
1142 if (p
->state
->fog_source_is_depth
) {
1143 input
= swizzle1(get_eye_position(p
), Z
);
1146 input
= swizzle1(register_input(p
, VERT_ATTRIB_FOG
), X
);
1149 if (p
->state
->fog_mode
&& p
->state
->tnl_do_vertex_fog
) {
1150 struct ureg params
= register_param2(p
, STATE_INTERNAL
,
1151 STATE_FOG_PARAMS_OPTIMIZED
);
1152 struct ureg tmp
= get_temp(p
);
1153 GLboolean useabs
= (p
->state
->fog_mode
!= FOG_EXP2
);
1156 emit_op1(p
, OPCODE_ABS
, tmp
, 0, input
);
1159 switch (p
->state
->fog_mode
) {
1161 struct ureg id
= get_identity_param(p
);
1162 emit_op3(p
, OPCODE_MAD
, tmp
, 0, useabs
? tmp
: input
,
1163 swizzle1(params
,X
), swizzle1(params
,Y
));
1164 emit_op2(p
, OPCODE_MAX
, tmp
, 0, tmp
, swizzle1(id
,X
)); /* saturate */
1165 emit_op2(p
, OPCODE_MIN
, fog
, WRITEMASK_X
, tmp
, swizzle1(id
,W
));
1169 emit_op2(p
, OPCODE_MUL
, tmp
, 0, useabs
? tmp
: input
,
1170 swizzle1(params
,Z
));
1171 emit_op1(p
, OPCODE_EX2
, fog
, WRITEMASK_X
, negate(tmp
));
1174 emit_op2(p
, OPCODE_MUL
, tmp
, 0, input
, swizzle1(params
,W
));
1175 emit_op2(p
, OPCODE_MUL
, tmp
, 0, tmp
, tmp
);
1176 emit_op1(p
, OPCODE_EX2
, fog
, WRITEMASK_X
, negate(tmp
));
1180 release_temp(p
, tmp
);
1183 /* results = incoming fog coords (compute fog per-fragment later)
1185 * KW: Is it really necessary to do anything in this case?
1186 * BP: Yes, we always need to compute the absolute value, unless
1187 * we want to push that down into the fragment program...
1189 GLboolean useabs
= GL_TRUE
;
1190 emit_op1(p
, useabs
? OPCODE_ABS
: OPCODE_MOV
, fog
, WRITEMASK_X
, input
);
1194 static void build_reflect_texgen( struct tnl_program
*p
,
1198 struct ureg normal
= get_eye_normal(p
);
1199 struct ureg eye_hat
= get_eye_position_normalized(p
);
1200 struct ureg tmp
= get_temp(p
);
1203 emit_op2(p
, OPCODE_DP3
, tmp
, 0, normal
, eye_hat
);
1205 emit_op2(p
, OPCODE_ADD
, tmp
, 0, tmp
, tmp
);
1207 emit_op3(p
, OPCODE_MAD
, dest
, writemask
, negate(tmp
), normal
, eye_hat
);
1209 release_temp(p
, tmp
);
1212 static void build_sphere_texgen( struct tnl_program
*p
,
1216 struct ureg normal
= get_eye_normal(p
);
1217 struct ureg eye_hat
= get_eye_position_normalized(p
);
1218 struct ureg tmp
= get_temp(p
);
1219 struct ureg half
= register_scalar_const(p
, .5);
1220 struct ureg r
= get_temp(p
);
1221 struct ureg inv_m
= get_temp(p
);
1222 struct ureg id
= get_identity_param(p
);
1224 /* Could share the above calculations, but it would be
1225 * a fairly odd state for someone to set (both sphere and
1226 * reflection active for different texture coordinate
1227 * components. Of course - if two texture units enable
1228 * reflect and/or sphere, things start to tilt in favour
1229 * of seperating this out:
1233 emit_op2(p
, OPCODE_DP3
, tmp
, 0, normal
, eye_hat
);
1235 emit_op2(p
, OPCODE_ADD
, tmp
, 0, tmp
, tmp
);
1237 emit_op3(p
, OPCODE_MAD
, r
, 0, negate(tmp
), normal
, eye_hat
);
1239 emit_op2(p
, OPCODE_ADD
, tmp
, 0, r
, swizzle(id
,X
,Y
,W
,Z
));
1240 /* rx^2 + ry^2 + (rz+1)^2 */
1241 emit_op2(p
, OPCODE_DP3
, tmp
, 0, tmp
, tmp
);
1243 emit_op1(p
, OPCODE_RSQ
, tmp
, 0, tmp
);
1245 emit_op2(p
, OPCODE_MUL
, inv_m
, 0, tmp
, half
);
1247 emit_op3(p
, OPCODE_MAD
, dest
, writemask
, r
, inv_m
, half
);
1249 release_temp(p
, tmp
);
1251 release_temp(p
, inv_m
);
1255 static void build_texture_transform( struct tnl_program
*p
)
1259 for (i
= 0; i
< MAX_TEXTURE_UNITS
; i
++) {
1261 if (!(p
->state
->fragprog_inputs_read
& FRAG_BIT_TEX(i
)))
1264 if (p
->state
->unit
[i
].texgen_enabled
||
1265 p
->state
->unit
[i
].texmat_enabled
) {
1267 GLuint texmat_enabled
= p
->state
->unit
[i
].texmat_enabled
;
1268 struct ureg out
= register_output(p
, VERT_RESULT_TEX0
+ i
);
1269 struct ureg out_texgen
= undef
;
1271 if (p
->state
->unit
[i
].texgen_enabled
) {
1272 GLuint copy_mask
= 0;
1273 GLuint sphere_mask
= 0;
1274 GLuint reflect_mask
= 0;
1275 GLuint normal_mask
= 0;
1279 out_texgen
= get_temp(p
);
1283 modes
[0] = p
->state
->unit
[i
].texgen_mode0
;
1284 modes
[1] = p
->state
->unit
[i
].texgen_mode1
;
1285 modes
[2] = p
->state
->unit
[i
].texgen_mode2
;
1286 modes
[3] = p
->state
->unit
[i
].texgen_mode3
;
1288 for (j
= 0; j
< 4; j
++) {
1290 case TXG_OBJ_LINEAR
: {
1291 struct ureg obj
= register_input(p
, VERT_ATTRIB_POS
);
1293 register_param3(p
, STATE_TEXGEN
, i
,
1294 STATE_TEXGEN_OBJECT_S
+ j
);
1296 emit_op2(p
, OPCODE_DP4
, out_texgen
, WRITEMASK_X
<< j
,
1300 case TXG_EYE_LINEAR
: {
1301 struct ureg eye
= get_eye_position(p
);
1303 register_param3(p
, STATE_TEXGEN
, i
,
1304 STATE_TEXGEN_EYE_S
+ j
);
1306 emit_op2(p
, OPCODE_DP4
, out_texgen
, WRITEMASK_X
<< j
,
1310 case TXG_SPHERE_MAP
:
1311 sphere_mask
|= WRITEMASK_X
<< j
;
1313 case TXG_REFLECTION_MAP
:
1314 reflect_mask
|= WRITEMASK_X
<< j
;
1316 case TXG_NORMAL_MAP
:
1317 normal_mask
|= WRITEMASK_X
<< j
;
1320 copy_mask
|= WRITEMASK_X
<< j
;
1327 build_sphere_texgen(p
, out_texgen
, sphere_mask
);
1331 build_reflect_texgen(p
, out_texgen
, reflect_mask
);
1335 struct ureg normal
= get_eye_normal(p
);
1336 emit_op1(p
, OPCODE_MOV
, out_texgen
, normal_mask
, normal
);
1340 struct ureg in
= register_input(p
, VERT_ATTRIB_TEX0
+i
);
1341 emit_op1(p
, OPCODE_MOV
, out_texgen
, copy_mask
, in
);
1345 if (texmat_enabled
) {
1346 struct ureg texmat
[4];
1347 struct ureg in
= (!is_undef(out_texgen
) ?
1349 register_input(p
, VERT_ATTRIB_TEX0
+i
));
1351 register_matrix_param5( p
, STATE_TEXTURE_MATRIX
, i
, 0, 3,
1353 emit_matrix_transform_vec4( p
, out
, texmat
, in
);
1356 register_matrix_param5( p
, STATE_TEXTURE_MATRIX
, i
, 0, 3,
1357 STATE_MATRIX_TRANSPOSE
, texmat
);
1358 emit_transpose_matrix_transform_vec4( p
, out
, texmat
, in
);
1365 emit_passthrough(p
, VERT_ATTRIB_TEX0
+i
, VERT_RESULT_TEX0
+i
);
1371 static void build_pointsize( struct tnl_program
*p
)
1373 struct ureg eye
= get_eye_position(p
);
1374 struct ureg state_size
= register_param1(p
, STATE_POINT_SIZE
);
1375 struct ureg state_attenuation
= register_param1(p
, STATE_POINT_ATTENUATION
);
1376 struct ureg out
= register_output(p
, VERT_RESULT_PSIZ
);
1377 struct ureg ut
= get_temp(p
);
1380 emit_op1(p
, OPCODE_ABS
, ut
, WRITEMASK_Y
, swizzle1(eye
, Z
));
1381 /* p1 + dist * (p2 + dist * p3); */
1382 emit_op3(p
, OPCODE_MAD
, ut
, WRITEMASK_X
, swizzle1(ut
, Y
),
1383 swizzle1(state_attenuation
, Z
), swizzle1(state_attenuation
, Y
));
1384 emit_op3(p
, OPCODE_MAD
, ut
, WRITEMASK_X
, swizzle1(ut
, Y
),
1385 ut
, swizzle1(state_attenuation
, X
));
1387 /* 1 / sqrt(factor) */
1388 emit_op1(p
, OPCODE_RSQ
, ut
, WRITEMASK_X
, ut
);
1391 /* out = pointSize / sqrt(factor) */
1392 emit_op2(p
, OPCODE_MUL
, out
, WRITEMASK_X
, ut
, state_size
);
1394 /* not sure, might make sense to do clamping here,
1395 but it's not done in t_vb_points neither */
1396 emit_op2(p
, OPCODE_MUL
, ut
, WRITEMASK_X
, ut
, state_size
);
1397 emit_op2(p
, OPCODE_MAX
, ut
, WRITEMASK_X
, ut
, swizzle1(state_size
, Y
));
1398 emit_op2(p
, OPCODE_MIN
, out
, WRITEMASK_X
, ut
, swizzle1(state_size
, Z
));
1401 release_temp(p
, ut
);
1405 * Emit constant point size.
1407 static void constant_pointsize( struct tnl_program
*p
)
1409 struct ureg state_size
= register_param1(p
, STATE_POINT_SIZE
);
1410 struct ureg out
= register_output(p
, VERT_RESULT_PSIZ
);
1411 emit_op1(p
, OPCODE_MOV
, out
, WRITEMASK_X
, state_size
);
1414 static void build_tnl_program( struct tnl_program
*p
)
1415 { /* Emit the program, starting with modelviewproject:
1419 /* Lighting calculations:
1421 if (p
->state
->fragprog_inputs_read
& (FRAG_BIT_COL0
|FRAG_BIT_COL1
)) {
1422 if (p
->state
->light_global_enabled
)
1425 if (p
->state
->fragprog_inputs_read
& FRAG_BIT_COL0
)
1426 emit_passthrough(p
, VERT_ATTRIB_COLOR0
, VERT_RESULT_COL0
);
1428 if (p
->state
->fragprog_inputs_read
& FRAG_BIT_COL1
)
1429 emit_passthrough(p
, VERT_ATTRIB_COLOR1
, VERT_RESULT_COL1
);
1433 if ((p
->state
->fragprog_inputs_read
& FRAG_BIT_FOGC
) ||
1434 p
->state
->fog_mode
!= FOG_NONE
)
1437 if (p
->state
->fragprog_inputs_read
& FRAG_BITS_TEX_ANY
)
1438 build_texture_transform(p
);
1440 if (p
->state
->point_attenuated
)
1444 constant_pointsize(p
);
1449 emit_op1(p
, OPCODE_END
, undef
, 0, undef
);
1454 _mesa_printf ("\n");
1460 create_new_program( const struct state_key
*key
,
1461 struct gl_vertex_program
*program
,
1464 struct tnl_program p
;
1466 _mesa_memset(&p
, 0, sizeof(p
));
1468 p
.program
= program
;
1469 p
.eye_position
= undef
;
1470 p
.eye_position_normalized
= undef
;
1471 p
.eye_normal
= undef
;
1475 if (max_temps
>= sizeof(int) * 8)
1476 p
.temp_reserved
= 0;
1478 p
.temp_reserved
= ~((1<<max_temps
)-1);
1480 p
.program
->Base
.Instructions
= _mesa_alloc_instructions(MAX_INSN
);
1481 p
.program
->Base
.String
= NULL
;
1482 p
.program
->Base
.NumInstructions
=
1483 p
.program
->Base
.NumTemporaries
=
1484 p
.program
->Base
.NumParameters
=
1485 p
.program
->Base
.NumAttributes
= p
.program
->Base
.NumAddressRegs
= 0;
1486 p
.program
->Base
.Parameters
= _mesa_new_parameter_list();
1487 p
.program
->Base
.InputsRead
= 0;
1488 p
.program
->Base
.OutputsWritten
= 0;
1490 build_tnl_program( &p
);
1493 static void *search_cache( struct tnl_cache
*cache
,
1498 struct tnl_cache_item
*c
;
1500 for (c
= cache
->items
[hash
% cache
->size
]; c
; c
= c
->next
) {
1501 if (c
->hash
== hash
&& _mesa_memcmp(c
->key
, key
, keysize
) == 0)
1508 static void rehash( struct tnl_cache
*cache
)
1510 struct tnl_cache_item
**items
;
1511 struct tnl_cache_item
*c
, *next
;
1514 size
= cache
->size
* 3;
1515 items
= (struct tnl_cache_item
**) _mesa_malloc(size
* sizeof(*items
));
1516 _mesa_memset(items
, 0, size
* sizeof(*items
));
1518 for (i
= 0; i
< cache
->size
; i
++)
1519 for (c
= cache
->items
[i
]; c
; c
= next
) {
1521 c
->next
= items
[c
->hash
% size
];
1522 items
[c
->hash
% size
] = c
;
1526 cache
->items
= items
;
1530 static void cache_item( struct tnl_cache
*cache
,
1535 struct tnl_cache_item
*c
= (struct tnl_cache_item
*) _mesa_malloc(sizeof(*c
));
1540 if (++cache
->n_items
> cache
->size
* 1.5)
1543 c
->next
= cache
->items
[hash
% cache
->size
];
1544 cache
->items
[hash
% cache
->size
] = c
;
1547 static GLuint
hash_key( struct state_key
*key
)
1549 GLuint
*ikey
= (GLuint
*)key
;
1552 /* I'm sure this can be improved on, but speed is important:
1554 for (i
= 0; i
< sizeof(*key
)/sizeof(GLuint
); i
++)
1562 * Return a vertex program which implements the current fixed-function
1563 * transform/lighting/texgen operations.
1564 * XXX move this into core mesa (main/)
1566 struct gl_vertex_program
*
1567 _mesa_get_fixed_func_vertex_program(GLcontext
*ctx
)
1569 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1570 struct gl_vertex_program
*prog
;
1571 struct state_key
*key
;
1574 /* Grab all the relevent state and put it in a single structure:
1576 key
= make_state_key(ctx
);
1577 hash
= hash_key(key
);
1579 /* Look for an already-prepared program for this state:
1581 prog
= (struct gl_vertex_program
*)
1582 search_cache( tnl
->vp_cache
, hash
, key
, sizeof(*key
) );
1585 /* OK, we'll have to build a new one */
1587 _mesa_printf("Build new TNL program\n");
1589 prog
= (struct gl_vertex_program
*)
1590 ctx
->Driver
.NewProgram(ctx
, GL_VERTEX_PROGRAM_ARB
, 0);
1592 create_new_program( key
, prog
,
1593 ctx
->Const
.VertexProgram
.MaxTemps
);
1596 if (ctx
->Driver
.ProgramStringNotify
)
1597 ctx
->Driver
.ProgramStringNotify( ctx
, GL_VERTEX_PROGRAM_ARB
,
1600 cache_item(tnl
->vp_cache
, hash
, key
, prog
);
1603 /* use cached program */
1612 void _tnl_UpdateFixedFunctionProgram( GLcontext
*ctx
)
1614 const struct gl_vertex_program
*prev
= ctx
->VertexProgram
._Current
;
1616 if (!ctx
->VertexProgram
._Current
||
1617 ctx
->VertexProgram
._Current
== ctx
->VertexProgram
._TnlProgram
) {
1618 ctx
->VertexProgram
._Current
1619 = ctx
->VertexProgram
._TnlProgram
1620 = _mesa_get_fixed_func_vertex_program(ctx
);
1623 /* Tell the driver about the change. Could define a new target for
1626 if (ctx
->VertexProgram
._Current
!= prev
&& ctx
->Driver
.BindProgram
) {
1627 ctx
->Driver
.BindProgram(ctx
, GL_VERTEX_PROGRAM_ARB
,
1628 (struct gl_program
*) ctx
->VertexProgram
._Current
);
1633 void _tnl_ProgramCacheInit( GLcontext
*ctx
)
1635 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1637 tnl
->vp_cache
= (struct tnl_cache
*) MALLOC(sizeof(*tnl
->vp_cache
));
1638 tnl
->vp_cache
->size
= 17;
1639 tnl
->vp_cache
->n_items
= 0;
1640 tnl
->vp_cache
->items
= (struct tnl_cache_item
**)
1641 _mesa_calloc(tnl
->vp_cache
->size
* sizeof(*tnl
->vp_cache
->items
));
1644 void _tnl_ProgramCacheDestroy( GLcontext
*ctx
)
1646 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1647 struct tnl_cache_item
*c
, *next
;
1650 for (i
= 0; i
< tnl
->vp_cache
->size
; i
++)
1651 for (c
= tnl
->vp_cache
->items
[i
]; c
; c
= next
) {
1658 FREE(tnl
->vp_cache
->items
);
1659 FREE(tnl
->vp_cache
);