mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-24 21:50:12 +01:00
glsl/ir: Add builtin constant function support for doubles
Signed-off-by: Dave Airlie <airlied@redhat.com> Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>
This commit is contained in:
Dave Airlie
Ilia Mirkin
parent
753ba6b999
commit
eeae6251be
1 changed files with 215 additions and 32 deletions
|
|
@ -60,7 +60,7 @@ static double copysign(double x, double y)
|
|||
#endif
|
||||
|
||||
static float
|
||||
dot(ir_constant *op0, ir_constant *op1)
|
||||
dot_f(ir_constant *op0, ir_constant *op1)
|
||||
{
|
||||
assert(op0->type->is_float() && op1->type->is_float());
|
||||
|
||||
|
|
@ -71,6 +71,18 @@ dot(ir_constant *op0, ir_constant *op1)
|
|||
return result;
|
||||
}
|
||||
|
||||
static double
|
||||
dot_d(ir_constant *op0, ir_constant *op1)
|
||||
{
|
||||
assert(op0->type->is_double() && op1->type->is_double());
|
||||
|
||||
double result = 0;
|
||||
for (unsigned c = 0; c < op0->type->components(); c++)
|
||||
result += op0->value.d[c] * op1->value.d[c];
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* This method is the only one supported by gcc. Unions in particular
|
||||
* are iffy, and read-through-converted-pointer is killed by strict
|
||||
* aliasing. OTOH, the compiler sees through the memcpy, so the
|
||||
|
|
@ -667,32 +679,81 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
data.b[0] = true;
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_unop_trunc:
|
||||
case ir_unop_d2f:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = op[0]->value.d[c];
|
||||
}
|
||||
break;
|
||||
case ir_unop_f2d:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = truncf(op[0]->value.f[c]);
|
||||
data.d[c] = op[0]->value.f[c];
|
||||
}
|
||||
break;
|
||||
case ir_unop_d2i:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.i[c] = op[0]->value.d[c];
|
||||
}
|
||||
break;
|
||||
case ir_unop_i2d:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_INT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.d[c] = op[0]->value.i[c];
|
||||
}
|
||||
break;
|
||||
case ir_unop_d2u:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.u[c] = op[0]->value.d[c];
|
||||
}
|
||||
break;
|
||||
case ir_unop_u2d:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_UINT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.d[c] = op[0]->value.u[c];
|
||||
}
|
||||
break;
|
||||
case ir_unop_d2b:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.b[c] = op[0]->value.d[c] != 0.0;
|
||||
}
|
||||
break;
|
||||
case ir_unop_trunc:
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = trunc(op[0]->value.d[c]);
|
||||
else
|
||||
data.f[c] = truncf(op[0]->value.f[c]);
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_unop_round_even:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = _mesa_round_to_even(op[0]->value.f[c]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = _mesa_round_to_even(op[0]->value.d[c]);
|
||||
else
|
||||
data.f[c] = _mesa_round_to_even(op[0]->value.f[c]);
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_unop_ceil:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = ceilf(op[0]->value.f[c]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = ceil(op[0]->value.d[c]);
|
||||
else
|
||||
data.f[c] = ceilf(op[0]->value.f[c]);
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_unop_floor:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = floorf(op[0]->value.f[c]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = floor(op[0]->value.d[c]);
|
||||
else
|
||||
data.f[c] = floorf(op[0]->value.f[c]);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -708,6 +769,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = op[0]->value.d[c] - floor(op[0]->value.d[c]);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -742,6 +806,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = -op[0]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = -op[0]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -762,6 +829,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = fabs(op[0]->value.f[c]);
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = fabs(op[0]->value.d[c]);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -780,6 +850,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = double((op[0]->value.d[c] > 0)-(op[0]->value.d[c] < 0));
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -787,7 +860,6 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
break;
|
||||
|
||||
case ir_unop_rcp:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
switch (this->type->base_type) {
|
||||
case GLSL_TYPE_UINT:
|
||||
|
|
@ -802,6 +874,10 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
if (op[0]->value.f[c] != 0.0)
|
||||
data.f[c] = 1.0F / op[0]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
if (op[0]->value.d[c] != 0.0)
|
||||
data.d[c] = 1.0 / op[0]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -809,16 +885,20 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
break;
|
||||
|
||||
case ir_unop_rsq:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = 1.0 / sqrt(op[0]->value.d[c]);
|
||||
else
|
||||
data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_unop_sqrt:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
for (unsigned c = 0; c < op[0]->type->components(); c++) {
|
||||
data.f[c] = sqrtf(op[0]->value.f[c]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = sqrt(op[0]->value.d[c]);
|
||||
else
|
||||
data.f[c] = sqrtf(op[0]->value.f[c]);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -934,7 +1014,10 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
break;
|
||||
|
||||
case ir_binop_dot:
|
||||
data.f[0] = dot(op[0], op[1]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[0] = dot_d(op[0], op[1]);
|
||||
else
|
||||
data.f[0] = dot_f(op[0], op[1]);
|
||||
break;
|
||||
|
||||
case ir_binop_min:
|
||||
|
|
@ -953,6 +1036,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -975,6 +1061,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -997,6 +1086,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1019,6 +1111,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1043,6 +1138,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1066,7 +1164,10 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
for (unsigned j = 0; j < p; j++) {
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned k = 0; k < m; k++) {
|
||||
data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[i+n*j] += op[0]->value.d[i+n*k]*op[1]->value.d[k+m*j];
|
||||
else
|
||||
data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1098,6 +1199,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1133,6 +1237,13 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
|
||||
* floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
/* We don't use fmod because it rounds toward zero; GLSL specifies
|
||||
* the use of floor.
|
||||
*/
|
||||
data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1]
|
||||
* floor(op[0]->value.d[c0] / op[1]->value.d[c1]);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1169,6 +1280,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.b[c] = op[0]->value.d[c] < op[1]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1187,6 +1301,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.b[c] = op[0]->value.d[c] > op[1]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1205,6 +1322,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.b[c] = op[0]->value.d[c] <= op[1]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1223,6 +1343,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1244,6 +1367,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_BOOL:
|
||||
data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.b[c] = op[0]->value.d[c] == op[1]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1265,6 +1391,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_BOOL:
|
||||
data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.b[c] = op[0]->value.d[c] != op[1]->value.d[c];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1375,6 +1504,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[0] = op[0]->value.f[c];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[0] = op[0]->value.d[c];
|
||||
break;
|
||||
case GLSL_TYPE_BOOL:
|
||||
data.b[0] = op[0]->value.b[c];
|
||||
break;
|
||||
|
|
@ -1474,6 +1606,19 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f);
|
||||
}
|
||||
break;
|
||||
case ir_unop_pack_double_2x32: {
|
||||
/* XXX needs to be checked on big-endian */
|
||||
uint64_t temp;
|
||||
temp = (uint64_t)op[0]->value.u[0] | ((uint64_t)op[0]->value.u[1] << 32);
|
||||
data.d[0] = *(double *)&temp;
|
||||
|
||||
break;
|
||||
}
|
||||
case ir_unop_unpack_double_2x32:
|
||||
/* XXX needs to be checked on big-endian */
|
||||
data.u[0] = *(uint32_t *)&op[0]->value.d[0];
|
||||
data.u[1] = *((uint32_t *)&op[0]->value.d[0] + 1);
|
||||
break;
|
||||
|
||||
case ir_triop_bitfield_extract: {
|
||||
int offset = op[1]->value.i[0];
|
||||
|
|
@ -1523,40 +1668,65 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
|
||||
case ir_binop_ldexp:
|
||||
for (unsigned c = 0; c < components; c++) {
|
||||
data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
|
||||
/* Flush subnormal values to zero. */
|
||||
if (!isnormal(data.f[c]))
|
||||
data.f[c] = copysign(0.0f, op[0]->value.f[c]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE) {
|
||||
data.d[c] = ldexp(op[0]->value.d[c], op[1]->value.i[c]);
|
||||
/* Flush subnormal values to zero. */
|
||||
if (!isnormal(data.d[c]))
|
||||
data.d[c] = copysign(0.0, op[0]->value.d[c]);
|
||||
} else {
|
||||
data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
|
||||
/* Flush subnormal values to zero. */
|
||||
if (!isnormal(data.f[c]))
|
||||
data.f[c] = copysign(0.0f, op[0]->value.f[c]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_triop_fma:
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
assert(op[1]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
assert(op[2]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT ||
|
||||
op[0]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
assert(op[1]->type->base_type == GLSL_TYPE_FLOAT ||
|
||||
op[1]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
assert(op[2]->type->base_type == GLSL_TYPE_FLOAT ||
|
||||
op[2]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
|
||||
for (unsigned c = 0; c < components; c++) {
|
||||
data.f[c] = op[0]->value.f[c] * op[1]->value.f[c]
|
||||
+ op[2]->value.f[c];
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = op[0]->value.d[c] * op[1]->value.d[c]
|
||||
+ op[2]->value.d[c];
|
||||
else
|
||||
data.f[c] = op[0]->value.f[c] * op[1]->value.f[c]
|
||||
+ op[2]->value.f[c];
|
||||
}
|
||||
break;
|
||||
|
||||
case ir_triop_lrp: {
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
assert(op[1]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
assert(op[2]->type->base_type == GLSL_TYPE_FLOAT);
|
||||
assert(op[0]->type->base_type == GLSL_TYPE_FLOAT ||
|
||||
op[0]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
assert(op[1]->type->base_type == GLSL_TYPE_FLOAT ||
|
||||
op[1]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
assert(op[2]->type->base_type == GLSL_TYPE_FLOAT ||
|
||||
op[2]->type->base_type == GLSL_TYPE_DOUBLE);
|
||||
|
||||
unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
|
||||
for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) {
|
||||
data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) +
|
||||
(op[1]->value.f[c] * op[2]->value.f[c2]);
|
||||
if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = op[0]->value.d[c] * (1.0 - op[2]->value.d[c2]) +
|
||||
(op[1]->value.d[c] * op[2]->value.d[c2]);
|
||||
else
|
||||
data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) +
|
||||
(op[1]->value.f[c] * op[2]->value.f[c2]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case ir_triop_csel:
|
||||
for (unsigned c = 0; c < components; c++) {
|
||||
data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c]
|
||||
if (op[1]->type->base_type == GLSL_TYPE_DOUBLE)
|
||||
data.d[c] = op[0]->value.b[c] ? op[1]->value.d[c]
|
||||
: op[2]->value.d[c];
|
||||
else
|
||||
data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c]
|
||||
: op[2]->value.u[c];
|
||||
}
|
||||
break;
|
||||
|
|
@ -1579,6 +1749,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_BOOL:
|
||||
data.b[idx] = op[1]->value.b[0];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[idx] = op[1]->value.d[0];
|
||||
break;
|
||||
default:
|
||||
assert(!"Should not get here.");
|
||||
break;
|
||||
|
|
@ -1625,6 +1798,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
|
|||
case GLSL_TYPE_FLOAT:
|
||||
data.f[c] = op[c]->value.f[0];
|
||||
break;
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
data.d[c] = op[c]->value.d[0];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
|
|
@ -1666,6 +1842,7 @@ ir_swizzle::constant_expression_value(struct hash_table *variable_context)
|
|||
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_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;
|
||||
default: assert(!"Should not get here."); break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1740,6 +1917,12 @@ ir_dereference_array::constant_expression_value(struct hash_table *variable_cont
|
|||
|
||||
break;
|
||||
|
||||
case GLSL_TYPE_DOUBLE:
|
||||
for (unsigned i = 0; i < column_type->vector_elements; i++)
|
||||
data.d[i] = array->value.d[mat_idx + i];
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
assert(!"Should not get here.");
|
||||
break;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue