src/mesa/shader/slang/slang_builtin.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.3
   4  *
   5  * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file slang_builtin.c
  27  * Resolve built-in uniform vars.
  28  * \author Brian Paul
  29  */
  30
  31 #include "imports.h"
  32 #include "slang_builtin.h"
  33 #include "slang_ir.h"
  34 #include "mtypes.h"
  35 #include "program.h"
  36 #include "prog_instruction.h"
  37 #include "prog_parameter.h"
  38 #include "prog_statevars.h"
  39
  40
  41 /**
  42  * Lookup GL state given a variable name, 0, 1 or 2 indexes and a field.
  43  * Allocate room for the state in the given param list and return position
  44  * in the list.
  45  * Yes, this is kind of ugly, but it works.
  46  */
  47 static GLint
  48 lookup_statevar(const char *var, GLint index1, GLint index2, const char *field,
  49                 GLuint *swizzleOut,
  50                 struct gl_program_parameter_list *paramList)
  51 {
  52    gl_state_index tokens[STATE_LENGTH];
  53    GLuint i;
  54    GLboolean isMatrix = GL_FALSE;
  55
  56    for (i = 0; i < STATE_LENGTH; i++) {
  57       tokens[i] = 0;
  58    }
  59    *swizzleOut = SWIZZLE_NOOP;
  60
  61    if (strcmp(var, "gl_ModelViewMatrix") == 0) {
  62       tokens[0] = STATE_MODELVIEW_MATRIX;
  63       isMatrix = GL_TRUE;
  64    }
  65    else if (strcmp(var, "gl_ModelProjectionMatrix") == 0) {
  66       tokens[0] = STATE_PROJECTION_MATRIX;
  67       isMatrix = GL_TRUE;
  68    }
  69    else if (strcmp(var, "gl_ModelViewProjectionMatrix") == 0) {
  70       tokens[0] = STATE_MVP_MATRIX;
  71       isMatrix = GL_TRUE;
  72    }
  73    else if (strcmp(var, "gl_NormalMatrix") == 0) {
  74       tokens[0] = STATE_MODELVIEW_MATRIX;
  75       isMatrix = GL_TRUE;
  76    }
  77    else if (strcmp(var, "gl_TextureMatrix") == 0) {
  78       tokens[0] = STATE_TEXTURE_MATRIX;
  79       if (index1 >= 0)
  80          tokens[1] = index1;
  81       isMatrix = GL_TRUE;
  82    }
  83    else if (strcmp(var, "gl_DepthRange") == 0) {
  84       tokens[0] = STATE_DEPTH_RANGE;
  85       if (strcmp(field, "near") == 0) {
  86          *swizzleOut = SWIZZLE_XXXX;
  87       }
  88       else if (strcmp(field, "far") == 0) {
  89          *swizzleOut = SWIZZLE_YYYY;
  90       }
  91       else if (strcmp(field, "diff") == 0) {
  92          *swizzleOut = SWIZZLE_ZZZZ;
  93       }
  94       else {
  95          return -1;
  96       }
  97    }
  98    else if (strcmp(var, "gl_ClipPlane") == 0) {
  99       tokens[0] = STATE_CLIPPLANE;
 100       tokens[1] = index1;
 101    }
 102    else if (strcmp(var, "gl_Point") == 0) {
 103       if (strcmp(field, "size") == 0) {
 104          tokens[0] = STATE_POINT_SIZE;
 105          *swizzleOut = SWIZZLE_XXXX;
 106       }
 107       else if (strcmp(field, "sizeMin") == 0) {
 108          tokens[0] = STATE_POINT_SIZE;
 109          *swizzleOut = SWIZZLE_YYYY;
 110       }
 111       else if (strcmp(field, "sizeMax") == 0) {
 112          tokens[0] = STATE_POINT_SIZE;
 113          *swizzleOut = SWIZZLE_ZZZZ;
 114       }
 115       else if (strcmp(field, "fadeThresholdSize") == 0) {
 116          tokens[0] = STATE_POINT_SIZE;
 117          *swizzleOut = SWIZZLE_WWWW;
 118       }
 119       else if (strcmp(field, "distanceConstantAttenuation") == 0) {
 120          tokens[0] = STATE_POINT_ATTENUATION;
 121          *swizzleOut = SWIZZLE_XXXX;
 122       }
 123       else if (strcmp(field, "distanceLinearAttenuation") == 0) {
 124          tokens[0] = STATE_POINT_ATTENUATION;
 125          *swizzleOut = SWIZZLE_YYYY;
 126       }
 127       else if (strcmp(field, "distanceQuadraticAttenuation") == 0) {
 128          tokens[0] = STATE_POINT_ATTENUATION;
 129          *swizzleOut = SWIZZLE_ZZZZ;
 130       }
 131       else {
 132          return -1;
 133       }
 134    }
 135    else if (strcmp(var, "gl_FrontMaterial") == 0 ||
 136             strcmp(var, "gl_BackMaterial") == 0) {
 137       tokens[0] = STATE_MATERIAL;
 138       if (strcmp(var, "gl_FrontMaterial") == 0)
 139          tokens[1] = 0;
 140       else
 141          tokens[1] = 1;
 142       if (strcmp(field, "emission") == 0) {
 143          tokens[2] = STATE_EMISSION;
 144       }
 145       else if (strcmp(field, "ambient") == 0) {
 146          tokens[2] = STATE_AMBIENT;
 147       }
 148       else if (strcmp(field, "diffuse") == 0) {
 149          tokens[2] = STATE_DIFFUSE;
 150       }
 151       else if (strcmp(field, "specular") == 0) {
 152          tokens[2] = STATE_SPECULAR;
 153       }
 154       else if (strcmp(field, "shininess") == 0) {
 155          tokens[2] = STATE_SHININESS;
 156          *swizzleOut = SWIZZLE_XXXX;
 157       }
 158       else {
 159          return -1;
 160       }
 161    }
 162    else if (strcmp(var, "gl_LightSource") == 0) {
 163       tokens[0] = STATE_LIGHT;
 164       tokens[1] = index1;
 165       if (strcmp(field, "ambient") == 0) {
 166          tokens[2] = STATE_AMBIENT;
 167       }
 168       else if (strcmp(field, "diffuse") == 0) {
 169          tokens[2] = STATE_DIFFUSE;
 170       }
 171       else if (strcmp(field, "specular") == 0) {
 172          tokens[2] = STATE_SPECULAR;
 173       }
 174       else if (strcmp(field, "position") == 0) {
 175          tokens[2] = STATE_POSITION;
 176       }
 177       else if (strcmp(field, "halfVector") == 0) {
 178          tokens[2] = STATE_HALF_VECTOR;
 179       }
 180       else if (strcmp(field, "spotDirection") == 0) {
 181          tokens[2] = STATE_SPOT_DIRECTION;
 182       }
 183       else if (strcmp(field, "spotCosCutoff") == 0) {
 184          tokens[2] = STATE_SPOT_DIRECTION;
 185          *swizzleOut = SWIZZLE_WWWW;
 186       }
 187       else if (strcmp(field, "spotCutoff") == 0) {
 188          tokens[2] = STATE_SPOT_CUTOFF;
 189          *swizzleOut = SWIZZLE_XXXX;
 190       }
 191       else if (strcmp(field, "spotExponent") == 0) {
 192          tokens[2] = STATE_ATTENUATION;
 193          *swizzleOut = SWIZZLE_WWWW;
 194       }
 195       else if (strcmp(field, "constantAttenuation") == 0) {
 196          tokens[2] = STATE_ATTENUATION;
 197          *swizzleOut = SWIZZLE_XXXX;
 198       }
 199       else if (strcmp(field, "linearAttenuation") == 0) {
 200          tokens[2] = STATE_ATTENUATION;
 201          *swizzleOut = SWIZZLE_YYYY;
 202       }
 203       else if (strcmp(field, "quadraticAttenuation") == 0) {
 204          tokens[2] = STATE_ATTENUATION;
 205          *swizzleOut = SWIZZLE_ZZZZ;
 206       }
 207       else {
 208          return -1;
 209       }
 210    }
 211    else if (strcmp(var, "gl_LightModel") == 0) {
 212       if (strcmp(field, "ambient") == 0) {
 213          tokens[0] = STATE_LIGHTMODEL_AMBIENT;
 214       }
 215       else {
 216          return -1;
 217       }
 218    }
 219    else if (strcmp(var, "gl_FrontLightModelProduct") == 0) {
 220       if (strcmp(field, "ambient") == 0) {
 221          tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
 222          tokens[1] = 0;
 223       }
 224       else {
 225          return -1;
 226       }
 227    }
 228    else if (strcmp(var, "gl_BackLightModelProduct") == 0) {
 229       if (strcmp(field, "ambient") == 0) {
 230          tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
 231          tokens[1] = 1;
 232       }
 233       else {
 234          return -1;
 235       }
 236    }
 237    else if (strcmp(var, "gl_FrontLightProduct") == 0 ||
 238             strcmp(var, "gl_BackLightProduct") == 0) {
 239       tokens[0] = STATE_LIGHTPROD;
 240       tokens[1] = index1; /* light number */
 241       if (strcmp(var, "gl_FrontLightProduct") == 0) {
 242          tokens[2] = 0; /* front */
 243       }
 244       else {
 245          tokens[2] = 1; /* back */
 246       }
 247       if (strcmp(field, "ambient") == 0) {
 248          tokens[3] = STATE_AMBIENT;
 249       }
 250       else if (strcmp(field, "diffuse") == 0) {
 251          tokens[3] = STATE_DIFFUSE;
 252       }
 253       else if (strcmp(field, "specular") == 0) {
 254          tokens[3] = STATE_SPECULAR;
 255       }
 256       else {
 257          return -1;
 258       }
 259    }
 260    else if (strcmp(var, "gl_TextureEnvColor") == 0) {
 261       tokens[0] = STATE_TEXENV_COLOR;
 262       tokens[1] = index1;
 263    }
 264    else if (strcmp(var, "gl_EyePlaneS") == 0) {
 265       tokens[0] = STATE_TEXGEN;
 266       tokens[1] = index1; /* tex unit */
 267       tokens[2] = STATE_TEXGEN_EYE_S;
 268    }
 269    else if (strcmp(var, "gl_EyePlaneT") == 0) {
 270       tokens[0] = STATE_TEXGEN;
 271       tokens[1] = index1; /* tex unit */
 272       tokens[2] = STATE_TEXGEN_EYE_T;
 273    }
 274    else if (strcmp(var, "gl_EyePlaneR") == 0) {
 275       tokens[0] = STATE_TEXGEN;
 276       tokens[1] = index1; /* tex unit */
 277       tokens[2] = STATE_TEXGEN_EYE_R;
 278    }
 279    else if (strcmp(var, "gl_EyePlaneQ") == 0) {
 280       tokens[0] = STATE_TEXGEN;
 281       tokens[1] = index1; /* tex unit */
 282       tokens[2] = STATE_TEXGEN_EYE_Q;
 283    }
 284    else if (strcmp(var, "gl_ObjectPlaneS") == 0) {
 285       tokens[0] = STATE_TEXGEN;
 286       tokens[1] = index1; /* tex unit */
 287       tokens[2] = STATE_TEXGEN_OBJECT_S;
 288    }
 289    else if (strcmp(var, "gl_ObjectPlaneT") == 0) {
 290       tokens[0] = STATE_TEXGEN;
 291       tokens[1] = index1; /* tex unit */
 292       tokens[2] = STATE_TEXGEN_OBJECT_T;
 293    }
 294    else if (strcmp(var, "gl_ObjectPlaneR") == 0) {
 295       tokens[0] = STATE_TEXGEN;
 296       tokens[1] = index1; /* tex unit */
 297       tokens[2] = STATE_TEXGEN_OBJECT_R;
 298    }
 299    else if (strcmp(var, "gl_ObjectPlaneQ") == 0) {
 300       tokens[0] = STATE_TEXGEN;
 301       tokens[1] = index1; /* tex unit */
 302       tokens[2] = STATE_TEXGEN_OBJECT_Q;
 303    }
 304    else if (strcmp(var, "gl_Fog") == 0) {
 305       if (strcmp(field, "color") == 0) {
 306          tokens[0] = STATE_FOG_COLOR;
 307       }
 308       else if (strcmp(field, "density") == 0) {
 309          tokens[0] = STATE_FOG_PARAMS;
 310          *swizzleOut = SWIZZLE_XXXX;
 311       }
 312       else if (strcmp(field, "start") == 0) {
 313          tokens[0] = STATE_FOG_PARAMS;
 314          *swizzleOut = SWIZZLE_YYYY;
 315       }
 316       else if (strcmp(field, "end") == 0) {
 317          tokens[0] = STATE_FOG_PARAMS;
 318          *swizzleOut = SWIZZLE_ZZZZ;
 319       }
 320       else if (strcmp(field, "scale") == 0) {
 321          tokens[0] = STATE_FOG_PARAMS;
 322          *swizzleOut = SWIZZLE_WWWW;
 323       }
 324       else {
 325          return -1;
 326       }
 327    }
 328    else {
 329       return -1;
 330    }
 331
 332    if (isMatrix) {
 333       /* load all four columns of matrix */
 334       GLint pos[4];
 335       GLuint j;
 336       for (j = 0; j < 4; j++) {
 337          tokens[2] = tokens[3] = j; /* jth row of matrix */
 338          pos[j] = _mesa_add_state_reference(paramList, tokens);
 339          assert(pos[j] >= 0);
 340          ASSERT(pos[j] >= 0);
 341       }
 342       return pos[0] + index1;
 343    }
 344    else {
 345       /* allocate a single register */
 346       GLint pos = _mesa_add_state_reference(paramList, tokens);
 347       ASSERT(pos >= 0);
 348       return pos;
 349    }
 350 }
 351
 352
 353 /**
 354  * Allocate storage for a pre-defined uniform (a GL state variable).
 355  * As a memory-saving optimization, we try to only allocate storage for
 356  * state vars that are actually used.
 357  * For example, the "gl_LightSource" uniform is huge.  If we only use
 358  * a handful of gl_LightSource fields, we don't want to allocate storage
 359  * for all of gl_LightSource.
 360  *
 361  * Currently, all pre-defined uniforms are in one of these forms:
 362  *   var
 363  *   var[i]
 364  *   var.field
 365  *   var[i].field
 366  *   var[i][j]
 367  */
 368 GLint
 369 _slang_alloc_statevar(slang_ir_node *n,
 370                       struct gl_program_parameter_list *paramList)
 371 {
 372    slang_ir_node *n0 = n;
 373    const char *field = NULL, *var;
 374    GLint index1 = -1, index2 = -1, pos;
 375    GLuint swizzle;
 376
 377    if (n->Opcode == IR_FIELD) {
 378       field = n->Field;
 379       n = n->Children[0];
 380    }
 381
 382    if (n->Opcode == IR_ELEMENT) {
 383       /* XXX can only handle constant indexes for now */
 384       assert(n->Children[1]->Opcode == IR_FLOAT);
 385       index1 = (GLint) n->Children[1]->Value[0];
 386       n = n->Children[0];
 387    }
 388
 389    if (n->Opcode == IR_ELEMENT) {
 390       /* XXX can only handle constant indexes for now */
 391       assert(n->Children[1]->Opcode == IR_FLOAT);
 392       index2 = (GLint) n->Children[1]->Value[0];
 393       n = n->Children[0];
 394    }
 395
 396    assert(n->Opcode == IR_VAR);
 397    var = (char *) n->Var->a_name;
 398
 399    pos = lookup_statevar(var, index1, index2, field, &swizzle, paramList);
 400    assert(pos >= 0);
 401    if (pos >= 0) {
 402       n0->Store->Index = pos;
 403       n0->Store->Swizzle = swizzle;
 404    }
 405    return pos;
 406 }
 407