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       if (strcmp(field, "near") == 0) {
 125          *swizzleOut = SWIZZLE_XXXX;
 126       }
 127       else if (strcmp(field, "far") == 0) {
 128          *swizzleOut = SWIZZLE_YYYY;
 129       }
 130       else if (strcmp(field, "diff") == 0) {
 131          *swizzleOut = SWIZZLE_ZZZZ;
 132       }
 133       else {
 134          return -1;
 135       }
 136    }
 137    else if (strcmp(var, "gl_ClipPlane") == 0) {
 138       if (index1 < 0)
 139          return -1;
 140       tokens[0] = STATE_CLIPPLANE;
 141       tokens[1] = index1;
 142    }
 143    else if (strcmp(var, "gl_Point") == 0) {
 144       if (strcmp(field, "size") == 0) {
 145          tokens[0] = STATE_POINT_SIZE;
 146          *swizzleOut = SWIZZLE_XXXX;
 147       }
 148       else if (strcmp(field, "sizeMin") == 0) {
 149          tokens[0] = STATE_POINT_SIZE;
 150          *swizzleOut = SWIZZLE_YYYY;
 151       }
 152       else if (strcmp(field, "sizeMax") == 0) {
 153          tokens[0] = STATE_POINT_SIZE;
 154          *swizzleOut = SWIZZLE_ZZZZ;
 155       }
 156       else if (strcmp(field, "fadeThresholdSize") == 0) {
 157          tokens[0] = STATE_POINT_SIZE;
 158          *swizzleOut = SWIZZLE_WWWW;
 159       }
 160       else if (strcmp(field, "distanceConstantAttenuation") == 0) {
 161          tokens[0] = STATE_POINT_ATTENUATION;
 162          *swizzleOut = SWIZZLE_XXXX;
 163       }
 164       else if (strcmp(field, "distanceLinearAttenuation") == 0) {
 165          tokens[0] = STATE_POINT_ATTENUATION;
 166          *swizzleOut = SWIZZLE_YYYY;
 167       }
 168       else if (strcmp(field, "distanceQuadraticAttenuation") == 0) {
 169          tokens[0] = STATE_POINT_ATTENUATION;
 170          *swizzleOut = SWIZZLE_ZZZZ;
 171       }
 172       else {
 173          return -1;
 174       }
 175    }
 176    else if (strcmp(var, "gl_FrontMaterial") == 0 ||
 177             strcmp(var, "gl_BackMaterial") == 0) {
 178       tokens[0] = STATE_MATERIAL;
 179       if (strcmp(var, "gl_FrontMaterial") == 0)
 180          tokens[1] = 0;
 181       else
 182          tokens[1] = 1;
 183       if (strcmp(field, "emission") == 0) {
 184          tokens[2] = STATE_EMISSION;
 185       }
 186       else if (strcmp(field, "ambient") == 0) {
 187          tokens[2] = STATE_AMBIENT;
 188       }
 189       else if (strcmp(field, "diffuse") == 0) {
 190          tokens[2] = STATE_DIFFUSE;
 191       }
 192       else if (strcmp(field, "specular") == 0) {
 193          tokens[2] = STATE_SPECULAR;
 194       }
 195       else if (strcmp(field, "shininess") == 0) {
 196          tokens[2] = STATE_SHININESS;
 197          *swizzleOut = SWIZZLE_XXXX;
 198       }
 199       else {
 200          return -1;
 201       }
 202    }
 203    else if (strcmp(var, "gl_LightSource") == 0) {
 204       if (!field || index1 < 0)
 205          return -1;
 206
 207       tokens[0] = STATE_LIGHT;
 208       tokens[1] = index1;
 209
 210       if (strcmp(field, "ambient") == 0) {
 211          tokens[2] = STATE_AMBIENT;
 212       }
 213       else if (strcmp(field, "diffuse") == 0) {
 214          tokens[2] = STATE_DIFFUSE;
 215       }
 216       else if (strcmp(field, "specular") == 0) {
 217          tokens[2] = STATE_SPECULAR;
 218       }
 219       else if (strcmp(field, "position") == 0) {
 220          tokens[2] = STATE_POSITION;
 221       }
 222       else if (strcmp(field, "halfVector") == 0) {
 223          tokens[2] = STATE_HALF_VECTOR;
 224       }
 225       else if (strcmp(field, "spotDirection") == 0) {
 226          tokens[2] = STATE_SPOT_DIRECTION;
 227       }
 228       else if (strcmp(field, "spotCosCutoff") == 0) {
 229          tokens[2] = STATE_SPOT_DIRECTION;
 230          *swizzleOut = SWIZZLE_WWWW;
 231       }
 232       else if (strcmp(field, "spotCutoff") == 0) {
 233          tokens[2] = STATE_SPOT_CUTOFF;
 234          *swizzleOut = SWIZZLE_XXXX;
 235       }
 236       else if (strcmp(field, "spotExponent") == 0) {
 237          tokens[2] = STATE_ATTENUATION;
 238          *swizzleOut = SWIZZLE_WWWW;
 239       }
 240       else if (strcmp(field, "constantAttenuation") == 0) {
 241          tokens[2] = STATE_ATTENUATION;
 242          *swizzleOut = SWIZZLE_XXXX;
 243       }
 244       else if (strcmp(field, "linearAttenuation") == 0) {
 245          tokens[2] = STATE_ATTENUATION;
 246          *swizzleOut = SWIZZLE_YYYY;
 247       }
 248       else if (strcmp(field, "quadraticAttenuation") == 0) {
 249          tokens[2] = STATE_ATTENUATION;
 250          *swizzleOut = SWIZZLE_ZZZZ;
 251       }
 252       else {
 253          return -1;
 254       }
 255    }
 256    else if (strcmp(var, "gl_LightModel") == 0) {
 257       if (strcmp(field, "ambient") == 0) {
 258          tokens[0] = STATE_LIGHTMODEL_AMBIENT;
 259       }
 260       else {
 261          return -1;
 262       }
 263    }
 264    else if (strcmp(var, "gl_FrontLightModelProduct") == 0) {
 265       if (strcmp(field, "sceneColor") == 0) {
 266          tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
 267          tokens[1] = 0;
 268       }
 269       else {
 270          return -1;
 271       }
 272    }
 273    else if (strcmp(var, "gl_BackLightModelProduct") == 0) {
 274       if (strcmp(field, "sceneColor") == 0) {
 275          tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
 276          tokens[1] = 1;
 277       }
 278       else {
 279          return -1;
 280       }
 281    }
 282    else if (strcmp(var, "gl_FrontLightProduct") == 0 ||
 283             strcmp(var, "gl_BackLightProduct") == 0) {
 284       if (index1 < 0 || !field)
 285          return -1;
 286
 287       tokens[0] = STATE_LIGHTPROD;
 288       tokens[1] = index1; /* light number */
 289       if (strcmp(var, "gl_FrontLightProduct") == 0) {
 290          tokens[2] = 0; /* front */
 291       }
 292       else {
 293          tokens[2] = 1; /* back */
 294       }
 295       if (strcmp(field, "ambient") == 0) {
 296          tokens[3] = STATE_AMBIENT;
 297       }
 298       else if (strcmp(field, "diffuse") == 0) {
 299          tokens[3] = STATE_DIFFUSE;
 300       }
 301       else if (strcmp(field, "specular") == 0) {
 302          tokens[3] = STATE_SPECULAR;
 303       }
 304       else {
 305          return -1;
 306       }
 307    }
 308    else if (strcmp(var, "gl_TextureEnvColor") == 0) {
 309       if (index1 < 0)
 310          return -1;
 311       tokens[0] = STATE_TEXENV_COLOR;
 312       tokens[1] = index1;
 313    }
 314    else if (strcmp(var, "gl_EyePlaneS") == 0) {
 315       if (index1 < 0)
 316          return -1;
 317       tokens[0] = STATE_TEXGEN;
 318       tokens[1] = index1; /* tex unit */
 319       tokens[2] = STATE_TEXGEN_EYE_S;
 320    }
 321    else if (strcmp(var, "gl_EyePlaneT") == 0) {
 322       if (index1 < 0)
 323          return -1;
 324       tokens[0] = STATE_TEXGEN;
 325       tokens[1] = index1; /* tex unit */
 326       tokens[2] = STATE_TEXGEN_EYE_T;
 327    }
 328    else if (strcmp(var, "gl_EyePlaneR") == 0) {
 329       if (index1 < 0)
 330          return -1;
 331       tokens[0] = STATE_TEXGEN;
 332       tokens[1] = index1; /* tex unit */
 333       tokens[2] = STATE_TEXGEN_EYE_R;
 334    }
 335    else if (strcmp(var, "gl_EyePlaneQ") == 0) {
 336       if (index1 < 0)
 337          return -1;
 338       tokens[0] = STATE_TEXGEN;
 339       tokens[1] = index1; /* tex unit */
 340       tokens[2] = STATE_TEXGEN_EYE_Q;
 341    }
 342    else if (strcmp(var, "gl_ObjectPlaneS") == 0) {
 343       if (index1 < 0)
 344          return -1;
 345       tokens[0] = STATE_TEXGEN;
 346       tokens[1] = index1; /* tex unit */
 347       tokens[2] = STATE_TEXGEN_OBJECT_S;
 348    }
 349    else if (strcmp(var, "gl_ObjectPlaneT") == 0) {
 350       if (index1 < 0)
 351          return -1;
 352       tokens[0] = STATE_TEXGEN;
 353       tokens[1] = index1; /* tex unit */
 354       tokens[2] = STATE_TEXGEN_OBJECT_T;
 355    }
 356    else if (strcmp(var, "gl_ObjectPlaneR") == 0) {
 357       if (index1 < 0)
 358          return -1;
 359       tokens[0] = STATE_TEXGEN;
 360       tokens[1] = index1; /* tex unit */
 361       tokens[2] = STATE_TEXGEN_OBJECT_R;
 362    }
 363    else if (strcmp(var, "gl_ObjectPlaneQ") == 0) {
 364       if (index1 < 0)
 365          return -1;
 366       tokens[0] = STATE_TEXGEN;
 367       tokens[1] = index1; /* tex unit */
 368       tokens[2] = STATE_TEXGEN_OBJECT_Q;
 369    }
 370    else if (strcmp(var, "gl_Fog") == 0) {
 371       if (strcmp(field, "color") == 0) {
 372          tokens[0] = STATE_FOG_COLOR;
 373       }
 374       else if (strcmp(field, "density") == 0) {
 375          tokens[0] = STATE_FOG_PARAMS;
 376          *swizzleOut = SWIZZLE_XXXX;
 377       }
 378       else if (strcmp(field, "start") == 0) {
 379          tokens[0] = STATE_FOG_PARAMS;
 380          *swizzleOut = SWIZZLE_YYYY;
 381       }
 382       else if (strcmp(field, "end") == 0) {
 383          tokens[0] = STATE_FOG_PARAMS;
 384          *swizzleOut = SWIZZLE_ZZZZ;
 385       }
 386       else if (strcmp(field, "scale") == 0) {
 387          tokens[0] = STATE_FOG_PARAMS;
 388          *swizzleOut = SWIZZLE_WWWW;
 389       }
 390       else {
 391          return -1;
 392       }
 393    }
 394    else {
 395       return -1;
 396    }
 397
 398    if (isMatrix) {
 399       /* load all four columns of matrix */
 400       GLint pos[4];
 401       GLuint j;
 402       for (j = 0; j < 4; j++) {
 403          tokens[2] = tokens[3] = j; /* jth row of matrix */
 404          pos[j] = _mesa_add_state_reference(paramList, tokens);
 405          assert(pos[j] >= 0);
 406          ASSERT(pos[j] >= 0);
 407       }
 408       return pos[0] + index1;
 409    }
 410    else {
 411       /* allocate a single register */
 412       GLint pos = _mesa_add_state_reference(paramList, tokens);
 413       ASSERT(pos >= 0);
 414       return pos;
 415    }
 416 }
 417
 418
 419
 420 /**
 421  * Given a variable name and datatype, emit uniform/constant buffer
 422  * entries which will store that state variable.
 423  * For example, if name="gl_LightSource" we'll emit 64 state variable
 424  * vectors/references and return position where that data starts.  This will
 425  * allow run-time array indexing into the light source array.
 426  *
 427  * Note that this is a recursive function.
 428  *
 429  * \return -1 if error, else index of start of data in the program parameter list
 430  */
 431 static GLint
 432 emit_statevars(const char *name, int array_len,
 433                const slang_type_specifier *type,
 434                gl_state_index tokens[STATE_LENGTH],
 435                struct gl_program_parameter_list *paramList)
 436 {
 437    if (type->type == SLANG_SPEC_ARRAY) {
 438       GLint i, pos = -1;
 439       assert(array_len > 0);
 440       if (strcmp(name, "gl_ClipPlane") == 0) {
 441          tokens[0] = STATE_CLIPPLANE;
 442       }
 443       else if (strcmp(name, "gl_LightSource") == 0) {
 444          tokens[0] = STATE_LIGHT;
 445       }
 446       else if (strcmp(name, "gl_FrontLightProduct") == 0) {
 447          tokens[0] = STATE_LIGHTPROD;
 448          tokens[2] = 0; /* front */
 449       }
 450       else if (strcmp(name, "gl_BackLightProduct") == 0) {
 451          tokens[0] = STATE_LIGHTPROD;
 452          tokens[2] = 1; /* back */
 453       }
 454       else if (strcmp(name, "gl_TextureEnvColor") == 0) {
 455          tokens[0] = STATE_TEXENV_COLOR;
 456       }
 457       else if (strcmp(name, "gl_EyePlaneS") == 0) {
 458          tokens[0] = STATE_TEXGEN;
 459          tokens[2] = STATE_TEXGEN_EYE_S;
 460       }
 461       else if (strcmp(name, "gl_EyePlaneT") == 0) {
 462          tokens[0] = STATE_TEXGEN;
 463          tokens[2] = STATE_TEXGEN_EYE_T;
 464       }
 465       else if (strcmp(name, "gl_EyePlaneR") == 0) {
 466          tokens[0] = STATE_TEXGEN;
 467          tokens[2] = STATE_TEXGEN_EYE_R;
 468       }
 469       else if (strcmp(name, "gl_EyePlaneQ") == 0) {
 470          tokens[0] = STATE_TEXGEN;
 471          tokens[2] = STATE_TEXGEN_EYE_Q;
 472       }
 473       else if (strcmp(name, "gl_ObjectPlaneS") == 0) {
 474          tokens[0] = STATE_TEXGEN;
 475          tokens[2] = STATE_TEXGEN_OBJECT_S;
 476       }
 477       else if (strcmp(name, "gl_ObjectPlaneT") == 0) {
 478          tokens[0] = STATE_TEXGEN;
 479          tokens[2] = STATE_TEXGEN_OBJECT_T;
 480       }
 481       else if (strcmp(name, "gl_ObjectPlaneR") == 0) {
 482          tokens[0] = STATE_TEXGEN;
 483          tokens[2] = STATE_TEXGEN_OBJECT_R;
 484       }
 485       else if (strcmp(name, "gl_ObjectPlaneQ") == 0) {
 486          tokens[0] = STATE_TEXGEN;
 487          tokens[2] = STATE_TEXGEN_OBJECT_Q;
 488       }
 489       else {
 490          return -1; /* invalid array name */
 491       }
 492       for (i = 0; i < array_len; i++) {
 493          GLint p;
 494          tokens[1] = i;
 495          p = emit_statevars(NULL, 0, type->_array, tokens, paramList);
 496          if (i == 0)
 497             pos = p;
 498       }
 499       return pos;
 500    }
 501    else if (type->type == SLANG_SPEC_STRUCT) {
 502       const slang_variable_scope *fields = type->_struct->fields;
 503       GLuint i, pos = 0;
 504       for (i = 0; i < fields->num_variables; i++) {
 505          const slang_variable *var = fields->variables[i];
 506          GLint p = emit_statevars(var->a_name, 0, &var->type.specifier,
 507                                   tokens, paramList);
 508          if (i == 0)
 509             pos = p;
 510       }
 511       return pos;
 512    }
 513    else {
 514       GLint pos;
 515       assert(type->type == SLANG_SPEC_VEC4 ||
 516              type->type == SLANG_SPEC_VEC3 ||
 517              type->type == SLANG_SPEC_VEC2 ||
 518              type->type == SLANG_SPEC_FLOAT ||
 519              type->type == SLANG_SPEC_IVEC4 ||
 520              type->type == SLANG_SPEC_IVEC3 ||
 521              type->type == SLANG_SPEC_IVEC2 ||
 522              type->type == SLANG_SPEC_INT);
 523       if (name) {
 524          GLint t;
 525
 526          if (tokens[0] == STATE_LIGHT)
 527             t = 2;
 528          else if (tokens[0] == STATE_LIGHTPROD)
 529             t = 3;
 530          else
 531             return -1; /* invalid array name */
 532
 533          if (strcmp(name, "ambient") == 0) {
 534             tokens[t] = STATE_AMBIENT;
 535          }
 536          else if (strcmp(name, "diffuse") == 0) {
 537             tokens[t] = STATE_DIFFUSE;
 538          }
 539          else if (strcmp(name, "specular") == 0) {
 540             tokens[t] = STATE_SPECULAR;
 541          }
 542          else if (strcmp(name, "position") == 0) {
 543             tokens[t] = STATE_POSITION;
 544          }
 545          else if (strcmp(name, "halfVector") == 0) {
 546             tokens[t] = STATE_HALF_VECTOR;
 547          }
 548          else if (strcmp(name, "spotDirection") == 0) {
 549             tokens[t] = STATE_SPOT_DIRECTION; /* xyz components */
 550          }
 551          else if (strcmp(name, "spotCosCutoff") == 0) {
 552             tokens[t] = STATE_SPOT_DIRECTION; /* w component */
 553          }
 554
 555          else if (strcmp(name, "constantAttenuation") == 0) {
 556             tokens[t] = STATE_ATTENUATION; /* x component */
 557          }
 558          else if (strcmp(name, "linearAttenuation") == 0) {
 559             tokens[t] = STATE_ATTENUATION; /* y component */
 560          }
 561          else if (strcmp(name, "quadraticAttenuation") == 0) {
 562             tokens[t] = STATE_ATTENUATION; /* z component */
 563          }
 564          else if (strcmp(name, "spotExponent") == 0) {
 565             tokens[t] = STATE_ATTENUATION; /* w = spot exponent */
 566          }
 567
 568          else if (strcmp(name, "spotCutoff") == 0) {
 569             tokens[t] = STATE_SPOT_CUTOFF; /* x component */
 570          }
 571
 572          else {
 573             return -1; /* invalid field name */
 574          }
 575       }
 576
 577       pos = _mesa_add_state_reference(paramList, tokens);
 578       return pos;
 579    }
 580
 581    return 1;
 582 }
 583
 584
 585 /**
 586  * Unroll the named built-in uniform variable into a sequence of state
 587  * vars in the given parameter list.
 588  */
 589 static GLint
 590 alloc_state_var_array(const slang_variable *var,
 591                       struct gl_program_parameter_list *paramList)
 592 {
 593    gl_state_index tokens[STATE_LENGTH];
 594    GLuint i;
 595    GLint pos;
 596
 597    /* Initialize the state tokens array.  This is very important.
 598     * When we call _mesa_add_state_reference() it'll searches the parameter
 599     * list to see if the given statevar token sequence is already present.
 600     * This is normally a good thing since it prevents redundant values in the
 601     * constant buffer.
 602     *
 603     * But when we're building arrays of state this can be bad.  For example,
 604     * consider this fragment of GLSL code:
 605     *   foo = gl_LightSource[3].diffuse;
 606     *   ...
 607     *   bar = gl_LightSource[i].diffuse;
 608     *
 609     * When we unroll the gl_LightSource array (for "bar") we want to re-emit
 610     * gl_LightSource[3].diffuse and not re-use the first instance (from "foo")
 611     * since that would upset the array layout.  We handle this situation by
 612     * setting the last token in the state var token array to the special
 613     * value STATE_ARRAY.
 614     * This token will only be set for array state.  We can hijack the last
 615     * element in the array for this since it's never used for light, clipplane
 616     * or texture env array state.
 617     */
 618    for (i = 0; i < STATE_LENGTH; i++)
 619       tokens[i] = 0;
 620    tokens[STATE_LENGTH - 1] = STATE_ARRAY;
 621
 622    pos = emit_statevars(var->a_name, var->array_len, &var->type.specifier,
 623                         tokens, paramList);
 624
 625    return pos;
 626 }
 627
 628
 629
 630 /**
 631  * Allocate storage for a pre-defined uniform (a GL state variable).
 632  * As a memory-saving optimization, we try to only allocate storage for
 633  * state vars that are actually used.
 634  *
 635  * Arrays such as gl_LightSource are handled specially.  For an expression
 636  * like "gl_LightSource[2].diffuse", we can allocate a single uniform/constant
 637  * slot and return the index.  In this case, we return direct=TRUE.
 638  *
 639  * Buf for something like "gl_LightSource[i].diffuse" we don't know the value
 640  * of 'i' at compile time so we need to "unroll" the gl_LightSource array
 641  * into a consecutive sequence of uniform/constant slots so it can be indexed
 642  * at runtime.  In this case, we return direct=FALSE.
 643  *
 644  * Currently, all pre-defined uniforms are in one of these forms:
 645  *   var
 646  *   var[i]
 647  *   var.field
 648  *   var[i].field
 649  *   var[i][j]
 650  *
 651  * \return -1 upon error, else position in paramList of the state variable/data
 652  */
 653 GLint
 654 _slang_alloc_statevar(slang_ir_node *n,
 655                       struct gl_program_parameter_list *paramList,
 656                       GLboolean *direct)
 657 {
 658    slang_ir_node *n0 = n;
 659    const char *field = NULL;
 660    GLint index1 = -1, index2 = -1;
 661    GLuint swizzle;
 662
 663    *direct = GL_TRUE;
 664
 665    if (n->Opcode == IR_FIELD) {
 666       field = n->Field;
 667       n = n->Children[0];
 668    }
 669
 670    if (n->Opcode == IR_ELEMENT) {
 671       if (n->Children[1]->Opcode == IR_FLOAT) {
 672          index1 = (GLint) n->Children[1]->Value[0];
 673       }
 674       else {
 675          *direct = GL_FALSE;
 676       }
 677       n = n->Children[0];
 678    }
 679
 680    if (n->Opcode == IR_ELEMENT) {
 681       /* XXX can only handle constant indexes for now */
 682       if (n->Children[1]->Opcode == IR_FLOAT) {
 683          /* two-dimensional array index: mat[i][j] */
 684          index2 = index1;
 685          index1 = (GLint) n->Children[1]->Value[0];
 686       }
 687       else {
 688          *direct = GL_FALSE;
 689       }
 690       n = n->Children[0];
 691    }
 692
 693    assert(n->Opcode == IR_VAR);
 694
 695    if (*direct) {
 696       const char *var = (const char *) n->Var->a_name;
 697       GLint pos =
 698          lookup_statevar(var, index1, index2, field, &swizzle, paramList);
 699       if (pos >= 0) {
 700          /* newly resolved storage for the statevar/constant/uniform */
 701          n0->Store->File = PROGRAM_STATE_VAR;
 702          n0->Store->Index = pos;
 703          n0->Store->Swizzle = swizzle;
 704          n0->Store->Parent = NULL;
 705          return pos;
 706       }
 707    }
 708
 709    *direct = GL_FALSE;
 710    return alloc_state_var_array(n->Var, paramList);
 711 }
 712
 713
 714
 715
 716 #define SWIZZLE_ZWWW MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
 717
 718
 719 /** Predefined shader inputs */
 720 struct input_info
 721 {
 722    const char *Name;
 723    GLuint Attrib;
 724    GLenum Type;
 725    GLuint Swizzle;
 726 };
 727
 728 /** Predefined vertex shader inputs/attributes */
 729 static const struct input_info vertInputs[] = {
 730    { "gl_Vertex", VERT_ATTRIB_POS, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 731    { "gl_Normal", VERT_ATTRIB_NORMAL, GL_FLOAT_VEC3, SWIZZLE_NOOP },
 732    { "gl_Color", VERT_ATTRIB_COLOR0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 733    { "gl_SecondaryColor", VERT_ATTRIB_COLOR1, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 734    { "gl_FogCoord", VERT_ATTRIB_FOG, GL_FLOAT, SWIZZLE_XXXX },
 735    { "gl_MultiTexCoord0", VERT_ATTRIB_TEX0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 736    { "gl_MultiTexCoord1", VERT_ATTRIB_TEX1, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 737    { "gl_MultiTexCoord2", VERT_ATTRIB_TEX2, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 738    { "gl_MultiTexCoord3", VERT_ATTRIB_TEX3, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 739    { "gl_MultiTexCoord4", VERT_ATTRIB_TEX4, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 740    { "gl_MultiTexCoord5", VERT_ATTRIB_TEX5, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 741    { "gl_MultiTexCoord6", VERT_ATTRIB_TEX6, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 742    { "gl_MultiTexCoord7", VERT_ATTRIB_TEX7, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 743    { NULL, 0, GL_NONE, SWIZZLE_NOOP }
 744 };
 745
 746 /** Predefined fragment shader inputs */
 747 static const struct input_info fragInputs[] = {
 748    { "gl_FragCoord", FRAG_ATTRIB_WPOS, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 749    { "gl_Color", FRAG_ATTRIB_COL0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 750    { "gl_SecondaryColor", FRAG_ATTRIB_COL1, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 751    { "gl_TexCoord", FRAG_ATTRIB_TEX0, GL_FLOAT_VEC4, SWIZZLE_NOOP },
 752    /* note: we're packing several quantities into the fogcoord vector */
 753    { "gl_FogFragCoord", FRAG_ATTRIB_FOGC, GL_FLOAT, SWIZZLE_XXXX },
 754    { "gl_FrontFacing", FRAG_ATTRIB_FACE, GL_FLOAT, SWIZZLE_XXXX },
 755    { "gl_PointCoord", FRAG_ATTRIB_PNTC, GL_FLOAT_VEC2, SWIZZLE_XYZW },
 756    { NULL, 0, GL_NONE, SWIZZLE_NOOP }
 757 };
 758
 759
 760 /**
 761  * Return the VERT_ATTRIB_* or FRAG_ATTRIB_* value that corresponds to
 762  * a vertex or fragment program input variable.  Return -1 if the input
 763  * name is invalid.
 764  * XXX return size too
 765  */
 766 GLint
 767 _slang_input_index(const char *name, GLenum target, GLuint *swizzleOut)
 768 {
 769    const struct input_info *inputs;
 770    GLuint i;
 771
 772    switch (target) {
 773    case GL_VERTEX_PROGRAM_ARB:
 774       inputs = vertInputs;
 775       break;
 776    case GL_FRAGMENT_PROGRAM_ARB:
 777       inputs = fragInputs;
 778       break;
 779    /* XXX geom program */
 780    default:
 781       _mesa_problem(NULL, "bad target in _slang_input_index");
 782       return -1;
 783    }
 784
 785    ASSERT(MAX_TEXTURE_COORD_UNITS == 8); /* if this fails, fix vertInputs above */
 786
 787    for (i = 0; inputs[i].Name; i++) {
 788       if (strcmp(inputs[i].Name, name) == 0) {
 789          /* found */
 790          *swizzleOut = inputs[i].Swizzle;
 791          return inputs[i].Attrib;
 792       }
 793    }
 794    return -1;
 795 }
 796
 797
 798 /**
 799  * Return name of the given vertex attribute (VERT_ATTRIB_x).
 800  */
 801 const char *
 802 _slang_vert_attrib_name(GLuint attrib)
 803 {
 804    GLuint i;
 805    assert(attrib < VERT_ATTRIB_GENERIC0);
 806    for (i = 0; vertInputs[i].Name; i++) {
 807       if (vertInputs[i].Attrib == attrib)
 808          return vertInputs[i].Name;
 809    }
 810    return NULL;
 811 }
 812
 813
 814 /**
 815  * Return type (GL_FLOAT, GL_FLOAT_VEC2, etc) of the given vertex
 816  * attribute (VERT_ATTRIB_x).
 817  */
 818 GLenum
 819 _slang_vert_attrib_type(GLuint attrib)
 820 {
 821    GLuint i;
 822    assert(attrib < VERT_ATTRIB_GENERIC0);
 823    for (i = 0; vertInputs[i].Name; i++) {
 824       if (vertInputs[i].Attrib == attrib)
 825          return vertInputs[i].Type;
 826    }
 827    return GL_NONE;
 828 }
 829
 830
 831
 832
 833
 834 /** Predefined shader output info */
 835 struct output_info
 836 {
 837    const char *Name;
 838    GLuint Attrib;
 839 };
 840
 841 /** Predefined vertex shader outputs */
 842 static const struct output_info vertOutputs[] = {
 843    { "gl_Position", VERT_RESULT_HPOS },
 844    { "gl_FrontColor", VERT_RESULT_COL0 },
 845    { "gl_BackColor", VERT_RESULT_BFC0 },
 846    { "gl_FrontSecondaryColor", VERT_RESULT_COL1 },
 847    { "gl_BackSecondaryColor", VERT_RESULT_BFC1 },
 848    { "gl_TexCoord", VERT_RESULT_TEX0 },
 849    { "gl_FogFragCoord", VERT_RESULT_FOGC },
 850    { "gl_PointSize", VERT_RESULT_PSIZ },
 851    { NULL, 0 }
 852 };
 853
 854 /** Predefined fragment shader outputs */
 855 static const struct output_info fragOutputs[] = {
 856    { "gl_FragColor", FRAG_RESULT_COLOR },
 857    { "gl_FragDepth", FRAG_RESULT_DEPTH },
 858    { "gl_FragData", FRAG_RESULT_DATA0 },
 859    { NULL, 0 }
 860 };
 861
 862
 863 /**
 864  * Return the VERT_RESULT_* or FRAG_RESULT_* value that corresponds to
 865  * a vertex or fragment program output variable.  Return -1 for an invalid
 866  * output name.
 867  */
 868 GLint
 869 _slang_output_index(const char *name, GLenum target)
 870 {
 871    const struct output_info *outputs;
 872    GLuint i;
 873
 874    switch (target) {
 875    case GL_VERTEX_PROGRAM_ARB:
 876       outputs = vertOutputs;
 877       break;
 878    case GL_FRAGMENT_PROGRAM_ARB:
 879       outputs = fragOutputs;
 880       break;
 881    /* XXX geom program */
 882    default:
 883       _mesa_problem(NULL, "bad target in _slang_output_index");
 884       return -1;
 885    }
 886
 887    for (i = 0; outputs[i].Name; i++) {
 888       if (strcmp(outputs[i].Name, name) == 0) {
 889          /* found */
 890          return outputs[i].Attrib;
 891       }
 892    }
 893    return -1;
 894 }