/*
* Mesa 3-D graphics library
- * Version: 6.5
+ * Version: 7.0
*
- * Copyright (C) 2004-2006 Brian Paul All Rights Reserved.
+ * Copyright (C) 2004-2007 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
/**
* \file shader_api.c
- * API functions for shader objects
+ * Implementation of GLSL-related API functions
* \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 "macros.h"
#include "program.h"
#include "prog_parameter.h"
-#include "shaderobjects.h"
-#include "shader_api.h"
-
-#include "slang_compile.h"
-#include "slang_link.h"
+#include "prog_print.h"
+#include "prog_statevars.h"
+#include "shader/shader_api.h"
+#include "shader/slang/slang_compile.h"
+#include "shader/slang/slang_link.h"
-GLvoid GLAPIENTRY
-_mesa_DeleteObjectARB(GLhandleARB obj)
-{
-#if 000
- if (obj != 0) {
- GET_CURRENT_CONTEXT(ctx);
- GET_GENERIC(gen, obj, "glDeleteObjectARB");
-
- if (gen != NULL) {
- (**gen).Delete(gen);
- RELEASE_GENERIC(gen);
- }
+/**
+ * Allocate a new gl_shader_program object, initialize it.
+ */
+struct gl_shader_program *
+_mesa_new_shader_program(GLcontext *ctx, GLuint name)
+{
+ struct gl_shader_program *shProg;
+ shProg = CALLOC_STRUCT(gl_shader_program);
+ if (shProg) {
+ shProg->Type = GL_SHADER_PROGRAM_MESA;
+ shProg->Name = name;
+ shProg->RefCount = 1;
+ shProg->Attributes = _mesa_new_parameter_list();
}
-#endif
+ return shProg;
}
-GLhandleARB GLAPIENTRY
-_mesa_GetHandleARB(GLenum pname)
+/**
+ * Clear (free) the shader program state that gets produced by linking.
+ */
+void
+_mesa_clear_shader_program_data(GLcontext *ctx,
+ struct gl_shader_program *shProg)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
-
- switch (pname) {
- case GL_PROGRAM_OBJECT_ARB:
- {
- struct gl2_program_intf **pro = ctx->ShaderObjects.CurrentProgram;
-
- if (pro != NULL)
- return (**pro)._container._generic.
- GetName((struct gl2_generic_intf **) (pro));
+ if (shProg->VertexProgram) {
+ if (shProg->VertexProgram->Base.Parameters == shProg->Uniforms) {
+ /* to prevent a double-free in the next call */
+ shProg->VertexProgram->Base.Parameters = NULL;
}
- break;
- default:
- _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
+ _mesa_delete_program(ctx, &shProg->VertexProgram->Base);
+ shProg->VertexProgram = NULL;
}
-#endif
- return 0;
-}
-
-GLvoid GLAPIENTRY
-_mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
-{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- struct gl_program *prog = _mesa_lookup_shader(ctx, shader);
- const GLuint n = linked->NumShaders;
- GLuint i, j;
-
- if (!linked || !prog) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glDetachObjectARB(bad program or shader name)");
- return;
- }
-
- for (i = 0; i < n; i++) {
- if (linked->Shaders[i] == prog) {
- struct gl_program **newList;
- /* found it */
- /* alloc new list */
- newList = (struct gl_program **)
- _mesa_malloc((n - 1) * sizeof(struct gl_program *));
- if (!newList) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachObjectARB");
- return;
- }
- for (j = 0; j < i; j++) {
- newList[j] = linked->Shaders[j];
- }
- while (++i < n)
- newList[j++] = linked->Shaders[i];
- _mesa_free(linked->Shaders);
- linked->Shaders = newList;
- return;
+ if (shProg->FragmentProgram) {
+ if (shProg->FragmentProgram->Base.Parameters == shProg->Uniforms) {
+ /* to prevent a double-free in the next call */
+ shProg->FragmentProgram->Base.Parameters = NULL;
}
+ _mesa_delete_program(ctx, &shProg->FragmentProgram->Base);
+ shProg->FragmentProgram = NULL;
}
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glDetachObjectARB(shader not found)");
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_CreateShaderObjectARB(GLenum shaderType)
-{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_program *newProg;
- GLuint name;
-
- name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
-
- switch (shaderType) {
- case GL_FRAGMENT_SHADER_ARB:
- /* alloc new gl_fragment_program */
- newProg = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, name);
- break;
- case GL_VERTEX_SHADER_ARB:
- /* alloc new gl_vertex_program */
- newProg = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, name);
- break;
- default:
- _mesa_error(ctx, GL_INVALID_ENUM, "CreateShaderObject(shaderType)");
- return 0;
+ if (shProg->Uniforms) {
+ _mesa_free_parameter_list(shProg->Uniforms);
+ shProg->Uniforms = NULL;
}
- _mesa_HashInsert(ctx->Shared->ShaderObjects, name, newProg);
-
- return name;
+ if (shProg->Varying) {
+ _mesa_free_parameter_list(shProg->Varying);
+ shProg->Varying = NULL;
+ }
}
-
-GLvoid GLAPIENTRY
-_mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
- const GLcharARB ** string, const GLint * length)
+/**
+ * Free all the data that hangs off a shader program object, but not the
+ * object itself.
+ */
+void
+_mesa_free_shader_program_data(GLcontext *ctx,
+ struct gl_shader_program *shProg)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_program *shader;
- GLint *offsets;
- GLsizei i;
- GLcharARB *source;
+ GLuint i;
- if (string == NULL) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
- return;
- }
+ assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
- shader = _mesa_lookup_shader(ctx, shaderObj);
- if (!shader) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB(shaderObj)");
- return;
- }
+ _mesa_clear_shader_program_data(ctx, shProg);
- /*
- * This array holds offsets of where the appropriate string ends, thus the
- * last element will be set to the total length of the source code.
- */
- offsets = (GLint *) _mesa_malloc(count * sizeof(GLint));
- if (offsets == NULL) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
- return;
+ if (shProg->Attributes) {
+ _mesa_free_parameter_list(shProg->Attributes);
+ shProg->Attributes = NULL;
}
- for (i = 0; i < count; i++) {
- if (string[i] == NULL) {
- _mesa_free((GLvoid *) offsets);
- _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB(null string)");
- return;
- }
- if (length == NULL || length[i] < 0)
- offsets[i] = _mesa_strlen(string[i]);
- else
- offsets[i] = length[i];
- /* accumulate string lengths */
- if (i > 0)
- offsets[i] += offsets[i - 1];
- }
-
- source = (GLcharARB *) _mesa_malloc((offsets[count - 1] + 1) *
- sizeof(GLcharARB));
- if (source == NULL) {
- _mesa_free((GLvoid *) offsets);
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
- return;
+ /* detach shaders */
+ for (i = 0; i < shProg->NumShaders; i++) {
+ _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
}
-
- for (i = 0; i < count; i++) {
- GLint start = (i > 0) ? offsets[i - 1] : 0;
- _mesa_memcpy(source + start, string[i],
- (offsets[i] - start) * sizeof(GLcharARB));
+ if (shProg->Shaders) {
+ _mesa_free(shProg->Shaders);
+ shProg->Shaders = NULL;
}
- source[offsets[count - 1]] = '\0';
+}
- /* free old shader source string and install new one */
- if (shader->String) {
- _mesa_free(shader->String);
+
+/**
+ * Free/delete a shader program object.
+ */
+void
+_mesa_free_shader_program(GLcontext *ctx, struct gl_shader_program *shProg)
+{
+ _mesa_free_shader_program_data(ctx, shProg);
+ if (shProg->Shaders) {
+ _mesa_free(shProg->Shaders);
+ shProg->Shaders = NULL;
}
- shader->String = (GLubyte *) source;
+ _mesa_free(shProg);
}
-GLvoid GLAPIENTRY
-_mesa_CompileShaderARB(GLhandleARB shaderObj)
+/**
+ * Set ptr to point to shProg.
+ * If ptr is pointing to another object, decrement its refcount (and delete
+ * if refcount hits zero).
+ * Then set ptr to point to shProg, incrementing its refcount.
+ */
+/* XXX this could be static */
+void
+_mesa_reference_shader_program(GLcontext *ctx,
+ struct gl_shader_program **ptr,
+ struct gl_shader_program *shProg)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_program *prog = _mesa_lookup_shader(ctx, shaderObj);
- slang_info_log info_log;
- slang_code_object obj;
- slang_unit_type type;
-
- if (!prog) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glCompileShader(shaderObj)");
+ assert(ptr);
+ if (*ptr == shProg) {
+ /* no-op */
return;
}
+ if (*ptr) {
+ /* Unreference the old shader program */
+ GLboolean deleteFlag = GL_FALSE;
+ struct gl_shader_program *old = *ptr;
+
+ ASSERT(old->RefCount > 0);
+ old->RefCount--;
+ /*printf("SHPROG DECR %p (%d) to %d\n",
+ (void*) old, old->Name, old->RefCount);*/
+ deleteFlag = (old->RefCount == 0);
+
+ if (deleteFlag) {
+ _mesa_HashRemove(ctx->Shared->ShaderProgramObjects, old->Name);
+ _mesa_free_shader_program(ctx, old);
+ }
- slang_info_log_construct(&info_log);
- _slang_code_object_ctr(&obj);
-
- if (prog->Target == GL_VERTEX_PROGRAM_ARB) {
- type = slang_unit_vertex_shader;
- }
- else {
- assert(prog->Target == GL_FRAGMENT_PROGRAM_ARB);
- type = slang_unit_fragment_shader;
+ *ptr = NULL;
}
+ assert(!*ptr);
- if (_slang_compile((const char*) prog->String, &obj,
- type, &info_log, prog)) {
- /*
- prog->CompileStatus = GL_TRUE;
- */
- }
- else {
- /*
- prog->CompileStatus = GL_FALSE;
- */
- _mesa_problem(ctx, "Program did not compile!");
+ if (shProg) {
+ shProg->RefCount++;
+ /*printf("SHPROG INCR %p (%d) to %d\n",
+ (void*) shProg, shProg->Name, shProg->RefCount);*/
+ *ptr = shProg;
}
}
-GLhandleARB GLAPIENTRY
-_mesa_CreateProgramObjectARB(GLvoid)
-{
- GET_CURRENT_CONTEXT(ctx);
- GLuint name;
- struct gl_linked_program *linked;
-
- name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ProgramObjects, 1);
- linked = _mesa_new_linked_program(ctx, name);
-
- _mesa_HashInsert(ctx->Shared->ProgramObjects, name, linked);
-
- return name;
-}
-
-
-GLvoid GLAPIENTRY
-_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
-{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- struct gl_program *prog = _mesa_lookup_shader(ctx, shader);
- const GLuint n = linked->NumShaders;
- GLuint i;
-
- if (!linked || !prog) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glAttachShader(bad program or shader name)");
- return;
- }
-
- for (i = 0; i < n; i++) {
- if (linked->Shaders[i] == prog) {
- /* already attached */
- return;
+/**
+ * Lookup a GLSL program object.
+ */
+struct gl_shader_program *
+_mesa_lookup_shader_program(GLcontext *ctx, GLuint name)
+{
+ struct gl_shader_program *shProg;
+ if (name) {
+ shProg = (struct gl_shader_program *)
+ _mesa_HashLookup(ctx->Shared->ShaderProgramObjects, name);
+ /* Note that both gl_shader and gl_shader_program objects are kept
+ * in the same hash table. Check the object's type to be sure it's
+ * what we're expecting.
+ */
+ if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
+ return NULL;
}
+ return shProg;
}
-
- /* grow list */
- linked->Shaders = (struct gl_program **)
- _mesa_realloc(linked->Shaders,
- n * sizeof(struct gl_program *),
- (n + 1) * sizeof(struct gl_program *));
- /* append */
- linked->Shaders[n] = prog;
- prog->RefCount++;
- linked->NumShaders++;
+ return NULL;
}
-
-
-GLvoid GLAPIENTRY
-_mesa_LinkProgramARB(GLhandleARB programObj)
+/**
+ * Allocate a new gl_shader object, initialize it.
+ */
+struct gl_shader *
+_mesa_new_shader(GLcontext *ctx, GLuint name, GLenum type)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked;
-
- linked = _mesa_lookup_linked_program(ctx, programObj);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glLinkProgram(programObj)");
- return;
+ struct gl_shader *shader;
+ assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
+ shader = CALLOC_STRUCT(gl_shader);
+ if (shader) {
+ shader->Type = type;
+ shader->Name = name;
+ shader->RefCount = 1;
}
- _slang_link2(ctx, programObj, linked);
+ return shader;
}
-
-GLvoid GLAPIENTRY
-_mesa_UseProgramObjectARB(GLhandleARB programObj)
+void
+_mesa_free_shader(GLcontext *ctx, struct gl_shader *sh)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked;
-
- FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-
- linked = _mesa_lookup_linked_program(ctx, programObj);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glUseProgramObjectARB(programObj)");
- return;
+ GLuint i;
+ if (sh->Source)
+ _mesa_free((void *) sh->Source);
+ if (sh->InfoLog)
+ _mesa_free(sh->InfoLog);
+ for (i = 0; i < sh->NumPrograms; i++) {
+ assert(sh->Programs[i]);
+ _mesa_delete_program(ctx, sh->Programs[i]);
}
-
- ctx->ShaderObjects.Linked = linked;
+ if (sh->Programs)
+ _mesa_free(sh->Programs);
+ _mesa_free(sh);
}
-GLvoid GLAPIENTRY
-_mesa_ValidateProgramARB(GLhandleARB programObj)
+/**
+ * Set ptr to point to sh.
+ * If ptr is pointing to another shader, decrement its refcount (and delete
+ * if refcount hits zero).
+ * Then set ptr to point to sh, incrementing its refcount.
+ */
+/* XXX this could be static */
+void
+_mesa_reference_shader(GLcontext *ctx, struct gl_shader **ptr,
+ struct gl_shader *sh)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_PROGRAM(pro, programObj, "glValidateProgramARB");
+ assert(ptr);
+ if (*ptr == sh) {
+ /* no-op */
+ return;
+ }
+ if (*ptr) {
+ /* Unreference the old shader */
+ GLboolean deleteFlag = GL_FALSE;
+ struct gl_shader *old = *ptr;
+
+ ASSERT(old->RefCount > 0);
+ old->RefCount--;
+ /*printf("SHADER DECR %p (%d) to %d\n",
+ (void*) old, old->Name, old->RefCount);*/
+ deleteFlag = (old->RefCount == 0);
+
+ if (deleteFlag) {
+ _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
+ _mesa_free_shader(ctx, old);
+ }
- if (pro != NULL) {
- (**pro).Validate(pro);
- RELEASE_PROGRAM(pro);
+ *ptr = NULL;
+ }
+ assert(!*ptr);
+
+ if (sh) {
+ /* reference new */
+ sh->RefCount++;
+ /*printf("SHADER INCR %p (%d) to %d\n",
+ (void*) sh, sh->Name, sh->RefCount);*/
+ *ptr = sh;
}
-#endif
}
/**
- * Helper function for all the _mesa_Uniform*() functions below.
+ * Lookup a GLSL shader object.
*/
-static INLINE void
-uniform(GLint location, GLsizei count, const GLvoid *values, GLenum type,
- const char *caller)
+struct gl_shader *
+_mesa_lookup_shader(GLcontext *ctx, GLuint name)
{
- GET_CURRENT_CONTEXT(ctx);
-
- if (ctx->ShaderObjects.Linked) {
- struct gl_linked_program *linked = ctx->ShaderObjects.Linked;
- if (location >= 0 && location < linked->Uniforms->NumParameters) {
- GLfloat *v = linked->Uniforms->ParameterValues[location];
- const GLfloat *fValues = (const GLfloat *) values; /* XXX */
- GLint i;
- if (type == GL_FLOAT_VEC4)
- count *= 4;
- else if (type == GL_FLOAT_VEC3)
- count *= 3;
- else
- abort();
-
- for (i = 0; i < count; i++)
- v[i] = fValues[i];
- return;
+ if (name) {
+ struct gl_shader *sh = (struct gl_shader *)
+ _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
+ /* Note that both gl_shader and gl_shader_program objects are kept
+ * in the same hash table. Check the object's type to be sure it's
+ * what we're expecting.
+ */
+ if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
+ return NULL;
}
+ return sh;
}
+ return NULL;
}
-GLvoid GLAPIENTRY
-_mesa_Uniform1fARB(GLint location, GLfloat v0)
-{
- uniform(location, 1, &v0, GL_FLOAT, "glUniform1fARB");
-}
-
-GLvoid GLAPIENTRY
-_mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1)
-{
- GLfloat v[2];
- v[0] = v0;
- v[1] = v1;
- uniform(location, 1, v, GL_FLOAT_VEC2, "glUniform2fARB");
-}
-
-GLvoid GLAPIENTRY
-_mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+/**
+ * Initialize context's shader state.
+ */
+void
+_mesa_init_shader_state(GLcontext * ctx)
{
- GLfloat v[3];
- v[0] = v0;
- v[1] = v1;
- v[2] = v2;
- uniform(location, 1, v, GL_FLOAT_VEC3, "glUniform3fARB");
+ /* Device drivers may override these to control what kind of instructions
+ * are generated by the GLSL compiler.
+ */
+ ctx->Shader.EmitHighLevelInstructions = GL_TRUE;
+ ctx->Shader.EmitCondCodes = GL_TRUE; /* XXX probably want GL_FALSE... */
+ ctx->Shader.EmitComments = GL_FALSE;
}
-GLvoid GLAPIENTRY
-_mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
- GLfloat v3)
-{
- GLfloat v[4];
- v[0] = v0;
- v[1] = v1;
- v[2] = v2;
- v[3] = v3;
- uniform(location, 1, v, GL_FLOAT_VEC4, "glUniform4fARB");
-}
-GLvoid GLAPIENTRY
-_mesa_Uniform1iARB(GLint location, GLint v0)
+/**
+ * Free the per-context shader-related state.
+ */
+void
+_mesa_free_shader_state(GLcontext *ctx)
{
- uniform(location, 1, &v0, GL_INT, "glUniform1iARB");
+ _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, NULL);
}
-GLvoid GLAPIENTRY
-_mesa_Uniform2iARB(GLint location, GLint v0, GLint v1)
-{
- GLint v[2];
- v[0] = v0;
- v[1] = v1;
- uniform(location, 1, v, GL_INT_VEC2, "glUniform2iARB");
-}
-GLvoid GLAPIENTRY
-_mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)
+/**
+ * Copy string from <src> to <dst>, up to maxLength characters, returning
+ * length of <dst> in <length>.
+ * \param src the strings source
+ * \param maxLength max chars to copy
+ * \param length returns number of chars copied
+ * \param dst the string destination
+ */
+static void
+copy_string(GLchar *dst, GLsizei maxLength, GLsizei *length, const GLchar *src)
{
- GLint v[3];
- v[0] = v0;
- v[1] = v1;
- v[2] = v2;
- uniform(location, 1, v, GL_INT_VEC3, "glUniform3iARB");
+ GLsizei len;
+ for (len = 0; len < maxLength - 1 && src && src[len]; len++)
+ dst[len] = src[len];
+ if (maxLength > 0)
+ dst[len] = 0;
+ if (length)
+ *length = len;
}
-GLvoid GLAPIENTRY
-_mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
- GLint v[4];
- v[0] = v0;
- v[1] = v1;
- v[2] = v2;
- v[3] = v3;
- uniform(location, 1, v, GL_INT_VEC4, "glUniform4iARB");
-}
-GLvoid GLAPIENTRY
-_mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
- uniform(location, count, value, GL_FLOAT, "glUniform1fvARB");
+/**
+ * Return size (in floats) of the given GLSL type.
+ * See also _slang_sizeof_type_specifier().
+ */
+static GLint
+sizeof_glsl_type(GLenum type)
+{
+ switch (type) {
+ case GL_BOOL:
+ case GL_FLOAT:
+ case GL_INT:
+ return 1;
+ case GL_BOOL_VEC2:
+ case GL_FLOAT_VEC2:
+ case GL_INT_VEC2:
+ return 2;
+ case GL_BOOL_VEC3:
+ case GL_FLOAT_VEC3:
+ case GL_INT_VEC3:
+ return 3;
+ case GL_BOOL_VEC4:
+ case GL_FLOAT_VEC4:
+ case GL_INT_VEC4:
+ return 4;
+ case GL_FLOAT_MAT2:
+ return 8; /* 2 rows of 4, actually */
+ case GL_FLOAT_MAT3:
+ return 12; /* 3 rows of 4, actually */
+ case GL_FLOAT_MAT4:
+ return 16;
+ case GL_FLOAT_MAT2x3:
+ return 8; /* 2 rows of 4, actually */
+ case GL_FLOAT_MAT2x4:
+ return 8;
+ case GL_FLOAT_MAT3x2:
+ return 12; /* 3 rows of 4, actually */
+ case GL_FLOAT_MAT3x4:
+ return 12;
+ case GL_FLOAT_MAT4x2:
+ return 16; /* 4 rows of 4, actually */
+ case GL_FLOAT_MAT4x3:
+ return 16; /* 4 rows of 4, actually */
+ default:
+ return 0; /* error */
+ }
}
-GLvoid GLAPIENTRY
-_mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
- uniform(location, count, value, GL_FLOAT_VEC2, "glUniform2fvARB");
-}
-GLvoid GLAPIENTRY
-_mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * value)
+/**
+ * Called via ctx->Driver.AttachShader()
+ */
+void
+_mesa_attach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
- uniform(location, count, value, GL_FLOAT_VEC3, "glUniform3fvARB");
-}
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ GLuint n;
+ GLuint i;
-GLvoid GLAPIENTRY
-_mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
- uniform(location, count, value, GL_FLOAT_VEC4, "glUniform4fvARB");
-}
+ if (!shProg || !sh) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glAttachShader(bad program or shader name)");
+ return;
+ }
-GLvoid GLAPIENTRY
-_mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * value)
-{
- uniform(location, count, value, GL_INT, "glUniform1ivARB");
-}
+ n = shProg->NumShaders;
-GLvoid GLAPIENTRY
-_mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * value)
-{
- uniform(location, count, value, GL_INT_VEC2, "glUniform2ivARB");
-}
+ for (i = 0; i < n; i++) {
+ if (shProg->Shaders[i] == sh) {
+ /* already attached */
+ return;
+ }
+ }
-GLvoid GLAPIENTRY
-_mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * value)
-{
- uniform(location, count, value, GL_INT_VEC3, "glUniform3ivARB");
-}
+ /* grow list */
+ shProg->Shaders = (struct gl_shader **)
+ _mesa_realloc(shProg->Shaders,
+ n * sizeof(struct gl_shader *),
+ (n + 1) * sizeof(struct gl_shader *));
+ if (!shProg->Shaders) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
+ return;
+ }
-GLvoid GLAPIENTRY
-_mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * value)
-{
- uniform(location, count, value, GL_INT_VEC4, "glUniform4ivARB");
+ /* append */
+ shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
+ _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
+ shProg->NumShaders++;
}
-/**
- * Helper function used by UniformMatrix**vARB() functions below.
- */
-static void
-uniform_matrix(GLint cols, GLint rows, const char *caller,
- GLenum matrixType,
- GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *values)
+void
+_mesa_bind_attrib_location(GLcontext *ctx, GLuint program, GLuint index,
+ const GLchar *name)
{
- const GLint matElements = rows * cols;
- GET_CURRENT_CONTEXT(ctx);
-
-#ifdef OLD
- GET_CURRENT_LINKED_PROGRAM(pro, caller);
-#endif
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ const GLint size = -1; /* unknown size */
+ GLint i, oldIndex;
- if (values == NULL) {
- _mesa_error(ctx, GL_INVALID_VALUE, caller);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(program)");
return;
}
- FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-
- if (transpose) {
- GLfloat *trans, *pt;
- const GLfloat *pv;
- GLint i, j, k;
-
- trans = (GLfloat *) _mesa_malloc(count * matElements * sizeof(GLfloat));
- if (!trans) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, caller);
- return;
- }
+ if (!name)
+ return;
- pt = trans;
- pv = values;
- for (i = 0; i < count; i++) {
- /* transpose from pv matrix into pt matrix */
- for (j = 0; j < cols; j++) {
- for (k = 0; k < rows; k++) {
- /* XXX verify this */
- pt[j * rows + k] = pv[k * cols + j];
- }
- }
- pt += matElements;
- pv += matElements;
- }
+ if (strncmp(name, "gl_", 3) == 0) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glBindAttribLocation(illegal name)");
+ return;
+ }
-#ifdef OLD
- if (!(**pro).WriteUniform(pro, location, count, trans, matrixType))
- _mesa_error(ctx, GL_INVALID_OPERATION, caller);
-#endif
- _mesa_free(trans);
+ if (shProg->LinkStatus) {
+ /* get current index/location for the attribute */
+ oldIndex = _mesa_get_attrib_location(ctx, program, name);
}
else {
-#ifdef OLD
- if (!(**pro).WriteUniform(pro, location, count, values, matrixType))
- _mesa_error(ctx, GL_INVALID_OPERATION, caller);
-#endif
+ oldIndex = -1;
}
-}
-
-GLvoid GLAPIENTRY
-_mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat * value)
-{
- uniform_matrix(2, 2, "glUniformMatrix2fvARB", GL_FLOAT_MAT2,
- location, count, transpose, value);
-}
+ /* this will replace the current value if it's already in the list */
+ i = _mesa_add_attribute(shProg->Attributes, name, size, index);
+ if (i < 0) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
+ }
-GLvoid GLAPIENTRY
-_mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat * value)
-{
- uniform_matrix(3, 3, "glUniformMatrix3fvARB", GL_FLOAT_MAT3,
- location, count, transpose, value);
+ if (shProg->VertexProgram && oldIndex >= 0 && oldIndex != index) {
+ /* If the index changed, need to search/replace references to that attribute
+ * in the vertex program.
+ */
+ _slang_remap_attribute(&shProg->VertexProgram->Base, oldIndex, index);
+ }
}
-GLvoid GLAPIENTRY
-_mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat * value)
-{
- uniform_matrix(4, 4, "glUniformMatrix4fvARB", GL_FLOAT_MAT4,
- location, count, transpose, value);
-}
-static GLboolean
-_mesa_get_object_parameter(GLhandleARB obj, GLenum pname, GLvoid * params,
- GLboolean * integral, GLint * size)
+GLuint
+_mesa_create_shader(GLcontext *ctx, GLenum type)
{
-#if 000
- GET_CURRENT_CONTEXT(ctx);
- GLint *ipar = (GLint *) params;
-
- /* set default values */
- *integral = GL_TRUE; /* indicates param type, TRUE: GLint, FALSE: GLfloat */
- *size = 1; /* param array size */
-
- switch (pname) {
- case GL_OBJECT_TYPE_ARB:
- case GL_OBJECT_DELETE_STATUS_ARB:
- case GL_OBJECT_INFO_LOG_LENGTH_ARB:
- {
- GET_GENERIC(gen, obj, "glGetObjectParameterivARB");
-
- if (gen == NULL)
- return GL_FALSE;
-
- switch (pname) {
- case GL_OBJECT_TYPE_ARB:
- *ipar = (**gen).GetType(gen);
- break;
- case GL_OBJECT_DELETE_STATUS_ARB:
- *ipar = (**gen).GetDeleteStatus(gen);
- break;
- case GL_OBJECT_INFO_LOG_LENGTH_ARB:
- *ipar = (**gen).GetInfoLogLength(gen);
- break;
- }
-
- RELEASE_GENERIC(gen);
- }
- break;
- case GL_OBJECT_SUBTYPE_ARB:
- case GL_OBJECT_COMPILE_STATUS_ARB:
- case GL_OBJECT_SHADER_SOURCE_LENGTH_ARB:
- {
- GET_SHADER(sha, obj, "glGetObjectParameterivARB");
-
- if (sha == NULL)
- return GL_FALSE;
-
- switch (pname) {
- case GL_OBJECT_SUBTYPE_ARB:
- *ipar = (**sha).GetSubType(sha);
- break;
- case GL_OBJECT_COMPILE_STATUS_ARB:
- *ipar = (**sha).GetCompileStatus(sha);
- break;
- case GL_OBJECT_SHADER_SOURCE_LENGTH_ARB:
- {
- const GLcharARB *src = (**sha).GetSource(sha);
- if (src == NULL)
- *ipar = 0;
- else
- *ipar = _mesa_strlen(src) + 1;
- }
- break;
- }
+ struct gl_shader *sh;
+ GLuint name;
- RELEASE_SHADER(sha);
- }
- break;
- case GL_OBJECT_LINK_STATUS_ARB:
- case GL_OBJECT_VALIDATE_STATUS_ARB:
- case GL_OBJECT_ATTACHED_OBJECTS_ARB:
- case GL_OBJECT_ACTIVE_UNIFORMS_ARB:
- case GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB:
- {
- GET_PROGRAM(pro, obj, "glGetObjectParameterivARB");
-
- if (pro == NULL)
- return GL_FALSE;
-
- switch (pname) {
- case GL_OBJECT_LINK_STATUS_ARB:
- *ipar = (**pro).GetLinkStatus(pro);
- break;
- case GL_OBJECT_VALIDATE_STATUS_ARB:
- *ipar = (**pro).GetValidateStatus(pro);
- break;
- case GL_OBJECT_ATTACHED_OBJECTS_ARB:
- *ipar =
- (**pro)._container.
- GetAttachedCount((struct gl2_container_intf **) (pro));
- break;
- case GL_OBJECT_ACTIVE_UNIFORMS_ARB:
- *ipar = (**pro).GetActiveUniformCount(pro);
- break;
- case GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB:
- *ipar = (**pro).GetActiveUniformMaxLength(pro);
- break;
- case GL_OBJECT_ACTIVE_ATTRIBUTES_ARB:
- *ipar = (**pro).GetActiveAttribCount(pro);
- break;
- case GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB:
- *ipar = (**pro).GetActiveAttribMaxLength(pro);
- break;
- }
+ name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
- RELEASE_PROGRAM(pro);
- }
+ switch (type) {
+ case GL_FRAGMENT_SHADER:
+ case GL_VERTEX_SHADER:
+ sh = _mesa_new_shader(ctx, name, type);
break;
default:
- _mesa_error(ctx, GL_INVALID_ENUM, "glGetObjectParameterivARB");
- return GL_FALSE;
- }
-#endif
- return GL_TRUE;
-}
-
-GLvoid GLAPIENTRY
-_mesa_GetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat * params)
-{
- GET_CURRENT_CONTEXT(ctx);
- GLboolean integral;
- GLint size;
-
- if (params == NULL) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterfvARB");
- return;
+ _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
+ return 0;
}
- assert(sizeof(GLfloat) == sizeof(GLint));
+ _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
- if (_mesa_get_object_parameter(obj, pname, (GLvoid *) params,
- &integral, &size)) {
- if (integral) {
- GLint i;
- for (i = 0; i < size; i++)
- params[i] = (GLfloat) ((GLint *) params)[i];
- }
- }
+ return name;
}
-GLvoid GLAPIENTRY
-_mesa_GetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint * params)
+
+GLuint
+_mesa_create_program(GLcontext *ctx)
{
- GET_CURRENT_CONTEXT(ctx);
- GLboolean integral;
- GLint size;
+ GLuint name;
+ struct gl_shader_program *shProg;
- if (params == NULL) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
- return;
- }
+ name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderProgramObjects, 1);
+ shProg = _mesa_new_shader_program(ctx, name);
- assert(sizeof(GLfloat) == sizeof(GLint));
+ _mesa_HashInsert(ctx->Shared->ShaderProgramObjects, name, shProg);
- if (_mesa_get_object_parameter(obj, pname, (GLvoid *) params,
- &integral, &size)) {
- if (!integral) {
- GLint i;
- for (i = 0; i < size; i++)
- params[i] = (GLint) ((GLfloat *) params)[i];
- }
- }
+ assert(shProg->RefCount == 1);
+
+ return name;
}
/**
- * Copy string from <src> to <dst>, up to maxLength characters, returning
- * length of <dst> in <length>.
- * \param src the strings source
- * \param maxLength max chars to copy
- * \param length returns numberof chars copied
- * \param dst the string destination
+ * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
+ * DeleteProgramARB.
*/
-static GLvoid
-copy_string(const GLcharARB * src, GLsizei maxLength, GLsizei * length,
- GLcharARB * dst)
-{
- GLsizei len;
- for (len = 0; len < maxLength - 1 && src && src[len]; len++)
- dst[len] = src[len];
- if (maxLength > 0)
- dst[len] = 0;
- if (length)
- *length = len;
-}
-
-
-GLvoid GLAPIENTRY
-_mesa_GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length,
- GLcharARB * infoLog)
+void
+_mesa_delete_program2(GLcontext *ctx, GLuint name)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_GENERIC(gen, obj, "glGetInfoLogARB");
+ /*
+ * NOTE: deleting shaders/programs works a bit differently than
+ * texture objects (and buffer objects, etc). Shader/program
+ * handles/IDs exist in the hash table until the object is really
+ * deleted (refcount==0). With texture objects, the handle/ID is
+ * removed from the hash table in glDeleteTextures() while the tex
+ * object itself might linger until its refcount goes to zero.
+ */
+ struct gl_shader_program *shProg;
- if (gen == NULL)
+ shProg = _mesa_lookup_shader_program(ctx, name);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteProgram(name)");
return;
+ }
- if (infoLog == NULL)
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetInfoLogARB");
- else {
- GLsizei actualsize = (**gen).GetInfoLogLength(gen);
- if (actualsize > maxLength)
- actualsize = maxLength;
- (**gen).GetInfoLog(gen, actualsize, infoLog);
- if (length != NULL)
- *length = (actualsize > 0) ? actualsize - 1 : 0;
- }
- RELEASE_GENERIC(gen);
-#endif
+ shProg->DeletePending = GL_TRUE;
+
+ /* effectively, decr shProg's refcount */
+ _mesa_reference_shader_program(ctx, &shProg, NULL);
}
-GLvoid GLAPIENTRY
-_mesa_GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount,
- GLsizei * count, GLhandleARB * obj)
+void
+_mesa_delete_shader(GLcontext *ctx, GLuint shader)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_CONTAINER(con, containerObj, "glGetAttachedObjectsARB");
-
- if (con == NULL)
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
return;
-
- if (obj == NULL)
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttachedObjectsARB");
- else {
- GLsizei cnt, i;
-
- cnt = (**con).GetAttachedCount(con);
- if (cnt > maxCount)
- cnt = maxCount;
- if (count != NULL)
- *count = cnt;
-
- for (i = 0; i < cnt; i++) {
- struct gl2_generic_intf **x = (**con).GetAttached(con, i);
- obj[i] = (**x).GetName(x);
- RELEASE_GENERIC(x);
- }
}
- RELEASE_CONTAINER(con);
-#endif
-}
-
-GLint GLAPIENTRY
-_mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB * name)
-{
- GET_CURRENT_CONTEXT(ctx);
- if (ctx->ShaderObjects.Linked) {
- const struct gl_linked_program *linked = ctx->ShaderObjects.Linked;
- GLuint loc;
- for (loc = 0; loc < linked->Uniforms->NumParameters; loc++) {
- const struct gl_program_parameter *u
- = linked->Uniforms->Parameters + loc;
- if (u->Type == PROGRAM_UNIFORM && !strcmp(u->Name, name)) {
- return loc;
- }
- }
- }
- return -1;
+ sh->DeletePending = GL_TRUE;
+ /* effectively, decr sh's refcount */
+ _mesa_reference_shader(ctx, &sh, NULL);
}
-GLvoid GLAPIENTRY
-_mesa_GetActiveUniformARB(GLhandleARB programObj, GLuint index,
- GLsizei maxLength, GLsizei * length, GLint * size,
- GLenum * type, GLcharARB * name)
+void
+_mesa_detach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_PROGRAM(pro, programObj, "glGetActiveUniformARB");
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ GLuint n;
+ GLuint i, j;
- if (pro == NULL)
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glDetachShader(bad program or shader name)");
return;
-
- if (size == NULL || type == NULL || name == NULL)
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniformARB");
- else {
- if (index < (**pro).GetActiveUniformCount(pro))
- (**pro).GetActiveUniform(pro, index, maxLength, length, size, type,
- name);
- else
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniformARB");
}
- RELEASE_PROGRAM(pro);
-#endif
-}
+ n = shProg->NumShaders;
-GLvoid GLAPIENTRY
-_mesa_GetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat * params)
-{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_LINKED_PROGRAM(pro, programObj, "glGetUniformfvARB");
-
- if (!pro)
- return;
+ for (i = 0; i < n; i++) {
+ if (shProg->Shaders[i]->Name == shader) {
+ /* found it */
+ struct gl_shader **newList;
- if (!(**pro).ReadUniform(pro, location, 1, params, GL_FLOAT))
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfvARB");
+ /* derefernce */
+ _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
- RELEASE_PROGRAM(pro);
+ /* alloc new, smaller array */
+ newList = (struct gl_shader **)
+ _mesa_malloc((n - 1) * sizeof(struct gl_shader *));
+ if (!newList) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
+ return;
+ }
+ for (j = 0; j < i; j++) {
+ newList[j] = shProg->Shaders[j];
+ }
+ while (++i < n)
+ newList[j++] = shProg->Shaders[i];
+ _mesa_free(shProg->Shaders);
+
+ shProg->Shaders = newList;
+ shProg->NumShaders = n - 1;
+
+#ifdef DEBUG
+ /* sanity check */
+ {
+ for (j = 0; j < shProg->NumShaders; j++) {
+ assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
+ shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
+ assert(shProg->Shaders[j]->RefCount > 0);
+ }
+ }
#endif
-}
-
-
-GLvoid GLAPIENTRY
-_mesa_GetUniformivARB(GLhandleARB programObj, GLint location, GLint * params)
-{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_LINKED_PROGRAM(pro, programObj, "glGetUniformivARB");
- if (!pro)
- return;
+ return;
+ }
+ }
- if (!(**pro).ReadUniform(pro, location, 1, params, GL_INT))
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformivARB");
- RELEASE_PROGRAM(pro);
-#endif
+ /* not found */
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glDetachShader(shader not found)");
}
-GLvoid GLAPIENTRY
-_mesa_GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length,
- GLcharARB * sourceOut)
-{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_program *shader = _mesa_lookup_shader(ctx, obj);
- if (!shader) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderSourceARB(obj)");
+void
+_mesa_get_active_attrib(GLcontext *ctx, GLuint program, GLuint index,
+ GLsizei maxLength, GLsizei *length, GLint *size,
+ GLenum *type, GLchar *nameOut)
+{
+ static const GLenum vec_types[] = {
+ GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4
+ };
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ GLint sz;
+
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib");
return;
}
- copy_string((GLcharARB *) shader->String, maxLength, length, sourceOut);
-}
-
-
-/* GL_ARB_vertex_shader */
-
-GLvoid GLAPIENTRY
-_mesa_BindAttribLocationARB(GLhandleARB programObj, GLuint index,
- const GLcharARB * name)
-{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_PROGRAM(pro, programObj, "glBindAttribLocationARB");
-
- if (pro == NULL)
+ if (!shProg->Attributes || index >= shProg->Attributes->NumParameters) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
return;
+ }
- if (name == NULL || index >= MAX_VERTEX_ATTRIBS)
- _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocationARB");
- else if (IS_NAME_WITH_GL_PREFIX(name))
- _mesa_error(ctx, GL_INVALID_OPERATION, "glBindAttribLocationARB");
- else
- (**pro).OverrideAttribBinding(pro, index, name);
- RELEASE_PROGRAM(pro);
-#endif
+ copy_string(nameOut, maxLength, length,
+ shProg->Attributes->Parameters[index].Name);
+ sz = shProg->Attributes->Parameters[index].Size;
+ if (size)
+ *size = 1; /* attributes may not be arrays */
+ if (type && sz > 0 && sz <= 4) /* XXX this is a temporary hack */
+ *type = vec_types[sz - 1];
}
-GLvoid GLAPIENTRY
-_mesa_GetActiveAttribARB(GLhandleARB programObj, GLuint index,
- GLsizei maxLength, GLsizei * length, GLint * size,
- GLenum * type, GLcharARB * name)
+/**
+ * Called via ctx->Driver.GetActiveUniform().
+ */
+void
+_mesa_get_active_uniform(GLcontext *ctx, GLuint program, GLuint index,
+ GLsizei maxLength, GLsizei *length, GLint *size,
+ GLenum *type, GLchar *nameOut)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_PROGRAM(pro, programObj, "glGetActiveAttribARB");
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ GLuint ind, j;
- if (pro == NULL)
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform");
return;
+ }
- if (name == NULL || index >= (**pro).GetActiveAttribCount(pro))
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttribARB");
- else
- (**pro).GetActiveAttrib(pro, index, maxLength, length, size, type,
- name);
- RELEASE_PROGRAM(pro);
-#endif
-}
-
-
-GLint GLAPIENTRY
-_mesa_GetAttribLocationARB(GLhandleARB programObj, const GLcharARB * name)
-{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GLint loc = -1;
- GET_LINKED_PROGRAM(pro, programObj, "glGetAttribLocationARB");
+ if (!shProg->Uniforms || index >= shProg->Uniforms->NumParameters) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
+ return;
+ }
- if (!pro)
- return -1;
+ ind = 0;
+ for (j = 0; j < shProg->Uniforms->NumParameters; j++) {
+ if (shProg->Uniforms->Parameters[j].Type == PROGRAM_UNIFORM ||
+ shProg->Uniforms->Parameters[j].Type == PROGRAM_SAMPLER) {
+ if (ind == index) {
+ GLuint uSize = shProg->Uniforms->Parameters[j].Size;
+ GLenum uType = shProg->Uniforms->Parameters[j].DataType;
+ /* found it */
+ copy_string(nameOut, maxLength, length,
+ shProg->Uniforms->Parameters[j].Name);
+ if (size) {
+ /* convert from floats to 'type' (eg: sizeof(mat4x4)=1) */
+ *size = uSize / sizeof_glsl_type(uType);
+ }
+ if (type)
+ *type = uType;
+ return;
+ }
+ ind++;
+ }
+ }
- if (name == NULL)
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttribLocationARB");
- else if (!IS_NAME_WITH_GL_PREFIX(name))
- loc = (**pro).GetAttribLocation(pro, name);
- RELEASE_PROGRAM(pro);
- return loc;
-#endif
- return 0;
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
}
/**
- ** OpenGL 2.0 functions which basically wrap the ARB_shader functions
- **/
-
-void GLAPIENTRY
-_mesa_AttachShader(GLuint program, GLuint shader)
-{
- _mesa_AttachObjectARB(program, shader);
+ * Called via ctx->Driver.GetAttachedShaders().
+ */
+void
+_mesa_get_attached_shaders(GLcontext *ctx, GLuint program, GLsizei maxCount,
+ GLsizei *count, GLuint *obj)
+{
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ if (shProg) {
+ GLint i;
+ for (i = 0; i < maxCount && i < shProg->NumShaders; i++) {
+ obj[i] = shProg->Shaders[i]->Name;
+ }
+ if (count)
+ *count = i;
+ }
+ else {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttachedShaders");
+ }
}
-GLuint GLAPIENTRY
-_mesa_CreateShader(GLenum type)
+GLint
+_mesa_get_attrib_location(GLcontext *ctx, GLuint program,
+ const GLchar *name)
{
- return (GLuint) _mesa_CreateShaderObjectARB(type);
-}
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
-GLuint GLAPIENTRY
-_mesa_CreateProgram(void)
-{
- return (GLuint) _mesa_CreateProgramObjectARB();
-}
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttribLocation");
+ return -1;
+ }
+ if (!shProg->LinkStatus) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetAttribLocation(program not linked)");
+ return -1;
+ }
-void GLAPIENTRY
-_mesa_DeleteProgram(GLuint name)
-{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked;
+ if (!name)
+ return -1;
- linked = _mesa_lookup_linked_program(ctx, name);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteProgram(name)");
- return;
+ if (shProg->Attributes) {
+ GLint i = _mesa_lookup_parameter_index(shProg->Attributes, -1, name);
+ if (i >= 0) {
+ return shProg->Attributes->Parameters[i].StateIndexes[0];
+ }
}
-
- _mesa_HashRemove(ctx->Shared->ProgramObjects, name);
- _mesa_delete_linked_program(ctx, linked);
+ return -1;
}
-void GLAPIENTRY
-_mesa_DeleteShader(GLuint shader)
+GLuint
+_mesa_get_handle(GLcontext *ctx, GLenum pname)
{
- _mesa_DeleteObjectARB(shader);
-}
+#if 0
+ GET_CURRENT_CONTEXT(ctx);
-void GLAPIENTRY
-_mesa_DetachShader(GLuint program, GLuint shader)
-{
- _mesa_DetachObjectARB(program, shader);
-}
+ switch (pname) {
+ case GL_PROGRAM_OBJECT_ARB:
+ {
+ struct gl2_program_intf **pro = ctx->Shader.CurrentProgram;
-void GLAPIENTRY
-_mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
- GLsizei *count, GLuint *obj)
-{
- {
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- if (linked) {
- GLuint i;
- for (i = 0; i < maxCount && i < linked->NumShaders; i++) {
- obj[i] = linked->Shaders[i]->Id;
- }
- if (count)
- *count = i;
- }
- else {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetAttachedShaders");
+ if (pro != NULL)
+ return (**pro)._container._generic.
+ GetName((struct gl2_generic_intf **) (pro));
}
+ break;
+ default:
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
}
+#endif
+ return 0;
}
-void GLAPIENTRY
-_mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
+void
+_mesa_get_programiv(GLcontext *ctx, GLuint program,
+ GLenum pname, GLint *params)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_PROGRAM(pro, program, "glGetProgramiv");
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
- if (!pro)
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
return;
+ }
switch (pname) {
case GL_DELETE_STATUS:
- *params = (**pro)._container._generic.GetDeleteStatus((struct gl2_generic_intf **) pro);
+ *params = shProg->DeletePending;
break;
case GL_LINK_STATUS:
- *params = (**pro).GetLinkStatus(pro);
+ *params = shProg->LinkStatus;
break;
case GL_VALIDATE_STATUS:
- *params = (**pro).GetValidateStatus(pro);
+ *params = shProg->Validated;
break;
case GL_INFO_LOG_LENGTH:
- *params = (**pro)._container._generic.GetInfoLogLength( (struct gl2_generic_intf **) pro );
+ *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
break;
case GL_ATTACHED_SHADERS:
- *params = (**pro)._container.GetAttachedCount( (struct gl2_container_intf **) pro );
+ *params = shProg->NumShaders;
break;
case GL_ACTIVE_ATTRIBUTES:
- *params = (**pro).GetActiveAttribCount(pro);
+ *params = shProg->Attributes ? shProg->Attributes->NumParameters : 0;
break;
case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
- *params = (**pro).GetActiveAttribMaxLength(pro);
+ *params = _mesa_longest_parameter_name(shProg->Attributes,
+ PROGRAM_INPUT) + 1;
break;
case GL_ACTIVE_UNIFORMS:
- *params = (**pro).GetActiveUniformCount(pro);
+ *params
+ = _mesa_num_parameters_of_type(shProg->Uniforms, PROGRAM_UNIFORM)
+ + _mesa_num_parameters_of_type(shProg->Uniforms, PROGRAM_SAMPLER);
break;
case GL_ACTIVE_UNIFORM_MAX_LENGTH:
- *params = (**pro).GetActiveUniformMaxLength(pro);
+ *params = MAX2(
+ _mesa_longest_parameter_name(shProg->Uniforms, PROGRAM_UNIFORM),
+ _mesa_longest_parameter_name(shProg->Uniforms, PROGRAM_SAMPLER));
+ if (*params > 0)
+ (*params)++; /* add one for terminating zero */
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
return;
}
-#endif
-}
-
-
-void GLAPIENTRY
-_mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
- GLsizei *length, GLchar *infoLog)
-{
- _mesa_GetInfoLogARB(program, bufSize, length, infoLog);
}
-void GLAPIENTRY
-_mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
+void
+_mesa_get_shaderiv(GLcontext *ctx, GLuint name, GLenum pname, GLint *params)
{
-#if 0
- GET_CURRENT_CONTEXT(ctx);
- GET_SHADER(sh, shader, "glGetShaderiv");
+ struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
- if (!sh)
+ if (!shader) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderiv(shader)");
return;
+ }
switch (pname) {
case GL_SHADER_TYPE:
- *params = (**sh).GetSubType(sh);
+ *params = shader->Type;
break;
case GL_DELETE_STATUS:
- *params = (**sh)._generic.GetDeleteStatus((struct gl2_generic_intf **) sh);
+ *params = shader->DeletePending;
break;
case GL_COMPILE_STATUS:
- *params = (**sh).GetCompileStatus(sh);
+ *params = shader->CompileStatus;
break;
case GL_INFO_LOG_LENGTH:
- *params = (**sh)._generic.GetInfoLogLength((struct gl2_generic_intf **)sh);
+ *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
break;
case GL_SHADER_SOURCE_LENGTH:
- {
- const GLchar *src = (**sh).GetSource(sh);
- *params = src ? (_mesa_strlen(src) + 1) : 0;
- }
+ *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
return;
}
-#endif
}
-void GLAPIENTRY
-_mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
- GLsizei *length, GLchar *infoLog)
+void
+_mesa_get_program_info_log(GLcontext *ctx, GLuint program, GLsizei bufSize,
+ GLsizei *length, GLchar *infoLog)
{
- _mesa_GetInfoLogARB(shader, bufSize, length, infoLog);
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
+ return;
+ }
+ copy_string(infoLog, bufSize, length, shProg->InfoLog);
}
-GLboolean GLAPIENTRY
-_mesa_IsProgram(GLuint name)
+void
+_mesa_get_shader_info_log(GLcontext *ctx, GLuint shader, GLsizei bufSize,
+ GLsizei *length, GLchar *infoLog)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_linked_program *linked = _mesa_lookup_linked_program(ctx, name);
- if (linked)
- return GL_TRUE;
- else
- return GL_FALSE;
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
+ return;
+ }
+ copy_string(infoLog, bufSize, length, sh->InfoLog);
}
-GLboolean GLAPIENTRY
-_mesa_IsShader(GLuint name)
+/**
+ * Called via ctx->Driver.GetShaderSource().
+ */
+void
+_mesa_get_shader_source(GLcontext *ctx, GLuint shader, GLsizei maxLength,
+ GLsizei *length, GLchar *sourceOut)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_program *shader = _mesa_lookup_shader(ctx, name);
- if (shader)
- return GL_TRUE;
- else
- return GL_FALSE;
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderSource(shader)");
+ return;
+ }
+ copy_string(sourceOut, maxLength, length, sh->Source);
}
/**
- ** 2.1 functions
- **/
-
-void GLAPIENTRY
-_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
-{
- uniform_matrix(2, 3, "glUniformMatrix2x3fv", GL_FLOAT_MAT2x3,
- location, count, transpose, value);
+ * Called via ctx->Driver.GetUniformfv().
+ */
+void
+_mesa_get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
+ GLfloat *params)
+{
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ if (shProg) {
+ GLint i;
+ if (location >= 0 && location < shProg->Uniforms->NumParameters) {
+ GLuint uSize;
+ GLenum uType;
+ GLint rows = 0;
+ uType = shProg->Uniforms->Parameters[location].DataType;
+ uSize = sizeof_glsl_type(uType);
+ /* Matrix types need special handling, because they span several
+ * parameters, and may also not be fully packed.
+ */
+ switch (shProg->Uniforms->Parameters[location].DataType) {
+ case GL_FLOAT_MAT2:
+ case GL_FLOAT_MAT3x2:
+ case GL_FLOAT_MAT4x2:
+ rows = 2;
+ break;
+ case GL_FLOAT_MAT2x3:
+ case GL_FLOAT_MAT3:
+ case GL_FLOAT_MAT4x3:
+ rows = 3;
+ break;
+ case GL_FLOAT_MAT2x4:
+ case GL_FLOAT_MAT3x4:
+ case GL_FLOAT_MAT4:
+ rows = 4;
+ }
+ if (rows != 0) {
+ GLint r, c;
+ for (c = 0, i = 0; c * 4 < uSize; c++)
+ for (r = 0; r < rows; r++, i++)
+ params[i] = shProg->Uniforms->ParameterValues[location + c][r];
+ }
+ else
+ for (i = 0; i < uSize; i++) {
+ params[i] = shProg->Uniforms->ParameterValues[location][i];
+ }
+ }
+ else {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetUniformfv(location)");
+ }
+ }
+ else {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetUniformfv(program)");
+ }
}
-void GLAPIENTRY
-_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+
+/**
+ * Called via ctx->Driver.GetUniformLocation().
+ */
+GLint
+_mesa_get_uniform_location(GLcontext *ctx, GLuint program, const GLchar *name)
{
- uniform_matrix(3, 2, "glUniformMatrix3x2fv", GL_FLOAT_MAT3x2,
- location, count, transpose, value);
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ if (shProg) {
+ GLuint loc;
+ for (loc = 0; loc < shProg->Uniforms->NumParameters; loc++) {
+ const struct gl_program_parameter *u
+ = shProg->Uniforms->Parameters + loc;
+ /* XXX this is a temporary simplification / short-cut.
+ * We need to handle things like "e.c[0].b" as seen in the
+ * GLSL orange book, page 189.
+ */
+ if ((u->Type == PROGRAM_UNIFORM ||
+ u->Type == PROGRAM_SAMPLER) && !strcmp(u->Name, name)) {
+ return loc;
+ }
+ }
+ }
+ return -1;
+
}
-void GLAPIENTRY
-_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+
+GLboolean
+_mesa_is_program(GLcontext *ctx, GLuint name)
{
- uniform_matrix(2, 4, "glUniformMatrix2x4fv", GL_FLOAT_MAT2x4,
- location, count, transpose, value);
+ struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
+ return shProg ? GL_TRUE : GL_FALSE;
}
-void GLAPIENTRY
-_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+
+GLboolean
+_mesa_is_shader(GLcontext *ctx, GLuint name)
{
- uniform_matrix(4, 2, "glUniformMatrix4x2fv", GL_FLOAT_MAT4x2,
- location, count, transpose, value);
+ struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
+ return shader ? GL_TRUE : GL_FALSE;
}
-void GLAPIENTRY
-_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+
+
+/**
+ * Called via ctx->Driver.ShaderSource()
+ */
+void
+_mesa_shader_source(GLcontext *ctx, GLuint shader, const GLchar *source)
{
- uniform_matrix(3, 4, "glUniformMatrix3x4fv", GL_FLOAT_MAT3x4,
- location, count, transpose, value);
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSource(shaderObj)");
+ return;
+ }
+
+ /* free old shader source string and install new one */
+ if (sh->Source) {
+ _mesa_free((void *) sh->Source);
+ }
+ sh->Source = source;
+ sh->CompileStatus = GL_FALSE;
}
-void GLAPIENTRY
-_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+
+/**
+ * Called via ctx->Driver.CompileShader()
+ */
+void
+_mesa_compile_shader(GLcontext *ctx, GLuint shaderObj)
{
- uniform_matrix(4, 3, "glUniformMatrix4x3fv", GL_FLOAT_MAT4x3,
- location, count, transpose, value);
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
+
+ if (!sh) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glCompileShader(shaderObj)");
+ return;
+ }
+
+ sh->CompileStatus = _slang_compile(ctx, sh);
}
/**
- * Create a new GLSL program object.
+ * Called via ctx->Driver.LinkProgram()
*/
-struct gl_linked_program *
-_mesa_new_linked_program(GLcontext *ctx, GLuint name)
+void
+_mesa_link_program(GLcontext *ctx, GLuint program)
{
- struct gl_linked_program *linked;
- linked = CALLOC_STRUCT(gl_linked_program);
- if (linked) {
- linked->Name = name;
+ struct gl_shader_program *shProg;
+
+ shProg = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLinkProgram(program)");
+ return;
}
- return linked;
+
+ _slang_link(ctx, program, shProg);
}
+/**
+ * Called via ctx->Driver.UseProgram()
+ */
void
-_mesa_free_linked_program_data(GLcontext *ctx,
- struct gl_linked_program *linked)
+_mesa_use_program(GLcontext *ctx, GLuint program)
{
- if (linked->VertexProgram) {
- if (linked->VertexProgram->Base.Parameters == linked->Uniforms) {
- /* to prevent a double-free in the next call */
- linked->VertexProgram->Base.Parameters = NULL;
- }
- _mesa_delete_program(ctx, &linked->VertexProgram->Base);
- linked->VertexProgram = NULL;
+ struct gl_shader_program *shProg;
+
+ if (ctx->Shader.CurrentProgram &&
+ ctx->Shader.CurrentProgram->Name == program) {
+ /* no-op */
+ return;
}
- if (linked->FragmentProgram) {
- if (linked->FragmentProgram->Base.Parameters == linked->Uniforms) {
- /* to prevent a double-free in the next call */
- linked->FragmentProgram->Base.Parameters = NULL;
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+
+ if (program) {
+ shProg = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glUseProgramObjectARB(programObj)");
+ return;
}
- _mesa_delete_program(ctx, &linked->FragmentProgram->Base);
- linked->FragmentProgram = NULL;
+ }
+ else {
+ shProg = NULL;
}
+ _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, shProg);
+}
+
+
+/**
+ * Called via ctx->Driver.Uniform().
+ */
+void
+_mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
+ const GLvoid *values, GLenum type)
+{
+ struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
+ GLint elems, i, k;
+ GLenum uType;
+ GLsizei maxCount;
- if (linked->Uniforms) {
- _mesa_free_parameter_list(linked->Uniforms);
- linked->Uniforms = NULL;
+ if (!shProg || !shProg->LinkStatus) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
+ return;
}
- if (linked->Varying) {
- _mesa_free_parameter_list(linked->Varying);
- linked->Varying = NULL;
+ if (location == -1)
+ return; /* The standard specifies this as a no-op */
+
+ /* The spec says this is GL_INVALID_OPERATION, although it seems like it
+ * ought to be GL_INVALID_VALUE
+ */
+ if (location < 0 || location >= (GLint) shProg->Uniforms->NumParameters) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location)");
+ return;
}
-}
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+ uType = shProg->Uniforms->Parameters[location].DataType;
+ /*
+ * If we're setting a sampler, we must use glUniformi1()!
+ */
+ if (shProg->Uniforms->Parameters[location].Type == PROGRAM_SAMPLER) {
+ GLint unit;
+ if (type != GL_INT || count != 1) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glUniform(only glUniform1i can be used "
+ "to set sampler uniforms)");
+ return;
+ }
+ /* check that the sampler (tex unit index) is legal */
+ unit = ((GLint *) values)[0];
+ if (unit >= ctx->Const.MaxTextureImageUnits) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glUniform1(invalid sampler/tex unit index)");
+ return;
+ }
+ }
-void
-_mesa_delete_linked_program(GLcontext *ctx, struct gl_linked_program *linked)
-{
- _mesa_free_linked_program_data(ctx, linked);
- _mesa_free(linked);
-}
+ if (count < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
+ return;
+ }
+ switch (type) {
+ case GL_FLOAT:
+ case GL_INT:
+ elems = 1;
+ break;
+ case GL_FLOAT_VEC2:
+ case GL_INT_VEC2:
+ elems = 2;
+ break;
+ case GL_FLOAT_VEC3:
+ case GL_INT_VEC3:
+ elems = 3;
+ break;
+ case GL_FLOAT_VEC4:
+ case GL_INT_VEC4:
+ elems = 4;
+ break;
+ default:
+ _mesa_problem(ctx, "Invalid type in _mesa_uniform");
+ return;
+ }
-/**
- * Lookup a GLSL program object.
- */
-struct gl_linked_program *
-_mesa_lookup_linked_program(GLcontext *ctx, GLuint name)
-{
- if (name)
- return (struct gl_linked_program *)
- _mesa_HashLookup(ctx->Shared->ProgramObjects, name);
- else
- return NULL;
-}
+ /* OpenGL requires types to match exactly, except that one can convert
+ * float or int array to boolean array.
+ */
+ switch (uType)
+ {
+ case GL_BOOL:
+ case GL_BOOL_VEC2:
+ case GL_BOOL_VEC3:
+ case GL_BOOL_VEC4:
+ if (elems != sizeof_glsl_type(uType)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(count mismatch)");
+ }
+ break;
+ case PROGRAM_SAMPLER:
+ break;
+ default:
+ if (shProg->Uniforms->Parameters[location].Type != PROGRAM_SAMPLER
+ && uType != type) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
+ }
+ break;
+ }
+ /* XXX if this is a base type, then count must equal 1. However, we
+ * don't have enough information from the compiler to distinguish a
+ * base type from a 1-element array of that type. The standard allows
+ * count to overrun an array, in which case the overflow is ignored.
+ */
+ maxCount = shProg->Uniforms->Parameters[location].Size / elems;
+ if (count > maxCount) count = maxCount;
+
+ for (k = 0; k < count; k++) {
+ GLfloat *uniformVal = shProg->Uniforms->ParameterValues[location + k];
+ if (type == GL_INT ||
+ type == GL_INT_VEC2 ||
+ type == GL_INT_VEC3 ||
+ type == GL_INT_VEC4) {
+ const GLint *iValues = ((const GLint *) values) + k * elems;
+ for (i = 0; i < elems; i++) {
+ uniformVal[i] = (GLfloat) iValues[i];
+ }
+ }
+ else {
+ const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
+ for (i = 0; i < elems; i++) {
+ uniformVal[i] = fValues[i];
+ }
+ }
+ if (uType == GL_BOOL ||
+ uType == GL_BOOL_VEC2 ||
+ uType == GL_BOOL_VEC3 ||
+ uType == GL_BOOL_VEC4) {
+ for (i = 0; i < elems; i++)
+ uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
+ }
+ }
-struct gl_shader *
-_mesa_new_shader(GLcontext *ctx, GLuint name, GLenum type)
-{
- struct gl_shader *shader;
- assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
- shader = CALLOC_STRUCT(gl_shader);
- if (shader) {
- shader->Name = name;
- shader->Type = type;
+ if (shProg->Uniforms->Parameters[location].Type == PROGRAM_SAMPLER) {
+ if (shProg->VertexProgram)
+ _slang_resolve_samplers(shProg, &shProg->VertexProgram->Base);
+ if (shProg->FragmentProgram)
+ _slang_resolve_samplers(shProg, &shProg->FragmentProgram->Base);
+ FLUSH_VERTICES(ctx, _NEW_TEXTURE);
}
- return shader;
}
/**
- * Lookup a GLSL shader object.
+ * Called by ctx->Driver.UniformMatrix().
*/
-struct gl_program *
-_mesa_lookup_shader(GLcontext *ctx, GLuint name)
+void
+_mesa_uniform_matrix(GLcontext *ctx, GLint cols, GLint rows,
+ GLenum matrixType, GLint location, GLsizei count,
+ GLboolean transpose, const GLfloat *values)
{
- if (name)
- return (struct gl_program *)
- _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
- else
- return NULL;
-}
+ GLsizei maxCount, i;
+ struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
+ if (!shProg || !shProg->LinkStatus) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glUniformMatrix(program not linked)");
+ return;
+ }
+ if (location == -1)
+ return; /* The standard specifies this as a no-op */
+ /* The spec says this is GL_INVALID_OPERATION, although it seems like it
+ * ought to be GL_INVALID_VALUE
+ */
+ if (location < 0 || location >= (GLint) shProg->Uniforms->NumParameters) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");
+ return;
+ }
+ if (values == NULL) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");
+ return;
+ }
+ if (count < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(count < 0)");
+ return;
+ }
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-GLvoid
-_mesa_init_shaderobjects(GLcontext * ctx)
-{
+ /*
+ * Note: the _columns_ of a matrix are stored in program registers, not
+ * the rows.
+ */
+ /* XXXX need to test 3x3 and 2x2 matrices... */
+ maxCount = shProg->Uniforms->Parameters[location].Size / (4 * cols);
+ if (count > maxCount)
+ count = maxCount;
+ for (i = 0; i < count; i++) {
+ if (transpose) {
+ GLuint row, col;
+ for (col = 0; col < cols; col++) {
+ GLfloat *v = shProg->Uniforms->ParameterValues[location + col];
+ for (row = 0; row < rows; row++) {
+ v[row] = values[row * cols + col];
+ }
+ }
+ }
+ else {
+ GLuint row, col;
+ for (col = 0; col < cols; col++) {
+ GLfloat *v = shProg->Uniforms->ParameterValues[location + col];
+ for (row = 0; row < rows; row++) {
+ v[row] = values[col * rows + row];
+ }
+ }
+ }
+ location += cols;
+ values += rows * cols;
+ }
+}
- ctx->ShaderObjects.CurrentProgram = NULL;
- ctx->ShaderObjects._FragmentShaderPresent = GL_FALSE;
- ctx->ShaderObjects._VertexShaderPresent = GL_FALSE;
-#if 0
- _mesa_init_shaderobjects_3dlabs(ctx);
-#endif
+void
+_mesa_validate_program(GLcontext *ctx, GLuint program)
+{
+ struct gl_shader_program *shProg;
+ shProg = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glValidateProgram(program)");
+ return;
+ }
+ /* XXX temporary */
+ shProg->Validated = GL_TRUE;
+
+ /* From the GL spec:
+ any two active samplers in the current program object are of
+ different types, but refer to the same texture image unit,
+
+ any active sampler in the current program object refers to a texture
+ image unit where fixed-function fragment processing accesses a
+ texture target that does not match the sampler type, or
+
+ the sum of the number of active samplers in the program and the
+ number of texture image units enabled for fixed-function fragment
+ processing exceeds the combined limit on the total number of texture
+ image units allowed.
+ */
}
projects / mesa.git / blobdiff