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

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

Diff Legend

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

Comparing libgender/shader.h (file contents): Revision 1.6 by root, Sat Oct 23 23:36:45 2004 UTC vs. Revision 1.27 by root, Wed Nov 3 01:37:23 2004 UTC

Diff Legend

Comparing libgender/shader.h (file contents):
Revision 1.6 by root, Sat Oct 23 23:36:45 2004 UTC vs.
Revision 1.27 by root, Wed Nov 3 01:37:23 2004 UTC