reactos/lib/mesa32/src/tnl/t_vp_build.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.3.1
   4  *
   5  * Copyright (C) 2005  Tungsten Graphics   All Rights Reserved.
   6  *
   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:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  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,
  21  * WHETHER IN
  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.
  24  */
  25
  26 /**
  27  * \file t_vp_build.c
  28  * Create a vertex program to execute the current fixed function T&L pipeline.
  29  * \author Keith Whitwell
  30  */
  31
  32
  33 #include "glheader.h"
  34 #include "macros.h"
  35 #include "enums.h"
  36 #include "t_context.h"
  37 #include "t_vp_build.h"
  38
  39 #include "shader/program.h"
  40 #include "shader/nvvertprog.h"
  41 #include "shader/arbvertparse.h"
  42
  43 struct state_key {
  44    unsigned light_global_enabled:1;
  45    unsigned light_local_viewer:1;
  46    unsigned light_twoside:1;
  47    unsigned light_color_material:1;
  48    unsigned light_color_material_mask:12;
  49    unsigned light_material_mask:12;
  50
  51    unsigned normalize:1;
  52    unsigned rescale_normals:1;
  53    unsigned fog_source_is_depth:1;
  54    unsigned tnl_do_vertex_fog:1;
  55    unsigned separate_specular:1;
  56    unsigned fog_enabled:1;
  57    unsigned fog_mode:2;
  58    unsigned point_attenuated:1;
  59    unsigned texture_enabled_global:1;
  60
  61    struct {
  62       unsigned light_enabled:1;
  63       unsigned light_eyepos3_is_zero:1;
  64       unsigned light_spotcutoff_is_180:1;
  65       unsigned light_attenuated:1;
  66       unsigned texunit_really_enabled:1;
  67       unsigned texmat_enabled:1;
  68       unsigned texgen_enabled:4;
  69       unsigned texgen_mode0:4;
  70       unsigned texgen_mode1:4;
  71       unsigned texgen_mode2:4;
  72       unsigned texgen_mode3:4;
  73    } unit[8];
  74 };
  75
  76
  77
  78 #define FOG_LINEAR   0
  79 #define FOG_EXP      1
  80 #define FOG_EXP2     2
  81 #define FOG_UNKNOWN  3
  82
  83 static GLuint translate_fog_mode( GLenum mode )
  84 {
  85    switch (mode) {
  86    case GL_LINEAR: return FOG_LINEAR;
  87    case GL_EXP: return FOG_EXP;
  88    case GL_EXP2: return FOG_EXP2;
  89    default: return FOG_UNKNOWN;
  90    }
  91 }
  92
  93 #define TXG_NONE           0
  94 #define TXG_OBJ_LINEAR     1
  95 #define TXG_EYE_LINEAR     2
  96 #define TXG_SPHERE_MAP     3
  97 #define TXG_REFLECTION_MAP 4
  98 #define TXG_NORMAL_MAP     5
  99
 100 static GLuint translate_texgen( GLboolean enabled, GLenum mode )
 101 {
 102    if (!enabled)
 103       return TXG_NONE;
 104
 105    switch (mode) {
 106    case GL_OBJECT_LINEAR: return TXG_OBJ_LINEAR;
 107    case GL_EYE_LINEAR: return TXG_EYE_LINEAR;
 108    case GL_SPHERE_MAP: return TXG_SPHERE_MAP;
 109    case GL_REFLECTION_MAP_NV: return TXG_REFLECTION_MAP;
 110    case GL_NORMAL_MAP_NV: return TXG_NORMAL_MAP;
 111    default: return TXG_NONE;
 112    }
 113 }
 114
 115 static struct state_key *make_state_key( GLcontext *ctx )
 116 {
 117    TNLcontext *tnl = TNL_CONTEXT(ctx);
 118    struct vertex_buffer *VB = &tnl->vb;
 119    struct state_key *key = CALLOC_STRUCT(state_key);
 120    GLuint i;
 121
 122    key->separate_specular = (ctx->Light.Model.ColorControl ==
 123                              GL_SEPARATE_SPECULAR_COLOR);
 124
 125    if (ctx->Light.Enabled) {
 126       key->light_global_enabled = 1;
 127
 128       if (ctx->Light.Model.LocalViewer)
 129          key->light_local_viewer = 1;
 130
 131       if (ctx->Light.Model.TwoSide)
 132          key->light_twoside = 1;
 133
 134       if (ctx->Light.ColorMaterialEnabled) {
 135          key->light_color_material = 1;
 136          key->light_color_material_mask = ctx->Light.ColorMaterialBitmask;
 137       }
 138
 139       for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT ; i < _TNL_ATTRIB_INDEX ; i++)
 140          if (VB->AttribPtr[i]->stride)
 141             key->light_material_mask |= 1<<(i-_TNL_ATTRIB_MAT_FRONT_AMBIENT);
 142
 143       for (i = 0; i < MAX_LIGHTS; i++) {
 144          struct gl_light *light = &ctx->Light.Light[i];
 145
 146          if (light->Enabled) {
 147             key->unit[i].light_enabled = 1;
 148
 149             if (light->EyePosition[3] == 0.0)
 150                key->unit[i].light_eyepos3_is_zero = 1;
 151
 152             if (light->SpotCutoff == 180.0)
 153                key->unit[i].light_spotcutoff_is_180 = 1;
 154
 155             if (light->ConstantAttenuation != 1.0 ||
 156                 light->LinearAttenuation != 0.0 ||
 157                 light->QuadraticAttenuation != 0.0)
 158                key->unit[i].light_attenuated = 1;
 159          }
 160       }
 161    }
 162
 163    if (ctx->Transform.Normalize)
 164       key->normalize = 1;
 165
 166    if (ctx->Transform.RescaleNormals)
 167       key->rescale_normals = 1;
 168
 169    if (ctx->Fog.Enabled)
 170       key->fog_enabled = 1;
 171
 172    if (key->fog_enabled) {
 173       if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT)
 174          key->fog_source_is_depth = 1;
 175
 176       if (tnl->_DoVertexFog)
 177          key->tnl_do_vertex_fog = 1;
 178
 179       key->fog_mode = translate_fog_mode(ctx->Fog.Mode);
 180    }
 181
 182    if (ctx->Point._Attenuated)
 183       key->point_attenuated = 1;
 184
 185    if (ctx->Texture._TexGenEnabled ||
 186        ctx->Texture._TexMatEnabled ||
 187        ctx->Texture._EnabledUnits)
 188       key->texture_enabled_global = 1;
 189
 190    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
 191       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
 192
 193       if (texUnit->_ReallyEnabled)
 194          key->unit[i].texunit_really_enabled = 1;
 195
 196       if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
 197          key->unit[i].texmat_enabled = 1;
 198
 199       if (texUnit->TexGenEnabled) {
 200          key->unit[i].texgen_enabled = 1;
 201
 202          key->unit[i].texgen_mode0 =
 203             translate_texgen( texUnit->TexGenEnabled & (1<<0),
 204                               texUnit->GenModeS );
 205          key->unit[i].texgen_mode1 =
 206             translate_texgen( texUnit->TexGenEnabled & (1<<1),
 207                               texUnit->GenModeT );
 208          key->unit[i].texgen_mode2 =
 209             translate_texgen( texUnit->TexGenEnabled & (1<<2),
 210                               texUnit->GenModeR );
 211          key->unit[i].texgen_mode3 =
 212             translate_texgen( texUnit->TexGenEnabled & (1<<3),
 213                               texUnit->GenModeQ );
 214       }
 215    }
 216
 217    return key;
 218 }
 219
 220
 221
 222 /* Very useful debugging tool - produces annotated listing of
 223  * generated program with line/function references for each
 224  * instruction back into this file:
 225  */
 226 #define DISASSEM (MESA_VERBOSE&VERBOSE_DISASSEM)
 227
 228 /* Should be tunable by the driver - do we want to do matrix
 229  * multiplications with DP4's or with MUL/MAD's?  SSE works better
 230  * with the latter, drivers may differ.
 231  */
 232 #define PREFER_DP4 0
 233
 234 #define MAX_INSN 200
 235
 236 /* Use uregs to represent registers internally, translate to Mesa's
 237  * expected formats on emit.
 238  *
 239  * NOTE: These are passed by value extensively in this file rather
 240  * than as usual by pointer reference.  If this disturbs you, try
 241  * remembering they are just 32bits in size.
 242  *
 243  * GCC is smart enough to deal with these dword-sized structures in
 244  * much the same way as if I had defined them as dwords and was using
 245  * macros to access and set the fields.  This is much nicer and easier
 246  * to evolve.
 247  */
 248 struct ureg {
 249    GLuint file:4;
 250    GLint idx:8;      /* relative addressing may be negative */
 251    GLuint negate:1;
 252    GLuint swz:12;
 253    GLuint pad:7;
 254 };
 255
 256
 257 struct tnl_program {
 258    const struct state_key *state;
 259    struct vertex_program *program;
 260
 261    GLuint temp_in_use;
 262    GLuint temp_reserved;
 263
 264    struct ureg eye_position;
 265    struct ureg eye_position_normalized;
 266    struct ureg eye_normal;
 267    struct ureg identity;
 268
 269    GLuint materials;
 270    GLuint color_materials;
 271 };
 272
 273
 274 const static struct ureg undef = {
 275    ~0,
 276    ~0,
 277    0,
 278    0,
 279    0
 280 };
 281
 282 /* Local shorthand:
 283  */
 284 #define X    SWIZZLE_X
 285 #define Y    SWIZZLE_Y
 286 #define Z    SWIZZLE_Z
 287 #define W    SWIZZLE_W
 288
 289
 290 /* Construct a ureg:
 291  */
 292 static struct ureg make_ureg(GLuint file, GLint idx)
 293 {
 294    struct ureg reg;
 295    reg.file = file;
 296    reg.idx = idx;
 297    reg.negate = 0;
 298    reg.swz = SWIZZLE_NOOP;
 299    reg.pad = 0;
 300    return reg;
 301 }
 302
 303
 304
 305 static struct ureg negate( struct ureg reg )
 306 {
 307    reg.negate ^= 1;
 308    return reg;
 309 }
 310
 311
 312 static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
 313 {
 314    reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
 315                            GET_SWZ(reg.swz, y),
 316                            GET_SWZ(reg.swz, z),
 317                            GET_SWZ(reg.swz, w));
 318
 319    return reg;
 320 }
 321
 322 static struct ureg swizzle1( struct ureg reg, int x )
 323 {
 324    return swizzle(reg, x, x, x, x);
 325 }
 326
 327 static struct ureg get_temp( struct tnl_program *p )
 328 {
 329    int bit = ffs( ~p->temp_in_use );
 330    if (!bit) {
 331       fprintf(stderr, "%s: out of temporaries\n", __FILE__);
 332       exit(1);
 333    }
 334
 335    p->temp_in_use |= 1<<(bit-1);
 336    return make_ureg(PROGRAM_TEMPORARY, bit-1);
 337 }
 338
 339 static struct ureg reserve_temp( struct tnl_program *p )
 340 {
 341    struct ureg temp = get_temp( p );
 342    p->temp_reserved |= 1<<temp.idx;
 343    return temp;
 344 }
 345
 346 static void release_temp( struct tnl_program *p, struct ureg reg )
 347 {
 348    if (reg.file == PROGRAM_TEMPORARY) {
 349       p->temp_in_use &= ~(1<<reg.idx);
 350       p->temp_in_use |= p->temp_reserved; /* can't release reserved temps */
 351    }
 352 }
 353
 354 static void release_temps( struct tnl_program *p )
 355 {
 356    p->temp_in_use = p->temp_reserved;
 357 }
 358
 359
 360
 361 static struct ureg register_input( struct tnl_program *p, GLuint input )
 362 {
 363    p->program->InputsRead |= (1<<input);
 364    return make_ureg(PROGRAM_INPUT, input);
 365 }
 366
 367 static struct ureg register_output( struct tnl_program *p, GLuint output )
 368 {
 369    p->program->OutputsWritten |= (1<<output);
 370    return make_ureg(PROGRAM_OUTPUT, output);
 371 }
 372
 373 static struct ureg register_const4f( struct tnl_program *p,
 374                               GLfloat s0,
 375                               GLfloat s1,
 376                               GLfloat s2,
 377                               GLfloat s3)
 378 {
 379    GLfloat values[4];
 380    GLint idx;
 381    values[0] = s0;
 382    values[1] = s1;
 383    values[2] = s2;
 384    values[3] = s3;
 385    idx = _mesa_add_unnamed_constant( p->program->Parameters, values );
 386    return make_ureg(PROGRAM_STATE_VAR, idx);
 387 }
 388
 389 #define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)
 390 #define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
 391 #define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)
 392 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
 393
 394 static GLboolean is_undef( struct ureg reg )
 395 {
 396    return reg.file == 0xf;
 397 }
 398
 399 static struct ureg get_identity_param( struct tnl_program *p )
 400 {
 401    if (is_undef(p->identity))
 402       p->identity = register_const4f(p, 0,0,0,1);
 403
 404    return p->identity;
 405 }
 406
 407 static struct ureg register_param6( struct tnl_program *p,
 408                                    GLint s0,
 409                                    GLint s1,
 410                                    GLint s2,
 411                                    GLint s3,
 412                                    GLint s4,
 413                                    GLint s5)
 414 {
 415    GLint tokens[6];
 416    GLint idx;
 417    tokens[0] = s0;
 418    tokens[1] = s1;
 419    tokens[2] = s2;
 420    tokens[3] = s3;
 421    tokens[4] = s4;
 422    tokens[5] = s5;
 423    idx = _mesa_add_state_reference( p->program->Parameters, tokens );
 424    return make_ureg(PROGRAM_STATE_VAR, idx);
 425 }
 426
 427
 428 #define register_param1(p,s0)          register_param6(p,s0,0,0,0,0,0)
 429 #define register_param2(p,s0,s1)       register_param6(p,s0,s1,0,0,0,0)
 430 #define register_param3(p,s0,s1,s2)    register_param6(p,s0,s1,s2,0,0,0)
 431 #define register_param4(p,s0,s1,s2,s3) register_param6(p,s0,s1,s2,s3,0,0)
 432
 433
 434 static void register_matrix_param6( struct tnl_program *p,
 435                                     GLint s0,
 436                                     GLint s1,
 437                                     GLint s2,
 438                                     GLint s3,
 439                                     GLint s4,
 440                                     GLint s5,
 441                                     struct ureg *matrix )
 442 {
 443    GLuint i;
 444
 445    /* This is a bit sad as the support is there to pull the whole
 446     * matrix out in one go:
 447     */
 448    for (i = 0; i <= s4 - s3; i++)
 449       matrix[i] = register_param6( p, s0, s1, s2, i, i, s5 );
 450 }
 451
 452
 453 static void emit_arg( struct vp_src_register *src,
 454                       struct ureg reg )
 455 {
 456    src->File = reg.file;
 457    src->Index = reg.idx;
 458    src->Swizzle = reg.swz;
 459    src->Negate = reg.negate;
 460    src->RelAddr = 0;
 461    src->pad = 0;
 462 }
 463
 464 static void emit_dst( struct vp_dst_register *dst,
 465                       struct ureg reg, GLuint mask )
 466 {
 467    dst->File = reg.file;
 468    dst->Index = reg.idx;
 469    /* allow zero as a shorthand for xyzw */
 470    dst->WriteMask = mask ? mask : WRITEMASK_XYZW;
 471    dst->pad = 0;
 472 }
 473
 474 static void debug_insn( struct vp_instruction *inst, const char *fn,
 475                         GLuint line )
 476 {
 477    if (DISASSEM) {
 478       static const char *last_fn;
 479
 480       if (fn != last_fn) {
 481          last_fn = fn;
 482          _mesa_printf("%s:\n", fn);
 483       }
 484
 485       _mesa_printf("%d:\t", line);
 486       _mesa_debug_vp_inst(1, inst);
 487    }
 488 }
 489
 490
 491 static void emit_op3fn(struct tnl_program *p,
 492                        GLuint op,
 493                        struct ureg dest,
 494                        GLuint mask,
 495                        struct ureg src0,
 496                        struct ureg src1,
 497                        struct ureg src2,
 498                        const char *fn,
 499                        GLuint line)
 500 {
 501    GLuint nr = p->program->Base.NumInstructions++;
 502    struct vp_instruction *inst = &p->program->Instructions[nr];
 503
 504    if (p->program->Base.NumInstructions > MAX_INSN) {
 505       _mesa_problem(0, "Out of instructions in emit_op3fn\n");
 506       return;
 507    }
 508
 509    inst->Opcode = op;
 510    inst->StringPos = 0;
 511    inst->Data = 0;
 512
 513    emit_arg( &inst->SrcReg[0], src0 );
 514    emit_arg( &inst->SrcReg[1], src1 );
 515    emit_arg( &inst->SrcReg[2], src2 );
 516
 517    emit_dst( &inst->DstReg, dest, mask );
 518
 519    debug_insn(inst, fn, line);
 520 }
 521
 522
 523 #define emit_op3(p, op, dst, mask, src0, src1, src2) \
 524    emit_op3fn(p, op, dst, mask, src0, src1, src2, __FUNCTION__, __LINE__)
 525
 526 #define emit_op2(p, op, dst, mask, src0, src1) \
 527     emit_op3fn(p, op, dst, mask, src0, src1, undef, __FUNCTION__, __LINE__)
 528
 529 #define emit_op1(p, op, dst, mask, src0) \
 530     emit_op3fn(p, op, dst, mask, src0, undef, undef, __FUNCTION__, __LINE__)
 531
 532
 533 static struct ureg make_temp( struct tnl_program *p, struct ureg reg )
 534 {
 535    if (reg.file == PROGRAM_TEMPORARY &&
 536        !(p->temp_reserved & (1<<reg.idx)))
 537       return reg;
 538    else {
 539       struct ureg temp = get_temp(p);
 540       emit_op1(p, VP_OPCODE_MOV, temp, 0, reg);
 541       return temp;
 542    }
 543 }
 544
 545
 546 /* Currently no tracking performed of input/output/register size or
 547  * active elements.  Could be used to reduce these operations, as
 548  * could the matrix type.
 549  */
 550 static void emit_matrix_transform_vec4( struct tnl_program *p,
 551                                         struct ureg dest,
 552                                         const struct ureg *mat,
 553                                         struct ureg src)
 554 {
 555    emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_X, src, mat[0]);
 556    emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_Y, src, mat[1]);
 557    emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_Z, src, mat[2]);
 558    emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_W, src, mat[3]);
 559 }
 560
 561 /* This version is much easier to implement if writemasks are not
 562  * supported natively on the target or (like SSE), the target doesn't
 563  * have a clean/obvious dotproduct implementation.
 564  */
 565 static void emit_transpose_matrix_transform_vec4( struct tnl_program *p,
 566                                                   struct ureg dest,
 567                                                   const struct ureg *mat,
 568                                                   struct ureg src)
 569 {
 570    struct ureg tmp;
 571
 572    if (dest.file != PROGRAM_TEMPORARY)
 573       tmp = get_temp(p);
 574    else
 575       tmp = dest;
 576
 577    emit_op2(p, VP_OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
 578    emit_op3(p, VP_OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
 579    emit_op3(p, VP_OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
 580    emit_op3(p, VP_OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
 581
 582    if (dest.file != PROGRAM_TEMPORARY)
 583       release_temp(p, tmp);
 584 }
 585
 586 static void emit_matrix_transform_vec3( struct tnl_program *p,
 587                                         struct ureg dest,
 588                                         const struct ureg *mat,
 589                                         struct ureg src)
 590 {
 591    emit_op2(p, VP_OPCODE_DP3, dest, WRITEMASK_X, src, mat[0]);
 592    emit_op2(p, VP_OPCODE_DP3, dest, WRITEMASK_Y, src, mat[1]);
 593    emit_op2(p, VP_OPCODE_DP3, dest, WRITEMASK_Z, src, mat[2]);
 594 }
 595
 596
 597 static void emit_normalize_vec3( struct tnl_program *p,
 598                                  struct ureg dest,
 599                                  struct ureg src )
 600 {
 601    struct ureg tmp = get_temp(p);
 602    emit_op2(p, VP_OPCODE_DP3, tmp, 0, src, src);
 603    emit_op1(p, VP_OPCODE_RSQ, tmp, 0, tmp);
 604    emit_op2(p, VP_OPCODE_MUL, dest, 0, src, tmp);
 605    release_temp(p, tmp);
 606 }
 607
 608 static void emit_passthrough( struct tnl_program *p,
 609                               GLuint input,
 610                               GLuint output )
 611 {
 612    struct ureg out = register_output(p, output);
 613    emit_op1(p, VP_OPCODE_MOV, out, 0, register_input(p, input));
 614 }
 615
 616 static struct ureg get_eye_position( struct tnl_program *p )
 617 {
 618    if (is_undef(p->eye_position)) {
 619       struct ureg pos = register_input( p, VERT_ATTRIB_POS );
 620       struct ureg modelview[4];
 621
 622       p->eye_position = reserve_temp(p);
 623
 624       if (PREFER_DP4) {
 625          register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 3,
 626                                  STATE_MATRIX, modelview );
 627
 628          emit_matrix_transform_vec4(p, p->eye_position, modelview, pos);
 629       }
 630       else {
 631          register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 3,
 632                                  STATE_MATRIX_TRANSPOSE, modelview );
 633
 634          emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos);
 635       }
 636    }
 637
 638    return p->eye_position;
 639 }
 640
 641
 642 static struct ureg get_eye_position_normalized( struct tnl_program *p )
 643 {
 644    if (is_undef(p->eye_position_normalized)) {
 645       struct ureg eye = get_eye_position(p);
 646       p->eye_position_normalized = reserve_temp(p);
 647       emit_normalize_vec3(p, p->eye_position_normalized, eye);
 648    }
 649
 650    return p->eye_position_normalized;
 651 }
 652
 653
 654 static struct ureg get_eye_normal( struct tnl_program *p )
 655 {
 656    if (is_undef(p->eye_normal)) {
 657       struct ureg normal = register_input(p, VERT_ATTRIB_NORMAL );
 658       struct ureg mvinv[3];
 659
 660       register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 2,
 661                               STATE_MATRIX_INVTRANS, mvinv );
 662
 663       p->eye_normal = reserve_temp(p);
 664
 665       /* Transform to eye space:
 666        */
 667       emit_matrix_transform_vec3( p, p->eye_normal, mvinv, normal );
 668
 669       /* Normalize/Rescale:
 670        */
 671       if (p->state->normalize) {
 672          emit_normalize_vec3( p, p->eye_normal, p->eye_normal );
 673       }
 674       else if (p->state->rescale_normals) {
 675          struct ureg rescale = register_param2(p, STATE_INTERNAL,
 676                                                STATE_NORMAL_SCALE);
 677
 678          emit_op2( p, VP_OPCODE_MUL, p->eye_normal, 0, normal,
 679                    swizzle1(rescale, X));
 680       }
 681    }
 682
 683    return p->eye_normal;
 684 }
 685
 686
 687
 688 static void build_hpos( struct tnl_program *p )
 689 {
 690    struct ureg pos = register_input( p, VERT_ATTRIB_POS );
 691    struct ureg hpos = register_output( p, VERT_RESULT_HPOS );
 692    struct ureg mvp[4];
 693
 694    if (PREFER_DP4) {
 695       register_matrix_param6( p, STATE_MATRIX, STATE_MVP, 0, 0, 3,
 696                               STATE_MATRIX, mvp );
 697       emit_matrix_transform_vec4( p, hpos, mvp, pos );
 698    }
 699    else {
 700       register_matrix_param6( p, STATE_MATRIX, STATE_MVP, 0, 0, 3,
 701                               STATE_MATRIX_TRANSPOSE, mvp );
 702       emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos );
 703    }
 704 }
 705
 706
 707 static GLuint material_attrib( GLuint side, GLuint property )
 708 {
 709    return ((property - STATE_AMBIENT) * 2 +
 710            side);
 711 }
 712
 713 static void set_material_flags( struct tnl_program *p )
 714 {
 715    p->color_materials = 0;
 716    p->materials = 0;
 717
 718    if (p->state->light_color_material) {
 719       p->materials =
 720          p->color_materials = p->state->light_color_material_mask;
 721    }
 722
 723    p->materials |= p->state->light_material_mask;
 724 }
 725
 726
 727 static struct ureg get_material( struct tnl_program *p, GLuint side,
 728                                  GLuint property )
 729 {
 730    GLuint attrib = material_attrib(side, property);
 731
 732    if (p->color_materials & (1<<attrib))
 733       return register_input(p, VERT_ATTRIB_COLOR0);
 734    else if (p->materials & (1<<attrib))
 735       return register_input( p, attrib + _TNL_ATTRIB_MAT_FRONT_AMBIENT );
 736    else
 737       return register_param3( p, STATE_MATERIAL, side, property );
 738 }
 739
 740 #define SCENE_COLOR_BITS(side) (( MAT_BIT_FRONT_EMISSION | \
 741                                    MAT_BIT_FRONT_AMBIENT | \
 742                                    MAT_BIT_FRONT_DIFFUSE) << (side))
 743
 744 /* Either return a precalculated constant value or emit code to
 745  * calculate these values dynamically in the case where material calls
 746  * are present between begin/end pairs.
 747  *
 748  * Probably want to shift this to the program compilation phase - if
 749  * we always emitted the calculation here, a smart compiler could
 750  * detect that it was constant (given a certain set of inputs), and
 751  * lift it out of the main loop.  That way the programs created here
 752  * would be independent of the vertex_buffer details.
 753  */
 754 static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
 755 {
 756    if (p->materials & SCENE_COLOR_BITS(side)) {
 757       struct ureg lm_ambient = register_param1(p, STATE_LIGHTMODEL_AMBIENT);
 758       struct ureg material_emission = get_material(p, side, STATE_EMISSION);
 759       struct ureg material_ambient = get_material(p, side, STATE_AMBIENT);
 760       struct ureg material_diffuse = get_material(p, side, STATE_DIFFUSE);
 761       struct ureg tmp = make_temp(p, material_diffuse);
 762       emit_op3(p, VP_OPCODE_MAD, tmp,  WRITEMASK_XYZ, lm_ambient,
 763                material_ambient, material_emission);
 764       return tmp;
 765    }
 766    else
 767       return register_param2( p, STATE_LIGHTMODEL_SCENECOLOR, side );
 768 }
 769
 770
 771 static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
 772                                   GLuint side, GLuint property )
 773 {
 774    GLuint attrib = material_attrib(side, property);
 775    if (p->materials & (1<<attrib)) {
 776       struct ureg light_value =
 777          register_param3(p, STATE_LIGHT, light, property);
 778       struct ureg material_value = get_material(p, side, property);
 779       struct ureg tmp = get_temp(p);
 780       emit_op2(p, VP_OPCODE_MUL, tmp,  0, light_value, material_value);
 781       return tmp;
 782    }
 783    else
 784       return register_param4(p, STATE_LIGHTPROD, light, side, property);
 785 }
 786
 787 static struct ureg calculate_light_attenuation( struct tnl_program *p,
 788                                                 GLuint i,
 789                                                 struct ureg VPpli,
 790                                                 struct ureg dist )
 791 {
 792    struct ureg attenuation = register_param3(p, STATE_LIGHT, i,
 793                                              STATE_ATTENUATION);
 794    struct ureg att = get_temp(p);
 795
 796    /* Calculate spot attenuation:
 797     */
 798    if (!p->state->unit[i].light_spotcutoff_is_180) {
 799       struct ureg spot_dir = register_param3(p, STATE_LIGHT, i,
 800                                              STATE_SPOT_DIRECTION);
 801       struct ureg spot = get_temp(p);
 802       struct ureg slt = get_temp(p);
 803
 804       emit_normalize_vec3( p, spot, spot_dir ); /* XXX: precompute! */
 805       emit_op2(p, VP_OPCODE_DP3, spot, 0, negate(VPpli), spot);
 806       emit_op2(p, VP_OPCODE_SLT, slt, 0, swizzle1(spot_dir,W), spot);
 807       emit_op2(p, VP_OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
 808       emit_op2(p, VP_OPCODE_MUL, att, 0, slt, spot);
 809
 810       release_temp(p, spot);
 811       release_temp(p, slt);
 812    }
 813
 814    /* Calculate distance attenuation:
 815     */
 816    if (p->state->unit[i].light_attenuated) {
 817
 818       /* 1/d,d,d,1/d */
 819       emit_op1(p, VP_OPCODE_RCP, dist, WRITEMASK_YZ, dist);
 820       /* 1,d,d*d,1/d */
 821       emit_op2(p, VP_OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
 822       /* 1/dist-atten */
 823       emit_op2(p, VP_OPCODE_DP3, dist, 0, attenuation, dist);
 824
 825       if (!p->state->unit[i].light_spotcutoff_is_180) {
 826          /* dist-atten */
 827          emit_op1(p, VP_OPCODE_RCP, dist, 0, dist);
 828          /* spot-atten * dist-atten */
 829          emit_op2(p, VP_OPCODE_MUL, att, 0, dist, att);
 830       } else {
 831          /* dist-atten */
 832          emit_op1(p, VP_OPCODE_RCP, att, 0, dist);
 833       }
 834    }
 835
 836    return att;
 837 }
 838
 839
 840
 841
 842
 843 /* Need to add some addtional parameters to allow lighting in object
 844  * space - STATE_SPOT_DIRECTION and STATE_HALF implicitly assume eye
 845  * space lighting.
 846  */
 847 static void build_lighting( struct tnl_program *p )
 848 {
 849    const GLboolean twoside = p->state->light_twoside;
 850    const GLboolean separate = p->state->separate_specular;
 851    GLuint nr_lights = 0, count = 0;
 852    struct ureg normal = get_eye_normal(p);
 853    struct ureg lit = get_temp(p);
 854    struct ureg dots = get_temp(p);
 855    struct ureg _col0 = undef, _col1 = undef;
 856    struct ureg _bfc0 = undef, _bfc1 = undef;
 857    GLuint i;
 858
 859    for (i = 0; i < MAX_LIGHTS; i++)
 860       if (p->state->unit[i].light_enabled)
 861          nr_lights++;
 862
 863    set_material_flags(p);
 864
 865    {
 866       struct ureg shininess = get_material(p, 0, STATE_SHININESS);
 867       emit_op1(p, VP_OPCODE_MOV, dots,  WRITEMASK_W, swizzle1(shininess,X));
 868       release_temp(p, shininess);
 869
 870       _col0 = make_temp(p, get_scenecolor(p, 0));
 871       if (separate)
 872          _col1 = make_temp(p, get_identity_param(p));
 873       else
 874          _col1 = _col0;
 875
 876    }
 877
 878    if (twoside) {
 879       struct ureg shininess = get_material(p, 1, STATE_SHININESS);
 880       emit_op1(p, VP_OPCODE_MOV, dots, WRITEMASK_Z,
 881                negate(swizzle1(shininess,X)));
 882       release_temp(p, shininess);
 883
 884       _bfc0 = make_temp(p, get_scenecolor(p, 1));
 885       if (separate)
 886          _bfc1 = make_temp(p, get_identity_param(p));
 887       else
 888          _bfc1 = _bfc0;
 889    }
 890
 891
 892    /* If no lights, still need to emit the scenecolor.
 893     */
 894       {
 895          struct ureg res0 = register_output( p, VERT_RESULT_COL0 );
 896          emit_op1(p, VP_OPCODE_MOV, res0, 0, _col0);
 897       }
 898
 899       if (separate) {
 900          struct ureg res1 = register_output( p, VERT_RESULT_COL1 );
 901          emit_op1(p, VP_OPCODE_MOV, res1, 0, _col1);
 902       }
 903
 904       if (twoside) {
 905          struct ureg res0 = register_output( p, VERT_RESULT_BFC0 );
 906          emit_op1(p, VP_OPCODE_MOV, res0, 0, _bfc0);
 907       }
 908
 909       if (twoside && separate) {
 910          struct ureg res1 = register_output( p, VERT_RESULT_BFC1 );
 911          emit_op1(p, VP_OPCODE_MOV, res1, 0, _bfc1);
 912       }
 913
 914    if (nr_lights == 0) {
 915       release_temps(p);
 916       return;
 917    }
 918
 919
 920    for (i = 0; i < MAX_LIGHTS; i++) {
 921       if (p->state->unit[i].light_enabled) {
 922          struct ureg half = undef;
 923          struct ureg att = undef, VPpli = undef;
 924
 925          count++;
 926
 927          if (p->state->unit[i].light_eyepos3_is_zero) {
 928             /* Can used precomputed constants in this case.
 929              * Attenuation never applies to infinite lights.
 930              */
 931             VPpli = register_param3(p, STATE_LIGHT, i,
 932                                     STATE_POSITION_NORMALIZED);
 933             half = register_param3(p, STATE_LIGHT, i, STATE_HALF);
 934          }
 935          else {
 936             struct ureg Ppli = register_param3(p, STATE_LIGHT, i,
 937                                                STATE_POSITION);
 938             struct ureg V = get_eye_position(p);
 939             struct ureg dist = get_temp(p);
 940
 941             VPpli = get_temp(p);
 942             half = get_temp(p);
 943
 944             /* Calulate VPpli vector
 945              */
 946             emit_op2(p, VP_OPCODE_SUB, VPpli, 0, Ppli, V);
 947
 948             /* Normalize VPpli.  The dist value also used in
 949              * attenuation below.
 950              */
 951             emit_op2(p, VP_OPCODE_DP3, dist, 0, VPpli, VPpli);
 952             emit_op1(p, VP_OPCODE_RSQ, dist, 0, dist);
 953             emit_op2(p, VP_OPCODE_MUL, VPpli, 0, VPpli, dist);
 954
 955
 956             /* Calculate  attenuation:
 957              */
 958             if (!p->state->unit[i].light_spotcutoff_is_180 ||
 959                 p->state->unit[i].light_attenuated) {
 960                att = calculate_light_attenuation(p, i, VPpli, dist);
 961             }
 962
 963
 964             /* Calculate viewer direction, or use infinite viewer:
 965              */
 966             if (p->state->light_local_viewer) {
 967                struct ureg eye_hat = get_eye_position_normalized(p);
 968                emit_op2(p, VP_OPCODE_SUB, half, 0, VPpli, eye_hat);
 969             }
 970             else {
 971                struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z);
 972                emit_op2(p, VP_OPCODE_ADD, half, 0, VPpli, z_dir);
 973             }
 974
 975             emit_normalize_vec3(p, half, half);
 976
 977             release_temp(p, dist);
 978          }
 979
 980          /* Calculate dot products:
 981           */
 982          emit_op2(p, VP_OPCODE_DP3, dots, WRITEMASK_X, normal, VPpli);
 983          emit_op2(p, VP_OPCODE_DP3, dots, WRITEMASK_Y, normal, half);
 984
 985
 986          /* Front face lighting:
 987           */
 988          {
 989             struct ureg ambient = get_lightprod(p, i, 0, STATE_AMBIENT);
 990             struct ureg diffuse = get_lightprod(p, i, 0, STATE_DIFFUSE);
 991             struct ureg specular = get_lightprod(p, i, 0, STATE_SPECULAR);
 992             struct ureg res0, res1;
 993             GLuint mask0, mask1;
 994
 995             emit_op1(p, VP_OPCODE_LIT, lit, 0, dots);
 996
 997             if (!is_undef(att))
 998                emit_op2(p, VP_OPCODE_MUL, lit, 0, lit, att);
 999
1000
1001             if (count == nr_lights) {
1002                if (separate) {
1003                   mask0 = WRITEMASK_XYZ;
1004                   mask1 = WRITEMASK_XYZ;
1005                   res0 = register_output( p, VERT_RESULT_COL0 );
1006                   res1 = register_output( p, VERT_RESULT_COL1 );
1007                }
1008                else {
1009                   mask0 = 0;
1010                   mask1 = WRITEMASK_XYZ;
1011                   res0 = _col0;
1012                   res1 = register_output( p, VERT_RESULT_COL0 );
1013                }
1014             } else {
1015                mask0 = 0;
1016                mask1 = 0;
1017                res0 = _col0;
1018                res1 = _col1;
1019             }
1020
1021             emit_op3(p, VP_OPCODE_MAD, _col0, 0, swizzle1(lit,X), ambient, _col0);
1022             emit_op3(p, VP_OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _col0);
1023             emit_op3(p, VP_OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _col1);
1024
1025             release_temp(p, ambient);
1026             release_temp(p, diffuse);
1027             release_temp(p, specular);
1028          }
1029
1030          /* Back face lighting:
1031           */
1032          if (twoside) {
1033             struct ureg ambient = get_lightprod(p, i, 1, STATE_AMBIENT);
1034             struct ureg diffuse = get_lightprod(p, i, 1, STATE_DIFFUSE);
1035             struct ureg specular = get_lightprod(p, i, 1, STATE_SPECULAR);
1036             struct ureg res0, res1;
1037             GLuint mask0, mask1;
1038
1039             emit_op1(p, VP_OPCODE_LIT, lit, 0, negate(swizzle(dots,X,Y,W,Z)));
1040
1041             if (!is_undef(att))
1042                emit_op2(p, VP_OPCODE_MUL, lit, 0, lit, att);
1043
1044             if (count == nr_lights) {
1045                if (separate) {
1046                   mask0 = WRITEMASK_XYZ;
1047                   mask1 = WRITEMASK_XYZ;
1048                   res0 = register_output( p, VERT_RESULT_BFC0 );
1049                   res1 = register_output( p, VERT_RESULT_BFC1 );
1050                }
1051                else {
1052                   mask0 = 0;
1053                   mask1 = WRITEMASK_XYZ;
1054                   res0 = _bfc0;
1055                   res1 = register_output( p, VERT_RESULT_BFC0 );
1056                }
1057             } else {
1058                res0 = _bfc0;
1059                res1 = _bfc1;
1060                mask0 = 0;
1061                mask1 = 0;
1062             }
1063
1064             emit_op3(p, VP_OPCODE_MAD, _bfc0, 0, swizzle1(lit,X), ambient, _bfc0);
1065             emit_op3(p, VP_OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _bfc0);
1066             emit_op3(p, VP_OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _bfc1);
1067
1068             release_temp(p, ambient);
1069             release_temp(p, diffuse);
1070             release_temp(p, specular);
1071          }
1072
1073          release_temp(p, half);
1074          release_temp(p, VPpli);
1075          release_temp(p, att);
1076       }
1077    }
1078
1079    release_temps( p );
1080 }
1081
1082
1083 static void build_fog( struct tnl_program *p )
1084 {
1085    struct ureg fog = register_output(p, VERT_RESULT_FOGC);
1086    struct ureg input;
1087
1088    if (p->state->fog_source_is_depth) {
1089       input = swizzle1(get_eye_position(p), Z);
1090    }
1091    else {
1092       input = swizzle1(register_input(p, VERT_ATTRIB_FOG), X);
1093    }
1094
1095    if (p->state->tnl_do_vertex_fog) {
1096       struct ureg params = register_param1(p, STATE_FOG_PARAMS);
1097       struct ureg tmp = get_temp(p);
1098
1099       switch (p->state->fog_mode) {
1100       case FOG_LINEAR: {
1101          struct ureg id = get_identity_param(p);
1102          emit_op2(p, VP_OPCODE_SUB, tmp, 0, swizzle1(params,Z), input);
1103          emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, swizzle1(params,W));
1104          emit_op2(p, VP_OPCODE_MAX, tmp, 0, tmp, swizzle1(id,X)); /* saturate */
1105          emit_op2(p, VP_OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W));
1106          break;
1107       }
1108       case FOG_EXP:
1109          emit_op1(p, VP_OPCODE_ABS, tmp, 0, input);
1110          emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, swizzle1(params,X));
1111          emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X,
1112                   register_const1f(p, M_E), negate(tmp));
1113          break;
1114       case FOG_EXP2:
1115          emit_op2(p, VP_OPCODE_MUL, tmp, 0, input, swizzle1(params,X));
1116          emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, tmp);
1117          emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X,
1118                   register_const1f(p, M_E), negate(tmp));
1119          break;
1120       }
1121
1122       release_temp(p, tmp);
1123    }
1124    else {
1125       /* results = incoming fog coords (compute fog per-fragment later)
1126        *
1127        * KW:  Is it really necessary to do anything in this case?
1128        */
1129       emit_op1(p, VP_OPCODE_MOV, fog, WRITEMASK_X, input);
1130    }
1131 }
1132
1133 static void build_reflect_texgen( struct tnl_program *p,
1134                                   struct ureg dest,
1135                                   GLuint writemask )
1136 {
1137    struct ureg normal = get_eye_normal(p);
1138    struct ureg eye_hat = get_eye_position_normalized(p);
1139    struct ureg tmp = get_temp(p);
1140
1141    /* n.u */
1142    emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
1143    /* 2n.u */
1144    emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
1145    /* (-2n.u)n + u */
1146    emit_op3(p, VP_OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
1147 }
1148
1149 static void build_sphere_texgen( struct tnl_program *p,
1150                                  struct ureg dest,
1151                                  GLuint writemask )
1152 {
1153    struct ureg normal = get_eye_normal(p);
1154    struct ureg eye_hat = get_eye_position_normalized(p);
1155    struct ureg tmp = get_temp(p);
1156    struct ureg half = register_scalar_const(p, .5);
1157    struct ureg r = get_temp(p);
1158    struct ureg inv_m = get_temp(p);
1159    struct ureg id = get_identity_param(p);
1160
1161    /* Could share the above calculations, but it would be
1162     * a fairly odd state for someone to set (both sphere and
1163     * reflection active for different texture coordinate
1164     * components.  Of course - if two texture units enable
1165     * reflect and/or sphere, things start to tilt in favour
1166     * of seperating this out:
1167     */
1168
1169    /* n.u */
1170    emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
1171    /* 2n.u */
1172    emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
1173    /* (-2n.u)n + u */
1174    emit_op3(p, VP_OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
1175    /* r + 0,0,1 */
1176    emit_op2(p, VP_OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
1177    /* rx^2 + ry^2 + (rz+1)^2 */
1178    emit_op2(p, VP_OPCODE_DP3, tmp, 0, tmp, tmp);
1179    /* 2/m */
1180    emit_op1(p, VP_OPCODE_RSQ, tmp, 0, tmp);
1181    /* 1/m */
1182    emit_op2(p, VP_OPCODE_MUL, inv_m, 0, tmp, half);
1183    /* r/m + 1/2 */
1184    emit_op3(p, VP_OPCODE_MAD, dest, writemask, r, inv_m, half);
1185
1186    release_temp(p, tmp);
1187    release_temp(p, r);
1188    release_temp(p, inv_m);
1189 }
1190
1191
1192 static void build_texture_transform( struct tnl_program *p )
1193 {
1194    GLuint i, j;
1195
1196    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1197       GLuint texmat_enabled = p->state->unit[i].texmat_enabled;
1198
1199       if (p->state->unit[i].texgen_enabled || texmat_enabled) {
1200          struct ureg out = register_output(p, VERT_RESULT_TEX0 + i);
1201          struct ureg out_texgen = undef;
1202
1203          if (p->state->unit[i].texgen_enabled) {
1204             GLuint copy_mask = 0;
1205             GLuint sphere_mask = 0;
1206             GLuint reflect_mask = 0;
1207             GLuint normal_mask = 0;
1208             GLuint modes[4];
1209
1210             if (texmat_enabled)
1211                out_texgen = get_temp(p);
1212             else
1213                out_texgen = out;
1214
1215             modes[0] = p->state->unit[i].texgen_mode0;
1216             modes[1] = p->state->unit[i].texgen_mode1;
1217             modes[2] = p->state->unit[i].texgen_mode2;
1218             modes[3] = p->state->unit[i].texgen_mode3;
1219
1220             for (j = 0; j < 4; j++) {
1221                switch (modes[j]) {
1222                case TXG_OBJ_LINEAR: {
1223                   struct ureg obj = register_input(p, VERT_ATTRIB_POS);
1224                   struct ureg plane =
1225                      register_param3(p, STATE_TEXGEN, i,
1226                                      STATE_TEXGEN_OBJECT_S + j);
1227
1228                   emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j,
1229                            obj, plane );
1230                   break;
1231                }
1232                case TXG_EYE_LINEAR: {
1233                   struct ureg eye = get_eye_position(p);
1234                   struct ureg plane =
1235                      register_param3(p, STATE_TEXGEN, i,
1236                                      STATE_TEXGEN_EYE_S + j);
1237
1238                   emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j,
1239                            eye, plane );
1240                   break;
1241                }
1242                case TXG_SPHERE_MAP:
1243                   sphere_mask |= WRITEMASK_X << j;
1244                   break;
1245                case TXG_REFLECTION_MAP:
1246                   reflect_mask |= WRITEMASK_X << j;
1247                   break;
1248                case TXG_NORMAL_MAP:
1249                   normal_mask |= WRITEMASK_X << j;
1250                   break;
1251                case TXG_NONE:
1252                   copy_mask |= WRITEMASK_X << j;
1253                }
1254
1255             }
1256
1257
1258             if (sphere_mask) {
1259                build_sphere_texgen(p, out_texgen, sphere_mask);
1260             }
1261
1262             if (reflect_mask) {
1263                build_reflect_texgen(p, out_texgen, reflect_mask);
1264             }
1265
1266             if (normal_mask) {
1267                struct ureg normal = get_eye_normal(p);
1268                emit_op1(p, VP_OPCODE_MOV, out_texgen, normal_mask, normal );
1269             }
1270
1271             if (copy_mask) {
1272                struct ureg in = register_input(p, VERT_ATTRIB_TEX0+i);
1273                emit_op1(p, VP_OPCODE_MOV, out_texgen, copy_mask, in );
1274             }
1275          }
1276
1277          if (texmat_enabled) {
1278             struct ureg texmat[4];
1279             struct ureg in = (!is_undef(out_texgen) ?
1280                               out_texgen :
1281                               register_input(p, VERT_ATTRIB_TEX0+i));
1282             if (PREFER_DP4) {
1283                register_matrix_param6( p, STATE_MATRIX, STATE_TEXTURE, i,
1284                                        0, 3, STATE_MATRIX, texmat );
1285                emit_matrix_transform_vec4( p, out, texmat, in );
1286             }
1287             else {
1288                register_matrix_param6( p, STATE_MATRIX, STATE_TEXTURE, i,
1289                                        0, 3, STATE_MATRIX_TRANSPOSE, texmat );
1290                emit_transpose_matrix_transform_vec4( p, out, texmat, in );
1291             }
1292          }
1293
1294          release_temps(p);
1295       }
1296       else if (p->state->unit[i].texunit_really_enabled) {
1297          /* KW: _ReallyEnabled isn't sufficient?  Need to know whether
1298           * this texture unit is referenced by the fragment shader.
1299           */
1300          emit_passthrough(p, VERT_ATTRIB_TEX0+i, VERT_RESULT_TEX0+i);
1301       }
1302    }
1303 }
1304
1305
1306 /* Seems like it could be tighter:
1307  */
1308 static void build_pointsize( struct tnl_program *p )
1309 {
1310    struct ureg eye = get_eye_position(p);
1311    struct ureg state_size = register_param1(p, STATE_POINT_SIZE);
1312    struct ureg state_attenuation = register_param1(p, STATE_POINT_ATTENUATION);
1313    struct ureg out = register_output(p, VERT_RESULT_PSIZ);
1314    struct ureg ut = get_temp(p);
1315
1316    /* 1, -Z, Z * Z, 1 */
1317    emit_op1(p, VP_OPCODE_MOV, ut, 0, swizzle1(get_identity_param(p), W));
1318    emit_op2(p, VP_OPCODE_MUL, ut, WRITEMASK_YZ, ut, negate(swizzle1(eye, Z)));
1319    emit_op2(p, VP_OPCODE_MUL, ut, WRITEMASK_Z, ut, negate(swizzle1(eye, Z)));
1320
1321
1322    /* p1 +  p2 * dist + p3 * dist * dist, 0 */
1323    emit_op2(p, VP_OPCODE_DP3, ut, 0, ut, state_attenuation);
1324
1325    /* 1 / factor */
1326    emit_op1(p, VP_OPCODE_RCP, ut, 0, ut );
1327
1328    /* out = pointSize / factor */
1329    emit_op2(p, VP_OPCODE_MUL, out, WRITEMASK_X, ut, state_size);
1330
1331    release_temp(p, ut);
1332 }
1333
1334 static void build_tnl_program( struct tnl_program *p )
1335 {   /* Emit the program, starting with modelviewproject:
1336     */
1337    build_hpos(p);
1338
1339    /* Lighting calculations:
1340     */
1341    if (p->state->light_global_enabled)
1342       build_lighting(p);
1343    else
1344       emit_passthrough(p, VERT_ATTRIB_COLOR0, VERT_RESULT_COL0);
1345
1346    if (p->state->fog_enabled)
1347       build_fog(p);
1348
1349    if (p->state->texture_enabled_global)
1350       build_texture_transform(p);
1351
1352    if (p->state->point_attenuated)
1353       build_pointsize(p);
1354
1355    /* Finish up:
1356     */
1357    emit_op1(p, VP_OPCODE_END, undef, 0, undef);
1358
1359    /* Disassemble:
1360     */
1361    if (DISASSEM) {
1362       _mesa_printf ("\n");
1363    }
1364 }
1365
1366
1367 static void
1368 create_new_program( const struct state_key *key,
1369                     struct vertex_program *program,
1370                     GLuint max_temps)
1371 {
1372    struct tnl_program p;
1373
1374    _mesa_memset(&p, 0, sizeof(p));
1375    p.state = key;
1376    p.program = program;
1377    p.eye_position = undef;
1378    p.eye_position_normalized = undef;
1379    p.eye_normal = undef;
1380    p.identity = undef;
1381    p.temp_in_use = 0;
1382
1383    if (max_temps >= sizeof(int) * 8)
1384       p.temp_reserved = 0;
1385    else
1386       p.temp_reserved = ~((1<<max_temps)-1);
1387
1388    p.program->Instructions = MALLOC(sizeof(struct vp_instruction) * MAX_INSN);
1389    p.program->Base.String = 0;
1390    p.program->Base.NumInstructions =
1391    p.program->Base.NumTemporaries =
1392    p.program->Base.NumParameters =
1393    p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0;
1394    p.program->Parameters = _mesa_new_parameter_list();
1395    p.program->InputsRead = 0;
1396    p.program->OutputsWritten = 0;
1397
1398    build_tnl_program( &p );
1399 }
1400
1401 static void *search_cache( struct tnl_cache *cache,
1402                            GLuint hash,
1403                            const void *key,
1404                            GLuint keysize)
1405 {
1406    struct tnl_cache *c;
1407
1408    for (c = cache; c; c = c->next) {
1409       if (c->hash == hash && memcmp(c->key, key, keysize) == 0)
1410          return c->data;
1411    }
1412
1413    return NULL;
1414 }
1415
1416 static void cache_item( struct tnl_cache **cache,
1417                         GLuint hash,
1418                         void *key,
1419                         void *data )
1420 {
1421    struct tnl_cache *c = MALLOC(sizeof(*c));
1422    c->hash = hash;
1423    c->key = key;
1424    c->data = data;
1425    c->next = *cache;
1426    *cache = c;
1427 }
1428
1429 static GLuint hash_key( struct state_key *key )
1430 {
1431    GLuint *ikey = (GLuint *)key;
1432    GLuint hash = 0, i;
1433
1434    /* I'm sure this can be improved on, but speed is important:
1435     */
1436    for (i = 0; i < sizeof(*key)/sizeof(GLuint); i++)
1437       hash ^= ikey[i];
1438
1439    return hash;
1440 }
1441
1442 void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
1443 {
1444    TNLcontext *tnl = TNL_CONTEXT(ctx);
1445    struct state_key *key;
1446    GLuint hash;
1447
1448    if (ctx->VertexProgram._Enabled)
1449       return;
1450
1451    /* Grab all the relevent state and put it in a single structure:
1452     */
1453    key = make_state_key(ctx);
1454    hash = hash_key(key);
1455
1456    /* Look for an already-prepared program for this state:
1457     */
1458    ctx->_TnlProgram = (struct vertex_program *)
1459       search_cache( tnl->vp_cache, hash, key, sizeof(*key) );
1460
1461    /* OK, we'll have to build a new one:
1462     */
1463    if (!ctx->_TnlProgram) {
1464       if (0)
1465          _mesa_printf("Build new TNL program\n");
1466
1467       ctx->_TnlProgram = (struct vertex_program *)
1468          ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
1469
1470       create_new_program( key, ctx->_TnlProgram,
1471                           ctx->Const.MaxVertexProgramTemps );
1472
1473       cache_item(&tnl->vp_cache, hash, key, ctx->_TnlProgram );
1474    }
1475    else {
1476       FREE(key);
1477       if (0)
1478          _mesa_printf("Found existing TNL program for key %x\n", hash);
1479    }
1480
1481    /* Need a BindProgram callback for the driver?
1482     */
1483 }
1484
1485
1486 void _tnl_ProgramCacheDestroy( GLcontext *ctx )
1487 {
1488    TNLcontext *tnl = TNL_CONTEXT(ctx);
1489    struct tnl_cache *a, *tmp;
1490
1491    for (a = tnl->vp_cache ; a; a = tmp) {
1492       tmp = a->next;
1493       FREE(a->key);
1494       FREE(a->data);
1495       FREE(a);
1496    }
1497 }