unsigned record_array_count = 1;
char *name_copy = ralloc_strdup(NULL, name);
- unsigned packing = type->interface_packing;
+ enum glsl_interface_packing packing = type->get_interface_packing();
recursion(type, &name_copy, strlen(name), false, NULL, packing, false,
record_array_count, NULL);
const bool row_major =
var->data.matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR;
- const unsigned packing = var->get_interface_type() ?
- var->get_interface_type()->interface_packing :
- var->type->interface_packing;
+ const enum glsl_interface_packing packing = var->get_interface_type() ?
+ var->get_interface_type_packing() :
+ var->type->get_interface_packing();
const glsl_type *t =
var->data.from_named_ifc_block ? var->get_interface_type() : var->type;
program_resource_visitor::recursion(const glsl_type *t, char **name,
size_t name_length, bool row_major,
const glsl_type *record_type,
- const unsigned packing,
+ const enum glsl_interface_packing packing,
bool last_field,
unsigned record_array_count,
const glsl_struct_field *named_ifc_member)
program_resource_visitor::visit_field(const glsl_type *type, const char *name,
bool row_major,
const glsl_type *,
- const unsigned,
+ const enum glsl_interface_packing,
bool /* last_field */)
{
visit_field(type, name, row_major);
void
program_resource_visitor::enter_record(const glsl_type *, const char *, bool,
- const unsigned)
+ const enum glsl_interface_packing)
{
}
void
program_resource_visitor::leave_record(const glsl_type *, const char *, bool,
- const unsigned)
+ const enum glsl_interface_packing)
{
}
: num_active_uniforms(0), num_hidden_uniforms(0), num_values(0),
num_shader_samplers(0), num_shader_images(0),
num_shader_uniform_components(0), num_shader_subroutines(0),
- is_ubo_var(false), is_shader_storage(false), map(map),
+ is_buffer_block(false), is_shader_storage(false), map(map),
hidden_map(hidden_map)
{
/* empty */
void process(ir_variable *var)
{
this->current_var = var;
- this->is_ubo_var = var->is_in_buffer_block();
+ this->is_buffer_block = var->is_in_buffer_block();
this->is_shader_storage = var->is_in_shader_storage_block();
if (var->is_interface_instance())
program_resource_visitor::process(var->get_interface_type(),
*/
unsigned num_shader_subroutines;
- bool is_ubo_var;
+ bool is_buffer_block;
bool is_shader_storage;
struct string_to_uint_map *map;
* Note that samplers do not count against this limit because they
* don't use any storage on current hardware.
*/
- if (!is_ubo_var && !is_shader_storage)
+ if (!is_buffer_block)
this->num_shader_uniform_components += values;
}
* uniforms.
*/
this->num_active_uniforms++;
- this->num_values += values;
+
+ if(!is_gl_identifier(name) && !is_shader_storage && !is_buffer_block)
+ this->num_values += values;
}
struct string_to_uint_map *hidden_map;
buffer_block_index = -1;
if (var->is_in_buffer_block()) {
- struct gl_uniform_block **blks = var->is_in_shader_storage_block() ?
+ struct gl_uniform_block *blks = var->is_in_shader_storage_block() ?
prog->ShaderStorageBlocks : prog->UniformBlocks;
unsigned num_blks = var->is_in_shader_storage_block() ?
prog->NumShaderStorageBlocks : prog->NumUniformBlocks;
unsigned l = strlen(var->get_interface_type()->name);
for (unsigned i = 0; i < num_blks; i++) {
- if (strncmp(var->get_interface_type()->name, blks[i]->Name, l)
- == 0 && blks[i]->Name[l] == '[') {
+ if (strncmp(var->get_interface_type()->name, blks[i].Name, l)
+ == 0 && blks[i].Name[l] == '[') {
buffer_block_index = i;
break;
}
}
} else {
for (unsigned i = 0; i < num_blks; i++) {
- if (strcmp(var->get_interface_type()->name, blks[i]->Name) ==
+ if (strcmp(var->get_interface_type()->name, blks[i].Name) ==
0) {
buffer_block_index = i;
break;
var->get_interface_type()->name);
} else {
const struct gl_uniform_block *const block =
- blks[buffer_block_index];
+ &blks[buffer_block_index];
assert(var->data.location != -1);
}
virtual void enter_record(const glsl_type *type, const char *,
- bool row_major, const unsigned packing) {
+ bool row_major, const enum glsl_interface_packing packing) {
assert(type->is_record());
if (this->buffer_block_index == -1)
return;
}
virtual void leave_record(const glsl_type *type, const char *,
- bool row_major, const unsigned packing) {
+ bool row_major, const enum glsl_interface_packing packing) {
assert(type->is_record());
if (this->buffer_block_index == -1)
return;
}
virtual void visit_field(const glsl_type *type, const char *name,
- bool row_major, const glsl_type *record_type,
- const unsigned packing,
+ bool row_major, const glsl_type * /* record_type */,
+ const enum glsl_interface_packing packing,
bool /* last_field */)
{
assert(!type->without_array()->is_record());
current_var->data.how_declared == ir_var_hidden;
this->uniforms[id].builtin = is_gl_identifier(name);
- /* Do not assign storage if the uniform is builtin */
- if (!this->uniforms[id].builtin)
- this->uniforms[id].storage = this->values;
-
this->uniforms[id].is_shader_storage =
current_var->is_in_shader_storage_block();
+ /* Do not assign storage if the uniform is a builtin or buffer object */
+ if (!this->uniforms[id].builtin &&
+ !this->uniforms[id].is_shader_storage &&
+ this->buffer_block_index == -1)
+ this->uniforms[id].storage = this->values;
+
if (this->buffer_block_index != -1) {
this->uniforms[id].block_index = this->buffer_block_index;
this->uniforms[id].row_major = false;
}
- this->values += values_for_type(type);
+ if (!this->uniforms[id].builtin &&
+ !this->uniforms[id].is_shader_storage &&
+ this->buffer_block_index == -1)
+ this->values += values_for_type(type);
}
/**
unsigned shader_shadow_samplers;
};
-/**
- * Merges a uniform block into an array of uniform blocks that may or
- * may not already contain a copy of it.
- *
- * Returns the index of the new block in the array.
- */
-int
-link_cross_validate_uniform_block(void *mem_ctx,
- struct gl_uniform_block **linked_blocks,
- unsigned int *num_linked_blocks,
- struct gl_uniform_block *new_block)
-{
- for (unsigned int i = 0; i < *num_linked_blocks; i++) {
- struct gl_uniform_block *old_block = &(*linked_blocks)[i];
-
- if (strcmp(old_block->Name, new_block->Name) == 0)
- return link_uniform_blocks_are_compatible(old_block, new_block)
- ? i : -1;
- }
-
- *linked_blocks = reralloc(mem_ctx, *linked_blocks,
- struct gl_uniform_block,
- *num_linked_blocks + 1);
- int linked_block_index = (*num_linked_blocks)++;
- struct gl_uniform_block *linked_block = &(*linked_blocks)[linked_block_index];
-
- memcpy(linked_block, new_block, sizeof(*new_block));
- linked_block->Uniforms = ralloc_array(*linked_blocks,
- struct gl_uniform_buffer_variable,
- linked_block->NumUniforms);
-
- memcpy(linked_block->Uniforms,
- new_block->Uniforms,
- sizeof(*linked_block->Uniforms) * linked_block->NumUniforms);
-
- linked_block->Name = ralloc_strdup(*linked_blocks, linked_block->Name);
-
- for (unsigned int i = 0; i < linked_block->NumUniforms; i++) {
- struct gl_uniform_buffer_variable *ubo_var =
- &linked_block->Uniforms[i];
-
- if (ubo_var->Name == ubo_var->IndexName) {
- ubo_var->Name = ralloc_strdup(*linked_blocks, ubo_var->Name);
- ubo_var->IndexName = ubo_var->Name;
- } else {
- ubo_var->Name = ralloc_strdup(*linked_blocks, ubo_var->Name);
- ubo_var->IndexName = ralloc_strdup(*linked_blocks, ubo_var->IndexName);
- }
- }
-
- return linked_block_index;
-}
-
/**
* Walks the IR and update the references to uniform blocks in the
* ir_variables to point at linked shader's list (previously, they
* shaders).
*/
static void
-link_update_uniform_buffer_variables(struct gl_shader *shader)
+link_update_uniform_buffer_variables(struct gl_linked_shader *shader)
{
foreach_in_list(ir_instruction, node, shader->ir) {
ir_variable *const var = node->as_variable();
sentinel = '[';
}
+ unsigned num_blocks = var->data.mode == ir_var_uniform ?
+ shader->NumUniformBlocks : shader->NumShaderStorageBlocks;
+ struct gl_uniform_block **blks = var->data.mode == ir_var_uniform ?
+ shader->UniformBlocks : shader->ShaderStorageBlocks;
+
const unsigned l = strlen(var->name);
- for (unsigned i = 0; i < shader->NumBufferInterfaceBlocks; i++) {
- for (unsigned j = 0; j < shader->BufferInterfaceBlocks[i]->NumUniforms; j++) {
+ for (unsigned i = 0; i < num_blocks; i++) {
+ for (unsigned j = 0; j < blks[i]->NumUniforms; j++) {
if (sentinel) {
- const char *begin = shader->BufferInterfaceBlocks[i]->Uniforms[j].Name;
+ const char *begin = blks[i]->Uniforms[j].Name;
const char *end = strchr(begin, sentinel);
if (end == NULL)
var->data.location = j;
break;
}
- } else if (!strcmp(var->name,
- shader->BufferInterfaceBlocks[i]->Uniforms[j].Name)) {
+ } else if (!strcmp(var->name, blks[i]->Uniforms[j].Name)) {
found = true;
var->data.location = j;
break;
struct string_to_uint_map *hiddenUniforms = new string_to_uint_map;
count_uniform_size uniform_size(prog->UniformHash, hiddenUniforms);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
continue;
sh->num_uniform_components = uniform_size.num_shader_uniform_components;
sh->num_combined_uniform_components = sh->num_uniform_components;
- for (unsigned i = 0; i < sh->NumBufferInterfaceBlocks; i++) {
- if (!sh->BufferInterfaceBlocks[i]->IsShaderStorage) {
- sh->num_combined_uniform_components +=
- sh->BufferInterfaceBlocks[i]->UniformBufferSize / 4;
- }
+ for (unsigned i = 0; i < sh->NumUniformBlocks; i++) {
+ sh->num_combined_uniform_components +=
+ sh->UniformBlocks[i]->UniformBufferSize / 4;
}
}
continue;
for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
- struct gl_shader *sh = prog->_LinkedShaders[j];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[j];
if (!sh)
continue;
if (uniforms[i].remap_location != UNMAPPED_UNIFORM_LOC)
continue;
for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
- struct gl_shader *sh = prog->_LinkedShaders[j];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[j];
if (!sh)
continue;
#ifndef NDEBUG
for (unsigned i = 0; i < num_uniforms; i++) {
- assert(uniforms[i].storage != NULL || uniforms[i].builtin);
+ assert(uniforms[i].storage != NULL || uniforms[i].builtin ||
+ uniforms[i].is_shader_storage ||
+ uniforms[i].block_index != -1);
}
assert(parcel.values == data_end);