Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.

 * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.

 * Copyright © 2010 Intel Corporation

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

/**

 * \file uniforms.c

 * Functions related to GLSL uniform variables.

 * \author Brian Paul

 */

/**

 * XXX things to do:

 * 1. Check that the right error code is generated for all _mesa_error() calls.

 * 2. Insert FLUSH_VERTICES calls in various places

 */

#include "main/glheader.h"

#include "main/context.h"

#include "main/dispatch.h"

#include "main/shaderapi.h"

#include "main/shaderobj.h"

#include "main/uniforms.h"

#include "program/prog_parameter.h"

#include "program/prog_statevars.h"

#include "program/prog_uniform.h"

#include "program/prog_instruction.h"

static GLenum

base_uniform_type(GLenum type)

{

   switch (type) {

#if 0 /* not needed, for now */

   case GL_BOOL:

   case GL_BOOL_VEC2:

   case GL_BOOL_VEC3:

   case GL_BOOL_VEC4:

      return GL_BOOL;

#endif

   case GL_FLOAT:

   case GL_FLOAT_VEC2:

   case GL_FLOAT_VEC3:

   case GL_FLOAT_VEC4:

      return GL_FLOAT;

   case GL_UNSIGNED_INT:

   case GL_UNSIGNED_INT_VEC2:

   case GL_UNSIGNED_INT_VEC3:

   case GL_UNSIGNED_INT_VEC4:

      return GL_UNSIGNED_INT;

   case GL_INT:

   case GL_INT_VEC2:

   case GL_INT_VEC3:

   case GL_INT_VEC4:

      return GL_INT;

   default:

      _mesa_problem(NULL, "Invalid type in base_uniform_type()");

      return GL_FLOAT;

   }

}

static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {

   {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},

   {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},

   {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},

};

static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {

   {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}

};

static struct gl_builtin_uniform_element gl_Point_elements[] = {

   {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},

   {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},

   {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},

   {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},

   {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},

   {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},

   {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},

};

static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {

   {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},

   {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

   {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

   {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

   {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},

};

static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {

   {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},

   {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},

   {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},

   {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},

   {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},

};

static struct gl_builtin_uniform_element gl_LightSource_elements[] = {

   {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

   {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

   {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

   {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},

   {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},

   {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},

    MAKE_SWIZZLE4(SWIZZLE_X,

		  SWIZZLE_Y,

		  SWIZZLE_Z,

		  SWIZZLE_Z)},

   {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},

   {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},

   {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},

   {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},

   {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},

   {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},

};

static struct gl_builtin_uniform_element gl_LightModel_elements[] = {

   {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {

   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {

   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {

   {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

   {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

   {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {

   {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},

   {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},

   {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {

   {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {

   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},

};

static struct gl_builtin_uniform_element gl_Fog_elements[] = {

   {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},

   {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},

   {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},

   {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},

   {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},

};

static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {

   {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},

};

#define MATRIX(name, statevar, modifier)				\

   static struct gl_builtin_uniform_element name ## _elements[] = {	\

      { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },		\

      { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },		\

      { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },		\

      { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },		\

   }

MATRIX(gl_ModelViewMatrix,

       STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);

MATRIX(gl_ModelViewMatrixInverse,

       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);

MATRIX(gl_ModelViewMatrixTranspose,

       STATE_MODELVIEW_MATRIX, 0);

MATRIX(gl_ModelViewMatrixInverseTranspose,

       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);

MATRIX(gl_ProjectionMatrix,

       STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);

MATRIX(gl_ProjectionMatrixInverse,

       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);

MATRIX(gl_ProjectionMatrixTranspose,

       STATE_PROJECTION_MATRIX, 0);

MATRIX(gl_ProjectionMatrixInverseTranspose,

       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);

MATRIX(gl_ModelViewProjectionMatrix,

       STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);

MATRIX(gl_ModelViewProjectionMatrixInverse,

       STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);

MATRIX(gl_ModelViewProjectionMatrixTranspose,

       STATE_MVP_MATRIX, 0);

MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,

       STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);

MATRIX(gl_TextureMatrix,

       STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);

MATRIX(gl_TextureMatrixInverse,

       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);

MATRIX(gl_TextureMatrixTranspose,

       STATE_TEXTURE_MATRIX, 0);

MATRIX(gl_TextureMatrixInverseTranspose,

       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);

static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {

   { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},

     SWIZZLE_XYZW },

   { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},

     SWIZZLE_XYZW },

   { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},

     SWIZZLE_XYZW },

};

#undef MATRIX

#define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}

const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {

   STATEVAR(gl_DepthRange),

   STATEVAR(gl_ClipPlane),

   STATEVAR(gl_Point),

   STATEVAR(gl_FrontMaterial),

   STATEVAR(gl_BackMaterial),

   STATEVAR(gl_LightSource),

   STATEVAR(gl_LightModel),

   STATEVAR(gl_FrontLightModelProduct),

   STATEVAR(gl_BackLightModelProduct),

   STATEVAR(gl_FrontLightProduct),

   STATEVAR(gl_BackLightProduct),

   STATEVAR(gl_TextureEnvColor),

   STATEVAR(gl_EyePlaneS),

   STATEVAR(gl_EyePlaneT),

   STATEVAR(gl_EyePlaneR),

   STATEVAR(gl_EyePlaneQ),

   STATEVAR(gl_ObjectPlaneS),

   STATEVAR(gl_ObjectPlaneT),

   STATEVAR(gl_ObjectPlaneR),

   STATEVAR(gl_ObjectPlaneQ),

   STATEVAR(gl_Fog),

   STATEVAR(gl_ModelViewMatrix),

   STATEVAR(gl_ModelViewMatrixInverse),

   STATEVAR(gl_ModelViewMatrixTranspose),

   STATEVAR(gl_ModelViewMatrixInverseTranspose),

   STATEVAR(gl_ProjectionMatrix),

   STATEVAR(gl_ProjectionMatrixInverse),

   STATEVAR(gl_ProjectionMatrixTranspose),

   STATEVAR(gl_ProjectionMatrixInverseTranspose),

   STATEVAR(gl_ModelViewProjectionMatrix),

   STATEVAR(gl_ModelViewProjectionMatrixInverse),

   STATEVAR(gl_ModelViewProjectionMatrixTranspose),

   STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),

   STATEVAR(gl_TextureMatrix),

   STATEVAR(gl_TextureMatrixInverse),

   STATEVAR(gl_TextureMatrixTranspose),

   STATEVAR(gl_TextureMatrixInverseTranspose),

   STATEVAR(gl_NormalMatrix),

   STATEVAR(gl_NormalScale),

   {NULL, NULL, 0}

};

static GLboolean

is_boolean_type(GLenum type)

{

   switch (type) {

   case GL_BOOL:

   case GL_BOOL_VEC2:

   case GL_BOOL_VEC3:

   case GL_BOOL_VEC4:

      return GL_TRUE;

   default:

      return GL_FALSE;

   }

}

static GLboolean

is_sampler_type(GLenum type)

{

   switch (type) {

   case GL_SAMPLER_1D:

   case GL_SAMPLER_2D:

   case GL_SAMPLER_3D:

   case GL_SAMPLER_CUBE:

   case GL_SAMPLER_1D_SHADOW:

   case GL_SAMPLER_2D_SHADOW:

   case GL_SAMPLER_2D_RECT_ARB:

   case GL_SAMPLER_2D_RECT_SHADOW_ARB:

   case GL_SAMPLER_1D_ARRAY_EXT:

   case GL_SAMPLER_2D_ARRAY_EXT:

   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:

   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:

      return GL_TRUE;

   default:

      return GL_FALSE;

   }

}

static struct gl_program_parameter *

get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)

{

   const struct gl_program *prog = NULL;

   GLint progPos;

   progPos = shProg->Uniforms->Uniforms[index].VertPos;

   if (progPos >= 0) {

      prog = &shProg->VertexProgram->Base;

   }

   else {

      progPos = shProg->Uniforms->Uniforms[index].FragPos;

      if (progPos >= 0) {

         prog = &shProg->FragmentProgram->Base;

      } else {

         progPos = shProg->Uniforms->Uniforms[index].GeomPos;

         if (progPos >= 0) {

            prog = &shProg->GeometryProgram->Base;

         }

      }

   }

   if (!prog || progPos < 0)

      return NULL; /* should never happen */

   return &prog->Parameters->Parameters[progPos];

}

/**

 * Called by glGetActiveUniform().

 */

static void

_mesa_get_active_uniform(struct gl_context *ctx, GLuint program, GLuint index,

                         GLsizei maxLength, GLsizei *length, GLint *size,

                         GLenum *type, GLchar *nameOut)

{

   const struct gl_shader_program *shProg;

   const struct gl_program *prog = NULL;

   const struct gl_program_parameter *param;

   GLint progPos;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");

   if (!shProg)

      return;

   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");

      return;

   }

   progPos = shProg->Uniforms->Uniforms[index].VertPos;

   if (progPos >= 0) {

      prog = &shProg->VertexProgram->Base;

   }

   else {

      progPos = shProg->Uniforms->Uniforms[index].FragPos;

      if (progPos >= 0) {

         prog = &shProg->FragmentProgram->Base;

      } else {

         progPos = shProg->Uniforms->Uniforms[index].GeomPos;

         if (progPos >= 0) {

            prog = &shProg->GeometryProgram->Base;

         }

      }

   }

   if (!prog || progPos < 0)

      return; /* should never happen */

   ASSERT(progPos < prog->Parameters->NumParameters);

   param = &prog->Parameters->Parameters[progPos];

   if (nameOut) {

      _mesa_copy_string(nameOut, maxLength, length, param->Name);

   }

   if (size) {

      GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

      if ((GLint) param->Size > typeSize) {

         /* This is an array.

          * Array elements are placed on vector[4] boundaries so they're

          * a multiple of four floats.  We round typeSize up to next multiple

          * of four to get the right size below.

          */

         typeSize = (typeSize + 3) & ~3;

      }

      /* Note that the returned size is in units of the , not bytes */

      *size = param->Size / typeSize;

   }

   if (type) {

      *type = param->DataType;

   }

}

static unsigned

get_vector_elements(GLenum type)

{

   switch (type) {

   case GL_FLOAT:

   case GL_INT:

   case GL_BOOL:

   case GL_UNSIGNED_INT:

   default: /* Catch all the various sampler types. */

      return 1;

   case GL_FLOAT_VEC2:

   case GL_INT_VEC2:

   case GL_BOOL_VEC2:

   case GL_UNSIGNED_INT_VEC2:

      return 2;

   case GL_FLOAT_VEC3:

   case GL_INT_VEC3:

   case GL_BOOL_VEC3:

   case GL_UNSIGNED_INT_VEC3:

      return 3;

   case GL_FLOAT_VEC4:

   case GL_INT_VEC4:

   case GL_BOOL_VEC4:

   case GL_UNSIGNED_INT_VEC4:

      return 4;

   }

}

static void

get_matrix_dims(GLenum type, GLint *rows, GLint *cols)

{

   switch (type) {

   case GL_FLOAT_MAT2:

      *rows = *cols = 2;

      break;

   case GL_FLOAT_MAT2x3:

      *rows = 3;

      *cols = 2;

      break;

   case GL_FLOAT_MAT2x4:

      *rows = 4;

      *cols = 2;

      break;

   case GL_FLOAT_MAT3:

      *rows = 3;

      *cols = 3;

      break;

   case GL_FLOAT_MAT3x2:

      *rows = 2;

      *cols = 3;

      break;

   case GL_FLOAT_MAT3x4:

      *rows = 4;

      *cols = 3;

      break;

   case GL_FLOAT_MAT4:

      *rows = 4;

      *cols = 4;

      break;

   case GL_FLOAT_MAT4x2:

      *rows = 2;

      *cols = 4;

      break;

   case GL_FLOAT_MAT4x3:

      *rows = 3;

      *cols = 4;

      break;

   default:

      *rows = *cols = 0;

   }

}

/**

 * Determine the number of rows and columns occupied by a uniform

 * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),

 * the number of rows = 1 and cols = number of elements in the vector.

 */

static void

get_uniform_rows_cols(const struct gl_program_parameter *p,

                      GLint *rows, GLint *cols)

{

   get_matrix_dims(p->DataType, rows, cols);

   if (*rows == 0 && *cols == 0) {

      /* not a matrix type, probably a float or vector */

      *rows = 1;

      *cols = get_vector_elements(p->DataType);

   }

}

/**

 * Helper for get_uniform[fi]v() functions.

 * Given a shader program name and uniform location, return a pointer

 * to the shader program and return the program parameter position.

 */

static void

lookup_uniform_parameter(struct gl_context *ctx, GLuint program, GLint location,

                         struct gl_program **progOut, GLint *paramPosOut)

{

   struct gl_shader_program *shProg

      = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");

   struct gl_program *prog = NULL;

   GLint progPos = -1;

   /* if shProg is NULL, we'll have already recorded an error */

   if (shProg) {

      if (!shProg->Uniforms ||

          location < 0 ||

          location >= (GLint) shProg->Uniforms->NumUniforms) {

         _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");

      }

      else {

         /* OK, find the gl_program and program parameter location */

         progPos = shProg->Uniforms->Uniforms[location].VertPos;

         if (progPos >= 0) {

            prog = &shProg->VertexProgram->Base;

         }

         else {

            progPos = shProg->Uniforms->Uniforms[location].FragPos;

            if (progPos >= 0) {

               prog = &shProg->FragmentProgram->Base;

            } else {

               progPos = shProg->Uniforms->Uniforms[location].GeomPos;

               if (progPos >= 0) {

                  prog = &shProg->GeometryProgram->Base;

               }

            }

         }

      }

   }

   *progOut = prog;

   *paramPosOut = progPos;

}

/**

 * GLGL uniform arrays and structs require special handling.

 *

 * The GL_ARB_shader_objects spec says that if you use

 * glGetUniformLocation to get the location of an array, you CANNOT

 * access other elements of the array by adding an offset to the

 * returned location.  For example, you must call

 * glGetUniformLocation("foo[16]") if you want to set the 16th element

 * of the array with glUniform().

 *

 * HOWEVER, some other OpenGL drivers allow accessing array elements

 * by adding an offset to the returned array location.  And some apps

 * seem to depend on that behaviour.

 *

 * Mesa's gl_uniform_list doesn't directly support this since each

 * entry in the list describes one uniform variable, not one uniform

 * element.  We could insert dummy entries in the list for each array

 * element after [0] but that causes complications elsewhere.

 *

 * We solve this problem by encoding two values in the location that's

 * returned by glGetUniformLocation():

 *  a) index into gl_uniform_list::Uniforms[] for the uniform

 *  b) an array/field offset (0 for simple types)

 *

 * These two values are encoded in the high and low halves of a GLint.

 * By putting the uniform number in the high part and the offset in the

 * low part, we can support the unofficial ability to index into arrays

 * by adding offsets to the location value.

 */

static void

merge_location_offset(GLint *location, GLint offset)

{

   *location = (*location << 16) | offset;

}

/**

 * Separate the uniform location and parameter offset.  See above.

 */

static void

split_location_offset(GLint *location, GLint *offset)

{

   *offset = *location & 0xffff;

   *location = *location >> 16;

}

/**

 * Called via glGetUniformfv().

 */

static void

_mesa_get_uniformfv(struct gl_context *ctx, GLuint program, GLint location,

                    GLfloat *params)

{

   struct gl_program *prog;

   GLint paramPos;

   GLint offset;

   split_location_offset(&location, &offset);

   lookup_uniform_parameter(ctx, program, location, &prog, ¶mPos);

   if (prog) {

      const struct gl_program_parameter *p =

         &prog->Parameters->Parameters[paramPos];

      GLint rows, cols, i, j, k;

      get_uniform_rows_cols(p, &rows, &cols);

      k = 0;

      for (i = 0; i < rows; i++) {

	 const int base = paramPos + offset + i;

         for (j = 0; j < cols; j++ ) {

            params[k++] = prog->Parameters->ParameterValues[base][j];

         }

      }

   }

}

/**

 * Called via glGetUniformiv().

 * \sa _mesa_get_uniformfv, only difference is a cast.

 */

static void

_mesa_get_uniformiv(struct gl_context *ctx, GLuint program, GLint location,

                    GLint *params)

{

   struct gl_program *prog;

   GLint paramPos;

   GLint offset;

   split_location_offset(&location, &offset);

   lookup_uniform_parameter(ctx, program, location, &prog, ¶mPos);

   if (prog) {

      const struct gl_program_parameter *p =

         &prog->Parameters->Parameters[paramPos];

      GLint rows, cols, i, j, k;

      get_uniform_rows_cols(p, &rows, &cols);

      k = 0;

      for (i = 0; i < rows; i++) {

	 const int base = paramPos + offset + i;

         for (j = 0; j < cols; j++ ) {

            params[k++] = (GLint) prog->Parameters->ParameterValues[base][j];

         }

      }

   }

}

/**

 * Called via glGetUniformuiv().

 * New in GL_EXT_gpu_shader4, OpenGL 3.0

 * \sa _mesa_get_uniformfv, only difference is a cast.

 */

static void

_mesa_get_uniformuiv(struct gl_context *ctx, GLuint program, GLint location,

                     GLuint *params)

{

   struct gl_program *prog;

   GLint paramPos;

   GLint offset;

   split_location_offset(&location, &offset);

   lookup_uniform_parameter(ctx, program, location, &prog, ¶mPos);

   if (prog) {

      const struct gl_program_parameter *p =

         &prog->Parameters->Parameters[paramPos];

      GLint rows, cols, i, j, k;

      get_uniform_rows_cols(p, &rows, &cols);

      k = 0;

      for (i = 0; i < rows; i++) {

	 const int base = paramPos + offset + i;

         for (j = 0; j < cols; j++ ) {

            params[k++] = (GLuint) prog->Parameters->ParameterValues[base][j];

         }

      }

   }

}

/**

 * Called via glGetUniformLocation().

 *

 * The return value will encode two values, the uniform location and an

 * offset (used for arrays, structs).

 */

GLint

_mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg,

			   const GLchar *name)

{

   GLint offset = 0, location = -1;

   if (shProg->LinkStatus == GL_FALSE) {

      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");

      return -1;

   }

   /* XXX we should return -1 if the uniform was declared, but not

    * actually used.

    */

   /* XXX we need to be able to parse uniform names for structs and arrays

    * such as:

    *   mymatrix[1]

    *   mystruct.field1

    */

   {

      /* handle 1-dimension arrays here... */

      char *c = strchr(name, '[');

      if (c) {

         /* truncate name at [ */

         const GLint len = c - name;

         GLchar *newName = malloc(len + 1);

         if (!newName)

            return -1; /* out of mem */

         memcpy(newName, name, len);

         newName[len] = 0;

         location = _mesa_lookup_uniform(shProg->Uniforms, newName);

         if (location >= 0) {

            const GLint element = atoi(c + 1);

            if (element > 0) {

               /* get type of the uniform array element */

               struct gl_program_parameter *p;

               p = get_uniform_parameter(shProg, location);

               if (p) {

                  GLint rows, cols;

                  get_matrix_dims(p->DataType, &rows, &cols);

                  if (rows < 1)

                     rows = 1;

                  offset = element * rows;

               }

            }

         }

         free(newName);

      }

   }

   if (location < 0) {

      location = _mesa_lookup_uniform(shProg->Uniforms, name);

   }

   if (location >= 0) {

      merge_location_offset(&location, offset);

   }

   return location;

}

/**

 * Update the vertex/fragment program's TexturesUsed array.

 *

 * This needs to be called after glUniform(set sampler var) is called.

 * A call to glUniform(samplerVar, value) causes a sampler to point to a

 * particular texture unit.  We know the sampler's texture target

 * (1D/2D/3D/etc) from compile time but the sampler's texture unit is

 * set by glUniform() calls.

 *

 * So, scan the program->SamplerUnits[] and program->SamplerTargets[]

 * information to update the prog->TexturesUsed[] values.

 * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,

 * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.

 * We'll use that info for state validation before rendering.

 */

void

_mesa_update_shader_textures_used(struct gl_program *prog)

{

   GLuint s;

   memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));

   for (s = 0; s < MAX_SAMPLERS; s++) {

      if (prog->SamplersUsed & (1 << s)) {

         GLuint unit = prog->SamplerUnits[s];

         GLuint tgt = prog->SamplerTargets[s];

         assert(unit < MAX_TEXTURE_IMAGE_UNITS);

         assert(tgt < NUM_TEXTURE_TARGETS);

         prog->TexturesUsed[unit] |= (1 << tgt);

      }

   }

}

/**

 * Check if the type given by userType is allowed to set a uniform of the

 * target type.  Generally, equivalence is required, but setting Boolean

 * uniforms can be done with glUniformiv or glUniformfv.

 */

static GLboolean

compatible_types(GLenum userType, GLenum targetType)

{

   if (userType == targetType)

      return GL_TRUE;

   if (targetType == GL_BOOL && (userType == GL_FLOAT ||

                                 userType == GL_UNSIGNED_INT ||

                                 userType == GL_INT))

      return GL_TRUE;

   if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||

                                      userType == GL_UNSIGNED_INT_VEC2 ||

                                      userType == GL_INT_VEC2))

      return GL_TRUE;

   if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||

                                      userType == GL_UNSIGNED_INT_VEC3 ||

                                      userType == GL_INT_VEC3))

      return GL_TRUE;

   if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||

                                      userType == GL_UNSIGNED_INT_VEC4 ||

                                      userType == GL_INT_VEC4))

      return GL_TRUE;

   if (is_sampler_type(targetType) && userType == GL_INT)

      return GL_TRUE;

   return GL_FALSE;

}

/**

 * Set the value of a program's uniform variable.

 * \param program  the program whose uniform to update

 * \param index  the index of the program parameter for the uniform

 * \param offset  additional parameter slot offset (for arrays)

 * \param type  the incoming datatype of 'values'

 * \param count  the number of uniforms to set

 * \param elems  number of elements per uniform (1, 2, 3 or 4)

 * \param values  the new values, of datatype 'type'

 */

static void

set_program_uniform(struct gl_context *ctx, struct gl_program *program,

                    GLint index, GLint offset,

                    GLenum type, GLsizei count, GLint elems,

                    const void *values)

{

   const struct gl_program_parameter *param =

      &program->Parameters->Parameters[index];

   assert(offset >= 0);

   assert(elems >= 1);

   assert(elems <= 4);

   if (!compatible_types(type, param->DataType)) {

      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");

      return;

   }

   if (index + offset > (GLint) program->Parameters->Size) {

      /* out of bounds! */

      return;

   }

   if (param->Type == PROGRAM_SAMPLER) {

      /* This controls which texture unit which is used by a sampler */

      GLboolean changed = GL_FALSE;

      GLint i;

      /* this should have been caught by the compatible_types() check */

      ASSERT(type == GL_INT);

      /* loop over number of samplers to change */

      for (i = 0; i < count; i++) {

         GLuint sampler =

            (GLuint) program->Parameters->ParameterValues[index + offset + i][0];

         GLuint texUnit = ((GLuint *) values)[i];

         /* check that the sampler (tex unit index) is legal */

         if (texUnit >= ctx->Const.MaxTextureImageUnits) {

            _mesa_error(ctx, GL_INVALID_VALUE,

                        "glUniform1(invalid sampler/tex unit index for '%s')",

                        param->Name);

            return;

         }

         /* This maps a sampler to a texture unit: */

         if (sampler < MAX_SAMPLERS) {

#if 0

            printf("Set program %p sampler %d '%s' to unit %u\n",

		   program, sampler, param->Name, texUnit);

#endif

            if (program->SamplerUnits[sampler] != texUnit) {

               program->SamplerUnits[sampler] = texUnit;

               changed = GL_TRUE;

            }

         }

      }

      if (changed) {

         /* When a sampler's value changes it usually requires rewriting

          * a GPU program's TEX instructions since there may not be a

          * sampler->texture lookup table.  We signal this with the

          * ProgramStringNotify() callback.

          */

         FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);

         _mesa_update_shader_textures_used(program);

         /* Do we need to care about the return value here?

          * This should not be the first time the driver was notified of

          * this program.

          */

         (void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);

      }

   }

   else {

      /* ordinary uniform variable */

      const GLboolean isUniformBool = is_boolean_type(param->DataType);

      const GLenum basicType = base_uniform_type(type);

      const GLint slots = (param->Size + 3) / 4;

      const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

      GLsizei k, i;

      if ((GLint) param->Size > typeSize) {

         /* an array */

         /* we'll ignore extra data below */

      }

      else {

         /* non-array: count must be at most one; count == 0 is handled by the loop below */

         if (count > 1) {

            _mesa_error(ctx, GL_INVALID_OPERATION,

                        "glUniform(uniform '%s' is not an array)",

                        param->Name);

            return;

         }

      }

      /* loop over number of array elements */

      for (k = 0; k < count; k++) {

         GLfloat *uniformVal;

         if (offset + k >= slots) {

            /* Extra array data is ignored */

            break;

         }

         /* uniformVal (the destination) is always float[4] */

         uniformVal = program->Parameters->ParameterValues[index + offset + k];

         if (basicType == GL_INT) {

            /* convert user's ints to floats */

            const GLint *iValues = ((const GLint *) values) + k * elems;

            for (i = 0; i < elems; i++) {

               uniformVal[i] = (GLfloat) iValues[i];

            }

         }

         else if (basicType == GL_UNSIGNED_INT) {

            /* convert user's uints to floats */

            const GLuint *iValues = ((const GLuint *) values) + k * elems;

            for (i = 0; i < elems; i++) {

               uniformVal[i] = (GLfloat) iValues[i];

            }

         }

         else {

            const GLfloat *fValues = ((const GLfloat *) values) + k * elems;

            assert(basicType == GL_FLOAT);

            for (i = 0; i < elems; i++) {

               uniformVal[i] = fValues[i];

            }

         }

         /* if the uniform is bool-valued, convert to 1.0 or 0.0 */

         if (isUniformBool) {

            for (i = 0; i < elems; i++) {

               uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;

            }

         }

      }

   }

}

/**

 * Called via glUniform*() functions.

 */

void

_mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,

	      GLint location, GLsizei count,

              const GLvoid *values, GLenum type)

{

   struct gl_uniform *uniform;

   GLint elems, offset;

   if (!shProg || !shProg->LinkStatus) {

      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");

      return;

   }

   if (location == -1)

      return;   /* The standard specifies this as a no-op */

   if (location < -1) {

      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location=%d)",

                  location);

      return;

   }

   split_location_offset(&location, &offset);

   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location=%d)", location);

      return;

   }

   if (count < 0) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");

      return;

   }

   elems = _mesa_sizeof_glsl_type(type);

   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

   uniform = &shProg->Uniforms->Uniforms[location];

   if (ctx->Shader.Flags & GLSL_UNIFORMS) {

      const GLenum basicType = base_uniform_type(type);

      GLint i;

      printf("Mesa: set program %u uniform %s (loc %d) to: ",

	     shProg->Name, uniform->Name, location);

      if (basicType == GL_INT) {

         const GLint *v = (const GLint *) values;

         for (i = 0; i < count * elems; i++) {

            printf("%d ", v[i]);

         }

      }

      else if (basicType == GL_UNSIGNED_INT) {

         const GLuint *v = (const GLuint *) values;

         for (i = 0; i < count * elems; i++) {

            printf("%u ", v[i]);

         }

      }

      else {

         const GLfloat *v = (const GLfloat *) values;

         assert(basicType == GL_FLOAT);

         for (i = 0; i < count * elems; i++) {

            printf("%g ", v[i]);

         }

      }

      printf("\n");

   }

   /* A uniform var may be used by both a vertex shader and a fragment

    * shader.  We may need to update one or both shader's uniform here:

    */

   if (shProg->VertexProgram) {

      /* convert uniform location to program parameter index */

      GLint index = uniform->VertPos;

      if (index >= 0) {

         set_program_uniform(ctx, &shProg->VertexProgram->Base,

                             index, offset, type, count, elems, values);

      }

   }

   if (shProg->FragmentProgram) {

      /* convert uniform location to program parameter index */

      GLint index = uniform->FragPos;

      if (index >= 0) {

         set_program_uniform(ctx, &shProg->FragmentProgram->Base,

                             index, offset, type, count, elems, values);

      }

   }