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       default:
  71          /* All other types should have already been filtered by other
  72           * paths in the caller.
  73           */
  74          assert(!"Should not get here.");
  75          break;
  76       }
  77    }
  78 }
  79
  80 void
  81 set_uniform_initializer(void *mem_ctx, gl_shader_program *prog,
  82                         const char *name, const glsl_type *type,
  83                         ir_constant *val)
  84 {
  85    if (type->is_record()) {
  86       ir_constant *field_constant;
  87
  88       field_constant = (ir_constant *)val->components.get_head();
  89
  90       for (unsigned int i = 0; i < type->length; i++) {
  91          const glsl_type *field_type = type->fields.structure[i].type;
  92          const char *field_name = ralloc_asprintf(mem_ctx, "%s.%s", name,
  93                                             type->fields.structure[i].name);
  94          set_uniform_initializer(mem_ctx, prog, field_name,
  95                                  field_type, field_constant);
  96          field_constant = (ir_constant *)field_constant->next;
  97       }
  98       return;
  99    } else if (type->is_array() && type->fields.array->is_record()) {
 100       const glsl_type *const element_type = type->fields.array;
 101
 102       for (unsigned int i = 0; i < type->length; i++) {
 103          const char *element_name = ralloc_asprintf(mem_ctx, "%s[%d]", name, i);
 104
 105          set_uniform_initializer(mem_ctx, prog, element_name,
 106                                  element_type, val->array_elements[i]);
 107       }
 108       return;
 109    }
 110
 111    struct gl_uniform_storage *const storage =
 112       get_storage(prog->UniformStorage,
 113                   prog->NumUserUniformStorage,
 114                   name);
 115    if (storage == NULL) {
 116       assert(storage != NULL);
 117       return;
 118    }
 119
 120    if (val->type->is_array()) {
 121       const enum glsl_base_type base_type =
 122          val->array_elements[0]->type->base_type;
 123       const unsigned int elements = val->array_elements[0]->type->components();
 124       unsigned int idx = 0;
 125
 126       assert(val->type->length >= storage->array_elements);
 127       for (unsigned int i = 0; i < storage->array_elements; i++) {
 128          copy_constant_to_storage(& storage->storage[idx],
 129                                   val->array_elements[i],
 130                                   base_type,
 131                                   elements);
 132
 133          idx += elements;
 134       }
 135
 136       if (base_type == GLSL_TYPE_SAMPLER) {
 137          for (unsigned int i = 0; i < storage->array_elements; i++) {
 138             prog->SamplerUnits[storage->sampler + i] = storage->storage[i].i;
 139          }
 140       }
 141    } else {
 142       copy_constant_to_storage(storage->storage,
 143                                val,
 144                                val->type->base_type,
 145                                val->type->components());
 146
 147       if (storage->type->is_sampler())
 148          prog->SamplerUnits[storage->sampler] = storage->storage[0].i;
 149    }
 150
 151    storage->initialized = true;
 152 }
 153 }
 154
 155 void
 156 link_set_uniform_initializers(struct gl_shader_program *prog)
 157 {
 158    void *mem_ctx = NULL;
 159
 160    for (unsigned int i = 0; i < MESA_SHADER_TYPES; i++) {
 161       struct gl_shader *shader = prog->_LinkedShaders[i];
 162
 163       if (shader == NULL)
 164          continue;
 165
 166       foreach_list(node, shader->ir) {
 167          ir_variable *const var = ((ir_instruction *) node)->as_variable();
 168
 169          if (!var || var->mode != ir_var_uniform || !var->constant_value)
 170             continue;
 171
 172          if (!mem_ctx)
 173             mem_ctx = ralloc_context(NULL);
 174
 175          linker::set_uniform_initializer(mem_ctx, prog, var->name,
 176                                          var->type, var->constant_value);
 177       }
 178    }
 179
 180    ralloc_free(mem_ctx);
 181 }