--- libgender/shader.h	2004/10/23 23:36:45	1.6
+++ libgender/shader.h	2004/10/28 17:07:47	1.15
@@ -45,6 +45,52 @@
     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;
+    void comma () const;
+    void end () const;
+    void operator ()() const
+    { 
+      begin ();
+      end ();
+    }
+  };
+
+  template<class A>
+  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<class A, class B>
+  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<class A, class B, class C>
+  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<class A, class B, class C, class D>
+  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<class type> friend class ref;
@@ -188,14 +234,14 @@
   };
 
   // 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) { }
+    gluvar_i (const char *name) : name (name) { }
   };
 
-  typedef auto_lvalue_ref1<glvar_i, const char *> glvar;
+  typedef auto_lvalue_ref1<gluvar_i, const char *> gluvar;
 
   struct var_i : lvalue_i
   {
@@ -214,15 +260,22 @@
   struct uniform_i : var_i
   {
     bool dirty;
+    GLint location;
 
     virtual void update () = 0;
 
     void build (shader_builder &b);
     void build_decl (ostringstream &b);
+
+    void update_location (GLint program)
+    {
+      location = glGetUniformLocationARB (program, name);
+    }
+
     uniform_i (const char *strtype);
   };
 
-  template<int dimension, typename gltype, const char *strtype, void (*upd)(CGparameter, const gltype *)>
+  template<int dimension, typename gltype, const char *strtype, void (*upd)(GLint, GLsizei, const gltype *)>
   struct uniform2_i : uniform_i
   {
     gltype data[dimension];
@@ -231,7 +284,9 @@
     {
       if (dirty)
         {
-          //upd (param, data);
+          if (location >= 0)
+            upd (location, dimension, data);
+
           dirty = false;
         }
     }
@@ -239,12 +294,12 @@
     uniform2_i () : uniform_i (strtype) { }
   };
 
-  template<int dimension, const char *strtype, void (*update)(CGparameter, const GLfloat *)>
+  template<int dimension, const char *strtype, void (*update)(GLint, GLsizei, const GLfloat *)>
   struct uniform_f_i : uniform2_i<dimension, GLfloat, strtype, update>
   {
   };
 
-  struct uniform_1f_i : uniform_f_i<1, str_float, cgGLSetParameter1fv> {
+  struct uniform_1f_i : uniform_f_i<1, str_float, glUniform1fvARB> {
     void operator =(GLfloat v)
     {
       data[0] = v;
@@ -252,9 +307,9 @@
     }
   };
 
-  struct uniform_2f_i : uniform_f_i<2, str_vec2, cgGLSetParameter2fv> { };
+  struct uniform_2f_i : uniform_f_i<2, str_vec2, glUniform2fvARB> { };
 
-  struct uniform_3f_i : uniform_f_i<3, str_vec3, cgGLSetParameter3fv> {
+  struct uniform_3f_i : uniform_f_i<3, str_vec3, glUniform3fvARB> {
     void operator =(const vec3 &v)
     {
       data[0] = v.x;
@@ -264,7 +319,7 @@
     }
   };
 
-  struct uniform_4f_i : uniform_f_i<4, str_vec4, cgGLSetParameter4fv> {
+  struct uniform_4f_i : uniform_f_i<4, str_vec4, glUniform4fvARB> {
 #if 0
     void operator =(const gl::matrix &m)
     {
@@ -274,9 +329,13 @@
 #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> { };
+  inline void UniformMatrix2fv (GLint l, GLsizei s, const GLfloat *m) { glUniformMatrix2fvARB (l, s, 0, m); }
+  inline void UniformMatrix3fv (GLint l, GLsizei s, const GLfloat *m) { glUniformMatrix3fvARB (l, s, 0, m); }
+  inline void UniformMatrix4fv (GLint l, GLsizei s, const GLfloat *m) { glUniformMatrix4fvARB (l, s, 0, m); }
+
+  struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, UniformMatrix2fv> { };
+  struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, UniformMatrix3fv> { };
+  struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, UniformMatrix4fv> { };
 
   template<class var_i>
   struct var_ref : ref<var_i>
@@ -373,6 +432,15 @@
     {
     }
 
+#if 0
+    template<typename expr>
+    temp_ref (const expr &e)
+    : ref<temporary_i> (*new temporary_i (strtype))
+    {
+      (*this) = e;
+    }
+#endif
+
     template<typename expr>
     const temp_ref &operator =(const expr &e) const;
   };
@@ -388,7 +456,7 @@
   template<GLenum gltype, const char *strtype>
   struct sampler_i : uniform_i
   {
-    GLuint texture;
+    GLuint unit;
 
     void update ()
     {
@@ -401,55 +469,55 @@
 
     void begin ()
     {
-      cgGLEnableTextureParameter (texture);
+      //cgGLEnableTextureParameter (unit);
     }
 
-    sampler_i (GLuint texturename) : uniform_i (strtype), texture (texturename) { }
+    sampler_i (GLuint textureunit) : uniform_i (strtype), unit (textureunit) { }
   };
 
-  struct sampler_1d_i : sampler_i<CG_SAMPLER1D, str_sampler_1d>
+  struct sampler_1d_i : sampler_i<GL_SAMPLER_1D_ARB, str_sampler_1d>
   {
-    sampler_1d_i (GLuint texturename) : sampler_i<CG_SAMPLER1D, str_sampler_1d> (texturename) { }
+    sampler_1d_i (GLuint textureunit) : sampler_i<GL_SAMPLER_1D_ARB, str_sampler_1d> (textureunit) { }
   };
 
-  struct sampler_1d_shadow_i : sampler_i<CG_SAMPLER1D, str_sampler_1d_shadow>
+  struct sampler_1d_shadow_i : sampler_i<GL_SAMPLER_1D_SHADOW_ARB, str_sampler_1d_shadow>
   {
-    sampler_1d_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLER1D, str_sampler_1d_shadow> (texturename) { }
+    sampler_1d_shadow_i (GLuint textureunit) : sampler_i<GL_SAMPLER_1D_SHADOW_ARB, str_sampler_1d_shadow> (textureunit) { }
   };
 
-  struct sampler_2d_i : sampler_i<CG_SAMPLER2D, str_sampler_2d>
+  struct sampler_2d_i : sampler_i<GL_SAMPLER_2D_ARB, str_sampler_2d>
   {
-    sampler_2d_i (GLuint texturename) : sampler_i<CG_SAMPLER2D, str_sampler_2d> (texturename) { }
+    sampler_2d_i (GLuint textureunit) : sampler_i<GL_SAMPLER_2D_ARB, str_sampler_2d> (textureunit) { }
   };
 
-  struct sampler_2d_shadow_i : sampler_i<CG_SAMPLER2D, str_sampler_2d_shadow>
+  struct sampler_2d_shadow_i : sampler_i<GL_SAMPLER_2D_SHADOW_ARB, str_sampler_2d_shadow>
   {
-    sampler_2d_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLER2D, str_sampler_2d_shadow> (texturename) { }
+    sampler_2d_shadow_i (GLuint textureunit) : sampler_i<GL_SAMPLER_2D_SHADOW_ARB, str_sampler_2d_shadow> (textureunit) { }
   };
 
-  struct sampler_2d_rect_i : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect>
+  struct sampler_2d_rect_i : sampler_i<GL_SAMPLER_2D_RECT_ARB, str_sampler_2d_rect>
   {
-    sampler_2d_rect_i (GLuint texturename) : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect> (texturename) { }
+    sampler_2d_rect_i (GLuint textureunit) : sampler_i<GL_SAMPLER_2D_RECT_ARB, str_sampler_2d_rect> (textureunit) { }
   };
 
-  struct sampler_2d_rect_shadow_i : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect_shadow>
+  struct sampler_2d_rect_shadow_i : sampler_i<GL_SAMPLER_2D_RECT_SHADOW_ARB, str_sampler_2d_rect_shadow>
   {
-    sampler_2d_rect_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect_shadow> (texturename) { }
+    sampler_2d_rect_shadow_i (GLuint textureunit) : sampler_i<GL_SAMPLER_2D_RECT_SHADOW_ARB, str_sampler_2d_rect_shadow> (textureunit) { }
   };
 
-  struct sampler_3d_i : sampler_i<CG_SAMPLER3D, str_sampler_3d>
+  struct sampler_3d_i : sampler_i<GL_SAMPLER_3D_ARB, str_sampler_3d>
   {
-    sampler_3d_i (GLuint texturename) : sampler_i<CG_SAMPLER3D, str_sampler_3d> (texturename) { }
+    sampler_3d_i (GLuint textureunit) : sampler_i<GL_SAMPLER_3D_ARB, str_sampler_3d> (textureunit) { }
   };
 
-  struct sampler_3d_rect_i : sampler_i<CG_SAMPLER3D, str_sampler_3d_rect>
+  struct sampler_3d_rect_i : sampler_i<GL_SAMPLER_3D_ARB, str_sampler_3d_rect>
   {
-    sampler_3d_rect_i (GLuint texturename) : sampler_i<CG_SAMPLER3D, str_sampler_3d_rect> (texturename) { }
+    sampler_3d_rect_i (GLuint textureunit) : sampler_i<GL_SAMPLER_3D_ARB, str_sampler_3d_rect> (textureunit) { }
   };
 
-  struct sampler_cube_i : sampler_i<CG_SAMPLERCUBE, str_sampler_cube>
+  struct sampler_cube_i : sampler_i<GL_SAMPLER_CUBE_ARB, str_sampler_cube>
   {
-    sampler_cube_i (GLuint texturename) : sampler_i<CG_SAMPLERCUBE, str_sampler_cube> (texturename) { }
+    sampler_cube_i (GLuint textureunit) : sampler_i<GL_SAMPLER_CUBE_ARB, str_sampler_cube> (textureunit) { }
   };
 
   typedef auto_ref1<sampler_1d_i, GLuint>             sampler_1d;
@@ -508,19 +576,6 @@
     {
       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<fragment>::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_i> fragment_vector;
@@ -553,6 +608,19 @@
   typedef shader_object<GL_VERTEX_SHADER_ARB>   vertex_shader;
   typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader;
 
+  struct program_object
+  {
+    GLuint id;
+
+    vertex_shader   vsh;
+    fragment_shader fsh;
+
+    program_object ();
+    ~program_object ();
+
+    void link ();
+  };
+
   template<typename T>
   struct sl_append
   {
@@ -683,12 +751,12 @@
   };
 
   template<>
-  struct sl_convert<glvar>
+  struct sl_convert<gluvar>
   {
-    typedef sl_expr< sl_append<glvar> > T;
-    static inline const T convert (const glvar &v)
+    typedef sl_expr< sl_append<gluvar> > T;
+    static inline const T convert (const gluvar &v)
     {
-      return sl_append<glvar> (v);
+      return sl_append<gluvar> (v);
     }
   };
 
@@ -707,6 +775,7 @@
 
   extern const fragment_const_string str_2sp;
   extern const fragment_const_string str_equal;
+  extern const fragment_const_string str_comma;
   extern const fragment_const_string str_endl;
 
   template<class fragment, typename expr>
@@ -764,29 +833,39 @@
     }
   };
 
+  extern const sl_append_const_string str_lpar;
+  extern const sl_append_const_string str_rpar;
+
+  template<class A, class B, class C>
+  struct sl_binop
+  {
+    const A a; const B b; const C c;
+    sl_binop (const A &a, const B &b, const C &c) : a(a), b(b), c(c) { }
+    void operator ()() const { str_lpar (); a (); b (); c (); str_rpar (); }
+  };
+
 # define SHADER_BINOP(op, str)						\
     extern const sl_append_const_string str_ ## str;				\
     template<typename A, typename B>					\
-    inline const sl_expr< sl_concat3< typename sl_convert<A>::T,		\
-                                      sl_append_const_string,		\
-                                      typename sl_convert<B>::T > >	\
+    inline const sl_expr< sl_binop< typename sl_convert<A>::T,		\
+                                    sl_append_const_string,		\
+                                    typename sl_convert<B>::T > >	\
     operator op(const A &a, const B &b)					\
     {									\
-      return concat (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b));	\
+      return sl_binop< typename sl_convert<A>::T, sl_append_const_string, typename sl_convert<B>::T >	\
+             (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b));	\
     }
 
   SHADER_BINOP (+, plus);
   SHADER_BINOP (-, minus);
   SHADER_BINOP (*, mul);
   SHADER_BINOP (/, div);
+  SHADER_BINOP (%, mod);
 
 # 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;
-
   template<typename T>
   inline const sl_expr< sl_concat3< sl_append_const_string,
                                     typename sl_convert<T>::T,
@@ -899,6 +978,161 @@
 
 # undef SHADER_SWIZZLE_OP
 
+# define SHADER_FUNC0_(name, glname)				\
+    template<typename A>					\
+    inline const sl_expr<sl_func0>				\
+    name ()							\
+    {								\
+      return sl_func0 (#glname " (");				\
+    }
+
+# define SHADER_FUNC0(name) SHADER_FUNC0_(name,name)
+
+# define SHADER_FUNC1_(name, glname)				\
+    template<typename A>					\
+    inline const sl_expr< sl_func1<typename sl_convert<A>::T> >	\
+    name (const A &a)					\
+    {								\
+      return sl_func1<typename sl_convert<A>::T> (#glname " (", sl_convert<A>::convert (a));\
+    }
+
+# define SHADER_FUNC1(name) SHADER_FUNC1_(name,name)
+
+# define SHADER_FUNC2_(name, glname)				\
+    template<typename A, typename B>				\
+    inline const sl_expr< sl_func2<typename sl_convert<A>::T, typename sl_convert<B>::T> >	\
+    name (const A &a, const B &b)				\
+    {								\
+      return sl_func2<typename sl_convert<A>::T, typename sl_convert<B>::T> (#glname " (", sl_convert<A>::convert (a), sl_convert<B>::convert (b));\
+    }
+
+# define SHADER_FUNC2(name) SHADER_FUNC2_(name,name)
+
+# define SHADER_FUNC3_(name, glname)				\
+    template<typename A, typename B, typename C>		\
+    inline const sl_expr< sl_func3<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T> >	\
+    name (const A &a, const B &b, const C &c)			\
+    {								\
+      return sl_func3<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T> (#glname " (", sl_convert<A>::convert (a), sl_convert<B>::convert (b), sl_convert<C>::convert (c));\
+    }
+
+# define SHADER_FUNC3(name) SHADER_FUNC3_(name,name)
+
+# define SHADER_FUNC4_(name, glname)				\
+    template<typename A, typename B, typename C, typename D>	\
+    inline const sl_expr< sl_func4<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T, typename sl_convert<D>::T > >	\
+    name (const A &a, const B &b, const C &c, const D &d)	\
+    {								\
+      return sl_func4<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T, typename sl_convert<D>::T> (#glname " (", sl_convert<A>::convert (a), sl_convert<B>::convert (b), sl_convert<C>::convert (c), sl_convert<D>::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_
+
   void debdebdebdebug ();//D
 }