X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Funiforms.c;h=b1968b3f7953936ec6a5a2dc565a93001b39b67e;hb=ebfcf9de43071e8eab6afe6fba5ee879b72dcbee;hp=b68d63d7853649a6de95b9ac2d32dcdbb7718c61;hpb=65add4327d786826d28c72ea34034df8137f65d9;p=mesa.git diff --git a/src/mesa/main/uniforms.c b/src/mesa/main/uniforms.c index b68d63d7853..b1968b3f795 100644 --- a/src/mesa/main/uniforms.c +++ b/src/mesa/main/uniforms.c @@ -18,9 +18,10 @@ * 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. + * THE AUTHORS OR COPYRIGHT HOLDERS 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. */ /** @@ -35,1463 +36,1600 @@ * 2. Insert FLUSH_VERTICES calls in various places */ -#include #include "main/glheader.h" #include "main/context.h" #include "main/dispatch.h" -#include "main/image.h" -#include "main/mfeatures.h" -#include "main/mtypes.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) { - case GL_BOOL: - case GL_BOOL_VEC2: - case GL_BOOL_VEC3: - case GL_BOOL_VEC4: - return GL_BOOL; - case GL_FLOAT: - case GL_FLOAT_VEC2: - case GL_FLOAT_VEC3: - case GL_FLOAT_VEC4: - case GL_FLOAT_MAT2: - case GL_FLOAT_MAT2x3: - case GL_FLOAT_MAT2x4: - case GL_FLOAT_MAT3x2: - case GL_FLOAT_MAT3: - case GL_FLOAT_MAT3x4: - case GL_FLOAT_MAT4x2: - case GL_FLOAT_MAT4x3: - case GL_FLOAT_MAT4: - 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; +#include "main/enums.h" +#include "compiler/glsl/ir_uniform.h" +#include "compiler/glsl_types.h" +#include "program/program.h" + +/** + * 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_shader_program *shProg, + struct gl_program *prog) +{ + GLuint s; + struct gl_shader *shader = + shProg->_LinkedShaders[_mesa_program_enum_to_shader_stage(prog->Target)]; + + assert(shader); + + memcpy(prog->SamplerUnits, shader->SamplerUnits, sizeof(prog->SamplerUnits)); + memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed)); + + shProg->SamplersValidated = GL_TRUE; + + for (s = 0; s < MAX_SAMPLERS; s++) { + if (prog->SamplersUsed & (1 << s)) { + GLuint unit = shader->SamplerUnits[s]; + GLuint tgt = shader->SamplerTargets[s]; + assert(unit < ARRAY_SIZE(prog->TexturesUsed)); + assert(tgt < NUM_TEXTURE_TARGETS); + + /* The types of the samplers associated with a particular texture + * unit must be an exact match. Page 74 (page 89 of the PDF) of the + * OpenGL 3.3 core spec says: + * + * "It is not allowed to have variables of different sampler + * types pointing to the same texture image unit within a program + * object." + */ + if (prog->TexturesUsed[unit] & ~(1 << tgt)) + shProg->SamplersValidated = GL_FALSE; + + prog->TexturesUsed[unit] |= (1 << tgt); + } } } - -static GLboolean -is_boolean_type(GLenum type) +/** + * Connect a piece of driver storage with a part of a uniform + * + * \param uni The uniform with which the storage will be associated + * \param element_stride Byte-stride between array elements. + * \sa gl_uniform_driver_storage::element_stride. + * \param vector_stride Byte-stride between vectors (in a matrix). + * \sa gl_uniform_driver_storage::vector_stride. + * \param format Conversion from native format to driver format + * required by the driver. + * \param data Location to dump the data. + */ +void +_mesa_uniform_attach_driver_storage(struct gl_uniform_storage *uni, + unsigned element_stride, + unsigned vector_stride, + enum gl_uniform_driver_format format, + void *data) +{ + uni->driver_storage = + realloc(uni->driver_storage, + sizeof(struct gl_uniform_driver_storage) + * (uni->num_driver_storage + 1)); + + uni->driver_storage[uni->num_driver_storage].element_stride = element_stride; + uni->driver_storage[uni->num_driver_storage].vector_stride = vector_stride; + uni->driver_storage[uni->num_driver_storage].format = format; + uni->driver_storage[uni->num_driver_storage].data = data; + + uni->num_driver_storage++; +} + +/** + * Sever all connections with all pieces of driver storage for all uniforms + * + * \warning + * This function does \b not release any of the \c data pointers + * previously passed in to \c _mesa_uniform_attach_driver_stoarge. + */ +void +_mesa_uniform_detach_all_driver_storage(struct gl_uniform_storage *uni) +{ + free(uni->driver_storage); + uni->driver_storage = NULL; + uni->num_driver_storage = 0; +} + +void GLAPIENTRY +_mesa_Uniform1f(GLint location, GLfloat v0) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_FLOAT, 1); +} + +void GLAPIENTRY +_mesa_Uniform2f(GLint location, GLfloat v0, GLfloat v1) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat v[2]; + v[0] = v0; + v[1] = v1; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_FLOAT, 2); +} + +void GLAPIENTRY +_mesa_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat v[3]; + v[0] = v0; + v[1] = v1; + v[2] = v2; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_FLOAT, 3); +} + +void GLAPIENTRY +_mesa_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, + GLfloat v3) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat v[4]; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_FLOAT, 4); +} + +void GLAPIENTRY +_mesa_Uniform1i(GLint location, GLint v0) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_INT, 1); +} + +void GLAPIENTRY +_mesa_Uniform2i(GLint location, GLint v0, GLint v1) +{ + GET_CURRENT_CONTEXT(ctx); + GLint v[2]; + v[0] = v0; + v[1] = v1; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_INT, 2); +} + +void GLAPIENTRY +_mesa_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2) +{ + GET_CURRENT_CONTEXT(ctx); + GLint v[3]; + v[0] = v0; + v[1] = v1; + v[2] = v2; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_INT, 3); +} + +void GLAPIENTRY +_mesa_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + GET_CURRENT_CONTEXT(ctx); + GLint v[4]; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_INT, 4); +} + +void GLAPIENTRY +_mesa_Uniform1fv(GLint location, GLsizei count, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 1); +} + +void GLAPIENTRY +_mesa_Uniform2fv(GLint location, GLsizei count, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 2); +} + +void GLAPIENTRY +_mesa_Uniform3fv(GLint location, GLsizei count, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 3); +} + +void GLAPIENTRY +_mesa_Uniform4fv(GLint location, GLsizei count, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 4); +} + +void GLAPIENTRY +_mesa_Uniform1iv(GLint location, GLsizei count, const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 1); +} + +void GLAPIENTRY +_mesa_Uniform2iv(GLint location, GLsizei count, const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 2); +} + +void GLAPIENTRY +_mesa_Uniform3iv(GLint location, GLsizei count, const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 3); +} + +void GLAPIENTRY +_mesa_Uniform4iv(GLint location, GLsizei count, const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 4); +} + +/** Same as above with direct state access **/ +void GLAPIENTRY +_mesa_ProgramUniform1f(GLuint program, GLint location, GLfloat v0) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1f"); + _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_FLOAT, 1); +} + +void GLAPIENTRY +_mesa_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat v[2]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2f"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_FLOAT, 2); +} + +void GLAPIENTRY +_mesa_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, + GLfloat v2) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat v[3]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3f"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_FLOAT, 3); +} + +void GLAPIENTRY +_mesa_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, + GLfloat v2, GLfloat v3) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat v[4]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4f"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_FLOAT, 4); +} + +void GLAPIENTRY +_mesa_ProgramUniform1i(GLuint program, GLint location, GLint v0) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1i"); + _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_INT, 1); +} + +void GLAPIENTRY +_mesa_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) +{ + GET_CURRENT_CONTEXT(ctx); + GLint v[2]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2i"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_INT, 2); +} + +void GLAPIENTRY +_mesa_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, + GLint v2) +{ + GET_CURRENT_CONTEXT(ctx); + GLint v[3]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3i"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_INT, 3); +} + +void GLAPIENTRY +_mesa_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, + GLint v2, GLint v3) +{ + GET_CURRENT_CONTEXT(ctx); + GLint v[4]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4i"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_INT, 4); +} + +void GLAPIENTRY +_mesa_ProgramUniform1fv(GLuint program, GLint location, GLsizei count, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1fv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 1); +} + +void GLAPIENTRY +_mesa_ProgramUniform2fv(GLuint program, GLint location, GLsizei count, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform2fv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 2); +} + +void GLAPIENTRY +_mesa_ProgramUniform3fv(GLuint program, GLint location, GLsizei count, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform3fv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 3); +} + +void GLAPIENTRY +_mesa_ProgramUniform4fv(GLuint program, GLint location, GLsizei count, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform4fv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 4); +} + +void GLAPIENTRY +_mesa_ProgramUniform1iv(GLuint program, GLint location, GLsizei count, + const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1iv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 1); +} + +void GLAPIENTRY +_mesa_ProgramUniform2iv(GLuint program, GLint location, GLsizei count, + const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform2iv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 2); +} + +void GLAPIENTRY +_mesa_ProgramUniform3iv(GLuint program, GLint location, GLsizei count, + const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform3iv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 3); +} + +void GLAPIENTRY +_mesa_ProgramUniform4iv(GLuint program, GLint location, GLsizei count, + const GLint * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform4iv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 4); +} + + +/** OpenGL 3.0 GLuint-valued functions **/ +void GLAPIENTRY +_mesa_Uniform1ui(GLint location, GLuint v0) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_UINT, 1); +} + +void GLAPIENTRY +_mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint v[2]; + v[0] = v0; + v[1] = v1; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_UINT, 2); +} + +void GLAPIENTRY +_mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint v[3]; + v[0] = v0; + v[1] = v1; + v[2] = v2; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_UINT, 3); +} + +void GLAPIENTRY +_mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint v[4]; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_UINT, 4); +} + +void GLAPIENTRY +_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 1); +} + +void GLAPIENTRY +_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 2); +} + +void GLAPIENTRY +_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 3); +} + +void GLAPIENTRY +_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 4); +} + + + +void GLAPIENTRY +_mesa_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 2, 2, location, count, transpose, value, GLSL_TYPE_FLOAT); +} + +void GLAPIENTRY +_mesa_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 3, 3, location, count, transpose, value, GLSL_TYPE_FLOAT); +} + +void GLAPIENTRY +_mesa_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 4, 4, location, count, transpose, value, GLSL_TYPE_FLOAT); +} + +/** Same as above with direct state access **/ + +void GLAPIENTRY +_mesa_ProgramUniform1ui(GLuint program, GLint location, GLuint v0) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1ui"); + _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_UINT, 1); +} + +void GLAPIENTRY +_mesa_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint v[2]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform2ui"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 2); +} + +void GLAPIENTRY +_mesa_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, + GLuint v2) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint v[3]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform3ui"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 3); +} + +void GLAPIENTRY +_mesa_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, + GLuint v2, GLuint v3) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint v[4]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4ui"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 4); +} + +void GLAPIENTRY +_mesa_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count, + const GLuint *value) { - switch (type) { - case GL_BOOL: - case GL_BOOL_VEC2: - case GL_BOOL_VEC3: - case GL_BOOL_VEC4: - return GL_TRUE; - default: - return GL_FALSE; - } + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1uiv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 1); } - -static GLboolean -is_sampler_type(GLenum type) -{ - switch (type) { - case GL_SAMPLER_1D: - case GL_INT_SAMPLER_1D: - case GL_UNSIGNED_INT_SAMPLER_1D: - case GL_SAMPLER_2D: - case GL_INT_SAMPLER_2D: - case GL_UNSIGNED_INT_SAMPLER_2D: - case GL_SAMPLER_3D: - case GL_INT_SAMPLER_3D: - case GL_UNSIGNED_INT_SAMPLER_3D: - case GL_SAMPLER_CUBE: - case GL_INT_SAMPLER_CUBE: - case GL_UNSIGNED_INT_SAMPLER_CUBE: - case GL_SAMPLER_1D_SHADOW: - case GL_SAMPLER_2D_SHADOW: - case GL_SAMPLER_CUBE_SHADOW: - case GL_SAMPLER_2D_RECT_ARB: - case GL_INT_SAMPLER_2D_RECT: - case GL_UNSIGNED_INT_SAMPLER_2D_RECT: - case GL_SAMPLER_2D_RECT_SHADOW_ARB: - case GL_SAMPLER_1D_ARRAY_EXT: - case GL_INT_SAMPLER_1D_ARRAY: - case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: - case GL_SAMPLER_2D_ARRAY_EXT: - case GL_INT_SAMPLER_2D_ARRAY: - case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: - case GL_SAMPLER_1D_ARRAY_SHADOW_EXT: - case GL_SAMPLER_2D_ARRAY_SHADOW_EXT: - case GL_SAMPLER_CUBE_MAP_ARRAY: - case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW: - case GL_SAMPLER_BUFFER: - case GL_INT_SAMPLER_BUFFER: - case GL_UNSIGNED_INT_SAMPLER_BUFFER: - case GL_SAMPLER_2D_MULTISAMPLE: - case GL_INT_SAMPLER_2D_MULTISAMPLE: - case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: - case GL_SAMPLER_2D_MULTISAMPLE_ARRAY: - case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: - case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: - case GL_SAMPLER_EXTERNAL_OES: - return GL_TRUE; - default: - return GL_FALSE; - } +void GLAPIENTRY +_mesa_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count, + const GLuint *value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform2uiv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 2); } +void GLAPIENTRY +_mesa_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count, + const GLuint *value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform3uiv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 3); +} -/** - * Given a uniform index, return the vertex/geometry/fragment program - * that has that parameter, plus the position of the parameter in the - * parameter/constant buffer. - * \param shProg the shader program - * \param index the uniform index in [0, NumUniforms-1] - * \param progOut returns containing program - * \param posOut returns position of the uniform in the param/const buffer - * \return GL_TRUE for success, GL_FALSE for invalid index - */ -static GLboolean -find_uniform_parameter_pos(struct gl_shader_program *shProg, GLint index, - struct gl_program **progOut, GLint *posOut) +void GLAPIENTRY +_mesa_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count, + const GLuint *value) { - struct gl_program *prog = NULL; - GLint pos; + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform4uiv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 4); +} - if (!shProg->Uniforms || - index < 0 || - index >= (GLint) shProg->Uniforms->NumUniforms) { - return GL_FALSE; - } - pos = shProg->Uniforms->Uniforms[index].VertPos; - if (pos >= 0) { - prog = shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program; - } - else { - pos = shProg->Uniforms->Uniforms[index].FragPos; - if (pos >= 0) { - prog = shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program; - } - else { - pos = shProg->Uniforms->Uniforms[index].GeomPos; - if (pos >= 0) { - prog = shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program; - } - } - } - if (!prog || pos < 0) - return GL_FALSE; /* should really never happen */ +void GLAPIENTRY +_mesa_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix2fv"); + _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - *progOut = prog; - *posOut = pos; +void GLAPIENTRY +_mesa_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix3fv"); + _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - return GL_TRUE; +void GLAPIENTRY +_mesa_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix4fv"); + _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GLSL_TYPE_FLOAT); } /** - * Return pointer to a gl_program_parameter which corresponds to a uniform. - * \param shProg the shader program - * \param index the uniform index in [0, NumUniforms-1] - * \return gl_program_parameter point or NULL if index is invalid + * Non-square UniformMatrix are OpenGL 2.1 */ -const struct gl_program_parameter * -get_uniform_parameter(struct gl_shader_program *shProg, GLint index) -{ - struct gl_program *prog; - GLint progPos; - - if (find_uniform_parameter_pos(shProg, index, &prog, &progPos)) - return &prog->Parameters->Parameters[progPos]; - else - return NULL; -} - - -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; - } +void GLAPIENTRY +_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 2, 3, location, count, transpose, value, GLSL_TYPE_FLOAT); } -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; - } +void GLAPIENTRY +_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 3, 2, location, count, transpose, value, GLSL_TYPE_FLOAT); } - -/** - * 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); - } +void GLAPIENTRY +_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 2, 4, location, count, transpose, value, GLSL_TYPE_FLOAT); } -static bool -validate_uniform_parameters(struct gl_context *ctx, - struct gl_shader_program *shProg, - GLint location, GLsizei count, - unsigned *loc, - unsigned *array_index, - const char *caller, - bool negative_one_is_not_valid) +void GLAPIENTRY +_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) { - if (!shProg || !shProg->LinkStatus) { - _mesa_error(ctx, GL_INVALID_OPERATION, "%s(program not linked)", caller); - return false; - } + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 4, 2, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - if (location == -1) { - /* For glGetUniform, page 264 (page 278 of the PDF) of the OpenGL 2.1 - * spec says: - * - * "The error INVALID_OPERATION is generated if program has not been - * linked successfully, or if location is not a valid location for - * program." - * - * For glUniform, page 82 (page 96 of the PDF) of the OpenGL 2.1 spec - * says: - * - * "If the value of location is -1, the Uniform* commands will - * silently ignore the data passed in, and the current uniform - * values will not be changed." - * - * Allowing -1 for the location parameter of glUniform allows - * applications to avoid error paths in the case that, for example, some - * uniform variable is removed by the compiler / linker after - * optimization. In this case, the new value of the uniform is dropped - * on the floor. For the case of glGetUniform, there is nothing - * sensible to do for a location of -1. - * - * The negative_one_is_not_valid flag selects between the two behaviors. - */ - if (negative_one_is_not_valid) { - _mesa_error(ctx, GL_INVALID_OPERATION, "%s(location=%d)", - caller, location); - } +void GLAPIENTRY +_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 3, 4, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - return false; - } +void GLAPIENTRY +_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 4, 3, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - /* From page 12 (page 26 of the PDF) of the OpenGL 2.1 spec: - * - * "If a negative number is provided where an argument of type sizei or - * sizeiptr is specified, the error INVALID_VALUE is generated." - */ - if (count < 0) { - _mesa_error(ctx, GL_INVALID_VALUE, "%s(count < 0)", caller); - return false; - } +/** Same as above with direct state access **/ - /* Page 82 (page 96 of the PDF) of the OpenGL 2.1 spec says: - * - * "If any of the following conditions occur, an INVALID_OPERATION - * error is generated by the Uniform* commands, and no uniform values - * are changed: - * - * ... - * - * - if no variable with a location of location exists in the - * program object currently in use and location is not -1, - */ - if (location < -1) { - _mesa_error(ctx, GL_INVALID_OPERATION, "%s(location=%d)", - caller, location); - return false; - } +void GLAPIENTRY +_mesa_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix2x3fv"); + _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - _mesa_uniform_split_location_offset(location, loc, array_index); +void GLAPIENTRY +_mesa_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix3x2fv"); + _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - if (*loc >= shProg->Uniforms->NumUniforms) { - _mesa_error(ctx, GL_INVALID_OPERATION, "%s(location=%d)", - caller, location); - return false; - } +void GLAPIENTRY +_mesa_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix2x4fv"); + _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - return true; +void GLAPIENTRY +_mesa_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix4x2fv"); + _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GLSL_TYPE_FLOAT); } -/** - * Called via glGetUniform[fiui]v() to get the current value of a uniform. - */ -void -_mesa_get_uniform(struct gl_context *ctx, GLuint program, GLint location, - GLsizei bufSize, GLenum returnType, GLvoid *paramsOut) +void GLAPIENTRY +_mesa_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) { + GET_CURRENT_CONTEXT(ctx); struct gl_shader_program *shProg = - _mesa_lookup_shader_program_err(ctx, program, "glGetUniformfv"); - struct gl_program *prog; - GLint paramPos; - unsigned loc, offset; + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix3x4fv"); + _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - if (!validate_uniform_parameters(ctx, shProg, location, 1, - &loc, &offset, "glGetUniform", true)) - return; +void GLAPIENTRY +_mesa_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLfloat * value) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix4x3fv"); + _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GLSL_TYPE_FLOAT); +} - if (!find_uniform_parameter_pos(shProg, loc, &prog, ¶mPos)) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(location)"); - } - else { - const struct gl_program_parameter *p = - &prog->Parameters->Parameters[paramPos]; - gl_constant_value (*values)[4]; - GLint rows, cols, i, j, k; - GLsizei numBytes; - GLenum storage_type; - - values = prog->Parameters->ParameterValues + paramPos + offset; - - get_uniform_rows_cols(p, &rows, &cols); - - numBytes = rows * cols * _mesa_sizeof_type(returnType); - if (bufSize < numBytes) { - _mesa_error( ctx, GL_INVALID_OPERATION, - "glGetnUniformfvARB(out of bounds: bufSize is %d," - " but %d bytes are required)", bufSize, numBytes ); - return; - } - if (ctx->Const.NativeIntegers) { - storage_type = base_uniform_type(p->DataType); - } else { - storage_type = GL_FLOAT; - } +void GLAPIENTRY +_mesa_GetnUniformfvARB(GLuint program, GLint location, + GLsizei bufSize, GLfloat *params) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_FLOAT, params); +} - k = 0; - for (i = 0; i < rows; i++) { - for (j = 0; j < cols; j++ ) { - void *out = (char *)paramsOut + 4 * k; - - switch (returnType) { - case GL_FLOAT: - switch (storage_type) { - case GL_FLOAT: - *(float *)out = values[i][j].f; - break; - case GL_INT: - case GL_BOOL: /* boolean is just an integer 1 or 0. */ - *(float *)out = values[i][j].i; - break; - case GL_UNSIGNED_INT: - *(float *)out = values[i][j].u; - break; - } - break; - - case GL_INT: - case GL_UNSIGNED_INT: - switch (storage_type) { - case GL_FLOAT: - /* While the GL 3.2 core spec doesn't explicitly - * state how conversion of float uniforms to integer - * values works, in section 6.2 "State Tables" on - * page 267 it says: - * - * "Unless otherwise specified, when floating - * point state is returned as integer values or - * integer state is returned as floating-point - * values it is converted in the fashion - * described in section 6.1.2" - * - * That section, on page 248, says: - * - * "If GetIntegerv or GetInteger64v are called, - * a floating-point value is rounded to the - * nearest integer..." - */ - *(int *)out = IROUND(values[i][j].f); - break; - - case GL_INT: - case GL_UNSIGNED_INT: - case GL_BOOL: - /* type conversions for these to int/uint are just - * copying the data. - */ - *(int *)out = values[i][j].i; - break; - break; - } - break; - } - - k++; - } - } - } +void GLAPIENTRY +_mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params) +{ + _mesa_GetnUniformfvARB(program, location, INT_MAX, params); } -/** - * 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) +void GLAPIENTRY +_mesa_GetnUniformivARB(GLuint program, GLint location, + GLsizei bufSize, GLint *params) { - GLint offset = 0, location = -1; + GET_CURRENT_CONTEXT(ctx); + _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT, params); +} - /* XXX we should return -1 if the uniform was declared, but not - * actually used. - */ +void GLAPIENTRY +_mesa_GetUniformiv(GLuint program, GLint location, GLint *params) +{ + _mesa_GetnUniformivARB(program, location, INT_MAX, params); +} - /* 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 */ - const struct gl_program_parameter *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); - } - } +/* GL3 */ +void GLAPIENTRY +_mesa_GetnUniformuivARB(GLuint program, GLint location, + GLsizei bufSize, GLuint *params) +{ + GET_CURRENT_CONTEXT(ctx); + _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT, params); +} - if (location < 0) { - location = _mesa_lookup_uniform(shProg->Uniforms, name); - } +void GLAPIENTRY +_mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params) +{ + _mesa_GetnUniformuivARB(program, location, INT_MAX, params); +} - if (location < 0) { - return -1; - } - return _mesa_uniform_merge_location_offset(location, offset); +/* GL4 */ +void GLAPIENTRY +_mesa_GetnUniformdvARB(GLuint program, GLint location, + GLsizei bufSize, GLdouble *params) +{ + GET_CURRENT_CONTEXT(ctx); + + _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params); } +void GLAPIENTRY +_mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params) +{ + _mesa_GetnUniformdvARB(program, location, INT_MAX, params); +} -/** - * 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) +GLint GLAPIENTRY +_mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name) { - GLuint s; + struct gl_shader_program *shProg; - memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed)); + GET_CURRENT_CONTEXT(ctx); - for (s = 0; s < MAX_SAMPLERS; s++) { - if (prog->SamplersUsed & (1 << s)) { - GLuint unit = prog->SamplerUnits[s]; - GLuint tgt = prog->SamplerTargets[s]; - assert(unit < Elements(prog->TexturesUsed)); - assert(tgt < NUM_TEXTURE_TARGETS); - prog->TexturesUsed[unit] |= (1 << tgt); - } + shProg = _mesa_lookup_shader_program_err(ctx, programObj, + "glGetUniformLocation"); + if (!shProg) + return -1; + + /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says: + * + * "If program has not been successfully linked, the error + * INVALID_OPERATION is generated." + */ + if (shProg->LinkStatus == GL_FALSE) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetUniformLocation(program not linked)"); + return -1; } -} + return _mesa_program_resource_location(shProg, GL_UNIFORM, name); +} -/** - * 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) +GLuint GLAPIENTRY +_mesa_GetUniformBlockIndex(GLuint program, + const GLchar *uniformBlockName) { - if (userType == targetType) - return GL_TRUE; + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg; - if (targetType == GL_BOOL && (userType == GL_FLOAT || - userType == GL_UNSIGNED_INT || - userType == GL_INT)) - return GL_TRUE; + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex"); + return GL_INVALID_INDEX; + } - if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 || - userType == GL_UNSIGNED_INT_VEC2 || - userType == GL_INT_VEC2)) - return GL_TRUE; + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetUniformBlockIndex"); + if (!shProg) + return GL_INVALID_INDEX; - if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 || - userType == GL_UNSIGNED_INT_VEC3 || - userType == GL_INT_VEC3)) - return GL_TRUE; + struct gl_program_resource *res = + _mesa_program_resource_find_name(shProg, GL_UNIFORM_BLOCK, + uniformBlockName, NULL); + if (!res) + return GL_INVALID_INDEX; - if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 || - userType == GL_UNSIGNED_INT_VEC4 || - userType == GL_INT_VEC4)) - return GL_TRUE; + return _mesa_program_resource_index(shProg, res); +} - if (is_sampler_type(targetType) && userType == GL_INT) - return GL_TRUE; +void GLAPIENTRY +_mesa_GetUniformIndices(GLuint program, + GLsizei uniformCount, + const GLchar * const *uniformNames, + GLuint *uniformIndices) +{ + GET_CURRENT_CONTEXT(ctx); + GLsizei i; + struct gl_shader_program *shProg; - return GL_FALSE; -} + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices"); + return; + } + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetUniformIndices"); + if (!shProg) + return; -/** - * 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) + if (uniformCount < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetUniformIndices(uniformCount < 0)"); + return; + } + + for (i = 0; i < uniformCount; i++) { + struct gl_program_resource *res = + _mesa_program_resource_find_name(shProg, GL_UNIFORM, uniformNames[i], + NULL); + uniformIndices[i] = _mesa_program_resource_index(shProg, res); + } +} + +void GLAPIENTRY +_mesa_UniformBlockBinding(GLuint program, + GLuint uniformBlockIndex, + GLuint uniformBlockBinding) { - const struct gl_program_parameter *param = - &program->Parameters->Parameters[index]; + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg; + + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding"); + return; + } - assert(offset >= 0); - assert(elems >= 1); - assert(elems <= 4); + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glUniformBlockBinding"); + if (!shProg) + return; - if (!compatible_types(type, param->DataType)) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)"); + if (uniformBlockIndex >= shProg->NumUniformBlocks) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glUniformBlockBinding(block index %u >= %u)", + uniformBlockIndex, shProg->NumUniformBlocks); return; } - if (index + offset > (GLint) program->Parameters->Size) { - /* out of bounds! */ + if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glUniformBlockBinding(block binding %u >= %u)", + uniformBlockBinding, ctx->Const.MaxUniformBufferBindings); 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].f; - GLuint texUnit = ((GLuint *) values)[i]; - - /* check that the sampler (tex unit index) is legal */ - if (texUnit >= ctx->Const.MaxCombinedTextureImageUnits) { - _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 (shProg->UniformBlocks[uniformBlockIndex]->Binding != + uniformBlockBinding) { + int i; - 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; - } - } + FLUSH_VERTICES(ctx, 0); + ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer; - /* loop over number of array elements */ - for (k = 0; k < count; k++) { - gl_constant_value *uniformVal; - - if (offset + k >= slots) { - /* Extra array data is ignored */ - break; - } - - /* uniformVal (the destination) is always gl_constant_value[4] */ - uniformVal = program->Parameters->ParameterValues[index + offset + k]; - - if (basicType == GL_INT) { - const GLint *iValues = ((const GLint *) values) + k * elems; - for (i = 0; i < elems; i++) { - if (!ctx->Const.NativeIntegers) - uniformVal[i].f = (GLfloat) iValues[i]; - else - uniformVal[i].i = iValues[i]; - } - } - else if (basicType == GL_UNSIGNED_INT) { - const GLuint *iValues = ((const GLuint *) values) + k * elems; - for (i = 0; i < elems; i++) { - if (!ctx->Const.NativeIntegers) - uniformVal[i].f = (GLfloat)(GLuint) iValues[i]; - else - uniformVal[i].u = iValues[i]; - } - } - else { - const GLfloat *fValues = ((const GLfloat *) values) + k * elems; - assert(basicType == GL_FLOAT); - for (i = 0; i < elems; i++) { - uniformVal[i].f = fValues[i]; - } - } - - /* if the uniform is bool-valued, convert to 1 or 0 */ - if (isUniformBool) { - for (i = 0; i < elems; i++) { - if (basicType == GL_FLOAT) - uniformVal[i].b = uniformVal[i].f != 0.0f ? 1 : 0; - else - uniformVal[i].b = uniformVal[i].u ? 1 : 0; - - if (ctx->Const.NativeIntegers) - uniformVal[i].u = - uniformVal[i].b ? ctx->Const.UniformBooleanTrue : 0; - else - uniformVal[i].f = uniformVal[i].b ? 1.0f : 0.0f; - } - } + const int interface_block_index = + shProg->UboInterfaceBlockIndex[uniformBlockIndex]; + + shProg->BufferInterfaceBlocks[interface_block_index].Binding = + uniformBlockBinding; + + for (i = 0; i < MESA_SHADER_STAGES; i++) { + int stage_index = + shProg->InterfaceBlockStageIndex[i][interface_block_index]; + + if (stage_index != -1) { + struct gl_shader *sh = shProg->_LinkedShaders[i]; + sh->BufferInterfaceBlocks[stage_index].Binding = uniformBlockBinding; + } } } } - -/** - * 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) +void GLAPIENTRY +_mesa_ShaderStorageBlockBinding(GLuint program, + GLuint shaderStorageBlockIndex, + GLuint shaderStorageBlockBinding) { - struct gl_uniform *uniform; - GLint elems; - unsigned loc, offset; + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg; - ASSERT_OUTSIDE_BEGIN_END(ctx); + if (!ctx->Extensions.ARB_shader_storage_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding"); + return; + } - if (!validate_uniform_parameters(ctx, shProg, location, count, - &loc, &offset, "glUniform", false)) + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glShaderStorageBlockBinding"); + if (!shProg) return; - elems = _mesa_sizeof_glsl_type(type); + if (shaderStorageBlockIndex >= shProg->NumShaderStorageBlocks) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glShaderStorageBlockBinding(block index %u >= %u)", + shaderStorageBlockIndex, shProg->NumShaderStorageBlocks); + return; + } - FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS); + if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glShaderStorageBlockBinding(block binding %u >= %u)", + shaderStorageBlockBinding, + ctx->Const.MaxShaderStorageBufferBindings); + return; + } - uniform = &shProg->Uniforms->Uniforms[loc]; + if (shProg->ShaderStorageBlocks[shaderStorageBlockIndex]->Binding != + shaderStorageBlockBinding) { + int i; - 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"); - } + FLUSH_VERTICES(ctx, 0); + ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer; - /* 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->_LinkedShaders[MESA_SHADER_VERTEX]) { - /* convert uniform location to program parameter index */ - GLint index = uniform->VertPos; - if (index >= 0) { - set_program_uniform(ctx, - shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program, - index, offset, type, count, elems, values); - } - } + const int interface_block_index = + shProg->SsboInterfaceBlockIndex[shaderStorageBlockIndex]; - if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]) { - /* convert uniform location to program parameter index */ - GLint index = uniform->FragPos; - if (index >= 0) { - set_program_uniform(ctx, - shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program, - index, offset, type, count, elems, values); - } - } + shProg->BufferInterfaceBlocks[interface_block_index].Binding = + shaderStorageBlockBinding; + + for (i = 0; i < MESA_SHADER_STAGES; i++) { + int stage_index = + shProg->InterfaceBlockStageIndex[i][interface_block_index]; - if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]) { - /* convert uniform location to program parameter index */ - GLint index = uniform->GeomPos; - if (index >= 0) { - set_program_uniform(ctx, - shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program, - index, offset, type, count, elems, values); + if (stage_index != -1) { + struct gl_shader *sh = shProg->_LinkedShaders[i]; + sh->BufferInterfaceBlocks[stage_index].Binding = shaderStorageBlockBinding; + } } } - - uniform->Initialized = GL_TRUE; } - /** - * Set a matrix-valued program parameter. + * Generic program resource property query. */ static void -set_program_uniform_matrix(struct gl_context *ctx, struct gl_program *program, - GLuint index, GLuint offset, - GLuint count, GLuint rows, GLuint cols, - GLboolean transpose, const GLfloat *values) -{ - GLuint mat, row, col; - GLuint src = 0; - const struct gl_program_parameter *param = - &program->Parameters->Parameters[index]; - const GLuint slots = (param->Size + 3) / 4; - const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType); - GLint nr, nc; - - /* check that the number of rows, columns is correct */ - get_matrix_dims(param->DataType, &nr, &nc); - if (rows != nr || cols != nc) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glUniformMatrix(matrix size mismatch)"); +mesa_bufferiv(struct gl_shader_program *shProg, GLenum type, + GLuint index, GLenum pname, GLint *params, const char *caller) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_program_resource *res = + _mesa_program_resource_find_index(shProg, type, index); + + if (!res) { + _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index); return; } - if ((GLint) param->Size <= typeSize) { - /* 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, - "glUniformMatrix(uniform is not an array)"); - return; - } - } + switch (pname) { + case GL_UNIFORM_BLOCK_BINDING: + case GL_ATOMIC_COUNTER_BUFFER_BINDING: + _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING, + params, caller); + return; + case GL_UNIFORM_BLOCK_DATA_SIZE: + case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE: + _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE, + params, caller); + return; + case GL_UNIFORM_BLOCK_NAME_LENGTH: + _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH, + params, caller); + return; + case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS: + case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS: + _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES, + params, caller); + return; + case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: + case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES: + _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES, + params, caller); + return; + case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: + case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER: + _mesa_program_resource_prop(shProg, res, index, + GL_REFERENCED_BY_VERTEX_SHADER, params, + caller); + return; - /* - * Note: the _columns_ of a matrix are stored in program registers, not - * the rows. So, the loops below look a little funny. - * XXX could optimize this a bit... - */ + case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER: + case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER: + _mesa_program_resource_prop(shProg, res, index, + GL_REFERENCED_BY_TESS_CONTROL_SHADER, params, + caller); + return; - /* loop over matrices */ - for (mat = 0; mat < count; mat++) { - - /* each matrix: */ - for (col = 0; col < cols; col++) { - GLfloat *v; - if (offset >= slots) { - /* Ignore writes beyond the end of (the used part of) an array */ - return; - } - v = (GLfloat *) program->Parameters->ParameterValues[index + offset]; - for (row = 0; row < rows; row++) { - if (transpose) { - v[row] = values[src + row * cols + col]; - } - else { - v[row] = values[src + col * rows + row]; - } - } - - offset++; - } + case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER: + case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER: + _mesa_program_resource_prop(shProg, res, index, + GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params, + caller); + return; - src += rows * cols; /* next matrix */ + case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER: + case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER: + _mesa_program_resource_prop(shProg, res, index, + GL_REFERENCED_BY_GEOMETRY_SHADER, params, + caller); + return; + case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: + case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER: + _mesa_program_resource_prop(shProg, res, index, + GL_REFERENCED_BY_FRAGMENT_SHADER, params, + caller); + return; + default: + _mesa_error(ctx, GL_INVALID_ENUM, + "%s(pname 0x%x (%s))", caller, pname, + _mesa_enum_to_string(pname)); + return; } } -/** - * Called by glUniformMatrix*() functions. - * Note: cols=2, rows=4 ==> array[2] of vec4 - */ -void -_mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg, - GLint cols, GLint rows, - GLint location, GLsizei count, - GLboolean transpose, const GLfloat *values) +void GLAPIENTRY +_mesa_GetActiveUniformBlockiv(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLint *params) { - struct gl_uniform *uniform; - unsigned loc, offset; - - ASSERT_OUTSIDE_BEGIN_END(ctx); + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg; - if (!validate_uniform_parameters(ctx, shProg, location, count, - &loc, &offset, "glUniformMatrix", false)) + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv"); return; + } - if (values == NULL) { - _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix"); + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetActiveUniformBlockiv"); + if (!shProg) return; - } - FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS); + mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params, + "glGetActiveUniformBlockiv"); +} - uniform = &shProg->Uniforms->Uniforms[loc]; +void GLAPIENTRY +_mesa_GetActiveUniformBlockName(GLuint program, + GLuint uniformBlockIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg; - if (shProg->_LinkedShaders[MESA_SHADER_VERTEX]) { - /* convert uniform location to program parameter index */ - GLint index = uniform->VertPos; - if (index >= 0) { - set_program_uniform_matrix(ctx, - shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program, - index, offset, - count, rows, cols, transpose, values); - } + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv"); + return; } - if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]) { - /* convert uniform location to program parameter index */ - GLint index = uniform->FragPos; - if (index >= 0) { - set_program_uniform_matrix(ctx, - shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program, - index, offset, - count, rows, cols, transpose, values); - } + if (bufSize < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetActiveUniformBlockName(bufSize %d < 0)", + bufSize); + return; } - if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]) { - /* convert uniform location to program parameter index */ - GLint index = uniform->GeomPos; - if (index >= 0) { - set_program_uniform_matrix(ctx, - shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program, - index, offset, - count, rows, cols, transpose, values); - } - } + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetActiveUniformBlockiv"); + if (!shProg) + return; - uniform->Initialized = GL_TRUE; + if (uniformBlockName) + _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK, + uniformBlockIndex, bufSize, length, + uniformBlockName, + "glGetActiveUniformBlockName"); } - void GLAPIENTRY -_mesa_Uniform1fARB(GLint location, GLfloat v0) +_mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex, + GLsizei bufSize, GLsizei *length, + GLchar *uniformName) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_FLOAT); -} + struct gl_shader_program *shProg; -void GLAPIENTRY -_mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1) -{ - GET_CURRENT_CONTEXT(ctx); - GLfloat v[2]; - v[0] = v0; - v[1] = v1; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC2); -} + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName"); + return; + } -void GLAPIENTRY -_mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) -{ - GET_CURRENT_CONTEXT(ctx); - GLfloat v[3]; - v[0] = v0; - v[1] = v1; - v[2] = v2; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC3); + if (bufSize < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetActiveUniformName(bufSize %d < 0)", + bufSize); + return; + } + + shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName"); + + if (!shProg) + return; + + _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize, + length, uniformName, "glGetActiveUniformName"); } void GLAPIENTRY -_mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, - GLfloat v3) +_mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, + GLenum pname, GLint *params) { GET_CURRENT_CONTEXT(ctx); - GLfloat v[4]; - v[0] = v0; - v[1] = v1; - v[2] = v2; - v[3] = v3; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC4); + struct gl_shader_program *shProg; + + if (!ctx->Extensions.ARB_shader_atomic_counters) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetActiveAtomicCounterBufferiv"); + return; + } + + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetActiveAtomicCounterBufferiv"); + if (!shProg) + return; + + mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params, + "glGetActiveAtomicCounterBufferiv"); } void GLAPIENTRY -_mesa_Uniform1iARB(GLint location, GLint v0) +_mesa_Uniform1d(GLint location, GLdouble v0) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_INT); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_DOUBLE, 1); } void GLAPIENTRY -_mesa_Uniform2iARB(GLint location, GLint v0, GLint v1) +_mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1) { GET_CURRENT_CONTEXT(ctx); - GLint v[2]; + GLdouble v[2]; v[0] = v0; v[1] = v1; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC2); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 2); } void GLAPIENTRY -_mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2) +_mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2) { GET_CURRENT_CONTEXT(ctx); - GLint v[3]; + GLdouble v[3]; v[0] = v0; v[1] = v1; v[2] = v2; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC3); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 3); } void GLAPIENTRY -_mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +_mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2, + GLdouble v3) { GET_CURRENT_CONTEXT(ctx); - GLint v[4]; + GLdouble v[4]; v[0] = v0; v[1] = v1; v[2] = v2; v[3] = v3; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC4); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 4); } void GLAPIENTRY -_mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * value) +_mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 1); } void GLAPIENTRY -_mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * value) +_mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC2); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 2); } void GLAPIENTRY -_mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * value) +_mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC3); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 3); } void GLAPIENTRY -_mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * value) +_mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC4); + _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 4); } void GLAPIENTRY -_mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * value) +_mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * value) +_mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC2); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * value) +_mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC3); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * value) +_mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble *value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC4); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE); } - -/** OpenGL 3.0 GLuint-valued functions **/ void GLAPIENTRY -_mesa_Uniform1ui(GLint location, GLuint v0) +_mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble *value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1) +_mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble *value) { GET_CURRENT_CONTEXT(ctx); - GLuint v[2]; - v[0] = v0; - v[1] = v1; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) +_mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble *value) { GET_CURRENT_CONTEXT(ctx); - GLuint v[3]; - v[0] = v0; - v[1] = v1; - v[2] = v2; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +_mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble *value) { GET_CURRENT_CONTEXT(ctx); - GLuint v[4]; - v[0] = v0; - v[1] = v1; - v[2] = v2; - v[3] = v3; - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value) +_mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, + const GLdouble *value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT); + _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram, + 4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value) +_mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1d"); + _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_DOUBLE, 1); } void GLAPIENTRY -_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value) +_mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3); + GLdouble v[2]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 2); } void GLAPIENTRY -_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value) +_mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, + GLdouble v2) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4); + GLdouble v[3]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 3); } - - void GLAPIENTRY -_mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, - const GLfloat * value) +_mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, + GLdouble v2, GLdouble v3) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 2, 2, location, count, transpose, value); + GLdouble v[4]; + struct gl_shader_program *shProg; + v[0] = v0; + v[1] = v1; + v[2] = v2; + v[3] = v3; + shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d"); + _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 4); } void GLAPIENTRY -_mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, - const GLfloat * value) +_mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 3, 3, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform1dv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 1); } void GLAPIENTRY -_mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, - const GLfloat * value) +_mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 4, 4, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform2dv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 2); } - -/** - * Non-square UniformMatrix are OpenGL 2.1 - */ void GLAPIENTRY -_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, - const GLfloat *value) +_mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 2, 3, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform3dv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 3); } void GLAPIENTRY -_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, - const GLfloat *value) +_mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count, + const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 3, 2, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniform4dv"); + _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 4); } void GLAPIENTRY -_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, - const GLfloat *value) +_mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 2, 4, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix2dv"); + _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, - const GLfloat *value) +_mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 4, 2, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix3dv"); + _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, - const GLfloat *value) +_mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 3, 4, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix4dv"); + _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, - const GLfloat *value) +_mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram, - 4, 3, location, count, transpose, value); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix2x3dv"); + _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE); } - void GLAPIENTRY -_mesa_GetnUniformfvARB(GLhandleARB program, GLint location, - GLsizei bufSize, GLfloat *params) +_mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_get_uniform(ctx, program, location, bufSize, GL_FLOAT, params); -} - -void GLAPIENTRY -_mesa_GetUniformfvARB(GLhandleARB program, GLint location, GLfloat *params) -{ - _mesa_GetnUniformfvARB(program, location, INT_MAX, params); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix3x2dv"); + _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE); } - void GLAPIENTRY -_mesa_GetnUniformivARB(GLhandleARB program, GLint location, - GLsizei bufSize, GLint *params) +_mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_get_uniform(ctx, program, location, bufSize, GL_INT, params); -} - -void GLAPIENTRY -_mesa_GetUniformivARB(GLhandleARB program, GLint location, GLint *params) -{ - _mesa_GetnUniformivARB(program, location, INT_MAX, params); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix2x4dv"); + _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE); } - -/* GL3 */ void GLAPIENTRY -_mesa_GetnUniformuivARB(GLhandleARB program, GLint location, - GLsizei bufSize, GLuint *params) +_mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - _mesa_get_uniform(ctx, program, location, bufSize, GL_UNSIGNED_INT, params); -} - -void GLAPIENTRY -_mesa_GetUniformuiv(GLhandleARB program, GLint location, GLuint *params) -{ - _mesa_GetnUniformuivARB(program, location, INT_MAX, params); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix4x2dv"); + _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE); } - -/* GL4 */ void GLAPIENTRY -_mesa_GetnUniformdvARB(GLhandleARB program, GLint location, - GLsizei bufSize, GLdouble *params) +_mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { GET_CURRENT_CONTEXT(ctx); - - (void) program; - (void) location; - (void) bufSize; - (void) params; - - /* - _mesa_get_uniform(ctx, program, location, bufSize, GL_DOUBLE, params); - */ - _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformdvARB" - "(GL_ARB_gpu_shader_fp64 not implemented)"); + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix3x4dv"); + _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE); } void GLAPIENTRY -_mesa_GetUniformdv(GLhandleARB program, GLint location, GLdouble *params) +_mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, + GLboolean transpose, const GLdouble * value) { - _mesa_GetnUniformdvARB(program, location, INT_MAX, params); -} - - -GLint GLAPIENTRY -_mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name) -{ - struct gl_shader_program *shProg; - GET_CURRENT_CONTEXT(ctx); - - shProg = _mesa_lookup_shader_program_err(ctx, programObj, - "glGetUniformLocation"); - if (!shProg) - return -1; - - /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says: - * - * "If program has not been successfully linked, the error - * INVALID_OPERATION is generated." - */ - if (shProg->LinkStatus == GL_FALSE) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetUniformLocation(program not linked)"); - return -1; - } - - return _mesa_get_uniform_location(ctx, shProg, name); -} - - -/** - * Plug in shader uniform-related functions into API dispatch table. - */ -void -_mesa_init_shader_uniform_dispatch(struct _glapi_table *exec) -{ -#if FEATURE_GL - SET_Uniform1fARB(exec, _mesa_Uniform1fARB); - SET_Uniform2fARB(exec, _mesa_Uniform2fARB); - SET_Uniform3fARB(exec, _mesa_Uniform3fARB); - SET_Uniform4fARB(exec, _mesa_Uniform4fARB); - SET_Uniform1iARB(exec, _mesa_Uniform1iARB); - SET_Uniform2iARB(exec, _mesa_Uniform2iARB); - SET_Uniform3iARB(exec, _mesa_Uniform3iARB); - SET_Uniform4iARB(exec, _mesa_Uniform4iARB); - SET_Uniform1fvARB(exec, _mesa_Uniform1fvARB); - SET_Uniform2fvARB(exec, _mesa_Uniform2fvARB); - SET_Uniform3fvARB(exec, _mesa_Uniform3fvARB); - SET_Uniform4fvARB(exec, _mesa_Uniform4fvARB); - SET_Uniform1ivARB(exec, _mesa_Uniform1ivARB); - SET_Uniform2ivARB(exec, _mesa_Uniform2ivARB); - SET_Uniform3ivARB(exec, _mesa_Uniform3ivARB); - SET_Uniform4ivARB(exec, _mesa_Uniform4ivARB); - SET_UniformMatrix2fvARB(exec, _mesa_UniformMatrix2fvARB); - SET_UniformMatrix3fvARB(exec, _mesa_UniformMatrix3fvARB); - SET_UniformMatrix4fvARB(exec, _mesa_UniformMatrix4fvARB); - - SET_GetActiveUniformARB(exec, _mesa_GetActiveUniformARB); - SET_GetUniformLocationARB(exec, _mesa_GetUniformLocationARB); - SET_GetUniformfvARB(exec, _mesa_GetUniformfvARB); - SET_GetUniformivARB(exec, _mesa_GetUniformivARB); - - /* OpenGL 2.1 */ - SET_UniformMatrix2x3fv(exec, _mesa_UniformMatrix2x3fv); - SET_UniformMatrix3x2fv(exec, _mesa_UniformMatrix3x2fv); - SET_UniformMatrix2x4fv(exec, _mesa_UniformMatrix2x4fv); - SET_UniformMatrix4x2fv(exec, _mesa_UniformMatrix4x2fv); - SET_UniformMatrix3x4fv(exec, _mesa_UniformMatrix3x4fv); - SET_UniformMatrix4x3fv(exec, _mesa_UniformMatrix4x3fv); - - /* OpenGL 3.0 */ - SET_Uniform1uiEXT(exec, _mesa_Uniform1ui); - SET_Uniform2uiEXT(exec, _mesa_Uniform2ui); - SET_Uniform3uiEXT(exec, _mesa_Uniform3ui); - SET_Uniform4uiEXT(exec, _mesa_Uniform4ui); - SET_Uniform1uivEXT(exec, _mesa_Uniform1uiv); - SET_Uniform2uivEXT(exec, _mesa_Uniform2uiv); - SET_Uniform3uivEXT(exec, _mesa_Uniform3uiv); - SET_Uniform4uivEXT(exec, _mesa_Uniform4uiv); - SET_GetUniformuivEXT(exec, _mesa_GetUniformuiv); - - /* GL_ARB_robustness */ - SET_GetnUniformfvARB(exec, _mesa_GetnUniformfvARB); - SET_GetnUniformivARB(exec, _mesa_GetnUniformivARB); - SET_GetnUniformuivARB(exec, _mesa_GetnUniformuivARB); - SET_GetnUniformdvARB(exec, _mesa_GetnUniformdvARB); /* GL 4.0 */ - -#endif /* FEATURE_GL */ + struct gl_shader_program *shProg = + _mesa_lookup_shader_program_err(ctx, program, + "glProgramUniformMatrix4x3dv"); + _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE); }