X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Flink_uniform_initializers.cpp;h=c6fe6a9ad679535106dd9466d98499ff85a1617f;hb=51b38106d74b1bd4fa2ce552f489c374bdffa812;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..c6fe6a9ad67 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,6 +44,18 @@ 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->NumUniformBlocks; 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,
@@ -123,29 +133,24 @@ 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
@@ -237,8 +242,8 @@ 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)
 	    continue;
@@ -253,9 +258,46 @@ link_set_uniform_initializers(struct gl_shader_program *prog)
                 || (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);
+               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_uniform_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) {
             linker::set_uniform_initializer(mem_ctx, prog, var->name,