Mesa (glsl2): ir_to_mesa: Add remaining state variable (builtin uniforms) support.
Eric Anholt
anholt at kemper.freedesktop.org
Wed Jul 28 19:35:19 UTC 2010
Module: Mesa
Branch: glsl2
Commit: dc27e7356952984d023e05fef90d0f8c4bb07a09
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=dc27e7356952984d023e05fef90d0f8c4bb07a09
Author: Eric Anholt <eric at anholt.net>
Date: Wed Jul 28 08:13:53 2010 -0700
ir_to_mesa: Add remaining state variable (builtin uniforms) support.
Fixes:
glsl1-GL state variable reference (diffuse product)
glsl1-GL state variable reference (gl_FrontMaterial.ambient)
glsl1-GL state variable reference (gl_LightSource[0].diffuse)
glsl1-GL state variable reference (point attenuation)
glsl1-GL state variable reference (point size)
glsl1-linear fog
---
src/mesa/program/ir_to_mesa.cpp | 201 +++++++++++++++++++++++++++++++++++++++
1 files changed, 201 insertions(+), 0 deletions(-)
diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp
index fe0c19a..c53381e 100644
--- a/src/mesa/program/ir_to_mesa.cpp
+++ b/src/mesa/program/ir_to_mesa.cpp
@@ -946,6 +946,181 @@ ir_to_mesa_visitor::visit(ir_swizzle *ir)
this->result = src_reg;
}
+static const struct {
+ const char *name;
+ const char *field;
+ int tokens[STATE_LENGTH];
+ int swizzle;
+ bool array_indexed;
+} statevars[] = {
+ {"gl_DepthRange", "near",
+ {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
+ {"gl_DepthRange", "far",
+ {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
+ {"gl_DepthRange", "diff",
+ {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
+
+ {"gl_ClipPlane", NULL,
+ {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW, true}
+,
+ {"gl_Point", "size",
+ {STATE_POINT_SIZE}, SWIZZLE_XXXX},
+ {"gl_Point", "sizeMin",
+ {STATE_POINT_SIZE}, SWIZZLE_YYYY},
+ {"gl_Point", "sizeMax",
+ {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
+ {"gl_Point", "fadeThresholdSize",
+ {STATE_POINT_SIZE}, SWIZZLE_WWWW},
+ {"gl_Point", "distanceConstantAttenuation",
+ {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
+ {"gl_Point", "distanceLinearAttenuation",
+ {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
+ {"gl_Point", "distanceQuadraticAttenuation",
+ {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
+
+ {"gl_FrontMaterial", "emission",
+ {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
+ {"gl_FrontMaterial", "ambient",
+ {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
+ {"gl_FrontMaterial", "diffuse",
+ {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
+ {"gl_FrontMaterial", "specular",
+ {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
+ {"gl_FrontMaterial", "shininess",
+ {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
+
+ {"gl_BackMaterial", "emission",
+ {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
+ {"gl_BackMaterial", "ambient",
+ {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
+ {"gl_BackMaterial", "diffuse",
+ {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
+ {"gl_BackMaterial", "specular",
+ {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
+ {"gl_BackMaterial", "shininess",
+ {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
+
+ {"gl_LightSource", "ambient",
+ {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW, true},
+ {"gl_LightSource", "diffuse",
+ {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW, true},
+ {"gl_LightSource", "specular",
+ {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW, true},
+ {"gl_LightSource", "position",
+ {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW, true},
+ {"gl_LightSource", "halfVector",
+ {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW, true},
+ {"gl_LightSource", "spotDirection",
+ {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_XYZW, true},
+ {"gl_LightSource", "spotCosCutoff",
+ {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW, true},
+ {"gl_LightSource", "spotCutoff",
+ {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX, true},
+ {"gl_LightSource", "spotExponent",
+ {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW, true},
+ {"gl_LightSource", "constantAttenuation",
+ {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX, true},
+ {"gl_LightSource", "linearAttenuation",
+ {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY, true},
+ {"gl_LightSource", "quadraticAttenuation",
+ {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ, true},
+
+ {"gl_LightModel", NULL,
+ {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
+
+ {"gl_FrontLightModelProduct", NULL,
+ {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
+ {"gl_BackLightModelProduct", NULL,
+ {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
+
+ {"gl_FrontLightProduct", "ambient",
+ {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW, true},
+ {"gl_FrontLightProduct", "diffuse",
+ {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW, true},
+ {"gl_FrontLightProduct", "specular",
+ {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW, true},
+
+ {"gl_BackLightProduct", "ambient",
+ {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW, true},
+ {"gl_BackLightProduct", "diffuse",
+ {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW, true},
+ {"gl_BackLightProduct", "specular",
+ {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW, true},
+
+ {"gl_TextureEnvColor", "ambient",
+ {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW, true},
+
+ {"gl_EyePlaneS", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW, true},
+ {"gl_EyePlaneT", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW, true},
+ {"gl_EyePlaneR", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW, true},
+ {"gl_EyePlaneQ", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW, true},
+
+ {"gl_ObjectPlaneS", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW, true},
+ {"gl_ObjectPlaneT", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW, true},
+ {"gl_ObjectPlaneR", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW, true},
+ {"gl_ObjectPlaneQ", NULL,
+ {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW, true},
+
+ {"gl_Fog", "color",
+ {STATE_FOG_COLOR}, SWIZZLE_XYZW},
+ {"gl_Fog", "density",
+ {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
+ {"gl_Fog", "start",
+ {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
+ {"gl_Fog", "end",
+ {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
+ {"gl_Fog", "scale",
+ {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
+};
+
+static ir_to_mesa_src_reg
+get_builtin_uniform_reg(struct gl_program *prog,
+ const char *name, int array_index, const char *field)
+{
+ unsigned int i;
+ ir_to_mesa_src_reg src_reg;
+ int tokens[STATE_LENGTH];
+
+ for (i = 0; i < Elements(statevars); i++) {
+ if (strcmp(statevars[i].name, name) != 0)
+ continue;
+ if (!field && statevars[i].field) {
+ assert(!"FINISHME: whole-structure state var dereference");
+ }
+ if (field && strcmp(statevars[i].field, field) != 0)
+ continue;
+ break;
+ }
+
+ if (i == Elements(statevars)) {
+ printf("builtin uniform %s%s%s not found\n",
+ name,
+ field ? "." : "",
+ field ? field : "");
+ abort();
+ }
+
+ memcpy(&tokens, statevars[i].tokens, sizeof(tokens));
+ if (statevars[i].array_indexed)
+ tokens[1] = array_index;
+
+ src_reg.file = PROGRAM_STATE_VAR;
+ src_reg.index = _mesa_add_state_reference(prog->Parameters,
+ (gl_state_index *)tokens);
+ src_reg.swizzle = statevars[i].swizzle;
+ src_reg.negate = 0;
+ src_reg.reladdr = false;
+
+ return src_reg;
+}
+
static int
add_matrix_ref(struct gl_program *prog, int *tokens)
{
@@ -1176,6 +1351,7 @@ ir_to_mesa_visitor::visit(ir_dereference_variable *ir)
void
ir_to_mesa_visitor::visit(ir_dereference_array *ir)
{
+ ir_variable *var = ir->variable_referenced();
ir_constant *index;
ir_to_mesa_src_reg src_reg;
ir_dereference_variable *deref_var = ir->array->as_dereference_variable();
@@ -1216,6 +1392,20 @@ ir_to_mesa_visitor::visit(ir_dereference_array *ir)
return;
}
+ if (strncmp(var->name, "gl_", 3) == 0 && var->mode == ir_var_uniform &&
+ !var->type->is_matrix()) {
+ ir_dereference_record *record = NULL;
+ if (ir->array->ir_type == ir_type_dereference_record)
+ record = (ir_dereference_record *)ir->array;
+
+ assert(index || !"FINISHME: variable-indexed builtin uniform access");
+
+ this->result = get_builtin_uniform_reg(prog,
+ var->name,
+ index->value.i[0],
+ record ? record->field : NULL);
+ }
+
ir->array->accept(this);
src_reg = this->result;
@@ -1260,6 +1450,17 @@ ir_to_mesa_visitor::visit(ir_dereference_record *ir)
unsigned int i;
const glsl_type *struct_type = ir->record->type;
int offset = 0;
+ ir_variable *var = ir->record->variable_referenced();
+
+ if (strncmp(var->name, "gl_", 3) == 0 && var->mode == ir_var_uniform) {
+ assert(var);
+
+ this->result = get_builtin_uniform_reg(prog,
+ var->name,
+ 0,
+ ir->field);
+ return;
+ }
ir->record->accept(this);
More information about the mesa-commit
mailing list