case ir_unop_dFdy_fine:
case ir_unop_subroutine_to_int:
case ir_unop_get_buffer_size:
- case ir_unop_ballot:
- case ir_binop_read_invocation:
- case ir_unop_read_first_invocation:
- case ir_unop_vote_any:
- case ir_unop_vote_all:
- case ir_unop_vote_eq:
case ir_unop_bitcast_u642d:
case ir_unop_bitcast_i642d:
case ir_unop_bitcast_d2u64:
case ir_unop_unpack_int_2x32:
case ir_unop_pack_uint_2x32:
case ir_unop_unpack_uint_2x32:
+ case ir_unop_pack_sampler_2x32:
+ case ir_unop_unpack_sampler_2x32:
+ case ir_unop_pack_image_2x32:
+ case ir_unop_unpack_image_2x32:
assert(!"not supported");
break;
class add_uniform_to_shader : public program_resource_visitor {
public:
add_uniform_to_shader(struct gl_shader_program *shader_program,
- struct gl_program_parameter_list *params,
- gl_shader_stage shader_type)
- : shader_program(shader_program), params(params), idx(-1),
- shader_type(shader_type)
+ struct gl_program_parameter_list *params)
+ : shader_program(shader_program), params(params), idx(-1)
{
/* empty */
}
void process(ir_variable *var)
{
this->idx = -1;
+ this->var = var;
this->program_resource_visitor::process(var);
var->data.param_index = this->idx;
}
struct gl_shader_program *shader_program;
struct gl_program_parameter_list *params;
int idx;
- gl_shader_stage shader_type;
+ ir_variable *var;
};
} /* anonymous namespace */
const enum glsl_interface_packing,
bool /* last_field */)
{
- unsigned int size;
-
- /* atomics don't get real storage */
- if (type->contains_atomic())
+ /* opaque types don't use storage in the param list unless they are
+ * bindless samplers or images.
+ */
+ if (type->contains_opaque() && !var->data.bindless)
return;
- if (type->is_vector() || type->is_scalar()) {
- size = type->vector_elements;
- if (type->is_64bit())
- size *= 2;
- } else {
- size = type_size(type) * 4;
- }
-
- gl_register_file file;
- if (type->without_array()->is_sampler()) {
- file = PROGRAM_SAMPLER;
- } else {
- file = PROGRAM_UNIFORM;
- }
-
- int index = _mesa_lookup_parameter_index(params, name);
- if (index < 0) {
- index = _mesa_add_parameter(params, file, name, size, type->gl_type,
- NULL, NULL);
-
- /* Sampler uniform values are stored in prog->SamplerUnits,
- * and the entry in that array is selected by this index we
- * store in ParameterValues[].
- */
- if (file == PROGRAM_SAMPLER) {
- unsigned location;
- const bool found =
- this->shader_program->UniformHash->get(location,
- params->Parameters[index].Name);
- assert(found);
-
- if (!found)
- return;
-
- struct gl_uniform_storage *storage =
- &this->shader_program->data->UniformStorage[location];
+ assert(_mesa_lookup_parameter_index(params, name) < 0);
- assert(storage->type->is_sampler() &&
- storage->opaque[shader_type].active);
+ unsigned size = type_size(type) * 4;
- for (unsigned int j = 0; j < size / 4; j++)
- params->ParameterValues[index + j][0].f =
- storage->opaque[shader_type].index + j;
- }
- }
+ int index = _mesa_add_parameter(params, PROGRAM_UNIFORM, name, size,
+ type->gl_type, NULL, NULL);
/* The first part of the uniform that's processed determines the base
* location of the whole uniform (for structures).
struct gl_program_parameter_list
*params)
{
- add_uniform_to_shader add(shader_program, params, sh->Stage);
+ add_uniform_to_shader add(shader_program, params);
foreach_in_list(ir_instruction, node, sh->ir) {
ir_variable *var = node->as_variable();
void
_mesa_associate_uniform_storage(struct gl_context *ctx,
- struct gl_shader_program *shader_program,
- struct gl_program_parameter_list *params,
+ struct gl_shader_program *shader_program,
+ struct gl_program *prog,
bool propagate_to_storage)
{
+ struct gl_program_parameter_list *params = prog->Parameters;
+ gl_shader_stage shader_type = prog->info.stage;
+
/* After adding each uniform to the parameter list, connect the storage for
* the parameter with the tracking structure used by the API for the
* uniform.
unsigned last_location = unsigned(~0);
for (unsigned i = 0; i < params->NumParameters; i++) {
if (params->Parameters[i].Type != PROGRAM_UNIFORM)
- continue;
+ continue;
unsigned location;
const bool found =
- shader_program->UniformHash->get(location, params->Parameters[i].Name);
+ shader_program->UniformHash->get(location, params->Parameters[i].Name);
assert(found);
if (!found)
- continue;
+ continue;
struct gl_uniform_storage *storage =
&shader_program->data->UniformStorage[location];
continue;
if (location != last_location) {
- enum gl_uniform_driver_format format = uniform_native;
+ enum gl_uniform_driver_format format = uniform_native;
+ unsigned columns = 0;
+ int dmul = 4 * sizeof(float);
- unsigned columns = 0;
- int dmul = 4 * sizeof(float);
- switch (storage->type->base_type) {
+ switch (storage->type->base_type) {
case GLSL_TYPE_UINT64:
- if (storage->type->vector_elements > 2)
+ if (storage->type->vector_elements > 2)
dmul *= 2;
- /* fallthrough */
- case GLSL_TYPE_UINT:
- assert(ctx->Const.NativeIntegers);
- format = uniform_native;
- columns = 1;
- break;
+ /* fallthrough */
+ case GLSL_TYPE_UINT:
+ assert(ctx->Const.NativeIntegers);
+ format = uniform_native;
+ columns = 1;
+ break;
case GLSL_TYPE_INT64:
- if (storage->type->vector_elements > 2)
+ if (storage->type->vector_elements > 2)
dmul *= 2;
- /* fallthrough */
- case GLSL_TYPE_INT:
- format =
- (ctx->Const.NativeIntegers) ? uniform_native : uniform_int_float;
- columns = 1;
- break;
-
- case GLSL_TYPE_DOUBLE:
- if (storage->type->vector_elements > 2)
+ /* fallthrough */
+ case GLSL_TYPE_INT:
+ format =
+ (ctx->Const.NativeIntegers) ? uniform_native : uniform_int_float;
+ columns = 1;
+ break;
+ case GLSL_TYPE_DOUBLE:
+ if (storage->type->vector_elements > 2)
dmul *= 2;
- /* fallthrough */
- case GLSL_TYPE_FLOAT:
- format = uniform_native;
- columns = storage->type->matrix_columns;
- break;
- case GLSL_TYPE_BOOL:
- format = uniform_native;
- columns = 1;
- break;
- case GLSL_TYPE_SAMPLER:
- case GLSL_TYPE_IMAGE:
+ /* fallthrough */
+ case GLSL_TYPE_FLOAT:
+ format = uniform_native;
+ columns = storage->type->matrix_columns;
+ break;
+ case GLSL_TYPE_BOOL:
+ format = uniform_native;
+ columns = 1;
+ break;
+ case GLSL_TYPE_SAMPLER:
+ case GLSL_TYPE_IMAGE:
case GLSL_TYPE_SUBROUTINE:
- format = uniform_native;
- columns = 1;
- break;
+ format = uniform_native;
+ columns = 1;
+ break;
case GLSL_TYPE_ATOMIC_UINT:
case GLSL_TYPE_ARRAY:
case GLSL_TYPE_VOID:
case GLSL_TYPE_ERROR:
case GLSL_TYPE_INTERFACE:
case GLSL_TYPE_FUNCTION:
- assert(!"Should not get here.");
- break;
- }
+ assert(!"Should not get here.");
+ break;
+ }
- _mesa_uniform_attach_driver_storage(storage,
- dmul * columns,
- dmul,
- format,
- ¶ms->ParameterValues[i]);
+ _mesa_uniform_attach_driver_storage(storage, dmul * columns, dmul,
+ format,
+ ¶ms->ParameterValues[i]);
- /* After attaching the driver's storage to the uniform, propagate any
- * data from the linker's backing store. This will cause values from
- * initializers in the source code to be copied over.
- */
+ /* When a bindless sampler/image is bound to a texture/image unit, we
+ * have to overwrite the constant value by the resident handle
+ * directly in the constant buffer before the next draw. One solution
+ * is to keep track a pointer to the base of the data.
+ */
+ if (storage->is_bindless && (prog->sh.NumBindlessSamplers ||
+ prog->sh.NumBindlessImages)) {
+ unsigned array_elements = MAX2(1, storage->array_elements);
+
+ for (unsigned j = 0; j < array_elements; ++j) {
+ unsigned unit = storage->opaque[shader_type].index + j;
+
+ if (storage->type->without_array()->is_sampler()) {
+ assert(unit >= 0 && unit < prog->sh.NumBindlessSamplers);
+ prog->sh.BindlessSamplers[unit].data =
+ ¶ms->ParameterValues[i] + j;
+ } else if (storage->type->without_array()->is_image()) {
+ assert(unit >= 0 && unit < prog->sh.NumBindlessImages);
+ prog->sh.BindlessImages[unit].data =
+ ¶ms->ParameterValues[i] + j;
+ }
+ }
+ }
+
+ /* After attaching the driver's storage to the uniform, propagate any
+ * data from the linker's backing store. This will cause values from
+ * initializers in the source code to be copied over.
+ */
if (propagate_to_storage) {
unsigned array_elements = MAX2(1, storage->array_elements);
_mesa_propagate_uniforms_to_driver_storage(storage, 0,
array_elements);
}
- last_location = location;
+ last_location = location;
}
}
}
* prog->ParameterValues to get reallocated (e.g., anything that adds a
* program constant) has to happen before creating this linkage.
*/
- _mesa_associate_uniform_storage(ctx, shader_program, prog->Parameters,
- true);
+ _mesa_associate_uniform_storage(ctx, shader_program, prog, true);
if (!shader_program->data->LinkStatus) {
goto fail_exit;
}
}
if (prog->data->LinkStatus) {
+ /* Reset sampler validated to true, validation happens via the
+ * LinkShader call below.
+ */
+ prog->SamplersValidated = GL_TRUE;
+
if (!ctx->Driver.LinkShader(ctx, prog)) {
prog->data->LinkStatus = linking_failure;
}
projects / mesa.git / blobdiff