src/glsl/link_uniform_initializers.cpp

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "main/core.h"
  25 #include "ir.h"
  26 #include "linker.h"
  27 #include "ir_uniform.h"
  28 #include "glsl_symbol_table.h"
  29 #include "program/hash_table.h"
  30
  31 /* These functions are put in a "private" namespace instead of being marked
  32  * static so that the unit tests can access them.  See
  33  * http://code.google.com/p/googletest/wiki/AdvancedGuide#Testing_Private_Code
  34  */
  35 namespace linker {
  36
  37 gl_uniform_storage *
  38 get_storage(gl_uniform_storage *storage, unsigned num_storage,
  39             const char *name)
  40 {
  41    for (unsigned int i = 0; i < num_storage; i++) {
  42       if (strcmp(name, storage[i].name) == 0)
  43          return &storage[i];
  44    }
  45
  46    return NULL;
  47 }
  48
  49 void
  50 copy_constant_to_storage(union gl_constant_value *storage,
  51                          const ir_constant *val,
  52                          const enum glsl_base_type base_type,
  53                          const unsigned int elements)
  54 {
  55    for (unsigned int i = 0; i < elements; i++) {
  56       switch (base_type) {
  57       case GLSL_TYPE_UINT:
  58          storage[i].u = val->value.u[i];
  59          break;
  60       case GLSL_TYPE_INT:
  61       case GLSL_TYPE_SAMPLER:
  62          storage[i].i = val->value.i[i];
  63          break;
  64       case GLSL_TYPE_FLOAT:
  65          storage[i].f = val->value.f[i];
  66          break;
  67       case GLSL_TYPE_BOOL:
  68          storage[i].b = int(val->value.b[i]);
  69          break;
  70       case GLSL_TYPE_ARRAY:
  71       case GLSL_TYPE_STRUCT:
  72       case GLSL_TYPE_VOID:
  73       case GLSL_TYPE_ERROR:
  74          /* All other types should have already been filtered by other
  75           * paths in the caller.
  76           */
  77          assert(!"Should not get here.");
  78          break;
  79       }
  80    }
  81 }
  82
  83 void
  84 set_uniform_initializer(void *mem_ctx, gl_shader_program *prog,
  85                         const char *name, const glsl_type *type,
  86                         ir_constant *val)
  87 {
  88    if (type->is_record()) {
  89       ir_constant *field_constant;
  90
  91       field_constant = (ir_constant *)val->components.get_head();
  92
  93       for (unsigned int i = 0; i < type->length; i++) {
  94          const glsl_type *field_type = type->fields.structure[i].type;
  95          const char *field_name = ralloc_asprintf(mem_ctx, "%s.%s", name,
  96                                             type->fields.structure[i].name);
  97          set_uniform_initializer(mem_ctx, prog, field_name,
  98                                  field_type, field_constant);
  99          field_constant = (ir_constant *)field_constant->next;
 100       }
 101       return;
 102    } else if (type->is_array() && type->fields.array->is_record()) {
 103       const glsl_type *const element_type = type->fields.array;
 104
 105       for (unsigned int i = 0; i < type->length; i++) {
 106          const char *element_name = ralloc_asprintf(mem_ctx, "%s[%d]", name, i);
 107
 108          set_uniform_initializer(mem_ctx, prog, element_name,
 109                                  element_type, val->array_elements[i]);
 110       }
 111       return;
 112    }
 113
 114    struct gl_uniform_storage *const storage =
 115       get_storage(prog->UniformStorage,
 116                   prog->NumUserUniformStorage,
 117                   name);
 118    if (storage == NULL) {
 119       assert(storage != NULL);
 120       return;
 121    }
 122
 123    if (val->type->is_array()) {
 124       const enum glsl_base_type base_type =
 125          val->array_elements[0]->type->base_type;
 126       const unsigned int elements = val->array_elements[0]->type->components();
 127       unsigned int idx = 0;
 128
 129       assert(val->type->length >= storage->array_elements);
 130       for (unsigned int i = 0; i < storage->array_elements; i++) {
 131          copy_constant_to_storage(& storage->storage[idx],
 132                                   val->array_elements[i],
 133                                   base_type,
 134                                   elements);
 135
 136          idx += elements;
 137       }
 138
 139       if (base_type == GLSL_TYPE_SAMPLER) {
 140          for (unsigned int i = 0; i < storage->array_elements; i++) {
 141             prog->SamplerUnits[storage->sampler + i] = storage->storage[i].i;
 142          }
 143       }
 144    } else {
 145       copy_constant_to_storage(storage->storage,
 146                                val,
 147                                val->type->base_type,
 148                                val->type->components());
 149
 150       if (storage->type->is_sampler())
 151          prog->SamplerUnits[storage->sampler] = storage->storage[0].i;
 152    }
 153
 154    storage->initialized = true;
 155 }
 156 }
 157
 158 void
 159 link_set_uniform_initializers(struct gl_shader_program *prog)
 160 {
 161    void *mem_ctx = NULL;
 162
 163    for (unsigned int i = 0; i < MESA_SHADER_TYPES; i++) {
 164       struct gl_shader *shader = prog->_LinkedShaders[i];
 165
 166       if (shader == NULL)
 167          continue;
 168
 169       foreach_list(node, shader->ir) {
 170          ir_variable *const var = ((ir_instruction *) node)->as_variable();
 171
 172          if (!var || var->mode != ir_var_uniform || !var->constant_value)
 173             continue;
 174
 175          if (!mem_ctx)
 176             mem_ctx = ralloc_context(NULL);
 177
 178          linker::set_uniform_initializer(mem_ctx, prog, var->name,
 179                                          var->type, var->constant_value);
 180       }
 181    }
 182
 183    ralloc_free(mem_ctx);
 184 }