OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete code made dead by previous uniform related patches

Browse Source 
Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
Tested-by: Tom Stellard <thomas.stellard@amd.com>
This commit is contained in:
Ian Romanick
2011-10-18 16:50:10 -07:00
parent c42ca36d67
commit be4524aeed
12 changed files with 0 additions and 879 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
src/glsl/linker.cpp
View File

@@ -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.
*

1
src/mesa/main/core.h
View File

@@ -54,7 +54,6 @@ extern "C" {
/* for GLSL */
#include "program/prog_parameter.h"
#include "program/prog_uniform.h"
#ifdef __cplusplus
}

1
src/mesa/main/mtypes.h
View File

@@ -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;

1
src/mesa/main/shaderapi.c
View File

@@ -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"

1
src/mesa/main/shaderobj.c
View File

@@ -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"

531
src/mesa/main/uniform_query.cpp
View File

@@ -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

1
src/mesa/program/ir_to_mesa.cpp
View File

@@ -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"
}

103
src/mesa/program/prog_uniform.c
View File

@@ -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);
}
}

85
src/mesa/program/prog_uniform.h
View File

@@ -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 */

1
src/mesa/sources.mak
View File

@@ -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

1
src/mesa/state_tracker/st_draw.c
View File

@@ -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"

1
src/mesa/state_tracker/st_glsl_to_tgsi.cpp
View File

@@ -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"