libgender/shader.C

#include "shader.h"
#include "shader_vars.h"

namespace shader {

  refcounted::~refcounted ()
  {
#if 0
    if (refcnt)
      abort ();
#endif
  }

  const char str_float  [] = "float";
  const char str_vec2   [] = "vec2";
  const char str_vec3   [] = "vec3";
  const char str_vec4   [] = "vec4";
  const char str_mat2   [] = "mat2";
  const char str_mat3   [] = "mat3";
  const char str_mat4   [] = "mat4";

  const char str_sampler_1d             [] = "sampler1D";
  const char str_sampler_1d_shadow      [] = "sampler1DShadow";
  const char str_sampler_2d             [] = "sampler2D";
  const char str_sampler_2d_shadow      [] = "sampler2DShadow";
  const char str_sampler_2d_rect        [] = "sampler2DRect";
  const char str_sampler_2d_rect_shadow [] = "sampler2DRectShadow";
  const char str_sampler_3d             [] = "sampler3D";
  const char str_sampler_3d_rect        [] = "sampler3DRect";
  const char str_sampler_cube           [] = "samplerCube";

  unsigned int var_i::next_id = 0;

  var_i::var_i (const char *typestr)
  : typestr (typestr)
  {
    //param = cgCreateParameter (cg_context, cgtype);
  }

  var_i::~var_i ()
  {
    //cgDestroyParameter (param);
  }

  temporary_i::temporary_i (const char *strtype)
  : var_i (strtype)
  {
    sprintf (name, "T%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
  }

  uniform_i::uniform_i (const char *strtype)
  : var_i (strtype), dirty (true)
  {
    sprintf (name, "U%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
  }

  fragment_string_i::~fragment_string_i ()
  {
    free (str);
  }

  ////////////////////////////////////////////////////////////////////////////

  void var_i::build_decl (ostringstream &b)
  {
    b << typestr << ' ' << name;
  }

  void uniform_i::build_decl (ostringstream &b)
  {
    b << "uniform " << typestr << ' ' << name;
  }

  void stream_i::build_decl (ostringstream &b)
  {
    b << typestr << ' ' << name;
  }

  ////////////////////////////////////////////////////////////////////////////

  void glvar_i::build (shader_builder &b)
  {
    b << name;
  }

  void var_i::build (shader_builder &b)
  {
    b << name;
  }

  void uniform_i::build (shader_builder &b)
  {
    var_i::build (b);

    if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
      b.refs.push_back (*this);
  }

  void stream_i::build (shader_builder &b)
  {
    var_i::build (b);

    if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
      b.streams.push_back (*this);
  }

  void temporary_i::build (shader_builder &b)
  {
    var_i::build (b);

    if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
      b.temps.push_back (*this);
  }

  void fragment_vector_i::build (shader_builder &b)
  {
    for (vector<fragment>::iterator i = begin (); i != end (); i++)
      (*i)->build (b);
  }

  void fragment_const_string_i::build (shader_builder &b)
  {
    b << str;
  }

  void fragment_string_i::build (shader_builder &b)
  {
    b << str;
  }

#if 0
  void statement_i::build (shader_builder &b)
  {
    b << "  ";
    fragment_vector_i::build (b);
    b << ";\n";
  }
#endif

  ////////////////////////////////////////////////////////////////////////////

  shader_object_i *cur = 0;

  shader_object_i::shader_object_i (GLenum type)
  : type (type)
  {
    id = glCreateShaderObjectARB (type);
  }

  shader_object_i::~shader_object_i ()
  {
    glDeleteObjectARB (id);
  }

  void shader_object_i::start ()
  {
    clear ();
    cur = this;
  }

  void shader_object_i::stop ()
  {
    cur = 0;
  }

  string shader_object_i::source ()
  {
    shader_builder b;
    build (b);
    ostringstream os;

    for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
      {
        (*i)->build_decl (os);
        os << ";\n";
      }

    // not neccessary right now, as GLSL is rich on predefinitions
    for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
      {
        os << "attribute ";
        (*i)->build_decl (os);
        os << ";\n";
      }

    os << "\nvoid main (void)\n{\n";

    for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
      {
        os << "  ";
        (*i)->build_decl (os);
        os << ";\n";
      }

    os << "\n";
    os << b.source.str ();
    os << "}\n";

    return os.str ();
  }

  void shader_object_i::compile ()
  {
    string src = source ();
    const char *sptr = src.data ();
    const int slen = src.size ();

        printf ("SOURCE<%s>\n", src.c_str ());
        abort ();
    glShaderSourceARB (id, 1, &sptr, &slen);
    glCompileShaderARB (id);

    GLint compiled;
    glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);

    if (!compiled)
      {
        char infolog[8192];
        glGetInfoLogARB (id, 8192, NULL, infolog);
        printf ("SOURCE<%s>\n", src.c_str ());
        printf ("INFOLOG<%s>\n", infolog);
        abort ();
      }
  }

  template<typename T>
  struct sl_append
  {
    T t;

    sl_append (const T &t) : t(t) { }

    void operator ()() const
    {
      cur->push_back (t);
    }
  };

  template<int length>
  struct sl_string
  {
    char str[length];

    void operator ()() const
    {
      cur->push_back (*new fragment_string_i (str));
    }
  };

  // only floats
  struct sl_float
  {
    const GLfloat c;

    sl_float (GLfloat c) : c(c) { }

    void operator ()() const
    {
      char s[64];
      sprintf (s, "%g", c);
      cur->append_string (s);
    }
  };

  template<class A, class B>
  inline sl_expr< sl_concat2<A, B> >
  concat (const A &a, const B &b)
  {
    typedef sl_concat2<A, B> expr;
    return sl_expr<expr> (expr (a, b));
  }

  template<class A, class B, class C>
  inline sl_expr< sl_concat3<A, B, C> >
  concat (const A &a, const B &b, const C &c)
  {
    typedef sl_concat3<A, B, C> expr;
    return sl_expr<expr> (expr (a, b, c));
  }

  template<class A, class B, class C, class D>
  inline sl_expr< sl_concat4<A, B, C, D> >
  concat (const A &a, const B &b, const C &c, const D &d)
  {
    typedef sl_concat4<A, B, C, D> expr;
    return sl_expr<expr> (expr (a, b, c, d));
  }

  template<typename expr>
  struct sl_convert
  {
    typedef sl_expr<expr> T;
    static inline const T &convert (const T &e)
    {
      return e;
    }
  };

  template<>
  struct sl_convert<GLfloat>
  {
    typedef sl_expr<sl_float> T;
    static inline const T convert (GLfloat f)
    {
      return sl_float (f);
    }
  };

  template<>
  struct sl_convert<vec3>
  {  
    typedef sl_expr< sl_string<256> > T;
    static inline const T convert (const vec3 &v)
    {
      sl_string<256> s;
      sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z);
      return s;
    }
  };

  template<>
  struct sl_convert<vec4>
  {  
    typedef sl_expr< sl_string<256> > T;
    static inline const T convert (const vec4 &v)
    {
      sl_string<256> s;
      sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w);
      return s;
    }
  };

  template<>
  template<class V>
  struct sl_convert< var_ref<V> >
  {
    typedef sl_expr< sl_append< var_ref<V> > > T;
    static inline const T convert (const var_ref<V> &v)
    {
      return sl_append< var_ref<V> > (v);
    }
  };

  template<>
  struct sl_convert<glvar>
  {
    typedef sl_expr< sl_append<glvar> > T;
    static inline const T convert (const glvar &v)
    {
      return sl_append<glvar> (v);
    }
  };

  template<>
  template<const char *strtype>
  struct sl_convert< temp_ref<strtype> >
  {
    typedef sl_expr< sl_append< temp_ref<strtype> > > T;
    static inline const T convert (const temp_ref<strtype> &v)
    {
      return sl_expr< sl_append< temp_ref<strtype> > >(
               sl_append< temp_ref<strtype> > (v)
             );
    }
  };

  template<class fragment, typename expr>
  inline void sl_assign (const fragment &f, const expr &e)
  {
    cur->append_const ("  ");
    cur->append (f);
    cur->append_const (" = ");
    sl_convert<expr>::convert (e) ();
    cur->append_const (";\n");
  }

  template<class type>
  template<typename expr>
  inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const
  {
    sl_assign (*this, e);
    return *this;
  }

  template<class type, typename arg1>
  template<typename expr>
  inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const
  {
    sl_assign (*this, e);
    return *this;
  }

  template<const char *strtype>
  template<typename expr>
  inline const temp_ref<strtype> &temp_ref<strtype>::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);
    }
  };

# 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 > >     \
    operator op(const A &a, const B &b)                                 \
    {                                                                   \
      return concat (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b));      \
    }

  const sl_append_const_string str_plus  (" + "); 
  const sl_append_const_string str_minus (" - "); 
  const sl_append_const_string str_mul   (" * "); 
  const sl_append_const_string str_div   (" / "); 

  SHADER_BINOP (+, plus);
  SHADER_BINOP (-, minus);
  SHADER_BINOP (*, mul);
  SHADER_BINOP (/, div);

# undef SHADER_BINOP

  const sl_append_const_string str_rpar  (")");

  void debdebdebdebug ()//D
  {
    vertex_shader vsh;
    fragment_shader fsh;
    temp_4f t1, t2;
    sampler_2d s2d (1);

    vsh->start ();

    temp_4f lightpos;
    temp_3f wpos;

    lightpos = vec4 (10, -10, 0, 1);
    wpos = gl.model_view_matrix_inverse_transpose * vin.normal;
    vout.position = wpos;

    vsh->end ();
    vsh->compile ();
  }

}

Revision:	1.2
Committed:	Sat Oct 23 21:47:02 2004 UTC (21 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+4 -4 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "shader.h"
2			#include "shader_vars.h"
3
4			namespace shader {
5
6			refcounted::~refcounted ()
7			{
8			#if 0
9			if (refcnt)
10			abort ();
11			#endif
12			}
13
14			const char str_float [] = "float";
15			const char str_vec2 [] = "vec2";
16			const char str_vec3 [] = "vec3";
17			const char str_vec4 [] = "vec4";
18			const char str_mat2 [] = "mat2";
19			const char str_mat3 [] = "mat3";
20			const char str_mat4 [] = "mat4";
21
22			const char str_sampler_1d [] = "sampler1D";
23			const char str_sampler_1d_shadow [] = "sampler1DShadow";
24			const char str_sampler_2d [] = "sampler2D";
25			const char str_sampler_2d_shadow [] = "sampler2DShadow";
26			const char str_sampler_2d_rect [] = "sampler2DRect";
27			const char str_sampler_2d_rect_shadow [] = "sampler2DRectShadow";
28			const char str_sampler_3d [] = "sampler3D";
29			const char str_sampler_3d_rect [] = "sampler3DRect";
30			const char str_sampler_cube [] = "samplerCube";
31
32			unsigned int var_i::next_id = 0;
33
34			var_i::var_i (const char *typestr)
35			: typestr (typestr)
36			{
37			//param = cgCreateParameter (cg_context, cgtype);
38			}
39
40			var_i::~var_i ()
41			{
42			//cgDestroyParameter (param);
43			}
44
45			temporary_i::temporary_i (const char *strtype)
46			: var_i (strtype)
47			{
48			sprintf (name, "T%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
49			}
50
51			uniform_i::uniform_i (const char *strtype)
52			: var_i (strtype), dirty (true)
53			{
54			sprintf (name, "U%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
55			}
56
57			fragment_string_i::~fragment_string_i ()
58			{
59			free (str);
60			}
61
62			////////////////////////////////////////////////////////////////////////////
63
64			void var_i::build_decl (ostringstream &b)
65			{
66			b << typestr << ' ' << name;
67			}
68
69			void uniform_i::build_decl (ostringstream &b)
70			{
71			b << "uniform " << typestr << ' ' << name;
72			}
73
74			void stream_i::build_decl (ostringstream &b)
75			{
76			b << typestr << ' ' << name;
77			}
78
79			////////////////////////////////////////////////////////////////////////////
80
81			void glvar_i::build (shader_builder &b)
82			{
83			b << name;
84			}
85
86			void var_i::build (shader_builder &b)
87			{
88			b << name;
89			}
90
91			void uniform_i::build (shader_builder &b)
92			{
93			var_i::build (b);
94
95			if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
96			b.refs.push_back (*this);
97			}
98
99			void stream_i::build (shader_builder &b)
100			{
101			var_i::build (b);
102
103			if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
104			b.streams.push_back (*this);
105			}
106
107			void temporary_i::build (shader_builder &b)
108			{
109			var_i::build (b);
110
111			if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
112			b.temps.push_back (*this);
113			}
114
115			void fragment_vector_i::build (shader_builder &b)
116			{
117			for (vector<fragment>::iterator i = begin (); i != end (); i++)
118			(*i)->build (b);
119			}
120
121			void fragment_const_string_i::build (shader_builder &b)
122			{
123			b << str;
124			}
125
126			void fragment_string_i::build (shader_builder &b)
127			{
128			b << str;
129			}
130
131			#if 0
132			void statement_i::build (shader_builder &b)
133			{
134			b << " ";
135			fragment_vector_i::build (b);
136			b << ";\n";
137			}
138			#endif
139
140			////////////////////////////////////////////////////////////////////////////
141
142			shader_object_i *cur = 0;
143
144			shader_object_i::shader_object_i (GLenum type)
145			: type (type)
146			{
147			id = glCreateShaderObjectARB (type);
148			}
149
150			shader_object_i::~shader_object_i ()
151			{
152			glDeleteObjectARB (id);
153			}
154
155			void shader_object_i::start ()
156			{
157			clear ();
158			cur = this;
159			}
160
161			void shader_object_i::stop ()
162			{
163			cur = 0;
164			}
165
166			string shader_object_i::source ()
167			{
168			shader_builder b;
169			build (b);
170			ostringstream os;
171
172			for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
173			{
174			(*i)->build_decl (os);
175			os << ";\n";
176			}
177
178			// not neccessary right now, as GLSL is rich on predefinitions
179			for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
180			{
181			os << "attribute ";
182			(*i)->build_decl (os);
183			os << ";\n";
184			}
185
186			os << "\nvoid main (void)\n{\n";
187
188			for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
189			{
190			os << " ";
191			(*i)->build_decl (os);
192			os << ";\n";
193			}
194
195			os << "\n";
196			os << b.source.str ();
197			os << "}\n";
198
199			return os.str ();
200			}
201
202			void shader_object_i::compile ()
203			{
204			string src = source ();
205			const char *sptr = src.data ();
206			const int slen = src.size ();
207
208			printf ("SOURCE<%s>\n", src.c_str ());
209			abort ();
210			glShaderSourceARB (id, 1, &sptr, &slen);
211			glCompileShaderARB (id);
212
213			GLint compiled;
214			glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
215
216			if (!compiled)
217			{
218			char infolog[8192];
219			glGetInfoLogARB (id, 8192, NULL, infolog);
220			printf ("SOURCE<%s>\n", src.c_str ());
221			printf ("INFOLOG<%s>\n", infolog);
222			abort ();
223			}
224			}
225
226			template<typename T>
227			struct sl_append
228			{
229			T t;
230
231			sl_append (const T &t) : t(t) { }
232
233			void operator ()() const
234			{
235			cur->push_back (t);
236			}
237			};
238
239			template<int length>
240			struct sl_string
241			{
242			char str[length];
243
244			void operator ()() const
245			{
246			cur->push_back (*new fragment_string_i (str));
247			}
248			};
249
250			// only floats
251			struct sl_float
252			{
253			const GLfloat c;
254
255			sl_float (GLfloat c) : c(c) { }
256
257			void operator ()() const
258			{
259			char s[64];
260			sprintf (s, "%g", c);
261			cur->append_string (s);
262			}
263			};
264
265			template<class A, class B>
266			inline sl_expr< sl_concat2<A, B> >
267			concat (const A &a, const B &b)
268			{
269			typedef sl_concat2<A, B> expr;
270			return sl_expr<expr> (expr (a, b));
271			}
272
273			template<class A, class B, class C>
274			inline sl_expr< sl_concat3<A, B, C> >
275			concat (const A &a, const B &b, const C &c)
276			{
277			typedef sl_concat3<A, B, C> expr;
278			return sl_expr<expr> (expr (a, b, c));
279			}
280
281			template<class A, class B, class C, class D>
282			inline sl_expr< sl_concat4<A, B, C, D> >
283			concat (const A &a, const B &b, const C &c, const D &d)
284			{
285			typedef sl_concat4<A, B, C, D> expr;
286			return sl_expr<expr> (expr (a, b, c, d));
287			}
288
289			template<typename expr>
290			struct sl_convert
291			{
292			typedef sl_expr<expr> T;
293			static inline const T &convert (const T &e)
294			{
295			return e;
296			}
297			};
298
299			template<>
300			struct sl_convert<GLfloat>
301			{
302			typedef sl_expr<sl_float> T;
303			static inline const T convert (GLfloat f)
304			{
305			return sl_float (f);
306			}
307			};
308
309			template<>
310			struct sl_convert<vec3>
311			{
312			typedef sl_expr< sl_string<256> > T;
313			static inline const T convert (const vec3 &v)
314			{
315			sl_string<256> s;
316			sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z);
317			return s;
318			}
319			};
320
321			template<>
322			struct sl_convert<vec4>
323			{
324			typedef sl_expr< sl_string<256> > T;
325			static inline const T convert (const vec4 &v)
326			{
327			sl_string<256> s;
328			sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w);
329			return s;
330			}
331			};
332
333			template<>
334			template<class V>
335	root	1.2	struct sl_convert< var_ref<V> >
336	root	1.1	{
337	root	1.2	typedef sl_expr< sl_append< var_ref<V> > > T;
338			static inline const T convert (const var_ref<V> &v)
339	root	1.1	{
340	root	1.2	return sl_append< var_ref<V> > (v);
341	root	1.1	}
342			};
343
344			template<>
345			struct sl_convert<glvar>
346			{
347			typedef sl_expr< sl_append<glvar> > T;
348			static inline const T convert (const glvar &v)
349			{
350			return sl_append<glvar> (v);
351			}
352			};
353
354			template<>
355			template<const char *strtype>
356			struct sl_convert< temp_ref<strtype> >
357			{
358			typedef sl_expr< sl_append< temp_ref<strtype> > > T;
359			static inline const T convert (const temp_ref<strtype> &v)
360			{
361			return sl_expr< sl_append< temp_ref<strtype> > >(
362			sl_append< temp_ref<strtype> > (v)
363			);
364			}
365			};
366
367			template<class fragment, typename expr>
368			inline void sl_assign (const fragment &f, const expr &e)
369			{
370			cur->append_const (" ");
371			cur->append (f);
372			cur->append_const (" = ");
373			sl_convert<expr>::convert (e) ();
374			cur->append_const (";\n");
375			}
376
377			template<class type>
378			template<typename expr>
379			inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const
380			{
381			sl_assign (*this, e);
382			return *this;
383			}
384
385			template<class type, typename arg1>
386			template<typename expr>
387			inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const
388			{
389			sl_assign (*this, e);
390			return *this;
391			}
392
393			template<const char *strtype>
394			template<typename expr>
395			inline const temp_ref<strtype> &temp_ref<strtype>::operator =(const expr &e) const
396			{
397			sl_assign (*this, e);
398			return *this;
399			}
400
401			struct sl_append_const_string
402			{
403			fragment_const_string str;
404			sl_append_const_string (const char *s)
405			: str (s)
406			{ }
407
408			void operator ()() const
409			{
410			cur->push_back (str);
411			}
412			};
413
414			# define SHADER_BINOP(op, str) \
415			extern const sl_append_const_string str_ ## str; \
416			template<typename A, typename B> \
417			inline const sl_expr< sl_concat3< typename sl_convert<A>::T, \
418			sl_append_const_string, \
419			typename sl_convert<B>::T > > \
420			operator op(const A &a, const B &b) \
421			{ \
422			return concat (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b)); \
423			}
424
425			const sl_append_const_string str_plus (" + ");
426			const sl_append_const_string str_minus (" - ");
427			const sl_append_const_string str_mul (" * ");
428			const sl_append_const_string str_div (" / ");
429
430			SHADER_BINOP (+, plus);
431			SHADER_BINOP (-, minus);
432			SHADER_BINOP (*, mul);
433			SHADER_BINOP (/, div);
434
435			# undef SHADER_BINOP
436
437			const sl_append_const_string str_rpar (")");
438
439			void debdebdebdebug ()//D
440			{
441			vertex_shader vsh;
442			fragment_shader fsh;
443			temp_4f t1, t2;
444			sampler_2d s2d (1);
445
446			vsh->start ();
447
448			temp_4f lightpos;
449			temp_3f wpos;
450
451			lightpos = vec4 (10, -10, 0, 1);
452			wpos = gl.model_view_matrix_inverse_transpose * vin.normal;
453			vout.position = wpos;
454
455			vsh->end ();
456			vsh->compile ();
457			}
458
459			}
460