src/mesa/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 "program/program.h"
  35 #include "program/prog_instruction.h"
  36 #include "program/prog_parameter.h"
  37 #include "program/prog_statevars.h"
  38 #include "slang/slang_ir.h"
  39 #include "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 rows (or 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 if (strcmp(name, "gl_TextureMatrix") == 0) {
 493          tokens[0] = STATE_TEXTURE_MATRIX;
 494          tokens[4] = STATE_MATRIX_TRANSPOSE;
 495       }
 496       else if (strcmp(name, "gl_TextureMatrixInverse") == 0) {
 497          tokens[0] = STATE_TEXTURE_MATRIX;
 498          tokens[4] = STATE_MATRIX_INVTRANS;
 499       }
 500       else if (strcmp(name, "gl_TextureMatrixTranspose") == 0) {
 501          tokens[0] = STATE_TEXTURE_MATRIX;
 502          tokens[4] = 0;
 503       }
 504       else if (strcmp(name, "gl_TextureMatrixInverseTranspose") == 0) {
 505          tokens[0] = STATE_TEXTURE_MATRIX;
 506          tokens[4] = STATE_MATRIX_INVERSE;
 507       }
 508       else {
 509          return -1; /* invalid array name */
 510       }
 511       /* emit state vars for each array element */
 512       for (i = 0; i < array_len; i++) {
 513          GLint p;
 514          tokens[1] = i;
 515          p = emit_statevars(NULL, 0, type->_array, tokens, paramList);
 516          if (i == 0)
 517             pos = p;
 518       }
 519       return pos;
 520    }
 521    else if (type->type == SLANG_SPEC_STRUCT) {
 522       const slang_variable_scope *fields = type->_struct->fields;
 523       GLuint i, pos = 0;
 524       for (i = 0; i < fields->num_variables; i++) {
 525          const slang_variable *var = fields->variables[i];
 526          GLint p = emit_statevars(var->a_name, 0, &var->type.specifier,
 527                                   tokens, paramList);
 528          if (i == 0)
 529             pos = p;
 530       }
 531       return pos;
 532    }
 533    else if (type->type == SLANG_SPEC_MAT4) {
 534       /* unroll/emit 4 array rows (or columns) */
 535       slang_type_specifier vec4;
 536       GLint i, p, pos = -1;
 537       vec4.type = SLANG_SPEC_VEC4;
 538       for (i = 0; i < 4; i++) {
 539          tokens[2] = tokens[3] = i; /* row[i] (or column[i]) of matrix */
 540          p = emit_statevars(NULL, 0, &vec4, tokens, paramList);
 541          if (pos == -1)
 542             pos = p;
 543       }
 544       return pos;
 545    }
 546    else {
 547       GLint pos;
 548       assert(type->type == SLANG_SPEC_VEC4 ||
 549              type->type == SLANG_SPEC_VEC3 ||
 550              type->type == SLANG_SPEC_VEC2 ||
 551              type->type == SLANG_SPEC_FLOAT ||
 552              type->type == SLANG_SPEC_IVEC4 ||
 553              type->type == SLANG_SPEC_IVEC3 ||
 554              type->type == SLANG_SPEC_IVEC2 ||
 555              type->type == SLANG_SPEC_INT);
 556       if (name) {
 557          GLint t;
 558
 559          if (tokens[0] == STATE_LIGHT)
 560             t = 2;
 561          else if (tokens[0] == STATE_LIGHTPROD)
 562             t = 3;
 563          else
 564             return -1; /* invalid array name */
 565
 566          if (strcmp(name, "ambient") == 0) {
 567             tokens[t] = STATE_AMBIENT;
 568          }
 569          else if (strcmp(name, "diffuse") == 0) {
 570             tokens[t] = STATE_DIFFUSE;
 571          }
 572          else if (strcmp(name, "specular") == 0) {
 573             tokens[t] = STATE_SPECULAR;
 574          }
 575          else if (strcmp(name, "position") == 0) {
 576             tokens[t] = STATE_POSITION;
 577          }
 578          else if (strcmp(name, "halfVector") == 0) {
 579             tokens[t] = STATE_HALF_VECTOR;
 580          }
 581          else if (strcmp(name, "spotDirection") == 0) {
 582             tokens[t] = STATE_SPOT_DIRECTION; /* xyz components */
 583          }
 584          else if (strcmp(name, "spotCosCutoff") == 0) {
 585             tokens[t] = STATE_SPOT_DIRECTION; /* w component */
 586          }
 587
 588          else if (strcmp(name, "constantAttenuation") == 0) {
 589             tokens[t] = STATE_ATTENUATION; /* x component */
 590          }
 591          else if (strcmp(name, "linearAttenuation") == 0) {
 592             tokens[t] = STATE_ATTENUATION; /* y component */
 593          }
 594          else if (strcmp(name, "quadraticAttenuation") == 0) {
 595             tokens[t] = STATE_ATTENUATION; /* z component */
 596          }
 597          else if (strcmp(name, "spotExponent") == 0) {
 598             tokens[t] = STATE_ATTENUATION; /* w = spot exponent */
 599          }
 600
 601          else if (strcmp(name, "spotCutoff") == 0) {
 602             tokens[t] = STATE_SPOT_CUTOFF; /* x component */
 603          }
 604
 605          else {
 606             return -1; /* invalid field name */
 607          }
 608       }
 609
 610       pos = _mesa_add_state_reference(paramList, tokens);
 611       return pos;
 612    }
 613
 614    return 1;
 615 }
 616
 617
 618 /**
 619  * Unroll the named built-in uniform variable into a sequence of state
 620  * vars in the given parameter list.
 621  */
 622 static GLint
 623 alloc_state_var_array(const slang_variable *var,
 624                       struct gl_program_parameter_list *paramList)
 625 {
 626    gl_state_index tokens[STATE_LENGTH];
 627    GLuint i;
 628    GLint pos;
 629
 630    /* Initialize the state tokens array.  This is very important.
 631     * When we call _mesa_add_state_reference() it'll searches the parameter
 632     * list to see if the given statevar token sequence is already present.
 633     * This is normally a good thing since it prevents redundant values in the
 634     * constant buffer.
 635     *
 636     * But when we're building arrays of state this can be bad.  For example,
 637     * consider this fragment of GLSL code:
 638     *   foo = gl_LightSource[3].diffuse;
 639     *   ...
 640     *   bar = gl_LightSource[i].diffuse;
 641     *
 642     * When we unroll the gl_LightSource array (for "bar") we want to re-emit
 643     * gl_LightSource[3].diffuse and not re-use the first instance (from "foo")
 644     * since that would upset the array layout.  We handle this situation by
 645     * setting the last token in the state var token array to the special
 646     * value STATE_ARRAY.
 647     * This token will only be set for array state.  We can hijack the last
 648     * element in the array for this since it's never used for light, clipplane
 649     * or texture env array state.
 650     */
 651    for (i = 0; i < STATE_LENGTH; i++)
 652       tokens[i] = 0;
 653    tokens[STATE_LENGTH - 1] = STATE_ARRAY;
 654
 655    pos = emit_statevars(var->a_name, var->array_len, &var->type.specifier,
 656                         tokens, paramList);
 657
 658    return pos;
 659 }
 660
 661
 662
 663 /**
 664  * Allocate storage for a pre-defined uniform (a GL state variable).
 665  * As a memory-saving optimization, we try to only allocate storage for
 666  * state vars that are actually used.
 667  *
 668  * Arrays such as gl_LightSource are handled specially.  For an expression
 669  * like "gl_LightSource[2].diffuse", we can allocate a single uniform/constant
 670  * slot and return the index.  In this case, we return direct=TRUE.
 671  *
 672  * Buf for something like "gl_LightSource[i].diffuse" we don't know the value
 673  * of 'i' at compile time so we need to "unroll" the gl_LightSource array
 674  * into a consecutive sequence of uniform/constant slots so it can be indexed
 675  * at runtime.  In this case, we return direct=FALSE.
 676  *
 677  * Currently, all pre-defined uniforms are in one of these forms:
 678  *   var
 679  *   var[i]
 680  *   var.field
 681  *   var[i].field
 682  *   var[i][j]
 683  *
 684  * \return -1 upon error, else position in paramList of the state variable/data
 685  */
 686 GLint
 687 _slang_alloc_statevar(slang_ir_node *n,
 688                       struct gl_program_parameter_list *paramList,
 689                       GLboolean *direct)
 690 {
 691    slang_ir_node *n0 = n;
 692    const char *field = NULL;
 693    GLint index1 = -1, index2 = -1;
 694    GLuint swizzle;
 695
 696    *direct = GL_TRUE;
 697
 698    if (n->Opcode == IR_FIELD) {
 699       field = n->Field;
 700       n = n->Children[0];
 701    }
 702
 703    if (n->Opcode == IR_ELEMENT) {
 704       if (n->Children[1]->Opcode == IR_FLOAT) {
 705          index1 = (GLint) n->Children[1]->Value[0];
 706       }
 707       else {
 708          *direct = GL_FALSE;
 709       }
 710       n = n->Children[0];
 711    }
 712
 713    if (n->Opcode == IR_ELEMENT) {
 714       /* XXX can only handle constant indexes for now */
 715       if (n->Children[1]->Opcode == IR_FLOAT) {
 716          /* two-dimensional array index: mat[i][j] */
 717          index2 = index1;
 718          index1 = (GLint) n->Children[1]->Value[0];
 719       }
 720       else {
 721          *direct = GL_FALSE;
 722       }
 723       n = n->Children[0];
 724    }
 725
 726    assert(n->Opcode == IR_VAR);
 727
 728    if (*direct) {
 729       const char *var = (const char *) n->Var->a_name;
 730       GLint pos =
 731          lookup_statevar(var, index1, index2, field, &swizzle, paramList);
 732       if (pos >= 0) {
 733          /* newly resolved storage for the statevar/constant/uniform */
 734          n0->Store->File = PROGRAM_STATE_VAR;
 735          n0->Store->Index = pos;
 736          n0->Store->Swizzle = swizzle;
 737          n0->Store->Parent = NULL;
 738          return pos;
 739       }
 740    }
 741
 742    *direct = GL_FALSE;
 743    return alloc_state_var_array(n->Var, paramList);
 744 }
 745
 746
 747
 748
 749 #define SWIZZLE_ZWWW MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
 750
 751
 752 /** Predefined shader inputs */
 753 struct input_info
 754 {
 755    const char *Name;
 756    GLuint Attrib;
 757    GLenum Type;
 758    GLuint Swizzle;
 759    GLboolean Array;
 760 };
 761
 762 /** Predefined vertex shader inputs/attributes */
 763 static const struct input_info vertInputs[] = {
 764    { "gl_Vertex", VERT_ATTRIB_POS, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 765    { "gl_Normal", VERT_ATTRIB_NORMAL, GL_FLOAT_VEC3, SWIZZLE_NOOP, GL_FALSE },
 766    { "gl_Color", VERT_ATTRIB_COLOR0, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 767    { "gl_SecondaryColor", VERT_ATTRIB_COLOR1, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 768    { "gl_FogCoord", VERT_ATTRIB_FOG, GL_FLOAT, SWIZZLE_XXXX, GL_FALSE },
 769    { "gl_MultiTexCoord0", VERT_ATTRIB_TEX0, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 770    { "gl_MultiTexCoord1", VERT_ATTRIB_TEX1, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 771    { "gl_MultiTexCoord2", VERT_ATTRIB_TEX2, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 772    { "gl_MultiTexCoord3", VERT_ATTRIB_TEX3, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 773    { "gl_MultiTexCoord4", VERT_ATTRIB_TEX4, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 774    { "gl_MultiTexCoord5", VERT_ATTRIB_TEX5, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 775    { "gl_MultiTexCoord6", VERT_ATTRIB_TEX6, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 776    { "gl_MultiTexCoord7", VERT_ATTRIB_TEX7, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE }
 777 };
 778
 779 static const struct input_info geomInputs[] = {
 780    { "gl_PrimitiveIDIn", GEOM_ATTRIB_PRIMITIVE_ID, GL_FLOAT, SWIZZLE_NOOP, GL_FALSE },
 781    { "gl_FrontColorIn", GEOM_ATTRIB_COLOR0, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 782    { "gl_BackColorIn", GEOM_ATTRIB_COLOR1, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 783    { "gl_FrontSecondaryColorIn", GEOM_ATTRIB_SECONDARY_COLOR0, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 784    { "gl_BackSecondaryColorIn", GEOM_ATTRIB_SECONDARY_COLOR1, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 785    { "gl_TexCoordIn", GEOM_ATTRIB_TEX_COORD, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 786    { "gl_FogFragCoordIn", GEOM_ATTRIB_FOG_FRAG_COORD, GL_FLOAT, SWIZZLE_NOOP, GL_TRUE },
 787    { "gl_PositionIn", GEOM_ATTRIB_POSITION, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 788    { "gl_ClipVertexIn", GEOM_ATTRIB_CLIP_VERTEX, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_TRUE },
 789    { "gl_PointSizeIn", GEOM_ATTRIB_POINT_SIZE, GL_FLOAT, SWIZZLE_NOOP, GL_TRUE }
 790 };
 791
 792 /** Predefined fragment shader inputs */
 793 static const struct input_info fragInputs[] = {
 794    { "gl_FragCoord", FRAG_ATTRIB_WPOS, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 795    { "gl_Color", FRAG_ATTRIB_COL0, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 796    { "gl_SecondaryColor", FRAG_ATTRIB_COL1, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 797    { "gl_TexCoord", FRAG_ATTRIB_TEX0, GL_FLOAT_VEC4, SWIZZLE_NOOP, GL_FALSE },
 798    { "gl_FogFragCoord", FRAG_ATTRIB_FOGC, GL_FLOAT, SWIZZLE_XXXX, GL_FALSE },
 799    { "gl_FrontFacing", FRAG_ATTRIB_FACE, GL_FLOAT, SWIZZLE_XXXX, GL_FALSE },
 800    { "gl_PointCoord", FRAG_ATTRIB_PNTC, GL_FLOAT_VEC2, SWIZZLE_XYZW, GL_FALSE }
 801 };
 802
 803
 804 /**
 805  * Return the VERT_ATTRIB_* or FRAG_ATTRIB_* value that corresponds to
 806  * a vertex or fragment program input variable.  Return -1 if the input
 807  * name is invalid.
 808  * XXX return size too
 809  */
 810 GLint
 811 _slang_input_index(const char *name, GLenum target, GLuint *swizzleOut,
 812                    GLboolean *is_array)
 813 {
 814    const struct input_info *inputs;
 815    GLuint i, n;
 816
 817    switch (target) {
 818    case GL_VERTEX_PROGRAM_ARB:
 819       inputs = vertInputs;
 820       n = Elements(vertInputs);
 821       break;
 822    case GL_FRAGMENT_PROGRAM_ARB:
 823       inputs = fragInputs;
 824       n = Elements(fragInputs);
 825       break;
 826    case MESA_GEOMETRY_PROGRAM:
 827       inputs = geomInputs;
 828       n = Elements(geomInputs);
 829       break;
 830    default:
 831       _mesa_problem(NULL, "bad target in _slang_input_index");
 832       return -1;
 833    }
 834
 835    ASSERT(MAX_TEXTURE_COORD_UNITS == 8); /* if this fails, fix vertInputs above */
 836
 837    for (i = 0; i < n; i++) {
 838       if (strcmp(inputs[i].Name, name) == 0) {
 839          /* found */
 840          *swizzleOut = inputs[i].Swizzle;
 841          if (is_array)
 842             *is_array = inputs[i].Array;
 843          return inputs[i].Attrib;
 844       }
 845    }
 846    return -1;
 847 }
 848
 849
 850 /**
 851  * Return name of the given vertex attribute (VERT_ATTRIB_x).
 852  */
 853 const char *
 854 _slang_vert_attrib_name(GLuint attrib)
 855 {
 856    GLuint i;
 857    assert(attrib < VERT_ATTRIB_GENERIC0);
 858    for (i = 0; Elements(vertInputs); i++) {
 859       if (vertInputs[i].Attrib == attrib)
 860          return vertInputs[i].Name;
 861    }
 862    return NULL;
 863 }
 864
 865
 866 /**
 867  * Return type (GL_FLOAT, GL_FLOAT_VEC2, etc) of the given vertex
 868  * attribute (VERT_ATTRIB_x).
 869  */
 870 GLenum
 871 _slang_vert_attrib_type(GLuint attrib)
 872 {
 873    GLuint i;
 874    assert(attrib < VERT_ATTRIB_GENERIC0);
 875    for (i = 0; Elements(vertInputs); i++) {
 876       if (vertInputs[i].Attrib == attrib)
 877          return vertInputs[i].Type;
 878    }
 879    return GL_NONE;
 880 }
 881
 882
 883
 884
 885
 886 /** Predefined shader output info */
 887 struct output_info
 888 {
 889    const char *Name;
 890    GLuint Attrib;
 891    GLenum Type;
 892 };
 893
 894 /** Predefined vertex shader outputs */
 895 static const struct output_info vertOutputs[] = {
 896    { "gl_Position", VERT_RESULT_HPOS, GL_FLOAT_VEC4 },
 897    { "gl_FrontColor", VERT_RESULT_COL0, GL_FLOAT_VEC4 },
 898    { "gl_BackColor", VERT_RESULT_BFC0, GL_FLOAT_VEC4 },
 899    { "gl_FrontSecondaryColor", VERT_RESULT_COL1, GL_FLOAT_VEC4 },
 900    { "gl_BackSecondaryColor", VERT_RESULT_BFC1, GL_FLOAT_VEC4 },
 901    { "gl_TexCoord", VERT_RESULT_TEX0, GL_FLOAT_VEC4 },
 902    { "gl_FogFragCoord", VERT_RESULT_FOGC, GL_FLOAT },
 903    { "gl_PointSize", VERT_RESULT_PSIZ, GL_FLOAT }
 904 };
 905
 906 /** Predefined geometry shader outputs */
 907 static const struct output_info geomOutputs[] = {
 908    { "gl_Position", GEOM_RESULT_POS, GL_FLOAT_VEC4 },
 909    { "gl_FrontColor", GEOM_RESULT_COL0, GL_FLOAT_VEC4  },
 910    { "gl_BackColor", GEOM_RESULT_COL1, GL_FLOAT_VEC4  },
 911    { "gl_FrontSecondaryColor", GEOM_RESULT_SCOL0, GL_FLOAT_VEC4  },
 912    { "gl_BackSecondaryColor", GEOM_RESULT_SCOL1, GL_FLOAT_VEC4  },
 913    { "gl_TexCoord", GEOM_RESULT_TEX0, GL_FLOAT_VEC4  },
 914    { "gl_FogFragCoord", GEOM_RESULT_FOGC, GL_FLOAT  },
 915    { "gl_ClipVertex", GEOM_RESULT_CLPV, GL_FLOAT_VEC4  },
 916    { "gl_PointSize", GEOM_RESULT_PSIZ, GL_FLOAT  },
 917    { "gl_PrimitiveID", GEOM_RESULT_PRID, GL_FLOAT  },
 918    { "gl_Layer", GEOM_RESULT_LAYR, GL_FLOAT  }
 919 };
 920
 921 /** Predefined fragment shader outputs */
 922 static const struct output_info fragOutputs[] = {
 923    { "gl_FragColor", FRAG_RESULT_COLOR, GL_FLOAT_VEC4 },
 924    { "gl_FragDepth", FRAG_RESULT_DEPTH, GL_FLOAT },
 925    { "gl_FragData", FRAG_RESULT_DATA0, GL_FLOAT_VEC4 }
 926 };
 927
 928
 929 /**
 930  * Return the VERT_RESULT_*, GEOM_RESULT_* or FRAG_RESULT_* value that corresponds
 931  * to a vertex or fragment program output variable.  Return -1 for an invalid
 932  * output name.
 933  */
 934 GLint
 935 _slang_output_index(const char *name, GLenum target)
 936 {
 937    const struct output_info *outputs;
 938    GLuint i, n;
 939
 940    switch (target) {
 941    case GL_VERTEX_PROGRAM_ARB:
 942       outputs = vertOutputs;
 943       n = Elements(vertOutputs);
 944       break;
 945    case GL_FRAGMENT_PROGRAM_ARB:
 946       outputs = fragOutputs;
 947       n = Elements(fragOutputs);
 948       break;
 949    case MESA_GEOMETRY_PROGRAM:
 950       outputs = geomOutputs;
 951       n = Elements(geomOutputs);
 952       break;
 953    default:
 954       _mesa_problem(NULL, "bad target in _slang_output_index");
 955       return -1;
 956    }
 957
 958    for (i = 0; i < n; i++) {
 959       if (strcmp(outputs[i].Name, name) == 0) {
 960          /* found */
 961          return outputs[i].Attrib;
 962       }
 963    }
 964    return -1;
 965 }
 966
 967
 968 /**
 969  * Given a VERT_RESULT_x index, return the corresponding string name.
 970  */
 971 const char *
 972 _slang_vertex_output_name(gl_vert_result index)
 973 {
 974    if (index < Elements(vertOutputs))
 975       return vertOutputs[index].Name;
 976    else
 977       return NULL;
 978 }
 979
 980
 981 /**
 982  * Given a GEOM_RESULT_x index, return the corresponding string name.
 983  */
 984 const char *
 985 _slang_geometry_output_name(gl_geom_result index)
 986 {
 987    if (index < Elements(geomOutputs))
 988       return geomOutputs[index].Name;
 989    else
 990       return NULL;
 991 }
 992
 993
 994 /**
 995  * Given a FRAG_RESULT_x index, return the corresponding string name.
 996  */
 997 const char *
 998 _slang_fragment_output_name(gl_frag_result index)
 999 {
1000    if (index < Elements(fragOutputs))
1001       return fragOutputs[index].Name;
1002    else
1003       return NULL;
1004 }
1005
1006
1007 /**
1008  * Given a VERT_RESULT_x index, return the corresponding varying
1009  * var's datatype.
1010  */
1011 GLenum
1012 _slang_vertex_output_type(gl_vert_result index)
1013 {
1014    if (index < Elements(vertOutputs))
1015       return vertOutputs[index].Type;
1016    else
1017       return GL_NONE;
1018 }