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

Comparing libgender/shader.C (file contents):
Revision 1.11 by root, Sun Oct 24 01:55:00 2004 UTC vs.
Revision 1.26 by root, Tue Nov 2 02:59:33 2004 UTC

1#include <cassert>
2
1#include "shader.h" 3#include "shader.h"
2#include "shader_vars.h" 4#include "shader_vars.h"
3 5
6#include <sstream>
7#include <iomanip>
8
4namespace shader { 9namespace shader {
5 10
11 using namespace std;
12
6 refcounted::~refcounted () 13 refcounted::~refcounted ()
7 { 14 {
8#if 1
9 if (refcnt) 15 if (refcnt)
10 abort (); 16 abort ();
11#endif
12 } 17 }
13 18
14 void refcounted::refcnt_dec () const 19 void refcounted::refcnt_destroy () const
15 { 20 {
16 if (!--refcnt) 21 if (!--refcnt)
17 delete this; // quite a bit of code... 22 delete this; // quite a bit of code...
18 } 23 }
19 24
… …
35 const char str_sampler_3d_rect [] = "sampler3DRect"; 40 const char str_sampler_3d_rect [] = "sampler3DRect";
36 const char str_sampler_cube [] = "samplerCube"; 41 const char str_sampler_cube [] = "samplerCube";
37 42
38 unsigned int var_i::next_id = 0; 43 unsigned int var_i::next_id = 0;
39 44
40 var_i::var_i (const char *typestr) 45 var_i::var_i (const char *domainstr, const char *typestr)
41 : typestr (typestr) 46 : domainstr (domainstr), typestr (typestr)
42 { 47 {
43 //param = cgCreateParameter (cg_context, cgtype);
44 } 48 }
45 49
46 var_i::~var_i () 50 var_i::~var_i ()
47 { 51 {
48 //cgDestroyParameter (param);
49 } 52 }
50 53
54#if 0
51 stream_i::stream_i (const char *strtype) 55 stream_i::stream_i (const char *strtype)
52 : var_i (strtype) 56 : var_i (strtype)
53 { 57 {
54 sprintf (name, "V%lx_%d", ((long)this >> 4) & 0xfff, ++next_id); 58 sprintf (name, "V%d", ++next_id);
55 } 59 }
60#endif
56 61
57 temporary_i::temporary_i (const char *strtype) 62 temporary_i::temporary_i (const char *strtype)
58 : var_i (strtype) 63 : var_i (0, strtype)
59 { 64 {
60 sprintf (name, "T%lx_%d", ((long)this >> 4) & 0xfff, ++next_id); 65 sprintf (name, "T%d", ++next_id);
66 }
67
68 varying_i::varying_i (const char *strtype)
69 : var_i ("varying", strtype)
70 {
71 sprintf (name, "V%d", ++next_id);
61 } 72 }
62 73
63 uniform_i::uniform_i (const char *strtype) 74 uniform_i::uniform_i (const char *strtype)
64 : var_i (strtype), dirty (true) 75 : var_i ("uniform", strtype)
65 { 76 {
66 sprintf (name, "U%lx_%d", ((long)this >> 4) & 0xfff, ++next_id); 77 sprintf (name, "U%d", ++next_id);
67 }
68
69 fragment_string_i::~fragment_string_i ()
70 {
71 free (str);
72 } 78 }
73 79
74 //////////////////////////////////////////////////////////////////////////// 80 ////////////////////////////////////////////////////////////////////////////
75 81
76 void var_i::build_decl (ostringstream &b) 82 void var_i::operator ()() const
77 { 83 {
78 b << typestr << ' ' << name; 84 compile::cur->code << name;
79 }
80 85
81 void uniform_i::build_decl (ostringstream &b) 86 if (compile::cur->first (this))
82 { 87 {
83 b << "uniform " << typestr << ' ' << name; 88 if (domainstr)
84 } 89 compile::cur->global << domainstr << ' ' << typestr << ' ' << name << ";\n";
85 90 else
86 void stream_i::build_decl (ostringstream &b) 91 compile::cur->local << " " << typestr << ' ' << name << ";\n";
87 { 92 }
88 b << typestr << ' ' << name;
89 } 93 }
90 94
91 //////////////////////////////////////////////////////////////////////////// 95 ////////////////////////////////////////////////////////////////////////////
92 96
93 void glvar_i::build (shader_builder &b) 97 int texture_units::unit_count = 8;
94 { 98 int texture_units::units[8] = { 7, 6, 5, 4, 3, 2, 1, 0 };
95 b << name;
96 }
97
98 void var_i::build (shader_builder &b)
99 {
100 b << name;
101 }
102
103 void uniform_i::build (shader_builder &b)
104 {
105 var_i::build (b);
106
107 if (find (b.refs.begin (), b.refs.end (), uniform (*this)) == b.refs.end ())
108 b.refs.push_back (*this);
109 }
110
111 void stream_i::build (shader_builder &b)
112 {
113 var_i::build (b);
114
115 if (find (b.streams.begin (), b.streams.end (), var (*this)) == b.streams.end ())
116 b.streams.push_back (*this);
117 }
118
119 void temporary_i::build (shader_builder &b)
120 {
121 var_i::build (b);
122
123 if (find (b.temps.begin (), b.temps.end (), var (*this)) == b.temps.end ())
124 b.temps.push_back (*this);
125 }
126
127 void fragment_vector_i::build (shader_builder &b)
128 {
129 for (vector<fragment>::iterator i = begin (); i != end (); i++)
130 (*i)->build (b);
131 }
132
133 void fragment_const_string_i::build (shader_builder &b)
134 {
135 b << str;
136 }
137
138 void fragment_string_i::build (shader_builder &b)
139 {
140 b << str;
141 }
142
143#if 0
144 void statement_i::build (shader_builder &b)
145 {
146 b << " ";
147 fragment_vector_i::build (b);
148 b << ";\n";
149 }
150#endif
151
152 ////////////////////////////////////////////////////////////////////////////
153 99
154 shader_object_i *cur = 0; 100 shader_object_i *cur = 0;
155 101
156 shader_object_i::shader_object_i (GLenum type) 102 shader_object_i::shader_object_i (GLenum type)
157 : type (type) 103 : type (type)
158 { 104 {
159 id = glCreateShaderObjectARB (type); 105 id = glCreateShaderObjectARB (type);
106 assert (id);
160 } 107 }
161 108
162 shader_object_i::~shader_object_i () 109 shader_object_i::~shader_object_i ()
163 { 110 {
164 glDeleteObjectARB (id); 111 glDeleteObjectARB (id);
165 } 112 }
166 113
114 static string linify (const string &s)
115 {
116 ostringstream o;
117
118 int b = 0, e;
119 int l = 1;
120 do {
121 o << setw (3) << l << ": ";
122 e = s.find ('\n', b);
123 if (e == string::npos)
124 e = s.size ();
125
126 o << s.substr (b, e - b + 1);
127 b = e + 1;
128 l++;
129 } while (b < s.size ());
130
131 return o.str ();
132 }
133
167 void shader_object_i::start () 134 void shader_object_i::start ()
168 { 135 {
169 clear (); 136 compile::cur = new compile::shader_builder;
170 cur = this;
171 } 137 }
172 138
173 void shader_object_i::stop () 139 void shader_object_i::stop ()
174 { 140 {
141 compile::shader_builder &b = *compile::cur;
142
143 ostringstream os;
144
145 os << b.global.str ()
146 << "\nvoid main (void)\n"
147 << "{\n"
148 << b.local.str ()
149 << "\n"
150 << b.code.str ()
151 << "}\n";
152
153 delete cur;
175 cur = 0; 154 cur = 0;
176 }
177 155
178 string shader_object_i::source ()
179 {
180 shader_builder b;
181 build (b);
182 ostringstream os;
183
184 for (vector<uniform>::iterator i = b.refs.begin (); i != b.refs.end (); i++)
185 {
186 (*i)->build_decl (os);
187 os << ";\n";
188 }
189
190 // not neccessary right now, as GLSL is rich on predefinitions
191 for (vector<var>::iterator i = b.streams.begin (); i != b.streams.end (); i++)
192 {
193 os << "attribute ";
194 (*i)->build_decl (os);
195 os << ";\n";
196 }
197
198 os << "\nvoid main (void)\n{\n";
199
200 for (vector<var>::iterator i = b.temps.begin (); i != b.temps.end (); i++)
201 {
202 os << " ";
203 (*i)->build_decl (os);
204 os << ";\n";
205 }
206
207 os << "\n";
208 os << b.source.str ();
209 os << "}\n";
210
211 return os.str ();
212 }
213
214 void shader_object_i::compile ()
215 {
216 string src = source (); 156 string src = os.str ();
217 const char *sptr = src.data (); 157 const char *sptr = src.data ();
218 const int slen = src.size (); 158 const int slen = src.size ();
219 159
220 printf ("SOURCE<%s>\n", src.c_str ()); 160 printf ("%s\n", linify (src).c_str ());
221 glShaderSourceARB (id, 1, &sptr, &slen); 161 glShaderSourceARB (id, 1, &sptr, &slen);
222 glCompileShaderARB (id); 162 glCompileShaderARB (id);
223 163
224 GLint compiled; 164 GLint compiled;
225 glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled); 165 glGetObjectParameterivARB (id, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
226 166
227 if (!compiled) 167 if (!compiled)
228 { 168 {
229 char infolog[8192]; 169 char infolog[8192];
230 glGetInfoLogARB (id, 8192, NULL, infolog); 170 glGetInfoLogARB (id, 8192, NULL, infolog);
231 printf ("SOURCE<%s>\n", src.c_str ()); 171 printf ("%s\n", linify (src).c_str ());
232 printf ("INFOLOG<%s>\n", infolog); 172 printf ("%s\n", infolog);
233 abort (); 173 abort ();
234 } 174 }
235 } 175 }
236 176
237 void sl_func0::begin () const 177 ////////////////////////////////////////////////////////////////////////////
238 { 178
239 cur->append_string (name_par); 179 program_object *program_object::cur = 0;
240 }
241 180
242 void sl_func0::comma () const 181 GLint uniform_i::location ()
243 { 182 {
244 cur->append (str_comma); 183 assert (program_object::cur);
245 }
246 184
247 void sl_func0::end () const 185 GLint &rid = program_object::cur->uloc[this];
248 {
249 str_rpar ();
250 }
251 186
252 void sl_float::operator ()() const 187 if (!rid)
253 { 188 rid = glGetUniformLocationARB (program_object::cur->id, name);
254 char s[20];
255 sprintf (s, "%g", c);
256 cur->append_string (s);
257 }
258 189
259 const sl_convert< ::vec2 >::T sl_convert< ::vec2 >::convert (const ::vec2 &v) 190 return rid;
191 }
192
193 program_object::program_object ()
194 {
195 id = glCreateProgramObjectARB ();
196 assert (id);
197
198 glAttachObjectARB (id, vsh->id);
199 glAttachObjectARB (id, fsh->id);
200 }
201
202 program_object::~program_object ()
203 {
204 glDeleteProgramsARB (1, &id);
205 }
206
207 void program_object::link ()
208 {
209 glLinkProgramARB (id);
210
211 GLint linked;
212 glGetObjectParameterivARB (id, GL_OBJECT_LINK_STATUS_ARB, &linked);
213
214 if (!linked)
215 {
216 char infolog[8192];
217 glGetInfoLogARB (id, 8192, NULL, infolog);
218 printf ("LINK-INFOLOG<%s>\n", infolog);
219 abort ();
220 }
221
222 uloc.clear ();
223 }
224
225 void program_object::enable ()
226 {
227 glUseProgramObjectARB (id);
228 //TODO: set samplers here
229 cur = this;
230 }
231
232 void program_object::disable ()
233 {
234 //TODO: clear samplers here
235 glUseProgramObjectARB (0);
236 cur = 0;
237 }
238
239 const sl_expr< sl_string<60> > sl_convert< ::vec2 >::convert (const ::vec2 &v)
260 { 240 {
261 sl_string<60> s; 241 sl_string<60> s;
262 sprintf (s.str, "vec2 (%g, %g)", v.x, v.y); 242 sprintf (s.str, "vec2 (%g, %g)", v.x, v.y);
263 return s; 243 return s;
264 } 244 }
265 245
266 const sl_convert< ::vec3 >::T sl_convert< ::vec3 >::convert (const ::vec3 &v) 246 const sl_expr< sl_string<80> > sl_convert< ::vec3 >::convert (const ::vec3 &v)
267 { 247 {
268 sl_string<80> s; 248 sl_string<80> s;
269 sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z); 249 sprintf (s.str, "vec3 (%g, %g, %g)", v.x, v.y, v.z);
270 return s; 250 return s;
271 } 251 }
272 252
273 const sl_convert< ::vec4 >::T sl_convert< ::vec4 >::convert (const ::vec4 &v) 253 const sl_expr< sl_string<100> > sl_convert< ::vec4 >::convert (const ::vec4 &v)
274 { 254 {
275 sl_string<100> s; 255 sl_string<100> s;
276 sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w); 256 sprintf (s.str, "vec4 (%g, %g, %g, %g)", v.x, v.y, v.z, v.w);
277 return s; 257 return s;
278 } 258 }
279 259
280 const fragment_const_string str_2sp (" "); 260 namespace compile {
281 const fragment_const_string str_equal (" = ");
282 const fragment_const_string str_comma (", ");
283 const fragment_const_string str_endl (";\n");
284 261
285 const sl_append_const_string str_plus (" + "); 262 shader_builder *cur = 0;
286 const sl_append_const_string str_minus (" - ");
287 const sl_append_const_string str_mul (" * ");
288 const sl_append_const_string str_div (" / ");
289 const sl_append_const_string str_mod (" % ");
290 263
291 const sl_append_const_string str_lpar ("("); 264 bool shader_builder::first (const void *p)
292 const sl_append_const_string str_rpar (")");
293
294 void swizzle_mask (sl_string<7> &s, int mask)
295 { 265 {
296 static const char channel[4] = { 'x', 'y', 'z', 'w' }; 266 if (seen.find (p) == seen.end ())
297
298 char *str = s.str;
299
300 *str++ = ')';
301 *str++ = '.';
302
303 while (mask)
304 { 267 {
305 int c = mask % 5; 268 seen.insert (p);
306 mask /= 5; 269 return true;
307
308 if (c)
309 *str++ = channel[c - 1];
310 } 270 }
311 271
312 *str++ = 0; 272 return false;
313 } 273 }
314 274 }
315 275
316 void debdebdebdebug ()//D 276 void debdebdebdebug ()//D
317 { 277 {
278 return;
279
280 using namespace compile;
281
318 vertex_shader vsh; 282 vertex_shader vsh;
319 283
320 vsh->start (); 284 vsh->start ();
321 285
322 temp_4f lightpos; 286 temp_4f lightpos;
323 temp_3f wpos; 287 temp_4f wpos;
324 288
325 lightpos = vec4 (10, -10, 0, 1); 289 lightpos = vec4 (0, 10, 0, 1);
326 wpos = xyz (gl.model_view_matrix * vin.vertex); 290 wpos = model_view_matrix * vin.vertex;
327 vout.position = gl.model_view_matrix_inverse_transpose * vin.vertex; 291 vout.position = vin.vertex * model_view_matrix_inverse;
328 vout.tex_coord[0] = vin.tex_coord[0]; 292 vout.tex_coord[0] = vin.tex_coord[0];
329 vout.tex_coord[1] = normalize (lightpos - wpos); 293 vout.tex_coord[1] = normalize (lightpos - wpos);
330 vout.tex_coord[2] = normalize (wpos); 294 vout.tex_coord[2] = normalize (wpos);
331 vout.tex_coord[3] = normalize (xyz (gl.model_view_matrix_inverse_transpose) * vin.normal); 295 //vout.tex_coord[3] = normalize (xyz (model_view_matrix_inverse_transpose) * vin.normal);
332 vout.tex_coord[4] = normalize (xyz (gl.projection_matrix_inverse_transpose) - wpos); 296 //vout.tex_coord[4] = normalize (xyz (projection_matrix_inverse_transpose) - wpos);
333 297
334 vsh->end (); 298 vsh->stop ();
335 //vsh->compile ();
336 299
337 fragment_shader fsh; 300 fragment_shader fsh;
338 301
339 fsh->start (); 302 fsh->start ();
340 303
341 xyz (fout.frag_color) = noise3 (x (fin.frag_coord) * y (fin.frag_coord)); 304 xyz (fout.frag_color) = noise3 (x (fin.frag_coord) * y (fin.frag_coord));
342 305
343 temp_1f spec_expon; 306 temp_1f spec_expon;
344 spec_expon = 200; 307 spec_expon = 200;
345 308
346 fsh->end ();
347 fsh->compile (); 309 fsh->stop ();
348 310
349 //abort (); 311 //abort ();
350 } 312 }
351 313
352} 314}

Diff Legend

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