[ViewVC] Diff of: cvs/libgender/shader.h

Comparing libgender/shader.h (file contents):
Revision 1.5 by root, Sat Oct 23 23:01:18 2004 UTC vs.
Revision 1.21 by root, Sat Oct 30 00:17:28 2004 UTC

…		…
1	#ifndef SHADER_H	1	#ifndef SHADER_H
2	#define SHADER_H	2	#define SHADER_H
3		3
		4	#include <cassert>
		5
		6	#include <map>
4	#include <sstream>	7	#include <sstream>
5		8
6	#include "opengl.h"	9	#include "opengl.h"
7	#include "util.h"	10	#include "util.h"
8		11
43	const A a; const B b; const C c; const D d;	46	const A a; const B b; const C c; const D d;
44	sl_concat4 (const A &a, const B &b, const C &c, const D &d) : a(a), b(b), c(c), d(d) { }	47	sl_concat4 (const A &a, const B &b, const C &c, const D &d) : a(a), b(b), c(c), d(d) { }
45	void operator ()() const { a (); b (); c (); d(); }	48	void operator ()() const { a (); b (); c (); d(); }
46	};	49	};
47		50
		51	struct sl_func0
		52	{
		53	const char *name_par;
		54	sl_func0 (const char *name_par) : name_par(name_par) { }
		55	void begin () const;
		56	void comma () const;
		57	void end () const;
		58	void operator ()() const
		59	{
		60	begin ();
		61	end ();
		62	}
		63	};
		64
		65	template<class A>
		66	struct sl_func1 : sl_func0
		67	{
		68	const A a;
		69	sl_func1 (const char *name, const A &a) : sl_func0(name), a(a) { }
		70	void operator ()() const { begin (); a (); end (); }
		71	};
		72
		73	template<class A, class B>
		74	struct sl_func2 : sl_func0
		75	{
		76	const A a; const B b;
		77	sl_func2 (const char *name, const A &a, const B &b) : sl_func0(name), a(a), b(b) { }
		78	void operator ()() const { begin (); a (); comma (); b (); end (); }
		79	};
		80
		81	template<class A, class B, class C>
		82	struct sl_func3 : sl_func0
		83	{
		84	const A a; const B b; const C c;
		85	sl_func3 (const char *name, const A &a, const B &b, const C &c) : sl_func0(name), a(a), b(b), c(c) { }
		86	void operator ()() const { begin (); a (); comma (); b (); comma (); c (); end (); }
		87	};
		88
		89	template<class A, class B, class C, class D>
		90	struct sl_func4 : sl_func0
		91	{
		92	const A a; const B b; const C c; const D d;
		93	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) { }
		94	void operator ()() const { begin (); a (); comma (); b (); comma (); c (); comma (); d(); end (); }
		95	};
		96
48	class refcounted	97	class refcounted
49	{	98	{
50	template<class type> friend class ref;	99	template<class type> friend class ref;
51	mutable int refcnt;	100	mutable int refcnt;
52	void refcnt_inc () const { refcnt++; }	101	void refcnt_inc () const { refcnt++; }
53	void refcnt_dec () const { if (!--refcnt) delete this; };	102	void refcnt_dec () const;
54	public:	103	public:
55	refcounted () : refcnt(0) { }	104	refcounted () : refcnt(0) { }
56	virtual ~refcounted ();	105	virtual ~refcounted ();
57	};	106	};
58		107
…		…
162		211
163	struct shader_builder	212	struct shader_builder
164	{	213	{
165	vector<uniform> refs; // uniform parameters	214	vector<uniform> refs; // uniform parameters
166	vector<var> temps; // temporary variables	215	vector<var> temps; // temporary variables
167	vector<var> streams; // varying inputs & outputs
168		216
169	ostringstream source;	217	ostringstream source;
170		218
171	template<typename type>	219	template<typename type>
172	shader_builder &operator <<(const type &t)	220	shader_builder &operator <<(const type &t)
…		…
186	struct lvalue_i : fragment_i	234	struct lvalue_i : fragment_i
187	{	235	{
188	};	236	};
189		237
190	// a simple predeclared variable with unspecified type	238	// a simple predeclared variable with unspecified type
191	struct glvar_i : lvalue_i	239	struct gluvar_i : lvalue_i
192	{	240	{
193	const char *name;	241	const char *name;
194	void build (shader_builder &b);	242	void build (shader_builder &b);
195	glvar_i (const char *name) : name (name) { }	243	gluvar_i (const char *name) : name (name) { }
196	};	244	};
197		245
198	typedef auto_lvalue_ref1<glvar_i, const char *> glvar;	246	typedef auto_lvalue_ref1<gluvar_i, const char *> gluvar;
199		247
200	struct var_i : lvalue_i	248	struct var_i : lvalue_i
201	{	249	{
202	static unsigned int next_id;	250	static unsigned int next_id;
203		251
…		…
211	~var_i ();	259	~var_i ();
212	};	260	};
213		261
214	struct uniform_i : var_i	262	struct uniform_i : var_i
215	{	263	{
216	bool dirty;
217
218	virtual void update () = 0;
219
220	void build (shader_builder &b);	264	void build (shader_builder &b);
221	void build_decl (ostringstream &b);	265	void build_decl (ostringstream &b);
		266
		267	GLint location ();
		268
222	uniform_i (const char *strtype);	269	uniform_i (const char *strtype);
223	};	270	};
224		271
225	template<int dimension, typename gltype, const char strtype, void (upd)(CGparameter, const gltype *)>	272	template<int dimension, typename gltype, const char *strtype>
226	struct uniform2_i : uniform_i	273	struct uniform2_i : uniform_i
227	{	274	{
228	gltype data[dimension];	275	gltype data[dimension];
229		276
230	void update ()
231	{
232	if (dirty)
233	{
234	//upd (param, data);
235	dirty = false;
236	}
237	}
238
239	uniform2_i () : uniform_i (strtype) { }	277	uniform2_i () : uniform_i (strtype) { }
240	};	278	};
241		279
242	template<int dimension, const char strtype, void (update)(CGparameter, const GLfloat *)>	280	template<int dimension, const char *strtype>
243	struct uniform_f_i : uniform2_i<dimension, GLfloat, strtype, update>	281	struct uniform_f_i : uniform2_i<dimension, GLfloat, strtype>
244	{	282	{
245	};	283	};
246		284
247	struct uniform_1f_i : uniform_f_i<1, str_float, cgGLSetParameter1fv> {	285	struct uniform_1f_i : uniform_f_i<1, str_float> {
248	void operator =(GLfloat v)	286	void set (GLfloat v)
249	{	287	{
250	data[0] = v;	288	data[0] = v;
251	dirty = true;
252	}
253	};
254		289
		290	GLint loc = location ();
		291	if (loc >= 0) // workaround for buggy drivers
		292	glUniform1fvARB (loc, 1, data);
		293	}
		294	};
		295
255	struct uniform_2f_i : uniform_f_i<2, str_vec2, cgGLSetParameter2fv> { };	296	struct uniform_2f_i : uniform_f_i<2, str_vec2> {
256		297	void set (GLfloat x, GLfloat y)
257	struct uniform_3f_i : uniform_f_i<3, str_vec3, cgGLSetParameter3fv> {
258	void operator =(const vec3 &v)
259	{	298	{
260	data[0] = v.x;	299	data[0] = x;
261	data[1] = v.y;	300	data[1] = y;
		301
		302	GLint loc = location ();
		303	if (loc >= 0) // workaround for buggy drivers
		304	glUniform2fvARB (loc, 1, data);
		305	}
		306
		307	void set (const vec2 &v) { set (v.x, v.y); }
		308	};
		309
		310	struct uniform_3f_i : uniform_f_i<3, str_vec3> {
		311	void set (GLfloat x, GLfloat y, GLfloat z)
		312	{
		313	data[0] = x;
		314	data[1] = y;
262	data[2] = v.z;	315	data[2] = z;
263	dirty = true;
264	}
265	};
266		316
		317	GLint loc = location ();
		318	if (loc >= 0) // workaround for buggy drivers
		319	glUniform3fvARB (loc, 1, data);
		320	}
		321
		322	void set (const vec3 &v) { set (v.x, v.y, v.z); }
		323	};
		324
267	struct uniform_4f_i : uniform_f_i<4, str_vec4, cgGLSetParameter4fv> {	325	struct uniform_4f_i : uniform_f_i<4, str_vec4> {
268	#if 0	326	void set (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
		327	{
		328	data[0] = x;
		329	data[1] = y;
		330	data[2] = z;
		331	data[3] = w;
		332
		333	GLint loc = location ();
		334	if (loc >= 0) // workaround for buggy drivers
		335	glUniform4fvARB (loc, 1, data);
		336	}
		337
		338	void set (const vec4 &v) { set (v.x, v.y, v.z, v.w); }
		339	};
		340
		341	struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2>
		342	{
		343	void set (const GLfloat d[4])
		344	{
		345	memcpy (data, d, 4 * sizeof (GLfloat));
		346
		347	GLint loc = location ();
		348	if (loc >= 0) // workaround for buggy drivers
		349	glUniformMatrix2fvARB (loc, 1, 0, data);
		350	}
		351	};
		352
		353	struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3>
		354	{
		355	void set (const GLfloat d[9])
		356	{
		357	memcpy (data, d, 9 * sizeof (GLfloat));
		358
		359	GLint loc = location ();
		360	if (loc >= 0) // workaround for buggy drivers
		361	glUniformMatrix3fvARB (loc, 1, 0, data);
		362	}
		363	};
		364
		365	struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4>
		366	{
269	void operator =(const gl::matrix &m)	367	void set (const gl::matrix &m)
270	{	368	{
271	memcpy (data, m.data, 16 * sizeof (GLfloat));	369	memcpy (data, m.data, 16 * sizeof (GLfloat));
272	dirty = true;
273	}
274	#endif
275	};
276		370
277	struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { };	371	GLint loc = location ();
278	struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { };	372	if (loc >= 0) // workaround for buggy drivers
279	struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { };	373	glUniformMatrix4fvARB (loc, 1, 0, data);
		374	}
		375	};
280		376
281	template<class var_i>	377	template<class var_i>
282	struct var_ref : ref<var_i>	378	struct var_ref : ref<var_i>
283	{	379	{
284	var_ref (const char *glname = 0)	380	var_ref (const char *glname = 0)
…		…
316	};	412	};
317		413
318	template<int dimension, const char *strtype>	414	template<int dimension, const char *strtype>
319	struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype>	415	struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype>
320	{	416	{
321	void set (const gl::vertex_buffer_object &vb, GLint offset)	417	void set (const gl::vertex_buffer &vb, GLint offset)
322	{	418	{
323	varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset);	419	varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset);
324	}	420	}
325	};	421	};
326		422
…		…
328	{	424	{
329	};	425	};
330		426
331	struct varying_2f_i : varying_f_i<2, str_vec2>	427	struct varying_2f_i : varying_f_i<2, str_vec2>
332	{	428	{
333	void set_t (const gl::vertex_buffer_object &vb)	429	void set_t (const gl::vertex_buffer &vb)
334	{	430	{
335	set (vb, gl::format_offset_t (vb.format));	431	set (vb, gl::format_offset_t (vb.format));
336	}	432	}
337	};	433	};
338		434
339	struct varying_3f_i : varying_f_i<3, str_vec3>	435	struct varying_3f_i : varying_f_i<3, str_vec3>
340	{	436	{
341	void set_p (const gl::vertex_buffer_object &vb)	437	void set_p (const gl::vertex_buffer &vb)
342	{	438	{
343	set (vb, gl::format_offset_p (vb.format));	439	set (vb, gl::format_offset_p (vb.format));
344	}	440	}
345		441
346	void set_n (const gl::vertex_buffer_object &vb)	442	void set_n (const gl::vertex_buffer &vb)
347	{	443	{
348	set (vb, gl::format_offset_n (vb.format));	444	set (vb, gl::format_offset_n (vb.format));
349	}	445	}
350	};	446	};
351		447
…		…
370	{	466	{
371	temp_ref ()	467	temp_ref ()
372	: ref<temporary_i> (*new temporary_i (strtype))	468	: ref<temporary_i> (*new temporary_i (strtype))
373	{	469	{
374	}	470	}
		471
		472	#if 0
		473	template<typename expr>
		474	temp_ref (const expr &e)
		475	: ref<temporary_i> (*new temporary_i (strtype))
		476	{
		477	(*this) = e;
		478	}
		479	#endif
375		480
376	template<typename expr>	481	template<typename expr>
377	const temp_ref &operator =(const expr &e) const;	482	const temp_ref &operator =(const expr &e) const;
378	};	483	};
379		484
…		…
383	typedef temp_ref<str_vec4> temp_4f;	488	typedef temp_ref<str_vec4> temp_4f;
384	typedef temp_ref<str_mat2> temp_matrix_2f;	489	typedef temp_ref<str_mat2> temp_matrix_2f;
385	typedef temp_ref<str_mat3> temp_matrix_3f;	490	typedef temp_ref<str_mat3> temp_matrix_3f;
386	typedef temp_ref<str_mat4> temp_matrix_4f;	491	typedef temp_ref<str_mat4> temp_matrix_4f;
387		492
		493	struct texture_units
		494	{
		495	static int units[8];
		496	static int unit_count;
		497
		498	static GLenum get_texture_unit ()
		499	{
		500	assert (unit_count);
		501	return units[--unit_count];
		502	}
		503
		504	static void put_texture_unit (GLenum unit)
		505	{
		506	assert (unit_count < 8);
		507	units[unit_count++] = unit;
		508	}
		509	};
		510
388	template<GLenum gltype, const char *strtype>	511	template<GLenum gltype, const char *strtype>
389	struct sampler_i : uniform_i	512	struct sampler_i : uniform_i, texture_units
390	{	513	{
391	GLuint texture;	514	int unit;
		515	GLuint name;
392		516
393	void update ()	517	void enable ()
394	{	518	{
395	if (dirty)	519	#if DEBUG
		520	assert (unit < 0);
		521	#endif
		522	GLint loc = location ();
		523
		524	if (loc >= 0)
396	{	525	{
397	//cgGLSetTextureParameter (param, texture);	526	unit = get_texture_unit ();
398	dirty = false;	527	glActiveTexture (GL_TEXTURE0 + unit);
		528	glBindTexture (gltype, name);
		529	glUniform1iARB (loc, unit);
399	}	530	}
400	}	531	}
401		532
402	void begin ()	533	void disable ()
403	{
404	cgGLEnableTextureParameter (texture);
405	}	534	{
		535	if (unit >= 0)
		536	{
		537	put_texture_unit (unit);
		538	unit = -1;
		539	}
		540	}
406		541
407	sampler_i (GLuint texturename) : uniform_i (strtype), texture (texturename) { }	542	template<class bufferclass, class vectype>
408	};	543	void set (const gl::vertex_buffer &vb, const vectype bufferclass::*vp)
		544	{
		545	glTexCoordPointer (
		546	vector_traits<vectype>::dimension (),
		547	gltype_traits<typename vector_traits<vectype>::basetype>::gltype,
		548	sizeof (bufferclass),
		549	(GLvoid)(char bufferclass::*)vp
		550	);
		551	}
409		552
		553	sampler_i (GLuint texture)
		554	: uniform_i (strtype)
		555	, name (texture)
		556	#if DEBUG
		557	, unit (-1)
		558	#endif
		559	{
		560	}
		561	};
		562
410	struct sampler_1d_i : sampler_i<CG_SAMPLER1D, str_sampler_1d>	563	struct sampler_1d_i : sampler_i<GL_TEXTURE_1D, str_sampler_1d>
411	{	564	{
412	sampler_1d_i (GLuint texturename) : sampler_i<CG_SAMPLER1D, str_sampler_1d> (texturename) { }	565	sampler_1d_i (GLuint texture) : sampler_i<GL_TEXTURE_1D, str_sampler_1d> (texture) { }
413	};	566	};
414		567
415	struct sampler_1d_shadow_i : sampler_i<CG_SAMPLER1D, str_sampler_1d_shadow>	568	struct sampler_1d_shadow_i : sampler_i<GL_TEXTURE_1D, str_sampler_1d_shadow>
416	{	569	{
417	sampler_1d_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLER1D, str_sampler_1d_shadow> (texturename) { }	570	sampler_1d_shadow_i (GLuint texture) : sampler_i<GL_TEXTURE_1D, str_sampler_1d_shadow> (texture) { }
418	};	571	};
419		572
420	struct sampler_2d_i : sampler_i<CG_SAMPLER2D, str_sampler_2d>	573	struct sampler_2d_i : sampler_i<GL_TEXTURE_2D, str_sampler_2d>
421	{	574	{
422	sampler_2d_i (GLuint texturename) : sampler_i<CG_SAMPLER2D, str_sampler_2d> (texturename) { }	575	sampler_2d_i (GLuint texture) : sampler_i<GL_TEXTURE_2D, str_sampler_2d> (texture) { }
423	};	576	};
424		577
425	struct sampler_2d_shadow_i : sampler_i<CG_SAMPLER2D, str_sampler_2d_shadow>	578	struct sampler_2d_shadow_i : sampler_i<GL_TEXTURE_2D, str_sampler_2d_shadow>
426	{	579	{
427	sampler_2d_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLER2D, str_sampler_2d_shadow> (texturename) { }	580	sampler_2d_shadow_i (GLuint texture) : sampler_i<GL_TEXTURE_2D, str_sampler_2d_shadow> (texture) { }
428	};	581	};
429		582
430	struct sampler_2d_rect_i : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect>	583	struct sampler_2d_rect_i : sampler_i<GL_TEXTURE_2D, str_sampler_2d_rect>
431	{	584	{
432	sampler_2d_rect_i (GLuint texturename) : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect> (texturename) { }	585	sampler_2d_rect_i (GLuint texture) : sampler_i<GL_TEXTURE_2D, str_sampler_2d_rect> (texture) { }
433	};	586	};
434		587
435	struct sampler_2d_rect_shadow_i : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect_shadow>	588	struct sampler_2d_rect_shadow_i : sampler_i<GL_TEXTURE_2D, str_sampler_2d_rect_shadow>
436	{	589	{
437	sampler_2d_rect_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect_shadow> (texturename) { }	590	sampler_2d_rect_shadow_i (GLuint texture) : sampler_i<GL_TEXTURE_2D, str_sampler_2d_rect_shadow> (texture) { }
438	};	591	};
439		592
440	struct sampler_3d_i : sampler_i<CG_SAMPLER3D, str_sampler_3d>	593	struct sampler_3d_i : sampler_i<GL_TEXTURE_3D, str_sampler_3d>
441	{	594	{
442	sampler_3d_i (GLuint texturename) : sampler_i<CG_SAMPLER3D, str_sampler_3d> (texturename) { }	595	sampler_3d_i (GLuint texture) : sampler_i<GL_TEXTURE_3D, str_sampler_3d> (texture) { }
443	};	596	};
444		597
445	struct sampler_3d_rect_i : sampler_i<CG_SAMPLER3D, str_sampler_3d_rect>	598	struct sampler_3d_rect_i : sampler_i<GL_TEXTURE_3D, str_sampler_3d_rect>
446	{	599	{
447	sampler_3d_rect_i (GLuint texturename) : sampler_i<CG_SAMPLER3D, str_sampler_3d_rect> (texturename) { }	600	sampler_3d_rect_i (GLuint texture) : sampler_i<GL_TEXTURE_3D, str_sampler_3d_rect> (texture) { }
448	};	601	};
449		602
450	struct sampler_cube_i : sampler_i<CG_SAMPLERCUBE, str_sampler_cube>	603	struct sampler_cube_i : sampler_i<GL_TEXTURE_CUBE_MAP, str_sampler_cube>
451	{	604	{
452	sampler_cube_i (GLuint texturename) : sampler_i<CG_SAMPLERCUBE, str_sampler_cube> (texturename) { }	605	sampler_cube_i (GLuint texture) : sampler_i<GL_TEXTURE_CUBE_MAP, str_sampler_cube> (texture) { }
453	};	606	};
454		607
		608	template<class sampler_i>
		609	struct sampler_ref : auto_ref1<sampler_i, GLuint>
		610	{
		611	sampler_ref (GLuint texture)
		612	: auto_ref1<sampler_i, GLuint> (texture)
		613	{
		614	}
		615	};
		616
455	typedef auto_ref1<sampler_1d_i, GLuint> sampler_1d;	617	typedef sampler_ref<sampler_1d_i> sampler_1d;
456	typedef auto_ref1<sampler_1d_shadow_i, GLuint> sampler_1d_shadow;	618	typedef sampler_ref<sampler_1d_shadow_i> sampler_1d_shadow;
457	typedef auto_ref1<sampler_2d_i, GLuint> sampler_2d;	619	typedef sampler_ref<sampler_2d_i> sampler_2d;
458	typedef auto_ref1<sampler_2d_shadow_i, GLuint> sampler_2d_shadow;	620	typedef sampler_ref<sampler_2d_shadow_i> sampler_2d_shadow;
459	typedef auto_ref1<sampler_2d_rect_i, GLuint> sampler_2d_rect;	621	typedef sampler_ref<sampler_2d_rect_i> sampler_2d_rect;
460	typedef auto_ref1<sampler_2d_rect_shadow_i, GLuint> sampler_2d_rect_shadow;	622	typedef sampler_ref<sampler_2d_rect_shadow_i> sampler_2d_rect_shadow;
461	typedef auto_ref1<sampler_3d_i, GLuint> sampler_3d;	623	typedef sampler_ref<sampler_3d_i> sampler_3d;
462	typedef auto_ref1<sampler_3d_rect_i, GLuint> sampler_3d_rect;	624	typedef sampler_ref<sampler_3d_rect_i> sampler_3d_rect;
463	typedef auto_ref1<sampler_cube_i, GLuint> sampler_cube;	625	typedef sampler_ref<sampler_cube_i> sampler_cube;
464		626
465	struct fragment_const_string_i : fragment_i	627	struct fragment_const_string_i : fragment_i
466	{	628	{
467	const char *str;	629	const char *str;
468		630
…		…
506		668
507	void append_string (const char *s)	669	void append_string (const char *s)
508	{	670	{
509	push_back (*new fragment_string_i (s));	671	push_back (*new fragment_string_i (s));
510	}	672	}
511
512	#if 0
513	fragment_vector_i &operator <<(statement_i &f)
514	{
515	push_back (*new fragment_const_string_i (" "));
516
517	for (vector<fragment>::iterator i = f.begin (); i != f.end (); i++)
518	push_back (*i);
519
520	push_back (*new fragment_const_string_i (";\n"));
521	return *this;
522	}
523	#endif
524	};	673	};
525		674
526	typedef ref<fragment_vector_i> fragment_vector;	675	typedef ref<fragment_vector_i> fragment_vector;
527		676
528	struct shader_object_i : fragment_vector_i	677	struct shader_object_i : fragment_vector_i
…		…
551	};	700	};
552		701
553	typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader;	702	typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader;
554	typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader;	703	typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader;
555		704
		705	struct program_object
		706	{
		707	static struct program_object *cur; // currently bound program
		708
		709	GLuint id;
		710
		711	vertex_shader vsh;
		712	fragment_shader fsh;
		713
		714	map<uniform_i *,GLint> uloc; // uniform location
		715
		716	program_object ();
		717	~program_object ();
		718
		719	void link ();
		720
		721	void enable ();
		722	void disable ();
		723	};
		724
556	template<typename T>	725	template<typename T>
557	struct sl_append	726	struct sl_append
558	{	727	{
559	T t;	728	T t;
560		729
…		…
575	{	744	{
576	cur->push_back (*new fragment_string_i (str));	745	cur->push_back (*new fragment_string_i (str));
577	}	746	}
578	};	747	};
579		748
580	// only floats
581	struct sl_float	749	struct sl_float
582	{	750	{
583	const GLfloat c;	751	const GLfloat c;
584		752
585	sl_float (GLfloat c) : c(c) { }	753	sl_float (GLfloat c) : c(c) { }
586		754
587	void operator ()() const	755	void operator ()() const;
588	{
589	char s[64];
590	sprintf (s, "%g", c);
591	cur->append_string (s);
592	}
593	};	756	};
594		757
595	template<class A, class B>	758	template<class A, class B>
596	inline sl_expr< sl_concat2<A, B> >	759	inline sl_expr< sl_concat2<A, B> >
597	concat (const A &a, const B &b)	760	concat (const A &a, const B &b)
…		…
655	return sl_float (i);	818	return sl_float (i);
656	}	819	}
657	};	820	};
658		821
659	template<>	822	template<>
		823	struct sl_convert<vec2>
		824	{
		825	typedef sl_expr< sl_string<60> > T;
		826	static const T convert (const vec2 &v);
		827	};
		828
		829	template<>
660	struct sl_convert<vec3>	830	struct sl_convert<vec3>
661	{	831	{
662	typedef sl_expr< sl_string<256> > T;	832	typedef sl_expr< sl_string<80> > T;
663	static inline const T convert (const vec3 &v)	833	static const T convert (const vec3 &v);
664	{
665	sl_string<256> s;
666	sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z);
667	return s;
668	}
669	};	834	};
670		835
671	template<>	836	template<>
672	struct sl_convert<vec4>	837	struct sl_convert<vec4>
673	{	838	{
674	typedef sl_expr< sl_string<256> > T;	839	typedef sl_expr< sl_string<100> > T;
675	static inline const T convert (const vec4 &v)	840	static const T convert (const vec4 &v);
676	{
677	sl_string<256> s;
678	sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w);
679	return s;
680	}
681	};	841	};
682		842
683	template<>	843	template<>
684	template<class V>	844	template<class V>
685	struct sl_convert< var_ref<V> >	845	struct sl_convert< var_ref<V> >
…		…
690	return sl_append< var_ref<V> > (v);	850	return sl_append< var_ref<V> > (v);
691	}	851	}
692	};	852	};
693		853
694	template<>	854	template<>
695	struct sl_convert<glvar>	855	struct sl_convert<gluvar>
696	{	856	{
697	typedef sl_expr< sl_append<glvar> > T;	857	typedef sl_expr< sl_append<gluvar> > T;
698	static inline const T convert (const glvar &v)	858	static inline const T convert (const gluvar &v)
699	{	859	{
700	return sl_append<glvar> (v);	860	return sl_append<gluvar> (v);
701	}	861	}
702	};	862	};
703		863
704	template<>	864	template<>
705	template<const char *strtype>	865	template<const char *strtype>
…		…
712	sl_append< temp_ref<strtype> > (v)	872	sl_append< temp_ref<strtype> > (v)
713	);	873	);
714	}	874	}
715	};	875	};
716		876
		877	template<>
		878	template<class sampler_i>
		879	struct sl_convert< sampler_ref<sampler_i> >
		880	{
		881	typedef sl_expr< sl_append< sampler_ref<sampler_i> > > T;
		882	static inline const T convert (const sampler_ref<sampler_i> &v)
		883	{
		884	return sl_append< sampler_ref<sampler_i> > (v);
		885	}
		886	};
		887
		888	namespace compile {
717	extern const fragment_const_string str_2sp;	889	extern const fragment_const_string str_2sp;
718	extern const fragment_const_string str_equal;	890	extern const fragment_const_string str_equal;
		891	extern const fragment_const_string str_comma;
719	extern const fragment_const_string str_endl;	892	extern const fragment_const_string str_endl;
720		893
721	template<class fragment, typename expr>	894	template<class fragment, typename expr>
722	inline void sl_assign (const fragment &f, const expr &e)	895	inline void sl_assign (const fragment &f, const expr &e)
723	{	896	{
724	cur->append (str_2sp);	897	cur->append (str_2sp);
725	cur->append (f);	898	cur->append (f);
726	cur->append (str_equal);	899	cur->append (str_equal);
727	sl_convert<expr>::convert (e) ();	900	sl_convert<expr>::convert (e) ();
728	cur->append (str_endl);	901	cur->append (str_endl);
		902	}
729	}	903	}
730		904
731	template<class type>	905	template<class type>
732	template<typename expr>	906	template<typename expr>
733	inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const	907	inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const
734	{	908	{
735	sl_assign (*this, e);	909	compile::sl_assign (*this, e);
736	return *this;	910	return *this;
737	}	911	}
738		912
739	template<class type, typename arg1>	913	template<class type, typename arg1>
740	template<typename expr>	914	template<typename expr>
741	inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const	915	inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const
742	{	916	{
743	sl_assign (*this, e);	917	compile::sl_assign (*this, e);
744	return *this;	918	return *this;
745	}	919	}
746		920
747	template<class T>	921	template<class T>
748	template<typename expr>	922	template<typename expr>
749	inline const sl_expr<T> &sl_expr<T>::operator =(const expr &e) const	923	inline const sl_expr<T> &sl_expr<T>::operator =(const expr &e) const
750	{	924	{
751	sl_assign (*this, e);	925	compile::sl_assign (*this, e);
752	return *this;	926	return *this;
753	}	927	}
754		928
755	template<const char *strtype>	929	template<const char *strtype>
756	template<typename expr>	930	template<typename expr>
757	inline const temp_ref<strtype> &temp_ref<strtype>::operator =(const expr &e) const	931	inline const temp_ref<strtype> &temp_ref<strtype>::operator =(const expr &e) const
758	{	932	{
759	sl_assign (*this, e);	933	compile::sl_assign (*this, e);
760	return *this;	934	return *this;
761	}	935	}
762		936
763	struct sl_append_const_string	937	struct sl_append_const_string
764	{	938	{
…		…
771	{	945	{
772	cur->push_back (str);	946	cur->push_back (str);
773	}	947	}
774	};	948	};
775		949
		950	namespace compile {
		951	extern const sl_append_const_string str_lpar;
		952	extern const sl_append_const_string str_rpar;
		953	extern const sl_append_const_string str_minus;
		954
		955	using namespace shader;
		956
		957	template<typename T>
		958	inline const sl_expr< sl_concat2< sl_append_const_string,
		959	typename sl_convert<T>::T
		960	> >
		961	operator -(const T &t)
		962	{
		963	return concat (str_minus, sl_convert<T>::convert (t), s);
		964	}
		965
		966	template<class A, class B, class C>
		967	struct sl_binop
		968	{
		969	const A a; const B b; const C c;
		970	sl_binop (const A &a, const B &b, const C &c) : a(a), b(b), c(c) { }
		971	void operator ()() const { str_lpar (); a (); b (); c (); str_rpar (); }
		972	};
		973
776	# define SHADER_BINOP(op, str) \	974	# define SHADER_BINOP(op, str) \
777	extern const sl_append_const_string str_ ## str; \	975	extern const sl_append_const_string str_ ## str; \
778	template<typename A, typename B> \	976	template<typename A, typename B> \
779	inline const sl_expr< sl_concat3< typename sl_convert<A>::T, \	977	inline const sl_expr< sl_binop< typename sl_convert<A>::T, \
780	sl_append_const_string, \	978	sl_append_const_string, \
781	typename sl_convert<B>::T > > \	979	typename sl_convert<B>::T > > \
782	operator op(const A &a, const B &b) \	980	operator op(const A &a, const B &b) \
783	{ \	981	{ \
		982	return sl_binop< typename sl_convert<A>::T, sl_append_const_string, typename sl_convert<B>::T > \
784	return concat (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b)); \	983	(sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b)); \
785	}	984	}
786		985
787	SHADER_BINOP (+, plus);	986	SHADER_BINOP (+, plus);
788	SHADER_BINOP (-, minus);	987	SHADER_BINOP (-, minus);
789	SHADER_BINOP (*, mul);	988	SHADER_BINOP (*, mul);
790	SHADER_BINOP (/, div);	989	SHADER_BINOP (/, div);
		990	SHADER_BINOP (%, mod);
791		991
		992	SHADER_BINOP (<, lt);
		993	SHADER_BINOP (<=, lte);
		994	SHADER_BINOP (==, eq);
		995	SHADER_BINOP (!=, ne);
		996	SHADER_BINOP (>=, gte);
		997	SHADER_BINOP (>, gt);
		998
792	# undef SHADER_BINOP	999	# undef SHADER_BINOP
793		1000
794	void swizzle_mask (sl_string<7> &s, int mask);	1001	void swizzle_mask (sl_string<7> &s, int mask);
		1002
		1003	template<typename T>
		1004	inline const sl_expr< sl_concat3< sl_append_const_string,
		1005	typename sl_convert<T>::T,
		1006	sl_string<7>
		1007	> >
		1008	swizzle (const T &t, int a, int b = 0, int c = 0, int d = 0)
		1009	{
		1010	sl_string<7> s;
		1011	swizzle_mask (s, ((d * 5 + c) * 5 + b) * 5 + a);
		1012	return concat (str_lpar, sl_convert<T>::convert (t), s);
		1013	}
		1014
		1015	# define SHADER_SWIZZLE_OP(abcd,type) \
		1016	template<typename T> \
		1017	inline const sl_expr< sl_concat3< sl_append_const_string, \
		1018	typename sl_convert<T>::T, \
		1019	sl_string<7> \
		1020	> > \
		1021	type (const T &t) \
		1022	{ \
		1023	return swizzle (t, (abcd / 1000) % 5, (abcd / 100) % 5, (abcd / 10) % 5, (abcd / 1) % 5); \
		1024	}
		1025
		1026	// brute force is lovely, ain't it?
		1027	SHADER_SWIZZLE_OP (1 , x ) SHADER_SWIZZLE_OP (11 , xx ) SHADER_SWIZZLE_OP (111 , xxx ) SHADER_SWIZZLE_OP (1111, xxxx)
		1028	SHADER_SWIZZLE_OP (1112, xxxy) SHADER_SWIZZLE_OP (1113, xxxz) SHADER_SWIZZLE_OP (1114, xxxw) SHADER_SWIZZLE_OP (112 , xxy )
		1029	SHADER_SWIZZLE_OP (1121, xxyx) SHADER_SWIZZLE_OP (1122, xxyy) SHADER_SWIZZLE_OP (1123, xxyz) SHADER_SWIZZLE_OP (1124, xxyw)
		1030	SHADER_SWIZZLE_OP (113 , xxz ) SHADER_SWIZZLE_OP (1131, xxzx) SHADER_SWIZZLE_OP (1132, xxzy) SHADER_SWIZZLE_OP (1133, xxzz)
		1031	SHADER_SWIZZLE_OP (1134, xxzw) SHADER_SWIZZLE_OP (114 , xxw ) SHADER_SWIZZLE_OP (1141, xxwx) SHADER_SWIZZLE_OP (1142, xxwy)
		1032	SHADER_SWIZZLE_OP (1143, xxwz) SHADER_SWIZZLE_OP (1144, xxww) SHADER_SWIZZLE_OP (12 , xy ) SHADER_SWIZZLE_OP (121 , xyx )
		1033	SHADER_SWIZZLE_OP (1211, xyxx) SHADER_SWIZZLE_OP (1212, xyxy) SHADER_SWIZZLE_OP (1213, xyxz) SHADER_SWIZZLE_OP (1214, xyxw)
		1034	SHADER_SWIZZLE_OP (122 , xyy ) SHADER_SWIZZLE_OP (1221, xyyx) SHADER_SWIZZLE_OP (1222, xyyy) SHADER_SWIZZLE_OP (1223, xyyz)
		1035	SHADER_SWIZZLE_OP (1224, xyyw) SHADER_SWIZZLE_OP (123 , xyz ) SHADER_SWIZZLE_OP (1231, xyzx) SHADER_SWIZZLE_OP (1232, xyzy)
		1036	SHADER_SWIZZLE_OP (1233, xyzz) SHADER_SWIZZLE_OP (1234, xyzw) SHADER_SWIZZLE_OP (124 , xyw ) SHADER_SWIZZLE_OP (1241, xywx)
		1037	SHADER_SWIZZLE_OP (1242, xywy) SHADER_SWIZZLE_OP (1243, xywz) SHADER_SWIZZLE_OP (1244, xyww) SHADER_SWIZZLE_OP (13 , xz )
		1038	SHADER_SWIZZLE_OP (131 , xzx ) SHADER_SWIZZLE_OP (1311, xzxx) SHADER_SWIZZLE_OP (1312, xzxy) SHADER_SWIZZLE_OP (1313, xzxz)
		1039	SHADER_SWIZZLE_OP (1314, xzxw) SHADER_SWIZZLE_OP (132 , xzy ) SHADER_SWIZZLE_OP (1321, xzyx) SHADER_SWIZZLE_OP (1322, xzyy)
		1040	SHADER_SWIZZLE_OP (1323, xzyz) SHADER_SWIZZLE_OP (1324, xzyw) SHADER_SWIZZLE_OP (133 , xzz ) SHADER_SWIZZLE_OP (1331, xzzx)
		1041	SHADER_SWIZZLE_OP (1332, xzzy) SHADER_SWIZZLE_OP (1333, xzzz) SHADER_SWIZZLE_OP (1334, xzzw) SHADER_SWIZZLE_OP (134 , xzw )
		1042	SHADER_SWIZZLE_OP (1341, xzwx) SHADER_SWIZZLE_OP (1342, xzwy) SHADER_SWIZZLE_OP (1343, xzwz) SHADER_SWIZZLE_OP (1344, xzww)
		1043	SHADER_SWIZZLE_OP (14 , xw ) SHADER_SWIZZLE_OP (141 , xwx ) SHADER_SWIZZLE_OP (1411, xwxx) SHADER_SWIZZLE_OP (1412, xwxy)
		1044	SHADER_SWIZZLE_OP (1413, xwxz) SHADER_SWIZZLE_OP (1414, xwxw) SHADER_SWIZZLE_OP (142 , xwy ) SHADER_SWIZZLE_OP (1421, xwyx)
		1045	SHADER_SWIZZLE_OP (1422, xwyy) SHADER_SWIZZLE_OP (1423, xwyz) SHADER_SWIZZLE_OP (1424, xwyw) SHADER_SWIZZLE_OP (143 , xwz )
		1046	SHADER_SWIZZLE_OP (1431, xwzx) SHADER_SWIZZLE_OP (1432, xwzy) SHADER_SWIZZLE_OP (1433, xwzz) SHADER_SWIZZLE_OP (1434, xwzw)
		1047	SHADER_SWIZZLE_OP (144 , xww ) SHADER_SWIZZLE_OP (1441, xwwx) SHADER_SWIZZLE_OP (1442, xwwy) SHADER_SWIZZLE_OP (1443, xwwz)
		1048	SHADER_SWIZZLE_OP (1444, xwww) SHADER_SWIZZLE_OP (2 , y ) SHADER_SWIZZLE_OP (21 , yx ) SHADER_SWIZZLE_OP (211 , yxx )
		1049	SHADER_SWIZZLE_OP (2111, yxxx) SHADER_SWIZZLE_OP (2112, yxxy) SHADER_SWIZZLE_OP (2113, yxxz) SHADER_SWIZZLE_OP (2114, yxxw)
		1050	SHADER_SWIZZLE_OP (212 , yxy ) SHADER_SWIZZLE_OP (2121, yxyx) SHADER_SWIZZLE_OP (2122, yxyy) SHADER_SWIZZLE_OP (2123, yxyz)
		1051	SHADER_SWIZZLE_OP (2124, yxyw) SHADER_SWIZZLE_OP (213 , yxz ) SHADER_SWIZZLE_OP (2131, yxzx) SHADER_SWIZZLE_OP (2132, yxzy)
		1052	SHADER_SWIZZLE_OP (2133, yxzz) SHADER_SWIZZLE_OP (2134, yxzw) SHADER_SWIZZLE_OP (214 , yxw ) SHADER_SWIZZLE_OP (2141, yxwx)
		1053	SHADER_SWIZZLE_OP (2142, yxwy) SHADER_SWIZZLE_OP (2143, yxwz) SHADER_SWIZZLE_OP (2144, yxww) SHADER_SWIZZLE_OP (22 , yy )
		1054	SHADER_SWIZZLE_OP (221 , yyx ) SHADER_SWIZZLE_OP (2211, yyxx) SHADER_SWIZZLE_OP (2212, yyxy) SHADER_SWIZZLE_OP (2213, yyxz)
		1055	SHADER_SWIZZLE_OP (2214, yyxw) SHADER_SWIZZLE_OP (222 , yyy ) SHADER_SWIZZLE_OP (2221, yyyx) SHADER_SWIZZLE_OP (2222, yyyy)
		1056	SHADER_SWIZZLE_OP (2223, yyyz) SHADER_SWIZZLE_OP (2224, yyyw) SHADER_SWIZZLE_OP (223 , yyz ) SHADER_SWIZZLE_OP (2231, yyzx)
		1057	SHADER_SWIZZLE_OP (2232, yyzy) SHADER_SWIZZLE_OP (2233, yyzz) SHADER_SWIZZLE_OP (2234, yyzw) SHADER_SWIZZLE_OP (224 , yyw )
		1058	SHADER_SWIZZLE_OP (2241, yywx) SHADER_SWIZZLE_OP (2242, yywy) SHADER_SWIZZLE_OP (2243, yywz) SHADER_SWIZZLE_OP (2244, yyww)
		1059	SHADER_SWIZZLE_OP (23 , yz ) SHADER_SWIZZLE_OP (231 , yzx ) SHADER_SWIZZLE_OP (2311, yzxx) SHADER_SWIZZLE_OP (2312, yzxy)
		1060	SHADER_SWIZZLE_OP (2313, yzxz) SHADER_SWIZZLE_OP (2314, yzxw) SHADER_SWIZZLE_OP (232 , yzy ) SHADER_SWIZZLE_OP (2321, yzyx)
		1061	SHADER_SWIZZLE_OP (2322, yzyy) SHADER_SWIZZLE_OP (2323, yzyz) SHADER_SWIZZLE_OP (2324, yzyw) SHADER_SWIZZLE_OP (233 , yzz )
		1062	SHADER_SWIZZLE_OP (2331, yzzx) SHADER_SWIZZLE_OP (2332, yzzy) SHADER_SWIZZLE_OP (2333, yzzz) SHADER_SWIZZLE_OP (2334, yzzw)
		1063	SHADER_SWIZZLE_OP (234 , yzw ) SHADER_SWIZZLE_OP (2341, yzwx) SHADER_SWIZZLE_OP (2342, yzwy) SHADER_SWIZZLE_OP (2343, yzwz)
		1064	SHADER_SWIZZLE_OP (2344, yzww) SHADER_SWIZZLE_OP (24 , yw ) SHADER_SWIZZLE_OP (241 , ywx ) SHADER_SWIZZLE_OP (2411, ywxx)
		1065	SHADER_SWIZZLE_OP (2412, ywxy) SHADER_SWIZZLE_OP (2413, ywxz) SHADER_SWIZZLE_OP (2414, ywxw) SHADER_SWIZZLE_OP (242 , ywy )
		1066	SHADER_SWIZZLE_OP (2421, ywyx) SHADER_SWIZZLE_OP (2422, ywyy) SHADER_SWIZZLE_OP (2423, ywyz) SHADER_SWIZZLE_OP (2424, ywyw)
		1067	SHADER_SWIZZLE_OP (243 , ywz ) SHADER_SWIZZLE_OP (2431, ywzx) SHADER_SWIZZLE_OP (2432, ywzy) SHADER_SWIZZLE_OP (2433, ywzz)
		1068	SHADER_SWIZZLE_OP (2434, ywzw) SHADER_SWIZZLE_OP (244 , yww ) SHADER_SWIZZLE_OP (2441, ywwx) SHADER_SWIZZLE_OP (2442, ywwy)
		1069	SHADER_SWIZZLE_OP (2443, ywwz) SHADER_SWIZZLE_OP (2444, ywww) SHADER_SWIZZLE_OP (3 , z ) SHADER_SWIZZLE_OP (31 , zx )
		1070	SHADER_SWIZZLE_OP (311 , zxx ) SHADER_SWIZZLE_OP (3111, zxxx) SHADER_SWIZZLE_OP (3112, zxxy) SHADER_SWIZZLE_OP (3113, zxxz)
		1071	SHADER_SWIZZLE_OP (3114, zxxw) SHADER_SWIZZLE_OP (312 , zxy ) SHADER_SWIZZLE_OP (3121, zxyx) SHADER_SWIZZLE_OP (3122, zxyy)
		1072	SHADER_SWIZZLE_OP (3123, zxyz) SHADER_SWIZZLE_OP (3124, zxyw) SHADER_SWIZZLE_OP (313 , zxz ) SHADER_SWIZZLE_OP (3131, zxzx)
		1073	SHADER_SWIZZLE_OP (3132, zxzy) SHADER_SWIZZLE_OP (3133, zxzz) SHADER_SWIZZLE_OP (3134, zxzw) SHADER_SWIZZLE_OP (314 , zxw )
		1074	SHADER_SWIZZLE_OP (3141, zxwx) SHADER_SWIZZLE_OP (3142, zxwy) SHADER_SWIZZLE_OP (3143, zxwz) SHADER_SWIZZLE_OP (3144, zxww)
		1075	SHADER_SWIZZLE_OP (32 , zy ) SHADER_SWIZZLE_OP (321 , zyx ) SHADER_SWIZZLE_OP (3211, zyxx) SHADER_SWIZZLE_OP (3212, zyxy)
		1076	SHADER_SWIZZLE_OP (3213, zyxz) SHADER_SWIZZLE_OP (3214, zyxw) SHADER_SWIZZLE_OP (322 , zyy ) SHADER_SWIZZLE_OP (3221, zyyx)
		1077	SHADER_SWIZZLE_OP (3222, zyyy) SHADER_SWIZZLE_OP (3223, zyyz) SHADER_SWIZZLE_OP (3224, zyyw) SHADER_SWIZZLE_OP (323 , zyz )
		1078	SHADER_SWIZZLE_OP (3231, zyzx) SHADER_SWIZZLE_OP (3232, zyzy) SHADER_SWIZZLE_OP (3233, zyzz) SHADER_SWIZZLE_OP (3234, zyzw)
		1079	SHADER_SWIZZLE_OP (324 , zyw ) SHADER_SWIZZLE_OP (3241, zywx) SHADER_SWIZZLE_OP (3242, zywy) SHADER_SWIZZLE_OP (3243, zywz)
		1080	SHADER_SWIZZLE_OP (3244, zyww) SHADER_SWIZZLE_OP (33 , zz ) SHADER_SWIZZLE_OP (331 , zzx ) SHADER_SWIZZLE_OP (3311, zzxx)
		1081	SHADER_SWIZZLE_OP (3312, zzxy) SHADER_SWIZZLE_OP (3313, zzxz) SHADER_SWIZZLE_OP (3314, zzxw) SHADER_SWIZZLE_OP (332 , zzy )
		1082	SHADER_SWIZZLE_OP (3321, zzyx) SHADER_SWIZZLE_OP (3322, zzyy) SHADER_SWIZZLE_OP (3323, zzyz) SHADER_SWIZZLE_OP (3324, zzyw)
		1083	SHADER_SWIZZLE_OP (333 , zzz ) SHADER_SWIZZLE_OP (3331, zzzx) SHADER_SWIZZLE_OP (3332, zzzy) SHADER_SWIZZLE_OP (3333, zzzz)
		1084	SHADER_SWIZZLE_OP (3334, zzzw) SHADER_SWIZZLE_OP (334 , zzw ) SHADER_SWIZZLE_OP (3341, zzwx) SHADER_SWIZZLE_OP (3342, zzwy)
		1085	SHADER_SWIZZLE_OP (3343, zzwz) SHADER_SWIZZLE_OP (3344, zzww) SHADER_SWIZZLE_OP (34 , zw ) SHADER_SWIZZLE_OP (341 , zwx )
		1086	SHADER_SWIZZLE_OP (3411, zwxx) SHADER_SWIZZLE_OP (3412, zwxy) SHADER_SWIZZLE_OP (3413, zwxz) SHADER_SWIZZLE_OP (3414, zwxw)
		1087	SHADER_SWIZZLE_OP (342 , zwy ) SHADER_SWIZZLE_OP (3421, zwyx) SHADER_SWIZZLE_OP (3422, zwyy) SHADER_SWIZZLE_OP (3423, zwyz)
		1088	SHADER_SWIZZLE_OP (3424, zwyw) SHADER_SWIZZLE_OP (343 , zwz ) SHADER_SWIZZLE_OP (3431, zwzx) SHADER_SWIZZLE_OP (3432, zwzy)
		1089	SHADER_SWIZZLE_OP (3433, zwzz) SHADER_SWIZZLE_OP (3434, zwzw) SHADER_SWIZZLE_OP (344 , zww ) SHADER_SWIZZLE_OP (3441, zwwx)
		1090	SHADER_SWIZZLE_OP (3442, zwwy) SHADER_SWIZZLE_OP (3443, zwwz) SHADER_SWIZZLE_OP (3444, zwww) SHADER_SWIZZLE_OP (4 , w )
		1091	SHADER_SWIZZLE_OP (41 , wx ) SHADER_SWIZZLE_OP (411 , wxx ) SHADER_SWIZZLE_OP (4111, wxxx) SHADER_SWIZZLE_OP (4112, wxxy)
		1092	SHADER_SWIZZLE_OP (4113, wxxz) SHADER_SWIZZLE_OP (4114, wxxw) SHADER_SWIZZLE_OP (412 , wxy ) SHADER_SWIZZLE_OP (4121, wxyx)
		1093	SHADER_SWIZZLE_OP (4122, wxyy) SHADER_SWIZZLE_OP (4123, wxyz) SHADER_SWIZZLE_OP (4124, wxyw) SHADER_SWIZZLE_OP (413 , wxz )
		1094	SHADER_SWIZZLE_OP (4131, wxzx) SHADER_SWIZZLE_OP (4132, wxzy) SHADER_SWIZZLE_OP (4133, wxzz) SHADER_SWIZZLE_OP (4134, wxzw)
		1095	SHADER_SWIZZLE_OP (414 , wxw ) SHADER_SWIZZLE_OP (4141, wxwx) SHADER_SWIZZLE_OP (4142, wxwy) SHADER_SWIZZLE_OP (4143, wxwz)
		1096	SHADER_SWIZZLE_OP (4144, wxww) SHADER_SWIZZLE_OP (42 , wy ) SHADER_SWIZZLE_OP (421 , wyx ) SHADER_SWIZZLE_OP (4211, wyxx)
		1097	SHADER_SWIZZLE_OP (4212, wyxy) SHADER_SWIZZLE_OP (4213, wyxz) SHADER_SWIZZLE_OP (4214, wyxw) SHADER_SWIZZLE_OP (422 , wyy )
		1098	SHADER_SWIZZLE_OP (4221, wyyx) SHADER_SWIZZLE_OP (4222, wyyy) SHADER_SWIZZLE_OP (4223, wyyz) SHADER_SWIZZLE_OP (4224, wyyw)
		1099	SHADER_SWIZZLE_OP (423 , wyz ) SHADER_SWIZZLE_OP (4231, wyzx) SHADER_SWIZZLE_OP (4232, wyzy) SHADER_SWIZZLE_OP (4233, wyzz)
		1100	SHADER_SWIZZLE_OP (4234, wyzw) SHADER_SWIZZLE_OP (424 , wyw ) SHADER_SWIZZLE_OP (4241, wywx) SHADER_SWIZZLE_OP (4242, wywy)
		1101	SHADER_SWIZZLE_OP (4243, wywz) SHADER_SWIZZLE_OP (4244, wyww) SHADER_SWIZZLE_OP (43 , wz ) SHADER_SWIZZLE_OP (431 , wzx )
		1102	SHADER_SWIZZLE_OP (4311, wzxx) SHADER_SWIZZLE_OP (4312, wzxy) SHADER_SWIZZLE_OP (4313, wzxz) SHADER_SWIZZLE_OP (4314, wzxw)
		1103	SHADER_SWIZZLE_OP (432 , wzy ) SHADER_SWIZZLE_OP (4321, wzyx) SHADER_SWIZZLE_OP (4322, wzyy) SHADER_SWIZZLE_OP (4323, wzyz)
		1104	SHADER_SWIZZLE_OP (4324, wzyw) SHADER_SWIZZLE_OP (433 , wzz ) SHADER_SWIZZLE_OP (4331, wzzx) SHADER_SWIZZLE_OP (4332, wzzy)
		1105	SHADER_SWIZZLE_OP (4333, wzzz) SHADER_SWIZZLE_OP (4334, wzzw) SHADER_SWIZZLE_OP (434 , wzw ) SHADER_SWIZZLE_OP (4341, wzwx)
		1106	SHADER_SWIZZLE_OP (4342, wzwy) SHADER_SWIZZLE_OP (4343, wzwz) SHADER_SWIZZLE_OP (4344, wzww) SHADER_SWIZZLE_OP (44 , ww )
		1107	SHADER_SWIZZLE_OP (441 , wwx ) SHADER_SWIZZLE_OP (4411, wwxx) SHADER_SWIZZLE_OP (4412, wwxy) SHADER_SWIZZLE_OP (4413, wwxz)
		1108	SHADER_SWIZZLE_OP (4414, wwxw) SHADER_SWIZZLE_OP (442 , wwy ) SHADER_SWIZZLE_OP (4421, wwyx) SHADER_SWIZZLE_OP (4422, wwyy)
		1109	SHADER_SWIZZLE_OP (4423, wwyz) SHADER_SWIZZLE_OP (4424, wwyw) SHADER_SWIZZLE_OP (443 , wwz ) SHADER_SWIZZLE_OP (4431, wwzx)
		1110	SHADER_SWIZZLE_OP (4432, wwzy) SHADER_SWIZZLE_OP (4433, wwzz) SHADER_SWIZZLE_OP (4434, wwzw) SHADER_SWIZZLE_OP (444 , www )
		1111	SHADER_SWIZZLE_OP (4441, wwwx) SHADER_SWIZZLE_OP (4442, wwwy) SHADER_SWIZZLE_OP (4443, wwwz) SHADER_SWIZZLE_OP (4444, wwww)
		1112
		1113	# undef SHADER_SWIZZLE_OP
		1114
		1115	# define SHADER_FUNC0_(name, glname) \
		1116	template<typename A> \
		1117	inline const sl_expr<sl_func0> \
		1118	name () \
		1119	{ \
		1120	return sl_func0 (#glname " ("); \
		1121	}
		1122
		1123	# define SHADER_FUNC0(name) SHADER_FUNC0_(name,name)
		1124
		1125	# define SHADER_FUNC1_(name, glname) \
		1126	template<typename A> \
		1127	inline const sl_expr< sl_func1<typename sl_convert<A>::T> > \
		1128	name (const A &a) \
		1129	{ \
		1130	return sl_func1<typename sl_convert<A>::T> (#glname " (", sl_convert<A>::convert (a));\
		1131	}
		1132
		1133	# define SHADER_FUNC1(name) SHADER_FUNC1_(name,name)
		1134
		1135	# define SHADER_FUNC2_(name, glname) \
		1136	template<typename A, typename B> \
		1137	inline const sl_expr< sl_func2<typename sl_convert<A>::T, typename sl_convert<B>::T> > \
		1138	name (const A &a, const B &b) \
		1139	{ \
		1140	return sl_func2<typename sl_convert<A>::T, typename sl_convert<B>::T> (#glname " (", sl_convert<A>::convert (a), sl_convert<B>::convert (b));\
		1141	}
		1142
		1143	# define SHADER_FUNC2(name) SHADER_FUNC2_(name,name)
		1144
		1145	# define SHADER_FUNC3_(name, glname) \
		1146	template<typename A, typename B, typename C> \
		1147	inline const sl_expr< sl_func3<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T> > \
		1148	name (const A &a, const B &b, const C &c) \
		1149	{ \
		1150	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));\
		1151	}
		1152
		1153	# define SHADER_FUNC3(name) SHADER_FUNC3_(name,name)
		1154
		1155	# define SHADER_FUNC4_(name, glname) \
		1156	template<typename A, typename B, typename C, typename D> \
		1157	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 > > \
		1158	name (const A &a, const B &b, const C &c, const D &d) \
		1159	{ \
		1160	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));\
		1161	}
		1162
		1163	# define SHADER_FUNC4(name) SHADER_FUNC4_(name,name)
		1164
		1165	SHADER_FUNC1 (abs)
		1166	SHADER_FUNC1 (acos)
		1167	SHADER_FUNC1 (all)
		1168	SHADER_FUNC1 (any)
		1169	SHADER_FUNC1 (asin)
		1170	SHADER_FUNC1 (atan)
		1171	SHADER_FUNC2 (atan)
		1172	SHADER_FUNC1 (ceil)
		1173	SHADER_FUNC3 (clamp)
		1174	SHADER_FUNC1 (cos)
		1175	SHADER_FUNC2 (cross)
		1176	SHADER_FUNC1 (dFdx)
		1177	SHADER_FUNC1 (dFdy)
		1178	SHADER_FUNC1 (degrees)
		1179	SHADER_FUNC2 (distance)
		1180	SHADER_FUNC2 (dot)
		1181	SHADER_FUNC2_(equal, equal)
		1182	SHADER_FUNC1 (exp)
		1183	SHADER_FUNC1 (exp2)
		1184	SHADER_FUNC3 (faceforward)
		1185	SHADER_FUNC1 (floor)
		1186	SHADER_FUNC1 (fract)
		1187	SHADER_FUNC0 (ftransform)
		1188	SHADER_FUNC1 (fwidth)
		1189	SHADER_FUNC2_(greater_than_equal, greaterThanEqual)
		1190	SHADER_FUNC2_(greater_then, greaterThan)
		1191	SHADER_FUNC1 (inversesqrt)
		1192	SHADER_FUNC1 (length)
		1193	SHADER_FUNC2_(less_than, lessThan)
		1194	SHADER_FUNC2_(less_than_equal, lessThanEqual)
		1195	SHADER_FUNC1 (log)
		1196	SHADER_FUNC1 (log2)
		1197	SHADER_FUNC2_(matrix_comp_mult, matrixCompMult)
		1198	SHADER_FUNC2 (max)
		1199	SHADER_FUNC2 (min)
		1200	SHADER_FUNC3 (mix)
		1201	SHADER_FUNC2 (mod)
		1202	SHADER_FUNC1 (noise1)
		1203	SHADER_FUNC1 (noise2)
		1204	SHADER_FUNC1 (noise3)
		1205	SHADER_FUNC1 (noise4)
		1206	SHADER_FUNC1 (normalize)
		1207	SHADER_FUNC1 (gl_not) // TODO
		1208	SHADER_FUNC2_(notequal, notEqual)
		1209	SHADER_FUNC2 (pow)
		1210	SHADER_FUNC1 (radians)
		1211	SHADER_FUNC2 (reflect)
		1212	SHADER_FUNC3 (refract)
		1213	SHADER_FUNC2_(shadow_1d, shadow1D)
		1214	SHADER_FUNC3_(shadow_1d, shadow1D)
		1215	SHADER_FUNC3_(shadow_1d_lod, shadow1DLod)
		1216	SHADER_FUNC2_(shadow_1d_proj, shadow1DProj)
		1217	SHADER_FUNC3_(shadow_1d_proj, shadow1DProj)
		1218	SHADER_FUNC3_(shadow_1d_proj_lod, shadow1DProjLod)
		1219	SHADER_FUNC2_(shadow_2d, shadow2D)
		1220	SHADER_FUNC3_(shadow_2d, shadow2D)
		1221	SHADER_FUNC3_(shadow_2d_lod, shadow2DLod)
		1222	SHADER_FUNC2_(shadow_2d_proj, shadow2DProj)
		1223	SHADER_FUNC3_(shadow_2d_proj, shadow2DProj)
		1224	SHADER_FUNC3_(shadow_2d_proj_lod, shadow2DProjLod)
		1225	SHADER_FUNC1 (sign)
		1226	SHADER_FUNC1 (sin)
		1227	SHADER_FUNC3 (smoothstep)
		1228	SHADER_FUNC1 (sqrt)
		1229	SHADER_FUNC2 (step)
		1230	SHADER_FUNC1 (tan)
		1231	SHADER_FUNC2_(texture_1d, texture1D)
		1232	SHADER_FUNC3_(texture_1d, texture1D)
		1233	SHADER_FUNC3_(texture_1d_lod, texture1DLod)
		1234	SHADER_FUNC2_(texture_1d_proj, texture1DProj)
		1235	SHADER_FUNC3_(texture_1d_proj, texture1DProj)
		1236	SHADER_FUNC3_(texture_1d_proj_lod, texture1DProjLod)
		1237	SHADER_FUNC2_(texture_2d, texture2D)
		1238	SHADER_FUNC3_(texture_2d, texture2D)
		1239	SHADER_FUNC3_(texture_2d_lod, texture2DLod)
		1240	SHADER_FUNC2_(texture_2d_proj, texture2DProj)
		1241	SHADER_FUNC3_(texture_2d_proj, texture2DProj)
		1242	SHADER_FUNC3_(texture_2d_proj_lod, texture2DProjLod)
		1243	SHADER_FUNC2_(texture_3d, texture3D)
		1244	SHADER_FUNC3_(texture_3d, texture3D)
		1245	SHADER_FUNC3_(texture_3d_lod, texture3DLod)
		1246	SHADER_FUNC2_(texture_3d_proj, texture3DProj)
		1247	SHADER_FUNC3_(texture_3d_proj, texture3DProj)
		1248	SHADER_FUNC3_(texture_3d_proj_lod, texture3DProjLod)
		1249	SHADER_FUNC2_(texture_cube, textureCube)
		1250	SHADER_FUNC3_(texture_cube, textureCube)
		1251	SHADER_FUNC3_(texture_cude_lod, textureCubeLod)
		1252	SHADER_FUNC1 (vec2) SHADER_FUNC2 (vec2)
		1253	SHADER_FUNC1 (vec3) SHADER_FUNC2 (vec3) SHADER_FUNC3 (vec3)
		1254	SHADER_FUNC1 (vec4) SHADER_FUNC2 (vec4) SHADER_FUNC3 (vec4) SHADER_FUNC4 (vec4)
		1255	SHADER_FUNC1 (mat2) SHADER_FUNC2 (mat2)
		1256	SHADER_FUNC1 (mat3) SHADER_FUNC2 (mat3) SHADER_FUNC3 (mat3)
		1257	SHADER_FUNC1 (mat4) SHADER_FUNC2 (mat4) SHADER_FUNC3 (mat4) SHADER_FUNC4 (mat4)
		1258
		1259	# undef SHADER_FUNC0
		1260	# undef SHADER_FUNC0_
		1261	# undef SHADER_FUNC1
		1262	# undef SHADER_FUNC1_
		1263	# undef SHADER_FUNC2
		1264	# undef SHADER_FUNC2_
		1265	# undef SHADER_FUNC3
		1266	# undef SHADER_FUNC3_
		1267	# undef SHADER_FUNC4
		1268	# undef SHADER_FUNC5_
		1269	}
		1270
795	void debdebdebdebug ();//D	1271	void debdebdebdebug ();//D
796	}	1272	}
797		1273
798	#endif	1274	#endif
799		1275
		1276	#include "shader_vars.h"
		1277
		1278

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libgender/shader.h (file contents): Revision 1.5 by root, Sat Oct 23 23:01:18 2004 UTC vs. Revision 1.21 by root, Sat Oct 30 00:17:28 2004 UTC

Diff Legend

Comparing libgender/shader.h (file contents):
Revision 1.5 by root, Sat Oct 23 23:01:18 2004 UTC vs.
Revision 1.21 by root, Sat Oct 30 00:17:28 2004 UTC