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 (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+4 -4 lines
Log Message:	* empty log message *
#	Content
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	struct sl_convert< var_ref<V> >
336	{
337	typedef sl_expr< sl_append< var_ref<V> > > T;
338	static inline const T convert (const var_ref<V> &v)
339	{
340	return sl_append< var_ref<V> > (v);
341	}
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