projects / mesa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add ir_dereference constructor for structure field dereferences
[mesa.git] / builtin_function.cpp
diff --git a/builtin_function.cpp b/builtin_function.cpp
index c83bdd0a2c52d9eb737131d2f88c70b8c753f73e..ff731c21625db2919190ba5f0cffb5e78df812e1 100644 (file)
--- a/builtin_function.cpp
+++ b/builtin_function.cpp
@@ -187,6 +187,23 @@ generate_max(exec_list *instructions,
    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,
@@ -236,8 +253,6 @@ generate_pow(exec_list *instructions,
 
 void
 generate_function_instance(ir_function *f,
-                          const char *name,
-                          exec_list *instructions,
                           int n_args,
                           void (*generate)(exec_list *instructions,
                                            ir_variable **declarations,
@@ -250,9 +265,6 @@ generate_function_instance(ir_function *f,
    ir_function_signature *const sig = new ir_function_signature(ret_type);
    f->add_signature(sig);
 
-   ir_label *const label = new ir_label(name, sig);
-   instructions->push_tail(label);
-   sig->definition = label;
    static const char *arg_names[] = {
       "arg0",
       "arg1",
@@ -270,6 +282,7 @@ generate_function_instance(ir_function *f,
    }
 
    generate(&sig->body, declarations, type);
+   sig->is_defined = true;
 }
 
 void
@@ -281,22 +294,159 @@ make_gentype_function(glsl_symbol_table *symtab, exec_list *instructions,
                                       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);
 
-   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);
+   instructions->push_tail(f);
+
+   generate_function_instance(f, n_args, generate,
+                             glsl_type::float_type, glsl_type::float_type);
+   generate_function_instance(f, n_args, generate,
+                             glsl_type::vec2_type, glsl_type::vec2_type);
+   generate_function_instance(f, n_args, generate,
+                             glsl_type::vec3_type, glsl_type::vec3_type);
+   generate_function_instance(f, n_args, generate,
+                             glsl_type::vec4_type, glsl_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");
+   instructions->push_tail(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 *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, 2, generate,
+                             bvec2_type, glsl_type::vec2_type);
+   generate_function_instance(f, 2, generate,
+                             bvec3_type, glsl_type::vec3_type);
+   generate_function_instance(f, 2, generate,
+                             bvec4_type, glsl_type::vec4_type);
+
+   generate_function_instance(f, 2, generate,
+                             bvec2_type, ivec2_type);
+   generate_function_instance(f, 2, generate,
+                             bvec3_type, ivec3_type);
+   generate_function_instance(f, 2, generate,
+                             bvec4_type, ivec4_type);
+
+   generate_function_instance(f, 2, generate,
+                             bvec2_type, uvec2_type);
+   generate_function_instance(f, 2, generate,
+                             bvec3_type, uvec3_type);
+   generate_function_instance(f, 2, generate,
+                             bvec4_type, uvec4_type);
+
+   if (do_bool) {
+      generate_function_instance(f, 2, generate,
+                                bvec2_type, bvec2_type);
+      generate_function_instance(f, 2, generate,
+                                bvec3_type, bvec3_type);
+      generate_function_instance(f, 2, generate,
+                                bvec4_type, bvec4_type);
+   }
 }
 
 static void
@@ -323,22 +473,20 @@ 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);
 
-   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);
+   instructions->push_tail(f);
+
+   generate_function_instance(f, 1, generate_length,
+                             glsl_type::float_type, glsl_type::float_type);
+   generate_function_instance(f, 1, generate_length,
+                             glsl_type::float_type, glsl_type::vec2_type);
+   generate_function_instance(f, 1, generate_length,
+                             glsl_type::float_type, glsl_type::vec3_type);
+   generate_function_instance(f, 1, generate_length,
+                             glsl_type::float_type, glsl_type::vec4_type);
 }
 
 static void
@@ -363,22 +511,20 @@ 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);
 
-   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);
+   instructions->push_tail(f);
+
+   generate_function_instance(f, 2, generate_dot,
+                             glsl_type::float_type, glsl_type::float_type);
+   generate_function_instance(f, 2, generate_dot,
+                             glsl_type::float_type, glsl_type::vec2_type);
+   generate_function_instance(f, 2, generate_dot,
+                             glsl_type::float_type, glsl_type::vec3_type);
+   generate_function_instance(f, 2, generate_dot,
+                             glsl_type::float_type, glsl_type::vec4_type);
 }
 
 static void
@@ -533,11 +679,13 @@ generate_any_functions(glsl_symbol_table *symtab, exec_list *instructions)
    bool added = symtab->add_function(name, f);
    assert(added);
 
-   generate_function_instance(f, name, instructions, 1, generate_any_bvec2,
+   instructions->push_tail(f);
+
+   generate_function_instance(f, 1, generate_any_bvec2,
                              glsl_type::bool_type, bvec2_type);
-   generate_function_instance(f, name, instructions, 1, generate_any_bvec3,
+   generate_function_instance(f, 1, generate_any_bvec3,
                              glsl_type::bool_type, bvec3_type);
-   generate_function_instance(f, name, instructions, 1, generate_any_bvec4,
+   generate_function_instance(f, 1, generate_any_bvec4,
                              glsl_type::bool_type, bvec4_type);
 }
 
@@ -553,11 +701,13 @@ generate_all_functions(glsl_symbol_table *symtab, exec_list *instructions)
    bool added = symtab->add_function(name, f);
    assert(added);
 
-   generate_function_instance(f, name, instructions, 1, generate_all_bvec2,
+   instructions->push_tail(f);
+
+   generate_function_instance(f, 1, generate_all_bvec2,
                              glsl_type::bool_type, bvec2_type);
-   generate_function_instance(f, name, instructions, 1, generate_all_bvec3,
+   generate_function_instance(f, 1, generate_all_bvec3,
                              glsl_type::bool_type, bvec3_type);
-   generate_function_instance(f, name, instructions, 1, generate_all_bvec4,
+   generate_function_instance(f, 1, generate_all_bvec4,
                              glsl_type::bool_type, bvec4_type);
 }
 
@@ -573,11 +723,13 @@ generate_not_functions(glsl_symbol_table *symtab, exec_list *instructions)
    bool added = symtab->add_function(name, f);
    assert(added);
 
-   generate_function_instance(f, name, instructions, 1, generate_not,
+   instructions->push_tail(f);
+
+   generate_function_instance(f, 1, generate_not,
                              bvec2_type, bvec2_type);
-   generate_function_instance(f, name, instructions, 1, generate_not,
+   generate_function_instance(f, 1, generate_not,
                              bvec3_type, bvec3_type);
-   generate_function_instance(f, name, instructions, 1, generate_not,
+   generate_function_instance(f, 1, generate_not,
                              bvec4_type, bvec4_type);
 }
 
@@ -611,7 +763,7 @@ generate_110_functions(glsl_symbol_table *symtab, exec_list *instructions)
    /* FINISHME: min(x, float y) */
    make_gentype_function(symtab, instructions, "max", 2, generate_max);
    /* FINISHME: max(x, float y) */
-   /* FINISHME: clamp() */
+   make_gentype_function(symtab, instructions, "clamp", 3, generate_clamp);
    /* FINISHME: clamp() */
    make_gentype_function(symtab, instructions, "mix", 3, generate_mix_vec);
    /* FINISHME: mix() */
@@ -633,12 +785,20 @@ generate_110_functions(glsl_symbol_table *symtab, exec_list *instructions)
    /* FINISHME: reflect() */
    /* FINISHME: refract() */
    /* FINISHME: matrixCompMult() */
-   /* FINISHME: lessThan() */
-   /* FINISHME: lessThanEqual() */
-   /* FINISHME: greaterThan() */
-   /* FINISHME: greaterThanEqual() */
-   /* FINISHME: equal() */
-   /* FINISHME: notEqual() */
+   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);