Home | History | Annotate | Download | only in glsl 
      1 /*
      2  * Copyright  2011 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 #ifndef IR_UNIFORM_H
     25 #define IR_UNIFORM_H
     26 
     27 
     28 /* stdbool.h is necessary because this file is included in both C and C++ code.
     29  */
     30 #include <stdbool.h>
     31 
     32 #include "program/prog_parameter.h"  /* For union gl_constant_value. */
     33 
     34 /**
     35  * Used by GL_ARB_explicit_uniform_location extension code in the linker
     36  * and glUniform* functions to identify inactive explicit uniform locations.
     37  */
     38 #define INACTIVE_UNIFORM_EXPLICIT_LOCATION ((gl_uniform_storage *) -1)
     39 
     40 #ifdef __cplusplus
     41 extern "C" {
     42 #endif
     43 
     44 enum PACKED gl_uniform_driver_format {
     45    uniform_native = 0,          /**< Store data in the native format. */
     46    uniform_int_float,           /**< Store integer data as floats. */
     47 };
     48 
     49 struct gl_uniform_driver_storage {
     50    /**
     51     * Number of bytes from one array element to the next.
     52     */
     53    uint8_t element_stride;
     54 
     55    /**
     56     * Number of bytes from one vector in a matrix to the next.
     57     */
     58    uint8_t vector_stride;
     59 
     60    /**
     61     * Base format of the stored data.
     62     */
     63    enum gl_uniform_driver_format format;
     64 
     65    /**
     66     * Pointer to the base of the data.
     67     */
     68    void *data;
     69 };
     70 
     71 struct gl_opaque_uniform_index {
     72    /**
     73     * Base opaque uniform index
     74     *
     75     * If \c gl_uniform_storage::base_type is an opaque type, this
     76     * represents its uniform index.  If \c
     77     * gl_uniform_storage::array_elements is not zero, the array will
     78     * use opaque uniform indices \c index through \c index + \c
     79     * gl_uniform_storage::array_elements - 1, inclusive.
     80     *
     81     * Note that the index may be different in each shader stage.
     82     */
     83    uint8_t index;
     84 
     85    /**
     86     * Whether this opaque uniform is used in this shader stage.
     87     */
     88    bool active;
     89 };
     90 
     91 struct gl_uniform_storage {
     92    char *name;
     93    /** Type of this uniform data stored.
     94     *
     95     * In the case of an array, it's the type of a single array element.
     96     */
     97    const struct glsl_type *type;
     98 
     99    /**
    100     * The number of elements in this uniform.
    101     *
    102     * For non-arrays, this is always 0.  For arrays, the value is the size of
    103     * the array.
    104     */
    105    unsigned array_elements;
    106 
    107    struct gl_opaque_uniform_index opaque[MESA_SHADER_STAGES];
    108 
    109    /**
    110     * Mask of shader stages (1 << MESA_SHADER_xxx) where this uniform is used.
    111     */
    112    unsigned active_shader_mask;
    113 
    114    /**
    115     * Storage used by the driver for the uniform
    116     */
    117    unsigned num_driver_storage;
    118    struct gl_uniform_driver_storage *driver_storage;
    119 
    120    /**
    121     * Storage used by Mesa for the uniform
    122     *
    123     * This form of the uniform is used by Mesa's implementation of \c
    124     * glGetUniform.  It can also be used by drivers to obtain the value of the
    125     * uniform if the \c ::driver_storage interface is not used.
    126     */
    127    union gl_constant_value *storage;
    128 
    129    /** Fields for GL_ARB_uniform_buffer_object
    130     * @{
    131     */
    132 
    133    /**
    134     * GL_UNIFORM_BLOCK_INDEX: index of the uniform block containing
    135     * the uniform, or -1 for the default uniform block.  Note that the
    136     * index is into the linked program's UniformBlocks[] array, not
    137     * the linked shader's.
    138     */
    139    int block_index;
    140 
    141    /** GL_UNIFORM_OFFSET: byte offset within the uniform block, or -1. */
    142    int offset;
    143 
    144    /**
    145     * GL_UNIFORM_MATRIX_STRIDE: byte stride between columns or rows of
    146     * a matrix.  Set to 0 for non-matrices in UBOs, or -1 for uniforms
    147     * in the default uniform block.
    148     */
    149    int matrix_stride;
    150 
    151    /**
    152     * GL_UNIFORM_ARRAY_STRIDE: byte stride between elements of the
    153     * array.  Set to zero for non-arrays in UBOs, or -1 for uniforms
    154     * in the default uniform block.
    155     */
    156    int array_stride;
    157 
    158    /** GL_UNIFORM_ROW_MAJOR: true iff it's a row-major matrix in a UBO */
    159    bool row_major;
    160 
    161    /** @} */
    162 
    163    /**
    164     * This is a compiler-generated uniform that should not be advertised
    165     * via the API.
    166     */
    167    bool hidden;
    168 
    169    /**
    170     * This is a built-in uniform that should not be modified through any gl API.
    171     */
    172    bool builtin;
    173 
    174    /**
    175     * This is a shader storage buffer variable, not an uniform.
    176     */
    177    bool is_shader_storage;
    178 
    179    /**
    180     * Index within gl_shader_program::AtomicBuffers[] of the atomic
    181     * counter buffer this uniform is stored in, or -1 if this is not
    182     * an atomic counter.
    183     */
    184    int atomic_buffer_index;
    185 
    186    /**
    187     * The 'base location' for this uniform in the uniform remap table. For
    188     * arrays this is the first element in the array.
    189     * for subroutines this is in shader subroutine uniform remap table.
    190     */
    191    unsigned remap_location;
    192 
    193    /**
    194     * The number of compatible subroutines with this subroutine uniform.
    195     */
    196    unsigned num_compatible_subroutines;
    197 
    198    /**
    199     * A single integer identifying the number of active array elements of
    200     * the top-level shader storage block member (GL_TOP_LEVEL_ARRAY_SIZE).
    201     */
    202    unsigned top_level_array_size;
    203 
    204    /**
    205     * A single integer identifying the stride between array elements of the
    206     * top-level shader storage block member. (GL_TOP_LEVEL_ARRAY_STRIDE).
    207     */
    208    unsigned top_level_array_stride;
    209 
    210    /**
    211     * Whether this uniform variable has the bindless_sampler or bindless_image
    212     * layout qualifier as specified by ARB_bindless_texture.
    213     */
    214    bool is_bindless;
    215 };
    216 
    217 #ifdef __cplusplus
    218 }
    219 #endif
    220 
    221 #endif /* IR_UNIFORM_H */
    222