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 "shader/program.h"
37 #include "shader/prog_instruction.h"
38 #include "shader/prog_parameter.h"
39 #include "shader/prog_print.h"
40 #include "shader/prog_statevars.h"
41 #include "t_context.h" /* NOTE: very light dependency on this */
42 #include "t_vp_build.h"
46 unsigned light_global_enabled:1;
47 unsigned light_local_viewer:1;
48 unsigned light_twoside:1;
49 unsigned light_color_material:1;
50 unsigned light_color_material_mask:12;
51 unsigned light_material_mask:12;
54 unsigned rescale_normals:1;
55 unsigned fog_source_is_depth:1;
56 unsigned tnl_do_vertex_fog:1;
57 unsigned separate_specular:1;
59 unsigned point_attenuated:1;
60 unsigned texture_enabled_global:1;
61 unsigned fragprog_inputs_read:12;
64 unsigned light_enabled:1;
65 unsigned light_eyepos3_is_zero:1;
66 unsigned light_spotcutoff_is_180:1;
67 unsigned light_attenuated:1;
68 unsigned texunit_really_enabled:1;
69 unsigned texmat_enabled:1;
70 unsigned texgen_enabled:4;
71 unsigned texgen_mode0:4;
72 unsigned texgen_mode1:4;
73 unsigned texgen_mode2:4;
74 unsigned texgen_mode3:4;
85 static GLuint translate_fog_mode( GLenum mode )
88 case GL_LINEAR: return FOG_LINEAR;
89 case GL_EXP: return FOG_EXP;
90 case GL_EXP2: return FOG_EXP2;
91 default: return FOG_NONE;
96 #define TXG_OBJ_LINEAR 1
97 #define TXG_EYE_LINEAR 2
98 #define TXG_SPHERE_MAP 3
99 #define TXG_REFLECTION_MAP 4
100 #define TXG_NORMAL_MAP 5
102 static GLuint translate_texgen( GLboolean enabled, GLenum mode )
108 case GL_OBJECT_LINEAR: return TXG_OBJ_LINEAR;
109 case GL_EYE_LINEAR: return TXG_EYE_LINEAR;
110 case GL_SPHERE_MAP: return TXG_SPHERE_MAP;
111 case GL_REFLECTION_MAP_NV: return TXG_REFLECTION_MAP;
112 case GL_NORMAL_MAP_NV: return TXG_NORMAL_MAP;
113 default: return TXG_NONE;
117 static struct state_key *make_state_key( GLcontext *ctx )
119 TNLcontext *tnl = TNL_CONTEXT(ctx);
120 struct vertex_buffer *VB = &tnl->vb;
121 const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
122 struct state_key *key = CALLOC_STRUCT(state_key);
125 /* This now relies on texenvprogram.c being active:
129 key->fragprog_inputs_read = fp->Base.InputsRead;
131 key->separate_specular = (ctx->Light.Model.ColorControl ==
132 GL_SEPARATE_SPECULAR_COLOR);
134 if (ctx->Light.Enabled) {
135 key->light_global_enabled = 1;
137 if (ctx->Light.Model.LocalViewer)
138 key->light_local_viewer = 1;
140 if (ctx->Light.Model.TwoSide)
141 key->light_twoside = 1;
143 if (ctx->Light.ColorMaterialEnabled) {
144 key->light_color_material = 1;
145 key->light_color_material_mask = ctx->Light.ColorMaterialBitmask;
148 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++)
149 if (VB->AttribPtr[i]->stride)
150 key->light_material_mask |= 1<<(i-_TNL_ATTRIB_MAT_FRONT_AMBIENT);
152 for (i = 0; i < MAX_LIGHTS; i++) {
153 struct gl_light *light = &ctx->Light.Light[i];
155 if (light->Enabled) {
156 key->unit[i].light_enabled = 1;
158 if (light->EyePosition[3] == 0.0)
159 key->unit[i].light_eyepos3_is_zero = 1;
161 if (light->SpotCutoff == 180.0)
162 key->unit[i].light_spotcutoff_is_180 = 1;
164 if (light->ConstantAttenuation != 1.0 ||
165 light->LinearAttenuation != 0.0 ||
166 light->QuadraticAttenuation != 0.0)
167 key->unit[i].light_attenuated = 1;
172 if (ctx->Transform.Normalize)
175 if (ctx->Transform.RescaleNormals)
176 key->rescale_normals = 1;
178 key->fog_mode = translate_fog_mode(fp->FogOption);
180 if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT)
181 key->fog_source_is_depth = 1;
183 if (tnl->_DoVertexFog)
184 key->tnl_do_vertex_fog = 1;
186 if (ctx->Point._Attenuated)
187 key->point_attenuated = 1;
189 if (ctx->Texture._TexGenEnabled ||
190 ctx->Texture._TexMatEnabled ||
191 ctx->Texture._EnabledUnits)
192 key->texture_enabled_global = 1;
194 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
195 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
197 if (texUnit->_ReallyEnabled)
198 key->unit[i].texunit_really_enabled = 1;
200 if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
201 key->unit[i].texmat_enabled = 1;
203 if (texUnit->TexGenEnabled) {
204 key->unit[i].texgen_enabled = 1;
206 key->unit[i].texgen_mode0 =
207 translate_texgen( texUnit->TexGenEnabled & (1<<0),
209 key->unit[i].texgen_mode1 =
210 translate_texgen( texUnit->TexGenEnabled & (1<<1),
212 key->unit[i].texgen_mode2 =
213 translate_texgen( texUnit->TexGenEnabled & (1<<2),
215 key->unit[i].texgen_mode3 =
216 translate_texgen( texUnit->TexGenEnabled & (1<<3),
226 /* Very useful debugging tool - produces annotated listing of
227 * generated program with line/function references for each
228 * instruction back into this file:
230 #define DISASSEM (MESA_VERBOSE&VERBOSE_DISASSEM)
232 /* Should be tunable by the driver - do we want to do matrix
233 * multiplications with DP4's or with MUL/MAD's? SSE works better
234 * with the latter, drivers may differ.
240 /* Use uregs to represent registers internally, translate to Mesa's
241 * expected formats on emit.
243 * NOTE: These are passed by value extensively in this file rather
244 * than as usual by pointer reference. If this disturbs you, try
245 * remembering they are just 32bits in size.
247 * GCC is smart enough to deal with these dword-sized structures in
248 * much the same way as if I had defined them as dwords and was using
249 * macros to access and set the fields. This is much nicer and easier
254 GLint idx:8; /* relative addressing may be negative */
262 const struct state_key *state;
263 struct gl_vertex_program *program;
266 GLuint temp_reserved;
268 struct ureg eye_position;
269 struct ureg eye_position_normalized;
270 struct ureg eye_normal;
271 struct ureg identity;
274 GLuint color_materials;
278 static const struct ureg undef = {
296 static struct ureg make_ureg(GLuint file, GLint idx)
302 reg.swz = SWIZZLE_NOOP;
309 static struct ureg negate( struct ureg reg )
316 static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
318 reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
321 GET_SWZ(reg.swz, w));
326 static struct ureg swizzle1( struct ureg reg, int x )
328 return swizzle(reg, x, x, x, x);
331 static struct ureg get_temp( struct tnl_program *p )
333 int bit = _mesa_ffs( ~p->temp_in_use );
335 _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
339 if ((GLuint) bit > p->program->Base.NumTemporaries)
340 p->program->Base.NumTemporaries = bit;
342 p->temp_in_use |= 1<<(bit-1);
343 return make_ureg(PROGRAM_TEMPORARY, bit-1);
346 static struct ureg reserve_temp( struct tnl_program *p )
348 struct ureg temp = get_temp( p );
349 p->temp_reserved |= 1<<temp.idx;
353 static void release_temp( struct tnl_program *p, struct ureg reg )
355 if (reg.file == PROGRAM_TEMPORARY) {
356 p->temp_in_use &= ~(1<<reg.idx);
357 p->temp_in_use |= p->temp_reserved; /* can't release reserved temps */
361 static void release_temps( struct tnl_program *p )
363 p->temp_in_use = p->temp_reserved;
368 static struct ureg register_input( struct tnl_program *p, GLuint input )
370 p->program->Base.InputsRead |= (1<<input);
371 return make_ureg(PROGRAM_INPUT, input);
374 static struct ureg register_output( struct tnl_program *p, GLuint output )
376 p->program->Base.OutputsWritten |= (1<<output);
377 return make_ureg(PROGRAM_OUTPUT, output);
380 static struct ureg register_const4f( struct tnl_program *p,
393 idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
395 ASSERT(swizzle == SWIZZLE_NOOP);
396 return make_ureg(PROGRAM_STATE_VAR, idx);
399 #define register_const1f(p, s0) register_const4f(p, s0, 0, 0, 1)
400 #define register_scalar_const(p, s0) register_const4f(p, s0, s0, s0, s0)
401 #define register_const2f(p, s0, s1) register_const4f(p, s0, s1, 0, 1)
402 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
404 static GLboolean is_undef( struct ureg reg )
406 return reg.file == PROGRAM_UNDEFINED;
409 static struct ureg get_identity_param( struct tnl_program *p )
411 if (is_undef(p->identity))
412 p->identity = register_const4f(p, 0,0,0,1);
417 static struct ureg register_param5(struct tnl_program *p,
424 gl_state_index tokens[STATE_LENGTH];
431 idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
432 return make_ureg(PROGRAM_STATE_VAR, idx);
436 #define register_param1(p,s0) register_param5(p,s0,0,0,0,0)
437 #define register_param2(p,s0,s1) register_param5(p,s0,s1,0,0,0)
438 #define register_param3(p,s0,s1,s2) register_param5(p,s0,s1,s2,0,0)
439 #define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
442 static void register_matrix_param5( struct tnl_program *p,
443 GLint s0, /* modelview, projection, etc */
444 GLint s1, /* texture matrix number */
445 GLint s2, /* first row */
446 GLint s3, /* last row */
447 GLint s4, /* inverse, transpose, etc */
448 struct ureg *matrix )
452 /* This is a bit sad as the support is there to pull the whole
453 * matrix out in one go:
455 for (i = 0; i <= s3 - s2; i++)
456 matrix[i] = register_param5( p, s0, s1, i, i, s4 );
460 static void emit_arg( struct prog_src_register *src,
463 src->File = reg.file;
464 src->Index = reg.idx;
465 src->Swizzle = reg.swz;
466 src->NegateBase = reg.negate ? NEGATE_XYZW : 0;
472 static void emit_dst( struct prog_dst_register *dst,
473 struct ureg reg, GLuint mask )
475 dst->File = reg.file;
476 dst->Index = reg.idx;
477 /* allow zero as a shorthand for xyzw */
478 dst->WriteMask = mask ? mask : WRITEMASK_XYZW;
479 dst->CondMask = COND_TR;
480 dst->CondSwizzle = 0;
485 static void debug_insn( struct prog_instruction *inst, const char *fn,
489 static const char *last_fn;
493 _mesa_printf("%s:\n", fn);
496 _mesa_printf("%d:\t", line);
497 _mesa_print_instruction(inst);
502 static void emit_op3fn(struct tnl_program *p,
512 GLuint nr = p->program->Base.NumInstructions++;
513 struct prog_instruction *inst = &p->program->Base.Instructions[nr];
515 if (p->program->Base.NumInstructions > MAX_INSN) {
516 _mesa_problem(0, "Out of instructions in emit_op3fn\n");
520 inst->Opcode = (enum prog_opcode) op;
524 emit_arg( &inst->SrcReg[0], src0 );
525 emit_arg( &inst->SrcReg[1], src1 );
526 emit_arg( &inst->SrcReg[2], src2 );
528 emit_dst( &inst->DstReg, dest, mask );
530 debug_insn(inst, fn, line);
534 #define emit_op3(p, op, dst, mask, src0, src1, src2) \
535 emit_op3fn(p, op, dst, mask, src0, src1, src2, __FUNCTION__, __LINE__)
537 #define emit_op2(p, op, dst, mask, src0, src1) \
538 emit_op3fn(p, op, dst, mask, src0, src1, undef, __FUNCTION__, __LINE__)
540 #define emit_op1(p, op, dst, mask, src0) \
541 emit_op3fn(p, op, dst, mask, src0, undef, undef, __FUNCTION__, __LINE__)
544 static struct ureg make_temp( struct tnl_program *p, struct ureg reg )
546 if (reg.file == PROGRAM_TEMPORARY &&
547 !(p->temp_reserved & (1<<reg.idx)))
550 struct ureg temp = get_temp(p);
551 emit_op1(p, OPCODE_MOV, temp, 0, reg);
557 /* Currently no tracking performed of input/output/register size or
558 * active elements. Could be used to reduce these operations, as
559 * could the matrix type.
561 static void emit_matrix_transform_vec4( struct tnl_program *p,
563 const struct ureg *mat,
566 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_X, src, mat[0]);
567 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_Y, src, mat[1]);
568 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_Z, src, mat[2]);
569 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_W, src, mat[3]);
572 /* This version is much easier to implement if writemasks are not
573 * supported natively on the target or (like SSE), the target doesn't
574 * have a clean/obvious dotproduct implementation.
576 static void emit_transpose_matrix_transform_vec4( struct tnl_program *p,
578 const struct ureg *mat,
583 if (dest.file != PROGRAM_TEMPORARY)
588 emit_op2(p, OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
589 emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
590 emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
591 emit_op3(p, OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
593 if (dest.file != PROGRAM_TEMPORARY)
594 release_temp(p, tmp);
597 static void emit_matrix_transform_vec3( struct tnl_program *p,
599 const struct ureg *mat,
602 emit_op2(p, OPCODE_DP3, dest, WRITEMASK_X, src, mat[0]);
603 emit_op2(p, OPCODE_DP3, dest, WRITEMASK_Y, src, mat[1]);
604 emit_op2(p, OPCODE_DP3, dest, WRITEMASK_Z, src, mat[2]);
608 static void emit_normalize_vec3( struct tnl_program *p,
612 struct ureg tmp = get_temp(p);
613 emit_op2(p, OPCODE_DP3, tmp, 0, src, src);
614 emit_op1(p, OPCODE_RSQ, tmp, 0, tmp);
615 emit_op2(p, OPCODE_MUL, dest, 0, src, tmp);
616 release_temp(p, tmp);
619 static void emit_passthrough( struct tnl_program *p,
623 struct ureg out = register_output(p, output);
624 emit_op1(p, OPCODE_MOV, out, 0, register_input(p, input));
627 static struct ureg get_eye_position( struct tnl_program *p )
629 if (is_undef(p->eye_position)) {
630 struct ureg pos = register_input( p, VERT_ATTRIB_POS );
631 struct ureg modelview[4];
633 p->eye_position = reserve_temp(p);
636 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
639 emit_matrix_transform_vec4(p, p->eye_position, modelview, pos);
642 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
643 STATE_MATRIX_TRANSPOSE, modelview );
645 emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos);
649 return p->eye_position;
653 static struct ureg get_eye_position_normalized( struct tnl_program *p )
655 if (is_undef(p->eye_position_normalized)) {
656 struct ureg eye = get_eye_position(p);
657 p->eye_position_normalized = reserve_temp(p);
658 emit_normalize_vec3(p, p->eye_position_normalized, eye);
661 return p->eye_position_normalized;
665 static struct ureg get_eye_normal( struct tnl_program *p )
667 if (is_undef(p->eye_normal)) {
668 struct ureg normal = register_input(p, VERT_ATTRIB_NORMAL );
669 struct ureg mvinv[3];
671 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 2,
672 STATE_MATRIX_INVTRANS, mvinv );
674 p->eye_normal = reserve_temp(p);
676 /* Transform to eye space:
678 emit_matrix_transform_vec3( p, p->eye_normal, mvinv, normal );
680 /* Normalize/Rescale:
682 if (p->state->normalize) {
683 emit_normalize_vec3( p, p->eye_normal, p->eye_normal );
685 else if (p->state->rescale_normals) {
686 struct ureg rescale = register_param2(p, STATE_INTERNAL,
689 emit_op2( p, OPCODE_MUL, p->eye_normal, 0, normal,
690 swizzle1(rescale, X));
694 return p->eye_normal;
699 static void build_hpos( struct tnl_program *p )
701 struct ureg pos = register_input( p, VERT_ATTRIB_POS );
702 struct ureg hpos = register_output( p, VERT_RESULT_HPOS );
706 register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
708 emit_matrix_transform_vec4( p, hpos, mvp, pos );
711 register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
712 STATE_MATRIX_TRANSPOSE, mvp );
713 emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos );
718 static GLuint material_attrib( GLuint side, GLuint property )
720 return ((property - STATE_AMBIENT) * 2 +
724 /* Get a bitmask of which material values vary on a per-vertex basis.
726 static void set_material_flags( struct tnl_program *p )
728 p->color_materials = 0;
731 if (p->state->light_color_material) {
733 p->color_materials = p->state->light_color_material_mask;
736 p->materials |= p->state->light_material_mask;
740 static struct ureg get_material( struct tnl_program *p, GLuint side,
743 GLuint attrib = material_attrib(side, property);
745 if (p->color_materials & (1<<attrib))
746 return register_input(p, VERT_ATTRIB_COLOR0);
747 else if (p->materials & (1<<attrib))
748 return register_input( p, attrib + _TNL_ATTRIB_MAT_FRONT_AMBIENT );
750 return register_param3( p, STATE_MATERIAL, side, property );
753 #define SCENE_COLOR_BITS(side) (( MAT_BIT_FRONT_EMISSION | \
754 MAT_BIT_FRONT_AMBIENT | \
755 MAT_BIT_FRONT_DIFFUSE) << (side))
757 /* Either return a precalculated constant value or emit code to
758 * calculate these values dynamically in the case where material calls
759 * are present between begin/end pairs.
761 * Probably want to shift this to the program compilation phase - if
762 * we always emitted the calculation here, a smart compiler could
763 * detect that it was constant (given a certain set of inputs), and
764 * lift it out of the main loop. That way the programs created here
765 * would be independent of the vertex_buffer details.
767 static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
769 if (p->materials & SCENE_COLOR_BITS(side)) {
770 struct ureg lm_ambient = register_param1(p, STATE_LIGHTMODEL_AMBIENT);
771 struct ureg material_emission = get_material(p, side, STATE_EMISSION);
772 struct ureg material_ambient = get_material(p, side, STATE_AMBIENT);
773 struct ureg material_diffuse = get_material(p, side, STATE_DIFFUSE);
774 struct ureg tmp = make_temp(p, material_diffuse);
775 emit_op3(p, OPCODE_MAD, tmp, WRITEMASK_XYZ, lm_ambient,
776 material_ambient, material_emission);
780 return register_param2( p, STATE_LIGHTMODEL_SCENECOLOR, side );
784 static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
785 GLuint side, GLuint property )
787 GLuint attrib = material_attrib(side, property);
788 if (p->materials & (1<<attrib)) {
789 struct ureg light_value =
790 register_param3(p, STATE_LIGHT, light, property);
791 struct ureg material_value = get_material(p, side, property);
792 struct ureg tmp = get_temp(p);
793 emit_op2(p, OPCODE_MUL, tmp, 0, light_value, material_value);
797 return register_param4(p, STATE_LIGHTPROD, light, side, property);
800 static struct ureg calculate_light_attenuation( struct tnl_program *p,
805 struct ureg attenuation = register_param3(p, STATE_LIGHT, i,
807 struct ureg att = get_temp(p);
809 /* Calculate spot attenuation:
811 if (!p->state->unit[i].light_spotcutoff_is_180) {
812 struct ureg spot_dir_norm = register_param3(p, STATE_INTERNAL,
813 STATE_SPOT_DIR_NORMALIZED, i);
814 struct ureg spot = get_temp(p);
815 struct ureg slt = get_temp(p);
817 emit_op2(p, OPCODE_DP3, spot, 0, negate(VPpli), spot_dir_norm);
818 emit_op2(p, OPCODE_SLT, slt, 0, swizzle1(spot_dir_norm,W), spot);
819 emit_op2(p, OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
820 emit_op2(p, OPCODE_MUL, att, 0, slt, spot);
822 release_temp(p, spot);
823 release_temp(p, slt);
826 /* Calculate distance attenuation:
828 if (p->state->unit[i].light_attenuated) {
831 emit_op1(p, OPCODE_RCP, dist, WRITEMASK_YZ, dist);
833 emit_op2(p, OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
835 emit_op2(p, OPCODE_DP3, dist, 0, attenuation, dist);
837 if (!p->state->unit[i].light_spotcutoff_is_180) {
839 emit_op1(p, OPCODE_RCP, dist, 0, dist);
840 /* spot-atten * dist-atten */
841 emit_op2(p, OPCODE_MUL, att, 0, dist, att);
844 emit_op1(p, OPCODE_RCP, att, 0, dist);
855 /* Need to add some addtional parameters to allow lighting in object
856 * space - STATE_SPOT_DIRECTION and STATE_HALF_VECTOR implicitly assume eye
859 static void build_lighting( struct tnl_program *p )
861 const GLboolean twoside = p->state->light_twoside;
862 const GLboolean separate = p->state->separate_specular;
863 GLuint nr_lights = 0, count = 0;
864 struct ureg normal = get_eye_normal(p);
865 struct ureg lit = get_temp(p);
866 struct ureg dots = get_temp(p);
867 struct ureg _col0 = undef, _col1 = undef;
868 struct ureg _bfc0 = undef, _bfc1 = undef;
871 for (i = 0; i < MAX_LIGHTS; i++)
872 if (p->state->unit[i].light_enabled)
875 set_material_flags(p);
878 struct ureg shininess = get_material(p, 0, STATE_SHININESS);
879 emit_op1(p, OPCODE_MOV, dots, WRITEMASK_W, swizzle1(shininess,X));
880 release_temp(p, shininess);
882 _col0 = make_temp(p, get_scenecolor(p, 0));
884 _col1 = make_temp(p, get_identity_param(p));
891 struct ureg shininess = get_material(p, 1, STATE_SHININESS);
892 emit_op1(p, OPCODE_MOV, dots, WRITEMASK_Z,
893 negate(swizzle1(shininess,X)));
894 release_temp(p, shininess);
896 _bfc0 = make_temp(p, get_scenecolor(p, 1));
898 _bfc1 = make_temp(p, get_identity_param(p));
904 /* If no lights, still need to emit the scenecolor.
907 struct ureg res0 = register_output( p, VERT_RESULT_COL0 );
908 emit_op1(p, OPCODE_MOV, res0, 0, _col0);
912 struct ureg res1 = register_output( p, VERT_RESULT_COL1 );
913 emit_op1(p, OPCODE_MOV, res1, 0, _col1);
917 struct ureg res0 = register_output( p, VERT_RESULT_BFC0 );
918 emit_op1(p, OPCODE_MOV, res0, 0, _bfc0);
921 if (twoside && separate) {
922 struct ureg res1 = register_output( p, VERT_RESULT_BFC1 );
923 emit_op1(p, OPCODE_MOV, res1, 0, _bfc1);
926 if (nr_lights == 0) {
932 for (i = 0; i < MAX_LIGHTS; i++) {
933 if (p->state->unit[i].light_enabled) {
934 struct ureg half = undef;
935 struct ureg att = undef, VPpli = undef;
939 if (p->state->unit[i].light_eyepos3_is_zero) {
940 /* Can used precomputed constants in this case.
941 * Attenuation never applies to infinite lights.
943 VPpli = register_param3(p, STATE_LIGHT, i,
944 STATE_POSITION_NORMALIZED);
945 if (p->state->light_local_viewer) {
946 struct ureg eye_hat = get_eye_position_normalized(p);
948 emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat);
949 emit_normalize_vec3(p, half, half);
951 half = register_param3(p, STATE_LIGHT, i, STATE_HALF_VECTOR);
955 struct ureg Ppli = register_param3(p, STATE_LIGHT, i,
957 struct ureg V = get_eye_position(p);
958 struct ureg dist = get_temp(p);
963 /* Calulate VPpli vector
965 emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V);
967 /* Normalize VPpli. The dist value also used in
970 emit_op2(p, OPCODE_DP3, dist, 0, VPpli, VPpli);
971 emit_op1(p, OPCODE_RSQ, dist, 0, dist);
972 emit_op2(p, OPCODE_MUL, VPpli, 0, VPpli, dist);
975 /* Calculate attenuation:
977 if (!p->state->unit[i].light_spotcutoff_is_180 ||
978 p->state->unit[i].light_attenuated) {
979 att = calculate_light_attenuation(p, i, VPpli, dist);
983 /* Calculate viewer direction, or use infinite viewer:
985 if (p->state->light_local_viewer) {
986 struct ureg eye_hat = get_eye_position_normalized(p);
987 emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat);
990 struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z);
991 emit_op2(p, OPCODE_ADD, half, 0, VPpli, z_dir);
994 emit_normalize_vec3(p, half, half);
996 release_temp(p, dist);
999 /* Calculate dot products:
1001 emit_op2(p, OPCODE_DP3, dots, WRITEMASK_X, normal, VPpli);
1002 emit_op2(p, OPCODE_DP3, dots, WRITEMASK_Y, normal, half);
1005 /* Front face lighting:
1008 struct ureg ambient = get_lightprod(p, i, 0, STATE_AMBIENT);
1009 struct ureg diffuse = get_lightprod(p, i, 0, STATE_DIFFUSE);
1010 struct ureg specular = get_lightprod(p, i, 0, STATE_SPECULAR);
1011 struct ureg res0, res1;
1012 GLuint mask0, mask1;
1014 emit_op1(p, OPCODE_LIT, lit, 0, dots);
1017 emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
1020 if (count == nr_lights) {
1022 mask0 = WRITEMASK_XYZ;
1023 mask1 = WRITEMASK_XYZ;
1024 res0 = register_output( p, VERT_RESULT_COL0 );
1025 res1 = register_output( p, VERT_RESULT_COL1 );
1029 mask1 = WRITEMASK_XYZ;
1031 res1 = register_output( p, VERT_RESULT_COL0 );
1040 emit_op3(p, OPCODE_MAD, _col0, 0, swizzle1(lit,X), ambient, _col0);
1041 emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _col0);
1042 emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _col1);
1044 release_temp(p, ambient);
1045 release_temp(p, diffuse);
1046 release_temp(p, specular);
1049 /* Back face lighting:
1052 struct ureg ambient = get_lightprod(p, i, 1, STATE_AMBIENT);
1053 struct ureg diffuse = get_lightprod(p, i, 1, STATE_DIFFUSE);
1054 struct ureg specular = get_lightprod(p, i, 1, STATE_SPECULAR);
1055 struct ureg res0, res1;
1056 GLuint mask0, mask1;
1058 emit_op1(p, OPCODE_LIT, lit, 0, negate(swizzle(dots,X,Y,W,Z)));
1061 emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
1063 if (count == nr_lights) {
1065 mask0 = WRITEMASK_XYZ;
1066 mask1 = WRITEMASK_XYZ;
1067 res0 = register_output( p, VERT_RESULT_BFC0 );
1068 res1 = register_output( p, VERT_RESULT_BFC1 );
1072 mask1 = WRITEMASK_XYZ;
1074 res1 = register_output( p, VERT_RESULT_BFC0 );
1083 emit_op3(p, OPCODE_MAD, _bfc0, 0, swizzle1(lit,X), ambient, _bfc0);
1084 emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _bfc0);
1085 emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _bfc1);
1087 release_temp(p, ambient);
1088 release_temp(p, diffuse);
1089 release_temp(p, specular);
1092 release_temp(p, half);
1093 release_temp(p, VPpli);
1094 release_temp(p, att);
1102 static void build_fog( struct tnl_program *p )
1104 struct ureg fog = register_output(p, VERT_RESULT_FOGC);
1106 GLuint useabs = p->state->fog_source_is_depth && p->state->fog_mode &&
1107 (p->state->fog_mode != FOG_EXP2);
1109 if (p->state->fog_source_is_depth) {
1110 input = swizzle1(get_eye_position(p), Z);
1113 input = swizzle1(register_input(p, VERT_ATTRIB_FOG), X);
1116 if (p->state->fog_mode && p->state->tnl_do_vertex_fog) {
1117 struct ureg params = register_param2(p, STATE_INTERNAL,
1118 STATE_FOG_PARAMS_OPTIMIZED);
1119 struct ureg tmp = get_temp(p);
1122 emit_op1(p, OPCODE_ABS, tmp, 0, input);
1125 switch (p->state->fog_mode) {
1127 struct ureg id = get_identity_param(p);
1128 emit_op3(p, OPCODE_MAD, tmp, 0, useabs ? tmp : input,
1129 swizzle1(params,X), swizzle1(params,Y));
1130 emit_op2(p, OPCODE_MAX, tmp, 0, tmp, swizzle1(id,X)); /* saturate */
1131 emit_op2(p, OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W));
1135 emit_op2(p, OPCODE_MUL, tmp, 0, useabs ? tmp : input,
1136 swizzle1(params,Z));
1137 emit_op1(p, OPCODE_EX2, fog, WRITEMASK_X, negate(tmp));
1140 emit_op2(p, OPCODE_MUL, tmp, 0, input, swizzle1(params,W));
1141 emit_op2(p, OPCODE_MUL, tmp, 0, tmp, tmp);
1142 emit_op1(p, OPCODE_EX2, fog, WRITEMASK_X, negate(tmp));
1146 release_temp(p, tmp);
1149 /* results = incoming fog coords (compute fog per-fragment later)
1151 * KW: Is it really necessary to do anything in this case?
1153 emit_op1(p, useabs ? OPCODE_ABS : OPCODE_MOV, fog, WRITEMASK_X, input);
1157 static void build_reflect_texgen( struct tnl_program *p,
1161 struct ureg normal = get_eye_normal(p);
1162 struct ureg eye_hat = get_eye_position_normalized(p);
1163 struct ureg tmp = get_temp(p);
1166 emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
1168 emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
1170 emit_op3(p, OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
1172 release_temp(p, tmp);
1175 static void build_sphere_texgen( struct tnl_program *p,
1179 struct ureg normal = get_eye_normal(p);
1180 struct ureg eye_hat = get_eye_position_normalized(p);
1181 struct ureg tmp = get_temp(p);
1182 struct ureg half = register_scalar_const(p, .5);
1183 struct ureg r = get_temp(p);
1184 struct ureg inv_m = get_temp(p);
1185 struct ureg id = get_identity_param(p);
1187 /* Could share the above calculations, but it would be
1188 * a fairly odd state for someone to set (both sphere and
1189 * reflection active for different texture coordinate
1190 * components. Of course - if two texture units enable
1191 * reflect and/or sphere, things start to tilt in favour
1192 * of seperating this out:
1196 emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
1198 emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
1200 emit_op3(p, OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
1202 emit_op2(p, OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
1203 /* rx^2 + ry^2 + (rz+1)^2 */
1204 emit_op2(p, OPCODE_DP3, tmp, 0, tmp, tmp);
1206 emit_op1(p, OPCODE_RSQ, tmp, 0, tmp);
1208 emit_op2(p, OPCODE_MUL, inv_m, 0, tmp, half);
1210 emit_op3(p, OPCODE_MAD, dest, writemask, r, inv_m, half);
1212 release_temp(p, tmp);
1214 release_temp(p, inv_m);
1218 static void build_texture_transform( struct tnl_program *p )
1222 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1224 if (!(p->state->fragprog_inputs_read & FRAG_BIT_TEX(i)))
1227 if (p->state->unit[i].texgen_enabled ||
1228 p->state->unit[i].texmat_enabled) {
1230 GLuint texmat_enabled = p->state->unit[i].texmat_enabled;
1231 struct ureg out = register_output(p, VERT_RESULT_TEX0 + i);
1232 struct ureg out_texgen = undef;
1234 if (p->state->unit[i].texgen_enabled) {
1235 GLuint copy_mask = 0;
1236 GLuint sphere_mask = 0;
1237 GLuint reflect_mask = 0;
1238 GLuint normal_mask = 0;
1242 out_texgen = get_temp(p);
1246 modes[0] = p->state->unit[i].texgen_mode0;
1247 modes[1] = p->state->unit[i].texgen_mode1;
1248 modes[2] = p->state->unit[i].texgen_mode2;
1249 modes[3] = p->state->unit[i].texgen_mode3;
1251 for (j = 0; j < 4; j++) {
1253 case TXG_OBJ_LINEAR: {
1254 struct ureg obj = register_input(p, VERT_ATTRIB_POS);
1256 register_param3(p, STATE_TEXGEN, i,
1257 STATE_TEXGEN_OBJECT_S + j);
1259 emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
1263 case TXG_EYE_LINEAR: {
1264 struct ureg eye = get_eye_position(p);
1266 register_param3(p, STATE_TEXGEN, i,
1267 STATE_TEXGEN_EYE_S + j);
1269 emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
1273 case TXG_SPHERE_MAP:
1274 sphere_mask |= WRITEMASK_X << j;
1276 case TXG_REFLECTION_MAP:
1277 reflect_mask |= WRITEMASK_X << j;
1279 case TXG_NORMAL_MAP:
1280 normal_mask |= WRITEMASK_X << j;
1283 copy_mask |= WRITEMASK_X << j;
1290 build_sphere_texgen(p, out_texgen, sphere_mask);
1294 build_reflect_texgen(p, out_texgen, reflect_mask);
1298 struct ureg normal = get_eye_normal(p);
1299 emit_op1(p, OPCODE_MOV, out_texgen, normal_mask, normal );
1303 struct ureg in = register_input(p, VERT_ATTRIB_TEX0+i);
1304 emit_op1(p, OPCODE_MOV, out_texgen, copy_mask, in );
1308 if (texmat_enabled) {
1309 struct ureg texmat[4];
1310 struct ureg in = (!is_undef(out_texgen) ?
1312 register_input(p, VERT_ATTRIB_TEX0+i));
1314 register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3,
1316 emit_matrix_transform_vec4( p, out, texmat, in );
1319 register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3,
1320 STATE_MATRIX_TRANSPOSE, texmat );
1321 emit_transpose_matrix_transform_vec4( p, out, texmat, in );
1328 emit_passthrough(p, VERT_ATTRIB_TEX0+i, VERT_RESULT_TEX0+i);
1334 static void build_pointsize( struct tnl_program *p )
1336 struct ureg eye = get_eye_position(p);
1337 struct ureg state_size = register_param1(p, STATE_POINT_SIZE);
1338 struct ureg state_attenuation = register_param1(p, STATE_POINT_ATTENUATION);
1339 struct ureg out = register_output(p, VERT_RESULT_PSIZ);
1340 struct ureg ut = get_temp(p);
1343 emit_op1(p, OPCODE_ABS, ut, WRITEMASK_Y, swizzle1(eye, Z));
1344 /* p1 + dist * (p2 + dist * p3); */
1345 emit_op3(p, OPCODE_MAD, ut, WRITEMASK_X, swizzle1(ut, Y),
1346 swizzle1(state_attenuation, Z), swizzle1(state_attenuation, Y));
1347 emit_op3(p, OPCODE_MAD, ut, WRITEMASK_X, swizzle1(ut, Y),
1348 ut, swizzle1(state_attenuation, X));
1350 /* 1 / sqrt(factor) */
1351 emit_op1(p, OPCODE_RSQ, ut, WRITEMASK_X, ut );
1354 /* out = pointSize / sqrt(factor) */
1355 emit_op2(p, OPCODE_MUL, out, WRITEMASK_X, ut, state_size);
1357 /* not sure, might make sense to do clamping here,
1358 but it's not done in t_vb_points neither */
1359 emit_op2(p, OPCODE_MUL, ut, WRITEMASK_X, ut, state_size);
1360 emit_op2(p, OPCODE_MAX, ut, WRITEMASK_X, ut, swizzle1(state_size, Y));
1361 emit_op2(p, OPCODE_MIN, out, WRITEMASK_X, ut, swizzle1(state_size, Z));
1364 release_temp(p, ut);
1367 static void build_tnl_program( struct tnl_program *p )
1368 { /* Emit the program, starting with modelviewproject:
1372 /* Lighting calculations:
1374 if (p->state->fragprog_inputs_read & (FRAG_BIT_COL0|FRAG_BIT_COL1)) {
1375 if (p->state->light_global_enabled)
1378 if (p->state->fragprog_inputs_read & FRAG_BIT_COL0)
1379 emit_passthrough(p, VERT_ATTRIB_COLOR0, VERT_RESULT_COL0);
1381 if (p->state->fragprog_inputs_read & FRAG_BIT_COL1)
1382 emit_passthrough(p, VERT_ATTRIB_COLOR1, VERT_RESULT_COL1);
1386 if ((p->state->fragprog_inputs_read & FRAG_BIT_FOGC) ||
1387 p->state->fog_mode != FOG_NONE)
1390 if (p->state->fragprog_inputs_read & FRAG_BITS_TEX_ANY)
1391 build_texture_transform(p);
1393 if (p->state->point_attenuated)
1398 emit_op1(p, OPCODE_END, undef, 0, undef);
1403 _mesa_printf ("\n");
1409 create_new_program( const struct state_key *key,
1410 struct gl_vertex_program *program,
1413 struct tnl_program p;
1415 _mesa_memset(&p, 0, sizeof(p));
1417 p.program = program;
1418 p.eye_position = undef;
1419 p.eye_position_normalized = undef;
1420 p.eye_normal = undef;
1424 if (max_temps >= sizeof(int) * 8)
1425 p.temp_reserved = 0;
1427 p.temp_reserved = ~((1<<max_temps)-1);
1429 p.program->Base.Instructions = _mesa_alloc_instructions(MAX_INSN);
1430 p.program->Base.String = NULL;
1431 p.program->Base.NumInstructions =
1432 p.program->Base.NumTemporaries =
1433 p.program->Base.NumParameters =
1434 p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0;
1435 p.program->Base.Parameters = _mesa_new_parameter_list();
1436 p.program->Base.InputsRead = 0;
1437 p.program->Base.OutputsWritten = 0;
1439 build_tnl_program( &p );
1442 static void *search_cache( struct tnl_cache *cache,
1447 struct tnl_cache_item *c;
1449 for (c = cache->items[hash % cache->size]; c; c = c->next) {
1450 if (c->hash == hash && _mesa_memcmp(c->key, key, keysize) == 0)
1457 static void rehash( struct tnl_cache *cache )
1459 struct tnl_cache_item **items;
1460 struct tnl_cache_item *c, *next;
1463 size = cache->size * 3;
1464 items = (struct tnl_cache_item**) _mesa_malloc(size * sizeof(*items));
1465 _mesa_memset(items, 0, size * sizeof(*items));
1467 for (i = 0; i < cache->size; i++)
1468 for (c = cache->items[i]; c; c = next) {
1470 c->next = items[c->hash % size];
1471 items[c->hash % size] = c;
1475 cache->items = items;
1479 static void cache_item( struct tnl_cache *cache,
1484 struct tnl_cache_item *c = (struct tnl_cache_item*) _mesa_malloc(sizeof(*c));
1489 if (++cache->n_items > cache->size * 1.5)
1492 c->next = cache->items[hash % cache->size];
1493 cache->items[hash % cache->size] = c;
1496 static GLuint hash_key( struct state_key *key )
1498 GLuint *ikey = (GLuint *)key;
1501 /* I'm sure this can be improved on, but speed is important:
1503 for (i = 0; i < sizeof(*key)/sizeof(GLuint); i++)
1509 void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
1511 TNLcontext *tnl = TNL_CONTEXT(ctx);
1512 struct state_key *key;
1514 const struct gl_vertex_program *prev = ctx->VertexProgram._Current;
1516 if (!ctx->VertexProgram._Current ||
1517 ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram) {
1518 /* Grab all the relevent state and put it in a single structure:
1520 key = make_state_key(ctx);
1521 hash = hash_key(key);
1523 /* Look for an already-prepared program for this state:
1525 ctx->VertexProgram._TnlProgram = (struct gl_vertex_program *)
1526 search_cache( tnl->vp_cache, hash, key, sizeof(*key) );
1528 /* OK, we'll have to build a new one:
1530 if (!ctx->VertexProgram._TnlProgram) {
1532 _mesa_printf("Build new TNL program\n");
1534 ctx->VertexProgram._TnlProgram = (struct gl_vertex_program *)
1535 ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
1537 create_new_program( key, ctx->VertexProgram._TnlProgram,
1538 ctx->Const.VertexProgram.MaxTemps );
1540 if (ctx->Driver.ProgramStringNotify)
1541 ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB,
1542 &ctx->VertexProgram._TnlProgram->Base );
1544 cache_item(tnl->vp_cache, hash, key, ctx->VertexProgram._TnlProgram );
1549 _mesa_printf("Found existing TNL program for key %x\n", hash);
1551 ctx->VertexProgram._Current = ctx->VertexProgram._TnlProgram;
1554 /* Tell the driver about the change. Could define a new target for
1557 if (ctx->VertexProgram._Current != prev && ctx->Driver.BindProgram) {
1558 ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
1559 (struct gl_program *) ctx->VertexProgram._Current);
1563 void _tnl_ProgramCacheInit( GLcontext *ctx )
1565 TNLcontext *tnl = TNL_CONTEXT(ctx);
1567 tnl->vp_cache = (struct tnl_cache *) MALLOC(sizeof(*tnl->vp_cache));
1568 tnl->vp_cache->size = 17;
1569 tnl->vp_cache->n_items = 0;
1570 tnl->vp_cache->items = (struct tnl_cache_item**)
1571 _mesa_calloc(tnl->vp_cache->size * sizeof(*tnl->vp_cache->items));
1574 void _tnl_ProgramCacheDestroy( GLcontext *ctx )
1576 TNLcontext *tnl = TNL_CONTEXT(ctx);
1577 struct tnl_cache_item *c, *next;
1580 for (i = 0; i < tnl->vp_cache->size; i++)
1581 for (c = tnl->vp_cache->items[i]; c; c = next) {
1588 FREE(tnl->vp_cache->items);
1589 FREE(tnl->vp_cache);