unreachable("Invalid base type");
}
+const glsl_type *glsl_type::get_float16_type() const
+{
+ assert(this->base_type == GLSL_TYPE_FLOAT);
+
+ return get_instance(GLSL_TYPE_FLOAT16,
+ this->vector_elements,
+ this->matrix_columns,
+ this->explicit_stride,
+ this->interface_row_major);
+}
static void
hash_free_type_function(struct hash_entry *entry)
if (explicit_matrix_types == NULL) {
explicit_matrix_types =
- _mesa_hash_table_create(NULL, _mesa_key_hash_string,
+ _mesa_hash_table_create(NULL, _mesa_hash_string,
_mesa_key_string_equal);
}
assert(glsl_type_users > 0);
if (array_types == NULL) {
- array_types = _mesa_hash_table_create(NULL, _mesa_key_hash_string,
+ array_types = _mesa_hash_table_create(NULL, _mesa_hash_string,
_mesa_key_string_equal);
}
}
unsigned
-glsl_type::count_attribute_slots(bool is_gl_vertex_input) const
+glsl_type::count_vec4_slots(bool is_gl_vertex_input, bool is_bindless) const
{
/* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
*
case GLSL_TYPE_FLOAT:
case GLSL_TYPE_FLOAT16:
case GLSL_TYPE_BOOL:
- case GLSL_TYPE_SAMPLER:
- case GLSL_TYPE_IMAGE:
return this->matrix_columns;
case GLSL_TYPE_DOUBLE:
case GLSL_TYPE_UINT64:
for (unsigned i = 0; i < this->length; i++) {
const glsl_type *member_type = this->fields.structure[i].type;
- size += member_type->count_attribute_slots(is_gl_vertex_input);
+ size += member_type->count_vec4_slots(is_gl_vertex_input, is_bindless);
}
return size;
case GLSL_TYPE_ARRAY: {
const glsl_type *element = this->fields.array;
- return this->length * element->count_attribute_slots(is_gl_vertex_input);
+ return this->length * element->count_vec4_slots(is_gl_vertex_input,
+ is_bindless);
}
+ case GLSL_TYPE_SAMPLER:
+ case GLSL_TYPE_IMAGE:
+ if (!is_bindless)
+ return 0;
+ else
+ return 1;
+
case GLSL_TYPE_SUBROUTINE:
return 1;
return 0;
}
-int
-glsl_type::coordinate_components() const
+unsigned
+glsl_type::count_dword_slots(bool is_bindless) const
{
- int size;
+ switch (this->base_type) {
+ case GLSL_TYPE_UINT:
+ case GLSL_TYPE_INT:
+ case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_BOOL:
+ return this->components();
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_INT16:
+ case GLSL_TYPE_FLOAT16:
+ return DIV_ROUND_UP(this->components(), 2);
+ case GLSL_TYPE_UINT8:
+ case GLSL_TYPE_INT8:
+ return DIV_ROUND_UP(this->components(), 4);
+ case GLSL_TYPE_IMAGE:
+ case GLSL_TYPE_SAMPLER:
+ if (!is_bindless)
+ return 0;
+ /* FALLTHROUGH */
+ case GLSL_TYPE_DOUBLE:
+ case GLSL_TYPE_UINT64:
+ case GLSL_TYPE_INT64:
+ return this->components() * 2;
+ case GLSL_TYPE_ARRAY:
+ return this->fields.array->count_dword_slots(is_bindless) *
+ this->length;
- switch (sampler_dimensionality) {
- case GLSL_SAMPLER_DIM_1D:
- case GLSL_SAMPLER_DIM_BUF:
- size = 1;
- break;
- case GLSL_SAMPLER_DIM_2D:
- case GLSL_SAMPLER_DIM_RECT:
- case GLSL_SAMPLER_DIM_MS:
- case GLSL_SAMPLER_DIM_EXTERNAL:
- case GLSL_SAMPLER_DIM_SUBPASS:
- size = 2;
- break;
- case GLSL_SAMPLER_DIM_3D:
- case GLSL_SAMPLER_DIM_CUBE:
- size = 3;
- break;
+ case GLSL_TYPE_INTERFACE:
+ case GLSL_TYPE_STRUCT: {
+ unsigned size = 0;
+ for (unsigned i = 0; i < this->length; i++) {
+ size += this->fields.structure[i].type->count_dword_slots(is_bindless);
+ }
+ return size;
+ }
+
+ case GLSL_TYPE_ATOMIC_UINT:
+ return 0;
+ case GLSL_TYPE_SUBROUTINE:
+ return 1;
+ case GLSL_TYPE_VOID:
+ case GLSL_TYPE_ERROR:
+ case GLSL_TYPE_FUNCTION:
default:
- assert(!"Should not get here.");
- size = 1;
- break;
+ unreachable("invalid type in st_glsl_type_dword_size()");
}
+ return 0;
+}
+
+int
+glsl_type::coordinate_components() const
+{
+ enum glsl_sampler_dim dim = (enum glsl_sampler_dim)sampler_dimensionality;
+ int size = glsl_get_sampler_dim_coordinate_components(dim);
+
/* Array textures need an additional component for the array index, except
* for cubemap array images that behave like a 2D array of interleaved
* cubemap faces.
struct {
unsigned base_type:5;
unsigned interface_row_major:1;
- unsigned vector_elements:6;
- unsigned matrix_columns:4;
- unsigned _pad:16;
+ unsigned vector_elements:3;
+ unsigned matrix_columns:3;
+ unsigned explicit_stride:20;
} basic;
struct {
unsigned base_type:5;
unsigned sampled_type:2;
unsigned _pad:19;
} sampler;
+ struct {
+ unsigned base_type:5;
+ unsigned length:13;
+ unsigned explicit_stride:14;
+ } array;
+ struct {
+ unsigned base_type:5;
+ unsigned interface_packing_or_packed:2;
+ unsigned interface_row_major:1;
+ unsigned length:24;
+ } strct;
};
void
case GLSL_TYPE_INT64:
case GLSL_TYPE_BOOL:
encoded.basic.interface_row_major = type->interface_row_major;
- encoded.basic.vector_elements = type->vector_elements;
+ assert(type->matrix_columns < 8);
+ if (type->vector_elements <= 4)
+ encoded.basic.vector_elements = type->vector_elements;
+ else if (type->vector_elements == 8)
+ encoded.basic.vector_elements = 5;
+ else if (type->vector_elements == 16)
+ encoded.basic.vector_elements = 6;
encoded.basic.matrix_columns = type->matrix_columns;
+ encoded.basic.explicit_stride = MIN2(type->explicit_stride, 0xfffff);
blob_write_uint32(blob, encoded.u32);
- blob_write_uint32(blob, type->explicit_stride);
+ /* If we don't have enough bits for explicit_stride, store it
+ * separately.
+ */
+ if (encoded.basic.explicit_stride == 0xfffff)
+ blob_write_uint32(blob, type->explicit_stride);
return;
case GLSL_TYPE_SAMPLER:
encoded.sampler.dimensionality = type->sampler_dimensionality;
case GLSL_TYPE_ATOMIC_UINT:
break;
case GLSL_TYPE_ARRAY:
+ encoded.array.length = MIN2(type->length, 0x1fff);
+ encoded.array.explicit_stride = MIN2(type->explicit_stride, 0x3fff);
blob_write_uint32(blob, encoded.u32);
- blob_write_uint32(blob, type->length);
- blob_write_uint32(blob, type->explicit_stride);
+ /* If we don't have enough bits for length or explicit_stride, store it
+ * separately.
+ */
+ if (encoded.array.length == 0x1fff)
+ blob_write_uint32(blob, type->length);
+ if (encoded.array.explicit_stride == 0x3fff)
+ blob_write_uint32(blob, type->explicit_stride);
encode_type_to_blob(blob, type->fields.array);
return;
case GLSL_TYPE_STRUCT:
case GLSL_TYPE_INTERFACE:
+ encoded.strct.length = MIN2(type->length, 0xffffff);
+ if (type->is_interface()) {
+ encoded.strct.interface_packing_or_packed = type->interface_packing;
+ encoded.strct.interface_row_major = type->interface_row_major;
+ } else {
+ encoded.strct.interface_packing_or_packed = type->packed;
+ }
blob_write_uint32(blob, encoded.u32);
blob_write_string(blob, type->name);
- blob_write_uint32(blob, type->length);
+
+ /* If we don't have enough bits for length, store it separately. */
+ if (encoded.strct.length == 0xffffff)
+ blob_write_uint32(blob, type->length);
size_t s_field_size, s_field_ptrs;
get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs);
((char *)&type->fields.structure[i]) + s_field_ptrs,
s_field_size - s_field_ptrs);
}
-
- if (type->is_interface()) {
- blob_write_uint32(blob, type->interface_packing);
- blob_write_uint32(blob, type->interface_row_major);
- } else {
- blob_write_uint32(blob, type->packed);
- }
return;
case GLSL_TYPE_VOID:
break;
case GLSL_TYPE_UINT64:
case GLSL_TYPE_INT64:
case GLSL_TYPE_BOOL: {
- unsigned explicit_stride = blob_read_uint32(blob);
+ unsigned explicit_stride = encoded.basic.explicit_stride;
+ if (explicit_stride == 0xfffff)
+ explicit_stride = blob_read_uint32(blob);
+ uint32_t vector_elements = encoded.basic.vector_elements;
+ if (vector_elements == 5)
+ vector_elements = 8;
+ else if (vector_elements == 6)
+ vector_elements = 16;
return glsl_type::get_instance(base_type, encoded.basic.vector_elements,
encoded.basic.matrix_columns,
explicit_stride,
case GLSL_TYPE_ATOMIC_UINT:
return glsl_type::atomic_uint_type;
case GLSL_TYPE_ARRAY: {
- unsigned length = blob_read_uint32(blob);
- unsigned explicit_stride = blob_read_uint32(blob);
+ unsigned length = encoded.array.length;
+ if (length == 0x1fff)
+ length = blob_read_uint32(blob);
+ unsigned explicit_stride = encoded.array.explicit_stride;
+ if (explicit_stride == 0x3fff)
+ explicit_stride = blob_read_uint32(blob);
return glsl_type::get_array_instance(decode_type_from_blob(blob),
length, explicit_stride);
}
case GLSL_TYPE_STRUCT:
case GLSL_TYPE_INTERFACE: {
char *name = blob_read_string(blob);
- unsigned num_fields = blob_read_uint32(blob);
+ unsigned num_fields = encoded.strct.length;
+ if (num_fields == 0xffffff)
+ num_fields = blob_read_uint32(blob);
size_t s_field_size, s_field_ptrs;
get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs);
const glsl_type *t;
if (base_type == GLSL_TYPE_INTERFACE) {
enum glsl_interface_packing packing =
- (glsl_interface_packing) blob_read_uint32(blob);
- bool row_major = blob_read_uint32(blob);
+ (glsl_interface_packing) encoded.strct.interface_packing_or_packed;
+ bool row_major = encoded.strct.interface_row_major;
t = glsl_type::get_interface_instance(fields, num_fields, packing,
row_major, name);
} else {
- unsigned packed = blob_read_uint32(blob);
+ unsigned packed = encoded.strct.interface_packing_or_packed;
t = glsl_type::get_struct_instance(fields, num_fields, name, packed);
}
}
return 1;
}
+
+extern "C" {
+
+int
+glsl_get_sampler_dim_coordinate_components(enum glsl_sampler_dim dim)
+{
+ switch (dim) {
+ case GLSL_SAMPLER_DIM_1D:
+ case GLSL_SAMPLER_DIM_BUF:
+ return 1;
+ case GLSL_SAMPLER_DIM_2D:
+ case GLSL_SAMPLER_DIM_RECT:
+ case GLSL_SAMPLER_DIM_MS:
+ case GLSL_SAMPLER_DIM_EXTERNAL:
+ case GLSL_SAMPLER_DIM_SUBPASS:
+ case GLSL_SAMPLER_DIM_SUBPASS_MS:
+ return 2;
+ case GLSL_SAMPLER_DIM_3D:
+ case GLSL_SAMPLER_DIM_CUBE:
+ return 3;
+ default:
+ unreachable("Unknown sampler dim");
+ }
+}
+
+}