/*
* 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 "prog_print.h"
#include "prog_statevars.h"
-#include "shader_api.h"
-
-#include "slang_compile.h"
-#include "slang_link.h"
+#include "shader/shader_api.h"
+#include "shader/slang/slang_compile.h"
+#include "shader/slang/slang_link.h"
struct gl_shader_program *shProg;
shProg = CALLOC_STRUCT(gl_shader_program);
if (shProg) {
- shProg->Type = GL_SHADER_PROGRAM;
+ shProg->Type = GL_SHADER_PROGRAM_MESA;
shProg->Name = name;
shProg->RefCount = 1;
shProg->Attributes = _mesa_new_parameter_list();
}
+/**
+ * Clear (free) the shader program state that gets produced by linking.
+ */
void
-_mesa_free_shader_program_data(GLcontext *ctx,
- struct gl_shader_program *shProg)
+_mesa_clear_shader_program_data(GLcontext *ctx,
+ struct gl_shader_program *shProg)
{
- assert(shProg->Type == GL_SHADER_PROGRAM);
-
if (shProg->VertexProgram) {
if (shProg->VertexProgram->Base.Parameters == shProg->Uniforms) {
/* to prevent a double-free in the next call */
shProg->FragmentProgram = NULL;
}
-
if (shProg->Uniforms) {
_mesa_free_parameter_list(shProg->Uniforms);
shProg->Uniforms = 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);
+ }
+ 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.
*/
* 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) {
+ if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
return NULL;
}
return shProg;
}
+/**
+ * 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.
*/
* 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) {
- assert(sh->Type == GL_VERTEX_SHADER ||
- sh->Type == GL_FRAGMENT_SHADER);
+ if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
return NULL;
}
return sh;
* 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);
+}
+
+
/**
* Copy string from <src> to <dst>, up to maxLength characters, returning
* length of <dst> in <length>.
}
/* append */
- shProg->Shaders[n] = sh;
- sh->RefCount++;
+ shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
+ _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
shProg->NumShaders++;
}
return;
}
- oldIndex = _mesa_get_attrib_location(ctx, program, name);
+ 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);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
}
- if (shProg->VertexProgram && oldIndex >= 0) {
+ 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);
}
-
-#if 0
- printf("===== post BindAttrib:\n");
- _mesa_print_program(&shProg->VertexProgram->Base);
-#endif
}
_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)
{
+ /*
+ * 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);
return;
}
- /* always remove from hash table */
- _mesa_HashRemove(ctx->Shared->ShaderObjects, name);
-
shProg->DeletePending = GL_TRUE;
- /* decrement refcount, delete if zero */
- shProg->RefCount--;
- if (shProg->RefCount <= 0) {
- _mesa_free_shader_program(ctx, shProg);
- }
+ /* effectively, decr shProg's refcount */
+ _mesa_reference_shader_program(ctx, &shProg, NULL);
}
}
sh->DeletePending = GL_TRUE;
- sh->RefCount--;
- if (sh->RefCount <= 0) {
- _mesa_free_shader(ctx, sh);
- }
+
+ /* effectively, decr sh's refcount */
+ _mesa_reference_shader(ctx, &sh, NULL);
}
for (i = 0; i < n; i++) {
if (shProg->Shaders[i]->Name == shader) {
- struct gl_shader **newList;
/* found it */
+ struct gl_shader **newList;
- shProg->Shaders[i]->RefCount--;
+ /* derefernce */
+ _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
/* alloc new, smaller array */
newList = (struct gl_shader **)
newList[j++] = shProg->Shaders[i];
_mesa_free(shProg->Shaders);
- /* XXX refcounting! */
-
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
+
return;
}
}
GLint sz;
if (!shProg) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib");
return;
}
if (!shProg->Attributes || index >= shProg->Attributes->NumParameters) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
return;
}
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;
+ GLuint ind, j;
if (!shProg) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform");
return;
}
- copy_string(nameOut, maxLength, length,
- shProg->Uniforms->Parameters[index].Name);
- sz = shProg->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) {
+ /* found it */
+ copy_string(nameOut, maxLength, length,
+ shProg->Uniforms->Parameters[j].Name);
+ if (size)
+ *size = shProg->Uniforms->Parameters[j].Size;
+ if (type)
+ *type = shProg->Uniforms->Parameters[j].DataType;
+ return;
+ }
+ ind++;
+ }
+ }
+
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
}
*params = shProg->Attributes ? shProg->Attributes->NumParameters : 0;
break;
case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
- *params = _mesa_parameter_longest_name(shProg->Attributes);
+ *params = _mesa_longest_parameter_name(shProg->Attributes,
+ PROGRAM_INPUT) + 1;
break;
case GL_ACTIVE_UNIFORMS:
- *params = shProg->Uniforms ? shProg->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(shProg->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_use_program(GLcontext *ctx, GLuint program)
{
+ struct gl_shader_program *shProg;
+
if (ctx->Shader.CurrentProgram &&
ctx->Shader.CurrentProgram->Name == program) {
/* no-op */
FLUSH_VERTICES(ctx, _NEW_PROGRAM);
- /* unbind old */
- if (ctx->Shader.CurrentProgram) {
- ctx->Shader.CurrentProgram->RefCount--;
- if (ctx->Shader.CurrentProgram->RefCount <= 0) {
- _mesa_free_shader_program(ctx, ctx->Shader.CurrentProgram);
- }
- ctx->Shader.CurrentProgram = NULL;
- }
-
if (program) {
- struct gl_shader_program *shProg;
shProg = _mesa_lookup_shader_program(ctx, program);
if (!shProg) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glUseProgramObjectARB(programObj)");
return;
}
- ctx->Shader.CurrentProgram = shProg;
- shProg->RefCount++;
}
else {
- /* don't use a shader program */
- ctx->Shader.CurrentProgram = NULL;
- }
+ shProg = NULL;
+ }
+
+ _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, shProg);
}
* 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;
+ }
+ }
+
+ if (count < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
+ return;
}
switch (type) {
type == GL_INT_VEC2 ||
type == GL_INT_VEC3 ||
type == GL_INT_VEC4) {
- const GLint *iValues = (const GLint *) values;
+ 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;
+ const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
for (i = 0; i < elems; i++) {
uniformVal[i] = fValues[i];
}
projects / mesa.git / blobdiff