/*
* Mesa 3-D graphics library
- * Version: 6.5.3
+ * Version: 7.0
*
* Copyright (C) 2004-2007 Brian Paul All Rights Reserved.
*
#include "glheader.h"
#include "context.h"
#include "hash.h"
+#include "macros.h"
#include "program.h"
#include "prog_parameter.h"
-#include "shader_api.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"
-#include "slang_compile.h"
-#include "slang_link.h"
+/**
+ * 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();
+ }
+ return shProg;
+}
+
+
+/**
+ * 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 (shProg->VertexProgram) {
+ if (shProg->VertexProgram->Base.Parameters == shProg->Uniforms) {
+ /* to prevent a double-free in the next call */
+ shProg->VertexProgram->Base.Parameters = NULL;
+ }
+ ctx->Driver.DeleteProgram(ctx, &shProg->VertexProgram->Base);
+ shProg->VertexProgram = NULL;
+ }
+
+ if (shProg->FragmentProgram) {
+ if (shProg->FragmentProgram->Base.Parameters == shProg->Uniforms) {
+ /* to prevent a double-free in the next call */
+ shProg->FragmentProgram->Base.Parameters = NULL;
+ }
+ ctx->Driver.DeleteProgram(ctx, &shProg->FragmentProgram->Base);
+ shProg->FragmentProgram = NULL;
+ }
+
+ if (shProg->Uniforms) {
+ _mesa_free_parameter_list(shProg->Uniforms);
+ shProg->Uniforms = NULL;
+ }
+
+ if (shProg->Varying) {
+ _mesa_free_parameter_list(shProg->Varying);
+ shProg->Varying = NULL;
+ }
+}
+
+
+/**
+ * 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)
+{
+ GLuint i;
+
+ assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
+
+ _mesa_clear_shader_program_data(ctx, shProg);
+
+ if (shProg->Attributes) {
+ _mesa_free_parameter_list(shProg->Attributes);
+ shProg->Attributes = NULL;
+ }
+
+ /* detach shaders */
+ for (i = 0; i < shProg->NumShaders; i++) {
+ _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
+ }
+ shProg->NumShaders = 0;
+
+ if (shProg->Shaders) {
+ _mesa_free(shProg->Shaders);
+ shProg->Shaders = NULL;
+ }
+}
+
+
+/**
+ * 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;
+ }
+ _mesa_free(shProg);
+}
+
+
+/**
+ * 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)
+{
+ 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->ShaderObjects, old->Name);
+ _mesa_free_shader_program(ctx, old);
+ }
+
+ *ptr = NULL;
+ }
+ assert(!*ptr);
+
+ if (shProg) {
+ shProg->RefCount++;
+ /*printf("SHPROG INCR %p (%d) to %d\n",
+ (void*) shProg, shProg->Name, shProg->RefCount);*/
+ *ptr = shProg;
+ }
+}
+
+
+/**
+ * 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->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 (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
+ return NULL;
+ }
+ return shProg;
+ }
+ return NULL;
+}
+
+
+/**
+ * Allocate a new gl_shader object, initialize it.
+ */
+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->Type = type;
+ shader->Name = name;
+ shader->RefCount = 1;
+ }
+ return shader;
+}
+
+
+void
+_mesa_free_shader(GLcontext *ctx, struct gl_shader *sh)
+{
+ 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]);
+ ctx->Driver.DeleteProgram(ctx, sh->Programs[i]);
+ }
+ if (sh->Programs)
+ _mesa_free(sh->Programs);
+ _mesa_free(sh);
+}
+
+
+/**
+ * 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)
+{
+ 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);
+ }
+
+ *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;
+ }
+}
+
+
+/**
+ * Lookup a GLSL shader object.
+ */
+struct gl_shader *
+_mesa_lookup_shader(GLcontext *ctx, GLuint name)
+{
+ 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;
+}
+
+/**
+ * Initialize context's shader state.
+ */
+void
+_mesa_init_shader_state(GLcontext * ctx)
+{
+ /* 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;
+}
+
+
+/**
+ * Free the per-context shader-related state.
+ */
+void
+_mesa_free_shader_state(GLcontext *ctx)
+{
+ _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, NULL);
+}
/**
}
+/**
+ * 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 */
+ }
+}
/**
void
_mesa_attach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
- 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;
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ GLuint n;
GLuint i;
- if (!linked || !prog) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
+ if (!shProg || !sh) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
"glAttachShader(bad program or shader name)");
return;
}
+ n = shProg->NumShaders;
+
for (i = 0; i < n; i++) {
- if (linked->Shaders[i] == prog) {
+ if (shProg->Shaders[i] == sh) {
/* already attached */
return;
}
}
/* grow list */
- linked->Shaders = (struct gl_program **)
- _mesa_realloc(linked->Shaders,
- n * sizeof(struct gl_program *),
- (n + 1) * sizeof(struct gl_program *));
- if (!linked->Shaders) {
+ 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;
}
/* append */
- linked->Shaders[n] = prog;
- prog->RefCount++;
- linked->NumShaders++;
+ shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
+ _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
+ shProg->NumShaders++;
}
_mesa_bind_attrib_location(GLcontext *ctx, GLuint program, GLuint index,
const GLchar *name)
{
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ const GLint size = -1; /* unknown size */
+ GLint i, oldIndex;
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glBindAttribLocation(program)");
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(program)");
return;
}
-#if 0 /* XXXX */
- 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
+ if (!name)
+ return;
+
+ if (strncmp(name, "gl_", 3) == 0) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glBindAttribLocation(illegal name)");
+ return;
+ }
+
+ if (shProg->LinkStatus) {
+ /* get current index/location for the attribute */
+ oldIndex = _mesa_get_attrib_location(ctx, program, name);
+ }
+ else {
+ oldIndex = -1;
+ }
+
+ /* 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");
+ }
+
+ 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);
+ }
}
GLuint
_mesa_create_shader(GLcontext *ctx, GLenum type)
{
- struct gl_program *newProg;
+ struct gl_shader *sh;
GLuint name;
name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
switch (type) {
- 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);
+ case GL_FRAGMENT_SHADER:
+ case GL_VERTEX_SHADER:
+ sh = _mesa_new_shader(ctx, name, type);
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
return 0;
}
- _mesa_HashInsert(ctx->Shared->ShaderObjects, name, newProg);
+ _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
return name;
}
_mesa_create_program(GLcontext *ctx)
{
GLuint name;
- struct gl_linked_program *linked;
+ struct gl_shader_program *shProg;
- name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ProgramObjects, 1);
- linked = _mesa_new_linked_program(ctx, name);
+ name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
+ shProg = _mesa_new_shader_program(ctx, name);
- _mesa_HashInsert(ctx->Shared->ProgramObjects, name, linked);
+ _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
+
+ assert(shProg->RefCount == 1);
return name;
}
+/**
+ * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
+ * DeleteProgramARB.
+ */
void
_mesa_delete_program2(GLcontext *ctx, GLuint name)
{
- struct gl_linked_program *linked;
-
- linked = _mesa_lookup_linked_program(ctx, name);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteProgram(name)");
+ /*
+ * 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;
+
+ shProg = _mesa_lookup_shader_program(ctx, name);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteProgram(name)");
return;
}
- /* XXX refcounting! */
- _mesa_HashRemove(ctx->Shared->ProgramObjects, name);
- _mesa_delete_linked_program(ctx, linked);
+ shProg->DeletePending = GL_TRUE;
+
+ /* effectively, decr shProg's refcount */
+ _mesa_reference_shader_program(ctx, &shProg, NULL);
}
void
_mesa_delete_shader(GLcontext *ctx, GLuint shader)
{
- /* XXX refcounting! */
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
+ return;
+ }
- /*
- _mesa_DeleteObjectARB(shader);
- */
+ sh->DeletePending = GL_TRUE;
+
+ /* effectively, decr sh's refcount */
+ _mesa_reference_shader(ctx, &sh, NULL);
}
void
_mesa_detach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- const GLuint n = linked->NumShaders;
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ GLuint n;
GLuint i, j;
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
"glDetachShader(bad program or shader name)");
return;
}
+ n = shProg->NumShaders;
+
for (i = 0; i < n; i++) {
- if (linked->Shaders[i]->Id == shader) {
- struct gl_program **newList;
+ if (shProg->Shaders[i]->Name == shader) {
/* found it */
+ struct gl_shader **newList;
+
+ /* derefernce */
+ _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
+
/* alloc new, smaller array */
- newList = (struct gl_program **)
- _mesa_malloc((n - 1) * sizeof(struct gl_program *));
+ 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] = linked->Shaders[j];
+ newList[j] = shProg->Shaders[j];
}
while (++i < n)
- newList[j++] = linked->Shaders[i];
- _mesa_free(linked->Shaders);
-
- /* XXX refcounting! */
+ 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
- linked->Shaders = newList;
return;
}
}
/* not found */
- _mesa_error(ctx, GL_INVALID_OPERATION,
+ _mesa_error(ctx, GL_INVALID_VALUE,
"glDetachShader(shader not found)");
}
static const GLenum vec_types[] = {
GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4
};
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
GLint sz;
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniform");
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib");
return;
}
- if (!linked->Attributes || index >= linked->Attributes->NumParameters) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
+ if (!shProg->Attributes || index >= shProg->Attributes->NumParameters) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
return;
}
copy_string(nameOut, maxLength, length,
- linked->Attributes->Parameters[index].Name);
- sz = linked->Attributes->Parameters[index].Size;
+ shProg->Attributes->Parameters[index].Name);
+ sz = shProg->Attributes->Parameters[index].Size;
if (size)
- *size = sz;
- if (type)
- *type = vec_types[sz]; /* XXX this is a temporary hack */
+ *size = 1; /* attributes may not be arrays */
+ if (type && sz > 0 && sz <= 4) /* XXX this is a temporary hack */
+ *type = vec_types[sz - 1];
}
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_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- GLint sz;
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ GLuint ind, j;
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniform");
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform");
return;
}
- if (!linked->Uniforms || index >= linked->Uniforms->NumParameters) {
+ if (!shProg->Uniforms || index >= shProg->Uniforms->NumParameters) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
return;
}
- copy_string(nameOut, maxLength, length,
- linked->Uniforms->Parameters[index].Name);
- sz = linked->Uniforms->Parameters[index].Size;
- if (size)
- *size = sz;
- if (type)
- *type = vec_types[sz]; /* XXX this is a temporary hack */
+ 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++;
+ }
+ }
+
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
}
_mesa_get_attached_shaders(GLcontext *ctx, GLuint program, GLsizei maxCount,
GLsizei *count, GLuint *obj)
{
- 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;
+ 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_OPERATION, "glGetAttachedShaders");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttachedShaders");
}
}
_mesa_get_attrib_location(GLcontext *ctx, GLuint program,
const GLchar *name)
{
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetAttribLocation");
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttribLocation");
return -1;
}
- if (!linked->LinkStatus) {
+ if (!shProg->LinkStatus) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetAttribLocation(program not linked)");
return -1;
if (!name)
return -1;
- if (linked->Attributes) {
- GLuint i;
- for (i = 0; i < linked->Attributes->NumParameters; i++) {
- if (!strcmp(linked->Attributes->Parameters[i].Name, name)) {
- return i;
- }
+ if (shProg->Attributes) {
+ GLint i = _mesa_lookup_parameter_index(shProg->Attributes, -1, name);
+ if (i >= 0) {
+ return shProg->Attributes->Parameters[i].StateIndexes[0];
}
}
return -1;
_mesa_get_programiv(GLcontext *ctx, GLuint program,
GLenum pname, GLint *params)
{
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
- if (!linked) {
+ if (!shProg) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
return;
}
switch (pname) {
case GL_DELETE_STATUS:
- *params = linked->DeletePending;
+ *params = shProg->DeletePending;
break;
case GL_LINK_STATUS:
- *params = linked->LinkStatus;
+ *params = shProg->LinkStatus;
break;
case GL_VALIDATE_STATUS:
- *params = linked->Validated;
+ *params = shProg->Validated;
break;
case GL_INFO_LOG_LENGTH:
- *params = linked->InfoLog ? strlen(linked->InfoLog) : 0;
+ *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
break;
case GL_ATTACHED_SHADERS:
- *params = linked->NumShaders;
+ *params = shProg->NumShaders;
break;
case GL_ACTIVE_ATTRIBUTES:
- *params = linked->Uniforms ? linked->Uniforms->NumParameters : 0;
+ *params = shProg->Attributes ? shProg->Attributes->NumParameters : 0;
break;
case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
- *params = _mesa_parameter_longest_name(linked->Attributes);
+ *params = _mesa_longest_parameter_name(shProg->Attributes,
+ PROGRAM_INPUT) + 1;
break;
case GL_ACTIVE_UNIFORMS:
- *params = linked->Uniforms ? linked->Uniforms->NumParameters : 0;
+ *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 = _mesa_parameter_longest_name(linked->Uniforms);
+ *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)");
void
_mesa_get_shaderiv(GLcontext *ctx, GLuint name, GLenum pname, GLint *params)
{
-#if 0
- struct gl_program *shader = _mesa_lookup_shader(ctx, name);
+ struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
if (!shader) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderiv(shader)");
return;
}
-#else
- struct gl_shader *shader;
-#endif
+
switch (pname) {
case GL_SHADER_TYPE:
*params = shader->Type;
*params = shader->CompileStatus;
break;
case GL_INFO_LOG_LENGTH:
- *params = shader->InfoLog ? strlen(shader->InfoLog) : 0;
+ *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
break;
case GL_SHADER_SOURCE_LENGTH:
- *params = shader->Source ? strlen((char *) shader->Source) : 0;
+ *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
_mesa_get_program_info_log(GLcontext *ctx, GLuint program, GLsizei bufSize,
GLsizei *length, GLchar *infoLog)
{
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- if (!linked) {
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
return;
}
- /* XXX also test length, infoLog params for NULL? */
- copy_string(linked->InfoLog, bufSize, length, infoLog);
+ copy_string(infoLog, bufSize, length, shProg->InfoLog);
}
_mesa_get_shader_info_log(GLcontext *ctx, GLuint shader, GLsizei bufSize,
GLsizei *length, GLchar *infoLog)
{
- struct gl_program *shProg = _mesa_lookup_shader(ctx, shader);
- if (!shProg) {
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
return;
}
- /*
- copy_string(shProg->InfoLog, bufSize, length, infoLog);
- */
+ copy_string(infoLog, bufSize, length, sh->InfoLog);
}
_mesa_get_shader_source(GLcontext *ctx, GLuint shader, GLsizei maxLength,
GLsizei *length, GLchar *sourceOut)
{
- struct gl_program *shProg = _mesa_lookup_shader(ctx, shader);
- if (!shProg) {
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
+ if (!sh) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderSource(shader)");
return;
}
- copy_string((GLchar *) shProg->String, maxLength, length, sourceOut);
+ copy_string(sourceOut, maxLength, length, sh->Source);
}
_mesa_get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
GLfloat *params)
{
- struct gl_linked_program *linked
- = _mesa_lookup_linked_program(ctx, program);
- if (linked) {
- GLuint i;
- if (location >= 0 && location < linked->Uniforms->NumParameters) {
- for (i = 0; i < linked->Uniforms->Parameters[location].Size; i++) {
- params[i] = linked->Uniforms->ParameterValues[location][i];
+ 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_OPERATION, "glGetUniformfv(program)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetUniformfv(program)");
}
}
GLint
_mesa_get_uniform_location(GLcontext *ctx, GLuint program, const GLchar *name)
{
- if (ctx->Shader.CurrentProgram) {
- const struct gl_linked_program *linked = ctx->Shader.CurrentProgram;
+ struct gl_shader_program *shProg
+ = _mesa_lookup_shader_program(ctx, program);
+ if (shProg) {
GLuint loc;
- for (loc = 0; loc < linked->Uniforms->NumParameters; loc++) {
+ for (loc = 0; loc < shProg->Uniforms->NumParameters; loc++) {
const struct gl_program_parameter *u
- = linked->Uniforms->Parameters + loc;
- if (u->Type == PROGRAM_UNIFORM && !strcmp(u->Name, name)) {
+ = 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;
}
}
GLboolean
_mesa_is_program(GLcontext *ctx, GLuint name)
{
- struct gl_linked_program *linked = _mesa_lookup_linked_program(ctx, name);
- return linked ? GL_TRUE : GL_FALSE;
+ struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
+ return shProg ? GL_TRUE : GL_FALSE;
}
GLboolean
_mesa_is_shader(GLcontext *ctx, GLuint name)
{
- struct gl_program *shader = _mesa_lookup_shader(ctx, name);
+ struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
return shader ? GL_TRUE : GL_FALSE;
}
void
_mesa_shader_source(GLcontext *ctx, GLuint shader, const GLchar *source)
{
- struct gl_program *shProg = _mesa_lookup_shader(ctx, shader);
- if (!shProg) {
+ 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 (shProg->String) {
- _mesa_free(shProg->String);
+ if (sh->Source) {
+ _mesa_free((void *) sh->Source);
}
- shProg->String = (GLubyte *) source;
+ sh->Source = source;
+ sh->CompileStatus = GL_FALSE;
}
void
_mesa_compile_shader(GLcontext *ctx, GLuint shaderObj)
{
- struct gl_program *prog = _mesa_lookup_shader(ctx, shaderObj);
- slang_info_log info_log;
- slang_code_object obj;
- slang_unit_type type;
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
- if (!prog) {
+ if (!sh) {
_mesa_error(ctx, GL_INVALID_VALUE, "glCompileShader(shaderObj)");
return;
}
- 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;
- }
-
- 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!");
- }
+ sh->CompileStatus = _slang_compile(ctx, sh);
}
void
_mesa_link_program(GLcontext *ctx, GLuint program)
{
- struct gl_linked_program *linked;
+ struct gl_shader_program *shProg;
- linked = _mesa_lookup_linked_program(ctx, program);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glLinkProgram(program)");
+ shProg = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLinkProgram(program)");
return;
}
- _slang_link2(ctx, program, linked);
+ _slang_link(ctx, program, shProg);
}
void
_mesa_use_program(GLcontext *ctx, GLuint program)
{
- /* XXXX need to handle reference counting here! */
+ struct gl_shader_program *shProg;
+
+ if (ctx->Shader.CurrentProgram &&
+ ctx->Shader.CurrentProgram->Name == program) {
+ /* no-op */
+ return;
+ }
+
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+
if (program) {
- struct gl_linked_program *linked;
- linked = _mesa_lookup_linked_program(ctx, program);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
+ shProg = _mesa_lookup_shader_program(ctx, program);
+ if (!shProg) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
"glUseProgramObjectARB(programObj)");
return;
}
- ctx->Shader.CurrentProgram = linked;
}
else {
- /* don't use a shader program */
- ctx->Shader.CurrentProgram = NULL;
- }
+ shProg = NULL;
+ }
+
+ _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, shProg);
}
_mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
const GLvoid *values, GLenum type)
{
- if (ctx->Shader.CurrentProgram) {
- struct gl_linked_program *linked = ctx->Shader.CurrentProgram;
- 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];
+ struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
+ GLint elems, i, k;
+ GLenum uType;
+ GLsizei maxCount;
+
+ if (!shProg || !shProg->LinkStatus) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
+ return;
+ }
+
+ if (location == -1)
+ return; /* The standard specifies this as a no-op */
+
+ /* 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;
}
}
- else {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not 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;
+ }
+
+ /* 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;
+ }
+ }
+
+ 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);
}
}
GLenum matrixType, GLint location, GLsizei count,
GLboolean transpose, const GLfloat *values)
{
- const char *caller = "glUniformMatrix";
- const GLint matElements = rows * cols;
-
+ 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, caller);
+ _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);
- 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;
+ /*
+ * 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];
+ }
+ }
}
-
- 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];
+ 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];
}
}
- pt += matElements;
- pv += matElements;
}
-
-#ifdef OLD
- if (!(**pro).WriteUniform(pro, location, count, trans, matrixType))
- _mesa_error(ctx, GL_INVALID_OPERATION, caller);
-#endif
- _mesa_free(trans);
- }
- else {
-#ifdef OLD
- if (!(**pro).WriteUniform(pro, location, count, values, matrixType))
- _mesa_error(ctx, GL_INVALID_OPERATION, caller);
-#endif
+ location += cols;
+ values += rows * cols;
}
}
void
_mesa_validate_program(GLcontext *ctx, GLuint program)
{
- struct gl_linked_program *linked;
- linked = _mesa_lookup_linked_program(ctx, program);
- if (!linked) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glValidateProgram(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 */
- linked->Validated = GL_TRUE;
+ shProg->Validated = GL_TRUE;
/* From the GL spec:
any two active samplers in the current program object are of
image units allowed.
*/
}
-
-
-
-/**********************************************************************/
-
-
-/**
- * Create a new GLSL program object.
- */
-struct gl_linked_program *
-_mesa_new_linked_program(GLcontext *ctx, GLuint name)
-{
- struct gl_linked_program *linked;
- linked = CALLOC_STRUCT(gl_linked_program);
- if (linked) {
- linked->Name = name;
- }
- return linked;
-}
-
-
-void
-_mesa_free_linked_program_data(GLcontext *ctx,
- struct gl_linked_program *linked)
-{
- 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;
- }
-
- if (linked->FragmentProgram) {
- if (linked->FragmentProgram->Base.Parameters == linked->Uniforms) {
- /* to prevent a double-free in the next call */
- linked->FragmentProgram->Base.Parameters = NULL;
- }
- _mesa_delete_program(ctx, &linked->FragmentProgram->Base);
- linked->FragmentProgram = NULL;
- }
-
-
- if (linked->Uniforms) {
- _mesa_free_parameter_list(linked->Uniforms);
- linked->Uniforms = NULL;
- }
-
- if (linked->Varying) {
- _mesa_free_parameter_list(linked->Varying);
- linked->Varying = NULL;
- }
-}
-
-
-
-void
-_mesa_delete_linked_program(GLcontext *ctx, struct gl_linked_program *linked)
-{
- _mesa_free_linked_program_data(ctx, linked);
- _mesa_free(linked);
-}
-
-
-/**
- * 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;
-}
-
-
-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;
- }
- return shader;
-}
-
-
-/**
- * Lookup a GLSL shader object.
- */
-struct gl_program *
-_mesa_lookup_shader(GLcontext *ctx, GLuint name)
-{
- if (name)
- return (struct gl_program *)
- _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
- else
- return NULL;
-}
-
-
-void
-_mesa_init_shader_state(GLcontext * ctx)
-{
- ctx->Shader._FragmentShaderPresent = GL_FALSE;
- ctx->Shader._VertexShaderPresent = GL_FALSE;
-}
projects / mesa.git / blobdiff