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

Comparing libgender/shader.h (file contents):
Revision 1.26 by root, Wed Nov 3 01:12:34 2004 UTC vs.
Revision 1.27 by root, Wed Nov 3 01:37:23 2004 UTC

… …
14 14
15 using namespace std; 15 using namespace std;
16 16
17 const int NAMELEN = 32; 17 const int NAMELEN = 32;
18 18
19 namespace compile {
20 struct shader_builder 19 struct shader_builder
21 { 20 {
21 static struct shader_builder *cur;
22
22 set<const void *> seen; 23 set<const void *> seen;
23 24
24 ostringstream global; 25 ostringstream global;
25 ostringstream local; 26 ostringstream local;
26 ostringstream code; 27 ostringstream code;
27 28
28 bool first (const void *p); 29 bool first (const void *p);
29 };
30 30
31 extern shader_builder *cur; 31 static void start ();
32 static string stop ();
32 } 33 };
33 34
34 template<class T> 35 template<class T>
35 struct sl_expr { 36 struct sl_expr {
36 const T &t; 37 const T &t;
37 sl_expr (const T &t) : t(t) { } 38 sl_expr (const T &t) : t(t) { }
… …
69 const char *name_par; 70 const char *name_par;
70 sl_func0 (const char *name_par) : name_par(name_par) { } 71 sl_func0 (const char *name_par) : name_par(name_par) { }
71 72
72 void begin () const 73 void begin () const
73 { 74 {
74 compile::cur->code << name_par; 75 shader_builder::cur->code << name_par;
75 } 76 }
76 77
77 void comma () const 78 void comma () const
78 { 79 {
79 compile::cur->code << ", "; 80 shader_builder::cur->code << ", ";
80 } 81 }
81 82
82 void end () const 83 void end () const
83 { 84 {
84 compile::cur->code << ")"; 85 shader_builder::cur->code << ")";
85 } 86 }
86 87
87 void operator ()() const 88 void operator ()() const
88 { 89 {
89 begin (); 90 begin ();
… …
254 { 255 {
255 const char *name; 256 const char *name;
256 257
257 void operator ()() const 258 void operator ()() const
258 { 259 {
259 compile::cur->code << name; 260 shader_builder::cur->code << name;
260 } 261 }
261 262
262 gluvar_i (const char *name) : name (name) { } 263 gluvar_i (const char *name) : name (name) { }
263 }; 264 };
264 265
… …
656 struct shader_object_i : refcounted 657 struct shader_object_i : refcounted
657 { 658 {
658 GLenum type; 659 GLenum type;
659 GLuint id; // GLhandleARB, but 2.0 will use uint 660 GLuint id; // GLhandleARB, but 2.0 will use uint
660 661
661 void start (); 662 void compile (const string &source);
662 void stop ();
663 663
664 shader_object_i (GLenum type); 664 shader_object_i (GLenum type);
665 ~shader_object_i (); 665 ~shader_object_i ();
666 }; 666 };
667 667
… …
704 { 704 {
705 char str[length]; 705 char str[length];
706 706
707 void operator ()() const 707 void operator ()() const
708 { 708 {
709 compile::cur->code << str; 709 shader_builder::cur->code << str;
710 } 710 }
711 }; 711 };
712 712
713 struct sl_float 713 struct sl_float
714 { 714 {
… …
716 716
717 sl_float (GLfloat c) : c(c) { } 717 sl_float (GLfloat c) : c(c) { }
718 718
719 void operator ()() const 719 void operator ()() const
720 { 720 {
721 compile::cur->code << c; 721 shader_builder::cur->code << c;
722 } 722 }
723 }; 723 };
724 724
725 template<class A, class B> 725 template<class A, class B>
726 inline sl_expr< sl_concat2<A, B> > 726 inline sl_expr< sl_concat2<A, B> >
… …
849 }; 849 };
850 850
851 template<class lvalue, typename expr> 851 template<class lvalue, typename expr>
852 inline void sl_assign (const lvalue &l, const expr &e) 852 inline void sl_assign (const lvalue &l, const expr &e)
853 { 853 {
854 compile::cur->code << " "; 854 shader_builder::cur->code << " ";
855 sl_convert<lvalue>::convert (l) (); 855 sl_convert<lvalue>::convert (l) ();
856 compile::cur->code << " = "; 856 shader_builder::cur->code << " = ";
857 sl_convert<expr>::convert (e) (); 857 sl_convert<expr>::convert (e) ();
858 compile::cur->code << ";\n"; 858 shader_builder::cur->code << ";\n";
859 } 859 }
860 860
861 template<class type> 861 template<class type>
862 template<typename expr> 862 template<typename expr>
863 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
… …
884 884
885 template<const char *strtype, class var_i> 885 template<const char *strtype, class var_i>
886 template<typename expr> 886 template<typename expr>
887 inline const glnvar_ref<strtype, var_i> &glnvar_ref<strtype, var_i>::operator =(const expr &e) const 887 inline const glnvar_ref<strtype, var_i> &glnvar_ref<strtype, var_i>::operator =(const expr &e) const
888 { 888 {
889 compile::sl_assign (*this, e); 889 sl_assign (*this, e);
890 return *this; 890 return *this;
891 } 891 }
892 892
893 namespace compile { 893 namespace compile {
894 using namespace shader; 894 using namespace shader;
… …
912 { 912 {
913 const A a; const char *b; const C c; 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) { } 914 sl_binop (const A &a, const char *b, const C &c) : a(a), b(b), c(c) { }
915 void operator ()() const 915 void operator ()() const
916 { 916 {
917 compile::cur->code << "("; 917 shader_builder::cur->code << "(";
918 a (); 918 a ();
919 compile::cur->code << b; 919 shader_builder::cur->code << b;
920 c (); 920 c ();
921 compile::cur->code << ")"; 921 shader_builder::cur->code << ")";
922 } 922 }
923 }; 923 };
924 924
925 template<class A, class B, class C> 925 template<class A, class B, class C>
926 struct sl_ternary 926 struct sl_ternary
927 { 927 {
928 const A a; const B b; const C c; 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) { } 929 sl_ternary (const A &a, const B &b, const C &c) : a(a), b(b), c(c) { }
930 void operator ()() const 930 void operator ()() const
931 { 931 {
932 compile::cur->code << "("; 932 shader_builder::cur->code << "(";
933 a (); 933 a ();
934 compile::cur->code << ") ? ("; 934 shader_builder::cur->code << ") ? (";
935 b (); 935 b ();
936 compile::cur->code << ") : ("; 936 shader_builder::cur->code << ") : (";
937 c (); 937 c ();
938 compile::cur->code << ")"; 938 shader_builder::cur->code << ")";
939 } 939 }
940 }; 940 };
941 941
942# define SHADER_BINOP(op) \ 942# define SHADER_BINOP(op) \
943 template<typename A, typename B> \ 943 template<typename A, typename B> \
… …
970 const A a; 970 const A a;
971 const char *swizzle; 971 const char *swizzle;
972 sl_swizzle (const A &a, const char *swizzle) : a(a), swizzle(swizzle) { } 972 sl_swizzle (const A &a, const char *swizzle) : a(a), swizzle(swizzle) { }
973 void operator ()() const 973 void operator ()() const
974 { 974 {
975 compile::cur->code << "("; 975 shader_builder::cur->code << "(";
976 a (); 976 a ();
977 compile::cur->code << ")." << swizzle; 977 shader_builder::cur->code << ")." << swizzle;
978 } 978 }
979 }; 979 };
980 980
981# define SHADER_SWIZZLE_OP(type) \ 981# define SHADER_SWIZZLE_OP(type) \
982 template<typename T> \ 982 template<typename T> \
… …
1239 return sl_ternary<typename sl_convert<A>::T, typename sl_convert<B>::T, typename sl_convert<C>::T> 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)); 1240 (sl_convert<A>::convert (a), sl_convert<B>::convert (b), sl_convert<C>::convert (c));
1241 } 1241 }
1242#endif 1242#endif
1243 1243
1244 void debdebdebdebug ();//D
1245} 1244}
1246 1245
1247#endif 1246#endif
1248 1247
1249#include "shader_vars.h" 1248#include "shader_vars.h"

Diff Legend

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