Delete code made dead by previous uniform related patches
Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Tested-by: Tom Stellard <thomas.stellard@amd.com>
This commit is contained in:
@@ -1021,13 +1021,6 @@ link_intrastage_shaders(void *mem_ctx,
|
||||
return linked;
|
||||
}
|
||||
|
||||
|
||||
struct uniform_node {
|
||||
exec_node link;
|
||||
struct gl_uniform *u;
|
||||
unsigned slots;
|
||||
};
|
||||
|
||||
/**
|
||||
* Update the sizes of linked shader uniform arrays to the maximum
|
||||
* array index used.
|
||||
@@ -1100,151 +1093,6 @@ update_array_sizes(struct gl_shader_program *prog)
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
add_uniform(void *mem_ctx, exec_list *uniforms, struct hash_table *ht,
|
||||
const char *name, const glsl_type *type, GLenum shader_type,
|
||||
unsigned *next_shader_pos, unsigned *total_uniforms)
|
||||
{
|
||||
if (type->is_record()) {
|
||||
for (unsigned int i = 0; i < type->length; i++) {
|
||||
const glsl_type *field_type = type->fields.structure[i].type;
|
||||
char *field_name = ralloc_asprintf(mem_ctx, "%s.%s", name,
|
||||
type->fields.structure[i].name);
|
||||
|
||||
add_uniform(mem_ctx, uniforms, ht, field_name, field_type,
|
||||
shader_type, next_shader_pos, total_uniforms);
|
||||
}
|
||||
} else {
|
||||
uniform_node *n = (uniform_node *) hash_table_find(ht, name);
|
||||
unsigned int vec4_slots;
|
||||
const glsl_type *array_elem_type = NULL;
|
||||
|
||||
if (type->is_array()) {
|
||||
array_elem_type = type->fields.array;
|
||||
/* Array of structures. */
|
||||
if (array_elem_type->is_record()) {
|
||||
for (unsigned int i = 0; i < type->length; i++) {
|
||||
char *elem_name = ralloc_asprintf(mem_ctx, "%s[%d]", name, i);
|
||||
add_uniform(mem_ctx, uniforms, ht, elem_name, array_elem_type,
|
||||
shader_type, next_shader_pos, total_uniforms);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* Fix the storage size of samplers at 1 vec4 each. Be sure to pad out
|
||||
* vectors to vec4 slots.
|
||||
*/
|
||||
if (type->is_array()) {
|
||||
if (array_elem_type->is_sampler())
|
||||
vec4_slots = type->length;
|
||||
else
|
||||
vec4_slots = type->length * array_elem_type->matrix_columns;
|
||||
} else if (type->is_sampler()) {
|
||||
vec4_slots = 1;
|
||||
} else {
|
||||
vec4_slots = type->matrix_columns;
|
||||
}
|
||||
|
||||
if (n == NULL) {
|
||||
n = (uniform_node *) calloc(1, sizeof(struct uniform_node));
|
||||
n->u = (gl_uniform *) calloc(1, sizeof(struct gl_uniform));
|
||||
n->slots = vec4_slots;
|
||||
|
||||
n->u->Name = strdup(name);
|
||||
n->u->Type = type;
|
||||
n->u->VertPos = -1;
|
||||
n->u->FragPos = -1;
|
||||
n->u->GeomPos = -1;
|
||||
(*total_uniforms)++;
|
||||
|
||||
hash_table_insert(ht, n, name);
|
||||
uniforms->push_tail(& n->link);
|
||||
}
|
||||
|
||||
switch (shader_type) {
|
||||
case GL_VERTEX_SHADER:
|
||||
n->u->VertPos = *next_shader_pos;
|
||||
break;
|
||||
case GL_FRAGMENT_SHADER:
|
||||
n->u->FragPos = *next_shader_pos;
|
||||
break;
|
||||
case GL_GEOMETRY_SHADER:
|
||||
n->u->GeomPos = *next_shader_pos;
|
||||
break;
|
||||
}
|
||||
|
||||
(*next_shader_pos) += vec4_slots;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
assign_uniform_locations(struct gl_shader_program *prog)
|
||||
{
|
||||
/* */
|
||||
exec_list uniforms;
|
||||
unsigned total_uniforms = 0;
|
||||
hash_table *ht = hash_table_ctor(32, hash_table_string_hash,
|
||||
hash_table_string_compare);
|
||||
void *mem_ctx = ralloc_context(NULL);
|
||||
|
||||
for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
|
||||
if (prog->_LinkedShaders[i] == NULL)
|
||||
continue;
|
||||
|
||||
unsigned next_position = 0;
|
||||
|
||||
foreach_list(node, prog->_LinkedShaders[i]->ir) {
|
||||
ir_variable *const var = ((ir_instruction *) node)->as_variable();
|
||||
|
||||
if ((var == NULL) || (var->mode != ir_var_uniform))
|
||||
continue;
|
||||
|
||||
if (strncmp(var->name, "gl_", 3) == 0) {
|
||||
/* At the moment, we don't allocate uniform locations for
|
||||
* builtin uniforms. It's permitted by spec, and we'll
|
||||
* likely switch to doing that at some point, but not yet.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
var->location = next_position;
|
||||
add_uniform(mem_ctx, &uniforms, ht, var->name, var->type,
|
||||
prog->_LinkedShaders[i]->Type,
|
||||
&next_position, &total_uniforms);
|
||||
}
|
||||
}
|
||||
|
||||
ralloc_free(mem_ctx);
|
||||
|
||||
gl_uniform_list *ul = (gl_uniform_list *)
|
||||
calloc(1, sizeof(gl_uniform_list));
|
||||
|
||||
ul->Size = total_uniforms;
|
||||
ul->NumUniforms = total_uniforms;
|
||||
ul->Uniforms = (gl_uniform *) calloc(total_uniforms, sizeof(gl_uniform));
|
||||
|
||||
unsigned idx = 0;
|
||||
uniform_node *next;
|
||||
for (uniform_node *node = (uniform_node *) uniforms.head
|
||||
; node->link.next != NULL
|
||||
; node = next) {
|
||||
next = (uniform_node *) node->link.next;
|
||||
|
||||
node->link.remove();
|
||||
memcpy(&ul->Uniforms[idx], node->u, sizeof(gl_uniform));
|
||||
idx++;
|
||||
|
||||
free(node->u);
|
||||
free(node);
|
||||
}
|
||||
|
||||
hash_table_dtor(ht);
|
||||
|
||||
prog->Uniforms = ul;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Find a contiguous set of available bits in a bitmask.
|
||||
*
|
||||
|
@@ -54,7 +54,6 @@ extern "C" {
|
||||
|
||||
/* for GLSL */
|
||||
#include "program/prog_parameter.h"
|
||||
#include "program/prog_uniform.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
@@ -2230,7 +2230,6 @@ struct gl_shader_program
|
||||
/** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */
|
||||
gl_texture_index SamplerTargets[MAX_SAMPLERS];
|
||||
|
||||
struct gl_uniform_list *Uniforms;
|
||||
struct gl_program_parameter_list *Varying;
|
||||
GLboolean LinkStatus; /**< GL_LINK_STATUS */
|
||||
GLboolean Validated;
|
||||
|
@@ -47,7 +47,6 @@
|
||||
#include "main/shaderobj.h"
|
||||
#include "program/program.h"
|
||||
#include "program/prog_parameter.h"
|
||||
#include "program/prog_uniform.h"
|
||||
#include "ralloc.h"
|
||||
#include <stdbool.h>
|
||||
#include "../glsl/glsl_parser_extras.h"
|
||||
|
@@ -37,7 +37,6 @@
|
||||
#include "main/shaderobj.h"
|
||||
#include "program/program.h"
|
||||
#include "program/prog_parameter.h"
|
||||
#include "program/prog_uniform.h"
|
||||
#include "program/hash_table.h"
|
||||
#include "ralloc.h"
|
||||
|
||||
|
@@ -72,267 +72,6 @@ _mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,
|
||||
}
|
||||
}
|
||||
|
||||
static GLenum
|
||||
base_uniform_type(GLenum type)
|
||||
{
|
||||
switch (type) {
|
||||
case GL_BOOL:
|
||||
case GL_BOOL_VEC2:
|
||||
case GL_BOOL_VEC3:
|
||||
case GL_BOOL_VEC4:
|
||||
return GL_BOOL;
|
||||
case GL_FLOAT:
|
||||
case GL_FLOAT_VEC2:
|
||||
case GL_FLOAT_VEC3:
|
||||
case GL_FLOAT_VEC4:
|
||||
case GL_FLOAT_MAT2:
|
||||
case GL_FLOAT_MAT2x3:
|
||||
case GL_FLOAT_MAT2x4:
|
||||
case GL_FLOAT_MAT3x2:
|
||||
case GL_FLOAT_MAT3:
|
||||
case GL_FLOAT_MAT3x4:
|
||||
case GL_FLOAT_MAT4x2:
|
||||
case GL_FLOAT_MAT4x3:
|
||||
case GL_FLOAT_MAT4:
|
||||
return GL_FLOAT;
|
||||
case GL_UNSIGNED_INT:
|
||||
case GL_UNSIGNED_INT_VEC2:
|
||||
case GL_UNSIGNED_INT_VEC3:
|
||||
case GL_UNSIGNED_INT_VEC4:
|
||||
return GL_UNSIGNED_INT;
|
||||
case GL_INT:
|
||||
case GL_INT_VEC2:
|
||||
case GL_INT_VEC3:
|
||||
case GL_INT_VEC4:
|
||||
return GL_INT;
|
||||
default:
|
||||
_mesa_problem(NULL, "Invalid type in base_uniform_type()");
|
||||
return GL_FLOAT;
|
||||
}
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
is_boolean_type(GLenum type)
|
||||
{
|
||||
switch (type) {
|
||||
case GL_BOOL:
|
||||
case GL_BOOL_VEC2:
|
||||
case GL_BOOL_VEC3:
|
||||
case GL_BOOL_VEC4:
|
||||
return GL_TRUE;
|
||||
default:
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
is_sampler_type(GLenum type)
|
||||
{
|
||||
switch (type) {
|
||||
case GL_SAMPLER_1D:
|
||||
case GL_INT_SAMPLER_1D:
|
||||
case GL_UNSIGNED_INT_SAMPLER_1D:
|
||||
case GL_SAMPLER_2D:
|
||||
case GL_INT_SAMPLER_2D:
|
||||
case GL_UNSIGNED_INT_SAMPLER_2D:
|
||||
case GL_SAMPLER_3D:
|
||||
case GL_INT_SAMPLER_3D:
|
||||
case GL_UNSIGNED_INT_SAMPLER_3D:
|
||||
case GL_SAMPLER_CUBE:
|
||||
case GL_INT_SAMPLER_CUBE:
|
||||
case GL_UNSIGNED_INT_SAMPLER_CUBE:
|
||||
case GL_SAMPLER_1D_SHADOW:
|
||||
case GL_SAMPLER_2D_SHADOW:
|
||||
case GL_SAMPLER_CUBE_SHADOW:
|
||||
case GL_SAMPLER_2D_RECT_ARB:
|
||||
case GL_INT_SAMPLER_2D_RECT:
|
||||
case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
|
||||
case GL_SAMPLER_2D_RECT_SHADOW_ARB:
|
||||
case GL_SAMPLER_1D_ARRAY_EXT:
|
||||
case GL_INT_SAMPLER_1D_ARRAY:
|
||||
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
|
||||
case GL_SAMPLER_2D_ARRAY_EXT:
|
||||
case GL_INT_SAMPLER_2D_ARRAY:
|
||||
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
|
||||
case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
|
||||
case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
|
||||
case GL_SAMPLER_CUBE_MAP_ARRAY:
|
||||
case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
|
||||
case GL_SAMPLER_BUFFER:
|
||||
case GL_INT_SAMPLER_BUFFER:
|
||||
case GL_UNSIGNED_INT_SAMPLER_BUFFER:
|
||||
case GL_SAMPLER_2D_MULTISAMPLE:
|
||||
case GL_INT_SAMPLER_2D_MULTISAMPLE:
|
||||
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
|
||||
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
|
||||
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
|
||||
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
|
||||
case GL_SAMPLER_EXTERNAL_OES:
|
||||
return GL_TRUE;
|
||||
default:
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a uniform index, return the vertex/geometry/fragment program
|
||||
* that has that parameter, plus the position of the parameter in the
|
||||
* parameter/constant buffer.
|
||||
* \param shProg the shader program
|
||||
* \param index the uniform index in [0, NumUniforms-1]
|
||||
* \param progOut returns containing program
|
||||
* \param posOut returns position of the uniform in the param/const buffer
|
||||
* \return GL_TRUE for success, GL_FALSE for invalid index
|
||||
*/
|
||||
static GLboolean
|
||||
find_uniform_parameter_pos(struct gl_shader_program *shProg, GLint index,
|
||||
struct gl_program **progOut, GLint *posOut)
|
||||
{
|
||||
struct gl_program *prog = NULL;
|
||||
GLint pos;
|
||||
|
||||
if (!shProg->Uniforms ||
|
||||
index < 0 ||
|
||||
index >= (GLint) shProg->Uniforms->NumUniforms) {
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
pos = shProg->Uniforms->Uniforms[index].VertPos;
|
||||
if (pos >= 0) {
|
||||
prog = shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
|
||||
}
|
||||
else {
|
||||
pos = shProg->Uniforms->Uniforms[index].FragPos;
|
||||
if (pos >= 0) {
|
||||
prog = shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program;
|
||||
}
|
||||
else {
|
||||
pos = shProg->Uniforms->Uniforms[index].GeomPos;
|
||||
if (pos >= 0) {
|
||||
prog = shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!prog || pos < 0)
|
||||
return GL_FALSE; /* should really never happen */
|
||||
|
||||
*progOut = prog;
|
||||
*posOut = pos;
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return pointer to a gl_program_parameter which corresponds to a uniform.
|
||||
* \param shProg the shader program
|
||||
* \param index the uniform index in [0, NumUniforms-1]
|
||||
* \return gl_program_parameter point or NULL if index is invalid
|
||||
*/
|
||||
const struct gl_program_parameter *
|
||||
get_uniform_parameter(struct gl_shader_program *shProg, GLint index)
|
||||
{
|
||||
struct gl_program *prog;
|
||||
GLint progPos;
|
||||
|
||||
if (find_uniform_parameter_pos(shProg, index, &prog, &progPos))
|
||||
return &prog->Parameters->Parameters[progPos];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static unsigned
|
||||
get_vector_elements(GLenum type)
|
||||
{
|
||||
switch (type) {
|
||||
case GL_FLOAT:
|
||||
case GL_INT:
|
||||
case GL_BOOL:
|
||||
case GL_UNSIGNED_INT:
|
||||
default: /* Catch all the various sampler types. */
|
||||
return 1;
|
||||
|
||||
case GL_FLOAT_VEC2:
|
||||
case GL_INT_VEC2:
|
||||
case GL_BOOL_VEC2:
|
||||
case GL_UNSIGNED_INT_VEC2:
|
||||
return 2;
|
||||
|
||||
case GL_FLOAT_VEC3:
|
||||
case GL_INT_VEC3:
|
||||
case GL_BOOL_VEC3:
|
||||
case GL_UNSIGNED_INT_VEC3:
|
||||
return 3;
|
||||
|
||||
case GL_FLOAT_VEC4:
|
||||
case GL_INT_VEC4:
|
||||
case GL_BOOL_VEC4:
|
||||
case GL_UNSIGNED_INT_VEC4:
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
get_matrix_dims(GLenum type, GLint *rows, GLint *cols)
|
||||
{
|
||||
switch (type) {
|
||||
case GL_FLOAT_MAT2:
|
||||
*rows = *cols = 2;
|
||||
break;
|
||||
case GL_FLOAT_MAT2x3:
|
||||
*rows = 3;
|
||||
*cols = 2;
|
||||
break;
|
||||
case GL_FLOAT_MAT2x4:
|
||||
*rows = 4;
|
||||
*cols = 2;
|
||||
break;
|
||||
case GL_FLOAT_MAT3:
|
||||
*rows = 3;
|
||||
*cols = 3;
|
||||
break;
|
||||
case GL_FLOAT_MAT3x2:
|
||||
*rows = 2;
|
||||
*cols = 3;
|
||||
break;
|
||||
case GL_FLOAT_MAT3x4:
|
||||
*rows = 4;
|
||||
*cols = 3;
|
||||
break;
|
||||
case GL_FLOAT_MAT4:
|
||||
*rows = 4;
|
||||
*cols = 4;
|
||||
break;
|
||||
case GL_FLOAT_MAT4x2:
|
||||
*rows = 2;
|
||||
*cols = 4;
|
||||
break;
|
||||
case GL_FLOAT_MAT4x3:
|
||||
*rows = 3;
|
||||
*cols = 4;
|
||||
break;
|
||||
default:
|
||||
*rows = *cols = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine the number of rows and columns occupied by a uniform
|
||||
* according to its datatype. For non-matrix types (such as GL_FLOAT_VEC4),
|
||||
* the number of rows = 1 and cols = number of elements in the vector.
|
||||
*/
|
||||
static void
|
||||
get_uniform_rows_cols(const struct gl_program_parameter *p,
|
||||
GLint *rows, GLint *cols)
|
||||
{
|
||||
get_matrix_dims(p->DataType, rows, cols);
|
||||
if (*rows == 0 && *cols == 0) {
|
||||
/* not a matrix type, probably a float or vector */
|
||||
*rows = 1;
|
||||
*cols = get_vector_elements(p->DataType);
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
validate_uniform_parameters(struct gl_context *ctx,
|
||||
struct gl_shader_program *shProg,
|
||||
@@ -624,207 +363,6 @@ log_program_parameters(const struct gl_shader_program *shProg)
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Check if the type given by userType is allowed to set a uniform of the
|
||||
* target type. Generally, equivalence is required, but setting Boolean
|
||||
* uniforms can be done with glUniformiv or glUniformfv.
|
||||
*/
|
||||
static GLboolean
|
||||
compatible_types(GLenum userType, GLenum targetType)
|
||||
{
|
||||
if (userType == targetType)
|
||||
return GL_TRUE;
|
||||
|
||||
if (targetType == GL_BOOL && (userType == GL_FLOAT ||
|
||||
userType == GL_UNSIGNED_INT ||
|
||||
userType == GL_INT))
|
||||
return GL_TRUE;
|
||||
|
||||
if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||
|
||||
userType == GL_UNSIGNED_INT_VEC2 ||
|
||||
userType == GL_INT_VEC2))
|
||||
return GL_TRUE;
|
||||
|
||||
if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||
|
||||
userType == GL_UNSIGNED_INT_VEC3 ||
|
||||
userType == GL_INT_VEC3))
|
||||
return GL_TRUE;
|
||||
|
||||
if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||
|
||||
userType == GL_UNSIGNED_INT_VEC4 ||
|
||||
userType == GL_INT_VEC4))
|
||||
return GL_TRUE;
|
||||
|
||||
if (is_sampler_type(targetType) && userType == GL_INT)
|
||||
return GL_TRUE;
|
||||
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the value of a program's uniform variable.
|
||||
* \param program the program whose uniform to update
|
||||
* \param index the index of the program parameter for the uniform
|
||||
* \param offset additional parameter slot offset (for arrays)
|
||||
* \param type the incoming datatype of 'values'
|
||||
* \param count the number of uniforms to set
|
||||
* \param elems number of elements per uniform (1, 2, 3 or 4)
|
||||
* \param values the new values, of datatype 'type'
|
||||
*/
|
||||
static void
|
||||
set_program_uniform(struct gl_context *ctx, struct gl_program *program,
|
||||
GLint index, GLint offset,
|
||||
GLenum type, GLsizei count, GLint elems,
|
||||
const void *values)
|
||||
{
|
||||
const struct gl_program_parameter *param =
|
||||
&program->Parameters->Parameters[index];
|
||||
|
||||
assert(offset >= 0);
|
||||
assert(elems >= 1);
|
||||
assert(elems <= 4);
|
||||
|
||||
if (!compatible_types(type, param->DataType)) {
|
||||
_mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
|
||||
return;
|
||||
}
|
||||
|
||||
if (index + offset > (GLint) program->Parameters->Size) {
|
||||
/* out of bounds! */
|
||||
return;
|
||||
}
|
||||
|
||||
if (param->Type == PROGRAM_SAMPLER) {
|
||||
/* This controls which texture unit which is used by a sampler */
|
||||
GLboolean changed = GL_FALSE;
|
||||
GLint i;
|
||||
|
||||
/* this should have been caught by the compatible_types() check */
|
||||
ASSERT(type == GL_INT);
|
||||
|
||||
/* loop over number of samplers to change */
|
||||
for (i = 0; i < count; i++) {
|
||||
GLuint sampler = (GLuint)
|
||||
program->Parameters->ParameterValues[index+offset + i][0].f;
|
||||
GLuint texUnit = ((GLuint *) values)[i];
|
||||
|
||||
/* check that the sampler (tex unit index) is legal */
|
||||
if (texUnit >= ctx->Const.MaxCombinedTextureImageUnits) {
|
||||
_mesa_error(ctx, GL_INVALID_VALUE,
|
||||
"glUniform1(invalid sampler/tex unit index for '%s')",
|
||||
param->Name);
|
||||
return;
|
||||
}
|
||||
|
||||
/* This maps a sampler to a texture unit: */
|
||||
if (sampler < MAX_SAMPLERS) {
|
||||
#if 0
|
||||
printf("Set program %p sampler %d '%s' to unit %u\n",
|
||||
program, sampler, param->Name, texUnit);
|
||||
#endif
|
||||
if (program->SamplerUnits[sampler] != texUnit) {
|
||||
program->SamplerUnits[sampler] = texUnit;
|
||||
changed = GL_TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (changed) {
|
||||
/* When a sampler's value changes it usually requires rewriting
|
||||
* a GPU program's TEX instructions since there may not be a
|
||||
* sampler->texture lookup table. We signal this with the
|
||||
* ProgramStringNotify() callback.
|
||||
*/
|
||||
FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);
|
||||
_mesa_update_shader_textures_used(program);
|
||||
/* Do we need to care about the return value here?
|
||||
* This should not be the first time the driver was notified of
|
||||
* this program.
|
||||
*/
|
||||
(void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* ordinary uniform variable */
|
||||
const GLboolean isUniformBool = is_boolean_type(param->DataType);
|
||||
const GLenum basicType = base_uniform_type(type);
|
||||
const GLint slots = (param->Size + 3) / 4;
|
||||
const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
|
||||
GLsizei k, i;
|
||||
|
||||
if ((GLint) param->Size > typeSize) {
|
||||
/* an array */
|
||||
/* we'll ignore extra data below */
|
||||
}
|
||||
else {
|
||||
/* non-array: count must be at most one; count == 0 is handled
|
||||
* by the loop below
|
||||
*/
|
||||
if (count > 1) {
|
||||
_mesa_error(ctx, GL_INVALID_OPERATION,
|
||||
"glUniform(uniform '%s' is not an array)",
|
||||
param->Name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* loop over number of array elements */
|
||||
for (k = 0; k < count; k++) {
|
||||
gl_constant_value *uniformVal;
|
||||
|
||||
if (offset + k >= slots) {
|
||||
/* Extra array data is ignored */
|
||||
break;
|
||||
}
|
||||
|
||||
/* uniformVal (the destination) is always gl_constant_value[4] */
|
||||
uniformVal = program->Parameters->ParameterValues[index + offset + k];
|
||||
|
||||
if (basicType == GL_INT) {
|
||||
const GLint *iValues = ((const GLint *) values) + k * elems;
|
||||
for (i = 0; i < elems; i++) {
|
||||
if (!ctx->Const.NativeIntegers)
|
||||
uniformVal[i].f = (GLfloat) iValues[i];
|
||||
else
|
||||
uniformVal[i].i = iValues[i];
|
||||
}
|
||||
}
|
||||
else if (basicType == GL_UNSIGNED_INT) {
|
||||
const GLuint *iValues = ((const GLuint *) values) + k * elems;
|
||||
for (i = 0; i < elems; i++) {
|
||||
if (!ctx->Const.NativeIntegers)
|
||||
uniformVal[i].f = (GLfloat)(GLuint) iValues[i];
|
||||
else
|
||||
uniformVal[i].u = iValues[i];
|
||||
}
|
||||
}
|
||||
else {
|
||||
const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
|
||||
assert(basicType == GL_FLOAT);
|
||||
for (i = 0; i < elems; i++) {
|
||||
uniformVal[i].f = fValues[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* if the uniform is bool-valued, convert to 1 or 0 */
|
||||
if (isUniformBool) {
|
||||
for (i = 0; i < elems; i++) {
|
||||
if (basicType == GL_FLOAT)
|
||||
uniformVal[i].b = uniformVal[i].f != 0.0f ? 1 : 0;
|
||||
else
|
||||
uniformVal[i].b = uniformVal[i].u ? 1 : 0;
|
||||
|
||||
if (ctx->Const.NativeIntegers)
|
||||
uniformVal[i].u =
|
||||
uniformVal[i].b ? ctx->Const.UniformBooleanTrue : 0;
|
||||
else
|
||||
uniformVal[i].f = uniformVal[i].b ? 1.0f : 0.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Propagate some values from uniform backing storage to driver storage
|
||||
*
|
||||
@@ -1177,75 +715,6 @@ _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a matrix-valued program parameter.
|
||||
*/
|
||||
static void
|
||||
set_program_uniform_matrix(struct gl_context *ctx, struct gl_program *program,
|
||||
GLuint index, GLuint offset,
|
||||
GLuint count, GLuint rows, GLuint cols,
|
||||
GLboolean transpose, const GLfloat *values)
|
||||
{
|
||||
GLuint mat, row, col;
|
||||
GLuint src = 0;
|
||||
const struct gl_program_parameter *param =
|
||||
&program->Parameters->Parameters[index];
|
||||
const GLuint slots = (param->Size + 3) / 4;
|
||||
const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
|
||||
GLint nr, nc;
|
||||
|
||||
/* check that the number of rows, columns is correct */
|
||||
get_matrix_dims(param->DataType, &nr, &nc);
|
||||
if (rows != nr || cols != nc) {
|
||||
_mesa_error(ctx, GL_INVALID_OPERATION,
|
||||
"glUniformMatrix(matrix size mismatch)");
|
||||
return;
|
||||
}
|
||||
|
||||
if ((GLint) param->Size <= typeSize) {
|
||||
/* non-array: count must be at most one; count == 0 is handled
|
||||
* by the loop below
|
||||
*/
|
||||
if (count > 1) {
|
||||
_mesa_error(ctx, GL_INVALID_OPERATION,
|
||||
"glUniformMatrix(uniform is not an array)");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Note: the _columns_ of a matrix are stored in program registers, not
|
||||
* the rows. So, the loops below look a little funny.
|
||||
* XXX could optimize this a bit...
|
||||
*/
|
||||
|
||||
/* loop over matrices */
|
||||
for (mat = 0; mat < count; mat++) {
|
||||
|
||||
/* each matrix: */
|
||||
for (col = 0; col < cols; col++) {
|
||||
GLfloat *v;
|
||||
if (offset >= slots) {
|
||||
/* Ignore writes beyond the end of (the used part of) an array */
|
||||
return;
|
||||
}
|
||||
v = (GLfloat *) program->Parameters->ParameterValues[index + offset];
|
||||
for (row = 0; row < rows; row++) {
|
||||
if (transpose) {
|
||||
v[row] = values[src + row * cols + col];
|
||||
}
|
||||
else {
|
||||
v[row] = values[src + col * rows + row];
|
||||
}
|
||||
}
|
||||
|
||||
offset++;
|
||||
}
|
||||
|
||||
src += rows * cols; /* next matrix */
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called by glUniformMatrix*() functions.
|
||||
* Note: cols=2, rows=4 ==> array[2] of vec4
|
||||
|
@@ -54,7 +54,6 @@ extern "C" {
|
||||
#include "program/prog_optimize.h"
|
||||
#include "program/prog_print.h"
|
||||
#include "program/program.h"
|
||||
#include "program/prog_uniform.h"
|
||||
#include "program/prog_parameter.h"
|
||||
#include "program/sampler.h"
|
||||
}
|
||||
|
@@ -1,103 +0,0 @@
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
* Version: 7.1
|
||||
*
|
||||
* Copyright (C) 1999-2008 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"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file prog_uniform.c
|
||||
* Shader uniform functions.
|
||||
* \author Brian Paul
|
||||
*/
|
||||
|
||||
#include "main/imports.h"
|
||||
#include "main/mtypes.h"
|
||||
#include "prog_uniform.h"
|
||||
|
||||
|
||||
struct gl_uniform_list *
|
||||
_mesa_new_uniform_list(void)
|
||||
{
|
||||
return CALLOC_STRUCT(gl_uniform_list);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_mesa_free_uniform_list(struct gl_uniform_list *list)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
if (!list)
|
||||
return;
|
||||
|
||||
for (i = 0; i < list->NumUniforms; i++) {
|
||||
free((void *) list->Uniforms[i].Name);
|
||||
}
|
||||
free(list->Uniforms);
|
||||
free(list);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return the location/index of the named uniform in the uniform list,
|
||||
* or -1 if not found.
|
||||
*/
|
||||
GLint
|
||||
_mesa_lookup_uniform(const struct gl_uniform_list *list, const char *name)
|
||||
{
|
||||
GLuint i;
|
||||
for (i = 0; list && i < list->NumUniforms; i++) {
|
||||
if (!strcmp(list->Uniforms[i].Name, name)) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
GLint
|
||||
_mesa_longest_uniform_name(const struct gl_uniform_list *list)
|
||||
{
|
||||
GLint max = 0;
|
||||
GLuint i;
|
||||
for (i = 0; list && i < list->NumUniforms; i++) {
|
||||
GLint len = (GLint) strlen(list->Uniforms[i].Name);
|
||||
if (len > max)
|
||||
max = len;
|
||||
}
|
||||
return max;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_mesa_print_uniforms(const struct gl_uniform_list *list)
|
||||
{
|
||||
GLuint i;
|
||||
printf("Uniform list %p:\n", (void *) list);
|
||||
for (i = 0; i < list->NumUniforms; i++) {
|
||||
printf("%d: %s %d %d %d\n",
|
||||
i,
|
||||
list->Uniforms[i].Name,
|
||||
list->Uniforms[i].VertPos,
|
||||
list->Uniforms[i].FragPos,
|
||||
list->Uniforms[i].GeomPos);
|
||||
}
|
||||
}
|
@@ -1,85 +0,0 @@
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
* Version: 7.1
|
||||
*
|
||||
* Copyright (C) 1999-2008 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"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file prog_uniform.c
|
||||
* Shader uniform functions.
|
||||
* \author Brian Paul
|
||||
*/
|
||||
|
||||
#ifndef PROG_UNIFORM_H
|
||||
#define PROG_UNIFORM_H
|
||||
|
||||
#include "main/glheader.h"
|
||||
|
||||
|
||||
/**
|
||||
* Shader program uniform variable.
|
||||
* The glGetUniformLocation() and glUniform() commands will use this
|
||||
* information.
|
||||
* Note that a uniform such as "binormal" might be used in both the
|
||||
* vertex shader and the fragment shader. When glUniform() is called to
|
||||
* set the uniform's value, it must be updated in both the vertex and
|
||||
* fragment shaders. The uniform may be in different locations in the
|
||||
* two shaders so we keep track of that here.
|
||||
*/
|
||||
struct gl_uniform
|
||||
{
|
||||
const char *Name; /**< Null-terminated string */
|
||||
GLint VertPos;
|
||||
GLint FragPos;
|
||||
GLint GeomPos;
|
||||
GLboolean Initialized; /**< For debug. Has this uniform been set? */
|
||||
const struct glsl_type *Type;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* List of gl_uniforms
|
||||
*/
|
||||
struct gl_uniform_list
|
||||
{
|
||||
GLuint Size; /**< allocated size of Uniforms array */
|
||||
GLuint NumUniforms; /**< number of uniforms in the array */
|
||||
struct gl_uniform *Uniforms; /**< Array [Size] */
|
||||
};
|
||||
|
||||
|
||||
extern struct gl_uniform_list *
|
||||
_mesa_new_uniform_list(void);
|
||||
|
||||
extern void
|
||||
_mesa_free_uniform_list(struct gl_uniform_list *list);
|
||||
|
||||
extern GLint
|
||||
_mesa_lookup_uniform(const struct gl_uniform_list *list, const char *name);
|
||||
|
||||
extern GLint
|
||||
_mesa_longest_uniform_name(const struct gl_uniform_list *list);
|
||||
|
||||
extern void
|
||||
_mesa_print_uniforms(const struct gl_uniform_list *list);
|
||||
|
||||
|
||||
#endif /* PROG_UNIFORM_H */
|
@@ -261,7 +261,6 @@ PROGRAM_SOURCES = \
|
||||
program/prog_parameter_layout.c \
|
||||
program/prog_print.c \
|
||||
program/prog_statevars.c \
|
||||
program/prog_uniform.c \
|
||||
program/programopt.c \
|
||||
program/register_allocate.c \
|
||||
program/symbol_table.c
|
||||
|
@@ -45,7 +45,6 @@
|
||||
#include "main/bufferobj.h"
|
||||
#include "main/macros.h"
|
||||
#include "main/mfeatures.h"
|
||||
#include "program/prog_uniform.h"
|
||||
|
||||
#include "vbo/vbo.h"
|
||||
|
||||
|
@@ -53,7 +53,6 @@ extern "C" {
|
||||
#include "program/prog_optimize.h"
|
||||
#include "program/prog_print.h"
|
||||
#include "program/program.h"
|
||||
#include "program/prog_uniform.h"
|
||||
#include "program/prog_parameter.h"
|
||||
#include "program/sampler.h"
|
||||
|
||||
|
Reference in New Issue
Block a user