--- libgender/shader.h 2004/10/23 23:36:45 1.6 +++ libgender/shader.h 2004/11/03 01:37:23 1.27 @@ -1,6 +1,10 @@ #ifndef SHADER_H #define SHADER_H +#include + +#include +#include #include #include "opengl.h" @@ -12,9 +16,25 @@ const int NAMELEN = 32; + struct shader_builder + { + static struct shader_builder *cur; + + set seen; + + ostringstream global; + ostringstream local; + ostringstream code; + + bool first (const void *p); + + static void start (); + static string stop (); + }; + template struct sl_expr { - const T t; + const T &t; sl_expr (const T &t) : t(t) { } void operator ()() const { t (); } template @@ -45,12 +65,72 @@ void operator ()() const { a (); b (); c (); d(); } }; + struct sl_func0 + { + const char *name_par; + sl_func0 (const char *name_par) : name_par(name_par) { } + + void begin () const + { + shader_builder::cur->code << name_par; + } + + void comma () const + { + shader_builder::cur->code << ", "; + } + + void end () const + { + shader_builder::cur->code << ")"; + } + + void operator ()() const + { + begin (); + end (); + } + }; + + template + struct sl_func1 : sl_func0 + { + const A a; + sl_func1 (const char *name, const A &a) : sl_func0(name), a(a) { } + void operator ()() const { begin (); a (); end (); } + }; + + template + struct sl_func2 : sl_func0 + { + const A a; const B b; + sl_func2 (const char *name, const A &a, const B &b) : sl_func0(name), a(a), b(b) { } + void operator ()() const { begin (); a (); comma (); b (); end (); } + }; + + template + struct sl_func3 : sl_func0 + { + const A a; const B b; const C c; + sl_func3 (const char *name, const A &a, const B &b, const C &c) : sl_func0(name), a(a), b(b), c(c) { } + void operator ()() const { begin (); a (); comma (); b (); comma (); c (); end (); } + }; + + template + struct sl_func4 : sl_func0 + { + const A a; const B b; const C c; const D d; + sl_func4 (const char *name, const A &a, const B &b, const C &c, const D &d) : sl_func0(name), a(a), b(b), c(c), d(d) { } + void operator ()() const { begin (); a (); comma (); b (); comma (); c (); comma (); d(); end (); } + }; + class refcounted { template friend class ref; - mutable int refcnt; + mutable unsigned int refcnt; void refcnt_inc () const { refcnt++; } - void refcnt_dec () const; + void refcnt_dec () const { if (!--refcnt) refcnt_destroy (); } + void refcnt_destroy () const; public: refcounted () : refcnt(0) { } virtual ~refcounted (); @@ -160,25 +240,8 @@ typedef ref var; typedef ref uniform; - struct shader_builder - { - vector refs; // uniform parameters - vector temps; // temporary variables - vector streams; // varying inputs & outputs - - ostringstream source; - - template - shader_builder &operator <<(const type &t) - { - source << t; - return *this; - } - }; - struct fragment_i : refcounted { - virtual void build (shader_builder &b) = 0; }; typedef ref fragment; @@ -188,95 +251,145 @@ }; // a simple predeclared variable with unspecified type - struct glvar_i : lvalue_i + struct gluvar_i : lvalue_i { const char *name; - void build (shader_builder &b); - glvar_i (const char *name) : name (name) { } + + void operator ()() const + { + shader_builder::cur->code << name; + } + + gluvar_i (const char *name) : name (name) { } }; - typedef auto_lvalue_ref1 glvar; + typedef auto_lvalue_ref1 gluvar; struct var_i : lvalue_i { static unsigned int next_id; char name[NAMELEN]; + const char *domainstr; const char *typestr; - void build (shader_builder &b); - virtual void build_decl (ostringstream &b); - - var_i (const char *typestr); + void operator ()() const; + + var_i (const char *domainstr, const char *typestr); ~var_i (); }; struct uniform_i : var_i { - bool dirty; - - virtual void update () = 0; + GLint location (); - void build (shader_builder &b); - void build_decl (ostringstream &b); uniform_i (const char *strtype); }; - template + template struct uniform2_i : uniform_i { gltype data[dimension]; - void update () - { - if (dirty) - { - //upd (param, data); - dirty = false; - } - } - uniform2_i () : uniform_i (strtype) { } }; - template - struct uniform_f_i : uniform2_i + template + struct uniform_f_i : uniform2_i { }; - struct uniform_1f_i : uniform_f_i<1, str_float, cgGLSetParameter1fv> { - void operator =(GLfloat v) + struct uniform_1f_i : uniform_f_i<1, str_float> { + void set (GLfloat v) { data[0] = v; - dirty = true; + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniform1fvARB (loc, 1, data); } }; - struct uniform_2f_i : uniform_f_i<2, str_vec2, cgGLSetParameter2fv> { }; + struct uniform_2f_i : uniform_f_i<2, str_vec2> { + void set (GLfloat x, GLfloat y) + { + data[0] = x; + data[1] = y; + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniform2fvARB (loc, 1, data); + } + + void set (const vec2 &v) { set (v.x, v.y); } + }; - struct uniform_3f_i : uniform_f_i<3, str_vec3, cgGLSetParameter3fv> { - void operator =(const vec3 &v) + struct uniform_3f_i : uniform_f_i<3, str_vec3> { + void set (GLfloat x, GLfloat y, GLfloat z) { - data[0] = v.x; - data[1] = v.y; - data[2] = v.z; - dirty = true; + data[0] = x; + data[1] = y; + data[2] = z; + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniform3fvARB (loc, 1, data); } + + void set (const vec3 &v) { set (v.x, v.y, v.z); } }; - struct uniform_4f_i : uniform_f_i<4, str_vec4, cgGLSetParameter4fv> { -#if 0 - void operator =(const gl::matrix &m) + struct uniform_4f_i : uniform_f_i<4, str_vec4> { + void set (GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - memcpy (data, m.data, 16 * sizeof (GLfloat)); - dirty = true; + data[0] = x; + data[1] = y; + data[2] = z; + data[3] = w; + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniform4fvARB (loc, 1, data); + } + + void set (const vec4 &v) { set (v.x, v.y, v.z, v.w); } + }; + + struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2> + { + void set (const GLfloat d[4]) + { + memcpy (data, d, 4 * sizeof (GLfloat)); + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniformMatrix2fvARB (loc, 1, 0, data); + } + }; + + struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3> + { + void set (const GLfloat d[9]) + { + memcpy (data, d, 9 * sizeof (GLfloat)); + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniformMatrix3fvARB (loc, 1, 0, data); } -#endif }; - struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { }; - struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { }; - struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { }; + struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4> + { + void set (const gl::matrix &m) + { + memcpy (data, m.data, 16 * sizeof (GLfloat)); + + GLint loc = location (); + if (loc >= 0) // workaround for buggy drivers + glUniformMatrix4fvARB (loc, 1, 0, data); + } + }; template struct var_ref : ref @@ -297,10 +410,11 @@ typedef var_ref uniform_matrix_3f; typedef var_ref uniform_matrix_4f; +#if 0 + // to be used for attributes + struct stream_i : var_i { - void build (shader_builder &b); - void build_decl (ostringstream &b); stream_i (const char *strtype); }; @@ -318,7 +432,7 @@ template struct varying_f_i : varying_i { - void set (const gl::vertex_buffer_object &vb, GLint offset) + void set (const gl::vertex_buffer &vb, GLint offset) { varying_i::set (gl::format_stride (vb.format), (GLvoid *)(long)offset); } @@ -330,7 +444,7 @@ struct varying_2f_i : varying_f_i<2, str_vec2> { - void set_t (const gl::vertex_buffer_object &vb) + void set_t (const gl::vertex_buffer &vb) { set (vb, gl::format_offset_t (vb.format)); } @@ -338,12 +452,12 @@ struct varying_3f_i : varying_f_i<3, str_vec3> { - void set_p (const gl::vertex_buffer_object &vb) + void set_p (const gl::vertex_buffer &vb) { set (vb, gl::format_offset_p (vb.format)); } - void set_n (const gl::vertex_buffer_object &vb) + void set_n (const gl::vertex_buffer &vb) { set (vb, gl::format_offset_n (vb.format)); } @@ -357,190 +471,200 @@ typedef var_ref varying_2f; typedef var_ref varying_3f; typedef var_ref varying_4f; +#endif - struct temporary_i : var_i + struct varying_i : var_i { - void build (shader_builder &b); + varying_i (const char *strtype); + }; + struct temporary_i : var_i + { temporary_i (const char *strtype); }; - template - struct temp_ref : ref + template + struct glnvar_ref : ref { - temp_ref () - : ref (*new temporary_i (strtype)) + glnvar_ref () + : ref (*new var_i (strtype)) + { + } + +#if 0 + template + glnvar_ref (const sl_expr &e) + : ref (*new var_i (strtype)) { + (*this) = e; } +#endif template - const temp_ref &operator =(const expr &e) const; + const glnvar_ref &operator =(const expr &e) const; }; - typedef temp_ref temp_1f; - typedef temp_ref temp_2f; - typedef temp_ref temp_3f; - typedef temp_ref temp_4f; - typedef temp_ref temp_matrix_2f; - typedef temp_ref temp_matrix_3f; - typedef temp_ref temp_matrix_4f; + typedef glnvar_ref temp_1f; + typedef glnvar_ref temp_2f; + typedef glnvar_ref temp_3f; + typedef glnvar_ref temp_4f; + typedef glnvar_ref temp_matrix_2f; + typedef glnvar_ref temp_matrix_3f; + typedef glnvar_ref temp_matrix_4f; - template - struct sampler_i : uniform_i + typedef glnvar_ref varying_1f; + typedef glnvar_ref varying_2f; + typedef glnvar_ref varying_3f; + typedef glnvar_ref varying_4f; + typedef glnvar_ref varying_matrix_2f; + typedef glnvar_ref varying_matrix_3f; + typedef glnvar_ref varying_matrix_4f; + + struct texture_units { - GLuint texture; + static int units[8]; + static int unit_count; - void update () + static GLenum get_texture_unit () { - if (dirty) - { - //cgGLSetTextureParameter (param, texture); - dirty = false; - } + assert (unit_count); + return units[--unit_count]; } - void begin () + static void put_texture_unit (GLenum unit) { - cgGLEnableTextureParameter (texture); + assert (unit_count < 8); + units[unit_count++] = unit; } - - sampler_i (GLuint texturename) : uniform_i (strtype), texture (texturename) { } }; - struct sampler_1d_i : sampler_i + template + struct sampler_i : uniform_i, texture_units { - sampler_1d_i (GLuint texturename) : sampler_i (texturename) { } - }; + int unit; + GLuint name; - struct sampler_1d_shadow_i : sampler_i - { - sampler_1d_shadow_i (GLuint texturename) : sampler_i (texturename) { } + void enable () + { +#if DEBUG + assert (unit < 0); +#endif + GLint loc = location (); + + if (loc >= 0) + { + unit = get_texture_unit (); + glActiveTexture (GL_TEXTURE0 + unit); + glBindTexture (gltype, name); + glUniform1iARB (loc, unit); + } + } + + void disable () + { + if (unit >= 0) + { + put_texture_unit (unit); + unit = -1; + } + } + + template + void set (const gl::vertex_buffer &vb, const vectype bufferclass::*vp) + { + glTexCoordPointer ( + vector_traits::dimension (), + gl::type_traits::basetype>::glenum (), + sizeof (bufferclass), + (GLvoid)(char bufferclass::*)vp + ); + } + + sampler_i (GLuint texture) + : uniform_i (strtype) + , name (texture) +#if DEBUG + , unit (-1) +#endif + { + } }; - struct sampler_2d_i : sampler_i + struct sampler_1d_i : sampler_i { - sampler_2d_i (GLuint texturename) : sampler_i (texturename) { } + sampler_1d_i (GLuint texture) : sampler_i (texture) { } }; - struct sampler_2d_shadow_i : sampler_i + struct sampler_1d_shadow_i : sampler_i { - sampler_2d_shadow_i (GLuint texturename) : sampler_i (texturename) { } + sampler_1d_shadow_i (GLuint texture) : sampler_i (texture) { } }; - struct sampler_2d_rect_i : sampler_i + struct sampler_2d_i : sampler_i { - sampler_2d_rect_i (GLuint texturename) : sampler_i (texturename) { } + sampler_2d_i (GLuint texture) : sampler_i (texture) { } }; - struct sampler_2d_rect_shadow_i : sampler_i + struct sampler_2d_shadow_i : sampler_i { - sampler_2d_rect_shadow_i (GLuint texturename) : sampler_i (texturename) { } + sampler_2d_shadow_i (GLuint texture) : sampler_i (texture) { } }; - struct sampler_3d_i : sampler_i + struct sampler_2d_rect_i : sampler_i { - sampler_3d_i (GLuint texturename) : sampler_i (texturename) { } + sampler_2d_rect_i (GLuint texture) : sampler_i (texture) { } }; - struct sampler_3d_rect_i : sampler_i + struct sampler_2d_rect_shadow_i : sampler_i { - sampler_3d_rect_i (GLuint texturename) : sampler_i (texturename) { } + sampler_2d_rect_shadow_i (GLuint texture) : sampler_i (texture) { } }; - struct sampler_cube_i : sampler_i + struct sampler_3d_i : sampler_i { - sampler_cube_i (GLuint texturename) : sampler_i (texturename) { } + sampler_3d_i (GLuint texture) : sampler_i (texture) { } }; - typedef auto_ref1 sampler_1d; - typedef auto_ref1 sampler_1d_shadow; - typedef auto_ref1 sampler_2d; - typedef auto_ref1 sampler_2d_shadow; - typedef auto_ref1 sampler_2d_rect; - typedef auto_ref1 sampler_2d_rect_shadow; - typedef auto_ref1 sampler_3d; - typedef auto_ref1 sampler_3d_rect; - typedef auto_ref1 sampler_cube; - - struct fragment_const_string_i : fragment_i + struct sampler_3d_rect_i : sampler_i { - const char *str; - - void build (shader_builder &b); - - fragment_const_string_i (const char *str) : str(str) { } + sampler_3d_rect_i (GLuint texture) : sampler_i (texture) { } }; - typedef auto_ref1 fragment_const_string; - - struct fragment_string_i : fragment_i + struct sampler_cube_i : sampler_i { - char *str; - - void build (shader_builder &b); - - fragment_string_i (const char *str) : str (strdup (str)) { } - ~fragment_string_i (); + sampler_cube_i (GLuint texture) : sampler_i (texture) { } }; - struct fragment_vector_i : fragment_i, vector + template + struct sampler_ref : auto_ref1 { - void build (shader_builder &b); - - template - void append (const ref &f) - { - push_back (f); - } - - template - void append (const sl_expr &e) - { - e (); - } - - void append_const (const char *s) + sampler_ref (GLuint texture) + : auto_ref1 (texture) { - push_back (*new fragment_const_string_i (s)); } - - void append_string (const char *s) - { - push_back (*new fragment_string_i (s)); - } - -#if 0 - fragment_vector_i &operator <<(statement_i &f) - { - push_back (*new fragment_const_string_i (" ")); - - for (vector::iterator i = f.begin (); i != f.end (); i++) - push_back (*i); - - push_back (*new fragment_const_string_i (";\n")); - return *this; - } -#endif }; - typedef ref fragment_vector; + typedef sampler_ref sampler_1d; + typedef sampler_ref sampler_1d_shadow; + typedef sampler_ref sampler_2d; + typedef sampler_ref sampler_2d_shadow; + typedef sampler_ref sampler_2d_rect; + typedef sampler_ref sampler_2d_rect_shadow; + typedef sampler_ref sampler_3d; + typedef sampler_ref sampler_3d_rect; + typedef sampler_ref sampler_cube; - struct shader_object_i : fragment_vector_i + struct shader_object_i : refcounted { GLenum type; GLuint id; // GLhandleARB, but 2.0 will use uint - string source (); - void compile (); - void start (); - void stop (); + void compile (const string &source); shader_object_i (GLenum type); ~shader_object_i (); }; - extern shader_object_i *cur; // record actions to this shader - template struct shader_object : ref { @@ -553,19 +677,28 @@ typedef shader_object vertex_shader; typedef shader_object fragment_shader; - template - struct sl_append + struct program_object_i : refcounted { - T t; + static struct program_object_i *cur; // currently bound program - sl_append (const T &t) : t(t) { } + GLuint id; - void operator ()() const - { - cur->push_back (t); - } + vertex_shader vsh; + fragment_shader fsh; + + map uloc; // uniform location + + program_object_i (); + ~program_object_i (); + + void link (); + + void enable (); + void disable (); }; + typedef auto_ref0 program_object; + template struct sl_string { @@ -573,7 +706,7 @@ void operator ()() const { - cur->push_back (*new fragment_string_i (str)); + shader_builder::cur->code << str; } }; @@ -583,7 +716,10 @@ sl_float (GLfloat c) : c(c) { } - void operator ()() const; + void operator ()() const + { + shader_builder::cur->code << c; + } }; template @@ -653,70 +789,73 @@ template<> struct sl_convert { - typedef sl_expr< sl_string<60> > T; - static const T convert (const vec2 &v); + static const sl_expr< sl_string<60> > convert (const vec2 &v); }; template<> struct sl_convert { - typedef sl_expr< sl_string<80> > T; - static const T convert (const vec3 &v); + static const sl_expr< sl_string<80> > convert (const vec3 &v); }; template<> struct sl_convert { - typedef sl_expr< sl_string<100> > T; - static const T convert (const vec4 &v); + static const sl_expr< sl_string<100> > convert (const vec4 &v); }; template<> - template - struct sl_convert< var_ref > + template + struct sl_convert< var_ref > { - typedef sl_expr< sl_append< var_ref > > T; - static inline const T convert (const var_ref &v) + typedef sl_expr< var_i > T; + static inline const T convert (const var_ref &v) { - return sl_append< var_ref > (v); + return T (*&v); } }; template<> - struct sl_convert + template + struct sl_convert< auto_lvalue_ref1 > { - typedef sl_expr< sl_append > T; - static inline const T convert (const glvar &v) + typedef sl_expr< gluvar_i > T; + static inline const T convert (const auto_lvalue_ref1 &v) { - return sl_append (v); + return T (*&v); } }; template<> - template - struct sl_convert< temp_ref > + template + struct sl_convert< glnvar_ref > { - typedef sl_expr< sl_append< temp_ref > > T; - static inline const T convert (const temp_ref &v) + typedef sl_expr< var_i > T; + static inline const T convert (const glnvar_ref &v) { - return sl_expr< sl_append< temp_ref > >( - sl_append< temp_ref > (v) - ); + return T (*&v); } }; - extern const fragment_const_string str_2sp; - extern const fragment_const_string str_equal; - extern const fragment_const_string str_endl; + template<> + template + struct sl_convert< sampler_ref > + { + typedef sl_expr< sampler_i > T; + static inline const T convert (const sampler_ref &v) + { + return T (*&v); + } + }; - template - inline void sl_assign (const fragment &f, const expr &e) + template + inline void sl_assign (const lvalue &l, const expr &e) { - cur->append (str_2sp); - cur->append (f); - cur->append (str_equal); + shader_builder::cur->code << " "; + sl_convert::convert (l) (); + shader_builder::cur->code << " = "; sl_convert::convert (e) (); - cur->append (str_endl); + shader_builder::cur->code << ";\n"; } template @@ -743,164 +882,369 @@ return *this; } - template + template template - inline const temp_ref &temp_ref::operator =(const expr &e) const + inline const glnvar_ref &glnvar_ref::operator =(const expr &e) const { sl_assign (*this, e); return *this; } - struct sl_append_const_string - { - fragment_const_string str; - sl_append_const_string (const char *s) - : str (s) - { } - - void operator ()() const - { - cur->push_back (str); - } - }; + namespace compile { + using namespace shader; -# define SHADER_BINOP(op, str) \ - extern const sl_append_const_string str_ ## str; \ - template \ - inline const sl_expr< sl_concat3< typename sl_convert::T, \ - sl_append_const_string, \ + template + inline const sl_expr< sl_func1::T> > + operator +(const T &t) + { + return sl_func1::T> ("+(", sl_convert::convert (t)); + } + + template + inline const sl_expr< sl_func1::T> > + operator -(const T &t) + { + return sl_func1::T> ("-(", sl_convert::convert (t)); + } + + template + struct sl_binop + { + const A a; const char *b; const C c; + sl_binop (const A &a, const char *b, const C &c) : a(a), b(b), c(c) { } + void operator ()() const + { + shader_builder::cur->code << "("; + a (); + shader_builder::cur->code << b; + c (); + shader_builder::cur->code << ")"; + } + }; + + template + struct sl_ternary + { + const A a; const B b; const C c; + sl_ternary (const A &a, const B &b, const C &c) : a(a), b(b), c(c) { } + void operator ()() const + { + shader_builder::cur->code << "("; + a (); + shader_builder::cur->code << ") ? ("; + b (); + shader_builder::cur->code << ") : ("; + c (); + shader_builder::cur->code << ")"; + } + }; + +# define SHADER_BINOP(op) \ + template \ + inline const sl_expr< sl_binop< typename sl_convert::T, \ typename sl_convert::T > > \ - operator op(const A &a, const B &b) \ - { \ - return concat (sl_convert::convert (a), str_ ## str, sl_convert::convert (b)); \ - } - - SHADER_BINOP (+, plus); - SHADER_BINOP (-, minus); - SHADER_BINOP (*, mul); - SHADER_BINOP (/, div); - -# undef SHADER_BINOP - - void swizzle_mask (sl_string<7> &s, int mask); - - extern const sl_append_const_string str_lpar; - extern const sl_append_const_string str_rpar; + operator op(const A &a, const B &b) \ + { \ + return sl_binop< typename sl_convert::T, typename sl_convert::T > \ + (sl_convert::convert (a), " " # op " ", sl_convert::convert (b)); \ + } + + SHADER_BINOP (+); + SHADER_BINOP (-); + SHADER_BINOP (*); + SHADER_BINOP (/); + SHADER_BINOP (%); + + SHADER_BINOP (<); + SHADER_BINOP (<=); + SHADER_BINOP (==); + SHADER_BINOP (!=); + SHADER_BINOP (>=); + SHADER_BINOP (>); + +# undef SHADER_BINOP + + template + struct sl_swizzle + { + const A a; + const char *swizzle; + sl_swizzle (const A &a, const char *swizzle) : a(a), swizzle(swizzle) { } + void operator ()() const + { + shader_builder::cur->code << "("; + a (); + shader_builder::cur->code << ")." << swizzle; + } + }; + +# define SHADER_SWIZZLE_OP(type) \ + template \ + inline const sl_expr< sl_swizzle::T> > \ + type (const T &t) \ + { \ + return sl_swizzle::T> (sl_convert::convert (t), #type); \ + } + + // brute force is lovely, ain't it? + SHADER_SWIZZLE_OP (x ) SHADER_SWIZZLE_OP (xx ) SHADER_SWIZZLE_OP (xxx ) SHADER_SWIZZLE_OP (xxxx) + SHADER_SWIZZLE_OP (xxxy) SHADER_SWIZZLE_OP (xxxz) SHADER_SWIZZLE_OP (xxxw) SHADER_SWIZZLE_OP (xxy ) + SHADER_SWIZZLE_OP (xxyx) SHADER_SWIZZLE_OP (xxyy) SHADER_SWIZZLE_OP (xxyz) SHADER_SWIZZLE_OP (xxyw) + SHADER_SWIZZLE_OP (xxz ) SHADER_SWIZZLE_OP (xxzx) SHADER_SWIZZLE_OP (xxzy) SHADER_SWIZZLE_OP (xxzz) + SHADER_SWIZZLE_OP (xxzw) SHADER_SWIZZLE_OP (xxw ) SHADER_SWIZZLE_OP (xxwx) SHADER_SWIZZLE_OP (xxwy) + SHADER_SWIZZLE_OP (xxwz) SHADER_SWIZZLE_OP (xxww) SHADER_SWIZZLE_OP (xy ) SHADER_SWIZZLE_OP (xyx ) + SHADER_SWIZZLE_OP (xyxx) SHADER_SWIZZLE_OP (xyxy) SHADER_SWIZZLE_OP (xyxz) SHADER_SWIZZLE_OP (xyxw) + SHADER_SWIZZLE_OP (xyy ) SHADER_SWIZZLE_OP (xyyx) SHADER_SWIZZLE_OP (xyyy) SHADER_SWIZZLE_OP (xyyz) + SHADER_SWIZZLE_OP (xyyw) SHADER_SWIZZLE_OP (xyz ) SHADER_SWIZZLE_OP (xyzx) SHADER_SWIZZLE_OP (xyzy) + SHADER_SWIZZLE_OP (xyzz) SHADER_SWIZZLE_OP (xyzw) SHADER_SWIZZLE_OP (xyw ) SHADER_SWIZZLE_OP (xywx) + SHADER_SWIZZLE_OP (xywy) SHADER_SWIZZLE_OP (xywz) SHADER_SWIZZLE_OP (xyww) SHADER_SWIZZLE_OP (xz ) + SHADER_SWIZZLE_OP (xzx ) SHADER_SWIZZLE_OP (xzxx) SHADER_SWIZZLE_OP (xzxy) SHADER_SWIZZLE_OP (xzxz) + SHADER_SWIZZLE_OP (xzxw) SHADER_SWIZZLE_OP (xzy ) SHADER_SWIZZLE_OP (xzyx) SHADER_SWIZZLE_OP (xzyy) + SHADER_SWIZZLE_OP (xzyz) SHADER_SWIZZLE_OP (xzyw) SHADER_SWIZZLE_OP (xzz ) SHADER_SWIZZLE_OP (xzzx) + SHADER_SWIZZLE_OP (xzzy) SHADER_SWIZZLE_OP (xzzz) SHADER_SWIZZLE_OP (xzzw) SHADER_SWIZZLE_OP (xzw ) + SHADER_SWIZZLE_OP (xzwx) SHADER_SWIZZLE_OP (xzwy) SHADER_SWIZZLE_OP (xzwz) SHADER_SWIZZLE_OP (xzww) + SHADER_SWIZZLE_OP (xw ) SHADER_SWIZZLE_OP (xwx ) SHADER_SWIZZLE_OP (xwxx) SHADER_SWIZZLE_OP (xwxy) + SHADER_SWIZZLE_OP (xwxz) SHADER_SWIZZLE_OP (xwxw) SHADER_SWIZZLE_OP (xwy ) SHADER_SWIZZLE_OP (xwyx) + SHADER_SWIZZLE_OP (xwyy) SHADER_SWIZZLE_OP (xwyz) SHADER_SWIZZLE_OP (xwyw) SHADER_SWIZZLE_OP (xwz ) + SHADER_SWIZZLE_OP (xwzx) SHADER_SWIZZLE_OP (xwzy) SHADER_SWIZZLE_OP (xwzz) SHADER_SWIZZLE_OP (xwzw) + SHADER_SWIZZLE_OP (xww ) SHADER_SWIZZLE_OP (xwwx) SHADER_SWIZZLE_OP (xwwy) SHADER_SWIZZLE_OP (xwwz) + SHADER_SWIZZLE_OP (xwww) SHADER_SWIZZLE_OP (y ) SHADER_SWIZZLE_OP (yx ) SHADER_SWIZZLE_OP (yxx ) + SHADER_SWIZZLE_OP (yxxx) SHADER_SWIZZLE_OP (yxxy) SHADER_SWIZZLE_OP (yxxz) SHADER_SWIZZLE_OP (yxxw) + SHADER_SWIZZLE_OP (yxy ) SHADER_SWIZZLE_OP (yxyx) SHADER_SWIZZLE_OP (yxyy) SHADER_SWIZZLE_OP (yxyz) + SHADER_SWIZZLE_OP (yxyw) SHADER_SWIZZLE_OP (yxz ) SHADER_SWIZZLE_OP (yxzx) SHADER_SWIZZLE_OP (yxzy) + SHADER_SWIZZLE_OP (yxzz) SHADER_SWIZZLE_OP (yxzw) SHADER_SWIZZLE_OP (yxw ) SHADER_SWIZZLE_OP (yxwx) + SHADER_SWIZZLE_OP (yxwy) SHADER_SWIZZLE_OP (yxwz) SHADER_SWIZZLE_OP (yxww) SHADER_SWIZZLE_OP (yy ) + SHADER_SWIZZLE_OP (yyx ) SHADER_SWIZZLE_OP (yyxx) SHADER_SWIZZLE_OP (yyxy) SHADER_SWIZZLE_OP (yyxz) + SHADER_SWIZZLE_OP (yyxw) SHADER_SWIZZLE_OP (yyy ) SHADER_SWIZZLE_OP (yyyx) SHADER_SWIZZLE_OP (yyyy) + SHADER_SWIZZLE_OP (yyyz) SHADER_SWIZZLE_OP (yyyw) SHADER_SWIZZLE_OP (yyz ) SHADER_SWIZZLE_OP (yyzx) + SHADER_SWIZZLE_OP (yyzy) SHADER_SWIZZLE_OP (yyzz) SHADER_SWIZZLE_OP (yyzw) SHADER_SWIZZLE_OP (yyw ) + SHADER_SWIZZLE_OP (yywx) SHADER_SWIZZLE_OP (yywy) SHADER_SWIZZLE_OP (yywz) SHADER_SWIZZLE_OP (yyww) + SHADER_SWIZZLE_OP (yz ) SHADER_SWIZZLE_OP (yzx ) SHADER_SWIZZLE_OP (yzxx) SHADER_SWIZZLE_OP (yzxy) + SHADER_SWIZZLE_OP (yzxz) SHADER_SWIZZLE_OP (yzxw) SHADER_SWIZZLE_OP (yzy ) SHADER_SWIZZLE_OP (yzyx) + SHADER_SWIZZLE_OP (yzyy) SHADER_SWIZZLE_OP (yzyz) SHADER_SWIZZLE_OP (yzyw) SHADER_SWIZZLE_OP (yzz ) + SHADER_SWIZZLE_OP (yzzx) SHADER_SWIZZLE_OP (yzzy) SHADER_SWIZZLE_OP (yzzz) SHADER_SWIZZLE_OP (yzzw) + SHADER_SWIZZLE_OP (yzw ) SHADER_SWIZZLE_OP (yzwx) SHADER_SWIZZLE_OP (yzwy) SHADER_SWIZZLE_OP (yzwz) + SHADER_SWIZZLE_OP (yzww) SHADER_SWIZZLE_OP (yw ) SHADER_SWIZZLE_OP (ywx ) SHADER_SWIZZLE_OP (ywxx) + SHADER_SWIZZLE_OP (ywxy) SHADER_SWIZZLE_OP (ywxz) SHADER_SWIZZLE_OP (ywxw) SHADER_SWIZZLE_OP (ywy ) + SHADER_SWIZZLE_OP (ywyx) SHADER_SWIZZLE_OP (ywyy) SHADER_SWIZZLE_OP (ywyz) SHADER_SWIZZLE_OP (ywyw) + SHADER_SWIZZLE_OP (ywz ) SHADER_SWIZZLE_OP (ywzx) SHADER_SWIZZLE_OP (ywzy) SHADER_SWIZZLE_OP (ywzz) + SHADER_SWIZZLE_OP (ywzw) SHADER_SWIZZLE_OP (yww ) SHADER_SWIZZLE_OP (ywwx) SHADER_SWIZZLE_OP (ywwy) + SHADER_SWIZZLE_OP (ywwz) SHADER_SWIZZLE_OP (ywww) SHADER_SWIZZLE_OP (z ) SHADER_SWIZZLE_OP (zx ) + SHADER_SWIZZLE_OP (zxx ) SHADER_SWIZZLE_OP (zxxx) SHADER_SWIZZLE_OP (zxxy) SHADER_SWIZZLE_OP (zxxz) + SHADER_SWIZZLE_OP (zxxw) SHADER_SWIZZLE_OP (zxy ) SHADER_SWIZZLE_OP (zxyx) SHADER_SWIZZLE_OP (zxyy) + SHADER_SWIZZLE_OP (zxyz) SHADER_SWIZZLE_OP (zxyw) SHADER_SWIZZLE_OP (zxz ) SHADER_SWIZZLE_OP (zxzx) + SHADER_SWIZZLE_OP (zxzy) SHADER_SWIZZLE_OP (zxzz) SHADER_SWIZZLE_OP (zxzw) SHADER_SWIZZLE_OP (zxw ) + SHADER_SWIZZLE_OP (zxwx) SHADER_SWIZZLE_OP (zxwy) SHADER_SWIZZLE_OP (zxwz) SHADER_SWIZZLE_OP (zxww) + SHADER_SWIZZLE_OP (zy ) SHADER_SWIZZLE_OP (zyx ) SHADER_SWIZZLE_OP (zyxx) SHADER_SWIZZLE_OP (zyxy) + SHADER_SWIZZLE_OP (zyxz) SHADER_SWIZZLE_OP (zyxw) SHADER_SWIZZLE_OP (zyy ) SHADER_SWIZZLE_OP (zyyx) + SHADER_SWIZZLE_OP (zyyy) SHADER_SWIZZLE_OP (zyyz) SHADER_SWIZZLE_OP (zyyw) SHADER_SWIZZLE_OP (zyz ) + SHADER_SWIZZLE_OP (zyzx) SHADER_SWIZZLE_OP (zyzy) SHADER_SWIZZLE_OP (zyzz) SHADER_SWIZZLE_OP (zyzw) + SHADER_SWIZZLE_OP (zyw ) SHADER_SWIZZLE_OP (zywx) SHADER_SWIZZLE_OP (zywy) SHADER_SWIZZLE_OP (zywz) + SHADER_SWIZZLE_OP (zyww) SHADER_SWIZZLE_OP (zz ) SHADER_SWIZZLE_OP (zzx ) SHADER_SWIZZLE_OP (zzxx) + SHADER_SWIZZLE_OP (zzxy) SHADER_SWIZZLE_OP (zzxz) SHADER_SWIZZLE_OP (zzxw) SHADER_SWIZZLE_OP (zzy ) + SHADER_SWIZZLE_OP (zzyx) SHADER_SWIZZLE_OP (zzyy) SHADER_SWIZZLE_OP (zzyz) SHADER_SWIZZLE_OP (zzyw) + SHADER_SWIZZLE_OP (zzz ) SHADER_SWIZZLE_OP (zzzx) SHADER_SWIZZLE_OP (zzzy) SHADER_SWIZZLE_OP (zzzz) + SHADER_SWIZZLE_OP (zzzw) SHADER_SWIZZLE_OP (zzw ) SHADER_SWIZZLE_OP (zzwx) SHADER_SWIZZLE_OP (zzwy) + SHADER_SWIZZLE_OP (zzwz) SHADER_SWIZZLE_OP (zzww) SHADER_SWIZZLE_OP (zw ) SHADER_SWIZZLE_OP (zwx ) + SHADER_SWIZZLE_OP (zwxx) SHADER_SWIZZLE_OP (zwxy) SHADER_SWIZZLE_OP (zwxz) SHADER_SWIZZLE_OP (zwxw) + SHADER_SWIZZLE_OP (zwy ) SHADER_SWIZZLE_OP (zwyx) SHADER_SWIZZLE_OP (zwyy) SHADER_SWIZZLE_OP (zwyz) + SHADER_SWIZZLE_OP (zwyw) SHADER_SWIZZLE_OP (zwz ) SHADER_SWIZZLE_OP (zwzx) SHADER_SWIZZLE_OP (zwzy) + SHADER_SWIZZLE_OP (zwzz) SHADER_SWIZZLE_OP (zwzw) SHADER_SWIZZLE_OP (zww ) SHADER_SWIZZLE_OP (zwwx) + SHADER_SWIZZLE_OP (zwwy) SHADER_SWIZZLE_OP (zwwz) SHADER_SWIZZLE_OP (zwww) SHADER_SWIZZLE_OP (w ) + SHADER_SWIZZLE_OP (wx ) SHADER_SWIZZLE_OP (wxx ) SHADER_SWIZZLE_OP (wxxx) SHADER_SWIZZLE_OP (wxxy) + SHADER_SWIZZLE_OP (wxxz) SHADER_SWIZZLE_OP (wxxw) SHADER_SWIZZLE_OP (wxy ) SHADER_SWIZZLE_OP (wxyx) + SHADER_SWIZZLE_OP (wxyy) SHADER_SWIZZLE_OP (wxyz) SHADER_SWIZZLE_OP (wxyw) SHADER_SWIZZLE_OP (wxz ) + SHADER_SWIZZLE_OP (wxzx) SHADER_SWIZZLE_OP (wxzy) SHADER_SWIZZLE_OP (wxzz) SHADER_SWIZZLE_OP (wxzw) + SHADER_SWIZZLE_OP (wxw ) SHADER_SWIZZLE_OP (wxwx) SHADER_SWIZZLE_OP (wxwy) SHADER_SWIZZLE_OP (wxwz) + SHADER_SWIZZLE_OP (wxww) SHADER_SWIZZLE_OP (wy ) SHADER_SWIZZLE_OP (wyx ) SHADER_SWIZZLE_OP (wyxx) + SHADER_SWIZZLE_OP (wyxy) SHADER_SWIZZLE_OP (wyxz) SHADER_SWIZZLE_OP (wyxw) SHADER_SWIZZLE_OP (wyy ) + SHADER_SWIZZLE_OP (wyyx) SHADER_SWIZZLE_OP (wyyy) SHADER_SWIZZLE_OP (wyyz) SHADER_SWIZZLE_OP (wyyw) + SHADER_SWIZZLE_OP (wyz ) SHADER_SWIZZLE_OP (wyzx) SHADER_SWIZZLE_OP (wyzy) SHADER_SWIZZLE_OP (wyzz) + SHADER_SWIZZLE_OP (wyzw) SHADER_SWIZZLE_OP (wyw ) SHADER_SWIZZLE_OP (wywx) SHADER_SWIZZLE_OP (wywy) + SHADER_SWIZZLE_OP (wywz) SHADER_SWIZZLE_OP (wyww) SHADER_SWIZZLE_OP (wz ) SHADER_SWIZZLE_OP (wzx ) + SHADER_SWIZZLE_OP (wzxx) SHADER_SWIZZLE_OP (wzxy) SHADER_SWIZZLE_OP (wzxz) SHADER_SWIZZLE_OP (wzxw) + SHADER_SWIZZLE_OP (wzy ) SHADER_SWIZZLE_OP (wzyx) SHADER_SWIZZLE_OP (wzyy) SHADER_SWIZZLE_OP (wzyz) + SHADER_SWIZZLE_OP (wzyw) SHADER_SWIZZLE_OP (wzz ) SHADER_SWIZZLE_OP (wzzx) SHADER_SWIZZLE_OP (wzzy) + SHADER_SWIZZLE_OP (wzzz) SHADER_SWIZZLE_OP (wzzw) SHADER_SWIZZLE_OP (wzw ) SHADER_SWIZZLE_OP (wzwx) + SHADER_SWIZZLE_OP (wzwy) SHADER_SWIZZLE_OP (wzwz) SHADER_SWIZZLE_OP (wzww) SHADER_SWIZZLE_OP (ww ) + SHADER_SWIZZLE_OP (wwx ) SHADER_SWIZZLE_OP (wwxx) SHADER_SWIZZLE_OP (wwxy) SHADER_SWIZZLE_OP (wwxz) + SHADER_SWIZZLE_OP (wwxw) SHADER_SWIZZLE_OP (wwy ) SHADER_SWIZZLE_OP (wwyx) SHADER_SWIZZLE_OP (wwyy) + SHADER_SWIZZLE_OP (wwyz) SHADER_SWIZZLE_OP (wwyw) SHADER_SWIZZLE_OP (wwz ) SHADER_SWIZZLE_OP (wwzx) + SHADER_SWIZZLE_OP (wwzy) SHADER_SWIZZLE_OP (wwzz) SHADER_SWIZZLE_OP (wwzw) SHADER_SWIZZLE_OP (www ) + SHADER_SWIZZLE_OP (wwwx) SHADER_SWIZZLE_OP (wwwy) SHADER_SWIZZLE_OP (wwwz) SHADER_SWIZZLE_OP (wwww) + +# undef SHADER_SWIZZLE_OP + +# define SHADER_FUNC0_(name, glname) \ + template \ + inline const sl_expr \ + name () \ + { \ + return sl_func0 (#glname " ("); \ + } + +# define SHADER_FUNC0(name) SHADER_FUNC0_(name,name) + +# define SHADER_FUNC1_(name, glname) \ + template \ + inline const sl_expr< sl_func1::T> > \ + name (const A &a) \ + { \ + return sl_func1::T> (#glname " (", sl_convert::convert (a));\ + } + +# define SHADER_FUNC1(name) SHADER_FUNC1_(name,name) + +# define SHADER_FUNC2_(name, glname) \ + template \ + inline const sl_expr< sl_func2::T, typename sl_convert::T> > \ + name (const A &a, const B &b) \ + { \ + return sl_func2::T, typename sl_convert::T> (#glname " (", sl_convert::convert (a), sl_convert::convert (b));\ + } + +# define SHADER_FUNC2(name) SHADER_FUNC2_(name,name) + +# define SHADER_FUNC3_(name, glname) \ + template \ + inline const sl_expr< sl_func3::T, typename sl_convert::T, typename sl_convert::T> > \ + name (const A &a, const B &b, const C &c) \ + { \ + return sl_func3::T, typename sl_convert::T, typename sl_convert::T> (#glname " (", sl_convert::convert (a), sl_convert::convert (b), sl_convert::convert (c));\ + } + +# define SHADER_FUNC3(name) SHADER_FUNC3_(name,name) + +# define SHADER_FUNC4_(name, glname) \ + template \ + inline const sl_expr< sl_func4::T, typename sl_convert::T, typename sl_convert::T, typename sl_convert::T > > \ + name (const A &a, const B &b, const C &c, const D &d) \ + { \ + return sl_func4::T, typename sl_convert::T, typename sl_convert::T, typename sl_convert::T> (#glname " (", sl_convert::convert (a), sl_convert::convert (b), sl_convert::convert (c), sl_convert::convert (d));\ + } + +# define SHADER_FUNC4(name) SHADER_FUNC4_(name,name) + + SHADER_FUNC1 (abs) + SHADER_FUNC1 (acos) + SHADER_FUNC1 (all) + SHADER_FUNC1 (any) + SHADER_FUNC1 (asin) + SHADER_FUNC1 (atan) + SHADER_FUNC2 (atan) + SHADER_FUNC1 (ceil) + SHADER_FUNC3 (clamp) + SHADER_FUNC1 (cos) + SHADER_FUNC2 (cross) + SHADER_FUNC1 (dFdx) + SHADER_FUNC1 (dFdy) + SHADER_FUNC1 (degrees) + SHADER_FUNC2 (distance) + SHADER_FUNC2 (dot) + SHADER_FUNC2_(equal, equal) + SHADER_FUNC1 (exp) + SHADER_FUNC1 (exp2) + SHADER_FUNC3 (faceforward) + SHADER_FUNC1 (floor) + SHADER_FUNC1 (fract) + SHADER_FUNC0 (ftransform) + SHADER_FUNC1 (fwidth) + SHADER_FUNC2_(greater_than_equal, greaterThanEqual) + SHADER_FUNC2_(greater_then, greaterThan) + SHADER_FUNC1 (inversesqrt) + SHADER_FUNC1 (length) + SHADER_FUNC2_(less_than, lessThan) + SHADER_FUNC2_(less_than_equal, lessThanEqual) + SHADER_FUNC1 (log) + SHADER_FUNC1 (log2) + SHADER_FUNC2_(matrix_comp_mult, matrixCompMult) + SHADER_FUNC2 (max) + SHADER_FUNC2 (min) + SHADER_FUNC3 (mix) + SHADER_FUNC2 (mod) + SHADER_FUNC1 (noise1) + SHADER_FUNC1 (noise2) + SHADER_FUNC1 (noise3) + SHADER_FUNC1 (noise4) + SHADER_FUNC1 (normalize) + SHADER_FUNC1 (gl_not) // TODO + SHADER_FUNC2_(notequal, notEqual) + SHADER_FUNC2 (pow) + SHADER_FUNC1 (radians) + SHADER_FUNC2 (reflect) + SHADER_FUNC3 (refract) + SHADER_FUNC2_(shadow_1d, shadow1D) + SHADER_FUNC3_(shadow_1d, shadow1D) + SHADER_FUNC3_(shadow_1d_lod, shadow1DLod) + SHADER_FUNC2_(shadow_1d_proj, shadow1DProj) + SHADER_FUNC3_(shadow_1d_proj, shadow1DProj) + SHADER_FUNC3_(shadow_1d_proj_lod, shadow1DProjLod) + SHADER_FUNC2_(shadow_2d, shadow2D) + SHADER_FUNC3_(shadow_2d, shadow2D) + SHADER_FUNC3_(shadow_2d_lod, shadow2DLod) + SHADER_FUNC2_(shadow_2d_proj, shadow2DProj) + SHADER_FUNC3_(shadow_2d_proj, shadow2DProj) + SHADER_FUNC3_(shadow_2d_proj_lod, shadow2DProjLod) + SHADER_FUNC1 (sign) + SHADER_FUNC1 (sin) + SHADER_FUNC3 (smoothstep) + SHADER_FUNC1 (sqrt) + SHADER_FUNC2 (step) + SHADER_FUNC1 (tan) + SHADER_FUNC2_(texture_1d, texture1D) + SHADER_FUNC3_(texture_1d, texture1D) + SHADER_FUNC3_(texture_1d_lod, texture1DLod) + SHADER_FUNC2_(texture_1d_proj, texture1DProj) + SHADER_FUNC3_(texture_1d_proj, texture1DProj) + SHADER_FUNC3_(texture_1d_proj_lod, texture1DProjLod) + SHADER_FUNC2_(texture_2d, texture2D) + SHADER_FUNC3_(texture_2d, texture2D) + SHADER_FUNC3_(texture_2d_lod, texture2DLod) + SHADER_FUNC2_(texture_2d_proj, texture2DProj) + SHADER_FUNC3_(texture_2d_proj, texture2DProj) + SHADER_FUNC3_(texture_2d_proj_lod, texture2DProjLod) + SHADER_FUNC2_(texture_3d, texture3D) + SHADER_FUNC3_(texture_3d, texture3D) + SHADER_FUNC3_(texture_3d_lod, texture3DLod) + SHADER_FUNC2_(texture_3d_proj, texture3DProj) + SHADER_FUNC3_(texture_3d_proj, texture3DProj) + SHADER_FUNC3_(texture_3d_proj_lod, texture3DProjLod) + SHADER_FUNC2_(texture_cube, textureCube) + SHADER_FUNC3_(texture_cube, textureCube) + SHADER_FUNC3_(texture_cude_lod, textureCubeLod) + SHADER_FUNC1 (vec2) SHADER_FUNC2 (vec2) + SHADER_FUNC1 (vec3) SHADER_FUNC2 (vec3) SHADER_FUNC3 (vec3) + SHADER_FUNC1 (vec4) SHADER_FUNC2 (vec4) SHADER_FUNC3 (vec4) SHADER_FUNC4 (vec4) + SHADER_FUNC1 (mat2) SHADER_FUNC2 (mat2) + SHADER_FUNC1 (mat3) SHADER_FUNC2 (mat3) SHADER_FUNC3 (mat3) + SHADER_FUNC1 (mat4) SHADER_FUNC2 (mat4) SHADER_FUNC3 (mat4) SHADER_FUNC4 (mat4) + +# undef SHADER_FUNC0 +# undef SHADER_FUNC0_ +# undef SHADER_FUNC1 +# undef SHADER_FUNC1_ +# undef SHADER_FUNC2 +# undef SHADER_FUNC2_ +# undef SHADER_FUNC3 +# undef SHADER_FUNC3_ +# undef SHADER_FUNC4 +# undef SHADER_FUNC5_ + } - template - inline const sl_expr< sl_concat3< sl_append_const_string, - typename sl_convert::T, - sl_string<7> - > > - swizzle (const T &t, int a, int b = 0, int c = 0, int d = 0) +#if 0 + template + inline const sl_expr< sl_ternary::T, typename sl_convert::T, typename sl_convert::T> > + ifelse (const A &a, const B &b, const C &c) { - sl_string<7> s; - swizzle_mask (s, ((d * 5 + c) * 5 + b) * 5 + a); - return concat (str_lpar, sl_convert::convert (t), s); + return sl_ternary::T, typename sl_convert::T, typename sl_convert::T> + (sl_convert::convert (a), sl_convert::convert (b), sl_convert::convert (c)); } +#endif -# define SHADER_SWIZZLE_OP(abcd,type) \ - template \ - inline const sl_expr< sl_concat3< sl_append_const_string, \ - typename sl_convert::T, \ - sl_string<7> \ - > > \ - type (const T &t) \ - { \ - return swizzle (t, (abcd / 1000) % 5, (abcd / 100) % 5, (abcd / 10) % 5, (abcd / 1) % 5); \ - } - - // brute force is lovely, ain't it? - SHADER_SWIZZLE_OP (1 , x ) SHADER_SWIZZLE_OP (11 , xx ) SHADER_SWIZZLE_OP (111 , xxx ) SHADER_SWIZZLE_OP (1111, xxxx) - SHADER_SWIZZLE_OP (1112, xxxy) SHADER_SWIZZLE_OP (1113, xxxz) SHADER_SWIZZLE_OP (1114, xxxw) SHADER_SWIZZLE_OP (112 , xxy ) - SHADER_SWIZZLE_OP (1121, xxyx) SHADER_SWIZZLE_OP (1122, xxyy) SHADER_SWIZZLE_OP (1123, xxyz) SHADER_SWIZZLE_OP (1124, xxyw) - SHADER_SWIZZLE_OP (113 , xxz ) SHADER_SWIZZLE_OP (1131, xxzx) SHADER_SWIZZLE_OP (1132, xxzy) SHADER_SWIZZLE_OP (1133, xxzz) - SHADER_SWIZZLE_OP (1134, xxzw) SHADER_SWIZZLE_OP (114 , xxw ) SHADER_SWIZZLE_OP (1141, xxwx) SHADER_SWIZZLE_OP (1142, xxwy) - SHADER_SWIZZLE_OP (1143, xxwz) SHADER_SWIZZLE_OP (1144, xxww) SHADER_SWIZZLE_OP (12 , xy ) SHADER_SWIZZLE_OP (121 , xyx ) - SHADER_SWIZZLE_OP (1211, xyxx) SHADER_SWIZZLE_OP (1212, xyxy) SHADER_SWIZZLE_OP (1213, xyxz) SHADER_SWIZZLE_OP (1214, xyxw) - SHADER_SWIZZLE_OP (122 , xyy ) SHADER_SWIZZLE_OP (1221, xyyx) SHADER_SWIZZLE_OP (1222, xyyy) SHADER_SWIZZLE_OP (1223, xyyz) - SHADER_SWIZZLE_OP (1224, xyyw) SHADER_SWIZZLE_OP (123 , xyz ) SHADER_SWIZZLE_OP (1231, xyzx) SHADER_SWIZZLE_OP (1232, xyzy) - SHADER_SWIZZLE_OP (1233, xyzz) SHADER_SWIZZLE_OP (1234, xyzw) SHADER_SWIZZLE_OP (124 , xyw ) SHADER_SWIZZLE_OP (1241, xywx) - SHADER_SWIZZLE_OP (1242, xywy) SHADER_SWIZZLE_OP (1243, xywz) SHADER_SWIZZLE_OP (1244, xyww) SHADER_SWIZZLE_OP (13 , xz ) - SHADER_SWIZZLE_OP (131 , xzx ) SHADER_SWIZZLE_OP (1311, xzxx) SHADER_SWIZZLE_OP (1312, xzxy) SHADER_SWIZZLE_OP (1313, xzxz) - SHADER_SWIZZLE_OP (1314, xzxw) SHADER_SWIZZLE_OP (132 , xzy ) SHADER_SWIZZLE_OP (1321, xzyx) SHADER_SWIZZLE_OP (1322, xzyy) - SHADER_SWIZZLE_OP (1323, xzyz) SHADER_SWIZZLE_OP (1324, xzyw) SHADER_SWIZZLE_OP (133 , xzz ) SHADER_SWIZZLE_OP (1331, xzzx) - SHADER_SWIZZLE_OP (1332, xzzy) SHADER_SWIZZLE_OP (1333, xzzz) SHADER_SWIZZLE_OP (1334, xzzw) SHADER_SWIZZLE_OP (134 , xzw ) - SHADER_SWIZZLE_OP (1341, xzwx) SHADER_SWIZZLE_OP (1342, xzwy) SHADER_SWIZZLE_OP (1343, xzwz) SHADER_SWIZZLE_OP (1344, xzww) - SHADER_SWIZZLE_OP (14 , xw ) SHADER_SWIZZLE_OP (141 , xwx ) SHADER_SWIZZLE_OP (1411, xwxx) SHADER_SWIZZLE_OP (1412, xwxy) - SHADER_SWIZZLE_OP (1413, xwxz) SHADER_SWIZZLE_OP (1414, xwxw) SHADER_SWIZZLE_OP (142 , xwy ) SHADER_SWIZZLE_OP (1421, xwyx) - SHADER_SWIZZLE_OP (1422, xwyy) SHADER_SWIZZLE_OP (1423, xwyz) SHADER_SWIZZLE_OP (1424, xwyw) SHADER_SWIZZLE_OP (143 , xwz ) - SHADER_SWIZZLE_OP (1431, xwzx) SHADER_SWIZZLE_OP (1432, xwzy) SHADER_SWIZZLE_OP (1433, xwzz) SHADER_SWIZZLE_OP (1434, xwzw) - SHADER_SWIZZLE_OP (144 , xww ) SHADER_SWIZZLE_OP (1441, xwwx) SHADER_SWIZZLE_OP (1442, xwwy) SHADER_SWIZZLE_OP (1443, xwwz) - SHADER_SWIZZLE_OP (1444, xwww) SHADER_SWIZZLE_OP (2 , y ) SHADER_SWIZZLE_OP (21 , yx ) SHADER_SWIZZLE_OP (211 , yxx ) - SHADER_SWIZZLE_OP (2111, yxxx) SHADER_SWIZZLE_OP (2112, yxxy) SHADER_SWIZZLE_OP (2113, yxxz) SHADER_SWIZZLE_OP (2114, yxxw) - SHADER_SWIZZLE_OP (212 , yxy ) SHADER_SWIZZLE_OP (2121, yxyx) SHADER_SWIZZLE_OP (2122, yxyy) SHADER_SWIZZLE_OP (2123, yxyz) - SHADER_SWIZZLE_OP (2124, yxyw) SHADER_SWIZZLE_OP (213 , yxz ) SHADER_SWIZZLE_OP (2131, yxzx) SHADER_SWIZZLE_OP (2132, yxzy) - SHADER_SWIZZLE_OP (2133, yxzz) SHADER_SWIZZLE_OP (2134, yxzw) SHADER_SWIZZLE_OP (214 , yxw ) SHADER_SWIZZLE_OP (2141, yxwx) - SHADER_SWIZZLE_OP (2142, yxwy) SHADER_SWIZZLE_OP (2143, yxwz) SHADER_SWIZZLE_OP (2144, yxww) SHADER_SWIZZLE_OP (22 , yy ) - SHADER_SWIZZLE_OP (221 , yyx ) SHADER_SWIZZLE_OP (2211, yyxx) SHADER_SWIZZLE_OP (2212, yyxy) SHADER_SWIZZLE_OP (2213, yyxz) - SHADER_SWIZZLE_OP (2214, yyxw) SHADER_SWIZZLE_OP (222 , yyy ) SHADER_SWIZZLE_OP (2221, yyyx) SHADER_SWIZZLE_OP (2222, yyyy) - SHADER_SWIZZLE_OP (2223, yyyz) SHADER_SWIZZLE_OP (2224, yyyw) SHADER_SWIZZLE_OP (223 , yyz ) SHADER_SWIZZLE_OP (2231, yyzx) - SHADER_SWIZZLE_OP (2232, yyzy) SHADER_SWIZZLE_OP (2233, yyzz) SHADER_SWIZZLE_OP (2234, yyzw) SHADER_SWIZZLE_OP (224 , yyw ) - SHADER_SWIZZLE_OP (2241, yywx) SHADER_SWIZZLE_OP (2242, yywy) SHADER_SWIZZLE_OP (2243, yywz) SHADER_SWIZZLE_OP (2244, yyww) - SHADER_SWIZZLE_OP (23 , yz ) SHADER_SWIZZLE_OP (231 , yzx ) SHADER_SWIZZLE_OP (2311, yzxx) SHADER_SWIZZLE_OP (2312, yzxy) - SHADER_SWIZZLE_OP (2313, yzxz) SHADER_SWIZZLE_OP (2314, yzxw) SHADER_SWIZZLE_OP (232 , yzy ) SHADER_SWIZZLE_OP (2321, yzyx) - SHADER_SWIZZLE_OP (2322, yzyy) SHADER_SWIZZLE_OP (2323, yzyz) SHADER_SWIZZLE_OP (2324, yzyw) SHADER_SWIZZLE_OP (233 , yzz ) - SHADER_SWIZZLE_OP (2331, yzzx) SHADER_SWIZZLE_OP (2332, yzzy) SHADER_SWIZZLE_OP (2333, yzzz) SHADER_SWIZZLE_OP (2334, yzzw) - SHADER_SWIZZLE_OP (234 , yzw ) SHADER_SWIZZLE_OP (2341, yzwx) SHADER_SWIZZLE_OP (2342, yzwy) SHADER_SWIZZLE_OP (2343, yzwz) - SHADER_SWIZZLE_OP (2344, yzww) SHADER_SWIZZLE_OP (24 , yw ) SHADER_SWIZZLE_OP (241 , ywx ) SHADER_SWIZZLE_OP (2411, ywxx) - SHADER_SWIZZLE_OP (2412, ywxy) SHADER_SWIZZLE_OP (2413, ywxz) SHADER_SWIZZLE_OP (2414, ywxw) SHADER_SWIZZLE_OP (242 , ywy ) - SHADER_SWIZZLE_OP (2421, ywyx) SHADER_SWIZZLE_OP (2422, ywyy) SHADER_SWIZZLE_OP (2423, ywyz) SHADER_SWIZZLE_OP (2424, ywyw) - SHADER_SWIZZLE_OP (243 , ywz ) SHADER_SWIZZLE_OP (2431, ywzx) SHADER_SWIZZLE_OP (2432, ywzy) SHADER_SWIZZLE_OP (2433, ywzz) - SHADER_SWIZZLE_OP (2434, ywzw) SHADER_SWIZZLE_OP (244 , yww ) SHADER_SWIZZLE_OP (2441, ywwx) SHADER_SWIZZLE_OP (2442, ywwy) - SHADER_SWIZZLE_OP (2443, ywwz) SHADER_SWIZZLE_OP (2444, ywww) SHADER_SWIZZLE_OP (3 , z ) SHADER_SWIZZLE_OP (31 , zx ) - SHADER_SWIZZLE_OP (311 , zxx ) SHADER_SWIZZLE_OP (3111, zxxx) SHADER_SWIZZLE_OP (3112, zxxy) SHADER_SWIZZLE_OP (3113, zxxz) - SHADER_SWIZZLE_OP (3114, zxxw) SHADER_SWIZZLE_OP (312 , zxy ) SHADER_SWIZZLE_OP (3121, zxyx) SHADER_SWIZZLE_OP (3122, zxyy) - SHADER_SWIZZLE_OP (3123, zxyz) SHADER_SWIZZLE_OP (3124, zxyw) SHADER_SWIZZLE_OP (313 , zxz ) SHADER_SWIZZLE_OP (3131, zxzx) - SHADER_SWIZZLE_OP (3132, zxzy) SHADER_SWIZZLE_OP (3133, zxzz) SHADER_SWIZZLE_OP (3134, zxzw) SHADER_SWIZZLE_OP (314 , zxw ) - SHADER_SWIZZLE_OP (3141, zxwx) SHADER_SWIZZLE_OP (3142, zxwy) SHADER_SWIZZLE_OP (3143, zxwz) SHADER_SWIZZLE_OP (3144, zxww) - SHADER_SWIZZLE_OP (32 , zy ) SHADER_SWIZZLE_OP (321 , zyx ) SHADER_SWIZZLE_OP (3211, zyxx) SHADER_SWIZZLE_OP (3212, zyxy) - SHADER_SWIZZLE_OP (3213, zyxz) SHADER_SWIZZLE_OP (3214, zyxw) SHADER_SWIZZLE_OP (322 , zyy ) SHADER_SWIZZLE_OP (3221, zyyx) - SHADER_SWIZZLE_OP (3222, zyyy) SHADER_SWIZZLE_OP (3223, zyyz) SHADER_SWIZZLE_OP (3224, zyyw) SHADER_SWIZZLE_OP (323 , zyz ) - SHADER_SWIZZLE_OP (3231, zyzx) SHADER_SWIZZLE_OP (3232, zyzy) SHADER_SWIZZLE_OP (3233, zyzz) SHADER_SWIZZLE_OP (3234, zyzw) - SHADER_SWIZZLE_OP (324 , zyw ) SHADER_SWIZZLE_OP (3241, zywx) SHADER_SWIZZLE_OP (3242, zywy) SHADER_SWIZZLE_OP (3243, zywz) - SHADER_SWIZZLE_OP (3244, zyww) SHADER_SWIZZLE_OP (33 , zz ) SHADER_SWIZZLE_OP (331 , zzx ) SHADER_SWIZZLE_OP (3311, zzxx) - SHADER_SWIZZLE_OP (3312, zzxy) SHADER_SWIZZLE_OP (3313, zzxz) SHADER_SWIZZLE_OP (3314, zzxw) SHADER_SWIZZLE_OP (332 , zzy ) - SHADER_SWIZZLE_OP (3321, zzyx) SHADER_SWIZZLE_OP (3322, zzyy) SHADER_SWIZZLE_OP (3323, zzyz) SHADER_SWIZZLE_OP (3324, zzyw) - SHADER_SWIZZLE_OP (333 , zzz ) SHADER_SWIZZLE_OP (3331, zzzx) SHADER_SWIZZLE_OP (3332, zzzy) SHADER_SWIZZLE_OP (3333, zzzz) - SHADER_SWIZZLE_OP (3334, zzzw) SHADER_SWIZZLE_OP (334 , zzw ) SHADER_SWIZZLE_OP (3341, zzwx) SHADER_SWIZZLE_OP (3342, zzwy) - SHADER_SWIZZLE_OP (3343, zzwz) SHADER_SWIZZLE_OP (3344, zzww) SHADER_SWIZZLE_OP (34 , zw ) SHADER_SWIZZLE_OP (341 , zwx ) - SHADER_SWIZZLE_OP (3411, zwxx) SHADER_SWIZZLE_OP (3412, zwxy) SHADER_SWIZZLE_OP (3413, zwxz) SHADER_SWIZZLE_OP (3414, zwxw) - SHADER_SWIZZLE_OP (342 , zwy ) SHADER_SWIZZLE_OP (3421, zwyx) SHADER_SWIZZLE_OP (3422, zwyy) SHADER_SWIZZLE_OP (3423, zwyz) - SHADER_SWIZZLE_OP (3424, zwyw) SHADER_SWIZZLE_OP (343 , zwz ) SHADER_SWIZZLE_OP (3431, zwzx) SHADER_SWIZZLE_OP (3432, zwzy) - SHADER_SWIZZLE_OP (3433, zwzz) SHADER_SWIZZLE_OP (3434, zwzw) SHADER_SWIZZLE_OP (344 , zww ) SHADER_SWIZZLE_OP (3441, zwwx) - SHADER_SWIZZLE_OP (3442, zwwy) SHADER_SWIZZLE_OP (3443, zwwz) SHADER_SWIZZLE_OP (3444, zwww) SHADER_SWIZZLE_OP (4 , w ) - SHADER_SWIZZLE_OP (41 , wx ) SHADER_SWIZZLE_OP (411 , wxx ) SHADER_SWIZZLE_OP (4111, wxxx) SHADER_SWIZZLE_OP (4112, wxxy) - SHADER_SWIZZLE_OP (4113, wxxz) SHADER_SWIZZLE_OP (4114, wxxw) SHADER_SWIZZLE_OP (412 , wxy ) SHADER_SWIZZLE_OP (4121, wxyx) - SHADER_SWIZZLE_OP (4122, wxyy) SHADER_SWIZZLE_OP (4123, wxyz) SHADER_SWIZZLE_OP (4124, wxyw) SHADER_SWIZZLE_OP (413 , wxz ) - SHADER_SWIZZLE_OP (4131, wxzx) SHADER_SWIZZLE_OP (4132, wxzy) SHADER_SWIZZLE_OP (4133, wxzz) SHADER_SWIZZLE_OP (4134, wxzw) - SHADER_SWIZZLE_OP (414 , wxw ) SHADER_SWIZZLE_OP (4141, wxwx) SHADER_SWIZZLE_OP (4142, wxwy) SHADER_SWIZZLE_OP (4143, wxwz) - SHADER_SWIZZLE_OP (4144, wxww) SHADER_SWIZZLE_OP (42 , wy ) SHADER_SWIZZLE_OP (421 , wyx ) SHADER_SWIZZLE_OP (4211, wyxx) - SHADER_SWIZZLE_OP (4212, wyxy) SHADER_SWIZZLE_OP (4213, wyxz) SHADER_SWIZZLE_OP (4214, wyxw) SHADER_SWIZZLE_OP (422 , wyy ) - SHADER_SWIZZLE_OP (4221, wyyx) SHADER_SWIZZLE_OP (4222, wyyy) SHADER_SWIZZLE_OP (4223, wyyz) SHADER_SWIZZLE_OP (4224, wyyw) - SHADER_SWIZZLE_OP (423 , wyz ) SHADER_SWIZZLE_OP (4231, wyzx) SHADER_SWIZZLE_OP (4232, wyzy) SHADER_SWIZZLE_OP (4233, wyzz) - SHADER_SWIZZLE_OP (4234, wyzw) SHADER_SWIZZLE_OP (424 , wyw ) SHADER_SWIZZLE_OP (4241, wywx) SHADER_SWIZZLE_OP (4242, wywy) - SHADER_SWIZZLE_OP (4243, wywz) SHADER_SWIZZLE_OP (4244, wyww) SHADER_SWIZZLE_OP (43 , wz ) SHADER_SWIZZLE_OP (431 , wzx ) - SHADER_SWIZZLE_OP (4311, wzxx) SHADER_SWIZZLE_OP (4312, wzxy) SHADER_SWIZZLE_OP (4313, wzxz) SHADER_SWIZZLE_OP (4314, wzxw) - SHADER_SWIZZLE_OP (432 , wzy ) SHADER_SWIZZLE_OP (4321, wzyx) SHADER_SWIZZLE_OP (4322, wzyy) SHADER_SWIZZLE_OP (4323, wzyz) - SHADER_SWIZZLE_OP (4324, wzyw) SHADER_SWIZZLE_OP (433 , wzz ) SHADER_SWIZZLE_OP (4331, wzzx) SHADER_SWIZZLE_OP (4332, wzzy) - SHADER_SWIZZLE_OP (4333, wzzz) SHADER_SWIZZLE_OP (4334, wzzw) SHADER_SWIZZLE_OP (434 , wzw ) SHADER_SWIZZLE_OP (4341, wzwx) - SHADER_SWIZZLE_OP (4342, wzwy) SHADER_SWIZZLE_OP (4343, wzwz) SHADER_SWIZZLE_OP (4344, wzww) SHADER_SWIZZLE_OP (44 , ww ) - SHADER_SWIZZLE_OP (441 , wwx ) SHADER_SWIZZLE_OP (4411, wwxx) SHADER_SWIZZLE_OP (4412, wwxy) SHADER_SWIZZLE_OP (4413, wwxz) - SHADER_SWIZZLE_OP (4414, wwxw) SHADER_SWIZZLE_OP (442 , wwy ) SHADER_SWIZZLE_OP (4421, wwyx) SHADER_SWIZZLE_OP (4422, wwyy) - SHADER_SWIZZLE_OP (4423, wwyz) SHADER_SWIZZLE_OP (4424, wwyw) SHADER_SWIZZLE_OP (443 , wwz ) SHADER_SWIZZLE_OP (4431, wwzx) - SHADER_SWIZZLE_OP (4432, wwzy) SHADER_SWIZZLE_OP (4433, wwzz) SHADER_SWIZZLE_OP (4434, wwzw) SHADER_SWIZZLE_OP (444 , www ) - SHADER_SWIZZLE_OP (4441, wwwx) SHADER_SWIZZLE_OP (4442, wwwy) SHADER_SWIZZLE_OP (4443, wwwz) SHADER_SWIZZLE_OP (4444, wwww) - -# undef SHADER_SWIZZLE_OP - - void debdebdebdebug ();//D } #endif +#include "shader_vars.h" + +