struct gl_program
{
GLuint Id;
- GLubyte *String; /**< Null-terminated program text */
+ GLubyte *String; /**< Null-terminated program text */
GLint RefCount;
- GLenum Target;
- GLenum Format; /**< String encoding format */
+ GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */
+ GLenum Format; /**< String encoding format */
GLboolean Resident;
struct prog_instruction *Instructions;
- GLbitfield InputsRead; /* Bitmask of which input regs are read */
- GLbitfield OutputsWritten; /* Bitmask of which output regs are written to */
+ GLbitfield InputsRead; /**< Bitmask of which input regs are read */
+ GLbitfield OutputsWritten; /**< Bitmask of which output regs are written to */
GLbitfield TexturesUsed[MAX_TEXTURE_IMAGE_UNITS]; /**< TEXTURE_x_BIT bitmask */
/** Named parameters, constants, etc. from program text */
/** Vertex/fragment shader varying vars */
struct gl_program_parameter_list *Varying;
+ /** Vertex program user-defined attributes */
+ struct gl_program_parameter_list *Attributes;
/** Logical counts */
/*@{*/
}
+/**
+ * Add parameter representing a varying variable.
+ */
GLint
_mesa_add_varying(struct gl_program_parameter_list *paramList,
const char *name, GLuint size)
}
+/**
+ * Add parameter representing a vertex program attribute.
+ */
+GLint
+_mesa_add_attribute(struct gl_program_parameter_list *paramList,
+ const char *name, GLint attrib)
+{
+ GLint size = 4; /* XXX ok? */
+ GLint i = _mesa_lookup_parameter_index(paramList, -1, name);
+ if (i >= 0) {
+ /* replace */
+ ASSERT(paramList->Parameters[i].StateIndexes[0] == STATE_USER_ATTRIB);
+ paramList->Parameters[i].StateIndexes[1] = attrib;
+ }
+ else {
+ /* add */
+ i = _mesa_add_parameter(paramList, name, NULL, size, PROGRAM_INPUT);
+ if (i >= 0) {
+ paramList->Parameters[i].StateIndexes[0] = STATE_USER_ATTRIB;
+ paramList->Parameters[i].StateIndexes[1] = attrib;
+ }
+ }
+ return i;
+}
+
#if 0 /* not used yet */
_mesa_add_varying(struct gl_program_parameter_list *paramList,
const char *name, GLuint size);
+extern GLint
+_mesa_add_attribute(struct gl_program_parameter_list *paramList,
+ const char *name, GLint attrib);
+
extern GLint
_mesa_add_state_reference(struct gl_program_parameter_list *paramList,
const GLint *stateTokens);
STATE_NORMAL_SCALE,
STATE_TEXRECT_SCALE,
STATE_POSITION_NORMALIZED, /* normalized light position */
+ STATE_USER_ATTRIB, /** shader vertex attrib: user-specified */
+ STATE_AUTO_ATTRIB, /** shader vertex attrib: linker-specified */
STATE_INTERNAL_DRIVER /* first available state index for drivers (must be last) */
} gl_state_index;
memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));
if (prog->Varying)
clone->Varying = _mesa_clone_parameter_list(prog->Varying);
+ if (prog->Attributes)
+ clone->Attributes = _mesa_clone_parameter_list(prog->Attributes);
memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));
clone->NumInstructions = prog->NumInstructions;
clone->NumTemporaries = prog->NumTemporaries;
#include "hash.h"
#include "program.h"
#include "prog_parameter.h"
+#include "prog_print.h"
+#include "prog_statevars.h"
#include "shader_api.h"
#include "slang_compile.h"
shProg->Type = GL_SHADER_PROGRAM;
shProg->Name = name;
shProg->RefCount = 1;
+ shProg->Attributes = _mesa_new_parameter_list();
}
return shProg;
}
{
struct gl_shader_program *shProg
= _mesa_lookup_shader_program(ctx, program);
+ GLint i;
+ GLint oldIndex;
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
+ oldIndex = _mesa_get_attrib_location(ctx, program, name);
+
+ /* this will replace the current value if it's already in the list */
+ i = _mesa_add_attribute(shProg->Attributes, name, index);
+ if (i < 0) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
+ }
+
+ if (shProg->VertexProgram && oldIndex >= 0) {
+ _slang_remap_attribute(&shProg->VertexProgram->Base, oldIndex, index);
+ }
+
+ printf("===== post BindAttrib:\n");
+ _mesa_print_program(&shProg->VertexProgram->Base);
+
}
return -1;
if (shProg->Attributes) {
- GLuint i;
- for (i = 0; i < shProg->Attributes->NumParameters; i++) {
- if (!strcmp(shProg->Attributes->Parameters[i].Name, name)) {
- return i;
- }
+ GLint i = _mesa_lookup_parameter_index(shProg->Attributes, -1, name);
+ if (i >= 0) {
+ return shProg->Attributes->Parameters[i].StateIndexes[1];
}
}
return -1;
*params = shProg->NumShaders;
break;
case GL_ACTIVE_ATTRIBUTES:
- *params = shProg->Uniforms ? shProg->Uniforms->NumParameters : 0;
+ *params = shProg->Attributes ? shProg->Attributes->NumParameters : 0;
break;
case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
*params = _mesa_parameter_longest_name(shProg->Attributes);
}
else if (var->type.qualifier == slang_qual_const) {
if (prog) {
- abort();
+ /* user-defined constant */
+ abort(); /* XXX fix */
}
else {
/* pre-defined global constant, like gl_MaxLights */
if (dbg) printf("CONST ");
}
else if (var->type.qualifier == slang_qual_attribute) {
- /* Vertex attribute */
- GLint index = _slang_input_index(varName, GL_VERTEX_PROGRAM_ARB);
- GLint size = 4; /* XXX? */
- assert(index >= 0);
- store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
+ if (prog) {
+ /* user-defined vertex attribute */
+ const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
+ GLint index = _mesa_add_parameter(prog->Attributes, varName,
+ NULL, size, PROGRAM_INPUT);
+ assert(index >= 0);
+ store = _slang_new_ir_storage(PROGRAM_INPUT,
+ VERT_ATTRIB_GENERIC0 + index, size);
+ }
+ else {
+ /* pre-defined vertex attrib */
+ GLint index = _slang_input_index(varName, GL_VERTEX_PROGRAM_ARB);
+ GLint size = 4; /* XXX? */
+ assert(index >= 0);
+ store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
+ }
if (dbg) printf("ATTRIB ");
}
else if (var->type.qualifier == slang_qual_fixedinput) {
shader->Programs[0]->Parameters = _mesa_new_parameter_list();
shader->Programs[0]->Varying = _mesa_new_parameter_list();
+ shader->Programs[0]->Attributes = _mesa_new_parameter_list();
}
slang_info_log_construct(&info_log);
_slang_resolve_samplers(struct gl_shader_program *shProg,
struct gl_program *prog);
+extern void
+_slang_remap_attribute(struct gl_program *prog, GLuint oldAttrib, GLuint newAttrib);
+
#ifdef __cplusplus
}
#include "prog_instruction.h"
#include "prog_parameter.h"
#include "prog_print.h"
+#include "prog_statevars.h"
#include "shader_api.h"
#include "slang_link.h"
/**
- * Scan program for texture instructions, lookup sampler/uniform's value
- * to determine which texture unit to use.
- * Also, update the program's TexturesUsed[] array.
+ * Resolve binding of generic vertex attributes.
+ * For example, if the vertex shader declared "attribute vec4 foobar" we'll
+ * allocate a generic vertex attribute for "foobar" and plug that value into
+ * the vertex program instructions.
*/
-void
-_slang_resolve_samplers(struct gl_shader_program *shProg,
- struct gl_program *prog)
+static GLboolean
+_slang_resolve_attributes(struct gl_shader_program *shProg,
+ struct gl_program *prog)
{
- GLuint i;
+ GLuint i, j;
+ GLbitfield usedAttributes;
- for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
- prog->TexturesUsed[i] = 0;
+ assert(prog->Target == GL_VERTEX_PROGRAM_ARB);
+
+ /* Build a bitmask indicating which attribute indexes have been
+ * explicitly bound by the user with glBindAttributeLocation().
+ */
+ usedAttributes = 0x0;
+ for (i = 0; i < shProg->Attributes->NumParameters; i++) {
+ GLint attr = shProg->Attributes->Parameters[i].StateIndexes[1];
+ usedAttributes |= attr;
+ }
+
+ if (!shProg->Attributes)
+ shProg->Attributes = _mesa_new_parameter_list();
+ /*
+ * Scan program for generic attribute references
+ */
for (i = 0; i < prog->NumInstructions; i++) {
struct prog_instruction *inst = prog->Instructions + i;
- if (inst->Opcode == OPCODE_TEX ||
- inst->Opcode == OPCODE_TXB ||
- inst->Opcode == OPCODE_TXP) {
- GLint sampleUnit = (GLint) shProg->Uniforms->ParameterValues[inst->Sampler][0];
- assert(sampleUnit < MAX_TEXTURE_IMAGE_UNITS);
- inst->TexSrcUnit = sampleUnit;
+ for (j = 0; j < 3; j++) {
+ if (inst->SrcReg[j].File == PROGRAM_INPUT &&
+ inst->SrcReg[j].Index >= VERT_ATTRIB_GENERIC0) {
+ /* this is a generic attrib */
+ const GLint k = inst->SrcReg[j].Index - VERT_ATTRIB_GENERIC0;
+ const char *name = prog->Attributes->Parameters[k].Name;
+ /* See if this attrib name is in the program's attribute list
+ * (i.e. was bound by the user).
+ */
+ GLint index = _mesa_lookup_parameter_index(shProg->Attributes,
+ -1, name);
+ GLint attr;
+ if (index >= 0) {
+ /* found, user must have specified a binding */
+ attr = shProg->Attributes->Parameters[index].StateIndexes[1];
+ }
+ else {
+ /* not found, choose our own attribute number */
+ for (attr = 0; attr < MAX_VERTEX_ATTRIBS; attr++) {
+ if (((1 << attr) & usedAttributes) == 0)
+ break;
+ }
+ if (attr == MAX_VERTEX_ATTRIBS) {
+ /* too many! XXX record error log */
+ return GL_FALSE;
+ }
+ _mesa_add_attribute(shProg->Attributes, name, attr);
+ }
- prog->TexturesUsed[inst->TexSrcUnit] |= (1 << inst->TexSrcTarget);
+ inst->SrcReg[j].Index = VERT_ATTRIB_GENERIC0 + attr;
+ }
}
}
+ return GL_TRUE;
}
}
+/**
+ * Scan a vertex program looking for instances of
+ * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + oldAttrib) and replace with
+ * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + newAttrib).
+ * This is used when the user calls glBindAttribLocation on an already linked
+ * shader program.
+ */
+void
+_slang_remap_attribute(struct gl_program *prog, GLuint oldAttrib, GLuint newAttrib)
+{
+ GLuint i, j;
+
+ assert(prog->Target == GL_VERTEX_PROGRAM_ARB);
+
+ for (i = 0; i < prog->NumInstructions; i++) {
+ struct prog_instruction *inst = prog->Instructions + i;
+ for (j = 0; j < 3; j++) {
+ if (inst->SrcReg[j].File == PROGRAM_INPUT) {
+ if (inst->SrcReg[j].Index == VERT_ATTRIB_GENERIC0 + oldAttrib) {
+ inst->SrcReg[j].Index = VERT_ATTRIB_GENERIC0 + newAttrib;
+ }
+ }
+ }
+ }
+
+ _slang_update_inputs_outputs(prog);
+}
+
+
+
+/**
+ * Scan program for texture instructions, lookup sampler/uniform's value
+ * to determine which texture unit to use.
+ * Also, update the program's TexturesUsed[] array.
+ */
+void
+_slang_resolve_samplers(struct gl_shader_program *shProg,
+ struct gl_program *prog)
+{
+ GLuint i;
+
+ for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
+ prog->TexturesUsed[i] = 0;
+
+ for (i = 0; i < prog->NumInstructions; i++) {
+ struct prog_instruction *inst = prog->Instructions + i;
+ if (inst->Opcode == OPCODE_TEX ||
+ inst->Opcode == OPCODE_TXB ||
+ inst->Opcode == OPCODE_TXP) {
+ GLint sampleUnit = (GLint) shProg->Uniforms->ParameterValues[inst->Sampler][0];
+ assert(sampleUnit < MAX_TEXTURE_IMAGE_UNITS);
+ inst->TexSrcUnit = sampleUnit;
+
+ prog->TexturesUsed[inst->TexSrcUnit] |= (1 << inst->TexSrcTarget);
+ }
+ }
+}
+
+
/** cast wrapper */
static struct gl_vertex_program *
_slang_resolve_branches(&shProg->VertexProgram->Base);
_slang_resolve_branches(&shProg->FragmentProgram->Base);
-#if 1
+
_slang_resolve_samplers(shProg, &shProg->VertexProgram->Base);
_slang_resolve_samplers(shProg, &shProg->FragmentProgram->Base);
-#endif
+
+ _slang_resolve_attributes(shProg, &shProg->VertexProgram->Base);
+
_slang_update_inputs_outputs(&shProg->VertexProgram->Base);
_slang_update_inputs_outputs(&shProg->FragmentProgram->Base);
projects / mesa.git / commitdiff