libgender/shader.C

#include <cassert>

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

namespace shader {

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

  void refcounted::refcnt_dec () const
  {
    if (!--refcnt)
      delete this; // quite a bit of code...
  }

  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);
  }

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

  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);
    assert (id);
  }

  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 ());
    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 ();
      }
  }

  program_object::program_object ()
  {
    id = glCreateProgramObjectARB ();
    assert (id);
  }

  program_object::~program_object ()
  {
    glDeleteProgramsARB (1, &id);
  }

  void program_object::link ()
  {
    glAttachObjectARB (id, vsh->id);
    glAttachObjectARB (id, fsh->id);
    glLinkProgramARB (id);
        
    GLint linked;
    glGetObjectParameterivARB (id, GL_OBJECT_LINK_STATUS_ARB, &linked);

    if (!linked)
      {
        char infolog[8192];
        glGetInfoLogARB (id, 8192, NULL, infolog);
        printf ("LINK-INFOLOG<%s>\n", infolog);
        abort ();
      }
  }

  void sl_func0::begin () const
  {
    cur->append_string (name_par);
  }

  void sl_func0::comma () const
  {
    cur->append (str_comma);
  }

  void sl_func0::end () const
  {
    str_rpar ();
  }

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

  const sl_convert< ::vec2 >::T sl_convert< ::vec2 >::convert (const ::vec2 &v)
  {
    sl_string<60> s;
    sprintf (s.str, "vec2 (%g, %g)", v.x, v.y);
    return s;
  }

  const sl_convert< ::vec3 >::T sl_convert< ::vec3 >::convert (const ::vec3 &v)
  {
    sl_string<80> s;
    sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z);
    return s;
  }

  const sl_convert< ::vec4 >::T sl_convert< ::vec4 >::convert (const ::vec4 &v)
  {
    sl_string<100> s;
    sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w);
    return s;
  }

  const fragment_const_string str_2sp    ("  ");
  const fragment_const_string str_equal  (" = ");
  const fragment_const_string str_comma  (", ");
  const fragment_const_string str_endl   (";\n");

  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   (" / "); 
  const sl_append_const_string str_mod   (" % "); 

  const sl_append_const_string str_lpar  ("(");
  const sl_append_const_string str_rpar  (")");

  void swizzle_mask (sl_string<7> &s, int mask)
  {
    static const char channel[4] = { 'x', 'y', 'z', 'w' };

    char *str = s.str;

    *str++ = ')';
    *str++ = '.';

    while (mask)
      {
        int c = mask % 5;
        mask /= 5;

        if (c)
          *str++ = channel[c - 1];
      }

    *str++ = 0;
  }


  void debdebdebdebug ()//D
  {
    vertex_shader vsh;

    vsh->start ();

    temp_4f lightpos;
    temp_3f wpos;

    lightpos = vec4 (0, 10, 0, 1);
    wpos = xyz (gl.model_view_matrix * vin.vertex);
    vout.position = gl.model_view_matrix_inverse_transpose * vin.vertex;
    vout.tex_coord[0] = vin.tex_coord[0];
    vout.tex_coord[1] = normalize (lightpos - wpos);
    vout.tex_coord[2] = normalize (wpos);
    //vout.tex_coord[3] = normalize (xyz (gl.model_view_matrix_inverse_transpose) * vin.normal);
    //vout.tex_coord[4] = normalize (xyz (gl.projection_matrix_inverse_transpose) - wpos);

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

    fragment_shader fsh;

    fsh->start ();

    xyz (fout.frag_color) = noise3 (x (fin.frag_coord) * y (fin.frag_coord));

    temp_1f spec_expon;
    spec_expon = 200;

    fsh->end ();
    fsh->compile ();

    //abort ();
  }

}

Revision:	1.14
Committed:	Sun Oct 24 17:10:04 2004 UTC (19 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.13:	+2 -2 lines
Log Message:	* empty log message *
#	Content
1	#include <cassert>
2
3	#include "shader.h"
4	#include "shader_vars.h"
5
6	namespace shader {
7
8	refcounted::~refcounted ()
9	{
10	#if 1
11	if (refcnt)
12	abort ();
13	#endif
14	}
15
16	void refcounted::refcnt_dec () const
17	{
18	if (!--refcnt)
19	delete this; // quite a bit of code...
20	}
21
22	const char str_float [] = "float";
23	const char str_vec2 [] = "vec2";
24	const char str_vec3 [] = "vec3";
25	const char str_vec4 [] = "vec4";
26	const char str_mat2 [] = "mat2";
27	const char str_mat3 [] = "mat3";
28	const char str_mat4 [] = "mat4";
29
30	const char str_sampler_1d [] = "sampler1D";
31	const char str_sampler_1d_shadow [] = "sampler1DShadow";
32	const char str_sampler_2d [] = "sampler2D";
33	const char str_sampler_2d_shadow [] = "sampler2DShadow";
34	const char str_sampler_2d_rect [] = "sampler2DRect";
35	const char str_sampler_2d_rect_shadow [] = "sampler2DRectShadow";
36	const char str_sampler_3d [] = "sampler3D";
37	const char str_sampler_3d_rect [] = "sampler3DRect";
38	const char str_sampler_cube [] = "samplerCube";
39
40	unsigned int var_i::next_id = 0;
41
42	var_i::var_i (const char *typestr)
43	: typestr (typestr)
44	{
45	//param = cgCreateParameter (cg_context, cgtype);
46	}
47
48	var_i::~var_i ()
49	{
50	//cgDestroyParameter (param);
51	}
52
53	stream_i::stream_i (const char *strtype)
54	: var_i (strtype)
55	{
56	sprintf (name, "V%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
57	}
58
59	temporary_i::temporary_i (const char *strtype)
60	: var_i (strtype)
61	{
62	sprintf (name, "T%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
63	}
64
65	uniform_i::uniform_i (const char *strtype)
66	: var_i (strtype), dirty (true)
67	{
68	sprintf (name, "U%lx_%d", ((long)this >> 4) & 0xfff, ++next_id);
69	}
70
71	fragment_string_i::~fragment_string_i ()
72	{
73	free (str);
74	}
75
76	////////////////////////////////////////////////////////////////////////////
77
78	void var_i::build_decl (ostringstream &b)
79	{
80	b << typestr << ' ' << name;
81	}
82
83	void uniform_i::build_decl (ostringstream &b)
84	{
85	b << "uniform " << typestr << ' ' << name;
86	}
87
88	void stream_i::build_decl (ostringstream &b)
89	{
90	b << typestr << ' ' << name;
91	}
92
93	////////////////////////////////////////////////////////////////////////////
94
95	void glvar_i::build (shader_builder &b)
96	{
97	b << name;
98	}
99
100	void var_i::build (shader_builder &b)
101	{
102	b << name;
103	}
104
105	void uniform_i::build (shader_builder &b)
106	{
107	var_i::build (b);
108
109	if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
110	b.refs.push_back (*this);
111	}
112
113	void stream_i::build (shader_builder &b)
114	{
115	var_i::build (b);
116
117	if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
118	b.streams.push_back (*this);
119	}
120
121	void temporary_i::build (shader_builder &b)
122	{
123	var_i::build (b);
124
125	if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
126	b.temps.push_back (*this);
127	}
128
129	void fragment_vector_i::build (shader_builder &b)
130	{
131	for (vector<fragment>::iterator i = begin (); i != end (); i++)
132	(*i)->build (b);
133	}
134
135	void fragment_const_string_i::build (shader_builder &b)
136	{
137	b << str;
138	}
139
140	void fragment_string_i::build (shader_builder &b)
141	{
142	b << str;
143	}
144
145	#if 0
146	void statement_i::build (shader_builder &b)
147	{
148	b << " ";
149	fragment_vector_i::build (b);
150	b << ";\n";
151	}
152	#endif
153
154	////////////////////////////////////////////////////////////////////////////
155
156	shader_object_i *cur = 0;
157
158	shader_object_i::shader_object_i (GLenum type)
159	: type (type)
160	{
161	id = glCreateShaderObjectARB (type);
162	assert (id);
163	}
164
165	shader_object_i::~shader_object_i ()
166	{
167	glDeleteObjectARB (id);
168	}
169
170	void shader_object_i::start ()
171	{
172	clear ();
173	cur = this;
174	}
175
176	void shader_object_i::stop ()
177	{
178	cur = 0;
179	}
180
181	string shader_object_i::source ()
182	{
183	shader_builder b;
184	build (b);
185	ostringstream os;
186
187	for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
188	{
189	(*i)->build_decl (os);
190	os << ";\n";
191	}
192
193	// not neccessary right now, as GLSL is rich on predefinitions
194	for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
195	{
196	os << "attribute ";
197	(*i)->build_decl (os);
198	os << ";\n";
199	}
200
201	os << "\nvoid main (void)\n{\n";
202
203	for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
204	{
205	os << " ";
206	(*i)->build_decl (os);
207	os << ";\n";
208	}
209
210	os << "\n";
211	os << b.source.str ();
212	os << "}\n";
213
214	return os.str ();
215	}
216
217	void shader_object_i::compile ()
218	{
219	string src = source ();
220	const char *sptr = src.data ();
221	const int slen = src.size ();
222
223	printf ("SOURCE<%s>\n", src.c_str ());
224	glShaderSourceARB (id, 1, &sptr, &slen);
225	glCompileShaderARB (id);
226
227	GLint compiled;
228	glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
229
230	if (!compiled)
231	{
232	char infolog[8192];
233	glGetInfoLogARB (id, 8192, NULL, infolog);
234	printf ("SOURCE<%s>\n", src.c_str ());
235	printf ("INFOLOG<%s>\n", infolog);
236	abort ();
237	}
238	}
239
240	program_object::program_object ()
241	{
242	id = glCreateProgramObjectARB ();
243	assert (id);
244	}
245
246	program_object::~program_object ()
247	{
248	glDeleteProgramsARB (1, &id);
249	}
250
251	void program_object::link ()
252	{
253	glAttachObjectARB (id, vsh->id);
254	glAttachObjectARB (id, fsh->id);
255	glLinkProgramARB (id);
256
257	GLint linked;
258	glGetObjectParameterivARB (id, GL_OBJECT_LINK_STATUS_ARB, &linked);
259
260	if (!linked)
261	{
262	char infolog[8192];
263	glGetInfoLogARB (id, 8192, NULL, infolog);
264	printf ("LINK-INFOLOG<%s>\n", infolog);
265	abort ();
266	}
267	}
268
269	void sl_func0::begin () const
270	{
271	cur->append_string (name_par);
272	}
273
274	void sl_func0::comma () const
275	{
276	cur->append (str_comma);
277	}
278
279	void sl_func0::end () const
280	{
281	str_rpar ();
282	}
283
284	void sl_float::operator ()() const
285	{
286	char s[20];
287	sprintf (s, "%g", c);
288	cur->append_string (s);
289	}
290
291	const sl_convert< ::vec2 >::T sl_convert< ::vec2 >::convert (const ::vec2 &v)
292	{
293	sl_string<60> s;
294	sprintf (s.str, "vec2 (%g, %g)", v.x, v.y);
295	return s;
296	}
297
298	const sl_convert< ::vec3 >::T sl_convert< ::vec3 >::convert (const ::vec3 &v)
299	{
300	sl_string<80> s;
301	sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z);
302	return s;
303	}
304
305	const sl_convert< ::vec4 >::T sl_convert< ::vec4 >::convert (const ::vec4 &v)
306	{
307	sl_string<100> s;
308	sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w);
309	return s;
310	}
311
312	const fragment_const_string str_2sp (" ");
313	const fragment_const_string str_equal (" = ");
314	const fragment_const_string str_comma (", ");
315	const fragment_const_string str_endl (";\n");
316
317	const sl_append_const_string str_plus (" + ");
318	const sl_append_const_string str_minus (" - ");
319	const sl_append_const_string str_mul (" * ");
320	const sl_append_const_string str_div (" / ");
321	const sl_append_const_string str_mod (" % ");
322
323	const sl_append_const_string str_lpar ("(");
324	const sl_append_const_string str_rpar (")");
325
326	void swizzle_mask (sl_string<7> &s, int mask)
327	{
328	static const char channel[4] = { 'x', 'y', 'z', 'w' };
329
330	char *str = s.str;
331
332	*str++ = ')';
333	*str++ = '.';
334
335	while (mask)
336	{
337	int c = mask % 5;
338	mask /= 5;
339
340	if (c)
341	*str++ = channel[c - 1];
342	}
343
344	*str++ = 0;
345	}
346
347
348	void debdebdebdebug ()//D
349	{
350	vertex_shader vsh;
351
352	vsh->start ();
353
354	temp_4f lightpos;
355	temp_3f wpos;
356
357	lightpos = vec4 (0, 10, 0, 1);
358	wpos = xyz (gl.model_view_matrix * vin.vertex);
359	vout.position = gl.model_view_matrix_inverse_transpose * vin.vertex;
360	vout.tex_coord[0] = vin.tex_coord[0];
361	vout.tex_coord[1] = normalize (lightpos - wpos);
362	vout.tex_coord[2] = normalize (wpos);
363	//vout.tex_coord[3] = normalize (xyz (gl.model_view_matrix_inverse_transpose) * vin.normal);
364	//vout.tex_coord[4] = normalize (xyz (gl.projection_matrix_inverse_transpose) - wpos);
365
366	vsh->end ();
367	vsh->compile ();
368
369	fragment_shader fsh;
370
371	fsh->start ();
372
373	xyz (fout.frag_color) = noise3 (x (fin.frag_coord) * y (fin.frag_coord));
374
375	temp_1f spec_expon;
376	spec_expon = 200;
377
378	fsh->end ();
379	fsh->compile ();
380
381	//abort ();
382	}
383
384	}
385