ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libgender/shader.h
Revision: 1.27
Committed: Wed Nov 3 01:37:23 2004 UTC (19 years, 7 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.26: +32 -33 lines
Log Message:
*** empty log message ***

File Contents

# Content
1 #ifndef SHADER_H
2 #define SHADER_H
3
4 #include <cassert>
5
6 #include <set>
7 #include <map>
8 #include <sstream>
9
10 #include "opengl.h"
11 #include "util.h"
12
13 namespace shader {
14
15 using namespace std;
16
17 const int NAMELEN = 32;
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
35 template<class T>
36 struct sl_expr {
37 const T &t;
38 sl_expr (const T &t) : t(t) { }
39 void operator ()() const { t (); }
40 template<typename expr>
41 const sl_expr &operator =(const expr &e) const;
42 };
43
44 template<class A, class B>
45 struct sl_concat2
46 {
47 const A a; const B b;
48 sl_concat2 (const A &a, const B &b) : a(a), b(b) { }
49 void operator ()() const { a (); b (); }
50 };
51
52 template<class A, class B, class C>
53 struct sl_concat3
54 {
55 const A a; const B b; const C c;
56 sl_concat3 (const A &a, const B &b, const C &c) : a(a), b(b), c(c) { }
57 void operator ()() const { a (); b (); c (); }
58 };
59
60 template<class A, class B, class C, class D>
61 struct sl_concat4
62 {
63 const A a; const B b; const C c; const 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) { }
65 void operator ()() const { a (); b (); c (); d(); }
66 };
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
127 class refcounted
128 {
129 template<class type> friend class ref;
130 mutable unsigned int refcnt;
131 void refcnt_inc () const { refcnt++; }
132 void refcnt_dec () const { if (!--refcnt) refcnt_destroy (); }
133 void refcnt_destroy () const;
134 public:
135 refcounted () : refcnt(0) { }
136 virtual ~refcounted ();
137 };
138
139 template<class type>
140 struct ref
141 {
142 type *p;
143
144 ref ()
145 {
146 p = new type;
147 p->refcnt_inc ();
148 }
149
150 ref (type &d)
151 {
152 d.refcnt_inc ();
153 p = &d;
154 }
155
156 ref (const ref &r)
157 {
158 r.p->refcnt_inc ();
159 p = r.p;
160 }
161
162 template<class type2>
163 ref (const ref<type2> &r)
164 {
165 r.p->refcnt_inc ();
166 p = r.p;
167 }
168
169 ~ref ()
170 {
171 p->refcnt_dec ();
172 }
173
174 ref &operator =(type &d)
175 {
176 d.refcnt_inc ();
177 p->refcnt_dec ();
178 p = &d;
179 return *this;
180 }
181
182 type *operator ->() const { return p; }
183
184 operator type &() const { return *p; }
185
186 template<class type2>
187 bool operator ==(const ref<type2> b) const
188 {
189 return (void *)p == (void *)b.p;
190 }
191 };
192
193 // ref with auto-construct
194 template<class type>
195 struct auto_ref0 : ref<type>
196 {
197 auto_ref0 () : ref<type> (*new type ()) { }
198 };
199
200 template<class type, typename arg1>
201 struct auto_ref1 : ref<type>
202 {
203 auto_ref1 (arg1 a) : ref<type> (*new type (a)) { }
204 };
205
206 template<class type>
207 struct auto_lvalue_ref0 : ref<type>
208 {
209 auto_lvalue_ref0 () : ref<type> (*new type ()) { }
210 template<typename expr>
211 const auto_lvalue_ref0 &operator =(const expr &e) const;
212 };
213
214 template<class type, typename arg1>
215 struct auto_lvalue_ref1 : ref<type>
216 {
217 auto_lvalue_ref1 (arg1 a) : ref<type> (*new type (a)) { }
218 template<class expr>
219 const auto_lvalue_ref1 &operator =(const expr &e) const;
220 };
221
222 extern const char str_float [];
223 extern const char str_vec2 [];
224 extern const char str_vec3 [];
225 extern const char str_vec4 [];
226 extern const char str_mat2 [];
227 extern const char str_mat3 [];
228 extern const char str_mat4 [];
229
230 extern const char str_sampler_1d [];
231 extern const char str_sampler_1d_shadow [];
232 extern const char str_sampler_2d [];
233 extern const char str_sampler_2d_shadow [];
234 extern const char str_sampler_2d_rect [];
235 extern const char str_sampler_2d_rect_shadow [];
236 extern const char str_sampler_3d [];
237 extern const char str_sampler_3d_rect [];
238 extern const char str_sampler_cube [];
239
240 typedef ref<struct var_i> var;
241 typedef ref<struct uniform_i> uniform;
242
243 struct fragment_i : refcounted
244 {
245 };
246
247 typedef ref<fragment_i> fragment;
248
249 struct lvalue_i : fragment_i
250 {
251 };
252
253 // a simple predeclared variable with unspecified type
254 struct gluvar_i : lvalue_i
255 {
256 const char *name;
257
258 void operator ()() const
259 {
260 shader_builder::cur->code << name;
261 }
262
263 gluvar_i (const char *name) : name (name) { }
264 };
265
266 typedef auto_lvalue_ref1<gluvar_i, const char *> gluvar;
267
268 struct var_i : lvalue_i
269 {
270 static unsigned int next_id;
271
272 char name[NAMELEN];
273 const char *domainstr;
274 const char *typestr;
275
276 void operator ()() const;
277
278 var_i (const char *domainstr, const char *typestr);
279 ~var_i ();
280 };
281
282 struct uniform_i : var_i
283 {
284 GLint location ();
285
286 uniform_i (const char *strtype);
287 };
288
289 template<int dimension, typename gltype, const char *strtype>
290 struct uniform2_i : uniform_i
291 {
292 gltype data[dimension];
293
294 uniform2_i () : uniform_i (strtype) { }
295 };
296
297 template<int dimension, const char *strtype>
298 struct uniform_f_i : uniform2_i<dimension, GLfloat, strtype>
299 {
300 };
301
302 struct uniform_1f_i : uniform_f_i<1, str_float> {
303 void set (GLfloat v)
304 {
305 data[0] = v;
306
307 GLint loc = location ();
308 if (loc >= 0) // workaround for buggy drivers
309 glUniform1fvARB (loc, 1, data);
310 }
311 };
312
313 struct uniform_2f_i : uniform_f_i<2, str_vec2> {
314 void set (GLfloat x, GLfloat y)
315 {
316 data[0] = x;
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;
332 data[2] = z;
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
342 struct uniform_4f_i : uniform_f_i<4, str_vec4> {
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 {
384 void set (const gl::matrix &m)
385 {
386 memcpy (data, m.data, 16 * sizeof (GLfloat));
387
388 GLint loc = location ();
389 if (loc >= 0) // workaround for buggy drivers
390 glUniformMatrix4fvARB (loc, 1, 0, data);
391 }
392 };
393
394 template<class var_i>
395 struct var_ref : ref<var_i>
396 {
397 var_ref (const char *glname = 0)
398 : ref<var_i> (*new var_i)
399 {
400 if (glname)
401 strcpy ((*this)->name, glname);
402 }
403 };
404
405 typedef var_ref<uniform_1f_i> uniform_1f;
406 typedef var_ref<uniform_2f_i> uniform_2f;
407 typedef var_ref<uniform_3f_i> uniform_3f;
408 typedef var_ref<uniform_4f_i> uniform_4f;
409 typedef var_ref<uniform_matrix_2f_i> uniform_matrix_2f;
410 typedef var_ref<uniform_matrix_3f_i> uniform_matrix_3f;
411 typedef var_ref<uniform_matrix_4f_i> uniform_matrix_4f;
412
413 #if 0
414 // to be used for attributes
415
416 struct stream_i : var_i
417 {
418 stream_i (const char *strtype);
419 };
420
421 template<int dimension, GLenum gltype, const char *strtype>
422 struct varying_i : stream_i
423 {
424 varying_i () : stream_i (strtype) { }
425
426 void set (GLsizei stride, GLvoid *ptr)
427 {
428 //cgGLSetParameterPointer (param, dimension, gltype, stride, ptr);
429 }
430 };
431
432 template<int dimension, const char *strtype>
433 struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype>
434 {
435 void set (const gl::vertex_buffer &vb, GLint offset)
436 {
437 varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset);
438 }
439 };
440
441 struct varying_1f_i : varying_f_i<1, str_float>
442 {
443 };
444
445 struct varying_2f_i : varying_f_i<2, str_vec2>
446 {
447 void set_t (const gl::vertex_buffer &vb)
448 {
449 set (vb, gl::format_offset_t (vb.format));
450 }
451 };
452
453 struct varying_3f_i : varying_f_i<3, str_vec3>
454 {
455 void set_p (const gl::vertex_buffer &vb)
456 {
457 set (vb, gl::format_offset_p (vb.format));
458 }
459
460 void set_n (const gl::vertex_buffer &vb)
461 {
462 set (vb, gl::format_offset_n (vb.format));
463 }
464 };
465
466 struct varying_4f_i : varying_f_i<4, str_vec4>
467 {
468 };
469
470 typedef var_ref<varying_1f_i> varying_1f;
471 typedef var_ref<varying_2f_i> varying_2f;
472 typedef var_ref<varying_3f_i> varying_3f;
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 };
480
481 struct temporary_i : var_i
482 {
483 temporary_i (const char *strtype);
484 };
485
486 template<const char *strtype, class var_i>
487 struct glnvar_ref : ref<var_i>
488 {
489 glnvar_ref ()
490 : ref<var_i> (*new var_i (strtype))
491 {
492 }
493
494 #if 0
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>
504 const glnvar_ref &operator =(const expr &e) const;
505 };
506
507 typedef glnvar_ref<str_float, temporary_i> temp_1f;
508 typedef glnvar_ref<str_vec2, temporary_i> temp_2f;
509 typedef glnvar_ref<str_vec3, temporary_i> temp_3f;
510 typedef glnvar_ref<str_vec4, temporary_i> temp_4f;
511 typedef glnvar_ref<str_mat2, temporary_i> temp_matrix_2f;
512 typedef glnvar_ref<str_mat3, temporary_i> temp_matrix_3f;
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 };
540
541 template<GLenum gltype, const char *strtype>
542 struct sampler_i : uniform_i, texture_units
543 {
544 int unit;
545 GLuint name;
546
547 void enable ()
548 {
549 #if DEBUG
550 assert (unit < 0);
551 #endif
552 GLint loc = location ();
553
554 if (loc >= 0)
555 {
556 unit = get_texture_unit ();
557 glActiveTexture (GL_TEXTURE0 + unit);
558 glBindTexture (gltype, name);
559 glUniform1iARB (loc, unit);
560 }
561 }
562
563 void disable ()
564 {
565 if (unit >= 0)
566 {
567 put_texture_unit (unit);
568 unit = -1;
569 }
570 }
571
572 template<class bufferclass, class vectype>
573 void set (const gl::vertex_buffer &vb, const vectype bufferclass::*vp)
574 {
575 glTexCoordPointer (
576 vector_traits<vectype>::dimension (),
577 gl::type_traits<typename vector_traits<vectype>::basetype>::glenum (),
578 sizeof (bufferclass),
579 (GLvoid)(char bufferclass::*)vp
580 );
581 }
582
583 sampler_i (GLuint texture)
584 : uniform_i (strtype)
585 , name (texture)
586 #if DEBUG
587 , unit (-1)
588 #endif
589 {
590 }
591 };
592
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 };
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
657 struct shader_object_i : refcounted
658 {
659 GLenum type;
660 GLuint id; // GLhandleARB, but 2.0 will use uint
661
662 void compile (const string &source);
663
664 shader_object_i (GLenum type);
665 ~shader_object_i ();
666 };
667
668 template<GLenum type>
669 struct shader_object : ref<shader_object_i>
670 {
671 shader_object ()
672 : ref<shader_object_i> (*new shader_object_i (type))
673 {
674 }
675 };
676
677 typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader;
678 typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader;
679
680 struct program_object_i : refcounted
681 {
682 static struct program_object_i *cur; // currently bound program
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 ();
698 };
699
700 typedef auto_ref0<program_object_i> program_object;
701
702 template<int length>
703 struct sl_string
704 {
705 char str[length];
706
707 void operator ()() const
708 {
709 shader_builder::cur->code << str;
710 }
711 };
712
713 struct sl_float
714 {
715 const GLfloat c;
716
717 sl_float (GLfloat c) : c(c) { }
718
719 void operator ()() const
720 {
721 shader_builder::cur->code << c;
722 }
723 };
724
725 template<class A, class B>
726 inline sl_expr< sl_concat2<A, B> >
727 concat (const A &a, const B &b)
728 {
729 typedef sl_concat2<A, B> expr;
730 return sl_expr<expr> (expr (a, b));
731 }
732
733 template<class A, class B, class C>
734 inline sl_expr< sl_concat3<A, B, C> >
735 concat (const A &a, const B &b, const C &c)
736 {
737 typedef sl_concat3<A, B, C> expr;
738 return sl_expr<expr> (expr (a, b, c));
739 }
740
741 template<class A, class B, class C, class D>
742 inline sl_expr< sl_concat4<A, B, C, D> >
743 concat (const A &a, const B &b, const C &c, const D &d)
744 {
745 typedef sl_concat4<A, B, C, D> expr;
746 return sl_expr<expr> (expr (a, b, c, d));
747 }
748
749 template<typename expr>
750 struct sl_convert
751 {
752 typedef sl_expr<expr> T;
753 static inline const T &convert (const T &e)
754 {
755 return e;
756 }
757 };
758
759 template<>
760 struct sl_convert<GLfloat>
761 {
762 typedef sl_expr<sl_float> T;
763 static inline const T convert (GLfloat f)
764 {
765 return sl_float (f);
766 }
767 };
768
769 template<>
770 struct sl_convert<GLdouble>
771 {
772 typedef sl_expr<sl_float> T;
773 static inline const T convert (GLdouble d)
774 {
775 return sl_float (d);
776 }
777 };
778
779 template<>
780 struct sl_convert<GLint>
781 {
782 typedef sl_expr<sl_float> T;
783 static inline const T convert (GLint i)
784 {
785 return sl_float (i);
786 }
787 };
788
789 template<>
790 struct sl_convert<vec2>
791 {
792 static const sl_expr< sl_string<60> > convert (const vec2 &v);
793 };
794
795 template<>
796 struct sl_convert<vec3>
797 {
798 static const sl_expr< sl_string<80> > convert (const vec3 &v);
799 };
800
801 template<>
802 struct sl_convert<vec4>
803 {
804 static const sl_expr< sl_string<100> > convert (const vec4 &v);
805 };
806
807 template<>
808 template<class var_i>
809 struct sl_convert< var_ref<var_i> >
810 {
811 typedef sl_expr< var_i > T;
812 static inline const T convert (const var_ref<var_i> &v)
813 {
814 return T (*&v);
815 }
816 };
817
818 template<>
819 template<class gluvar_i>
820 struct sl_convert< auto_lvalue_ref1<gluvar_i, const char *> >
821 {
822 typedef sl_expr< gluvar_i > T;
823 static inline const T convert (const auto_lvalue_ref1<gluvar_i, const char *> &v)
824 {
825 return T (*&v);
826 }
827 };
828
829 template<>
830 template<const char *strtype, class var_i>
831 struct sl_convert< glnvar_ref<strtype, var_i> >
832 {
833 typedef sl_expr< var_i > T;
834 static inline const T convert (const glnvar_ref<strtype, var_i> &v)
835 {
836 return T (*&v);
837 }
838 };
839
840 template<>
841 template<class sampler_i>
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 };
850
851 template<class lvalue, typename expr>
852 inline void sl_assign (const lvalue &l, const expr &e)
853 {
854 shader_builder::cur->code << " ";
855 sl_convert<lvalue>::convert (l) ();
856 shader_builder::cur->code << " = ";
857 sl_convert<expr>::convert (e) ();
858 shader_builder::cur->code << ";\n";
859 }
860
861 template<class type>
862 template<typename expr>
863 inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const
864 {
865 sl_assign (*this, e);
866 return *this;
867 }
868
869 template<class type, typename arg1>
870 template<typename expr>
871 inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const
872 {
873 sl_assign (*this, e);
874 return *this;
875 }
876
877 template<class T>
878 template<typename expr>
879 inline const sl_expr<T> &sl_expr<T>::operator =(const expr &e) const
880 {
881 sl_assign (*this, e);
882 return *this;
883 }
884
885 template<const char *strtype, class var_i>
886 template<typename expr>
887 inline const glnvar_ref<strtype, var_i> &glnvar_ref<strtype, var_i>::operator =(const expr &e) const
888 {
889 sl_assign (*this, e);
890 return *this;
891 }
892
893 namespace compile {
894 using namespace shader;
895
896 template<typename T>
897 inline const sl_expr< sl_func1<typename sl_convert<T>::T> >
898 operator +(const T &t)
899 {
900 return sl_func1<typename sl_convert<T>::T> ("+(", sl_convert<T>::convert (t));
901 }
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) { }
915 void operator ()() const
916 {
917 shader_builder::cur->code << "(";
918 a ();
919 shader_builder::cur->code << b;
920 c ();
921 shader_builder::cur->code << ")";
922 }
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 }
940 };
941
942 # define SHADER_BINOP(op) \
943 template<typename A, typename B> \
944 inline const sl_expr< sl_binop< typename sl_convert<A>::T, \
945 typename sl_convert<B>::T > > \
946 operator op(const A &a, const B &b) \
947 { \
948 return sl_binop< typename sl_convert<A>::T, typename sl_convert<B>::T > \
949 (sl_convert<A>::convert (a), " " # op " ", sl_convert<B>::convert (b)); \
950 }
951
952 SHADER_BINOP (+);
953 SHADER_BINOP (-);
954 SHADER_BINOP (*);
955 SHADER_BINOP (/);
956 SHADER_BINOP (%);
957
958 SHADER_BINOP (<);
959 SHADER_BINOP (<=);
960 SHADER_BINOP (==);
961 SHADER_BINOP (!=);
962 SHADER_BINOP (>=);
963 SHADER_BINOP (>);
964
965 # undef SHADER_BINOP
966
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 };
980
981 # define SHADER_SWIZZLE_OP(type) \
982 template<typename T> \
983 inline const sl_expr< sl_swizzle<typename sl_convert<T>::T> > \
984 type (const T &t) \
985 { \
986 return sl_swizzle<typename sl_convert<T>::T> (sl_convert<T>::convert (t), #type); \
987 }
988
989 // brute force is lovely, ain't it?
990 SHADER_SWIZZLE_OP (x ) SHADER_SWIZZLE_OP (xx ) SHADER_SWIZZLE_OP (xxx ) SHADER_SWIZZLE_OP (xxxx)
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_
1232 }
1233
1234 #if 0
1235 template<typename A, typename B, typename C>
1236 inline const sl_expr< sl_ternary<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T> >
1237 ifelse (const A &a, const B &b, const C &c)
1238 {
1239 return sl_ternary<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T>
1240 (sl_convert<A>::convert (a), sl_convert<B>::convert (b), sl_convert<C>::convert (c));
1241 }
1242 #endif
1243
1244 }
1245
1246 #endif
1247
1248 #include "shader_vars.h"
1249
1250