9fa99f3b6c
Now, ir_function is emitted as part of the IR instructions, rather than simply existing in the symbol table. Individual ir_function_signatures are not emitted themselves, but only as part of ir_function.
833 lines
26 KiB
C++
833 lines
26 KiB
C++
/*
|
|
* Copyright © 2010 Intel Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include "glsl_symbol_table.h"
|
|
#include "glsl_parser_extras.h"
|
|
#include "glsl_types.h"
|
|
#include "ir.h"
|
|
|
|
static void
|
|
generate_unop(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type,
|
|
enum ir_expression_operation op)
|
|
{
|
|
ir_dereference *const arg = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
result = new ir_expression(op, type, arg, NULL);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_binop(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type,
|
|
enum ir_expression_operation op)
|
|
{
|
|
ir_dereference *const arg1 = new ir_dereference(declarations[0]);
|
|
ir_dereference *const arg2 = new ir_dereference(declarations[1]);
|
|
ir_rvalue *result;
|
|
|
|
result = new ir_expression(op, type, arg1, arg2);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_radians(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
result = new ir_expression(ir_binop_mul, type,
|
|
arg,
|
|
new ir_constant((float)(M_PI / 180.0)));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_degrees(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
result = new ir_expression(ir_binop_mul, type,
|
|
arg,
|
|
new ir_constant((float)(180.0 / M_PI)));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_exp(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_exp);
|
|
}
|
|
|
|
static void
|
|
generate_log(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_log);
|
|
}
|
|
|
|
static void
|
|
generate_exp2(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_exp2);
|
|
}
|
|
|
|
static void
|
|
generate_log2(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_log2);
|
|
}
|
|
|
|
static void
|
|
generate_rsq(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_rsq);
|
|
}
|
|
|
|
static void
|
|
generate_sqrt(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_sqrt);
|
|
}
|
|
|
|
static void
|
|
generate_abs(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_abs);
|
|
}
|
|
|
|
static void
|
|
generate_ceil(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_ceil);
|
|
}
|
|
|
|
static void
|
|
generate_floor(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_unop(instructions, declarations, type, ir_unop_floor);
|
|
}
|
|
|
|
static void
|
|
generate_mod(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_binop(instructions, declarations, type, ir_binop_mod);
|
|
}
|
|
|
|
static void
|
|
generate_min(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_binop(instructions, declarations, type, ir_binop_min);
|
|
}
|
|
|
|
static void
|
|
generate_max(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_binop(instructions, declarations, type, ir_binop_max);
|
|
}
|
|
|
|
static void
|
|
generate_clamp(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const x = new ir_dereference(declarations[0]);
|
|
ir_dereference *const minval = new ir_dereference(declarations[1]);
|
|
ir_dereference *const maxval = new ir_dereference(declarations[2]);
|
|
ir_rvalue *result;
|
|
|
|
result = new ir_expression(ir_binop_min, type, x, maxval);
|
|
result = new ir_expression(ir_binop_max, type, result, minval);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_mix_vec(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const x = new ir_dereference(declarations[0]);
|
|
ir_dereference *const y = new ir_dereference(declarations[1]);
|
|
ir_dereference *const a = new ir_dereference(declarations[2]);
|
|
ir_rvalue *result, *temp;
|
|
|
|
temp = new ir_expression(ir_binop_sub, type, new ir_constant(1.0f), a);
|
|
result = new ir_expression(ir_binop_mul, type, x, temp);
|
|
|
|
temp = new ir_expression(ir_binop_mul, type, y, a);
|
|
result = new ir_expression(ir_binop_add, type, result, temp);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
|
|
static void
|
|
generate_normalize(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg = new ir_dereference(declarations[0]);
|
|
ir_rvalue *temp;
|
|
ir_rvalue *result;
|
|
|
|
temp = new ir_expression(ir_binop_dot, glsl_type::float_type, arg, arg);
|
|
temp = new ir_expression(ir_unop_rsq, glsl_type::float_type, temp, NULL);
|
|
result = new ir_expression(ir_binop_mul, type, arg, temp);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
|
|
static void
|
|
generate_pow(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_binop(instructions, declarations, type, ir_binop_pow);
|
|
}
|
|
|
|
void
|
|
generate_function_instance(ir_function *f,
|
|
const char *name,
|
|
exec_list *instructions,
|
|
int n_args,
|
|
void (*generate)(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type),
|
|
const glsl_type *ret_type,
|
|
const glsl_type *type)
|
|
{
|
|
ir_variable *declarations[16];
|
|
|
|
ir_function_signature *const sig = new ir_function_signature(ret_type);
|
|
f->add_signature(sig);
|
|
|
|
static const char *arg_names[] = {
|
|
"arg0",
|
|
"arg1",
|
|
"arg2"
|
|
};
|
|
int i;
|
|
|
|
for (i = 0; i < n_args; i++) {
|
|
ir_variable *var = new ir_variable(type, arg_names[i]);
|
|
|
|
var->mode = ir_var_in;
|
|
sig->parameters.push_tail(var);
|
|
|
|
declarations[i] = var;
|
|
}
|
|
|
|
generate(&sig->body, declarations, type);
|
|
sig->is_defined = true;
|
|
}
|
|
|
|
void
|
|
make_gentype_function(glsl_symbol_table *symtab, exec_list *instructions,
|
|
const char *name,
|
|
int n_args,
|
|
void (*generate)(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type))
|
|
{
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *float_type = glsl_type::float_type;
|
|
const glsl_type *vec2_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 2, 1);
|
|
const glsl_type *vec3_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 3, 1);
|
|
const glsl_type *vec4_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, n_args, generate,
|
|
float_type, float_type);
|
|
generate_function_instance(f, name, instructions, n_args, generate,
|
|
vec2_type, vec2_type);
|
|
generate_function_instance(f, name, instructions, n_args, generate,
|
|
vec3_type, vec3_type);
|
|
generate_function_instance(f, name, instructions, n_args, generate,
|
|
vec4_type, vec4_type);
|
|
}
|
|
|
|
static void
|
|
generate_vec_compare(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type,
|
|
enum ir_expression_operation op)
|
|
{
|
|
ir_dereference *const x = new ir_dereference(declarations[0]);
|
|
ir_dereference *const y = new ir_dereference(declarations[1]);
|
|
ir_variable *temp;
|
|
const glsl_type *return_type;
|
|
int i;
|
|
|
|
return_type = glsl_type::get_instance(GLSL_TYPE_BOOL,
|
|
type->vector_elements, 1);
|
|
temp = new ir_variable(return_type, "temp");
|
|
|
|
for (i = 0; i < type->vector_elements; i++) {
|
|
ir_assignment *assign;
|
|
ir_expression *compare;
|
|
|
|
compare = new ir_expression(op,
|
|
glsl_type::get_instance(type->base_type,
|
|
1, 1),
|
|
new ir_swizzle(x, i, 0, 0, 0, 1),
|
|
new ir_swizzle(y, i, 0, 0, 0, 1));
|
|
assign = new ir_assignment(new ir_swizzle(new ir_dereference(temp),
|
|
i, 0, 0, 0, 1),
|
|
compare, NULL);
|
|
instructions->push_tail(assign);
|
|
}
|
|
ir_instruction *inst = new ir_return(new ir_dereference(temp));
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_lessThan(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_vec_compare(instructions, declarations, type, ir_binop_less);
|
|
}
|
|
|
|
static void
|
|
generate_lessThanEqual(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_vec_compare(instructions, declarations, type, ir_binop_lequal);
|
|
}
|
|
|
|
static void
|
|
generate_greaterThan(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_vec_compare(instructions, declarations, type, ir_binop_greater);
|
|
}
|
|
|
|
static void
|
|
generate_greaterThanEqual(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_vec_compare(instructions, declarations, type, ir_binop_gequal);
|
|
}
|
|
|
|
static void
|
|
generate_equal(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_vec_compare(instructions, declarations, type, ir_binop_equal);
|
|
}
|
|
|
|
static void
|
|
generate_notEqual(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
generate_vec_compare(instructions, declarations, type, ir_binop_nequal);
|
|
}
|
|
|
|
static void
|
|
generate_vec_compare_function(glsl_symbol_table *symtab,
|
|
exec_list *instructions,
|
|
const char *name,
|
|
void (*generate)(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type),
|
|
bool do_bool)
|
|
{
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *vec2_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 2, 1);
|
|
const glsl_type *vec3_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 3, 1);
|
|
const glsl_type *vec4_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 4, 1);
|
|
const glsl_type *ivec2_type = glsl_type::get_instance(GLSL_TYPE_INT, 2, 1);
|
|
const glsl_type *ivec3_type = glsl_type::get_instance(GLSL_TYPE_INT, 3, 1);
|
|
const glsl_type *ivec4_type = glsl_type::get_instance(GLSL_TYPE_INT, 4, 1);
|
|
const glsl_type *uvec2_type = glsl_type::get_instance(GLSL_TYPE_UINT, 2, 1);
|
|
const glsl_type *uvec3_type = glsl_type::get_instance(GLSL_TYPE_UINT, 3, 1);
|
|
const glsl_type *uvec4_type = glsl_type::get_instance(GLSL_TYPE_UINT, 4, 1);
|
|
const glsl_type *bvec2_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 2, 1);
|
|
const glsl_type *bvec3_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 3, 1);
|
|
const glsl_type *bvec4_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec2_type, vec2_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec3_type, vec3_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec4_type, vec4_type);
|
|
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec2_type, ivec2_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec3_type, ivec3_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec4_type, ivec4_type);
|
|
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec2_type, uvec2_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec3_type, uvec3_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec4_type, uvec4_type);
|
|
|
|
if (do_bool) {
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec2_type, bvec2_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec3_type, bvec3_type);
|
|
generate_function_instance(f, name, instructions, 2, generate,
|
|
bvec4_type, bvec4_type);
|
|
}
|
|
}
|
|
|
|
static void
|
|
generate_length(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result, *temp;
|
|
|
|
(void)type;
|
|
|
|
/* FINISHME: implement the abs(arg) variant for length(float f) */
|
|
|
|
temp = new ir_expression(ir_binop_dot, glsl_type::float_type, arg, arg);
|
|
result = new ir_expression(ir_unop_sqrt, glsl_type::float_type, temp, NULL);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
void
|
|
generate_length_functions(glsl_symbol_table *symtab, exec_list *instructions)
|
|
{
|
|
const char *name = "length";
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *float_type = glsl_type::float_type;
|
|
const glsl_type *vec2_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 2, 1);
|
|
const glsl_type *vec3_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 3, 1);
|
|
const glsl_type *vec4_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, 1, generate_length,
|
|
float_type, float_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_length,
|
|
float_type, vec2_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_length,
|
|
float_type, vec3_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_length,
|
|
float_type, vec4_type);
|
|
}
|
|
|
|
static void
|
|
generate_dot(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_dereference *const arg1 = new ir_dereference(declarations[1]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_dot, glsl_type::float_type, arg0, arg1);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
void
|
|
generate_dot_functions(glsl_symbol_table *symtab, exec_list *instructions)
|
|
{
|
|
const char *name = "dot";
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *float_type = glsl_type::float_type;
|
|
const glsl_type *vec2_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 2, 1);
|
|
const glsl_type *vec3_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 3, 1);
|
|
const glsl_type *vec4_type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, 2, generate_dot,
|
|
float_type, float_type);
|
|
generate_function_instance(f, name, instructions, 2, generate_dot,
|
|
float_type, vec2_type);
|
|
generate_function_instance(f, name, instructions, 2, generate_dot,
|
|
float_type, vec3_type);
|
|
generate_function_instance(f, name, instructions, 2, generate_dot,
|
|
float_type, vec4_type);
|
|
}
|
|
|
|
static void
|
|
generate_any_bvec2(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_logic_or, glsl_type::bool_type,
|
|
new ir_swizzle(arg0, 0, 0, 0, 0, 1),
|
|
new ir_swizzle(arg0, 1, 0, 0, 0, 1));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_any_bvec3(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_logic_or, glsl_type::bool_type,
|
|
new ir_swizzle(arg0, 0, 0, 0, 0, 1),
|
|
new ir_swizzle(arg0, 1, 0, 0, 0, 1));
|
|
result = new ir_expression(ir_binop_logic_or, glsl_type::bool_type,
|
|
result,
|
|
new ir_swizzle(arg0, 2, 0, 0, 0, 1));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_any_bvec4(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_logic_or, glsl_type::bool_type,
|
|
new ir_swizzle(arg0, 0, 0, 0, 0, 1),
|
|
new ir_swizzle(arg0, 1, 0, 0, 0, 1));
|
|
result = new ir_expression(ir_binop_logic_or, glsl_type::bool_type,
|
|
result,
|
|
new ir_swizzle(arg0, 2, 0, 0, 0, 1));
|
|
result = new ir_expression(ir_binop_logic_or, glsl_type::bool_type,
|
|
result,
|
|
new ir_swizzle(arg0, 3, 0, 0, 0, 1));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_all_bvec2(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_logic_and, glsl_type::bool_type,
|
|
new ir_swizzle(arg0, 0, 0, 0, 0, 1),
|
|
new ir_swizzle(arg0, 1, 0, 0, 0, 1));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_all_bvec3(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_logic_and, glsl_type::bool_type,
|
|
new ir_swizzle(arg0, 0, 0, 0, 0, 1),
|
|
new ir_swizzle(arg0, 1, 0, 0, 0, 1));
|
|
result = new ir_expression(ir_binop_logic_and, glsl_type::bool_type,
|
|
result,
|
|
new ir_swizzle(arg0, 2, 0, 0, 0, 1));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_all_bvec4(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
(void)type;
|
|
|
|
result = new ir_expression(ir_binop_logic_and, glsl_type::bool_type,
|
|
new ir_swizzle(arg0, 0, 0, 0, 0, 1),
|
|
new ir_swizzle(arg0, 1, 0, 0, 0, 1));
|
|
result = new ir_expression(ir_binop_logic_and, glsl_type::bool_type,
|
|
result,
|
|
new ir_swizzle(arg0, 2, 0, 0, 0, 1));
|
|
result = new ir_expression(ir_binop_logic_and, glsl_type::bool_type,
|
|
result,
|
|
new ir_swizzle(arg0, 3, 0, 0, 0, 1));
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
static void
|
|
generate_not(exec_list *instructions,
|
|
ir_variable **declarations,
|
|
const glsl_type *type)
|
|
{
|
|
ir_dereference *const arg0 = new ir_dereference(declarations[0]);
|
|
ir_rvalue *result;
|
|
|
|
result = new ir_expression(ir_unop_logic_not, type, arg0, NULL);
|
|
|
|
ir_instruction *inst = new ir_return(result);
|
|
instructions->push_tail(inst);
|
|
}
|
|
|
|
void
|
|
generate_any_functions(glsl_symbol_table *symtab, exec_list *instructions)
|
|
{
|
|
const char *name = "any";
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *bvec2_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 2, 1);
|
|
const glsl_type *bvec3_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 3, 1);
|
|
const glsl_type *bvec4_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, 1, generate_any_bvec2,
|
|
glsl_type::bool_type, bvec2_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_any_bvec3,
|
|
glsl_type::bool_type, bvec3_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_any_bvec4,
|
|
glsl_type::bool_type, bvec4_type);
|
|
}
|
|
|
|
void
|
|
generate_all_functions(glsl_symbol_table *symtab, exec_list *instructions)
|
|
{
|
|
const char *name = "all";
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *bvec2_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 2, 1);
|
|
const glsl_type *bvec3_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 3, 1);
|
|
const glsl_type *bvec4_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, 1, generate_all_bvec2,
|
|
glsl_type::bool_type, bvec2_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_all_bvec3,
|
|
glsl_type::bool_type, bvec3_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_all_bvec4,
|
|
glsl_type::bool_type, bvec4_type);
|
|
}
|
|
|
|
void
|
|
generate_not_functions(glsl_symbol_table *symtab, exec_list *instructions)
|
|
{
|
|
const char *name = "not";
|
|
ir_function *const f = new ir_function(name);
|
|
const glsl_type *bvec2_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 2, 1);
|
|
const glsl_type *bvec3_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 3, 1);
|
|
const glsl_type *bvec4_type = glsl_type::get_instance(GLSL_TYPE_BOOL, 4, 1);
|
|
|
|
bool added = symtab->add_function(name, f);
|
|
assert(added);
|
|
|
|
instructions->push_tail(f);
|
|
|
|
generate_function_instance(f, name, instructions, 1, generate_not,
|
|
bvec2_type, bvec2_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_not,
|
|
bvec3_type, bvec3_type);
|
|
generate_function_instance(f, name, instructions, 1, generate_not,
|
|
bvec4_type, bvec4_type);
|
|
}
|
|
|
|
void
|
|
generate_110_functions(glsl_symbol_table *symtab, exec_list *instructions)
|
|
{
|
|
make_gentype_function(symtab, instructions, "radians", 1, generate_radians);
|
|
make_gentype_function(symtab, instructions, "degrees", 1, generate_degrees);
|
|
/* FINISHME: sin() */
|
|
/* FINISHME: cos() */
|
|
/* FINISHME: tan() */
|
|
/* FINISHME: asin() */
|
|
/* FINISHME: acos() */
|
|
/* FINISHME: atan(y,x) */
|
|
/* FINISHME: atan(y/x) */
|
|
make_gentype_function(symtab, instructions, "pow", 2, generate_pow);
|
|
make_gentype_function(symtab, instructions, "exp", 1, generate_exp);
|
|
make_gentype_function(symtab, instructions, "log", 1, generate_log);
|
|
make_gentype_function(symtab, instructions, "exp2", 1, generate_exp2);
|
|
make_gentype_function(symtab, instructions, "log2", 1, generate_log2);
|
|
make_gentype_function(symtab, instructions, "sqrt", 1, generate_sqrt);
|
|
make_gentype_function(symtab, instructions, "inversesqrt", 1, generate_rsq);
|
|
make_gentype_function(symtab, instructions, "abs", 1, generate_abs);
|
|
/* FINISHME: sign() */
|
|
make_gentype_function(symtab, instructions, "floor", 1, generate_floor);
|
|
make_gentype_function(symtab, instructions, "ceil", 1, generate_ceil);
|
|
/* FINISHME: fract() */
|
|
/* FINISHME: mod(x, float y) */
|
|
make_gentype_function(symtab, instructions, "mod", 2, generate_mod);
|
|
make_gentype_function(symtab, instructions, "min", 2, generate_min);
|
|
/* FINISHME: min(x, float y) */
|
|
make_gentype_function(symtab, instructions, "max", 2, generate_max);
|
|
/* FINISHME: max(x, float y) */
|
|
make_gentype_function(symtab, instructions, "clamp", 3, generate_clamp);
|
|
/* FINISHME: clamp() */
|
|
make_gentype_function(symtab, instructions, "mix", 3, generate_mix_vec);
|
|
/* FINISHME: mix() */
|
|
/* FINISHME: step() */
|
|
/* FINISHME: step() */
|
|
/* FINISHME: smoothstep() */
|
|
/* FINISHME: smoothstep() */
|
|
/* FINISHME: floor() */
|
|
/* FINISHME: step() */
|
|
generate_length_functions(symtab, instructions);
|
|
/* FINISHME: distance() */
|
|
generate_dot_functions(symtab, instructions);
|
|
/* FINISHME: cross() */
|
|
make_gentype_function(symtab, instructions, "normalize", 1,
|
|
generate_normalize);
|
|
/* FINISHME: normalize() */
|
|
/* FINISHME: ftransform() */
|
|
/* FINISHME: faceforward() */
|
|
/* FINISHME: reflect() */
|
|
/* FINISHME: refract() */
|
|
/* FINISHME: matrixCompMult() */
|
|
generate_vec_compare_function(symtab, instructions,
|
|
"lessThan", generate_lessThan, false);
|
|
generate_vec_compare_function(symtab, instructions,
|
|
"lessThanEqual", generate_lessThanEqual,
|
|
false);
|
|
generate_vec_compare_function(symtab, instructions,
|
|
"greaterThan", generate_greaterThan, false);
|
|
generate_vec_compare_function(symtab, instructions,
|
|
"greaterThanEqual", generate_greaterThanEqual,
|
|
false);
|
|
generate_vec_compare_function(symtab, instructions,
|
|
"equal", generate_equal, false);
|
|
generate_vec_compare_function(symtab, instructions,
|
|
"notEqual", generate_notEqual, false);
|
|
generate_any_functions(symtab, instructions);
|
|
generate_all_functions(symtab, instructions);
|
|
generate_not_functions(symtab, instructions);
|
|
/* FINISHME: texture*() */
|
|
/* FINISHME: shadow*() */
|
|
/* FINISHME: dFd[xy]() */
|
|
/* FINISHME: fwidth() */
|
|
}
|
|
|
|
void
|
|
_mesa_glsl_initialize_functions(exec_list *instructions,
|
|
struct _mesa_glsl_parse_state *state)
|
|
{
|
|
generate_110_functions(state->symbols, instructions);
|
|
}
|