src/mesa/shader/slang/slang_builtin.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.3
   4  *
   5  * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
   6  * Copyright (C) 2008  VMware, Inc.   All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions 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 MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 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 slang_builtin.c
  28  * Resolve built-in uniform vars.
  29  * \author Brian Paul
  30  */
  31
  32 #include "main/imports.h"
  33 #include "main/mtypes.h"
  34 #include "shader/program.h"
  35 #include "shader/prog_instruction.h"
  36 #include "shader/prog_parameter.h"
  37 #include "shader/prog_statevars.h"
  38 #include "shader/slang/slang_ir.h"
  39 #include "shader/slang/slang_builtin.h"
  40
  41
  42 /** special state token (see below) */
  43 #define STATE_ARRAY ((gl_state_index) 0xfffff)
  44
  45
  46 /**
  47  * Lookup GL state given a variable name, 0, 1 or 2 indexes and a field.
  48  * Allocate room for the state in the given param list and return position
  49  * in the list.
  50  * Yes, this is kind of ugly, but it works.
  51  */
  52 static GLint
  53 lookup_statevar(const char *var, GLint index1, GLint index2, const char *field,
  54                 GLuint *swizzleOut,
  55                 struct gl_program_parameter_list *paramList)
  56 {
  57    /*
  58     * NOTE: The ARB_vertex_program extension specified that matrices get
  59     * loaded in registers in row-major order.  With GLSL, we want column-
  60     * major order.  So, we need to transpose all matrices here...
  61     */
  62    static const struct {
  63       const char *name;
  64       gl_state_index matrix;
  65       gl_state_index modifier;
  66    } matrices[] = {
  67       { "gl_ModelViewMatrix", STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE },
  68       { "gl_ModelViewMatrixInverse", STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS },
  69       { "gl_ModelViewMatrixTranspose", STATE_MODELVIEW_MATRIX, 0 },
  70       { "gl_ModelViewMatrixInverseTranspose", STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE },
  71
  72       { "gl_ProjectionMatrix", STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE },
  73       { "gl_ProjectionMatrixInverse", STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS },
  74       { "gl_ProjectionMatrixTranspose", STATE_PROJECTION_MATRIX, 0 },
  75       { "gl_ProjectionMatrixInverseTranspose", STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE },
  76
  77       { "gl_ModelViewProjectionMatrix", STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE },
  78       { "gl_ModelViewProjectionMatrixInverse", STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS },
  79       { "gl_ModelViewProjectionMatrixTranspose", STATE_MVP_MATRIX, 0 },
  80       { "gl_ModelViewProjectionMatrixInverseTranspose", STATE_MVP_MATRIX, STATE_MATRIX_INVERSE },
  81
  82       { "gl_TextureMatrix", STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE },
  83       { "gl_TextureMatrixInverse", STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS },
  84       { "gl_TextureMatrixTranspose", STATE_TEXTURE_MATRIX, 0 },
  85       { "gl_TextureMatrixInverseTranspose", STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE },
  86
  87       { "gl_NormalMatrix", STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE },
  88
  89       { NULL, 0, 0 }
  90    };
  91    gl_state_index tokens[STATE_LENGTH];
  92    GLuint i;
  93    GLboolean isMatrix = GL_FALSE;
  94
  95    for (i = 0; i < STATE_LENGTH; i++) {
  96       tokens[i] = 0;
  97    }
  98    *swizzleOut = SWIZZLE_NOOP;
  99
 100    /* first, look if var is a pre-defined matrix */
 101    for (i = 0; matrices[i].name; i++) {
 102       if (strcmp(var, matrices[i].name) == 0) {
 103          tokens[0] = matrices[i].matrix;
 104          /* tokens[1], [2] and [3] filled below */
 105          tokens[4] = matrices[i].modifier;
 106          isMatrix = GL_TRUE;
 107          break;
 108       }
 109    }
 110
 111    if (isMatrix) {
 112       if (tokens[0] == STATE_TEXTURE_MATRIX) {
 113          /* texture_matrix[index1][index2] */
 114          tokens[1] = index1 >= 0 ? index1 : 0; /* which texture matrix */
 115          index1 = index2; /* move matrix row value to index1 */
 116       }
 117       if (index1 < 0) {
 118          /* index1 is unused: prevent extra addition at end of function */
 119          index1 = 0;
 120       }
 121    }
 122    else if (strcmp(var, "gl_DepthRange") == 0) {
 123       tokens[0] = STATE_DEPTH_RANGE;
 124       assert(field);
 125       if (strcmp(field, "near") == 0) {
 126          *swizzleOut = SWIZZLE_XXXX;
 127       }
 128       else if (strcmp(field, "far") == 0) {
 129          *swizzleOut = SWIZZLE_YYYY;
 130       }
 131       else if (strcmp(field, "diff") == 0) {
 132          *swizzleOut = SWIZZLE_ZZZZ;
 133       }
 134       else {
 135          return -1;
 136       }
 137    }
 138    else if (strcmp(var, "gl_ClipPlane") == 0) {
 139       if (index1 < 0)
 140          return -1;
 141       tokens[0] = STATE_CLIPPLANE;
 142       tokens[1] = index1;
 143    }
 144    else if (strcmp(var, "gl_Point") == 0) {
 145       assert(field);
 146       if (strcmp(field, "size") == 0) {
 147          tokens[0] = STATE_POINT_SIZE;
 148          *swizzleOut = SWIZZLE_XXXX;
 149       }
 150       else if (strcmp(field, "sizeMin") == 0) {
 151          tokens[0] = STATE_POINT_SIZE;
 152          *swizzleOut = SWIZZLE_YYYY;
 153       }
 154       else if (strcmp(field, "sizeMax") == 0) {
 155          tokens[0] = STATE_POINT_SIZE;
 156          *swizzleOut = SWIZZLE_ZZZZ;
 157       }
 158       else if (strcmp(field, "fadeThresholdSize") == 0) {
 159          tokens[0] = STATE_POINT_SIZE;
 160          *swizzleOut = SWIZZLE_WWWW;
 161       }
 162       else if (strcmp(field, "distanceConstantAttenuation") == 0) {
 163          tokens[0] = STATE_POINT_ATTENUATION;
 164          *swizzleOut = SWIZZLE_XXXX;
 165       }
 166       else if (strcmp(field, "distanceLinearAttenuation") == 0) {
 167          tokens[0] = STATE_POINT_ATTENUATION;
 168          *swizzleOut = SWIZZLE_YYYY;
 169       }
 170       else if (strcmp(field, "distanceQuadraticAttenuation") == 0) {
 171          tokens[0] = STATE_POINT_ATTENUATION;
 172          *swizzleOut = SWIZZLE_ZZZZ;
 173       }
 174       else {
 175          return -1;
 176       }
 177    }
 178    else if (strcmp(var, "gl_FrontMaterial") == 0 ||
 179             strcmp(var, "gl_BackMaterial") == 0) {
 180       tokens[0] = STATE_MATERIAL;
 181       if (strcmp(var, "gl_FrontMaterial") == 0)
 182          tokens[1] = 0;
 183       else
 184          tokens[1] = 1;
 185       assert(field);
 186       if (strcmp(field, "emission") == 0) {
 187          tokens[2] = STATE_EMISSION;
 188       }
 189       else if (strcmp(field, "ambient") == 0) {
 190          tokens[2] = STATE_AMBIENT;
 191       }
 192       else if (strcmp(field, "diffuse") == 0) {
 193          tokens[2] = STATE_DIFFUSE;
 194       }
 195       else if (strcmp(field, "specular") == 0) {
 196          tokens[2] = STATE_SPECULAR;
 197       }
 198       else if (strcmp(field, "shininess") == 0) {
 199          tokens[2] = STATE_SHININESS;
 200          *swizzleOut = SWIZZLE_XXXX;
 201       }
 202       else {
 203          return -1;
 204       }
 205    }
 206    else if (strcmp(var, "gl_LightSource") == 0) {
 207       if (!field || index1 < 0)
 208          return -1;
 209
 210       tokens[0] = STATE_LIGHT;
 211       tokens[1] = index1;
 212
 213       if (strcmp(field, "ambient") == 0) {
 214          tokens[2] = STATE_AMBIENT;
 215       }
 216       else if (strcmp(field, "diffuse") == 0) {
 217          tokens[2] = STATE_DIFFUSE;
 218       }
 219       else if (strcmp(field, "specular") == 0) {
 220          tokens[2] = STATE_SPECULAR;
 221       }
 222       else if (strcmp(field, "position") == 0) {
 223          tokens[2] = STATE_POSITION;
 224       }
 225       else if (strcmp(field, "halfVector") == 0) {
 226          tokens[2] = STATE_HALF_VECTOR;
 227       }
 228       else if (strcmp(field, "spotDirection") == 0) {
 229          tokens[2] = STATE_SPOT_DIRECTION;
 230       }
 231       else if (strcmp(field, "spotCosCutoff") == 0) {
 232          tokens[2] = STATE_SPOT_DIRECTION;
 233          *swizzleOut = SWIZZLE_WWWW;
 234       }
 235       else if (strcmp(field, "spotCutoff") == 0) {
 236          tokens[2] = STATE_SPOT_CUTOFF;
 237          *swizzleOut = SWIZZLE_XXXX;
 238       }
 239       else if (strcmp(field, "spotExponent") == 0) {
 240          tokens[2] = STATE_ATTENUATION;
 241          *swizzleOut = SWIZZLE_WWWW;
 242       }
 243       else if (strcmp(field, "constantAttenuation") == 0) {
 244          tokens[2] = STATE_ATTENUATION;
 245          *swizzleOut = SWIZZLE_XXXX;
 246       }
 247       else if (strcmp(field, "linearAttenuation") == 0) {
 248          tokens[2] = STATE_ATTENUATION;
 249          *swizzleOut = SWIZZLE_YYYY;
 250       }
 251       else if (strcmp(field, "quadraticAttenuation") == 0) {
 252          tokens[2] = STATE_ATTENUATION;
 253          *swizzleOut = SWIZZLE_ZZZZ;
 254       }
 255       else {
 256          return -1;
 257       }
 258    }
 259    else if (strcmp(var, "gl_LightModel") == 0) {
 260       if (strcmp(field, "ambient") == 0) {
 261          tokens[0] = STATE_LIGHTMODEL_AMBIENT;
 262       }
 263       else {
 264          return -1;
 265       }
 266    }
 267    else if (strcmp(var, "gl_FrontLightModelProduct") == 0) {
 268       if (strcmp(field, "sceneColor") == 0) {
 269          tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
 270          tokens[1] = 0;
 271       }
 272       else {
 273          return -1;
 274       }
 275    }
 276    else if (strcmp(var, "gl_BackLightModelProduct") == 0) {
 277       if (strcmp(field, "sceneColor") == 0) {
 278          tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
 279          tokens[1] = 1;
 280       }
 281       else {
 282          return -1;
 283       }
 284    }
 285    else if (strcmp(var, "gl_FrontLightProduct") == 0 ||
 286             strcmp(var, "gl_BackLightProduct") == 0) {
 287       if (index1 < 0 || !field)
 288          return -1;
 289
 290       tokens[0] = STATE_LIGHTPROD;
 291       tokens[1] = index1; /* light number */
 292       if (strcmp(var, "gl_FrontLightProduct") == 0) {
 293          tokens[2] = 0; /* front */
 294       }
 295       else {
 296          tokens[2] = 1; /* back */
 297       }
 298       if (strcmp(field, "ambient") == 0) {
 299          tokens[3] = STATE_AMBIENT;
 300       }
 301       else if (strcmp(field, "diffuse") == 0) {
 302          tokens[3] = STATE_DIFFUSE;
 303       }
 304       else if (strcmp(field, "specular") == 0) {
 305          tokens[3] = STATE_SPECULAR;
 306       }
 307       else {
 308          return -1;
 309       }
 310    }
 311    else if (strcmp(var, "gl_TextureEnvColor") == 0) {
 312       if (index1 < 0)
 313          return -1;
 314       tokens[0] = STATE_TEXENV_COLOR;
 315       tokens[1] = index1;
 316    }
 317    else if (strcmp(var, "gl_EyePlaneS") == 0) {
 318       if (index1 < 0)
 319          return -1;
 320       tokens[0] = STATE_TEXGEN;
 321       tokens[1] = index1; /* tex unit */
 322       tokens[2] = STATE_TEXGEN_EYE_S;
 323    }
 324    else if (strcmp(var, "gl_EyePlaneT") == 0) {
 325       if (index1 < 0)
 326          return -1;
 327       tokens[0] = STATE_TEXGEN;
 328       tokens[1] = index1; /* tex unit */
 329       tokens[2] = STATE_TEXGEN_EYE_T;
 330    }
 331    else if (strcmp(var, "gl_EyePlaneR") == 0) {
 332       if (index1 < 0)
 333          return -1;
 334       tokens[0] = STATE_TEXGEN;
 335       tokens[1] = index1; /* tex unit */
 336       tokens[2] = STATE_TEXGEN_EYE_R;
 337    }
 338    else if (strcmp(var, "gl_EyePlaneQ") == 0) {
 339       if (index1 < 0)
 340          return -1;
 341       tokens[0] = STATE_TEXGEN;
 342       tokens[1] = index1; /* tex unit */
 343       tokens[2] = STATE_TEXGEN_EYE_Q;
 344    }
 345    else if (strcmp(var, "gl_ObjectPlaneS") == 0) {
 346       if (index1 < 0)
 347          return -1;
 348       tokens[0] = STATE_TEXGEN;
 349       tokens[1] = index1; /* tex unit */
 350       tokens[2] = STATE_TEXGEN_OBJECT_S;
 351    }
 352    else if (strcmp(var, "gl_ObjectPlaneT") == 0) {
 353       if (index1 < 0)
 354          return -1;
 355       tokens[0] = STATE_TEXGEN;
 356       tokens[1] = index1; /* tex unit */
 357       tokens[2] = STATE_TEXGEN_OBJECT_T;
 358    }
 359    else if (strcmp(var, "gl_ObjectPlaneR") == 0) {
 360       if (index1 < 0)
 361          return -1;
 362       tokens[0] = STATE_TEXGEN;
 363       tokens[1] = index1; /* tex unit */
 364       tokens[2] = STATE_TEXGEN_OBJECT_R;
 365    }
 366    else if (strcmp(var, "gl_ObjectPlaneQ") == 0) {
 367       if (index1 < 0)
 368          return -1;
 369       tokens[0] = STATE_TEXGEN;
 370       tokens[1] = index1; /* tex unit */
 371       tokens[2] = STATE_TEXGEN_OBJECT_Q;
 372    }
 373    else if (strcmp(var, "gl_Fog") == 0) {
 374       if (strcmp(field, "color") == 0) {
 375          tokens[0] = STATE_FOG_COLOR;
 376       }
 377       else if (strcmp(field, "density") == 0) {
 378          tokens[0] = STATE_FOG_PARAMS;
 379          *swizzleOut = SWIZZLE_XXXX;
 380       }
 381       else if (strcmp(field, "start") == 0) {
 382          tokens[0] = STATE_FOG_PARAMS;
 383          *swizzleOut = SWIZZLE_YYYY;
 384       }
 385       else if (strcmp(field, "end") == 0) {
 386          tokens[0] = STATE_FOG_PARAMS;
 387          *swizzleOut = SWIZZLE_ZZZZ;
 388       }
 389       else if (strcmp(field, "scale") == 0) {
 390          tokens[0] = STATE_FOG_PARAMS;
 391          *swizzleOut = SWIZZLE_WWWW;
 392       }
 393       else {
 394          return -1;
 395       }
 396    }
 397    else {
 398       return -1;
 399    }
 400
 401    if (isMatrix) {
 402       /* load all four columns of matrix */
 403       GLint pos[4];
 404       GLuint j;
 405       for (j = 0; j < 4; j++) {
 406          tokens[2] = tokens[3] = j; /* jth row of matrix */
 407          pos[j] = _mesa_add_state_reference(paramList, tokens);
 408          assert(pos[j] >= 0);
 409          ASSERT(pos[j] >= 0);
 410       }
 411       return pos[0] + index1;
 412    }
 413    else {
 414       /* allocate a single register */
 415       GLint pos = _mesa_add_state_reference(paramList, tokens);
 416       ASSERT(pos >= 0);
 417       return pos;
 418    }
 419 }
 420
 421
 422
 423 /**
 424  * Given a variable name and datatype, emit uniform/constant buffer
 425  * entries which will store that state variable.
 426  * For example, if name="gl_LightSource" we'll emit 64 state variable
 427  * vectors/references and return position where that data starts.  This will
 428  * allow run-time array indexing into the light source array.
 429  *
 430  * Note that this is a recursive function.
 431  *
 432  * \return -1 if error, else index of start of data in the program parameter list
 433  */
 434 static GLint
 435 emit_statevars(const char *name, int array_len,
 436                const slang_type_specifier *type,
 437                gl_state_index tokens[STATE_LENGTH],
 438                struct gl_program_parameter_list *paramList)
 439 {
 440    if (type->type == SLANG_SPEC_ARRAY) {
 441       GLint i, pos = -1;
 442       assert(array_len > 0);
 443       if (strcmp(name, "gl_ClipPlane") == 0) {
 444          tokens[0] = STATE_CLIPPLANE;
 445       }
 446       else if (strcmp(name, "gl_LightSource") == 0) {
 447          tokens[0] = STATE_LIGHT;
 448       }
 449       else if (strcmp(name, "gl_FrontLightProduct") == 0) {
 450          tokens[0] = STATE_LIGHTPROD;
 451          tokens[2] = 0; /* front */
 452       }
 453       else if (strcmp(name, "gl_BackLightProduct") == 0) {
 454          tokens[0] = STATE_LIGHTPROD;
 455          tokens[2] = 1; /* back */
 456       }
 457       else if (strcmp(name, "gl_TextureEnvColor") == 0) {
 458          tokens[0] = STATE_TEXENV_COLOR;
 459       }
 460       else if (strcmp(name, "gl_EyePlaneS") == 0) {
 461          tokens[0] = STATE_TEXGEN;
 462          tokens[2] = STATE_TEXGEN_EYE_S;
 463       }
 464       else if (strcmp(name, "gl_EyePlaneT") == 0) {
 465          tokens[0] = STATE_TEXGEN;
 466          tokens[2] = STATE_TEXGEN_EYE_T;
 467       }
 468       else if (strcmp(name, "gl_EyePlaneR") == 0) {
 469          tokens[0] = STATE_TEXGEN;
 470          tokens[2] = STATE_TEXGEN_EYE_R;
 471       }
 472       else if (strcmp(name, "gl_EyePlaneQ") == 0) {
 473          tokens[0] = STATE_TEXGEN;
 474          tokens[2] = STATE_TEXGEN_EYE_Q;
 475       }
 476       else if (strcmp(name, "gl_ObjectPlaneS") == 0) {
 477          tokens[0] = STATE_TEXGEN;
 478          tokens[2] = STATE_TEXGEN_OBJECT_S;
 479       }
 480       else if (strcmp(name, "gl_ObjectPlaneT") == 0) {
 481          tokens[0] = STATE_TEXGEN;
 482          tokens[2] = STATE_TEXGEN_OBJECT_T;
 483       }
 484       else if (strcmp(name, "gl_ObjectPlaneR") == 0) {
 485          tokens[0] = STATE_TEXGEN;
 486          tokens[2] = STATE_TEXGEN_OBJECT_R;
 487       }
 488       else if (strcmp(name, "gl_ObjectPlaneQ") == 0) {
 489          tokens[0] = STATE_TEXGEN;
 490          tokens[2] = STATE_TEXGEN_OBJECT_Q;
 491       }
 492       else {
 493          return -1; /* invalid array name */
 494       }
 495       for (i = 0; i < array_len; i++) {
 496          GLint p;
 497          tokens[1] = i;
 498          p = emit_statevars(NULL, 0, type->_array, tokens, paramList);
 499          if (i == 0)
 500             pos = p;
 501       }
 502       return pos;
 503    }
 504    else if (type->type == SLANG_SPEC_STRUCT) {
 505       const slang_variable_scope *fields = type->_struct->fields;
 506       GLuint i, pos = 0;
 507       for (i = 0; i < fields->num_variables; i++) {
 508          const slang_variable *var = fields->variables[i];
 509          GLint p = emit_statevars(var->a_name, 0, &var->type.specifier,
 510                                   tokens, paramList);
 511          if (i == 0)
 512             pos = p;
 513       }
 514       return pos;
 515    }
 516    else {
 517       GLint pos;
 518       assert(type->type == SLANG_SPEC_VEC4 ||
 519              type->type == SLANG_SPEC_VEC3 ||
 520              type->type == SLANG_SPEC_VEC2 ||
 521              type->type == SLANG_SPEC_FLOAT ||
 522              type->type == SLANG_SPEC_IVEC4 ||
 523              type->type == SLANG_SPEC_IVEC3 ||
 524              type->type == SLANG_SPEC_IVEC2 ||
 525              type->type == SLANG_SPEC_INT);
 526       if (name) {
 527          GLint t;
 528
 529          if (tokens[0] == STATE_LIGHT)
 530             t = 2;
 531          else if (tokens[0] == STATE_LIGHTPROD)
 532             t = 3;
 533          else
 534             return -1; /* invalid array name */
 535
 536          if (strcmp(name, "ambient") == 0) {
 537             tokens[t] = STATE_AMBIENT;
 538          }
 539          else if (strcmp(name, "diffuse") == 0) {
 540             tokens[t] = STATE_DIFFUSE;
 541          }
 542          else if (strcmp(name, "specular") == 0) {
 543             tokens[t] = STATE_SPECULAR;
 544          }
 545          else if (strcmp(name, "position") == 0) {
 546             tokens[t] = STATE_POSITION;
 547          }
 548          else if (strcmp(name, "halfVector") == 0) {
 549             tokens[t] = STATE_HALF_VECTOR;
 550          }
 551          else if (strcmp(name, "spotDirection") == 0) {
 552             tokens[t] = STATE_SPOT_DIRECTION; /* xyz components */
 553          }
 554          else if (strcmp(name, "spotCosCutoff") == 0) {
 555             tokens[t] = STATE_SPOT_DIRECTION; /* w component */
 556          }
 557
 558          else if (strcmp(name, "constantAttenuation") == 0) {
 559             tokens[t] = STATE_ATTENUATION; /* x component */
 560          }
 561          else if (strcmp(name, "linearAttenuation") == 0) {
 562             tokens[t] = STATE_ATTENUATION; /* y component */
 563          }
 564          else if (strcmp(name, "quadraticAttenuation") == 0) {
 565             tokens[t] = STATE_ATTENUATION; /* z component */
 566          }
 567          else if (strcmp(name, "spotExponent") == 0) {
 568             tokens[t] = STATE_ATTENUATION; /* w = spot exponent */
 569          }
 570
 571          else if (strcmp(name, "spotCutoff") == 0) {
 572             tokens[t] = STATE_SPOT_CUTOFF; /* x component */
 573          }
 574
 575          else {
 576             return -1; /* invalid field name */
 577          }
 578       }
 579
 580       pos = _mesa_add_state_reference(paramList, tokens);
 581       return pos;
 582    }
 583
 584    return 1;
 585 }
 586
 587
 588 /**
 589  * Unroll the named built-in uniform variable into a sequence of state
 590  * vars in the given parameter list.
 591  */
 592 static GLint
 593 alloc_state_var_array(const slang_variable *var,
 594                       struct gl_program_parameter_list *paramList)
 595 {
 596    gl_state_index tokens[STATE_LENGTH];
 597    GLuint i;
 598    GLint pos;
 599
 600    /* Initialize the state tokens array.  This is very important.
 601     * When we call _mesa_add_state_reference() it'll searches the parameter
 602     * list to see if the given statevar token sequence is already present.
 603     * This is normally a good thing since it prevents redundant values in the
 604     * constant buffer.
 605     *
 606     * But when we're building arrays of state this can be bad.  For example,
 607     * consider this fragment of GLSL code:
 608     *   foo = gl_LightSource[3].diffuse;
 609     *   ...
 610     *   bar = gl_LightSource[i].diffuse;
 611     *
 612     * When we unroll the gl_LightSource array (for "bar") we want to re-emit
 613     * gl_LightSource[3].diffuse and not re-use the first instance (from "foo")
 614     * since that would upset the array layout.  We handle this situation by
 615     * setting the last token in the state var token array to the special
 616     * value STATE_ARRAY.
 617     * This token will only be set for array state.  We can hijack the last
 618     * element in the array for this since it's never used for light, clipplane
 619     * or texture env array state.
 620     */
 621    for (i = 0; i < STATE_LENGTH; i++)
 622       tokens[i] = 0;
 623    tokens[STATE_LENGTH - 1] = STATE_ARRAY;
 624
 625    pos = emit_statevars(var->a_name, var->array_len, &var->type.specifier,
 626                         tokens, paramList);
 627
 628    return pos;
 629 }
 630
 631
 632
 633 /**
 634  * Allocate storage for a pre-defined uniform (a GL state variable).
 635  * As a memory-saving optimization, we try to only allocate storage for
 636  * state vars that are actually used.
 637  *
 638  * Arrays such as gl_LightSource are handled specially.  For an expression
 639  * like "gl_LightSource[2].diffuse", we can allocate a single uniform/constant
 640  * slot and return the index.  In this case, we return direct=TRUE.
 641  *
 642  * Buf for something like "gl_LightSource[i].diffuse" we don't know the value
 643  * of 'i' at compile time so we need to "unroll" the gl_LightSource array
 644  * into a consecutive sequence of uniform/constant slots so it can be indexed
 645  * at runtime.  In this case, we return direct=FALSE.
 646  *
 647  * Currently, all pre-defined uniforms are in one of these forms:
 648  *   var
 649  *   var[i]
 650  *   var.field
 651  *   var[i].field
 652  *   var[i][j]
 653  *
 654  * \return -1 upon error, else position in paramList of the state variable/data
 655  */
 656 GLint
 657 _slang_alloc_statevar(slang_ir_node *n,
 658                       struct gl_program_parameter_list *paramList,
 659                       GLboolean *direct)
 660 {
 661    slang_ir_node *n0 = n;
 662    const char *field = NULL;
 663    GLint index1 = -1, index2 = -1;
 664    GLuint swizzle;
 665
 666    *direct = GL_TRUE;
 667
 668    if (n->Opcode == IR_FIELD) {
 669       field = n->Field;
 670       n = n->Children[0];
 671    }
 672
 673    if (n->Opcode == IR_ELEMENT) {
 674       if (n->Children[1]->Opcode == IR_FLOAT) {
 675          index1 = (GLint) n->Children[1]->Value[0];
 676       }
 677       else {
 678          *direct = GL_FALSE;
 679       }
 680       n = n->Children[0];
 681    }
 682
 683    if (n->Opcode == IR_ELEMENT) {
 684       /* XXX can only handle constant indexes for now */
 685       if (n->Children[1]->Opcode == IR_FLOAT) {
 686          /* two-dimensional array index: mat[i][j] */
 687          index2 = index1;
 688          index1 = (GLint) n->Children[1]->Value[0];
 689       }
 690       else {
 691          *direct = GL_FALSE;
 692       }
 693       n = n->Children[0];
 694    }
 695
 696    assert(n->Opcode == IR_VAR);
 697
 698    if (*direct) {
 699       const char *var = (const char *) n->Var->a_name;
 700       GLint pos =
 701          lookup_statevar(var, index1, index2, field, &swizzle, paramList);
 702       if (pos >= 0) {
 703          /* newly resolved storage for the statevar/constant/uniform */
 704          n0->Store->File = PROGRAM_STATE_VAR;
 705          n0->Store->Index = pos;
 706          n0->Store->Swizzle = swizzle;
 707          n0->Store->Parent = NULL;
 708          return pos;
 709       }
 710    }
 711
 712    *direct = GL_FALSE;
 713    return alloc_state_var_array(n->Var, paramList);
 714 }
 715
 716
 717
 718
 719 #define SWIZZLE_ZWWW MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
 720
 721
 722 /** Predefined shader inputs */
 723 struct input_info
 724 {
 725    const char *Name;
 726    GLuint Attrib;
 727    GLenum Type;
 728    GLuint Swizzle;
 729 };
 730
 731 /** Predefined vertex shader inputs/attributes */
 732 static const struct input_info vertInputs[] = {
 733    { "gl_Vertex", VERT_ATTRIB_POS, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 734    { "gl_Normal", VERT_ATTRIB_NORMAL, GL_FLOAT_VEC3, SWIZZLE_NOOP },
 735    { "gl_Color", VERT_ATTRIB_COLOR0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 736    { "gl_SecondaryColor", VERT_ATTRIB_COLOR1, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 737    { "gl_FogCoord", VERT_ATTRIB_FOG, GL_FLOAT, SWIZZLE_XXXX },
 738    { "gl_MultiTexCoord0", VERT_ATTRIB_TEX0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 739    { "gl_MultiTexCoord1", VERT_ATTRIB_TEX1, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 740    { "gl_MultiTexCoord2", VERT_ATTRIB_TEX2, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 741    { "gl_MultiTexCoord3", VERT_ATTRIB_TEX3, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 742    { "gl_MultiTexCoord4", VERT_ATTRIB_TEX4, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 743    { "gl_MultiTexCoord5", VERT_ATTRIB_TEX5, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 744    { "gl_MultiTexCoord6", VERT_ATTRIB_TEX6, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 745    { "gl_MultiTexCoord7", VERT_ATTRIB_TEX7, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 746    { NULL, 0, GL_NONE, SWIZZLE_NOOP }
 747 };
 748
 749 /** Predefined fragment shader inputs */
 750 static const struct input_info fragInputs[] = {
 751    { "gl_FragCoord", FRAG_ATTRIB_WPOS, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 752    { "gl_Color", FRAG_ATTRIB_COL0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 753    { "gl_SecondaryColor", FRAG_ATTRIB_COL1, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 754    { "gl_TexCoord", FRAG_ATTRIB_TEX0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 755    { "gl_FogFragCoord", FRAG_ATTRIB_FOGC, GL_FLOAT, SWIZZLE_XXXX },
 756    { "gl_FrontFacing", FRAG_ATTRIB_FACE, GL_FLOAT, SWIZZLE_XXXX },
 757    { "gl_PointCoord", FRAG_ATTRIB_PNTC, GL_FLOAT_VEC2, SWIZZLE_XYZW },
 758    { NULL, 0, GL_NONE, SWIZZLE_NOOP }
 759 };
 760
 761
 762 /**
 763  * Return the VERT_ATTRIB_* or FRAG_ATTRIB_* value that corresponds to
 764  * a vertex or fragment program input variable.  Return -1 if the input
 765  * name is invalid.
 766  * XXX return size too
 767  */
 768 GLint
 769 _slang_input_index(const char *name, GLenum target, GLuint *swizzleOut)
 770 {
 771    const struct input_info *inputs;
 772    GLuint i;
 773
 774    switch (target) {
 775    case GL_VERTEX_PROGRAM_ARB:
 776       inputs = vertInputs;
 777       break;
 778    case GL_FRAGMENT_PROGRAM_ARB:
 779       inputs = fragInputs;
 780       break;
 781    /* XXX geom program */
 782    default:
 783       _mesa_problem(NULL, "bad target in _slang_input_index");
 784       return -1;
 785    }
 786
 787    ASSERT(MAX_TEXTURE_COORD_UNITS == 8); /* if this fails, fix vertInputs above */
 788
 789    for (i = 0; inputs[i].Name; i++) {
 790       if (strcmp(inputs[i].Name, name) == 0) {
 791          /* found */
 792          *swizzleOut = inputs[i].Swizzle;
 793          return inputs[i].Attrib;
 794       }
 795    }
 796    return -1;
 797 }
 798
 799
 800 /**
 801  * Return name of the given vertex attribute (VERT_ATTRIB_x).
 802  */
 803 const char *
 804 _slang_vert_attrib_name(GLuint attrib)
 805 {
 806    GLuint i;
 807    assert(attrib < VERT_ATTRIB_GENERIC0);
 808    for (i = 0; vertInputs[i].Name; i++) {
 809       if (vertInputs[i].Attrib == attrib)
 810          return vertInputs[i].Name;
 811    }
 812    return NULL;
 813 }
 814
 815
 816 /**
 817  * Return type (GL_FLOAT, GL_FLOAT_VEC2, etc) of the given vertex
 818  * attribute (VERT_ATTRIB_x).
 819  */
 820 GLenum
 821 _slang_vert_attrib_type(GLuint attrib)
 822 {
 823    GLuint i;
 824    assert(attrib < VERT_ATTRIB_GENERIC0);
 825    for (i = 0; vertInputs[i].Name; i++) {
 826       if (vertInputs[i].Attrib == attrib)
 827          return vertInputs[i].Type;
 828    }
 829    return GL_NONE;
 830 }
 831
 832
 833
 834
 835
 836 /** Predefined shader output info */
 837 struct output_info
 838 {
 839    const char *Name;
 840    GLuint Attrib;
 841    GLenum Type;
 842 };
 843
 844 /** Predefined vertex shader outputs */
 845 static const struct output_info vertOutputs[] = {
 846    { "gl_Position", VERT_RESULT_HPOS, GL_FLOAT_VEC4 },
 847    { "gl_FrontColor", VERT_RESULT_COL0, GL_FLOAT_VEC4 },
 848    { "gl_BackColor", VERT_RESULT_BFC0, GL_FLOAT_VEC4 },
 849    { "gl_FrontSecondaryColor", VERT_RESULT_COL1, GL_FLOAT_VEC4 },
 850    { "gl_BackSecondaryColor", VERT_RESULT_BFC1, GL_FLOAT_VEC4 },
 851    { "gl_TexCoord", VERT_RESULT_TEX0, GL_FLOAT_VEC4 },
 852    { "gl_FogFragCoord", VERT_RESULT_FOGC, GL_FLOAT },
 853    { "gl_PointSize", VERT_RESULT_PSIZ, GL_FLOAT },
 854    { NULL, 0, GL_NONE }
 855 };
 856
 857 /** Predefined fragment shader outputs */
 858 static const struct output_info fragOutputs[] = {
 859    { "gl_FragColor", FRAG_RESULT_COLOR, GL_FLOAT_VEC4 },
 860    { "gl_FragDepth", FRAG_RESULT_DEPTH, GL_FLOAT },
 861    { "gl_FragData", FRAG_RESULT_DATA0, GL_FLOAT_VEC4 },
 862    { NULL, 0, GL_NONE }
 863 };
 864
 865
 866 /**
 867  * Return the VERT_RESULT_* or FRAG_RESULT_* value that corresponds to
 868  * a vertex or fragment program output variable.  Return -1 for an invalid
 869  * output name.
 870  */
 871 GLint
 872 _slang_output_index(const char *name, GLenum target)
 873 {
 874    const struct output_info *outputs;
 875    GLuint i;
 876
 877    switch (target) {
 878    case GL_VERTEX_PROGRAM_ARB:
 879       outputs = vertOutputs;
 880       break;
 881    case GL_FRAGMENT_PROGRAM_ARB:
 882       outputs = fragOutputs;
 883       break;
 884    /* XXX geom program */
 885    default:
 886       _mesa_problem(NULL, "bad target in _slang_output_index");
 887       return -1;
 888    }
 889
 890    for (i = 0; outputs[i].Name; i++) {
 891       if (strcmp(outputs[i].Name, name) == 0) {
 892          /* found */
 893          return outputs[i].Attrib;
 894       }
 895    }
 896    return -1;
 897 }
 898
 899
 900 /**
 901  * Given a VERT_RESULT_x index, return the corresponding string name.
 902  */
 903 const char *
 904 _slang_vertex_output_name(gl_vert_result index)
 905 {
 906    if (index < Elements(vertOutputs))
 907       return vertOutputs[index].Name;
 908    else
 909       return NULL;
 910 }
 911
 912
 913 /**
 914  * Given a FRAG_RESULT_x index, return the corresponding string name.
 915  */
 916 const char *
 917 _slang_fragment_output_name(gl_frag_result index)
 918 {
 919    if (index < Elements(fragOutputs))
 920       return fragOutputs[index].Name;
 921    else
 922       return NULL;
 923 }
 924
 925
 926 /**
 927  * Given a VERT_RESULT_x index, return the corresponding varying
 928  * var's datatype.
 929  */
 930 GLenum
 931 _slang_vertex_output_type(gl_vert_result index)
 932 {
 933    if (index < Elements(vertOutputs))
 934       return vertOutputs[index].Type;
 935    else
 936       return GL_NONE;
 937 }