Subversion Repositories Kolibri OS

/*

 * Copyright © 2012 Intel Corporation

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 */

#include "main/core.h"

#include "ir.h"

#include "linker.h"

#include "ir_uniform.h"

#include "link_uniform_block_active_visitor.h"

#include "main/hash_table.h"

#include "program.h"

class ubo_visitor : public program_resource_visitor {

public:

   ubo_visitor(void *mem_ctx, gl_uniform_buffer_variable *variables,

               unsigned num_variables)

      : index(0), offset(0), buffer_size(0), variables(variables),

        num_variables(num_variables), mem_ctx(mem_ctx), is_array_instance(false)

   {

      /* empty */

   }

   void process(const glsl_type *type, const char *name)

   {

      this->offset = 0;

      this->buffer_size = 0;

      this->is_array_instance = strchr(name, ']') != NULL;

      this->program_resource_visitor::process(type, name);

   }

   unsigned index;

   unsigned offset;

   unsigned buffer_size;

   gl_uniform_buffer_variable *variables;

   unsigned num_variables;

   void *mem_ctx;

   bool is_array_instance;

private:

   virtual void visit_field(const glsl_type *type, const char *name,

                            bool row_major)

   {

      (void) type;

      (void) name;

      (void) row_major;

      assert(!"Should not get here.");

   }

   virtual void visit_field(const glsl_type *type, const char *name,

                            bool row_major, const glsl_type *record_type)

   {

      assert(this->index < this->num_variables);

      gl_uniform_buffer_variable *v = &this->variables[this->index++];

      v->Name = ralloc_strdup(mem_ctx, name);

      v->Type = type;

      v->RowMajor = row_major;

      if (this->is_array_instance) {

         v->IndexName = ralloc_strdup(mem_ctx, name);

         char *open_bracket = strchr(v->IndexName, '[');

         assert(open_bracket != NULL);

         char *close_bracket = strchr(open_bracket, ']');

         assert(close_bracket != NULL);

         /* Length of the tail without the ']' but with the NUL.

          */

         unsigned len = strlen(close_bracket + 1) + 1;

         memmove(open_bracket, close_bracket + 1, len);

     } else {

         v->IndexName = v->Name;

      }

      const unsigned alignment = record_type

	 ? record_type->std140_base_alignment(v->RowMajor)

	 : type->std140_base_alignment(v->RowMajor);

      unsigned size = type->std140_size(v->RowMajor);

      this->offset = glsl_align(this->offset, alignment);

      v->Offset = this->offset;

      this->offset += size;

      /* From the GL_ARB_uniform_buffer_object spec:

       *

       *     "For uniform blocks laid out according to [std140] rules, the

       *      minimum buffer object size returned by the

       *      UNIFORM_BLOCK_DATA_SIZE query is derived by taking the offset of

       *      the last basic machine unit consumed by the last uniform of the

       *      uniform block (including any end-of-array or end-of-structure

       *      padding), adding one, and rounding up to the next multiple of

       *      the base alignment required for a vec4."

       */

      this->buffer_size = glsl_align(this->offset, 16);

   }

   virtual void visit_field(const glsl_struct_field *field)

   {

      /* FINISHME: When support for doubles (dvec4, etc.) is added to the

       * FINISHME: compiler, this may be incorrect for a structure in a UBO

       * FINISHME: like struct s { struct { float f } s1; dvec4 v; };.

       */

      this->offset = glsl_align(this->offset,

                                field->type->std140_base_alignment(false));

   }

};

class count_block_size : public program_resource_visitor {

public:

   count_block_size() : num_active_uniforms(0)

   {

      /* empty */

   }

   unsigned num_active_uniforms;

private:

   virtual void visit_field(const glsl_type *type, const char *name,

                            bool row_major)

   {

      (void) type;

      (void) name;

      (void) row_major;

      this->num_active_uniforms++;

   }

};

struct block {

   const glsl_type *type;

   bool has_instance_name;

};

int

link_uniform_blocks(void *mem_ctx,

                    struct gl_shader_program *prog,

                    struct gl_shader **shader_list,

                    unsigned num_shaders,

                    struct gl_uniform_block **blocks_ret)

{

   /* This hash table will track all of the uniform blocks that have been

    * encountered.  Since blocks with the same block-name must be the same,

    * the hash is organized by block-name.

    */

   struct hash_table *block_hash =

      _mesa_hash_table_create(mem_ctx, _mesa_key_string_equal);

   /* Determine which uniform blocks are active.

    */

   link_uniform_block_active_visitor v(mem_ctx, block_hash, prog);

   for (unsigned i = 0; i < num_shaders; i++) {

      visit_list_elements(&v, shader_list[i]->ir);

   }

   /* Count the number of active uniform blocks.  Count the total number of

    * active slots in those uniform blocks.

    */

   unsigned num_blocks = 0;

   unsigned num_variables = 0;

   count_block_size block_size;

   struct hash_entry *entry;

   hash_table_foreach (block_hash, entry) {

      const struct link_uniform_block_active *const b =

         (const struct link_uniform_block_active *) entry->data;

      const glsl_type *const block_type =

         b->type->is_array() ? b->type->fields.array : b->type;

      assert((b->num_array_elements > 0) == b->type->is_array());

      block_size.num_active_uniforms = 0;

      block_size.process(block_type, "");

      if (b->num_array_elements > 0) {

         num_blocks += b->num_array_elements;

         num_variables += b->num_array_elements

            * block_size.num_active_uniforms;

      } else {

         num_blocks++;

         num_variables += block_size.num_active_uniforms;

      }

   }

   if (num_blocks == 0) {

      assert(num_variables == 0);

      _mesa_hash_table_destroy(block_hash, NULL);

      return 0;

   }

   assert(num_variables != 0);

   /* Allocate storage to hold all of the informatation related to uniform

    * blocks that can be queried through the API.

    */

   gl_uniform_block *blocks =

      ralloc_array(mem_ctx, gl_uniform_block, num_blocks);

   gl_uniform_buffer_variable *variables =

      ralloc_array(blocks, gl_uniform_buffer_variable, num_variables);

   /* Add each variable from each uniform block to the API tracking

    * structures.

    */

   unsigned i = 0;

   ubo_visitor parcel(blocks, variables, num_variables);

   STATIC_ASSERT(unsigned(GLSL_INTERFACE_PACKING_STD140)

                 == unsigned(ubo_packing_std140));

   STATIC_ASSERT(unsigned(GLSL_INTERFACE_PACKING_SHARED)

                 == unsigned(ubo_packing_shared));

   STATIC_ASSERT(unsigned(GLSL_INTERFACE_PACKING_PACKED)

                 == unsigned(ubo_packing_packed));

   hash_table_foreach (block_hash, entry) {

      const struct link_uniform_block_active *const b =

         (const struct link_uniform_block_active *) entry->data;

      const glsl_type *block_type = b->type;

      if (b->num_array_elements > 0) {

         const char *const name = block_type->fields.array->name;

         assert(b->has_instance_name);

         for (unsigned j = 0; j < b->num_array_elements; j++) {

            blocks[i].Name = ralloc_asprintf(blocks, "%s[%u]", name,

                                             b->array_elements[j]);

            blocks[i].Uniforms = &variables[parcel.index];

            blocks[i].Binding = 0;

            blocks[i].UniformBufferSize = 0;

            blocks[i]._Packing =

               gl_uniform_block_packing(block_type->interface_packing);

            parcel.process(block_type->fields.array,

                           blocks[i].Name);

            blocks[i].UniformBufferSize = parcel.buffer_size;

            blocks[i].NumUniforms =

               (unsigned)(ptrdiff_t)(&variables[parcel.index] - blocks[i].Uniforms);

            i++;

         }

      } else {

         blocks[i].Name = ralloc_strdup(blocks, block_type->name);

         blocks[i].Uniforms = &variables[parcel.index];

         blocks[i].Binding = 0;

         blocks[i].UniformBufferSize = 0;

         blocks[i]._Packing =

            gl_uniform_block_packing(block_type->interface_packing);

         parcel.process(block_type,

                        b->has_instance_name ? block_type->name : "");

         blocks[i].UniformBufferSize = parcel.buffer_size;

         blocks[i].NumUniforms =

            (unsigned)(ptrdiff_t)(&variables[parcel.index] - blocks[i].Uniforms);

         i++;

      }

   }

   assert(parcel.index == num_variables);

   _mesa_hash_table_destroy(block_hash, NULL);

   *blocks_ret = blocks;

   return num_blocks;

}

bool

link_uniform_blocks_are_compatible(const gl_uniform_block *a,

				   const gl_uniform_block *b)

{

   assert(strcmp(a->Name, b->Name) == 0);

   /* Page 35 (page 42 of the PDF) in section 4.3.7 of the GLSL 1.50 spec says:

    *

    *     "Matched block names within an interface (as defined above) must

    *     match in terms of having the same number of declarations with the

    *     same sequence of types and the same sequence of member names, as

    *     well as having the same member-wise layout qualification....if a

    *     matching block is declared as an array, then the array sizes must

    *     also match... Any mismatch will generate a link error."

    *

    * Arrays are not yet supported, so there is no check for that.

    */

   if (a->NumUniforms != b->NumUniforms)

      return false;

   if (a->_Packing != b->_Packing)

      return false;

   for (unsigned i = 0; i < a->NumUniforms; i++) {

      if (strcmp(a->Uniforms[i].Name, b->Uniforms[i].Name) != 0)

	 return false;

      if (a->Uniforms[i].Type != b->Uniforms[i].Type)

	 return false;

      if (a->Uniforms[i].RowMajor != b->Uniforms[i].RowMajor)

	 return false;

   }

   return true;

}