X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Flink_uniform_initializers.cpp;h=065257b5a0ea80763d32eb9a3009fcd69751c578;hb=3524d6df33b1e3716992f9a555ffb0f7b1ae2f4f;hp=c6338502d0899806e652f38a8b6ad4b8bdd02c6a;hpb=157391a41bc3e0222888d0450405867139ab4c9d;p=mesa.git diff --git a/src/glsl/link_uniform_initializers.cpp b/src/glsl/link_uniform_initializers.cpp index c6338502d08..065257b5a0e 100644 --- a/src/glsl/link_uniform_initializers.cpp +++ b/src/glsl/link_uniform_initializers.cpp @@ -25,8 +25,6 @@ #include "ir.h" #include "linker.h" #include "ir_uniform.h" -#include "glsl_symbol_table.h" -#include "program/hash_table.h" /* These functions are put in a "private" namespace instead of being marked * static so that the unit tests can access them. See @@ -46,11 +44,24 @@ get_storage(gl_uniform_storage *storage, unsigned num_storage, return NULL; } +static unsigned +get_uniform_block_index(const gl_shader_program *shProg, + const char *uniformBlockName) +{ + for (unsigned i = 0; i < shProg->NumBufferInterfaceBlocks; i++) { + if (!strcmp(shProg->UniformBlocks[i].Name, uniformBlockName)) + return i; + } + + return GL_INVALID_INDEX; +} + void copy_constant_to_storage(union gl_constant_value *storage, const ir_constant *val, const enum glsl_base_type base_type, - const unsigned int elements) + const unsigned int elements, + unsigned int boolean_true) { for (unsigned int i = 0; i < elements; i++) { switch (base_type) { @@ -64,8 +75,13 @@ copy_constant_to_storage(union gl_constant_value *storage, case GLSL_TYPE_FLOAT: storage[i].f = val->value.f[i]; break; + case GLSL_TYPE_DOUBLE: + /* XXX need to check on big-endian */ + storage[i * 2].u = *(uint32_t *)&val->value.d[i]; + storage[i * 2 + 1].u = *(((uint32_t *)&val->value.d[i]) + 1); + break; case GLSL_TYPE_BOOL: - storage[i].b = int(val->value.b[i]); + storage[i].b = val->value.b[i] ? boolean_true : 0; break; case GLSL_TYPE_ARRAY: case GLSL_TYPE_STRUCT: @@ -73,6 +89,7 @@ copy_constant_to_storage(union gl_constant_value *storage, case GLSL_TYPE_ATOMIC_UINT: case GLSL_TYPE_INTERFACE: case GLSL_TYPE_VOID: + case GLSL_TYPE_SUBROUTINE: case GLSL_TYPE_ERROR: /* All other types should have already been filtered by other * paths in the caller. @@ -83,11 +100,16 @@ copy_constant_to_storage(union gl_constant_value *storage, } } +/** + * Initialize an opaque uniform from the value of an explicit binding + * qualifier specified in the shader. Atomic counters are different because + * they have no storage and should be handled elsewhere. + */ void -set_sampler_binding(gl_shader_program *prog, const char *name, int binding) +set_opaque_binding(gl_shader_program *prog, const char *name, int binding) { struct gl_uniform_storage *const storage = - get_storage(prog->UniformStorage, prog->NumUserUniformStorage, name); + get_storage(prog->UniformStorage, prog->NumUniformStorage, name); if (storage == NULL) { assert(storage != NULL); @@ -110,11 +132,20 @@ set_sampler_binding(gl_shader_program *prog, const char *name, int binding) for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) { gl_shader *shader = prog->_LinkedShaders[sh]; - if (shader && storage->sampler[sh].active) { - for (unsigned i = 0; i < elements; i++) { - unsigned index = storage->sampler[sh].index + i; + if (shader) { + if (storage->type->base_type == GLSL_TYPE_SAMPLER && + storage->opaque[sh].active) { + for (unsigned i = 0; i < elements; i++) { + const unsigned index = storage->opaque[sh].index + i; + shader->SamplerUnits[index] = storage->storage[i].i; + } - shader->SamplerUnits[index] = storage->storage[i].i; + } else if (storage->type->base_type == GLSL_TYPE_IMAGE && + storage->opaque[sh].active) { + for (unsigned i = 0; i < elements; i++) { + const unsigned index = storage->opaque[sh].index + i; + shader->ImageUnits[index] = storage->storage[i].i; + } } } } @@ -123,35 +154,30 @@ set_sampler_binding(gl_shader_program *prog, const char *name, int binding) } void -set_block_binding(gl_shader_program *prog, const char *name, int binding) +set_block_binding(gl_shader_program *prog, const char *block_name, int binding) { - struct gl_uniform_storage *const storage = - get_storage(prog->UniformStorage, prog->NumUserUniformStorage, name); + const unsigned block_index = get_uniform_block_index(prog, block_name); - if (storage == NULL) { - assert(storage != NULL); + if (block_index == GL_INVALID_INDEX) { + assert(block_index != GL_INVALID_INDEX); return; } - if (storage->block_index != -1) { /* This is a field of a UBO. val is the binding index. */ for (int i = 0; i < MESA_SHADER_STAGES; i++) { - int stage_index = prog->UniformBlockStageIndex[i][storage->block_index]; + int stage_index = prog->UniformBlockStageIndex[i][block_index]; if (stage_index != -1) { struct gl_shader *sh = prog->_LinkedShaders[i]; sh->UniformBlocks[stage_index].Binding = binding; } } - } - - storage->initialized = true; } void set_uniform_initializer(void *mem_ctx, gl_shader_program *prog, const char *name, const glsl_type *type, - ir_constant *val) + ir_constant *val, unsigned int boolean_true) { if (type->is_record()) { ir_constant *field_constant; @@ -163,7 +189,7 @@ set_uniform_initializer(void *mem_ctx, gl_shader_program *prog, const char *field_name = ralloc_asprintf(mem_ctx, "%s.%s", name, type->fields.structure[i].name); set_uniform_initializer(mem_ctx, prog, field_name, - field_type, field_constant); + field_type, field_constant, boolean_true); field_constant = (ir_constant *)field_constant->next; } return; @@ -174,14 +200,15 @@ set_uniform_initializer(void *mem_ctx, gl_shader_program *prog, const char *element_name = ralloc_asprintf(mem_ctx, "%s[%d]", name, i); set_uniform_initializer(mem_ctx, prog, element_name, - element_type, val->array_elements[i]); + element_type, val->array_elements[i], + boolean_true); } return; } struct gl_uniform_storage *const storage = get_storage(prog->UniformStorage, - prog->NumUserUniformStorage, + prog->NumUniformStorage, name); if (storage == NULL) { assert(storage != NULL); @@ -193,28 +220,31 @@ set_uniform_initializer(void *mem_ctx, gl_shader_program *prog, val->array_elements[0]->type->base_type; const unsigned int elements = val->array_elements[0]->type->components(); unsigned int idx = 0; + unsigned dmul = (base_type == GLSL_TYPE_DOUBLE) ? 2 : 1; assert(val->type->length >= storage->array_elements); for (unsigned int i = 0; i < storage->array_elements; i++) { copy_constant_to_storage(& storage->storage[idx], val->array_elements[i], base_type, - elements); + elements, + boolean_true); - idx += elements; + idx += elements * dmul; } } else { copy_constant_to_storage(storage->storage, val, val->type->base_type, - val->type->components()); + val->type->components(), + boolean_true); if (storage->type->is_sampler()) { for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) { gl_shader *shader = prog->_LinkedShaders[sh]; - if (shader && storage->sampler[sh].active) { - unsigned index = storage->sampler[sh].index; + if (shader && storage->opaque[sh].active) { + unsigned index = storage->opaque[sh].index; shader->SamplerUnits[index] = storage->storage[0].i; } @@ -227,7 +257,8 @@ set_uniform_initializer(void *mem_ctx, gl_shader_program *prog, } void -link_set_uniform_initializers(struct gl_shader_program *prog) +link_set_uniform_initializers(struct gl_shader_program *prog, + unsigned int boolean_true) { void *mem_ctx = NULL; @@ -237,10 +268,11 @@ link_set_uniform_initializers(struct gl_shader_program *prog) if (shader == NULL) continue; - foreach_list(node, shader->ir) { - ir_variable *const var = ((ir_instruction *) node)->as_variable(); + foreach_in_list(ir_instruction, node, shader->ir) { + ir_variable *const var = node->as_variable(); - if (!var || var->data.mode != ir_var_uniform) + if (!var || (var->data.mode != ir_var_uniform && + var->data.mode != ir_var_shader_storage)) continue; if (!mem_ctx) @@ -249,17 +281,55 @@ link_set_uniform_initializers(struct gl_shader_program *prog) if (var->data.explicit_binding) { const glsl_type *const type = var->type; - if (type->is_sampler() - || (type->is_array() && type->fields.array->is_sampler())) { - linker::set_sampler_binding(prog, var->name, var->data.binding); - } else if (var->is_in_uniform_block()) { - linker::set_block_binding(prog, var->name, var->data.binding); + if (type->without_array()->is_sampler() || + type->without_array()->is_image()) { + linker::set_opaque_binding(prog, var->name, var->data.binding); + } else if (var->is_in_buffer_block()) { + const glsl_type *const iface_type = var->get_interface_type(); + + /* If the variable is an array and it is an interface instance, + * we need to set the binding for each array element. Just + * checking that the variable is an array is not sufficient. + * The variable could be an array element of a uniform block + * that lacks an instance name. For example: + * + * uniform U { + * float f[4]; + * }; + * + * In this case "f" would pass is_in_buffer_block (above) and + * type->is_array(), but it will fail is_interface_instance(). + */ + if (var->is_interface_instance() && var->type->is_array()) { + for (unsigned i = 0; i < var->type->length; i++) { + const char *name = + ralloc_asprintf(mem_ctx, "%s[%u]", iface_type->name, i); + + /* Section 4.4.3 (Uniform Block Layout Qualifiers) of the + * GLSL 4.20 spec says: + * + * "If the binding identifier is used with a uniform + * block instanced as an array then the first element + * of the array takes the specified block binding and + * each subsequent element takes the next consecutive + * uniform block binding point." + */ + linker::set_block_binding(prog, name, + var->data.binding + i); + } + } else { + linker::set_block_binding(prog, iface_type->name, + var->data.binding); + } + } else if (type->contains_atomic()) { + /* we don't actually need to do anything. */ } else { - assert(!"Explicit binding not on a sampler or UBO."); + assert(!"Explicit binding not on a sampler, UBO or atomic."); } - } else if (var->constant_value) { + } else if (var->constant_initializer) { linker::set_uniform_initializer(mem_ctx, prog, var->name, - var->type, var->constant_value); + var->type, var->constant_initializer, + boolean_true); } } }