*
* packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
*/
- return (uint8_t) (int) _mesa_roundevenf(CLAMP(x, 0.0f, 1.0f) * 255.0f);
+ return (uint8_t) (int) _mesa_roundevenf(SATURATE(x) * 255.0f);
}
/**
* packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
*/
return (uint16_t) (int)
- _mesa_roundevenf(CLAMP(x, 0.0f, 1.0f) * 65535.0f);
+ _mesa_roundevenf(SATURATE(x) * 65535.0f);
}
/**
return a - b;
}
+static uint64_t
+pack_2x32(uint32_t a, uint32_t b)
+{
+ uint64_t v = a;
+ v |= (uint64_t)b << 32;
+ return v;
+}
+
+static void
+unpack_2x32(uint64_t p, uint32_t *a, uint32_t *b)
+{
+ *a = p & 0xffffffff;
+ *b = (p >> 32);
+}
+
/**
* Get the constant that is ultimately referenced by an r-value, in a constant
* expression evaluation context.
if (this->type->is_error())
return NULL;
+ const glsl_type *return_type = this->type;
ir_constant *op[ARRAY_SIZE(this->operands)] = { NULL, };
ir_constant_data data;
return NULL;
}
+ for (unsigned operand = 0; operand < this->num_operands; operand++) {
+ switch (op[operand]->type->base_type) {
+ case GLSL_TYPE_FLOAT16: {
+ const struct glsl_type *float_type =
+ glsl_type::get_instance(GLSL_TYPE_FLOAT,
+ op[operand]->type->vector_elements,
+ op[operand]->type->matrix_columns,
+ op[operand]->type->explicit_stride,
+ op[operand]->type->interface_row_major);
+
+ ir_constant_data f;
+ for (unsigned i = 0; i < ARRAY_SIZE(f.f); i++)
+ f.f[i] = _mesa_half_to_float(op[operand]->value.f16[i]);
+
+ op[operand] = new(mem_ctx) ir_constant(float_type, &f);
+ break;
+ }
+ case GLSL_TYPE_INT16: {
+ const struct glsl_type *int_type =
+ glsl_type::get_instance(GLSL_TYPE_INT,
+ op[operand]->type->vector_elements,
+ op[operand]->type->matrix_columns,
+ op[operand]->type->explicit_stride,
+ op[operand]->type->interface_row_major);
+
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.i); i++)
+ d.i[i] = op[operand]->value.i16[i];
+
+ op[operand] = new(mem_ctx) ir_constant(int_type, &d);
+ break;
+ }
+ case GLSL_TYPE_UINT16: {
+ const struct glsl_type *uint_type =
+ glsl_type::get_instance(GLSL_TYPE_UINT,
+ op[operand]->type->vector_elements,
+ op[operand]->type->matrix_columns,
+ op[operand]->type->explicit_stride,
+ op[operand]->type->interface_row_major);
+
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.u); i++)
+ d.u[i] = op[operand]->value.u16[i];
+
+ op[operand] = new(mem_ctx) ir_constant(uint_type, &d);
+ break;
+ }
+ default:
+ /* nothing to do */
+ break;
+ }
+ }
+
+ switch (return_type->base_type) {
+ case GLSL_TYPE_FLOAT16:
+ return_type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
+ return_type->vector_elements,
+ return_type->matrix_columns,
+ return_type->explicit_stride,
+ return_type->interface_row_major);
+ break;
+ case GLSL_TYPE_INT16:
+ return_type = glsl_type::get_instance(GLSL_TYPE_INT,
+ return_type->vector_elements,
+ return_type->matrix_columns,
+ return_type->explicit_stride,
+ return_type->interface_row_major);
+ break;
+ case GLSL_TYPE_UINT16:
+ return_type = glsl_type::get_instance(GLSL_TYPE_UINT,
+ return_type->vector_elements,
+ return_type->matrix_columns,
+ return_type->explicit_stride,
+ return_type->interface_row_major);
+ break;
+ default:
+ /* nothing to do */
+ break;
+ }
+
if (op[1] != NULL)
switch (this->operation) {
case ir_binop_lshift:
#include "ir_expression_operation_constant.h"
- return new(mem_ctx) ir_constant(this->type, &data);
+ switch (type->base_type) {
+ case GLSL_TYPE_FLOAT16: {
+ ir_constant_data f;
+ for (unsigned i = 0; i < ARRAY_SIZE(f.f16); i++)
+ f.f16[i] = _mesa_float_to_half(data.f[i]);
+
+ return new(mem_ctx) ir_constant(this->type, &f);
+ }
+ case GLSL_TYPE_INT16: {
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.i16); i++)
+ d.i16[i] = data.i[i];
+
+ return new(mem_ctx) ir_constant(this->type, &d);
+ }
+ case GLSL_TYPE_UINT16: {
+ ir_constant_data d;
+ for (unsigned i = 0; i < ARRAY_SIZE(d.u16); i++)
+ d.u16[i] = data.u[i];
+
+ return new(mem_ctx) ir_constant(this->type, &d);
+ }
+ default:
+ return new(mem_ctx) ir_constant(this->type, &data);
+ }
}
for (unsigned i = 0; i < this->mask.num_components; i++) {
switch (v->type->base_type) {
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_INT16: data.u16[i] = v->value.u16[swiz_idx[i]]; break;
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT: data.u[i] = v->value.u[swiz_idx[i]]; break;
case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
+ case GLSL_TYPE_FLOAT16: data.f16[i] = v->value.f16[swiz_idx[i]]; break;
case GLSL_TYPE_BOOL: data.b[i] = v->value.b[swiz_idx[i]]; break;
case GLSL_TYPE_DOUBLE:data.d[i] = v->value.d[swiz_idx[i]]; break;
case GLSL_TYPE_UINT64:data.u64[i] = v->value.u64[swiz_idx[i]]; break;
ir_constant_data data = { { 0 } };
switch (column_type->base_type) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
+ case GLSL_TYPE_FLOAT16:
for (unsigned i = 0; i < column_type->vector_elements; i++)
- data.u[i] = array->value.u[mat_idx + i];
+ data.f16[i] = array->value.f16[mat_idx + i];
break;
break;
default:
- assert(!"Should not get here.");
- break;
+ unreachable("Matrix types are either float or double.");
}
return new(mem_ctx) ir_constant(column_type, &data);
/*
* Of the builtin functions, only the texture lookups and the noise
- * ones must not be used in constant expressions. They all include
- * specific opcodes so they don't need to be special-cased at this
- * point.
+ * ones must not be used in constant expressions. Texture instructions
+ * include special ir_texture opcodes which can't be constant-folded (see
+ * ir_texture::constant_expression_value). Noise functions, however, we
+ * have to special case here.
*/
+ if (strcmp(this->function_name(), "noise1") == 0 ||
+ strcmp(this->function_name(), "noise2") == 0 ||
+ strcmp(this->function_name(), "noise3") == 0 ||
+ strcmp(this->function_name(), "noise4") == 0)
+ return NULL;
/* Initialize the table of dereferencable names with the function
* parameters. Verify their const-ness on the way.
projects / mesa.git / blobdiff