#include "ir_uniform.h"
#include "glsl_symbol_table.h"
#include "program.h"
-#include "util/string_to_uint_map.h"
+#include "string_to_uint_map.h"
#include "ir_array_refcount.h"
/**
*/
#define UNMAPPED_UNIFORM_LOC ~0u
-/**
- * Count the backing storage requirements for a type
- */
-static unsigned
-values_for_type(const glsl_type *type)
-{
- if (type->is_sampler()) {
- return 1;
- } else if (type->is_array() && type->fields.array->is_sampler()) {
- return type->array_size();
- } else {
- return type->component_slots();
- }
-}
-
void
-program_resource_visitor::process(const glsl_type *type, const char *name)
+program_resource_visitor::process(const glsl_type *type, const char *name,
+ bool use_std430_as_default)
{
assert(type->without_array()->is_record()
|| type->without_array()->is_interface());
unsigned record_array_count = 1;
char *name_copy = ralloc_strdup(NULL, name);
- enum glsl_interface_packing packing = type->get_interface_packing();
+
+ enum glsl_interface_packing packing =
+ type->get_internal_ifc_packing(use_std430_as_default);
recursion(type, &name_copy, strlen(name), false, NULL, packing, false,
record_array_count, NULL);
}
void
-program_resource_visitor::process(ir_variable *var)
+program_resource_visitor::process(ir_variable *var, bool use_std430_as_default)
{
unsigned record_array_count = 1;
const bool row_major =
var->data.matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR;
- const enum glsl_interface_packing packing = var->get_interface_type() ?
- var->get_interface_type_packing() :
- var->type->get_interface_packing();
+ enum glsl_interface_packing packing = var->get_interface_type() ?
+ var->get_interface_type()->
+ get_internal_ifc_packing(use_std430_as_default) :
+ var->type->get_internal_ifc_packing(use_std430_as_default);
const glsl_type *t =
var->data.from_named_ifc_block ? var->get_interface_type() : var->type;
const char *field = t->fields.structure[i].name;
size_t new_length = name_length;
- if (t->fields.structure[i].type->is_record())
- this->visit_field(&t->fields.structure[i]);
-
if (t->is_interface() && t->fields.structure[i].offset != -1)
this->set_buffer_offset(t->fields.structure[i].offset);
}
}
-void
-program_resource_visitor::visit_field(const glsl_struct_field *)
-{
-}
-
void
program_resource_visitor::enter_record(const glsl_type *, const char *, bool,
const enum glsl_interface_packing)
class count_uniform_size : public program_resource_visitor {
public:
count_uniform_size(struct string_to_uint_map *map,
- struct string_to_uint_map *hidden_map)
+ struct string_to_uint_map *hidden_map,
+ bool use_std430_as_default)
: num_active_uniforms(0), num_hidden_uniforms(0), num_values(0),
num_shader_samplers(0), num_shader_images(0),
num_shader_uniform_components(0), num_shader_subroutines(0),
is_buffer_block(false), is_shader_storage(false), map(map),
- hidden_map(hidden_map)
+ hidden_map(hidden_map), current_var(NULL),
+ use_std430_as_default(use_std430_as_default)
{
/* empty */
}
this->is_shader_storage = var->is_in_shader_storage_block();
if (var->is_interface_instance())
program_resource_visitor::process(var->get_interface_type(),
- var->get_interface_type()->name);
+ var->get_interface_type()->name,
+ use_std430_as_default);
else
- program_resource_visitor::process(var);
+ program_resource_visitor::process(var, use_std430_as_default);
}
/**
* uniform for multiple shader targets, but in this case we want to
* count it for each shader target.
*/
- const unsigned values = values_for_type(type);
+ const unsigned values = type->component_slots();
if (type->contains_subroutine()) {
this->num_shader_subroutines += values;
- } else if (type->contains_sampler()) {
- this->num_shader_samplers += values;
- } else if (type->contains_image()) {
- this->num_shader_images += values;
+ } else if (type->contains_sampler() && !current_var->data.bindless) {
+ /* Samplers (bound or bindless) are counted as two components as
+ * specified by ARB_bindless_texture. */
+ this->num_shader_samplers += values / 2;
+ } else if (type->contains_image() && !current_var->data.bindless) {
+ /* Images (bound or bindless) are counted as two components as
+ * specified by ARB_bindless_texture. */
+ this->num_shader_images += values / 2;
/* As drivers are likely to represent image uniforms as
* scalar indices, count them against the limit of uniform
* Current variable being processed.
*/
ir_variable *current_var;
+
+ bool use_std430_as_default;
};
} /* anonymous namespace */
+unsigned
+link_calculate_matrix_stride(const glsl_type *matrix, bool row_major,
+ enum glsl_interface_packing packing)
+{
+ const unsigned N = matrix->is_double() ? 8 : 4;
+ const unsigned items =
+ row_major ? matrix->matrix_columns : matrix->vector_elements;
+
+ assert(items <= 4);
+
+ /* Matrix stride for std430 mat2xY matrices are not rounded up to
+ * vec4 size.
+ *
+ * Section 7.6.2.2 "Standard Uniform Block Layout" of the OpenGL 4.3 spec
+ * says:
+ *
+ * 2. If the member is a two- or four-component vector with components
+ * consuming N basic machine units, the base alignment is 2N or 4N,
+ * respectively.
+ * ...
+ * 4. If the member is an array of scalars or vectors, the base
+ * alignment and array stride are set to match the base alignment of
+ * a single array element, according to rules (1), (2), and (3), and
+ * rounded up to the base alignment of a vec4.
+ * ...
+ * 7. If the member is a row-major matrix with C columns and R rows, the
+ * matrix is stored identically to an array of R row vectors with C
+ * components each, according to rule (4).
+ * ...
+ *
+ * When using the std430 storage layout, shader storage blocks will be
+ * laid out in buffer storage identically to uniform and shader storage
+ * blocks using the std140 layout, except that the base alignment and
+ * stride of arrays of scalars and vectors in rule 4 and of structures
+ * in rule 9 are not rounded up a multiple of the base alignment of a
+ * vec4.
+ */
+ return packing == GLSL_INTERFACE_PACKING_STD430
+ ? (items < 3 ? items * N : glsl_align(items * N, 16))
+ : glsl_align(items * N, 16);
+}
+
/**
* Class to help parcel out pieces of backing storage to uniforms
*
parcel_out_uniform_storage(struct gl_shader_program *prog,
struct string_to_uint_map *map,
struct gl_uniform_storage *uniforms,
- union gl_constant_value *values)
- : prog(prog), map(map), uniforms(uniforms), values(values)
+ union gl_constant_value *values,
+ bool use_std430_as_default)
+ : prog(prog), map(map), uniforms(uniforms),
+ use_std430_as_default(use_std430_as_default), values(values),
+ bindless_targets(NULL), bindless_access(NULL)
+ {
+ }
+
+ virtual ~parcel_out_uniform_storage()
{
+ free(this->bindless_targets);
+ free(this->bindless_access);
}
void start_shader(gl_shader_stage shader_type)
this->next_subroutine = 0;
this->record_array_count = 1;
memset(this->targets, 0, sizeof(this->targets));
+
+ this->num_bindless_samplers = 0;
+ this->next_bindless_sampler = 0;
+ free(this->bindless_targets);
+ this->bindless_targets = NULL;
+
+ this->num_bindless_images = 0;
+ this->next_bindless_image = 0;
+ free(this->bindless_access);
+ this->bindless_access = NULL;
}
void set_and_process(ir_variable *var)
current_var = var;
field_counter = 0;
this->record_next_sampler = new string_to_uint_map;
+ this->record_next_bindless_sampler = new string_to_uint_map;
+ this->record_next_image = new string_to_uint_map;
+ this->record_next_bindless_image = new string_to_uint_map;
buffer_block_index = -1;
if (var->is_in_buffer_block()) {
if (var->is_interface_instance()) {
ubo_byte_offset = 0;
process(var->get_interface_type(),
- var->get_interface_type()->name);
+ var->get_interface_type()->name,
+ use_std430_as_default);
} else {
const struct gl_uniform_block *const block =
&blks[buffer_block_index];
&block->Uniforms[var->data.location];
ubo_byte_offset = ubo_var->Offset;
- process(var);
+ process(var, use_std430_as_default);
}
} else {
/* Store any explicit location and reset data location so we can
this->explicit_location = current_var->data.location;
current_var->data.location = -1;
- process(var);
+ process(var, use_std430_as_default);
}
delete this->record_next_sampler;
+ delete this->record_next_bindless_sampler;
+ delete this->record_next_image;
+ delete this->record_next_bindless_image;
}
int buffer_block_index;
gl_shader_stage shader_type;
private:
+ bool set_opaque_indices(const glsl_type *base_type,
+ struct gl_uniform_storage *uniform,
+ const char *name, unsigned &next_index,
+ struct string_to_uint_map *record_next_index)
+ {
+ assert(base_type->is_sampler() || base_type->is_image());
+
+ if (this->record_array_count > 1) {
+ unsigned inner_array_size = MAX2(1, uniform->array_elements);
+ char *name_copy = ralloc_strdup(NULL, name);
+
+ /* Remove all array subscripts from the sampler/image name */
+ char *str_start;
+ const char *str_end;
+ while((str_start = strchr(name_copy, '[')) &&
+ (str_end = strchr(name_copy, ']'))) {
+ memmove(str_start, str_end + 1, 1 + strlen(str_end + 1));
+ }
+
+ unsigned index = 0;
+ if (record_next_index->get(index, name_copy)) {
+ /* In this case, we've already seen this uniform so we just use the
+ * next sampler/image index recorded the last time we visited.
+ */
+ uniform->opaque[shader_type].index = index;
+ index = inner_array_size + uniform->opaque[shader_type].index;
+ record_next_index->put(index, name_copy);
+
+ ralloc_free(name_copy);
+ /* Return as everything else has already been initialised in a
+ * previous pass.
+ */
+ return false;
+ } else {
+ /* We've never seen this uniform before so we need to allocate
+ * enough indices to store it.
+ *
+ * Nested struct arrays behave like arrays of arrays so we need to
+ * increase the index by the total number of elements of the
+ * sampler/image in case there is more than one sampler/image
+ * inside the structs. This allows the offset to be easily
+ * calculated for indirect indexing.
+ */
+ uniform->opaque[shader_type].index = next_index;
+ next_index += inner_array_size * this->record_array_count;
+
+ /* Store the next index for future passes over the struct array
+ */
+ index = uniform->opaque[shader_type].index + inner_array_size;
+ record_next_index->put(index, name_copy);
+ ralloc_free(name_copy);
+ }
+ } else {
+ /* Increment the sampler/image by 1 for non-arrays and by the number
+ * of array elements for arrays.
+ */
+ uniform->opaque[shader_type].index = next_index;
+ next_index += MAX2(1, uniform->array_elements);
+ }
+ return true;
+ }
+
void handle_samplers(const glsl_type *base_type,
struct gl_uniform_storage *uniform, const char *name)
{
if (base_type->is_sampler()) {
uniform->opaque[shader_type].active = true;
- /* Handle multiple samplers inside struct arrays */
- if (this->record_array_count > 1) {
- unsigned inner_array_size = MAX2(1, uniform->array_elements);
- char *name_copy = ralloc_strdup(NULL, name);
-
- /* Remove all array subscripts from the sampler name */
- char *str_start;
- const char *str_end;
- while((str_start = strchr(name_copy, '[')) &&
- (str_end = strchr(name_copy, ']'))) {
- memmove(str_start, str_end + 1, 1 + strlen(str_end));
- }
-
- unsigned index = 0;
- if (this->record_next_sampler->get(index, name_copy)) {
- /* In this case, we've already seen this uniform so we just use
- * the next sampler index recorded the last time we visited.
- */
- uniform->opaque[shader_type].index = index;
- index = inner_array_size + uniform->opaque[shader_type].index;
- this->record_next_sampler->put(index, name_copy);
+ const gl_texture_index target = base_type->sampler_index();
+ const unsigned shadow = base_type->sampler_shadow;
- ralloc_free(name_copy);
- /* Return as everything else has already been initialised in a
- * previous pass.
- */
+ if (current_var->data.bindless) {
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_bindless_sampler,
+ this->record_next_bindless_sampler))
return;
- } else {
- /* We've never seen this uniform before so we need to allocate
- * enough indices to store it.
- *
- * Nested struct arrays behave like arrays of arrays so we need
- * to increase the index by the total number of elements of the
- * sampler in case there is more than one sampler inside the
- * structs. This allows the offset to be easily calculated for
- * indirect indexing.
- */
- uniform->opaque[shader_type].index = this->next_sampler;
- this->next_sampler +=
- inner_array_size * this->record_array_count;
- /* Store the next index for future passes over the struct array
- */
- index = uniform->opaque[shader_type].index + inner_array_size;
- this->record_next_sampler->put(index, name_copy);
- ralloc_free(name_copy);
+ this->num_bindless_samplers = this->next_bindless_sampler;
+
+ this->bindless_targets = (gl_texture_index *)
+ realloc(this->bindless_targets,
+ this->num_bindless_samplers * sizeof(gl_texture_index));
+
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < this->num_bindless_samplers;
+ i++) {
+ this->bindless_targets[i] = target;
}
} else {
- /* Increment the sampler by 1 for non-arrays and by the number of
- * array elements for arrays.
- */
- uniform->opaque[shader_type].index = this->next_sampler;
- this->next_sampler += MAX2(1, uniform->array_elements);
- }
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_sampler,
+ this->record_next_sampler))
+ return;
- const gl_texture_index target = base_type->sampler_index();
- const unsigned shadow = base_type->sampler_shadow;
- for (unsigned i = uniform->opaque[shader_type].index;
- i < MIN2(this->next_sampler, MAX_SAMPLERS);
- i++) {
- this->targets[i] = target;
- this->shader_samplers_used |= 1U << i;
- this->shader_shadow_samplers |= shadow << i;
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < MIN2(this->next_sampler, MAX_SAMPLERS);
+ i++) {
+ this->targets[i] = target;
+ this->shader_samplers_used |= 1U << i;
+ this->shader_shadow_samplers |= shadow << i;
+ }
}
}
}
void handle_images(const glsl_type *base_type,
- struct gl_uniform_storage *uniform)
+ struct gl_uniform_storage *uniform, const char *name)
{
if (base_type->is_image()) {
- uniform->opaque[shader_type].index = this->next_image;
uniform->opaque[shader_type].active = true;
/* Set image access qualifiers */
const GLenum access =
- (current_var->data.image_read_only ? GL_READ_ONLY :
- current_var->data.image_write_only ? GL_WRITE_ONLY :
+ (current_var->data.memory_read_only ? GL_READ_ONLY :
+ current_var->data.memory_write_only ? GL_WRITE_ONLY :
GL_READ_WRITE);
- const unsigned first = this->next_image;
+ if (current_var->data.bindless) {
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_bindless_image,
+ this->record_next_bindless_image))
+ return;
- /* Increment the image index by 1 for non-arrays and by the
- * number of array elements for arrays.
- */
- this->next_image += MAX2(1, uniform->array_elements);
+ this->num_bindless_images = this->next_bindless_image;
- for (unsigned i = first; i < MIN2(next_image, MAX_IMAGE_UNIFORMS); i++)
- prog->_LinkedShaders[shader_type]->Program->sh.ImageAccess[i] = access;
+ this->bindless_access = (GLenum *)
+ realloc(this->bindless_access,
+ this->num_bindless_images * sizeof(GLenum));
+
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < this->num_bindless_images;
+ i++) {
+ this->bindless_access[i] = access;
+ }
+ } else {
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_image,
+ this->record_next_image))
+ return;
+
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < MIN2(this->next_image, MAX_IMAGE_UNIFORMS);
+ i++) {
+ prog->_LinkedShaders[shader_type]->Program->sh.ImageAccess[i] = access;
+ }
+ }
}
}
this->uniforms[id].opaque[shader_type].index = ~0;
this->uniforms[id].opaque[shader_type].active = false;
+ this->uniforms[id].active_shader_mask |= 1 << shader_type;
+
/* This assigns uniform indices to sampler and image uniforms. */
handle_samplers(base_type, &this->uniforms[id], name);
- handle_images(base_type, &this->uniforms[id]);
+ handle_images(base_type, &this->uniforms[id], name);
handle_subroutines(base_type, &this->uniforms[id]);
/* For array of arrays or struct arrays the base location may have
this->uniforms[id].is_shader_storage =
current_var->is_in_shader_storage_block();
+ this->uniforms[id].is_bindless = current_var->data.bindless;
/* Do not assign storage if the uniform is a builtin or buffer object */
if (!this->uniforms[id].builtin &&
}
if (type->without_array()->is_matrix()) {
- const glsl_type *matrix = type->without_array();
- const unsigned N = matrix->base_type == GLSL_TYPE_DOUBLE ? 8 : 4;
- const unsigned items =
- row_major ? matrix->matrix_columns : matrix->vector_elements;
-
- assert(items <= 4);
- if (packing == GLSL_INTERFACE_PACKING_STD430)
- this->uniforms[id].matrix_stride = items < 3 ? items * N :
- glsl_align(items * N, 16);
- else
- this->uniforms[id].matrix_stride = glsl_align(items * N, 16);
+ this->uniforms[id].matrix_stride =
+ link_calculate_matrix_stride(type->without_array(),
+ row_major,
+ packing);
this->uniforms[id].row_major = row_major;
} else {
this->uniforms[id].matrix_stride = 0;
if (!this->uniforms[id].builtin &&
!this->uniforms[id].is_shader_storage &&
this->buffer_block_index == -1)
- this->values += values_for_type(type);
+ this->values += type->component_slots();
}
/**
struct gl_uniform_storage *uniforms;
unsigned next_sampler;
+ unsigned next_bindless_sampler;
unsigned next_image;
+ unsigned next_bindless_image;
unsigned next_subroutine;
+ bool use_std430_as_default;
+
/**
* Field counter is used to take care that uniform structures
* with explicit locations get sequential locations.
*/
struct string_to_uint_map *record_next_sampler;
+ /* Map for temporarily storing next imager index when handling images in
+ * struct arrays.
+ */
+ struct string_to_uint_map *record_next_image;
+
+ /* Map for temporarily storing next bindless sampler index when handling
+ * bindless samplers in struct arrays.
+ */
+ struct string_to_uint_map *record_next_bindless_sampler;
+
+ /* Map for temporarily storing next bindless image index when handling
+ * bindless images in struct arrays.
+ */
+ struct string_to_uint_map *record_next_bindless_image;
+
public:
union gl_constant_value *values;
* Mask of samplers used by the current shader stage for shadows.
*/
unsigned shader_shadow_samplers;
+
+ /**
+ * Number of bindless samplers used by the current shader stage.
+ */
+ unsigned num_bindless_samplers;
+
+ /**
+ * Texture targets for bindless samplers used by the current stage.
+ */
+ gl_texture_index *bindless_targets;
+
+ /**
+ * Number of bindless images used by the current shader stage.
+ */
+ unsigned num_bindless_images;
+
+ /**
+ * Access types for bindless images used by the current stage.
+ */
+ GLenum *bindless_access;
+
};
static bool
static void
link_setup_uniform_remap_tables(struct gl_context *ctx,
- struct gl_shader_program *prog,
- unsigned num_explicit_uniform_locs)
+ struct gl_shader_program *prog)
{
- unsigned total_entries = num_explicit_uniform_locs;
- unsigned empty_locs =
- prog->NumUniformRemapTable - num_explicit_uniform_locs;
+ unsigned total_entries = prog->NumExplicitUniformLocations;
+ unsigned empty_locs = prog->NumUniformRemapTable - total_entries;
/* Reserve all the explicit locations of the active uniforms. */
for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
static void
link_assign_uniform_storage(struct gl_context *ctx,
struct gl_shader_program *prog,
- const unsigned num_data_slots,
- unsigned num_explicit_uniform_locs)
+ const unsigned num_data_slots)
{
/* On the outside chance that there were no uniforms, bail out.
*/
unsigned int boolean_true = ctx->Const.UniformBooleanTrue;
- prog->data->UniformStorage = rzalloc_array(prog, struct gl_uniform_storage,
- prog->data->NumUniformStorage);
- union gl_constant_value *data = rzalloc_array(prog->data->UniformStorage,
- union gl_constant_value,
- num_data_slots);
+ union gl_constant_value *data;
+ if (prog->data->UniformStorage == NULL) {
+ prog->data->UniformStorage = rzalloc_array(prog->data,
+ struct gl_uniform_storage,
+ prog->data->NumUniformStorage);
+ data = rzalloc_array(prog->data->UniformStorage,
+ union gl_constant_value, num_data_slots);
+ prog->data->UniformDataDefaults =
+ rzalloc_array(prog->data->UniformStorage,
+ union gl_constant_value, num_data_slots);
+ } else {
+ data = prog->data->UniformDataSlots;
+ }
+
#ifndef NDEBUG
union gl_constant_value *data_end = &data[num_data_slots];
#endif
parcel_out_uniform_storage parcel(prog, prog->UniformHash,
- prog->data->UniformStorage, data);
+ prog->data->UniformStorage, data,
+ ctx->Const.UseSTD430AsDefaultPacking);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- if (prog->_LinkedShaders[i] == NULL)
+ struct gl_linked_shader *shader = prog->_LinkedShaders[i];
+
+ if (!shader)
continue;
parcel.start_shader((gl_shader_stage)i);
- foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) {
+ foreach_in_list(ir_instruction, node, shader->ir) {
ir_variable *const var = node->as_variable();
if ((var == NULL) || (var->data.mode != ir_var_uniform &&
parcel.set_and_process(var);
}
- prog->_LinkedShaders[i]->active_samplers = parcel.shader_samplers_used;
- prog->_LinkedShaders[i]->shadow_samplers = parcel.shader_shadow_samplers;
+ shader->Program->SamplersUsed = parcel.shader_samplers_used;
+ shader->shadow_samplers = parcel.shader_shadow_samplers;
+
+ if (parcel.num_bindless_samplers > 0) {
+ shader->Program->sh.NumBindlessSamplers = parcel.num_bindless_samplers;
+ shader->Program->sh.BindlessSamplers =
+ rzalloc_array(shader->Program, gl_bindless_sampler,
+ parcel.num_bindless_samplers);
+ for (unsigned j = 0; j < parcel.num_bindless_samplers; j++) {
+ shader->Program->sh.BindlessSamplers[j].target =
+ parcel.bindless_targets[j];
+ }
+ }
+
+ if (parcel.num_bindless_images > 0) {
+ shader->Program->sh.NumBindlessImages = parcel.num_bindless_images;
+ shader->Program->sh.BindlessImages =
+ rzalloc_array(shader->Program, gl_bindless_image,
+ parcel.num_bindless_images);
+ for (unsigned j = 0; j < parcel.num_bindless_images; j++) {
+ shader->Program->sh.BindlessImages[j].access =
+ parcel.bindless_access[j];
+ }
+ }
- STATIC_ASSERT(sizeof(prog->_LinkedShaders[i]->SamplerTargets) ==
- sizeof(parcel.targets));
- memcpy(prog->_LinkedShaders[i]->SamplerTargets, parcel.targets,
- sizeof(prog->_LinkedShaders[i]->SamplerTargets));
+ STATIC_ASSERT(ARRAY_SIZE(shader->Program->sh.SamplerTargets) ==
+ ARRAY_SIZE(parcel.targets));
+ for (unsigned j = 0; j < ARRAY_SIZE(parcel.targets); j++)
+ shader->Program->sh.SamplerTargets[j] = parcel.targets[j];
}
#ifndef NDEBUG
assert(parcel.values == data_end);
#endif
- link_setup_uniform_remap_tables(ctx, prog, num_explicit_uniform_locs);
+ link_setup_uniform_remap_tables(ctx, prog);
+
+ /* Set shader cache fields */
+ prog->data->NumUniformDataSlots = num_data_slots;
+ prog->data->UniformDataSlots = data;
link_set_uniform_initializers(prog, boolean_true);
}
void
link_assign_uniform_locations(struct gl_shader_program *prog,
- struct gl_context *ctx,
- unsigned int num_explicit_uniform_locs)
+ struct gl_context *ctx)
{
ralloc_free(prog->data->UniformStorage);
prog->data->UniformStorage = NULL;
* glGetUniformLocation.
*/
struct string_to_uint_map *hiddenUniforms = new string_to_uint_map;
- count_uniform_size uniform_size(prog->UniformHash, hiddenUniforms);
+ count_uniform_size uniform_size(prog->UniformHash, hiddenUniforms,
+ ctx->Const.UseSTD430AsDefaultPacking);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
}
sh->Program->info.num_textures = uniform_size.num_shader_samplers;
- sh->NumImages = uniform_size.num_shader_images;
+ sh->Program->info.num_images = uniform_size.num_shader_images;
sh->num_uniform_components = uniform_size.num_shader_uniform_components;
sh->num_combined_uniform_components = sh->num_uniform_components;
hiddenUniforms->iterate(assign_hidden_uniform_slot_id, &uniform_size);
delete hiddenUniforms;
- link_assign_uniform_storage(ctx, prog, uniform_size.num_values,
- num_explicit_uniform_locs);
+ link_assign_uniform_storage(ctx, prog, uniform_size.num_values);
}
projects / mesa.git / blobdiff