1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /**
29 * \file ffvertex_prog.c
30 *
31 * Create a vertex program to execute the current fixed function T&L pipeline.
32 * \author Keith Whitwell
33 */
34
35
36 #include "main/glheader.h"
37 #include "main/mtypes.h"
38 #include "main/macros.h"
39 #include "main/mfeatures.h"
40 #include "main/enums.h"
41 #include "main/ffvertex_prog.h"
42 #include "program/program.h"
43 #include "program/prog_cache.h"
44 #include "program/prog_instruction.h"
45 #include "program/prog_parameter.h"
46 #include "program/prog_print.h"
47 #include "program/prog_statevars.h"
48
49
50 /** Max of number of lights and texture coord units */
51 #define NUM_UNITS MAX2(MAX_TEXTURE_COORD_UNITS, MAX_LIGHTS)
52
53 struct state_key {
54 unsigned light_color_material_mask:12;
55 unsigned light_global_enabled:1;
56 unsigned light_local_viewer:1;
57 unsigned light_twoside:1;
58 unsigned material_shininess_is_zero:1;
59 unsigned need_eye_coords:1;
60 unsigned normalize:1;
61 unsigned rescale_normals:1;
62
63 unsigned fog_source_is_depth:1;
64 unsigned fog_distance_mode:2;
65 unsigned separate_specular:1;
66 unsigned point_attenuated:1;
67 unsigned point_array:1;
68 unsigned texture_enabled_global:1;
69 unsigned fragprog_inputs_read:12;
70
71 GLbitfield64 varying_vp_inputs;
72
73 struct {
74 unsigned light_enabled:1;
75 unsigned light_eyepos3_is_zero:1;
76 unsigned light_spotcutoff_is_180:1;
77 unsigned light_attenuated:1;
78 unsigned texunit_really_enabled:1;
79 unsigned texmat_enabled:1;
80 unsigned coord_replace:1;
81 unsigned texgen_enabled:4;
82 unsigned texgen_mode0:4;
83 unsigned texgen_mode1:4;
84 unsigned texgen_mode2:4;
85 unsigned texgen_mode3:4;
86 } unit[NUM_UNITS];
87 };
88
89
90 #define TXG_NONE 0
91 #define TXG_OBJ_LINEAR 1
92 #define TXG_EYE_LINEAR 2
93 #define TXG_SPHERE_MAP 3
94 #define TXG_REFLECTION_MAP 4
95 #define TXG_NORMAL_MAP 5
96
translate_texgen(GLboolean enabled,GLenum mode)97 static GLuint translate_texgen( GLboolean enabled, GLenum mode )
98 {
99 if (!enabled)
100 return TXG_NONE;
101
102 switch (mode) {
103 case GL_OBJECT_LINEAR: return TXG_OBJ_LINEAR;
104 case GL_EYE_LINEAR: return TXG_EYE_LINEAR;
105 case GL_SPHERE_MAP: return TXG_SPHERE_MAP;
106 case GL_REFLECTION_MAP_NV: return TXG_REFLECTION_MAP;
107 case GL_NORMAL_MAP_NV: return TXG_NORMAL_MAP;
108 default: return TXG_NONE;
109 }
110 }
111
112 #define FDM_EYE_RADIAL 0
113 #define FDM_EYE_PLANE 1
114 #define FDM_EYE_PLANE_ABS 2
115
translate_fog_distance_mode(GLenum mode)116 static GLuint translate_fog_distance_mode( GLenum mode )
117 {
118 switch (mode) {
119 case GL_EYE_RADIAL_NV:
120 return FDM_EYE_RADIAL;
121 case GL_EYE_PLANE:
122 return FDM_EYE_PLANE;
123 default: /* shouldn't happen; fall through to a sensible default */
124 case GL_EYE_PLANE_ABSOLUTE_NV:
125 return FDM_EYE_PLANE_ABS;
126 }
127 }
128
check_active_shininess(struct gl_context * ctx,const struct state_key * key,GLuint side)129 static GLboolean check_active_shininess( struct gl_context *ctx,
130 const struct state_key *key,
131 GLuint side )
132 {
133 GLuint attr = MAT_ATTRIB_FRONT_SHININESS + side;
134
135 if ((key->varying_vp_inputs & VERT_BIT_COLOR0) &&
136 (key->light_color_material_mask & (1 << attr)))
137 return GL_TRUE;
138
139 if (key->varying_vp_inputs & VERT_ATTRIB_GENERIC(attr))
140 return GL_TRUE;
141
142 if (ctx->Light.Material.Attrib[attr][0] != 0.0F)
143 return GL_TRUE;
144
145 return GL_FALSE;
146 }
147
148
make_state_key(struct gl_context * ctx,struct state_key * key)149 static void make_state_key( struct gl_context *ctx, struct state_key *key )
150 {
151 const struct gl_fragment_program *fp;
152 GLuint i;
153
154 memset(key, 0, sizeof(struct state_key));
155 fp = ctx->FragmentProgram._Current;
156
157 /* This now relies on texenvprogram.c being active:
158 */
159 assert(fp);
160
161 key->need_eye_coords = ctx->_NeedEyeCoords;
162
163 key->fragprog_inputs_read = fp->Base.InputsRead;
164 key->varying_vp_inputs = ctx->varying_vp_inputs;
165
166 if (ctx->RenderMode == GL_FEEDBACK) {
167 /* make sure the vertprog emits color and tex0 */
168 key->fragprog_inputs_read |= (FRAG_BIT_COL0 | FRAG_BIT_TEX0);
169 }
170
171 key->separate_specular = (ctx->Light.Model.ColorControl ==
172 GL_SEPARATE_SPECULAR_COLOR);
173
174 if (ctx->Light.Enabled) {
175 key->light_global_enabled = 1;
176
177 if (ctx->Light.Model.LocalViewer)
178 key->light_local_viewer = 1;
179
180 if (ctx->Light.Model.TwoSide)
181 key->light_twoside = 1;
182
183 if (ctx->Light.ColorMaterialEnabled) {
184 key->light_color_material_mask = ctx->Light._ColorMaterialBitmask;
185 }
186
187 for (i = 0; i < MAX_LIGHTS; i++) {
188 struct gl_light *light = &ctx->Light.Light[i];
189
190 if (light->Enabled) {
191 key->unit[i].light_enabled = 1;
192
193 if (light->EyePosition[3] == 0.0)
194 key->unit[i].light_eyepos3_is_zero = 1;
195
196 if (light->SpotCutoff == 180.0)
197 key->unit[i].light_spotcutoff_is_180 = 1;
198
199 if (light->ConstantAttenuation != 1.0 ||
200 light->LinearAttenuation != 0.0 ||
201 light->QuadraticAttenuation != 0.0)
202 key->unit[i].light_attenuated = 1;
203 }
204 }
205
206 if (check_active_shininess(ctx, key, 0)) {
207 key->material_shininess_is_zero = 0;
208 }
209 else if (key->light_twoside &&
210 check_active_shininess(ctx, key, 1)) {
211 key->material_shininess_is_zero = 0;
212 }
213 else {
214 key->material_shininess_is_zero = 1;
215 }
216 }
217
218 if (ctx->Transform.Normalize)
219 key->normalize = 1;
220
221 if (ctx->Transform.RescaleNormals)
222 key->rescale_normals = 1;
223
224 if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) {
225 key->fog_source_is_depth = 1;
226 key->fog_distance_mode = translate_fog_distance_mode(ctx->Fog.FogDistanceMode);
227 }
228
229 if (ctx->Point._Attenuated)
230 key->point_attenuated = 1;
231
232 #if FEATURE_point_size_array
233 if (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled)
234 key->point_array = 1;
235 #endif
236
237 if (ctx->Texture._TexGenEnabled ||
238 ctx->Texture._TexMatEnabled ||
239 ctx->Texture._EnabledUnits)
240 key->texture_enabled_global = 1;
241
242 for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
243 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
244
245 if (texUnit->_ReallyEnabled)
246 key->unit[i].texunit_really_enabled = 1;
247
248 if (ctx->Point.PointSprite)
249 if (ctx->Point.CoordReplace[i])
250 key->unit[i].coord_replace = 1;
251
252 if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
253 key->unit[i].texmat_enabled = 1;
254
255 if (texUnit->TexGenEnabled) {
256 key->unit[i].texgen_enabled = 1;
257
258 key->unit[i].texgen_mode0 =
259 translate_texgen( texUnit->TexGenEnabled & (1<<0),
260 texUnit->GenS.Mode );
261 key->unit[i].texgen_mode1 =
262 translate_texgen( texUnit->TexGenEnabled & (1<<1),
263 texUnit->GenT.Mode );
264 key->unit[i].texgen_mode2 =
265 translate_texgen( texUnit->TexGenEnabled & (1<<2),
266 texUnit->GenR.Mode );
267 key->unit[i].texgen_mode3 =
268 translate_texgen( texUnit->TexGenEnabled & (1<<3),
269 texUnit->GenQ.Mode );
270 }
271 }
272 }
273
274
275
276 /* Very useful debugging tool - produces annotated listing of
277 * generated program with line/function references for each
278 * instruction back into this file:
279 */
280 #define DISASSEM 0
281
282
283 /* Use uregs to represent registers internally, translate to Mesa's
284 * expected formats on emit.
285 *
286 * NOTE: These are passed by value extensively in this file rather
287 * than as usual by pointer reference. If this disturbs you, try
288 * remembering they are just 32bits in size.
289 *
290 * GCC is smart enough to deal with these dword-sized structures in
291 * much the same way as if I had defined them as dwords and was using
292 * macros to access and set the fields. This is much nicer and easier
293 * to evolve.
294 */
295 struct ureg {
296 GLuint file:4;
297 GLint idx:9; /* relative addressing may be negative */
298 /* sizeof(idx) should == sizeof(prog_src_reg::Index) */
299 GLuint negate:1;
300 GLuint swz:12;
301 GLuint pad:6;
302 };
303
304
305 struct tnl_program {
306 const struct state_key *state;
307 struct gl_vertex_program *program;
308 GLint max_inst; /** number of instructions allocated for program */
309 GLboolean mvp_with_dp4;
310
311 GLuint temp_in_use;
312 GLuint temp_reserved;
313
314 struct ureg eye_position;
315 struct ureg eye_position_z;
316 struct ureg eye_position_normalized;
317 struct ureg transformed_normal;
318 struct ureg identity;
319
320 GLuint materials;
321 GLuint color_materials;
322 };
323
324
325 static const struct ureg undef = {
326 PROGRAM_UNDEFINED,
327 0,
328 0,
329 0,
330 0
331 };
332
333 /* Local shorthand:
334 */
335 #define X SWIZZLE_X
336 #define Y SWIZZLE_Y
337 #define Z SWIZZLE_Z
338 #define W SWIZZLE_W
339
340
341 /* Construct a ureg:
342 */
make_ureg(GLuint file,GLint idx)343 static struct ureg make_ureg(GLuint file, GLint idx)
344 {
345 struct ureg reg;
346 reg.file = file;
347 reg.idx = idx;
348 reg.negate = 0;
349 reg.swz = SWIZZLE_NOOP;
350 reg.pad = 0;
351 return reg;
352 }
353
354
355
negate(struct ureg reg)356 static struct ureg negate( struct ureg reg )
357 {
358 reg.negate ^= 1;
359 return reg;
360 }
361
362
swizzle(struct ureg reg,int x,int y,int z,int w)363 static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
364 {
365 reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
366 GET_SWZ(reg.swz, y),
367 GET_SWZ(reg.swz, z),
368 GET_SWZ(reg.swz, w));
369 return reg;
370 }
371
372
swizzle1(struct ureg reg,int x)373 static struct ureg swizzle1( struct ureg reg, int x )
374 {
375 return swizzle(reg, x, x, x, x);
376 }
377
378
get_temp(struct tnl_program * p)379 static struct ureg get_temp( struct tnl_program *p )
380 {
381 int bit = ffs( ~p->temp_in_use );
382 if (!bit) {
383 _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
384 exit(1);
385 }
386
387 if ((GLuint) bit > p->program->Base.NumTemporaries)
388 p->program->Base.NumTemporaries = bit;
389
390 p->temp_in_use |= 1<<(bit-1);
391 return make_ureg(PROGRAM_TEMPORARY, bit-1);
392 }
393
394
reserve_temp(struct tnl_program * p)395 static struct ureg reserve_temp( struct tnl_program *p )
396 {
397 struct ureg temp = get_temp( p );
398 p->temp_reserved |= 1<<temp.idx;
399 return temp;
400 }
401
402
release_temp(struct tnl_program * p,struct ureg reg)403 static void release_temp( struct tnl_program *p, struct ureg reg )
404 {
405 if (reg.file == PROGRAM_TEMPORARY) {
406 p->temp_in_use &= ~(1<<reg.idx);
407 p->temp_in_use |= p->temp_reserved; /* can't release reserved temps */
408 }
409 }
410
release_temps(struct tnl_program * p)411 static void release_temps( struct tnl_program *p )
412 {
413 p->temp_in_use = p->temp_reserved;
414 }
415
416
register_param5(struct tnl_program * p,GLint s0,GLint s1,GLint s2,GLint s3,GLint s4)417 static struct ureg register_param5(struct tnl_program *p,
418 GLint s0,
419 GLint s1,
420 GLint s2,
421 GLint s3,
422 GLint s4)
423 {
424 gl_state_index tokens[STATE_LENGTH];
425 GLint idx;
426 tokens[0] = s0;
427 tokens[1] = s1;
428 tokens[2] = s2;
429 tokens[3] = s3;
430 tokens[4] = s4;
431 idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
432 return make_ureg(PROGRAM_STATE_VAR, idx);
433 }
434
435
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)
440
441
442
443 /**
444 * \param input one of VERT_ATTRIB_x tokens.
445 */
register_input(struct tnl_program * p,GLuint input)446 static struct ureg register_input( struct tnl_program *p, GLuint input )
447 {
448 assert(input < VERT_ATTRIB_MAX);
449
450 if (p->state->varying_vp_inputs & VERT_BIT(input)) {
451 p->program->Base.InputsRead |= VERT_BIT(input);
452 return make_ureg(PROGRAM_INPUT, input);
453 }
454 else {
455 return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB, input );
456 }
457 }
458
459
460 /**
461 * \param input one of VERT_RESULT_x tokens.
462 */
register_output(struct tnl_program * p,GLuint output)463 static struct ureg register_output( struct tnl_program *p, GLuint output )
464 {
465 p->program->Base.OutputsWritten |= BITFIELD64_BIT(output);
466 return make_ureg(PROGRAM_OUTPUT, output);
467 }
468
469
register_const4f(struct tnl_program * p,GLfloat s0,GLfloat s1,GLfloat s2,GLfloat s3)470 static struct ureg register_const4f( struct tnl_program *p,
471 GLfloat s0,
472 GLfloat s1,
473 GLfloat s2,
474 GLfloat s3)
475 {
476 gl_constant_value values[4];
477 GLint idx;
478 GLuint swizzle;
479 values[0].f = s0;
480 values[1].f = s1;
481 values[2].f = s2;
482 values[3].f = s3;
483 idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
484 &swizzle );
485 ASSERT(swizzle == SWIZZLE_NOOP);
486 return make_ureg(PROGRAM_CONSTANT, idx);
487 }
488
489 #define register_const1f(p, s0) register_const4f(p, s0, 0, 0, 1)
490 #define register_scalar_const(p, s0) register_const4f(p, s0, s0, s0, s0)
491 #define register_const2f(p, s0, s1) register_const4f(p, s0, s1, 0, 1)
492 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
493
is_undef(struct ureg reg)494 static GLboolean is_undef( struct ureg reg )
495 {
496 return reg.file == PROGRAM_UNDEFINED;
497 }
498
499
get_identity_param(struct tnl_program * p)500 static struct ureg get_identity_param( struct tnl_program *p )
501 {
502 if (is_undef(p->identity))
503 p->identity = register_const4f(p, 0,0,0,1);
504
505 return p->identity;
506 }
507
register_matrix_param5(struct tnl_program * p,GLint s0,GLint s1,GLint s2,GLint s3,GLint s4,struct ureg * matrix)508 static void register_matrix_param5( struct tnl_program *p,
509 GLint s0, /* modelview, projection, etc */
510 GLint s1, /* texture matrix number */
511 GLint s2, /* first row */
512 GLint s3, /* last row */
513 GLint s4, /* inverse, transpose, etc */
514 struct ureg *matrix )
515 {
516 GLint i;
517
518 /* This is a bit sad as the support is there to pull the whole
519 * matrix out in one go:
520 */
521 for (i = 0; i <= s3 - s2; i++)
522 matrix[i] = register_param5( p, s0, s1, i, i, s4 );
523 }
524
525
emit_arg(struct prog_src_register * src,struct ureg reg)526 static void emit_arg( struct prog_src_register *src,
527 struct ureg reg )
528 {
529 src->File = reg.file;
530 src->Index = reg.idx;
531 src->Swizzle = reg.swz;
532 src->Negate = reg.negate ? NEGATE_XYZW : NEGATE_NONE;
533 src->Abs = 0;
534 src->RelAddr = 0;
535 /* Check that bitfield sizes aren't exceeded */
536 ASSERT(src->Index == reg.idx);
537 }
538
539
emit_dst(struct prog_dst_register * dst,struct ureg reg,GLuint mask)540 static void emit_dst( struct prog_dst_register *dst,
541 struct ureg reg, GLuint mask )
542 {
543 dst->File = reg.file;
544 dst->Index = reg.idx;
545 /* allow zero as a shorthand for xyzw */
546 dst->WriteMask = mask ? mask : WRITEMASK_XYZW;
547 dst->CondMask = COND_TR; /* always pass cond test */
548 dst->CondSwizzle = SWIZZLE_NOOP;
549 dst->CondSrc = 0;
550 /* Check that bitfield sizes aren't exceeded */
551 ASSERT(dst->Index == reg.idx);
552 }
553
554
debug_insn(struct prog_instruction * inst,const char * fn,GLuint line)555 static void debug_insn( struct prog_instruction *inst, const char *fn,
556 GLuint line )
557 {
558 if (DISASSEM) {
559 static const char *last_fn;
560
561 if (fn != last_fn) {
562 last_fn = fn;
563 printf("%s:\n", fn);
564 }
565
566 printf("%d:\t", line);
567 _mesa_print_instruction(inst);
568 }
569 }
570
571
emit_op3fn(struct tnl_program * p,enum prog_opcode op,struct ureg dest,GLuint mask,struct ureg src0,struct ureg src1,struct ureg src2,const char * fn,GLuint line)572 static void emit_op3fn(struct tnl_program *p,
573 enum prog_opcode op,
574 struct ureg dest,
575 GLuint mask,
576 struct ureg src0,
577 struct ureg src1,
578 struct ureg src2,
579 const char *fn,
580 GLuint line)
581 {
582 GLuint nr;
583 struct prog_instruction *inst;
584
585 assert((GLint) p->program->Base.NumInstructions <= p->max_inst);
586
587 if (p->program->Base.NumInstructions == p->max_inst) {
588 /* need to extend the program's instruction array */
589 struct prog_instruction *newInst;
590
591 /* double the size */
592 p->max_inst *= 2;
593
594 newInst = _mesa_alloc_instructions(p->max_inst);
595 if (!newInst) {
596 _mesa_error(NULL, GL_OUT_OF_MEMORY, "vertex program build");
597 return;
598 }
599
600 _mesa_copy_instructions(newInst,
601 p->program->Base.Instructions,
602 p->program->Base.NumInstructions);
603
604 _mesa_free_instructions(p->program->Base.Instructions,
605 p->program->Base.NumInstructions);
606
607 p->program->Base.Instructions = newInst;
608 }
609
610 nr = p->program->Base.NumInstructions++;
611
612 inst = &p->program->Base.Instructions[nr];
613 inst->Opcode = (enum prog_opcode) op;
614 inst->Data = 0;
615
616 emit_arg( &inst->SrcReg[0], src0 );
617 emit_arg( &inst->SrcReg[1], src1 );
618 emit_arg( &inst->SrcReg[2], src2 );
619
620 emit_dst( &inst->DstReg, dest, mask );
621
622 debug_insn(inst, fn, line);
623 }
624
625
626 #define emit_op3(p, op, dst, mask, src0, src1, src2) \
627 emit_op3fn(p, op, dst, mask, src0, src1, src2, __FUNCTION__, __LINE__)
628
629 #define emit_op2(p, op, dst, mask, src0, src1) \
630 emit_op3fn(p, op, dst, mask, src0, src1, undef, __FUNCTION__, __LINE__)
631
632 #define emit_op1(p, op, dst, mask, src0) \
633 emit_op3fn(p, op, dst, mask, src0, undef, undef, __FUNCTION__, __LINE__)
634
635
make_temp(struct tnl_program * p,struct ureg reg)636 static struct ureg make_temp( struct tnl_program *p, struct ureg reg )
637 {
638 if (reg.file == PROGRAM_TEMPORARY &&
639 !(p->temp_reserved & (1<<reg.idx)))
640 return reg;
641 else {
642 struct ureg temp = get_temp(p);
643 emit_op1(p, OPCODE_MOV, temp, 0, reg);
644 return temp;
645 }
646 }
647
648
649 /* Currently no tracking performed of input/output/register size or
650 * active elements. Could be used to reduce these operations, as
651 * could the matrix type.
652 */
emit_matrix_transform_vec4(struct tnl_program * p,struct ureg dest,const struct ureg * mat,struct ureg src)653 static void emit_matrix_transform_vec4( struct tnl_program *p,
654 struct ureg dest,
655 const struct ureg *mat,
656 struct ureg src)
657 {
658 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_X, src, mat[0]);
659 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_Y, src, mat[1]);
660 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_Z, src, mat[2]);
661 emit_op2(p, OPCODE_DP4, dest, WRITEMASK_W, src, mat[3]);
662 }
663
664
665 /* This version is much easier to implement if writemasks are not
666 * supported natively on the target or (like SSE), the target doesn't
667 * have a clean/obvious dotproduct implementation.
668 */
emit_transpose_matrix_transform_vec4(struct tnl_program * p,struct ureg dest,const struct ureg * mat,struct ureg src)669 static void emit_transpose_matrix_transform_vec4( struct tnl_program *p,
670 struct ureg dest,
671 const struct ureg *mat,
672 struct ureg src)
673 {
674 struct ureg tmp;
675
676 if (dest.file != PROGRAM_TEMPORARY)
677 tmp = get_temp(p);
678 else
679 tmp = dest;
680
681 emit_op2(p, OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
682 emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
683 emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
684 emit_op3(p, OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
685
686 if (dest.file != PROGRAM_TEMPORARY)
687 release_temp(p, tmp);
688 }
689
690
emit_matrix_transform_vec3(struct tnl_program * p,struct ureg dest,const struct ureg * mat,struct ureg src)691 static void emit_matrix_transform_vec3( struct tnl_program *p,
692 struct ureg dest,
693 const struct ureg *mat,
694 struct ureg src)
695 {
696 emit_op2(p, OPCODE_DP3, dest, WRITEMASK_X, src, mat[0]);
697 emit_op2(p, OPCODE_DP3, dest, WRITEMASK_Y, src, mat[1]);
698 emit_op2(p, OPCODE_DP3, dest, WRITEMASK_Z, src, mat[2]);
699 }
700
701
emit_normalize_vec3(struct tnl_program * p,struct ureg dest,struct ureg src)702 static void emit_normalize_vec3( struct tnl_program *p,
703 struct ureg dest,
704 struct ureg src )
705 {
706 #if 0
707 /* XXX use this when drivers are ready for NRM3 */
708 emit_op1(p, OPCODE_NRM3, dest, WRITEMASK_XYZ, src);
709 #else
710 struct ureg tmp = get_temp(p);
711 emit_op2(p, OPCODE_DP3, tmp, WRITEMASK_X, src, src);
712 emit_op1(p, OPCODE_RSQ, tmp, WRITEMASK_X, tmp);
713 emit_op2(p, OPCODE_MUL, dest, 0, src, swizzle1(tmp, X));
714 release_temp(p, tmp);
715 #endif
716 }
717
718
emit_passthrough(struct tnl_program * p,GLuint input,GLuint output)719 static void emit_passthrough( struct tnl_program *p,
720 GLuint input,
721 GLuint output )
722 {
723 struct ureg out = register_output(p, output);
724 emit_op1(p, OPCODE_MOV, out, 0, register_input(p, input));
725 }
726
727
get_eye_position(struct tnl_program * p)728 static struct ureg get_eye_position( struct tnl_program *p )
729 {
730 if (is_undef(p->eye_position)) {
731 struct ureg pos = register_input( p, VERT_ATTRIB_POS );
732 struct ureg modelview[4];
733
734 p->eye_position = reserve_temp(p);
735
736 if (p->mvp_with_dp4) {
737 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
738 0, modelview );
739
740 emit_matrix_transform_vec4(p, p->eye_position, modelview, pos);
741 }
742 else {
743 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
744 STATE_MATRIX_TRANSPOSE, modelview );
745
746 emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos);
747 }
748 }
749
750 return p->eye_position;
751 }
752
753
get_eye_position_z(struct tnl_program * p)754 static struct ureg get_eye_position_z( struct tnl_program *p )
755 {
756 if (!is_undef(p->eye_position))
757 return swizzle1(p->eye_position, Z);
758
759 if (is_undef(p->eye_position_z)) {
760 struct ureg pos = register_input( p, VERT_ATTRIB_POS );
761 struct ureg modelview[4];
762
763 p->eye_position_z = reserve_temp(p);
764
765 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
766 0, modelview );
767
768 emit_op2(p, OPCODE_DP4, p->eye_position_z, 0, pos, modelview[2]);
769 }
770
771 return p->eye_position_z;
772 }
773
774
get_eye_position_normalized(struct tnl_program * p)775 static struct ureg get_eye_position_normalized( struct tnl_program *p )
776 {
777 if (is_undef(p->eye_position_normalized)) {
778 struct ureg eye = get_eye_position(p);
779 p->eye_position_normalized = reserve_temp(p);
780 emit_normalize_vec3(p, p->eye_position_normalized, eye);
781 }
782
783 return p->eye_position_normalized;
784 }
785
786
get_transformed_normal(struct tnl_program * p)787 static struct ureg get_transformed_normal( struct tnl_program *p )
788 {
789 if (is_undef(p->transformed_normal) &&
790 !p->state->need_eye_coords &&
791 !p->state->normalize &&
792 !(p->state->need_eye_coords == p->state->rescale_normals))
793 {
794 p->transformed_normal = register_input(p, VERT_ATTRIB_NORMAL );
795 }
796 else if (is_undef(p->transformed_normal))
797 {
798 struct ureg normal = register_input(p, VERT_ATTRIB_NORMAL );
799 struct ureg mvinv[3];
800 struct ureg transformed_normal = reserve_temp(p);
801
802 if (p->state->need_eye_coords) {
803 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 2,
804 STATE_MATRIX_INVTRANS, mvinv );
805
806 /* Transform to eye space:
807 */
808 emit_matrix_transform_vec3( p, transformed_normal, mvinv, normal );
809 normal = transformed_normal;
810 }
811
812 /* Normalize/Rescale:
813 */
814 if (p->state->normalize) {
815 emit_normalize_vec3( p, transformed_normal, normal );
816 normal = transformed_normal;
817 }
818 else if (p->state->need_eye_coords == p->state->rescale_normals) {
819 /* This is already adjusted for eye/non-eye rendering:
820 */
821 struct ureg rescale = register_param2(p, STATE_INTERNAL,
822 STATE_NORMAL_SCALE);
823
824 emit_op2( p, OPCODE_MUL, transformed_normal, 0, normal, rescale );
825 normal = transformed_normal;
826 }
827
828 assert(normal.file == PROGRAM_TEMPORARY);
829 p->transformed_normal = normal;
830 }
831
832 return p->transformed_normal;
833 }
834
835
build_hpos(struct tnl_program * p)836 static void build_hpos( struct tnl_program *p )
837 {
838 struct ureg pos = register_input( p, VERT_ATTRIB_POS );
839 struct ureg hpos = register_output( p, VERT_RESULT_HPOS );
840 struct ureg mvp[4];
841
842 if (p->mvp_with_dp4) {
843 register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
844 0, mvp );
845 emit_matrix_transform_vec4( p, hpos, mvp, pos );
846 }
847 else {
848 register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
849 STATE_MATRIX_TRANSPOSE, mvp );
850 emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos );
851 }
852 }
853
854
material_attrib(GLuint side,GLuint property)855 static GLuint material_attrib( GLuint side, GLuint property )
856 {
857 return (property - STATE_AMBIENT) * 2 + side;
858 }
859
860
861 /**
862 * Get a bitmask of which material values vary on a per-vertex basis.
863 */
set_material_flags(struct tnl_program * p)864 static void set_material_flags( struct tnl_program *p )
865 {
866 p->color_materials = 0;
867 p->materials = 0;
868
869 if (p->state->varying_vp_inputs & VERT_BIT_COLOR0) {
870 p->materials =
871 p->color_materials = p->state->light_color_material_mask;
872 }
873
874 p->materials |= (p->state->varying_vp_inputs >> VERT_ATTRIB_GENERIC0);
875 }
876
877
get_material(struct tnl_program * p,GLuint side,GLuint property)878 static struct ureg get_material( struct tnl_program *p, GLuint side,
879 GLuint property )
880 {
881 GLuint attrib = material_attrib(side, property);
882
883 if (p->color_materials & (1<<attrib))
884 return register_input(p, VERT_ATTRIB_COLOR0);
885 else if (p->materials & (1<<attrib)) {
886 /* Put material values in the GENERIC slots -- they are not used
887 * for anything in fixed function mode.
888 */
889 return register_input( p, attrib + VERT_ATTRIB_GENERIC0 );
890 }
891 else
892 return register_param3( p, STATE_MATERIAL, side, property );
893 }
894
895 #define SCENE_COLOR_BITS(side) (( MAT_BIT_FRONT_EMISSION | \
896 MAT_BIT_FRONT_AMBIENT | \
897 MAT_BIT_FRONT_DIFFUSE) << (side))
898
899
900 /**
901 * Either return a precalculated constant value or emit code to
902 * calculate these values dynamically in the case where material calls
903 * are present between begin/end pairs.
904 *
905 * Probably want to shift this to the program compilation phase - if
906 * we always emitted the calculation here, a smart compiler could
907 * detect that it was constant (given a certain set of inputs), and
908 * lift it out of the main loop. That way the programs created here
909 * would be independent of the vertex_buffer details.
910 */
get_scenecolor(struct tnl_program * p,GLuint side)911 static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
912 {
913 if (p->materials & SCENE_COLOR_BITS(side)) {
914 struct ureg lm_ambient = register_param1(p, STATE_LIGHTMODEL_AMBIENT);
915 struct ureg material_emission = get_material(p, side, STATE_EMISSION);
916 struct ureg material_ambient = get_material(p, side, STATE_AMBIENT);
917 struct ureg material_diffuse = get_material(p, side, STATE_DIFFUSE);
918 struct ureg tmp = make_temp(p, material_diffuse);
919 emit_op3(p, OPCODE_MAD, tmp, WRITEMASK_XYZ, lm_ambient,
920 material_ambient, material_emission);
921 return tmp;
922 }
923 else
924 return register_param2( p, STATE_LIGHTMODEL_SCENECOLOR, side );
925 }
926
927
get_lightprod(struct tnl_program * p,GLuint light,GLuint side,GLuint property)928 static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
929 GLuint side, GLuint property )
930 {
931 GLuint attrib = material_attrib(side, property);
932 if (p->materials & (1<<attrib)) {
933 struct ureg light_value =
934 register_param3(p, STATE_LIGHT, light, property);
935 struct ureg material_value = get_material(p, side, property);
936 struct ureg tmp = get_temp(p);
937 emit_op2(p, OPCODE_MUL, tmp, 0, light_value, material_value);
938 return tmp;
939 }
940 else
941 return register_param4(p, STATE_LIGHTPROD, light, side, property);
942 }
943
944
calculate_light_attenuation(struct tnl_program * p,GLuint i,struct ureg VPpli,struct ureg dist)945 static struct ureg calculate_light_attenuation( struct tnl_program *p,
946 GLuint i,
947 struct ureg VPpli,
948 struct ureg dist )
949 {
950 struct ureg attenuation = register_param3(p, STATE_LIGHT, i,
951 STATE_ATTENUATION);
952 struct ureg att = undef;
953
954 /* Calculate spot attenuation:
955 */
956 if (!p->state->unit[i].light_spotcutoff_is_180) {
957 struct ureg spot_dir_norm = register_param3(p, STATE_INTERNAL,
958 STATE_LIGHT_SPOT_DIR_NORMALIZED, i);
959 struct ureg spot = get_temp(p);
960 struct ureg slt = get_temp(p);
961
962 att = get_temp(p);
963
964 emit_op2(p, OPCODE_DP3, spot, 0, negate(VPpli), spot_dir_norm);
965 emit_op2(p, OPCODE_SLT, slt, 0, swizzle1(spot_dir_norm,W), spot);
966 emit_op2(p, OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
967 emit_op2(p, OPCODE_MUL, att, 0, slt, spot);
968
969 release_temp(p, spot);
970 release_temp(p, slt);
971 }
972
973 /* Calculate distance attenuation(See formula (2.4) at glspec 2.1 page 62):
974 *
975 * Skip the calucation when _dist_ is undefined(light_eyepos3_is_zero)
976 */
977 if (p->state->unit[i].light_attenuated && !is_undef(dist)) {
978 if (is_undef(att))
979 att = get_temp(p);
980 /* 1/d,d,d,1/d */
981 emit_op1(p, OPCODE_RCP, dist, WRITEMASK_YZ, dist);
982 /* 1,d,d*d,1/d */
983 emit_op2(p, OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
984 /* 1/dist-atten */
985 emit_op2(p, OPCODE_DP3, dist, 0, attenuation, dist);
986
987 if (!p->state->unit[i].light_spotcutoff_is_180) {
988 /* dist-atten */
989 emit_op1(p, OPCODE_RCP, dist, 0, dist);
990 /* spot-atten * dist-atten */
991 emit_op2(p, OPCODE_MUL, att, 0, dist, att);
992 }
993 else {
994 /* dist-atten */
995 emit_op1(p, OPCODE_RCP, att, 0, dist);
996 }
997 }
998
999 return att;
1000 }
1001
1002
1003 /**
1004 * Compute:
1005 * lit.y = MAX(0, dots.x)
1006 * lit.z = SLT(0, dots.x)
1007 */
emit_degenerate_lit(struct tnl_program * p,struct ureg lit,struct ureg dots)1008 static void emit_degenerate_lit( struct tnl_program *p,
1009 struct ureg lit,
1010 struct ureg dots )
1011 {
1012 struct ureg id = get_identity_param(p); /* id = {0,0,0,1} */
1013
1014 /* Note that lit.x & lit.w will not be examined. Note also that
1015 * dots.xyzw == dots.xxxx.
1016 */
1017
1018 /* MAX lit, id, dots;
1019 */
1020 emit_op2(p, OPCODE_MAX, lit, WRITEMASK_XYZW, id, dots);
1021
1022 /* result[2] = (in > 0 ? 1 : 0)
1023 * SLT lit.z, id.z, dots; # lit.z = (0 < dots.z) ? 1 : 0
1024 */
1025 emit_op2(p, OPCODE_SLT, lit, WRITEMASK_Z, swizzle1(id,Z), dots);
1026 }
1027
1028
1029 /* Need to add some addtional parameters to allow lighting in object
1030 * space - STATE_SPOT_DIRECTION and STATE_HALF_VECTOR implicitly assume eye
1031 * space lighting.
1032 */
build_lighting(struct tnl_program * p)1033 static void build_lighting( struct tnl_program *p )
1034 {
1035 const GLboolean twoside = p->state->light_twoside;
1036 const GLboolean separate = p->state->separate_specular;
1037 GLuint nr_lights = 0, count = 0;
1038 struct ureg normal = get_transformed_normal(p);
1039 struct ureg lit = get_temp(p);
1040 struct ureg dots = get_temp(p);
1041 struct ureg _col0 = undef, _col1 = undef;
1042 struct ureg _bfc0 = undef, _bfc1 = undef;
1043 GLuint i;
1044
1045 /*
1046 * NOTE:
1047 * dots.x = dot(normal, VPpli)
1048 * dots.y = dot(normal, halfAngle)
1049 * dots.z = back.shininess
1050 * dots.w = front.shininess
1051 */
1052
1053 for (i = 0; i < MAX_LIGHTS; i++)
1054 if (p->state->unit[i].light_enabled)
1055 nr_lights++;
1056
1057 set_material_flags(p);
1058
1059 {
1060 if (!p->state->material_shininess_is_zero) {
1061 struct ureg shininess = get_material(p, 0, STATE_SHININESS);
1062 emit_op1(p, OPCODE_MOV, dots, WRITEMASK_W, swizzle1(shininess,X));
1063 release_temp(p, shininess);
1064 }
1065
1066 _col0 = make_temp(p, get_scenecolor(p, 0));
1067 if (separate)
1068 _col1 = make_temp(p, get_identity_param(p));
1069 else
1070 _col1 = _col0;
1071 }
1072
1073 if (twoside) {
1074 if (!p->state->material_shininess_is_zero) {
1075 /* Note that we negate the back-face specular exponent here.
1076 * The negation will be un-done later in the back-face code below.
1077 */
1078 struct ureg shininess = get_material(p, 1, STATE_SHININESS);
1079 emit_op1(p, OPCODE_MOV, dots, WRITEMASK_Z,
1080 negate(swizzle1(shininess,X)));
1081 release_temp(p, shininess);
1082 }
1083
1084 _bfc0 = make_temp(p, get_scenecolor(p, 1));
1085 if (separate)
1086 _bfc1 = make_temp(p, get_identity_param(p));
1087 else
1088 _bfc1 = _bfc0;
1089 }
1090
1091 /* If no lights, still need to emit the scenecolor.
1092 */
1093 {
1094 struct ureg res0 = register_output( p, VERT_RESULT_COL0 );
1095 emit_op1(p, OPCODE_MOV, res0, 0, _col0);
1096 }
1097
1098 if (separate) {
1099 struct ureg res1 = register_output( p, VERT_RESULT_COL1 );
1100 emit_op1(p, OPCODE_MOV, res1, 0, _col1);
1101 }
1102
1103 if (twoside) {
1104 struct ureg res0 = register_output( p, VERT_RESULT_BFC0 );
1105 emit_op1(p, OPCODE_MOV, res0, 0, _bfc0);
1106 }
1107
1108 if (twoside && separate) {
1109 struct ureg res1 = register_output( p, VERT_RESULT_BFC1 );
1110 emit_op1(p, OPCODE_MOV, res1, 0, _bfc1);
1111 }
1112
1113 if (nr_lights == 0) {
1114 release_temps(p);
1115 return;
1116 }
1117
1118 for (i = 0; i < MAX_LIGHTS; i++) {
1119 if (p->state->unit[i].light_enabled) {
1120 struct ureg half = undef;
1121 struct ureg att = undef, VPpli = undef;
1122 struct ureg dist = undef;
1123
1124 count++;
1125 if (p->state->unit[i].light_eyepos3_is_zero) {
1126 VPpli = register_param3(p, STATE_INTERNAL,
1127 STATE_LIGHT_POSITION_NORMALIZED, i);
1128 } else {
1129 struct ureg Ppli = register_param3(p, STATE_INTERNAL,
1130 STATE_LIGHT_POSITION, i);
1131 struct ureg V = get_eye_position(p);
1132
1133 VPpli = get_temp(p);
1134 dist = get_temp(p);
1135
1136 /* Calculate VPpli vector
1137 */
1138 emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V);
1139
1140 /* Normalize VPpli. The dist value also used in
1141 * attenuation below.
1142 */
1143 emit_op2(p, OPCODE_DP3, dist, 0, VPpli, VPpli);
1144 emit_op1(p, OPCODE_RSQ, dist, 0, dist);
1145 emit_op2(p, OPCODE_MUL, VPpli, 0, VPpli, dist);
1146 }
1147
1148 /* Calculate attenuation:
1149 */
1150 att = calculate_light_attenuation(p, i, VPpli, dist);
1151 release_temp(p, dist);
1152
1153 /* Calculate viewer direction, or use infinite viewer:
1154 */
1155 if (!p->state->material_shininess_is_zero) {
1156 if (p->state->light_local_viewer) {
1157 struct ureg eye_hat = get_eye_position_normalized(p);
1158 half = get_temp(p);
1159 emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat);
1160 emit_normalize_vec3(p, half, half);
1161 } else if (p->state->unit[i].light_eyepos3_is_zero) {
1162 half = register_param3(p, STATE_INTERNAL,
1163 STATE_LIGHT_HALF_VECTOR, i);
1164 } else {
1165 struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z);
1166 half = get_temp(p);
1167 emit_op2(p, OPCODE_ADD, half, 0, VPpli, z_dir);
1168 emit_normalize_vec3(p, half, half);
1169 }
1170 }
1171
1172 /* Calculate dot products:
1173 */
1174 if (p->state->material_shininess_is_zero) {
1175 emit_op2(p, OPCODE_DP3, dots, 0, normal, VPpli);
1176 }
1177 else {
1178 emit_op2(p, OPCODE_DP3, dots, WRITEMASK_X, normal, VPpli);
1179 emit_op2(p, OPCODE_DP3, dots, WRITEMASK_Y, normal, half);
1180 }
1181
1182 /* Front face lighting:
1183 */
1184 {
1185 struct ureg ambient = get_lightprod(p, i, 0, STATE_AMBIENT);
1186 struct ureg diffuse = get_lightprod(p, i, 0, STATE_DIFFUSE);
1187 struct ureg specular = get_lightprod(p, i, 0, STATE_SPECULAR);
1188 struct ureg res0, res1;
1189 GLuint mask0, mask1;
1190
1191 if (count == nr_lights) {
1192 if (separate) {
1193 mask0 = WRITEMASK_XYZ;
1194 mask1 = WRITEMASK_XYZ;
1195 res0 = register_output( p, VERT_RESULT_COL0 );
1196 res1 = register_output( p, VERT_RESULT_COL1 );
1197 }
1198 else {
1199 mask0 = 0;
1200 mask1 = WRITEMASK_XYZ;
1201 res0 = _col0;
1202 res1 = register_output( p, VERT_RESULT_COL0 );
1203 }
1204 }
1205 else {
1206 mask0 = 0;
1207 mask1 = 0;
1208 res0 = _col0;
1209 res1 = _col1;
1210 }
1211
1212 if (!is_undef(att)) {
1213 /* light is attenuated by distance */
1214 emit_op1(p, OPCODE_LIT, lit, 0, dots);
1215 emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
1216 emit_op3(p, OPCODE_MAD, _col0, 0, swizzle1(lit,X), ambient, _col0);
1217 }
1218 else if (!p->state->material_shininess_is_zero) {
1219 /* there's a non-zero specular term */
1220 emit_op1(p, OPCODE_LIT, lit, 0, dots);
1221 emit_op2(p, OPCODE_ADD, _col0, 0, ambient, _col0);
1222 }
1223 else {
1224 /* no attenutation, no specular */
1225 emit_degenerate_lit(p, lit, dots);
1226 emit_op2(p, OPCODE_ADD, _col0, 0, ambient, _col0);
1227 }
1228
1229 emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _col0);
1230 emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _col1);
1231
1232 release_temp(p, ambient);
1233 release_temp(p, diffuse);
1234 release_temp(p, specular);
1235 }
1236
1237 /* Back face lighting:
1238 */
1239 if (twoside) {
1240 struct ureg ambient = get_lightprod(p, i, 1, STATE_AMBIENT);
1241 struct ureg diffuse = get_lightprod(p, i, 1, STATE_DIFFUSE);
1242 struct ureg specular = get_lightprod(p, i, 1, STATE_SPECULAR);
1243 struct ureg res0, res1;
1244 GLuint mask0, mask1;
1245
1246 if (count == nr_lights) {
1247 if (separate) {
1248 mask0 = WRITEMASK_XYZ;
1249 mask1 = WRITEMASK_XYZ;
1250 res0 = register_output( p, VERT_RESULT_BFC0 );
1251 res1 = register_output( p, VERT_RESULT_BFC1 );
1252 }
1253 else {
1254 mask0 = 0;
1255 mask1 = WRITEMASK_XYZ;
1256 res0 = _bfc0;
1257 res1 = register_output( p, VERT_RESULT_BFC0 );
1258 }
1259 }
1260 else {
1261 res0 = _bfc0;
1262 res1 = _bfc1;
1263 mask0 = 0;
1264 mask1 = 0;
1265 }
1266
1267 /* For the back face we need to negate the X and Y component
1268 * dot products. dots.Z has the negated back-face specular
1269 * exponent. We swizzle that into the W position. This
1270 * negation makes the back-face specular term positive again.
1271 */
1272 dots = negate(swizzle(dots,X,Y,W,Z));
1273
1274 if (!is_undef(att)) {
1275 emit_op1(p, OPCODE_LIT, lit, 0, dots);
1276 emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
1277 emit_op3(p, OPCODE_MAD, _bfc0, 0, swizzle1(lit,X), ambient, _bfc0);
1278 }
1279 else if (!p->state->material_shininess_is_zero) {
1280 emit_op1(p, OPCODE_LIT, lit, 0, dots);
1281 emit_op2(p, OPCODE_ADD, _bfc0, 0, ambient, _bfc0); /**/
1282 }
1283 else {
1284 emit_degenerate_lit(p, lit, dots);
1285 emit_op2(p, OPCODE_ADD, _bfc0, 0, ambient, _bfc0);
1286 }
1287
1288 emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _bfc0);
1289 emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _bfc1);
1290 /* restore dots to its original state for subsequent lights
1291 * by negating and swizzling again.
1292 */
1293 dots = negate(swizzle(dots,X,Y,W,Z));
1294
1295 release_temp(p, ambient);
1296 release_temp(p, diffuse);
1297 release_temp(p, specular);
1298 }
1299
1300 release_temp(p, half);
1301 release_temp(p, VPpli);
1302 release_temp(p, att);
1303 }
1304 }
1305
1306 release_temps( p );
1307 }
1308
1309
build_fog(struct tnl_program * p)1310 static void build_fog( struct tnl_program *p )
1311 {
1312 struct ureg fog = register_output(p, VERT_RESULT_FOGC);
1313 struct ureg input;
1314
1315 if (p->state->fog_source_is_depth) {
1316
1317 switch (p->state->fog_distance_mode) {
1318 case FDM_EYE_RADIAL: /* Z = sqrt(Xe*Xe + Ye*Ye + Ze*Ze) */
1319 input = get_eye_position(p);
1320 emit_op2(p, OPCODE_DP3, fog, WRITEMASK_X, input, input);
1321 emit_op1(p, OPCODE_RSQ, fog, WRITEMASK_X, fog);
1322 emit_op1(p, OPCODE_RCP, fog, WRITEMASK_X, fog);
1323 break;
1324 case FDM_EYE_PLANE: /* Z = Ze */
1325 input = get_eye_position_z(p);
1326 emit_op1(p, OPCODE_MOV, fog, WRITEMASK_X, input);
1327 break;
1328 case FDM_EYE_PLANE_ABS: /* Z = abs(Ze) */
1329 input = get_eye_position_z(p);
1330 emit_op1(p, OPCODE_ABS, fog, WRITEMASK_X, input);
1331 break;
1332 default: assert(0); break; /* can't happen */
1333 }
1334
1335 }
1336 else {
1337 input = swizzle1(register_input(p, VERT_ATTRIB_FOG), X);
1338 emit_op1(p, OPCODE_ABS, fog, WRITEMASK_X, input);
1339 }
1340
1341 emit_op1(p, OPCODE_MOV, fog, WRITEMASK_YZW, get_identity_param(p));
1342 }
1343
1344
build_reflect_texgen(struct tnl_program * p,struct ureg dest,GLuint writemask)1345 static void build_reflect_texgen( struct tnl_program *p,
1346 struct ureg dest,
1347 GLuint writemask )
1348 {
1349 struct ureg normal = get_transformed_normal(p);
1350 struct ureg eye_hat = get_eye_position_normalized(p);
1351 struct ureg tmp = get_temp(p);
1352
1353 /* n.u */
1354 emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
1355 /* 2n.u */
1356 emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
1357 /* (-2n.u)n + u */
1358 emit_op3(p, OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
1359
1360 release_temp(p, tmp);
1361 }
1362
1363
build_sphere_texgen(struct tnl_program * p,struct ureg dest,GLuint writemask)1364 static void build_sphere_texgen( struct tnl_program *p,
1365 struct ureg dest,
1366 GLuint writemask )
1367 {
1368 struct ureg normal = get_transformed_normal(p);
1369 struct ureg eye_hat = get_eye_position_normalized(p);
1370 struct ureg tmp = get_temp(p);
1371 struct ureg half = register_scalar_const(p, .5);
1372 struct ureg r = get_temp(p);
1373 struct ureg inv_m = get_temp(p);
1374 struct ureg id = get_identity_param(p);
1375
1376 /* Could share the above calculations, but it would be
1377 * a fairly odd state for someone to set (both sphere and
1378 * reflection active for different texture coordinate
1379 * components. Of course - if two texture units enable
1380 * reflect and/or sphere, things start to tilt in favour
1381 * of seperating this out:
1382 */
1383
1384 /* n.u */
1385 emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
1386 /* 2n.u */
1387 emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
1388 /* (-2n.u)n + u */
1389 emit_op3(p, OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
1390 /* r + 0,0,1 */
1391 emit_op2(p, OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
1392 /* rx^2 + ry^2 + (rz+1)^2 */
1393 emit_op2(p, OPCODE_DP3, tmp, 0, tmp, tmp);
1394 /* 2/m */
1395 emit_op1(p, OPCODE_RSQ, tmp, 0, tmp);
1396 /* 1/m */
1397 emit_op2(p, OPCODE_MUL, inv_m, 0, tmp, half);
1398 /* r/m + 1/2 */
1399 emit_op3(p, OPCODE_MAD, dest, writemask, r, inv_m, half);
1400
1401 release_temp(p, tmp);
1402 release_temp(p, r);
1403 release_temp(p, inv_m);
1404 }
1405
1406
build_texture_transform(struct tnl_program * p)1407 static void build_texture_transform( struct tnl_program *p )
1408 {
1409 GLuint i, j;
1410
1411 for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
1412
1413 if (!(p->state->fragprog_inputs_read & FRAG_BIT_TEX(i)))
1414 continue;
1415
1416 if (p->state->unit[i].coord_replace)
1417 continue;
1418
1419 if (p->state->unit[i].texgen_enabled ||
1420 p->state->unit[i].texmat_enabled) {
1421
1422 GLuint texmat_enabled = p->state->unit[i].texmat_enabled;
1423 struct ureg out = register_output(p, VERT_RESULT_TEX0 + i);
1424 struct ureg out_texgen = undef;
1425
1426 if (p->state->unit[i].texgen_enabled) {
1427 GLuint copy_mask = 0;
1428 GLuint sphere_mask = 0;
1429 GLuint reflect_mask = 0;
1430 GLuint normal_mask = 0;
1431 GLuint modes[4];
1432
1433 if (texmat_enabled)
1434 out_texgen = get_temp(p);
1435 else
1436 out_texgen = out;
1437
1438 modes[0] = p->state->unit[i].texgen_mode0;
1439 modes[1] = p->state->unit[i].texgen_mode1;
1440 modes[2] = p->state->unit[i].texgen_mode2;
1441 modes[3] = p->state->unit[i].texgen_mode3;
1442
1443 for (j = 0; j < 4; j++) {
1444 switch (modes[j]) {
1445 case TXG_OBJ_LINEAR: {
1446 struct ureg obj = register_input(p, VERT_ATTRIB_POS);
1447 struct ureg plane =
1448 register_param3(p, STATE_TEXGEN, i,
1449 STATE_TEXGEN_OBJECT_S + j);
1450
1451 emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
1452 obj, plane );
1453 break;
1454 }
1455 case TXG_EYE_LINEAR: {
1456 struct ureg eye = get_eye_position(p);
1457 struct ureg plane =
1458 register_param3(p, STATE_TEXGEN, i,
1459 STATE_TEXGEN_EYE_S + j);
1460
1461 emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
1462 eye, plane );
1463 break;
1464 }
1465 case TXG_SPHERE_MAP:
1466 sphere_mask |= WRITEMASK_X << j;
1467 break;
1468 case TXG_REFLECTION_MAP:
1469 reflect_mask |= WRITEMASK_X << j;
1470 break;
1471 case TXG_NORMAL_MAP:
1472 normal_mask |= WRITEMASK_X << j;
1473 break;
1474 case TXG_NONE:
1475 copy_mask |= WRITEMASK_X << j;
1476 }
1477 }
1478
1479 if (sphere_mask) {
1480 build_sphere_texgen(p, out_texgen, sphere_mask);
1481 }
1482
1483 if (reflect_mask) {
1484 build_reflect_texgen(p, out_texgen, reflect_mask);
1485 }
1486
1487 if (normal_mask) {
1488 struct ureg normal = get_transformed_normal(p);
1489 emit_op1(p, OPCODE_MOV, out_texgen, normal_mask, normal );
1490 }
1491
1492 if (copy_mask) {
1493 struct ureg in = register_input(p, VERT_ATTRIB_TEX0+i);
1494 emit_op1(p, OPCODE_MOV, out_texgen, copy_mask, in );
1495 }
1496 }
1497
1498 if (texmat_enabled) {
1499 struct ureg texmat[4];
1500 struct ureg in = (!is_undef(out_texgen) ?
1501 out_texgen :
1502 register_input(p, VERT_ATTRIB_TEX0+i));
1503 if (p->mvp_with_dp4) {
1504 register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3,
1505 0, texmat );
1506 emit_matrix_transform_vec4( p, out, texmat, in );
1507 }
1508 else {
1509 register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3,
1510 STATE_MATRIX_TRANSPOSE, texmat );
1511 emit_transpose_matrix_transform_vec4( p, out, texmat, in );
1512 }
1513 }
1514
1515 release_temps(p);
1516 }
1517 else {
1518 emit_passthrough(p, VERT_ATTRIB_TEX0+i, VERT_RESULT_TEX0+i);
1519 }
1520 }
1521 }
1522
1523
1524 /**
1525 * Point size attenuation computation.
1526 */
build_atten_pointsize(struct tnl_program * p)1527 static void build_atten_pointsize( struct tnl_program *p )
1528 {
1529 struct ureg eye = get_eye_position_z(p);
1530 struct ureg state_size = register_param2(p, STATE_INTERNAL, STATE_POINT_SIZE_CLAMPED);
1531 struct ureg state_attenuation = register_param1(p, STATE_POINT_ATTENUATION);
1532 struct ureg out = register_output(p, VERT_RESULT_PSIZ);
1533 struct ureg ut = get_temp(p);
1534
1535 /* dist = |eyez| */
1536 emit_op1(p, OPCODE_ABS, ut, WRITEMASK_Y, swizzle1(eye, Z));
1537 /* p1 + dist * (p2 + dist * p3); */
1538 emit_op3(p, OPCODE_MAD, ut, WRITEMASK_X, swizzle1(ut, Y),
1539 swizzle1(state_attenuation, Z), swizzle1(state_attenuation, Y));
1540 emit_op3(p, OPCODE_MAD, ut, WRITEMASK_X, swizzle1(ut, Y),
1541 ut, swizzle1(state_attenuation, X));
1542
1543 /* 1 / sqrt(factor) */
1544 emit_op1(p, OPCODE_RSQ, ut, WRITEMASK_X, ut );
1545
1546 #if 0
1547 /* out = pointSize / sqrt(factor) */
1548 emit_op2(p, OPCODE_MUL, out, WRITEMASK_X, ut, state_size);
1549 #else
1550 /* this is a good place to clamp the point size since there's likely
1551 * no hardware registers to clamp point size at rasterization time.
1552 */
1553 emit_op2(p, OPCODE_MUL, ut, WRITEMASK_X, ut, state_size);
1554 emit_op2(p, OPCODE_MAX, ut, WRITEMASK_X, ut, swizzle1(state_size, Y));
1555 emit_op2(p, OPCODE_MIN, out, WRITEMASK_X, ut, swizzle1(state_size, Z));
1556 #endif
1557
1558 release_temp(p, ut);
1559 }
1560
1561
1562 /**
1563 * Pass-though per-vertex point size, from user's point size array.
1564 */
build_array_pointsize(struct tnl_program * p)1565 static void build_array_pointsize( struct tnl_program *p )
1566 {
1567 struct ureg in = register_input(p, VERT_ATTRIB_POINT_SIZE);
1568 struct ureg out = register_output(p, VERT_RESULT_PSIZ);
1569 emit_op1(p, OPCODE_MOV, out, WRITEMASK_X, in);
1570 }
1571
1572
build_tnl_program(struct tnl_program * p)1573 static void build_tnl_program( struct tnl_program *p )
1574 {
1575 /* Emit the program, starting with the modelview, projection transforms:
1576 */
1577 build_hpos(p);
1578
1579 /* Lighting calculations:
1580 */
1581 if (p->state->fragprog_inputs_read & (FRAG_BIT_COL0|FRAG_BIT_COL1)) {
1582 if (p->state->light_global_enabled)
1583 build_lighting(p);
1584 else {
1585 if (p->state->fragprog_inputs_read & FRAG_BIT_COL0)
1586 emit_passthrough(p, VERT_ATTRIB_COLOR0, VERT_RESULT_COL0);
1587
1588 if (p->state->fragprog_inputs_read & FRAG_BIT_COL1)
1589 emit_passthrough(p, VERT_ATTRIB_COLOR1, VERT_RESULT_COL1);
1590 }
1591 }
1592
1593 if (p->state->fragprog_inputs_read & FRAG_BIT_FOGC)
1594 build_fog(p);
1595
1596 if (p->state->fragprog_inputs_read & FRAG_BITS_TEX_ANY)
1597 build_texture_transform(p);
1598
1599 if (p->state->point_attenuated)
1600 build_atten_pointsize(p);
1601 else if (p->state->point_array)
1602 build_array_pointsize(p);
1603
1604 /* Finish up:
1605 */
1606 emit_op1(p, OPCODE_END, undef, 0, undef);
1607
1608 /* Disassemble:
1609 */
1610 if (DISASSEM) {
1611 printf ("\n");
1612 }
1613 }
1614
1615
1616 static void
create_new_program(const struct state_key * key,struct gl_vertex_program * program,GLboolean mvp_with_dp4,GLuint max_temps)1617 create_new_program( const struct state_key *key,
1618 struct gl_vertex_program *program,
1619 GLboolean mvp_with_dp4,
1620 GLuint max_temps)
1621 {
1622 struct tnl_program p;
1623
1624 memset(&p, 0, sizeof(p));
1625 p.state = key;
1626 p.program = program;
1627 p.eye_position = undef;
1628 p.eye_position_z = undef;
1629 p.eye_position_normalized = undef;
1630 p.transformed_normal = undef;
1631 p.identity = undef;
1632 p.temp_in_use = 0;
1633 p.mvp_with_dp4 = mvp_with_dp4;
1634
1635 if (max_temps >= sizeof(int) * 8)
1636 p.temp_reserved = 0;
1637 else
1638 p.temp_reserved = ~((1<<max_temps)-1);
1639
1640 /* Start by allocating 32 instructions.
1641 * If we need more, we'll grow the instruction array as needed.
1642 */
1643 p.max_inst = 32;
1644 p.program->Base.Instructions = _mesa_alloc_instructions(p.max_inst);
1645 p.program->Base.String = NULL;
1646 p.program->Base.NumInstructions =
1647 p.program->Base.NumTemporaries =
1648 p.program->Base.NumParameters =
1649 p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0;
1650 p.program->Base.Parameters = _mesa_new_parameter_list();
1651 p.program->Base.InputsRead = 0;
1652 p.program->Base.OutputsWritten = 0;
1653
1654 build_tnl_program( &p );
1655 }
1656
1657
1658 /**
1659 * Return a vertex program which implements the current fixed-function
1660 * transform/lighting/texgen operations.
1661 */
1662 struct gl_vertex_program *
_mesa_get_fixed_func_vertex_program(struct gl_context * ctx)1663 _mesa_get_fixed_func_vertex_program(struct gl_context *ctx)
1664 {
1665 struct gl_vertex_program *prog;
1666 struct state_key key;
1667
1668 /* Grab all the relevent state and put it in a single structure:
1669 */
1670 make_state_key(ctx, &key);
1671
1672 /* Look for an already-prepared program for this state:
1673 */
1674 prog = gl_vertex_program(
1675 _mesa_search_program_cache(ctx->VertexProgram.Cache, &key, sizeof(key)));
1676
1677 if (!prog) {
1678 /* OK, we'll have to build a new one */
1679 if (0)
1680 printf("Build new TNL program\n");
1681
1682 prog = gl_vertex_program(ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0));
1683 if (!prog)
1684 return NULL;
1685
1686 create_new_program( &key, prog,
1687 ctx->mvp_with_dp4,
1688 ctx->Const.VertexProgram.MaxTemps );
1689
1690 #if 0
1691 if (ctx->Driver.ProgramStringNotify)
1692 ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB,
1693 &prog->Base );
1694 #endif
1695 _mesa_program_cache_insert(ctx, ctx->VertexProgram.Cache,
1696 &key, sizeof(key), &prog->Base);
1697 }
1698
1699 return prog;
1700 }
1701