ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libgender/shader.h
(Generate patch)

Comparing libgender/shader.h (file contents):
Revision 1.1 by root, Sat Oct 23 21:43:27 2004 UTC vs.
Revision 1.6 by root, Sat Oct 23 23:36:45 2004 UTC

… …
15 template<class T> 15 template<class T>
16 struct sl_expr { 16 struct sl_expr {
17 const T t; 17 const T t;
18 sl_expr (const T &t) : t(t) { } 18 sl_expr (const T &t) : t(t) { }
19 void operator ()() const { t (); } 19 void operator ()() const { t (); }
20 template<typename expr>
21 const sl_expr &operator =(const expr &e) const;
20 }; 22 };
21 23
22 template<class A, class B> 24 template<class A, class B>
23 struct sl_concat2 25 struct sl_concat2
24 { 26 {
… …
46 class refcounted 48 class refcounted
47 { 49 {
48 template<class type> friend class ref; 50 template<class type> friend class ref;
49 mutable int refcnt; 51 mutable int refcnt;
50 void refcnt_inc () const { refcnt++; } 52 void refcnt_inc () const { refcnt++; }
51 void refcnt_dec () const { if (!--refcnt) delete this; }; 53 void refcnt_dec () const;
52 public: 54 public:
53 refcounted () : refcnt(0) { } 55 refcounted () : refcnt(0) { }
54 virtual ~refcounted (); 56 virtual ~refcounted ();
55 }; 57 };
56 58
… …
274 276
275 struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { }; 277 struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { };
276 struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { }; 278 struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { };
277 struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { }; 279 struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { };
278 280
279 template<class uniform_i> 281 template<class var_i>
280 struct uniform_ref : ref<uniform_i> 282 struct var_ref : ref<var_i>
281 { 283 {
282 uniform_ref (const char *glname = 0) 284 var_ref (const char *glname = 0)
283 : ref<uniform_i> (*new uniform_i) 285 : ref<var_i> (*new var_i)
284 { 286 {
285 if (glname) 287 if (glname)
286 strcpy ((*this)->name, glname); 288 strcpy ((*this)->name, glname);
287 } 289 }
288 }; 290 };
289 291
290 typedef uniform_ref<uniform_1f_i> uniform_1f; 292 typedef var_ref<uniform_1f_i> uniform_1f;
291 typedef uniform_ref<uniform_2f_i> uniform_2f; 293 typedef var_ref<uniform_2f_i> uniform_2f;
292 typedef uniform_ref<uniform_3f_i> uniform_3f; 294 typedef var_ref<uniform_3f_i> uniform_3f;
293 typedef uniform_ref<uniform_4f_i> uniform_4f; 295 typedef var_ref<uniform_4f_i> uniform_4f;
294 typedef uniform_ref<uniform_matrix_2f_i> uniform_matrix_2f; 296 typedef var_ref<uniform_matrix_2f_i> uniform_matrix_2f;
295 typedef uniform_ref<uniform_matrix_3f_i> uniform_matrix_3f; 297 typedef var_ref<uniform_matrix_3f_i> uniform_matrix_3f;
296 typedef uniform_ref<uniform_matrix_4f_i> uniform_matrix_4f; 298 typedef var_ref<uniform_matrix_4f_i> uniform_matrix_4f;
297 299
298 struct stream_i : var_i 300 struct stream_i : var_i
299 { 301 {
300 void build (shader_builder &b); 302 void build (shader_builder &b);
301 void build_decl (ostringstream &b); 303 void build_decl (ostringstream &b);
302 stream_i (const char *strtype) : var_i (strtype) { } 304 stream_i (const char *strtype);
303 }; 305 };
304 306
305 template<int dimension, GLenum gltype, const char *strtype> 307 template<int dimension, GLenum gltype, const char *strtype>
306 struct varying_i : stream_i 308 struct varying_i : stream_i
307 { 309 {
308 varying_i (const char *glname) 310 varying_i () : stream_i (strtype) { }
309 : stream_i (strtype)
310 {
311 strcpy (name, glname);
312 }
313 311
314 void set (GLsizei stride, GLvoid *ptr) 312 void set (GLsizei stride, GLvoid *ptr)
315 { 313 {
316 //cgGLSetParameterPointer (param, dimension, gltype, stride, ptr); 314 //cgGLSetParameterPointer (param, dimension, gltype, stride, ptr);
317 } 315 }
318 }; 316 };
319 317
320 template<int dimension, const char *strtype> 318 template<int dimension, const char *strtype>
321 struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype> 319 struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype>
322 { 320 {
323 varying_f_i (const char *glname) : varying_i<dimension, GL_FLOAT, strtype> (glname) { }
324
325 void set (const gl::vertex_buffer_object &vb, GLint offset) 321 void set (const gl::vertex_buffer_object &vb, GLint offset)
326 { 322 {
327 varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset); 323 varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset);
328 } 324 }
329 }; 325 };
330 326
331 struct varying_1f_i : varying_f_i<1, str_float> 327 struct varying_1f_i : varying_f_i<1, str_float>
332 { 328 {
333 varying_1f_i (const char *glname) : varying_f_i<1, str_float> (glname) { }
334 }; 329 };
335 330
336 struct varying_2f_i : varying_f_i<2, str_vec2> 331 struct varying_2f_i : varying_f_i<2, str_vec2>
337 { 332 {
338 varying_2f_i (const char *glname) : varying_f_i<2, str_vec2> (glname) { }
339
340 void set_t (const gl::vertex_buffer_object &vb) 333 void set_t (const gl::vertex_buffer_object &vb)
341 { 334 {
342 set (vb, gl::format_offset_t (vb.format)); 335 set (vb, gl::format_offset_t (vb.format));
343 } 336 }
344 }; 337 };
345 338
346 struct varying_3f_i : varying_f_i<3, str_vec3> 339 struct varying_3f_i : varying_f_i<3, str_vec3>
347 { 340 {
348 varying_3f_i (const char *glname) : varying_f_i<3, str_vec3> (glname) { }
349
350 void set_p (const gl::vertex_buffer_object &vb) 341 void set_p (const gl::vertex_buffer_object &vb)
351 { 342 {
352 set (vb, gl::format_offset_p (vb.format)); 343 set (vb, gl::format_offset_p (vb.format));
353 } 344 }
354 345
… …
358 } 349 }
359 }; 350 };
360 351
361 struct varying_4f_i : varying_f_i<4, str_vec4> 352 struct varying_4f_i : varying_f_i<4, str_vec4>
362 { 353 {
363 varying_4f_i (const char *glname) : varying_f_i<4, str_vec4> (glname) { }
364 }; 354 };
365 355
366 typedef auto_lvalue_ref1<varying_1f_i, const char *> varying_1f; 356 typedef var_ref<varying_1f_i> varying_1f;
367 typedef auto_lvalue_ref1<varying_2f_i, const char *> varying_2f; 357 typedef var_ref<varying_2f_i> varying_2f;
368 typedef auto_lvalue_ref1<varying_3f_i, const char *> varying_3f; 358 typedef var_ref<varying_3f_i> varying_3f;
369 typedef auto_lvalue_ref1<varying_4f_i, const char *> varying_4f; 359 typedef var_ref<varying_4f_i> varying_4f;
370 360
371 struct temporary_i : var_i 361 struct temporary_i : var_i
372 { 362 {
373 void build (shader_builder &b); 363 void build (shader_builder &b);
374 364
… …
501 void append (const ref<fragment_i> &f) 491 void append (const ref<fragment_i> &f)
502 { 492 {
503 push_back (f); 493 push_back (f);
504 } 494 }
505 495
496 template<class expr>
497 void append (const sl_expr<expr> &e)
498 {
499 e ();
500 }
501
506 void append_const (const char *s) 502 void append_const (const char *s)
507 { 503 {
508 push_back (*new fragment_const_string_i (s)); 504 push_back (*new fragment_const_string_i (s));
509 } 505 }
510 506
… …
555 }; 551 };
556 552
557 typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader; 553 typedef shader_object<GL_VERTEX_SHADER_ARB> vertex_shader;
558 typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader; 554 typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader;
559 555
556 template<typename T>
557 struct sl_append
558 {
559 T t;
560
561 sl_append (const T &t) : t(t) { }
562
563 void operator ()() const
564 {
565 cur->push_back (t);
566 }
567 };
568
569 template<int length>
570 struct sl_string
571 {
572 char str[length];
573
574 void operator ()() const
575 {
576 cur->push_back (*new fragment_string_i (str));
577 }
578 };
579
580 struct sl_float
581 {
582 const GLfloat c;
583
584 sl_float (GLfloat c) : c(c) { }
585
586 void operator ()() const;
587 };
588
589 template<class A, class B>
590 inline sl_expr< sl_concat2<A, B> >
591 concat (const A &a, const B &b)
592 {
593 typedef sl_concat2<A, B> expr;
594 return sl_expr<expr> (expr (a, b));
595 }
596
597 template<class A, class B, class C>
598 inline sl_expr< sl_concat3<A, B, C> >
599 concat (const A &a, const B &b, const C &c)
600 {
601 typedef sl_concat3<A, B, C> expr;
602 return sl_expr<expr> (expr (a, b, c));
603 }
604
605 template<class A, class B, class C, class D>
606 inline sl_expr< sl_concat4<A, B, C, D> >
607 concat (const A &a, const B &b, const C &c, const D &d)
608 {
609 typedef sl_concat4<A, B, C, D> expr;
610 return sl_expr<expr> (expr (a, b, c, d));
611 }
612
613 template<typename expr>
614 struct sl_convert
615 {
616 typedef sl_expr<expr> T;
617 static inline const T &convert (const T &e)
618 {
619 return e;
620 }
621 };
622
623 template<>
624 struct sl_convert<GLfloat>
625 {
626 typedef sl_expr<sl_float> T;
627 static inline const T convert (GLfloat f)
628 {
629 return sl_float (f);
630 }
631 };
632
633 template<>
634 struct sl_convert<GLdouble>
635 {
636 typedef sl_expr<sl_float> T;
637 static inline const T convert (GLdouble d)
638 {
639 return sl_float (d);
640 }
641 };
642
643 template<>
644 struct sl_convert<GLint>
645 {
646 typedef sl_expr<sl_float> T;
647 static inline const T convert (GLint i)
648 {
649 return sl_float (i);
650 }
651 };
652
653 template<>
654 struct sl_convert<vec2>
655 {
656 typedef sl_expr< sl_string<60> > T;
657 static const T convert (const vec2 &v);
658 };
659
660 template<>
661 struct sl_convert<vec3>
662 {
663 typedef sl_expr< sl_string<80> > T;
664 static const T convert (const vec3 &v);
665 };
666
667 template<>
668 struct sl_convert<vec4>
669 {
670 typedef sl_expr< sl_string<100> > T;
671 static const T convert (const vec4 &v);
672 };
673
674 template<>
675 template<class V>
676 struct sl_convert< var_ref<V> >
677 {
678 typedef sl_expr< sl_append< var_ref<V> > > T;
679 static inline const T convert (const var_ref<V> &v)
680 {
681 return sl_append< var_ref<V> > (v);
682 }
683 };
684
685 template<>
686 struct sl_convert<glvar>
687 {
688 typedef sl_expr< sl_append<glvar> > T;
689 static inline const T convert (const glvar &v)
690 {
691 return sl_append<glvar> (v);
692 }
693 };
694
695 template<>
696 template<const char *strtype>
697 struct sl_convert< temp_ref<strtype> >
698 {
699 typedef sl_expr< sl_append< temp_ref<strtype> > > T;
700 static inline const T convert (const temp_ref<strtype> &v)
701 {
702 return sl_expr< sl_append< temp_ref<strtype> > >(
703 sl_append< temp_ref<strtype> > (v)
704 );
705 }
706 };
707
708 extern const fragment_const_string str_2sp;
709 extern const fragment_const_string str_equal;
710 extern const fragment_const_string str_endl;
711
712 template<class fragment, typename expr>
713 inline void sl_assign (const fragment &f, const expr &e)
714 {
715 cur->append (str_2sp);
716 cur->append (f);
717 cur->append (str_equal);
718 sl_convert<expr>::convert (e) ();
719 cur->append (str_endl);
720 }
721
722 template<class type>
723 template<typename expr>
724 inline const auto_lvalue_ref0<type> &auto_lvalue_ref0<type>::operator =(const expr &e) const
725 {
726 sl_assign (*this, e);
727 return *this;
728 }
729
730 template<class type, typename arg1>
731 template<typename expr>
732 inline const auto_lvalue_ref1<type,arg1> &auto_lvalue_ref1<type,arg1>::operator =(const expr &e) const
733 {
734 sl_assign (*this, e);
735 return *this;
736 }
737
738 template<class T>
739 template<typename expr>
740 inline const sl_expr<T> &sl_expr<T>::operator =(const expr &e) const
741 {
742 sl_assign (*this, e);
743 return *this;
744 }
745
746 template<const char *strtype>
747 template<typename expr>
748 inline const temp_ref<strtype> &temp_ref<strtype>::operator =(const expr &e) const
749 {
750 sl_assign (*this, e);
751 return *this;
752 }
753
754 struct sl_append_const_string
755 {
756 fragment_const_string str;
757 sl_append_const_string (const char *s)
758 : str (s)
759 { }
760
761 void operator ()() const
762 {
763 cur->push_back (str);
764 }
765 };
766
767# define SHADER_BINOP(op, str) \
768 extern const sl_append_const_string str_ ## str; \
769 template<typename A, typename B> \
770 inline const sl_expr< sl_concat3< typename sl_convert<A>::T, \
771 sl_append_const_string, \
772 typename sl_convert<B>::T > > \
773 operator op(const A &a, const B &b) \
774 { \
775 return concat (sl_convert<A>::convert (a), str_ ## str, sl_convert<B>::convert (b)); \
776 }
777
778 SHADER_BINOP (+, plus);
779 SHADER_BINOP (-, minus);
780 SHADER_BINOP (*, mul);
781 SHADER_BINOP (/, div);
782
783# undef SHADER_BINOP
784
785 void swizzle_mask (sl_string<7> &s, int mask);
786
787 extern const sl_append_const_string str_lpar;
788 extern const sl_append_const_string str_rpar;
789
790 template<typename T>
791 inline const sl_expr< sl_concat3< sl_append_const_string,
792 typename sl_convert<T>::T,
793 sl_string<7>
794 > >
795 swizzle (const T &t, int a, int b = 0, int c = 0, int d = 0)
796 {
797 sl_string<7> s;
798 swizzle_mask (s, ((d * 5 + c) * 5 + b) * 5 + a);
799 return concat (str_lpar, sl_convert<T>::convert (t), s);
800 }
801
802# define SHADER_SWIZZLE_OP(abcd,type) \
803 template<typename T> \
804 inline const sl_expr< sl_concat3< sl_append_const_string, \
805 typename sl_convert<T>::T, \
806 sl_string<7> \
807 > > \
808 type (const T &t) \
809 { \
810 return swizzle (t, (abcd / 1000) % 5, (abcd / 100) % 5, (abcd / 10) % 5, (abcd / 1) % 5); \
811 }
812
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
560 void debdebdebdebug ();//D 902 void debdebdebdebug ();//D
561} 903}
562 904
563#endif 905#endif
564 906

Diff Legend

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