LEFT | RIGHT |
1 /* | 1 /* |
2 * $Id$ | 2 * $Id$ |
3 * | 3 * |
4 * ***** BEGIN GPL LICENSE BLOCK ***** | 4 * ***** BEGIN GPL LICENSE BLOCK ***** |
5 * | 5 * |
6 * This program is free software; you can redistribute it and/or | 6 * This program is free software; you can redistribute it and/or |
7 * modify it under the terms of the GNU General Public License | 7 * modify it under the terms of the GNU General Public License |
8 * as published by the Free Software Foundation; either version 2 | 8 * as published by the Free Software Foundation; either version 2 |
9 * of the License, or (at your option) any later version. The Blender | 9 * of the License, or (at your option) any later version. The Blender |
10 * Foundation also sells licenses for use in proprietary software under | 10 * Foundation also sells licenses for use in proprietary software under |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
69 #include "BLI_threads.h" | 69 #include "BLI_threads.h" |
70 #include "BLI_blenlib.h" | 70 #include "BLI_blenlib.h" |
71 | 71 |
72 #include "GPU_buffers.h" | 72 #include "GPU_buffers.h" |
73 #include "GPU_draw.h" | 73 #include "GPU_draw.h" |
74 #include "GPU_extensions.h" | 74 #include "GPU_extensions.h" |
75 #include "GPU_material.h" | 75 #include "GPU_material.h" |
76 | 76 |
77 #include "smoke_API.h" | 77 #include "smoke_API.h" |
78 | 78 |
| 79 extern Material defmaterial; /* from material.c */ |
| 80 |
79 /* These are some obscure rendering functions shared between the | 81 /* These are some obscure rendering functions shared between the |
80 * game engine and the blender, in this module to avoid duplicaten | 82 * game engine and the blender, in this module to avoid duplicaten |
81 * and abstract them away from the rest a bit */ | 83 * and abstract them away from the rest a bit */ |
82 | 84 |
83 /* Text Rendering */ | 85 /* Text Rendering */ |
84 | 86 |
85 static void gpu_mcol(unsigned int ucol) | 87 static void gpu_mcol(unsigned int ucol) |
86 { | 88 { |
87 /* mcol order is swapped */ | 89 /* mcol order is swapped */ |
88 char *cp= (char *)&ucol; | 90 char *cp= (char *)&ucol; |
89 glColor3ub(cp[3], cp[2], cp[1]); | 91 glColor3ub(cp[3], cp[2], cp[1]); |
90 } | 92 } |
91 | 93 |
92 void GPU_render_text(MTFace *tface, int mode, | 94 void GPU_render_text(MTFace *tface, int mode, |
93 const char *textstr, int textlen, unsigned int *col, | 95 const char *textstr, int textlen, unsigned int *col, |
94 float *v1, float *v2, float *v3, float *v4, int glattrib) | 96 float *v1, float *v2, float *v3, float *v4, int glattrib) |
95 { | 97 { |
96 » if ((mode & GEMAT_TEXT) && (textlen>0) && tface->tpage) { | 98 » if ((mode & TF_BMFONT) && (textlen>0) && tface->tpage) { |
97 Image* ima = (Image*)tface->tpage; | 99 Image* ima = (Image*)tface->tpage; |
98 int index, character; | 100 int index, character; |
99 float centerx, centery, sizex, sizey, transx, transy, movex, mov
ey, advance; | 101 float centerx, centery, sizex, sizey, transx, transy, movex, mov
ey, advance; |
100 float advance_tab; | |
101 ················ | |
102 /* multiline */ | |
103 float line_start= 0.0f, line_height; | |
104 ················ | |
105 if (v4) | |
106 line_height= MAX4(v1[1], v2[1], v3[1], v4[2]) - MIN4(v1[
1], v2[1], v3[1], v4[2]); | |
107 else | |
108 line_height= MAX3(v1[1], v2[1], v3[1]) - MIN3(v1[1], v2[
1], v3[1]); | |
109 line_height *= 1.2; /* could be an option? */ | |
110 /* end multiline */ | |
111 | |
112 ················ | |
113 /* color has been set */ | |
114 if (tface->mode & TF_OBCOL) | |
115 col= NULL; | |
116 else if (!col) | |
117 glColor3f(1.0f, 1.0f, 1.0f); | |
118 | |
119 glPushMatrix(); | |
120 ················ | |
121 /* get the tab width */ | |
122 matrixGlyph((ImBuf *)ima->ibufs.first, ' ', & centerx, ¢ery, | |
123 &sizex, &sizey, &transx, &transy, &movex, &movey, &advan
ce); | |
124 ················ | |
125 advance_tab= advance * 4; /* tab width could also be an option *
/ | |
126 ················ | |
127 ················ | |
128 for (index = 0; index < textlen; index++) { | |
129 float uv[4][2]; | |
130 | |
131 // lets calculate offset stuff | |
132 character = textstr[index]; | |
133 ························ | |
134 if (character=='\n') { | |
135 glTranslatef(line_start, -line_height, 0.0); | |
136 line_start = 0.0f; | |
137 continue; | |
138 } | |
139 else if (character=='\t') { | |
140 glTranslatef(advance_tab, 0.0, 0.0); | |
141 line_start -= advance_tab; /* so we can go back
to the start of the line */ | |
142 continue; | |
143 ································ | |
144 } | |
145 ························ | |
146 // space starts at offset 1 | |
147 // character = character - ' ' + 1; | |
148 matrixGlyph((ImBuf *)ima->ibufs.first, character, & cent
erx, ¢ery, | |
149 &sizex, &sizey, &transx, &transy, &movex, &movey
, &advance); | |
150 | |
151 uv[0][0] = (tface->uv[0][0] - centerx) * sizex + transx; | |
152 uv[0][1] = (tface->uv[0][1] - centery) * sizey + transy; | |
153 uv[1][0] = (tface->uv[1][0] - centerx) * sizex + transx; | |
154 uv[1][1] = (tface->uv[1][1] - centery) * sizey + transy; | |
155 uv[2][0] = (tface->uv[2][0] - centerx) * sizex + transx; | |
156 uv[2][1] = (tface->uv[2][1] - centery) * sizey + transy; | |
157 ························ | |
158 glBegin(GL_POLYGON); | |
159 if(glattrib >= 0) glVertexAttrib2fvARB(glattrib, uv[0]); | |
160 else glTexCoord2fv(uv[0]); | |
161 if(col) gpu_mcol(col[0]); | |
162 glVertex3f(sizex * v1[0] + movex, sizey * v1[1] + movey,
v1[2]); | |
163 ························ | |
164 if(glattrib >= 0) glVertexAttrib2fvARB(glattrib, uv[1]); | |
165 else glTexCoord2fv(uv[1]); | |
166 if(col) gpu_mcol(col[1]); | |
167 glVertex3f(sizex * v2[0] + movex, sizey * v2[1] + movey,
v2[2]); | |
168 | |
169 if(glattrib >= 0) glVertexAttrib2fvARB(glattrib, uv[2]); | |
170 else glTexCoord2fv(uv[2]); | |
171 if(col) gpu_mcol(col[2]); | |
172 glVertex3f(sizex * v3[0] + movex, sizey * v3[1] + movey,
v3[2]); | |
173 | |
174 if(v4) { | |
175 uv[3][0] = (tface->uv[3][0] - centerx) * sizex +
transx; | |
176 uv[3][1] = (tface->uv[3][1] - centery) * sizey +
transy; | |
177 | |
178 if(glattrib >= 0) glVertexAttrib2fvARB(glattrib,
uv[3]); | |
179 else glTexCoord2fv(uv[3]); | |
180 if(col) gpu_mcol(col[3]); | |
181 glVertex3f(sizex * v4[0] + movex, sizey * v4[1]
+ movey, v4[2]); | |
182 } | |
183 glEnd(); | |
184 | |
185 glTranslatef(advance, 0.0, 0.0); | |
186 line_start -= advance; /* so we can go back to the start
of the line */ | |
187 } | |
188 glPopMatrix(); | |
189 } | |
190 } | |
191 | |
192 /* Checking powers of two for images since opengl 1.x requires it */ | |
193 | |
194 static int is_pow2(int num) | |
195 { | |
196 /* (n&(n-1)) zeros the least significant bit of n */ | |
197 return ((num)&(num-1))==0; | |
198 } | |
199 | |
200 static int smaller_pow2(int num) | |
201 { | |
202 while (!is_pow2(num)) | |
203 num= num&(num-1); | |
204 | |
205 return num;····· | |
206 } | |
207 | |
208 static int is_pow2_limit(int num) | |
209 { | |
210 /* take texture clamping into account */ | |
211 | |
212 /* XXX: texturepaint not global! | |
213 if (G.f & G_TEXTUREPAINT) | |
214 return 1;*/ | |
215 | |
216 if (U.glreslimit != 0 && num > U.glreslimit) | |
217 return 0; | |
218 | |
219 return ((num)&(num-1))==0; | |
220 } | |
221 | |
222 static int smaller_pow2_limit(int num) | |
223 { | |
224 /* XXX: texturepaint not global! | |
225 if (G.f & G_TEXTUREPAINT) | |
226 return 1;*/ | |
227 ········ | |
228 /* take texture clamping into account */ | |
229 if (U.glreslimit != 0 && num > U.glreslimit) | |
230 return U.glreslimit; | |
231 | |
232 return smaller_pow2(num); | |
233 } | |
234 | |
235 /* Current OpenGL state caching for GPU_set_tpage */ | |
236 | |
237 static struct GPUTextureState { | |
238 int curtile, tile; | |
239 int curtilemode, tilemode; | |
240 int curtileXRep, tileXRep; | |
241 int curtileYRep, tileYRep; | |
242 Image *ima, *curima; | |
243 | |
244 int domipmap, linearmipmap; | |
245 | |
246 int alphamode; | |
247 MTFace *lasttface; | |
248 } GTS = {0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, 1, 0, -1, NULL}; | |
249 | |
250 /* Mipmap settings */ | |
251 | |
252 void GPU_set_mipmap(int mipmap) | |
253 { | |
254 if (GTS.domipmap != (mipmap != 0)) { | |
255 GPU_free_images(); | |
256 GTS.domipmap = mipmap != 0; | |
257 } | |
258 } | |
259 | |
260 void GPU_set_linear_mipmap(int linear) | |
261 { | |
262 if (GTS.linearmipmap != (linear != 0)) { | |
263 GPU_free_images(); | |
264 GTS.linearmipmap = linear != 0; | |
265 } | |
266 } | |
267 | |
268 static int gpu_get_mipmap(void) | |
269 { | |
270 return GTS.domipmap; | |
271 } | |
272 | |
273 static GLenum gpu_get_mipmap_filter(int mag) | |
274 { | |
275 /* linearmipmap is off by default *when mipmapping is off, | |
276 * use unfiltered display */ | |
277 if(mag) { | |
278 if(GTS.linearmipmap || GTS.domipmap) | |
279 return GL_LINEAR; | |
280 else | |
281 return GL_NEAREST; | |
282 } | |
283 else { | |
284 if(GTS.linearmipmap) | |
285 return GL_LINEAR_MIPMAP_LINEAR; | |
286 else if(GTS.domipmap) | |
287 return GL_LINEAR_MIPMAP_NEAREST; | |
288 else | |
289 return GL_NEAREST; | |
290 } | |
291 } | |
292 | |
293 /* Set OpenGL state for an MTFace */ | |
294 | |
295 static void gpu_make_repbind(Image *ima) | |
296 { | |
297 ImBuf *ibuf; | |
298 ········ | |
299 ibuf = BKE_image_get_ibuf(ima, NULL); | |
300 if(ibuf==NULL) | |
301 return; | |
302 | |
303 if(ima->repbind) { | |
304 glDeleteTextures(ima->totbind, (GLuint *)ima->repbind); | |
305 MEM_freeN(ima->repbind); | |
306 ima->repbind= NULL; | |
307 ima->tpageflag &= ~IMA_MIPMAP_COMPLETE; | |
308 } | |
309 | |
310 ima->totbind= ima->xrep*ima->yrep; | |
311 | |
312 if(ima->totbind>1) | |
313 ima->repbind= MEM_callocN(sizeof(int)*ima->totbind, "repbind"); | |
314 } | |
315 | |
316 static void gpu_clear_tpage(void) | |
317 { | |
318 if(GTS.lasttface==NULL) | |
319 return; | |
320 ········ | |
321 GTS.lasttface= NULL; | |
322 GTS.curtile= 0; | |
323 GTS.curima= NULL; | |
324 if(GTS.curtilemode!=0) { | |
325 glMatrixMode(GL_TEXTURE); | |
326 glLoadIdentity(); | |
327 glMatrixMode(GL_MODELVIEW); | |
328 } | |
329 GTS.curtilemode= 0; | |
330 GTS.curtileXRep=0; | |
331 GTS.curtileYRep=0; | |
332 GTS.alphamode= -1; | |
333 ········ | |
334 glDisable(GL_BLEND); | |
335 glDisable(GL_TEXTURE_2D); | |
336 glDisable(GL_TEXTURE_GEN_S); | |
337 glDisable(GL_TEXTURE_GEN_T); | |
338 glDisable(GL_ALPHA_TEST); | |
339 } | |
340 | |
341 static void gpu_set_blend_mode(GPUBlendMode blendmode) | |
342 { | |
343 if(blendmode == GPU_BLEND_SOLID) { | |
344 glDisable(GL_BLEND); | |
345 glDisable(GL_ALPHA_TEST); | |
346 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
347 } | |
348 else if(blendmode==GPU_BLEND_ADD) { | |
349 glEnable(GL_BLEND); | |
350 glBlendFunc(GL_ONE, GL_ONE); | |
351 glDisable(GL_ALPHA_TEST); | |
352 } | |
353 else if(ELEM(blendmode, GPU_BLEND_ALPHA, GPU_BLEND_ALPHA_SORT)) { | |
354 glEnable(GL_BLEND); | |
355 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
356 ················ | |
357 /* if U.glalphaclip == 1.0, some cards go bonkers... | |
358 * turn off alpha test in this case */ | |
359 | |
360 /* added after 2.45 to clip alpha */ | |
361 if(U.glalphaclip == 1.0) { | |
362 glDisable(GL_ALPHA_TEST); | |
363 } | |
364 else { | |
365 glEnable(GL_ALPHA_TEST); | |
366 glAlphaFunc(GL_GREATER, U.glalphaclip); | |
367 } | |
368 } | |
369 else if(blendmode==GPU_BLEND_CLIP) { | |
370 glDisable(GL_BLEND);· | |
371 glEnable(GL_ALPHA_TEST); | |
372 glAlphaFunc(GL_GREATER, 0.5f); | |
373 } | |
374 } | |
375 | |
376 static void gpu_verify_alpha_mode(int transp) | |
377 { | |
378 /* verify alpha blending modes */ | |
379 if(GTS.alphamode == transp) | |
380 return; | |
381 | |
382 gpu_set_blend_mode(transp); | |
383 GTS.alphamode= transp; | |
384 } | |
385 | |
386 static void gpu_verify_reflection(Image *ima) | |
387 { | |
388 if (ima && (ima->flag & IMA_REFLECT)) { | |
389 /* enable reflection mapping */ | |
390 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); | |
391 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); | |
392 | |
393 glEnable(GL_TEXTURE_GEN_S); | |
394 glEnable(GL_TEXTURE_GEN_T); | |
395 } | |
396 else { | |
397 /* disable reflection mapping */ | |
398 glDisable(GL_TEXTURE_GEN_S); | |
399 glDisable(GL_TEXTURE_GEN_T); | |
400 } | |
401 } | |
402 | |
403 int GPU_verify_image(Image *ima, ImageUser *iuser, int tftile, int compare, int
mipmap) | |
404 { | |
405 ImBuf *ibuf = NULL; | |
406 unsigned int *bind = NULL; | |
407 int rectw, recth, tpx=0, tpy=0, y; | |
408 unsigned int *rectrow, *tilerectrow; | |
409 unsigned int *tilerect= NULL, *scalerect= NULL, *rect= NULL; | |
410 short texwindx, texwindy, texwinsx, texwinsy; | |
411 | |
412 /* initialize tile mode and number of repeats */ | |
413 GTS.ima = ima; | |
414 GTS.tilemode= (ima && (ima->tpageflag & (IMA_TILES|IMA_TWINANIM))); | |
415 GTS.tileXRep = 0; | |
416 GTS.tileYRep = 0; | |
417 | |
418 /* setting current tile according to frame */ | |
419 if(ima && (ima->tpageflag & IMA_TWINANIM)) | |
420 GTS.tile= ima->lastframe; | |
421 else | |
422 GTS.tile= tftile; | |
423 | |
424 GTS.tile = MAX2(0, GTS.tile); | |
425 | |
426 if(ima) { | |
427 GTS.tileXRep = ima->xrep; | |
428 GTS.tileYRep = ima->yrep; | |
429 } | |
430 | |
431 /* if same image & tile, we're done */ | |
432 if(compare && ima == GTS.curima && GTS.curtile == GTS.tile && | |
433 GTS.tilemode == GTS.curtilemode && GTS.curtileXRep == GTS.tileXRep && | |
434 GTS.curtileYRep == GTS.tileYRep) | |
435 return (ima != NULL); | |
436 | |
437 /* if tiling mode or repeat changed, change texture matrix to fit */ | |
438 if(GTS.tilemode!=GTS.curtilemode || GTS.curtileXRep!=GTS.tileXRep || | |
439 GTS.curtileYRep != GTS.tileYRep) { | |
440 | |
441 glMatrixMode(GL_TEXTURE); | |
442 glLoadIdentity(); | |
443 | |
444 if(ima && (ima->tpageflag & IMA_TILES)) | |
445 glScalef(ima->xrep, ima->yrep, 1.0); | |
446 | |
447 glMatrixMode(GL_MODELVIEW); | |
448 } | |
449 | |
450 /* check if we have a valid image */ | |
451 if(ima==NULL || ima->ok==0) | |
452 return 0; | |
453 | |
454 /* check if we have a valid image buffer */ | |
455 ibuf= BKE_image_get_ibuf(ima, iuser); | |
456 | |
457 if(ibuf==NULL) | |
458 return 0; | |
459 | |
460 /* ensure we have a char buffer and not only float */ | |
461 if ((ibuf->rect==NULL) && ibuf->rect_float) | |
462 IMB_rect_from_float(ibuf); | |
463 | |
464 /* currently, tpage refresh is used by ima sequences */ | |
465 if(ima->tpageflag & IMA_TPAGE_REFRESH) { | |
466 GPU_free_image(ima); | |
467 ima->tpageflag &= ~IMA_TPAGE_REFRESH; | |
468 } | |
469 ········ | |
470 if(GTS.tilemode) { | |
471 /* tiled mode */ | |
472 if(ima->repbind==NULL) gpu_make_repbind(ima); | |
473 if(GTS.tile>=ima->totbind) GTS.tile= 0; | |
474 ················ | |
475 /* this happens when you change repeat buttons */ | |
476 if(ima->repbind) bind= &ima->repbind[GTS.tile]; | |
477 else bind= &ima->bindcode; | |
478 ················ | |
479 if(*bind==0) { | |
480 ························ | |
481 texwindx= ibuf->x/ima->xrep; | |
482 texwindy= ibuf->y/ima->yrep; | |
483 ························ | |
484 if(GTS.tile>=ima->xrep*ima->yrep) | |
485 GTS.tile= ima->xrep*ima->yrep-1; | |
486 ········ | |
487 texwinsy= GTS.tile / ima->xrep; | |
488 texwinsx= GTS.tile - texwinsy*ima->xrep; | |
489 ········ | |
490 texwinsx*= texwindx; | |
491 texwinsy*= texwindy; | |
492 ········ | |
493 tpx= texwindx; | |
494 tpy= texwindy; | |
495 | |
496 rect= ibuf->rect + texwinsy*ibuf->x + texwinsx; | |
497 } | |
498 } | |
499 else { | |
500 /* regular image mode */ | |
501 bind= &ima->bindcode; | |
502 ················ | |
503 if(*bind==0) { | |
504 tpx= ibuf->x; | |
505 tpy= ibuf->y; | |
506 rect= ibuf->rect; | |
507 } | |
508 } | |
509 | |
510 if(*bind != 0) { | |
511 /* enable opengl drawing with textures */ | |
512 glBindTexture(GL_TEXTURE_2D, *bind); | |
513 return *bind; | |
514 } | |
515 | |
516 rectw = tpx; | |
517 recth = tpy; | |
518 | |
519 /* for tiles, copy only part of image into buffer */ | |
520 if (GTS.tilemode) { | |
521 tilerect= MEM_mallocN(rectw*recth*sizeof(*tilerect), "tilerect")
; | |
522 | |
523 for (y=0; y<recth; y++) { | |
524 rectrow= &rect[y*ibuf->x]; | |
525 tilerectrow= &tilerect[y*rectw]; | |
526 ································ | |
527 memcpy(tilerectrow, rectrow, tpx*sizeof(*rectrow)); | |
528 } | |
529 ························ | |
530 rect= tilerect; | |
531 } | |
532 | |
533 /* scale if not a power of two */ | |
534 if (!mipmap && (!is_pow2_limit(rectw) || !is_pow2_limit(recth))) { | |
535 rectw= smaller_pow2_limit(rectw); | |
536 recth= smaller_pow2_limit(recth); | |
537 ················ | |
538 scalerect= MEM_mallocN(rectw*recth*sizeof(*scalerect), "scalerec
t"); | |
539 gluScaleImage(GL_RGBA, tpx, tpy, GL_UNSIGNED_BYTE, rect, rectw,
recth, GL_UNSIGNED_BYTE, scalerect); | |
540 rect= scalerect; | |
541 } | |
542 | |
543 /* create image */ | |
544 glGenTextures(1, (GLuint *)bind); | |
545 glBindTexture( GL_TEXTURE_2D, *bind); | |
546 | |
547 if (!(gpu_get_mipmap() && mipmap)) { | |
548 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rectw, recth, 0, GL_RG
BA, GL_UNSIGNED_BYTE, rect); | |
549 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
; | |
550 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gpu_get_mi
pmap_filter(1)); | |
551 } | |
552 else { | |
553 gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, rectw, recth, GL_RGBA,
GL_UNSIGNED_BYTE, rect); | |
554 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gpu_get_mi
pmap_filter(0)); | |
555 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gpu_get_mi
pmap_filter(1)); | |
556 | |
557 ima->tpageflag |= IMA_MIPMAP_COMPLETE; | |
558 } | |
559 | |
560 /* set to modulate with vertex color */ | |
561 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
562 ················ | |
563 /* clean up */ | |
564 if (tilerect) | |
565 MEM_freeN(tilerect); | |
566 if (scalerect) | |
567 MEM_freeN(scalerect); | |
568 | |
569 return *bind; | |
570 } | |
571 | |
572 static void gpu_verify_repeat(Image *ima) | |
573 { | |
574 /* set either clamp or repeat in X/Y */ | |
575 if (ima->tpageflag & IMA_CLAMP_U) | |
576 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | |
577 else | |
578 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
579 | |
580 if (ima->tpageflag & IMA_CLAMP_V) | |
581 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_ED
GE); | |
582 else | |
583 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
584 } | |
585 | |
586 int GPU_set_tpage(MTFace *tface, int mipmap, int transp) | |
587 { | |
588 Image *ima; | |
589 ········ | |
590 /* check if we need to clear the state */ | |
591 if(tface==NULL) { | |
592 gpu_clear_tpage(); | |
593 return 0; | |
594 } | |
595 | |
596 ima= tface->tpage; | |
597 GTS.lasttface= tface; | |
598 | |
599 gpu_verify_alpha_mode(transp); | |
600 gpu_verify_reflection(ima); | |
601 | |
602 if(GPU_verify_image(ima, NULL, tface->tile, 1, mipmap)) { | |
603 GTS.curtile= GTS.tile; | |
604 GTS.curima= GTS.ima; | |
605 GTS.curtilemode= GTS.tilemode; | |
606 GTS.curtileXRep = GTS.tileXRep; | |
607 GTS.curtileYRep = GTS.tileYRep; | |
608 | |
609 glEnable(GL_TEXTURE_2D); | |
610 } | |
611 else { | |
612 glDisable(GL_TEXTURE_2D); | |
613 ················ | |
614 GTS.curtile= 0; | |
615 GTS.curima= NULL; | |
616 GTS.curtilemode= 0; | |
617 GTS.curtileXRep = 0; | |
618 GTS.curtileYRep = 0; | |
619 | |
620 return 0; | |
621 } | |
622 ········ | |
623 gpu_verify_repeat(ima); | |
624 ········ | |
625 /* Did this get lost in the image recode? */ | |
626 /* tag_image_time(ima);*/ | |
627 | |
628 return 1; | |
629 } | |
630 | |
631 /* these two functions are called on entering and exiting texture paint mode, | |
632 temporary disabling/enabling mipmapping on all images for quick texture | |
633 updates with glTexSubImage2D. images that didn't change don't have to be | |
634 re-uploaded to OpenGL */ | |
635 void GPU_paint_set_mipmap(int mipmap) | |
636 { | |
637 Image* ima; | |
638 ········ | |
639 if(!GTS.domipmap) | |
640 return; | |
641 | |
642 if(mipmap) { | |
643 for(ima=G.main->image.first; ima; ima=ima->id.next) { | |
644 if(ima->bindcode) { | |
645 if(ima->tpageflag & IMA_MIPMAP_COMPLETE) { | |
646 glBindTexture(GL_TEXTURE_2D, ima->bindco
de); | |
647 glTexParameteri(GL_TEXTURE_2D, GL_TEXTUR
E_MIN_FILTER, gpu_get_mipmap_filter(0)); | |
648 glTexParameteri(GL_TEXTURE_2D, GL_TEXTUR
E_MAG_FILTER, gpu_get_mipmap_filter(1)); | |
649 } | |
650 else | |
651 GPU_free_image(ima); | |
652 } | |
653 } | |
654 | |
655 } | |
656 else { | |
657 for(ima=G.main->image.first; ima; ima=ima->id.next) { | |
658 if(ima->bindcode) { | |
659 glBindTexture(GL_TEXTURE_2D, ima->bindcode); | |
660 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FI
LTER, GL_LINEAR); | |
661 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FI
LTER, gpu_get_mipmap_filter(1)); | |
662 } | |
663 } | |
664 } | |
665 } | |
666 | |
667 void GPU_paint_update_image(Image *ima, int x, int y, int w, int h, int mipmap) | |
668 { | |
669 ImBuf *ibuf; | |
670 ········ | |
671 ibuf = BKE_image_get_ibuf(ima, NULL); | |
672 ········ | |
673 if (ima->repbind || (gpu_get_mipmap() && mipmap) || !ima->bindcode || !i
buf || | |
674 (!is_pow2(ibuf->x) || !is_pow2(ibuf->y)) || | |
675 (w == 0) || (h == 0)) { | |
676 /* these cases require full reload still */ | |
677 GPU_free_image(ima); | |
678 } | |
679 else { | |
680 /* for the special case, we can do a partial update | |
681 * which is much quicker for painting */ | |
682 GLint row_length, skip_pixels, skip_rows; | |
683 | |
684 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &row_length); | |
685 glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skip_pixels); | |
686 glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skip_rows); | |
687 | |
688 if ((ibuf->rect==NULL) && ibuf->rect_float) | |
689 IMB_rect_from_float(ibuf); | |
690 | |
691 glBindTexture(GL_TEXTURE_2D, ima->bindcode); | |
692 | |
693 glPixelStorei(GL_UNPACK_ROW_LENGTH, ibuf->x); | |
694 glPixelStorei(GL_UNPACK_SKIP_PIXELS, x); | |
695 glPixelStorei(GL_UNPACK_SKIP_ROWS, y); | |
696 | |
697 glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_RGBA, | |
698 GL_UNSIGNED_BYTE, ibuf->rect); | |
699 | |
700 glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length); | |
701 glPixelStorei(GL_UNPACK_SKIP_PIXELS, skip_pixels); | |
702 glPixelStorei(GL_UNPACK_SKIP_ROWS, skip_rows); | |
703 | |
704 if(ima->tpageflag & IMA_MIPMAP_COMPLETE) | |
705 ima->tpageflag &= ~IMA_MIPMAP_COMPLETE; | |
706 } | |
707 } | |
708 | |
709 void GPU_update_images_framechange(void) | |
710 { | |
711 Image *ima; | |
712 ········ | |
713 for(ima=G.main->image.first; ima; ima=ima->id.next) { | |
714 if(ima->tpageflag & IMA_TWINANIM) { | |
715 if(ima->twend >= ima->xrep*ima->yrep) | |
716 ima->twend= ima->xrep*ima->yrep-1; | |
717 ················ | |
718 /* check: is bindcode not in the array? free. (to do) */ | |
719 ························ | |
720 ima->lastframe++; | |
721 if(ima->lastframe > ima->twend) | |
722 ima->lastframe= ima->twsta; | |
723 } | |
724 } | |
725 } | |
726 | |
727 int GPU_update_image_time(Image *ima, double time) | |
728 { | |
729 int inc = 0; | |
730 float diff; | |
731 int newframe; | |
732 | |
733 if (!ima) | |
734 return 0; | |
735 | |
736 if (ima->lastupdate<0) | |
737 ima->lastupdate = 0; | |
738 | |
739 if (ima->lastupdate>time) | |
740 ima->lastupdate=(float)time; | |
741 | |
742 if(ima->tpageflag & IMA_TWINANIM) { | |
743 if(ima->twend >= ima->xrep*ima->yrep) ima->twend= ima->xrep*ima-
>yrep-1; | |
744 ················ | |
745 /* check: is the bindcode not in the array? Then free. (still to
do) */ | |
746 ················ | |
747 diff = (float)(time-ima->lastupdate); | |
748 inc = (int)(diff*(float)ima->animspeed); | |
749 | |
750 ima->lastupdate+=((float)inc/(float)ima->animspeed); | |
751 | |
752 newframe = ima->lastframe+inc; | |
753 | |
754 if(newframe > (int)ima->twend) { | |
755 if(ima->twend-ima->twsta != 0) | |
756 newframe = (int)ima->twsta-1 + (newframe-ima->tw
end)%(ima->twend-ima->twsta); | |
757 else | |
758 newframe = ima->twsta; | |
759 } | |
760 | |
761 ima->lastframe = newframe; | |
762 } | |
763 | |
764 return inc; | |
765 } | |
766 | |
767 | |
768 void GPU_free_smoke(SmokeModifierData *smd) | |
769 { | |
770 if(smd->type & MOD_SMOKE_TYPE_DOMAIN && smd->domain) | |
771 { | |
772 if(smd->domain->tex) | |
773 GPU_texture_free(smd->domain->tex); | |
774 smd->domain->tex = NULL; | |
775 | |
776 if(smd->domain->tex_shadow) | |
777 GPU_texture_free(smd->domain->tex_shadow); | |
778 smd->domain->tex_shadow = NULL; | |
779 } | |
780 } | |
781 | |
782 void GPU_create_smoke(SmokeModifierData *smd, int highres) | |
783 { | |
784 if(smd->type & MOD_SMOKE_TYPE_DOMAIN && !smd->domain->tex && !highres) | |
785 smd->domain->tex = GPU_texture_create_3D(smd->domain->res[0], sm
d->domain->res[1], smd->domain->res[2], smoke_get_density(smd->domain->fluid)); | |
786 else if(smd->type & MOD_SMOKE_TYPE_DOMAIN && !smd->domain->tex && highre
s) | |
787 smd->domain->tex = GPU_texture_create_3D(smd->domain->res_wt[0],
smd->domain->res_wt[1], smd->domain->res_wt[2], smoke_turbulence_get_density(sm
d->domain->wt)); | |
788 | |
789 smd->domain->tex_shadow = GPU_texture_create_3D(smd->domain->res[0], smd
->domain->res[1], smd->domain->res[2], smd->domain->shadow); | |
790 } | |
791 | |
792 static ListBase image_free_queue = {NULL, NULL}; | |
793 | |
794 static void gpu_queue_image_for_free(Image *ima) | |
795 { | |
796 Image *cpy = MEM_dupallocN(ima); | |
797 | |
798 BLI_lock_thread(LOCK_OPENGL); | |
799 BLI_addtail(&image_free_queue, cpy); | |
800 BLI_unlock_thread(LOCK_OPENGL); | |
801 } | |
802 | |
803 void GPU_free_unused_buffers(void) | |
804 { | |
805 Image *ima; | |
806 | |
807 if(!BLI_thread_is_main()) | |
808 return; | |
809 | |
810 BLI_lock_thread(LOCK_OPENGL); | |
811 | |
812 /* images */ | |
813 for(ima=image_free_queue.first; ima; ima=ima->id.next) | |
814 GPU_free_image(ima); | |
815 | |
816 BLI_freelistN(&image_free_queue); | |
817 | |
818 /* vbo buffers */ | |
819 /* it's probably not necessary to free all buffers every frame */ | |
820 /* GPU_buffer_pool_free_unused(0); */ | |
821 | |
822 BLI_unlock_thread(LOCK_OPENGL); | |
823 } | |
824 | |
825 void GPU_free_image(Image *ima) | |
826 { | |
827 if(!BLI_thread_is_main()) { | |
828 gpu_queue_image_for_free(ima); | |
829 return; | |
830 } | |
831 | |
832 /* free regular image binding */ | |
833 if(ima->bindcode) { | |
834 glDeleteTextures(1, (GLuint *)&ima->bindcode); | |
835 ima->bindcode= 0; | |
836 ima->tpageflag &= ~IMA_MIPMAP_COMPLETE; | |
837 } | |
838 | |
839 /* free glsl image binding */ | |
840 if(ima->gputexture) { | |
841 GPU_texture_free(ima->gputexture); | |
842 ima->gputexture= NULL; | |
843 } | |
844 | |
845 /* free repeated image binding */ | |
846 if(ima->repbind) { | |
847 glDeleteTextures(ima->totbind, (GLuint *)ima->repbind); | |
848 ········ | |
849 MEM_freeN(ima->repbind); | |
850 ima->repbind= NULL; | |
851 ima->tpageflag &= ~IMA_MIPMAP_COMPLETE; | |
852 } | |
853 } | |
854 | |
855 void GPU_free_images(void) | |
856 { | |
857 Image* ima; | |
858 | |
859 if(G.main) | |
860 for(ima=G.main->image.first; ima; ima=ima->id.next) | |
861 GPU_free_image(ima); | |
862 } | |
863 | |
864 /* same as above but only free animated images */ | |
865 void GPU_free_images_anim(void) | |
866 { | |
867 Image* ima; | |
868 | |
869 if(G.main) | |
870 for(ima=G.main->image.first; ima; ima=ima->id.next) | |
871 if(ELEM(ima->source, IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) | |
872 GPU_free_image(ima); | |
873 } | |
874 | |
875 /* OpenGL Materials */ | |
876 | |
877 #define FIXEDMAT 8 | |
878 | |
879 /* OpenGL state caching for materials */ | |
880 | |
881 typedef struct GPUMaterialFixed { | |
882 float diff[4]; | |
883 float spec[4]; | |
884 int hard; | |
885 } GPUMaterialFixed;· | |
886 | |
887 static struct GPUMaterialState { | |
888 GPUMaterialFixed (*matbuf); | |
889 GPUMaterialFixed matbuf_fixed[FIXEDMAT]; | |
890 int totmat; | |
891 | |
892 Material **gmatbuf; | |
893 Material *gmatbuf_fixed[FIXEDMAT]; | |
894 Material *gboundmat; | |
895 Object *gob; | |
896 Scene *gscene; | |
897 int glay; | |
898 float (*gviewmat)[4]; | |
899 float (*gviewinv)[4]; | |
900 | |
901 GPUBlendMode *blendmode; | |
902 GPUBlendMode blendmode_fixed[FIXEDMAT]; | |
903 int alphapass; | |
904 | |
905 int lastmatnr, lastretval; | |
906 GPUBlendMode lastblendmode; | |
907 } GMS = {NULL}; | |
908 | |
909 /* fixed function material, alpha handed by caller */ | |
910 static void gpu_material_to_fixed(GPUMaterialFixed *smat, const Material *bmat,
const int gamma, const Object *ob) | |
911 { | |
912 if (bmat->mode & MA_SHLESS) { | |
913 copy_v3_v3(smat->diff, &bmat->r); | |
914 smat->diff[3]= 1.0; | |
915 | |
916 if(gamma) { | |
917 linearrgb_to_srgb_v3_v3(smat->diff, smat->diff); | |
918 }······· | |
919 } | |
920 else { | |
921 mul_v3_v3fl(smat->diff, &bmat->r, bmat->ref + bmat->emit); | |
922 smat->diff[3]= 1.0; /* caller may set this to bmat->alpha */ | |
923 | |
924 if(bmat->shade_flag & MA_OBCOLOR) | |
925 mul_v3_v3(smat->diff, ob->col); | |
926 ················ | |
927 mul_v3_v3fl(smat->spec, &bmat->specr, bmat->spec); | |
928 smat->spec[3]= 1.0; /* always 1 */ | |
929 smat->hard= CLAMPIS(bmat->har, 0, 128); | |
930 | |
931 if(gamma) { | |
932 linearrgb_to_srgb_v3_v3(smat->diff, smat->diff); | |
933 linearrgb_to_srgb_v3_v3(smat->spec, smat->spec); | |
934 }······· | |
935 } | |
936 } | |
937 | |
938 static Material *gpu_active_node_material(Material *ma) | |
939 { | |
940 if(ma && ma->use_nodes && ma->nodetree) { | |
941 bNode *node= nodeGetActiveID(ma->nodetree, ID_MA); | |
942 | |
943 if(node) | |
944 return (Material *)node->id; | |
945 else | |
946 return NULL; | |
947 } | |
948 | |
949 return ma; | |
950 } | |
951 | |
952 void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
bject *ob, int glsl, int *do_alpha_pass) | |
953 { | |
954 extern Material defmaterial; /* from material.c */ | |
955 Material *ma; | |
956 GPUMaterial *gpumat; | |
957 GPUBlendMode blendmode; | |
958 int a; | |
959 int gamma = scene->r.color_mgt_flag & R_COLOR_MANAGEMENT; | |
960 ········ | |
961 /* initialize state */ | |
962 memset(&GMS, 0, sizeof(GMS)); | |
963 GMS.lastmatnr = -1; | |
964 GMS.lastretval = -1; | |
965 GMS.lastblendmode = GPU_BLEND_SOLID; | |
966 | |
967 GMS.gob = ob; | |
968 GMS.gscene = scene; | |
969 GMS.totmat= ob->totcol+1; /* materials start from 1, default material is
0 */ | |
970 GMS.glay= v3d->lay; | |
971 GMS.gviewmat= rv3d->viewmat; | |
972 GMS.gviewinv= rv3d->viewinv; | |
973 | |
974 GMS.alphapass = (v3d && v3d->transp); | |
975 if(do_alpha_pass) | |
976 *do_alpha_pass = 0; | |
977 ········ | |
978 if(GMS.totmat > FIXEDMAT) { | |
979 GMS.matbuf= MEM_callocN(sizeof(GPUMaterialFixed)*GMS.totmat, "GM
S.matbuf"); | |
980 GMS.gmatbuf= MEM_callocN(sizeof(*GMS.gmatbuf)*GMS.totmat, "GMS.m
atbuf"); | |
981 GMS.blendmode= MEM_callocN(sizeof(*GMS.blendmode)*GMS.totmat, "G
MS.matbuf"); | |
982 } | |
983 else { | |
984 GMS.matbuf= GMS.matbuf_fixed; | |
985 GMS.gmatbuf= GMS.gmatbuf_fixed; | |
986 GMS.blendmode= GMS.blendmode_fixed; | |
987 } | |
988 | |
989 /* no materials assigned? */ | |
990 if(ob->totcol==0) { | |
991 gpu_material_to_fixed(&GMS.matbuf[0], &defmaterial, 0, ob); | |
992 | |
993 /* do material 1 too, for displists! */ | |
994 memcpy(&GMS.matbuf[1], &GMS.matbuf[0], sizeof(GPUMaterialFixed))
; | |
995 | |
996 if(glsl) { | |
997 GMS.gmatbuf[0]= &defmaterial; | |
998 GPU_material_from_blender(GMS.gscene, &defmaterial); | |
999 } | |
1000 | |
1001 GMS.blendmode[0]= GPU_BLEND_SOLID; | |
1002 } | |
1003 ········ | |
1004 /* setup materials */ | |
1005 for(a=1; a<=ob->totcol; a++) { | |
1006 /* find a suitable material */ | |
1007 ma= give_current_material(ob, a); | |
1008 if(!glsl) ma= gpu_active_node_material(ma); | |
1009 if(ma==NULL) ma= &defmaterial; | |
1010 | |
1011 /* create glsl material if requested */ | |
1012 gpumat = (glsl)? GPU_material_from_blender(GMS.gscene, ma): NULL
; | |
1013 | |
1014 if(gpumat) { | |
1015 /* do glsl only if creating it succeed, else fallback */ | |
1016 GMS.gmatbuf[a]= ma; | |
1017 blendmode = GPU_material_blend_mode(gpumat, ob->col); | |
1018 } | |
1019 else { | |
1020 /* fixed function opengl materials */ | |
1021 gpu_material_to_fixed(&GMS.matbuf[a], ma, gamma, ob); | |
1022 | |
1023 blendmode = (ma->alpha == 1.0f)? GPU_BLEND_SOLID: GPU_BL
END_ALPHA; | |
1024 if(do_alpha_pass && GMS.alphapass) | |
1025 GMS.matbuf[a].diff[3]= ma->alpha; | |
1026 else | |
1027 GMS.matbuf[a].diff[3]= 1.0f; | |
1028 } | |
1029 | |
1030 /* setting do_alpha_pass = 1 indicates this object needs to be | |
1031 * drawn in a second alpha pass for improved blending */ | |
1032 if(do_alpha_pass) { | |
1033 GMS.blendmode[a]= blendmode; | |
1034 if(ELEM3(blendmode, GPU_BLEND_ALPHA, GPU_BLEND_ADD, GPU_
BLEND_ALPHA_SORT) && !GMS.alphapass) | |
1035 *do_alpha_pass= 1; | |
1036 } | |
1037 } | |
1038 | |
1039 /* let's start with a clean state */ | |
1040 GPU_disable_material(); | |
1041 } | |
1042 | |
1043 int GPU_enable_material(int nr, void *attribs) | |
1044 { | |
1045 extern Material defmaterial; /* from material.c */ | |
1046 GPUVertexAttribs *gattribs = attribs; | |
1047 GPUMaterial *gpumat; | |
1048 GPUBlendMode blendmode; | |
1049 | |
1050 /* no GPU_begin_object_materials, use default material */ | |
1051 if(!GMS.matbuf) { | |
1052 float diff[4], spec[4]; | |
1053 | |
1054 memset(&GMS, 0, sizeof(GMS)); | |
1055 | |
1056 mul_v3_v3fl(diff, &defmaterial.r, defmaterial.ref + defmaterial.
emit); | |
1057 diff[3]= 1.0; | |
1058 | |
1059 mul_v3_v3fl(spec, &defmaterial.specr, defmaterial.spec); | |
1060 spec[3]= 1.0; | |
1061 | |
1062 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diff); | |
1063 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spec); | |
1064 glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 35); /* blender def
ault */ | |
1065 | |
1066 return 0; | |
1067 } | |
1068 | |
1069 /* prevent index to use un-initialized array items */ | |
1070 if(nr>=GMS.totmat) | |
1071 nr= 0; | |
1072 | |
1073 if(gattribs) | |
1074 memset(gattribs, 0, sizeof(*gattribs)); | |
1075 | |
1076 /* keep current material */ | |
1077 if(nr==GMS.lastmatnr) | |
1078 return GMS.lastretval; | |
1079 | |
1080 /* unbind glsl material */ | |
1081 if(GMS.gboundmat) { | |
1082 if(GMS.alphapass) glDepthMask(0); | |
1083 GPU_material_unbind(GPU_material_from_blender(GMS.gscene, GMS.gb
oundmat)); | |
1084 GMS.gboundmat= NULL; | |
1085 } | |
1086 | |
1087 /* draw materials with alpha in alpha pass */ | |
1088 GMS.lastmatnr = nr; | |
1089 GMS.lastretval = ELEM(GMS.blendmode[nr], GPU_BLEND_SOLID, GPU_BLEND_CLIP
); | |
1090 if(GMS.alphapass) | |
1091 GMS.lastretval = !GMS.lastretval; | |
1092 | |
1093 if(GMS.lastretval) { | |
1094 if(gattribs && GMS.gmatbuf[nr]) { | |
1095 /* bind glsl material and get attributes */ | |
1096 Material *mat = GMS.gmatbuf[nr]; | |
1097 | |
1098 gpumat = GPU_material_from_blender(GMS.gscene, mat); | |
1099 GPU_material_vertex_attributes(gpumat, gattribs); | |
1100 GPU_material_bind(gpumat, GMS.gob->lay, GMS.glay, 1.0, !
(GMS.gob->mode & OB_MODE_TEXTURE_PAINT)); | |
1101 GPU_material_bind_uniforms(gpumat, GMS.gob->obmat, GMS.g
viewmat, GMS.gviewinv, GMS.gob->col); | |
1102 GMS.gboundmat= mat; | |
1103 | |
1104 if(GMS.alphapass) glDepthMask(1); | |
1105 } | |
1106 else { | |
1107 /* or do fixed function opengl material */ | |
1108 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, GMS.matbuf[n
r].diff); | |
1109 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, GMS.matbuf[
nr].spec); | |
1110 glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, GMS.matbuf[
nr].hard); | |
1111 } | |
1112 | |
1113 /* set (alpha) blending mode */ | |
1114 blendmode = (GMS.alphapass)? GPU_BLEND_ALPHA: GPU_BLEND_SOLID; | |
1115 GPU_set_material_blend_mode(blendmode); | |
1116 } | |
1117 | |
1118 return GMS.lastretval; | |
1119 } | |
1120 | |
1121 void GPU_set_material_blend_mode(int blendmode) | |
1122 { | |
1123 if(GMS.lastblendmode == blendmode) | |
1124 return; | |
1125 ········ | |
1126 gpu_set_blend_mode(blendmode); | |
1127 GMS.lastblendmode = blendmode; | |
1128 } | |
1129 | |
1130 int GPU_get_material_blend_mode(void) | |
1131 { | |
1132 return GMS.lastblendmode; | |
1133 } | |
1134 | |
1135 void GPU_disable_material(void) | |
1136 { | |
1137 GMS.lastmatnr= -1; | |
1138 GMS.lastretval= 1; | |
1139 | |
1140 if(GMS.gboundmat) { | |
1141 if(GMS.alphapass) glDepthMask(0); | |
1142 GPU_material_unbind(GPU_material_from_blender(GMS.gscene, GMS.gb
oundmat)); | |
1143 GMS.gboundmat= NULL; | |
1144 } | |
1145 | |
1146 GPU_set_material_blend_mode(GPU_BLEND_SOLID); | |
1147 } | |
1148 | |
1149 void GPU_end_object_materials(void) | |
1150 { | |
1151 GPU_disable_material(); | |
1152 | |
1153 if(GMS.matbuf && GMS.matbuf != GMS.matbuf_fixed) { | |
1154 MEM_freeN(GMS.matbuf); | |
1155 MEM_freeN(GMS.gmatbuf); | |
1156 MEM_freeN(GMS.blendmode); | |
1157 } | |
1158 | |
1159 GMS.matbuf= NULL; | |
1160 GMS.gmatbuf= NULL; | |
1161 GMS.blendmode= NULL; | |
1162 | |
1163 /* resetting the texture matrix after the glScale needed for tiled textu
res */ | |
1164 if(GTS.tilemode) | |
1165 { | |
1166 glMatrixMode(GL_TEXTURE); | |
1167 glLoadIdentity(); | |
1168 glMatrixMode(GL_MODELVIEW); | |
1169 } | |
1170 } | |
1171 | |
1172 /* Lights */ | |
1173 | |
1174 int GPU_default_lights(void) | |
1175 { | |
1176 int a, count = 0; | |
1177 ········ | |
1178 /* initialize */ | |
1179 if(U.light[0].flag==0 && U.light[1].flag==0 && U.light[2].flag==0) { | |
1180 U.light[0].flag= 1; | |
1181 U.light[0].vec[0]= -0.3; U.light[0].vec[1]= 0.3; U.light[0].vec[
2]= 0.9; | |
1182 U.light[0].col[0]= 0.8; U.light[0].col[1]= 0.8; U.light[0].col[2
]= 0.8; | |
1183 U.light[0].spec[0]= 0.5; U.light[0].spec[1]= 0.5; U.light[0].spe
c[2]= 0.5; | |
1184 U.light[0].spec[3]= 1.0; | |
1185 ················ | |
1186 U.light[1].flag= 0; | |
1187 U.light[1].vec[0]= 0.5; U.light[1].vec[1]= 0.5; U.light[1].vec[2
]= 0.1; | |
1188 U.light[1].col[0]= 0.4; U.light[1].col[1]= 0.4; U.light[1].col[2
]= 0.8; | |
1189 U.light[1].spec[0]= 0.3; U.light[1].spec[1]= 0.3; U.light[1].spe
c[2]= 0.5; | |
1190 U.light[1].spec[3]= 1.0; | |
1191 ········ | |
1192 U.light[2].flag= 0; | |
1193 U.light[2].vec[0]= 0.3; U.light[2].vec[1]= -0.3; U.light[2].vec[
2]= -0.2; | |
1194 U.light[2].col[0]= 0.8; U.light[2].col[1]= 0.5; U.light[2].col[2
]= 0.4; | |
1195 U.light[2].spec[0]= 0.5; U.light[2].spec[1]= 0.4; U.light[2].spe
c[2]= 0.3; | |
1196 U.light[2].spec[3]= 1.0; | |
1197 } | |
1198 | |
1199 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); | |
1200 | |
1201 glLightfv(GL_LIGHT0, GL_POSITION, U.light[0].vec);· | |
1202 glLightfv(GL_LIGHT0, GL_DIFFUSE, U.light[0].col);· | |
1203 glLightfv(GL_LIGHT0, GL_SPECULAR, U.light[0].spec);· | |
1204 | |
1205 glLightfv(GL_LIGHT1, GL_POSITION, U.light[1].vec);· | |
1206 glLightfv(GL_LIGHT1, GL_DIFFUSE, U.light[1].col);· | |
1207 glLightfv(GL_LIGHT1, GL_SPECULAR, U.light[1].spec);· | |
1208 | |
1209 glLightfv(GL_LIGHT2, GL_POSITION, U.light[2].vec);· | |
1210 glLightfv(GL_LIGHT2, GL_DIFFUSE, U.light[2].col);· | |
1211 glLightfv(GL_LIGHT2, GL_SPECULAR, U.light[2].spec);· | |
1212 | |
1213 for(a=0; a<8; a++) { | |
1214 if(a<3) { | |
1215 if(U.light[a].flag) { | |
1216 glEnable(GL_LIGHT0+a); | |
1217 count++; | |
1218 } | |
1219 else | |
1220 glDisable(GL_LIGHT0+a); | |
1221 ························ | |
1222 // clear stuff from other opengl lamp usage | |
1223 glLightf(GL_LIGHT0+a, GL_SPOT_CUTOFF, 180.0); | |
1224 glLightf(GL_LIGHT0+a, GL_CONSTANT_ATTENUATION, 1.0); | |
1225 glLightf(GL_LIGHT0+a, GL_LINEAR_ATTENUATION, 0.0); | |
1226 } | |
1227 else | |
1228 glDisable(GL_LIGHT0+a); | |
1229 } | |
1230 ········ | |
1231 glDisable(GL_LIGHTING); | |
1232 | |
1233 glDisable(GL_COLOR_MATERIAL); | |
1234 | |
1235 return count; | |
1236 } | |
1237 | |
1238 int GPU_scene_object_lights(Scene *scene, Object *ob, int lay, float viewmat[][4
], int ortho) | |
1239 { | |
1240 Base *base; | |
1241 Lamp *la; | |
1242 int count; | |
1243 float position[4], direction[4], energy[4]; | |
1244 ········ | |
1245 /* disable all lights */ | |
1246 for(count=0; count<8; count++) | |
1247 glDisable(GL_LIGHT0+count); | |
1248 ········ | |
1249 /* view direction for specular is not compute correct by default in | |
1250 * opengl, so we set the settings ourselfs */ | |
1251 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, (ortho)? GL_FALSE: GL_TRUE); | |
1252 | |
1253 count= 0; | |
1254 ········ | |
1255 for(base=scene->base.first; base; base=base->next) { | |
1256 if(base->object->type!=OB_LAMP) | |
1257 continue; | |
1258 | |
1259 if(!(base->lay & lay) || !(base->lay & ob->lay)) | |
1260 continue; | |
1261 | |
1262 la= base->object->data; | |
1263 ················ | |
1264 /* setup lamp transform */ | |
1265 glPushMatrix(); | |
1266 glLoadMatrixf((float *)viewmat); | |
1267 ················ | |
1268 where_is_object_simul(scene, base->object); | |
1269 ················ | |
1270 if(la->type==LA_SUN) { | |
1271 /* sun lamp */ | |
1272 copy_v3_v3(direction, base->object->obmat[2]); | |
1273 direction[3]= 0.0; | |
1274 | |
1275 glLightfv(GL_LIGHT0+count, GL_POSITION, direction);· | |
1276 } | |
1277 else { | |
1278 /* other lamps with attenuation */ | |
1279 copy_v3_v3(position, base->object->obmat[3]); | |
1280 position[3]= 1.0f; | |
1281 | |
1282 glLightfv(GL_LIGHT0+count, GL_POSITION, position);· | |
1283 glLightf(GL_LIGHT0+count, GL_CONSTANT_ATTENUATION, 1.0); | |
1284 glLightf(GL_LIGHT0+count, GL_LINEAR_ATTENUATION, la->att
1/la->dist); | |
1285 glLightf(GL_LIGHT0+count, GL_QUADRATIC_ATTENUATION, la->
att2/(la->dist*la->dist)); | |
1286 ························ | |
1287 if(la->type==LA_SPOT) { | |
1288 /* spot lamp */ | |
1289 negate_v3_v3(direction, base->object->obmat[2]); | |
1290 glLightfv(GL_LIGHT0+count, GL_SPOT_DIRECTION, di
rection); | |
1291 glLightf(GL_LIGHT0+count, GL_SPOT_CUTOFF, la->sp
otsize/2.0); | |
1292 glLightf(GL_LIGHT0+count, GL_SPOT_EXPONENT, 128.
0*la->spotblend); | |
1293 } | |
1294 else | |
1295 glLightf(GL_LIGHT0+count, GL_SPOT_CUTOFF, 180.0)
; | |
1296 } | |
1297 ················ | |
1298 /* setup energy */ | |
1299 mul_v3_v3fl(energy, &la->r, la->energy); | |
1300 energy[3]= 1.0; | |
1301 | |
1302 glLightfv(GL_LIGHT0+count, GL_DIFFUSE, energy);· | |
1303 glLightfv(GL_LIGHT0+count, GL_SPECULAR, energy); | |
1304 glEnable(GL_LIGHT0+count); | |
1305 ················ | |
1306 glPopMatrix();·································· | |
1307 ················ | |
1308 count++; | |
1309 if(count==8) | |
1310 break; | |
1311 } | |
1312 | |
1313 return count; | |
1314 } | |
1315 | |
1316 /* Default OpenGL State */ | |
1317 | |
1318 void GPU_state_init(void) | |
1319 { | |
1320 /* also called when doing opengl rendering and in the game engine */ | |
1321 float mat_ambient[] = { 0.0, 0.0, 0.0, 0.0 }; | |
1322 float mat_specular[] = { 0.5, 0.5, 0.5, 1.0 }; | |
1323 int a, x, y; | |
1324 GLubyte pat[32*32]; | |
1325 const GLubyte *patc= pat; | |
1326 ········ | |
1327 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient); | |
1328 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_specular); | |
1329 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular); | |
1330 glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 35); | |
1331 | |
1332 GPU_default_lights(); | |
1333 ········ | |
1334 glDepthFunc(GL_LEQUAL); | |
1335 /* scaling matrices */ | |
1336 glEnable(GL_NORMALIZE); | |
1337 | |
1338 glShadeModel(GL_FLAT); | |
1339 | |
1340 glDisable(GL_ALPHA_TEST); | |
1341 glDisable(GL_BLEND); | |
1342 glDisable(GL_DEPTH_TEST); | |
1343 glDisable(GL_FOG); | |
1344 glDisable(GL_LIGHTING); | |
1345 glDisable(GL_LOGIC_OP); | |
1346 glDisable(GL_STENCIL_TEST); | |
1347 glDisable(GL_TEXTURE_1D); | |
1348 glDisable(GL_TEXTURE_2D); | |
1349 | |
1350 /* default disabled, enable should be local per function */ | |
1351 glDisableClientState(GL_VERTEX_ARRAY); | |
1352 glDisableClientState(GL_NORMAL_ARRAY); | |
1353 glDisableClientState(GL_COLOR_ARRAY); | |
1354 glDisableClientState(GL_TEXTURE_COORD_ARRAY); | |
1355 ········ | |
1356 glPixelTransferi(GL_MAP_COLOR, GL_FALSE); | |
1357 glPixelTransferi(GL_RED_SCALE, 1); | |
1358 glPixelTransferi(GL_RED_BIAS, 0); | |
1359 glPixelTransferi(GL_GREEN_SCALE, 1); | |
1360 glPixelTransferi(GL_GREEN_BIAS, 0); | |
1361 glPixelTransferi(GL_BLUE_SCALE, 1); | |
1362 glPixelTransferi(GL_BLUE_BIAS, 0); | |
1363 glPixelTransferi(GL_ALPHA_SCALE, 1); | |
1364 glPixelTransferi(GL_ALPHA_BIAS, 0); | |
1365 ········ | |
1366 glPixelTransferi(GL_DEPTH_BIAS, 0); | |
1367 glPixelTransferi(GL_DEPTH_SCALE, 1); | |
1368 glDepthRange(0.0, 1.0); | |
1369 ········ | |
1370 a= 0; | |
1371 for(x=0; x<32; x++) { | |
1372 for(y=0; y<4; y++) { | |
1373 if( (x) & 1) pat[a++]= 0x88; | |
1374 else pat[a++]= 0x22; | |
1375 } | |
1376 } | |
1377 ········ | |
1378 glPolygonStipple(patc); | |
1379 | |
1380 glMatrixMode(GL_TEXTURE); | |
1381 glLoadIdentity(); | |
1382 glMatrixMode(GL_MODELVIEW); | |
1383 | |
1384 glFrontFace(GL_CCW); | |
1385 glCullFace(GL_BACK); | |
1386 glDisable(GL_CULL_FACE); | |
1387 | |
1388 /* calling this makes drawing very slow when AA is not set up in ghost | |
1389 on Linux/NVIDIA. | |
1390 glDisable(GL_MULTISAMPLE); */ | |
1391 } | |
1392 | |
1393 /* debugging aid */ | |
1394 static void gpu_get_print(const char *name, GLenum type) | |
1395 { | |
1396 float value[16]; | |
1397 int a; | |
1398 ········ | |
1399 memset(value, 0, sizeof(value)); | |
1400 glGetFloatv(type, value); | |
1401 | |
1402 printf("%s: ", name); | |
1403 for(a=0; a<16; a++) | |
1404 printf("%.2f ", value[a]); | |
1405 printf("\n"); | |
1406 } | |
1407 | |
1408 void GPU_state_print(void) | |
1409 { | |
1410 gpu_get_print("GL_ACCUM_ALPHA_BITS", GL_ACCUM_ALPHA_BITS); | |
1411 gpu_get_print("GL_ACCUM_BLUE_BITS", GL_ACCUM_BLUE_BITS); | |
1412 gpu_get_print("GL_ACCUM_CLEAR_VALUE", GL_ACCUM_CLEAR_VALUE); | |
1413 gpu_get_print("GL_ACCUM_GREEN_BITS", GL_ACCUM_GREEN_BITS); | |
1414 gpu_get_print("GL_ACCUM_RED_BITS", GL_ACCUM_RED_BITS); | |
1415 gpu_get_print("GL_ACTIVE_TEXTURE", GL_ACTIVE_TEXTURE); | |
1416 gpu_get_print("GL_ALIASED_POINT_SIZE_RANGE", GL_ALIASED_POINT_SIZE_RANGE
); | |
1417 gpu_get_print("GL_ALIASED_LINE_WIDTH_RANGE", GL_ALIASED_LINE_WIDTH_RANGE
); | |
1418 gpu_get_print("GL_ALPHA_BIAS", GL_ALPHA_BIAS); | |
1419 gpu_get_print("GL_ALPHA_BITS", GL_ALPHA_BITS); | |
1420 gpu_get_print("GL_ALPHA_SCALE", GL_ALPHA_SCALE); | |
1421 gpu_get_print("GL_ALPHA_TEST", GL_ALPHA_TEST); | |
1422 gpu_get_print("GL_ALPHA_TEST_FUNC", GL_ALPHA_TEST_FUNC); | |
1423 gpu_get_print("GL_ALPHA_TEST_REF", GL_ALPHA_TEST_REF); | |
1424 gpu_get_print("GL_ARRAY_BUFFER_BINDING", GL_ARRAY_BUFFER_BINDING); | |
1425 gpu_get_print("GL_ATTRIB_STACK_DEPTH", GL_ATTRIB_STACK_DEPTH); | |
1426 gpu_get_print("GL_AUTO_NORMAL", GL_AUTO_NORMAL); | |
1427 gpu_get_print("GL_AUX_BUFFERS", GL_AUX_BUFFERS); | |
1428 gpu_get_print("GL_BLEND", GL_BLEND); | |
1429 gpu_get_print("GL_BLEND_COLOR", GL_BLEND_COLOR); | |
1430 gpu_get_print("GL_BLEND_DST_ALPHA", GL_BLEND_DST_ALPHA); | |
1431 gpu_get_print("GL_BLEND_DST_RGB", GL_BLEND_DST_RGB); | |
1432 gpu_get_print("GL_BLEND_EQUATION_RGB", GL_BLEND_EQUATION_RGB); | |
1433 gpu_get_print("GL_BLEND_EQUATION_ALPHA", GL_BLEND_EQUATION_ALPHA); | |
1434 gpu_get_print("GL_BLEND_SRC_ALPHA", GL_BLEND_SRC_ALPHA); | |
1435 gpu_get_print("GL_BLEND_SRC_RGB", GL_BLEND_SRC_RGB); | |
1436 gpu_get_print("GL_BLUE_BIAS", GL_BLUE_BIAS); | |
1437 gpu_get_print("GL_BLUE_BITS", GL_BLUE_BITS); | |
1438 gpu_get_print("GL_BLUE_SCALE", GL_BLUE_SCALE); | |
1439 gpu_get_print("GL_CLIENT_ACTIVE_TEXTURE", GL_CLIENT_ACTIVE_TEXTURE); | |
1440 gpu_get_print("GL_CLIENT_ATTRIB_STACK_DEPTH", GL_CLIENT_ATTRIB_STACK_DEP
TH); | |
1441 gpu_get_print("GL_CLIP_PLANE0", GL_CLIP_PLANE0); | |
1442 gpu_get_print("GL_COLOR_ARRAY", GL_COLOR_ARRAY); | |
1443 gpu_get_print("GL_COLOR_ARRAY_BUFFER_BINDING", GL_COLOR_ARRAY_BUFFER_BIN
DING); | |
1444 gpu_get_print("GL_COLOR_ARRAY_SIZE", GL_COLOR_ARRAY_SIZE); | |
1445 gpu_get_print("GL_COLOR_ARRAY_STRIDE", GL_COLOR_ARRAY_STRIDE); | |
1446 gpu_get_print("GL_COLOR_ARRAY_TYPE", GL_COLOR_ARRAY_TYPE); | |
1447 gpu_get_print("GL_COLOR_CLEAR_VALUE", GL_COLOR_CLEAR_VALUE); | |
1448 gpu_get_print("GL_COLOR_LOGIC_OP", GL_COLOR_LOGIC_OP); | |
1449 gpu_get_print("GL_COLOR_MATERIAL", GL_COLOR_MATERIAL); | |
1450 gpu_get_print("GL_COLOR_MATERIAL_FACE", GL_COLOR_MATERIAL_FACE); | |
1451 gpu_get_print("GL_COLOR_MATERIAL_PARAMETER", GL_COLOR_MATERIAL_PARAMETER
); | |
1452 gpu_get_print("GL_COLOR_MATRIX", GL_COLOR_MATRIX); | |
1453 gpu_get_print("GL_COLOR_MATRIX_STACK_DEPTH", GL_COLOR_MATRIX_STACK_DEPTH
); | |
1454 gpu_get_print("GL_COLOR_SUM", GL_COLOR_SUM); | |
1455 gpu_get_print("GL_COLOR_TABLE", GL_COLOR_TABLE); | |
1456 gpu_get_print("GL_COLOR_WRITEMASK", GL_COLOR_WRITEMASK); | |
1457 gpu_get_print("GL_COMPRESSED_TEXTURE_FORMATS", GL_COMPRESSED_TEXTURE_FOR
MATS); | |
1458 gpu_get_print("GL_CONVOLUTION_1D", GL_CONVOLUTION_1D); | |
1459 gpu_get_print("GL_CONVOLUTION_2D", GL_CONVOLUTION_2D); | |
1460 gpu_get_print("GL_CULL_FACE", GL_CULL_FACE); | |
1461 gpu_get_print("GL_CULL_FACE_MODE", GL_CULL_FACE_MODE); | |
1462 gpu_get_print("GL_CURRENT_COLOR", GL_CURRENT_COLOR); | |
1463 gpu_get_print("GL_CURRENT_FOG_COORD", GL_CURRENT_FOG_COORD); | |
1464 gpu_get_print("GL_CURRENT_INDEX", GL_CURRENT_INDEX); | |
1465 gpu_get_print("GL_CURRENT_NORMAL", GL_CURRENT_NORMAL); | |
1466 gpu_get_print("GL_CURRENT_PROGRAM", GL_CURRENT_PROGRAM); | |
1467 gpu_get_print("GL_CURRENT_RASTER_COLOR", GL_CURRENT_RASTER_COLOR); | |
1468 gpu_get_print("GL_CURRENT_RASTER_DISTANCE", GL_CURRENT_RASTER_DISTANCE); | |
1469 gpu_get_print("GL_CURRENT_RASTER_INDEX", GL_CURRENT_RASTER_INDEX); | |
1470 gpu_get_print("GL_CURRENT_RASTER_POSITION", GL_CURRENT_RASTER_POSITION); | |
1471 gpu_get_print("GL_CURRENT_RASTER_POSITION_VALID", GL_CURRENT_RASTER_POSI
TION_VALID); | |
1472 gpu_get_print("GL_CURRENT_RASTER_SECONDARY_COLOR", GL_CURRENT_RASTER_SEC
ONDARY_COLOR); | |
1473 gpu_get_print("GL_CURRENT_RASTER_TEXTURE_COORDS", GL_CURRENT_RASTER_TEXT
URE_COORDS); | |
1474 gpu_get_print("GL_CURRENT_SECONDARY_COLOR", GL_CURRENT_SECONDARY_COLOR); | |
1475 gpu_get_print("GL_CURRENT_TEXTURE_COORDS", GL_CURRENT_TEXTURE_COORDS); | |
1476 gpu_get_print("GL_DEPTH_BIAS", GL_DEPTH_BIAS); | |
1477 gpu_get_print("GL_DEPTH_BITS", GL_DEPTH_BITS); | |
1478 gpu_get_print("GL_DEPTH_CLEAR_VALUE", GL_DEPTH_CLEAR_VALUE); | |
1479 gpu_get_print("GL_DEPTH_FUNC", GL_DEPTH_FUNC); | |
1480 gpu_get_print("GL_DEPTH_RANGE", GL_DEPTH_RANGE); | |
1481 gpu_get_print("GL_DEPTH_SCALE", GL_DEPTH_SCALE); | |
1482 gpu_get_print("GL_DEPTH_TEST", GL_DEPTH_TEST); | |
1483 gpu_get_print("GL_DEPTH_WRITEMASK", GL_DEPTH_WRITEMASK); | |
1484 gpu_get_print("GL_DITHER", GL_DITHER); | |
1485 gpu_get_print("GL_DOUBLEBUFFER", GL_DOUBLEBUFFER); | |
1486 gpu_get_print("GL_DRAW_BUFFER", GL_DRAW_BUFFER); | |
1487 gpu_get_print("GL_DRAW_BUFFER0", GL_DRAW_BUFFER0); | |
1488 gpu_get_print("GL_EDGE_FLAG", GL_EDGE_FLAG); | |
1489 gpu_get_print("GL_EDGE_FLAG_ARRAY", GL_EDGE_FLAG_ARRAY); | |
1490 gpu_get_print("GL_EDGE_FLAG_ARRAY_BUFFER_BINDING", GL_EDGE_FLAG_ARRAY_BU
FFER_BINDING); | |
1491 gpu_get_print("GL_EDGE_FLAG_ARRAY_STRIDE", GL_EDGE_FLAG_ARRAY_STRIDE); | |
1492 gpu_get_print("GL_ELEMENT_ARRAY_BUFFER_BINDING", GL_ELEMENT_ARRAY_BUFFER
_BINDING); | |
1493 gpu_get_print("GL_FEEDBACK_BUFFER_SIZE", GL_FEEDBACK_BUFFER_SIZE); | |
1494 gpu_get_print("GL_FEEDBACK_BUFFER_TYPE", GL_FEEDBACK_BUFFER_TYPE); | |
1495 gpu_get_print("GL_FOG", GL_FOG); | |
1496 gpu_get_print("GL_FOG_COORD_ARRAY", GL_FOG_COORD_ARRAY); | |
1497 gpu_get_print("GL_FOG_COORD_ARRAY_BUFFER_BINDING", GL_FOG_COORD_ARRAY_BU
FFER_BINDING); | |
1498 gpu_get_print("GL_FOG_COORD_ARRAY_STRIDE", GL_FOG_COORD_ARRAY_STRIDE); | |
1499 gpu_get_print("GL_FOG_COORD_ARRAY_TYPE", GL_FOG_COORD_ARRAY_TYPE); | |
1500 gpu_get_print("GL_FOG_COORD_SRC", GL_FOG_COORD_SRC); | |
1501 gpu_get_print("GL_FOG_COLOR", GL_FOG_COLOR); | |
1502 gpu_get_print("GL_FOG_DENSITY", GL_FOG_DENSITY); | |
1503 gpu_get_print("GL_FOG_END", GL_FOG_END); | |
1504 gpu_get_print("GL_FOG_HINT", GL_FOG_HINT); | |
1505 gpu_get_print("GL_FOG_INDEX", GL_FOG_INDEX); | |
1506 gpu_get_print("GL_FOG_MODE", GL_FOG_MODE); | |
1507 gpu_get_print("GL_FOG_START", GL_FOG_START); | |
1508 gpu_get_print("GL_FRAGMENT_SHADER_DERIVATIVE_HINT", GL_FRAGMENT_SHADER_D
ERIVATIVE_HINT); | |
1509 gpu_get_print("GL_FRONT_FACE", GL_FRONT_FACE); | |
1510 gpu_get_print("GL_GENERATE_MIPMAP_HINT", GL_GENERATE_MIPMAP_HINT); | |
1511 gpu_get_print("GL_GREEN_BIAS", GL_GREEN_BIAS); | |
1512 gpu_get_print("GL_GREEN_BITS", GL_GREEN_BITS); | |
1513 gpu_get_print("GL_GREEN_SCALE", GL_GREEN_SCALE); | |
1514 gpu_get_print("GL_HISTOGRAM", GL_HISTOGRAM); | |
1515 gpu_get_print("GL_INDEX_ARRAY", GL_INDEX_ARRAY); | |
1516 gpu_get_print("GL_INDEX_ARRAY_BUFFER_BINDING", GL_INDEX_ARRAY_BUFFER_BIN
DING); | |
1517 gpu_get_print("GL_INDEX_ARRAY_STRIDE", GL_INDEX_ARRAY_STRIDE); | |
1518 gpu_get_print("GL_INDEX_ARRAY_TYPE", GL_INDEX_ARRAY_TYPE); | |
1519 gpu_get_print("GL_INDEX_BITS", GL_INDEX_BITS); | |
1520 gpu_get_print("GL_INDEX_CLEAR_VALUE", GL_INDEX_CLEAR_VALUE); | |
1521 gpu_get_print("GL_INDEX_LOGIC_OP", GL_INDEX_LOGIC_OP); | |
1522 gpu_get_print("GL_INDEX_MODE", GL_INDEX_MODE); | |
1523 gpu_get_print("GL_INDEX_OFFSET", GL_INDEX_OFFSET); | |
1524 gpu_get_print("GL_INDEX_SHIFT", GL_INDEX_SHIFT); | |
1525 gpu_get_print("GL_INDEX_WRITEMASK", GL_INDEX_WRITEMASK); | |
1526 gpu_get_print("GL_LIGHT0", GL_LIGHT0); | |
1527 gpu_get_print("GL_LIGHTING", GL_LIGHTING); | |
1528 gpu_get_print("GL_LIGHT_MODEL_AMBIENT", GL_LIGHT_MODEL_AMBIENT); | |
1529 gpu_get_print("GL_LIGHT_MODEL_COLOR_CONTROL", GL_LIGHT_MODEL_COLOR_CONTR
OL); | |
1530 gpu_get_print("GL_LIGHT_MODEL_LOCAL_VIEWER", GL_LIGHT_MODEL_LOCAL_VIEWER
); | |
1531 gpu_get_print("GL_LIGHT_MODEL_TWO_SIDE", GL_LIGHT_MODEL_TWO_SIDE); | |
1532 gpu_get_print("GL_LINE_SMOOTH", GL_LINE_SMOOTH); | |
1533 gpu_get_print("GL_LINE_SMOOTH_HINT", GL_LINE_SMOOTH_HINT); | |
1534 gpu_get_print("GL_LINE_STIPPLE", GL_LINE_STIPPLE); | |
1535 gpu_get_print("GL_LINE_STIPPLE_PATTERN", GL_LINE_STIPPLE_PATTERN); | |
1536 gpu_get_print("GL_LINE_STIPPLE_REPEAT", GL_LINE_STIPPLE_REPEAT); | |
1537 gpu_get_print("GL_LINE_WIDTH", GL_LINE_WIDTH); | |
1538 gpu_get_print("GL_LINE_WIDTH_GRANULARITY", GL_LINE_WIDTH_GRANULARITY); | |
1539 gpu_get_print("GL_LINE_WIDTH_RANGE", GL_LINE_WIDTH_RANGE); | |
1540 gpu_get_print("GL_LIST_BASE", GL_LIST_BASE); | |
1541 gpu_get_print("GL_LIST_INDEX", GL_LIST_INDEX); | |
1542 gpu_get_print("GL_LIST_MODE", GL_LIST_MODE); | |
1543 gpu_get_print("GL_LOGIC_OP_MODE", GL_LOGIC_OP_MODE); | |
1544 gpu_get_print("GL_MAP1_COLOR_4", GL_MAP1_COLOR_4); | |
1545 gpu_get_print("GL_MAP1_GRID_DOMAIN", GL_MAP1_GRID_DOMAIN); | |
1546 gpu_get_print("GL_MAP1_GRID_SEGMENTS", GL_MAP1_GRID_SEGMENTS); | |
1547 gpu_get_print("GL_MAP1_INDEX", GL_MAP1_INDEX); | |
1548 gpu_get_print("GL_MAP1_NORMAL", GL_MAP1_NORMAL); | |
1549 gpu_get_print("GL_MAP1_TEXTURE_COORD_1", GL_MAP1_TEXTURE_COORD_1); | |
1550 gpu_get_print("GL_MAP1_TEXTURE_COORD_2", GL_MAP1_TEXTURE_COORD_2); | |
1551 gpu_get_print("GL_MAP1_TEXTURE_COORD_3", GL_MAP1_TEXTURE_COORD_3); | |
1552 gpu_get_print("GL_MAP1_TEXTURE_COORD_4", GL_MAP1_TEXTURE_COORD_4); | |
1553 gpu_get_print("GL_MAP1_VERTEX_3", GL_MAP1_VERTEX_3); | |
1554 gpu_get_print("GL_MAP1_VERTEX_4", GL_MAP1_VERTEX_4); | |
1555 gpu_get_print("GL_MAP2_COLOR_4", GL_MAP2_COLOR_4); | |
1556 gpu_get_print("GL_MAP2_GRID_DOMAIN", GL_MAP2_GRID_DOMAIN); | |
1557 gpu_get_print("GL_MAP2_GRID_SEGMENTS", GL_MAP2_GRID_SEGMENTS); | |
1558 gpu_get_print("GL_MAP2_INDEX", GL_MAP2_INDEX); | |
1559 gpu_get_print("GL_MAP2_NORMAL", GL_MAP2_NORMAL); | |
1560 gpu_get_print("GL_MAP2_TEXTURE_COORD_1", GL_MAP2_TEXTURE_COORD_1); | |
1561 gpu_get_print("GL_MAP2_TEXTURE_COORD_2", GL_MAP2_TEXTURE_COORD_2); | |
1562 gpu_get_print("GL_MAP2_TEXTURE_COORD_3", GL_MAP2_TEXTURE_COORD_3); | |
1563 gpu_get_print("GL_MAP2_TEXTURE_COORD_4", GL_MAP2_TEXTURE_COORD_4); | |
1564 gpu_get_print("GL_MAP2_VERTEX_3", GL_MAP2_VERTEX_3); | |
1565 gpu_get_print("GL_MAP2_VERTEX_4", GL_MAP2_VERTEX_4); | |
1566 gpu_get_print("GL_MAP_COLOR", GL_MAP_COLOR); | |
1567 gpu_get_print("GL_MAP_STENCIL", GL_MAP_STENCIL); | |
1568 gpu_get_print("GL_MATRIX_MODE", GL_MATRIX_MODE); | |
1569 gpu_get_print("GL_MAX_3D_TEXTURE_SIZE", GL_MAX_3D_TEXTURE_SIZE); | |
1570 gpu_get_print("GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", GL_MAX_CLIENT_ATTRIB_S
TACK_DEPTH); | |
1571 gpu_get_print("GL_MAX_ATTRIB_STACK_DEPTH", GL_MAX_ATTRIB_STACK_DEPTH); | |
1572 gpu_get_print("GL_MAX_CLIP_PLANES", GL_MAX_CLIP_PLANES); | |
1573 gpu_get_print("GL_MAX_COLOR_MATRIX_STACK_DEPTH", GL_MAX_COLOR_MATRIX_STA
CK_DEPTH); | |
1574 gpu_get_print("GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS", GL_MAX_COMBINED_TEX
TURE_IMAGE_UNITS); | |
1575 gpu_get_print("GL_MAX_CUBE_MAP_TEXTURE_SIZE", GL_MAX_CUBE_MAP_TEXTURE_SI
ZE); | |
1576 gpu_get_print("GL_MAX_DRAW_BUFFERS", GL_MAX_DRAW_BUFFERS); | |
1577 gpu_get_print("GL_MAX_ELEMENTS_INDICES", GL_MAX_ELEMENTS_INDICES); | |
1578 gpu_get_print("GL_MAX_ELEMENTS_VERTICES", GL_MAX_ELEMENTS_VERTICES); | |
1579 gpu_get_print("GL_MAX_EVAL_ORDER", GL_MAX_EVAL_ORDER); | |
1580 gpu_get_print("GL_MAX_FRAGMENT_UNIFORM_COMPONENTS", GL_MAX_FRAGMENT_UNIF
ORM_COMPONENTS); | |
1581 gpu_get_print("GL_MAX_LIGHTS", GL_MAX_LIGHTS); | |
1582 gpu_get_print("GL_MAX_LIST_NESTING", GL_MAX_LIST_NESTING); | |
1583 gpu_get_print("GL_MAX_MODELVIEW_STACK_DEPTH", GL_MAX_MODELVIEW_STACK_DEP
TH); | |
1584 gpu_get_print("GL_MAX_NAME_STACK_DEPTH", GL_MAX_NAME_STACK_DEPTH); | |
1585 gpu_get_print("GL_MAX_PIXEL_MAP_TABLE", GL_MAX_PIXEL_MAP_TABLE); | |
1586 gpu_get_print("GL_MAX_PROJECTION_STACK_DEPTH", GL_MAX_PROJECTION_STACK_D
EPTH); | |
1587 gpu_get_print("GL_MAX_TEXTURE_COORDS", GL_MAX_TEXTURE_COORDS); | |
1588 gpu_get_print("GL_MAX_TEXTURE_IMAGE_UNITS", GL_MAX_TEXTURE_IMAGE_UNITS); | |
1589 gpu_get_print("GL_MAX_TEXTURE_LOD_BIAS", GL_MAX_TEXTURE_LOD_BIAS); | |
1590 gpu_get_print("GL_MAX_TEXTURE_SIZE", GL_MAX_TEXTURE_SIZE); | |
1591 gpu_get_print("GL_MAX_TEXTURE_STACK_DEPTH", GL_MAX_TEXTURE_STACK_DEPTH); | |
1592 gpu_get_print("GL_MAX_TEXTURE_UNITS", GL_MAX_TEXTURE_UNITS); | |
1593 gpu_get_print("GL_MAX_VARYING_FLOATS", GL_MAX_VARYING_FLOATS); | |
1594 gpu_get_print("GL_MAX_VERTEX_ATTRIBS", GL_MAX_VERTEX_ATTRIBS); | |
1595 gpu_get_print("GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS", GL_MAX_VERTEX_TEXTURE
_IMAGE_UNITS); | |
1596 gpu_get_print("GL_MAX_VERTEX_UNIFORM_COMPONENTS", GL_MAX_VERTEX_UNIFORM_
COMPONENTS); | |
1597 gpu_get_print("GL_MAX_VIEWPORT_DIMS", GL_MAX_VIEWPORT_DIMS); | |
1598 gpu_get_print("GL_MINMAX", GL_MINMAX); | |
1599 gpu_get_print("GL_MODELVIEW_MATRIX", GL_MODELVIEW_MATRIX); | |
1600 gpu_get_print("GL_MODELVIEW_STACK_DEPTH", GL_MODELVIEW_STACK_DEPTH); | |
1601 gpu_get_print("GL_NAME_STACK_DEPTH", GL_NAME_STACK_DEPTH); | |
1602 gpu_get_print("GL_NORMAL_ARRAY", GL_NORMAL_ARRAY); | |
1603 gpu_get_print("GL_NORMAL_ARRAY_BUFFER_BINDING", GL_NORMAL_ARRAY_BUFFER_B
INDING); | |
1604 gpu_get_print("GL_NORMAL_ARRAY_STRIDE", GL_NORMAL_ARRAY_STRIDE); | |
1605 gpu_get_print("GL_NORMAL_ARRAY_TYPE", GL_NORMAL_ARRAY_TYPE); | |
1606 gpu_get_print("GL_NORMALIZE", GL_NORMALIZE); | |
1607 gpu_get_print("GL_NUM_COMPRESSED_TEXTURE_FORMATS", GL_NUM_COMPRESSED_TEX
TURE_FORMATS); | |
1608 gpu_get_print("GL_PACK_ALIGNMENT", GL_PACK_ALIGNMENT); | |
1609 gpu_get_print("GL_PACK_IMAGE_HEIGHT", GL_PACK_IMAGE_HEIGHT); | |
1610 gpu_get_print("GL_PACK_LSB_FIRST", GL_PACK_LSB_FIRST); | |
1611 gpu_get_print("GL_PACK_ROW_LENGTH", GL_PACK_ROW_LENGTH); | |
1612 gpu_get_print("GL_PACK_SKIP_IMAGES", GL_PACK_SKIP_IMAGES); | |
1613 gpu_get_print("GL_PACK_SKIP_PIXELS", GL_PACK_SKIP_PIXELS); | |
1614 gpu_get_print("GL_PACK_SKIP_ROWS", GL_PACK_SKIP_ROWS); | |
1615 gpu_get_print("GL_PACK_SWAP_BYTES", GL_PACK_SWAP_BYTES); | |
1616 gpu_get_print("GL_PERSPECTIVE_CORRECTION_HINT", GL_PERSPECTIVE_CORRECTIO
N_HINT); | |
1617 gpu_get_print("GL_PIXEL_MAP_A_TO_A_SIZE", GL_PIXEL_MAP_A_TO_A_SIZE); | |
1618 gpu_get_print("GL_PIXEL_MAP_B_TO_B_SIZE", GL_PIXEL_MAP_B_TO_B_SIZE); | |
1619 gpu_get_print("GL_PIXEL_MAP_G_TO_G_SIZE", GL_PIXEL_MAP_G_TO_G_SIZE); | |
1620 gpu_get_print("GL_PIXEL_MAP_I_TO_A_SIZE", GL_PIXEL_MAP_I_TO_A_SIZE); | |
1621 gpu_get_print("GL_PIXEL_MAP_I_TO_B_SIZE", GL_PIXEL_MAP_I_TO_B_SIZE); | |
1622 gpu_get_print("GL_PIXEL_MAP_I_TO_G_SIZE", GL_PIXEL_MAP_I_TO_G_SIZE); | |
1623 gpu_get_print("GL_PIXEL_MAP_I_TO_I_SIZE", GL_PIXEL_MAP_I_TO_I_SIZE); | |
1624 gpu_get_print("GL_PIXEL_MAP_I_TO_R_SIZE", GL_PIXEL_MAP_I_TO_R_SIZE); | |
1625 gpu_get_print("GL_PIXEL_MAP_R_TO_R_SIZE", GL_PIXEL_MAP_R_TO_R_SIZE); | |
1626 gpu_get_print("GL_PIXEL_MAP_S_TO_S_SIZE", GL_PIXEL_MAP_S_TO_S_SIZE); | |
1627 gpu_get_print("GL_PIXEL_PACK_BUFFER_BINDING", GL_PIXEL_PACK_BUFFER_BINDI
NG); | |
1628 gpu_get_print("GL_PIXEL_UNPACK_BUFFER_BINDING", GL_PIXEL_UNPACK_BUFFER_B
INDING); | |
1629 gpu_get_print("GL_POINT_DISTANCE_ATTENUATION", GL_POINT_DISTANCE_ATTENUA
TION); | |
1630 gpu_get_print("GL_POINT_FADE_THRESHOLD_SIZE", GL_POINT_FADE_THRESHOLD_SI
ZE); | |
1631 gpu_get_print("GL_POINT_SIZE", GL_POINT_SIZE); | |
1632 gpu_get_print("GL_POINT_SIZE_GRANULARITY", GL_POINT_SIZE_GRANULARITY); | |
1633 gpu_get_print("GL_POINT_SIZE_MAX", GL_POINT_SIZE_MAX); | |
1634 gpu_get_print("GL_POINT_SIZE_MIN", GL_POINT_SIZE_MIN); | |
1635 gpu_get_print("GL_POINT_SIZE_RANGE", GL_POINT_SIZE_RANGE); | |
1636 gpu_get_print("GL_POINT_SMOOTH", GL_POINT_SMOOTH); | |
1637 gpu_get_print("GL_POINT_SMOOTH_HINT", GL_POINT_SMOOTH_HINT); | |
1638 gpu_get_print("GL_POINT_SPRITE", GL_POINT_SPRITE); | |
1639 gpu_get_print("GL_POLYGON_MODE", GL_POLYGON_MODE); | |
1640 gpu_get_print("GL_POLYGON_OFFSET_FACTOR", GL_POLYGON_OFFSET_FACTOR); | |
1641 gpu_get_print("GL_POLYGON_OFFSET_UNITS", GL_POLYGON_OFFSET_UNITS); | |
1642 gpu_get_print("GL_POLYGON_OFFSET_FILL", GL_POLYGON_OFFSET_FILL); | |
1643 gpu_get_print("GL_POLYGON_OFFSET_LINE", GL_POLYGON_OFFSET_LINE); | |
1644 gpu_get_print("GL_POLYGON_OFFSET_POINT", GL_POLYGON_OFFSET_POINT); | |
1645 gpu_get_print("GL_POLYGON_SMOOTH", GL_POLYGON_SMOOTH); | |
1646 gpu_get_print("GL_POLYGON_SMOOTH_HINT", GL_POLYGON_SMOOTH_HINT); | |
1647 gpu_get_print("GL_POLYGON_STIPPLE", GL_POLYGON_STIPPLE); | |
1648 gpu_get_print("GL_POST_COLOR_MATRIX_COLOR_TABLE", GL_POST_COLOR_MATRIX_C
OLOR_TABLE); | |
1649 gpu_get_print("GL_POST_COLOR_MATRIX_RED_BIAS", GL_POST_COLOR_MATRIX_RED_
BIAS); | |
1650 gpu_get_print("GL_POST_COLOR_MATRIX_GREEN_BIAS", GL_POST_COLOR_MATRIX_GR
EEN_BIAS); | |
1651 gpu_get_print("GL_POST_COLOR_MATRIX_BLUE_BIAS", GL_POST_COLOR_MATRIX_BLU
E_BIAS); | |
1652 gpu_get_print("GL_POST_COLOR_MATRIX_ALPHA_BIAS", GL_POST_COLOR_MATRIX_AL
PHA_BIAS); | |
1653 gpu_get_print("GL_POST_COLOR_MATRIX_RED_SCALE", GL_POST_COLOR_MATRIX_RED
_SCALE); | |
1654 gpu_get_print("GL_POST_COLOR_MATRIX_GREEN_SCALE", GL_POST_COLOR_MATRIX_G
REEN_SCALE); | |
1655 gpu_get_print("GL_POST_COLOR_MATRIX_BLUE_SCALE", GL_POST_COLOR_MATRIX_BL
UE_SCALE); | |
1656 gpu_get_print("GL_POST_COLOR_MATRIX_ALPHA_SCALE", GL_POST_COLOR_MATRIX_A
LPHA_SCALE); | |
1657 gpu_get_print("GL_POST_CONVOLUTION_COLOR_TABLE", GL_POST_CONVOLUTION_COL
OR_TABLE); | |
1658 gpu_get_print("GL_POST_CONVOLUTION_RED_BIAS", GL_POST_CONVOLUTION_RED_BI
AS); | |
1659 gpu_get_print("GL_POST_CONVOLUTION_GREEN_BIAS", GL_POST_CONVOLUTION_GREE
N_BIAS); | |
1660 gpu_get_print("GL_POST_CONVOLUTION_BLUE_BIAS", GL_POST_CONVOLUTION_BLUE_
BIAS); | |
1661 gpu_get_print("GL_POST_CONVOLUTION_ALPHA_BIAS", GL_POST_CONVOLUTION_ALPH
A_BIAS); | |
1662 gpu_get_print("GL_POST_CONVOLUTION_RED_SCALE", GL_POST_CONVOLUTION_RED_S
CALE); | |
1663 gpu_get_print("GL_POST_CONVOLUTION_GREEN_SCALE", GL_POST_CONVOLUTION_GRE
EN_SCALE); | |
1664 gpu_get_print("GL_POST_CONVOLUTION_BLUE_SCALE", GL_POST_CONVOLUTION_BLUE
_SCALE); | |
1665 gpu_get_print("GL_POST_CONVOLUTION_ALPHA_SCALE", GL_POST_CONVOLUTION_ALP
HA_SCALE); | |
1666 gpu_get_print("GL_PROJECTION_MATRIX", GL_PROJECTION_MATRIX); | |
1667 gpu_get_print("GL_PROJECTION_STACK_DEPTH", GL_PROJECTION_STACK_DEPTH); | |
1668 gpu_get_print("GL_READ_BUFFER", GL_READ_BUFFER); | |
1669 gpu_get_print("GL_RED_BIAS", GL_RED_BIAS); | |
1670 gpu_get_print("GL_RED_BITS", GL_RED_BITS); | |
1671 gpu_get_print("GL_RED_SCALE", GL_RED_SCALE); | |
1672 gpu_get_print("GL_RENDER_MODE", GL_RENDER_MODE); | |
1673 gpu_get_print("GL_RESCALE_NORMAL", GL_RESCALE_NORMAL); | |
1674 gpu_get_print("GL_RGBA_MODE", GL_RGBA_MODE); | |
1675 gpu_get_print("GL_SAMPLE_BUFFERS", GL_SAMPLE_BUFFERS); | |
1676 gpu_get_print("GL_SAMPLE_COVERAGE_VALUE", GL_SAMPLE_COVERAGE_VALUE); | |
1677 gpu_get_print("GL_SAMPLE_COVERAGE_INVERT", GL_SAMPLE_COVERAGE_INVERT); | |
1678 gpu_get_print("GL_SAMPLES", GL_SAMPLES); | |
1679 gpu_get_print("GL_SCISSOR_BOX", GL_SCISSOR_BOX); | |
1680 gpu_get_print("GL_SCISSOR_TEST", GL_SCISSOR_TEST); | |
1681 gpu_get_print("GL_SECONDARY_COLOR_ARRAY", GL_SECONDARY_COLOR_ARRAY); | |
1682 gpu_get_print("GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING", GL_SECONDARY_CO
LOR_ARRAY_BUFFER_BINDING); | |
1683 gpu_get_print("GL_SECONDARY_COLOR_ARRAY_SIZE", GL_SECONDARY_COLOR_ARRAY_
SIZE); | |
1684 gpu_get_print("GL_SECONDARY_COLOR_ARRAY_STRIDE", GL_SECONDARY_COLOR_ARRA
Y_STRIDE); | |
1685 gpu_get_print("GL_SECONDARY_COLOR_ARRAY_TYPE", GL_SECONDARY_COLOR_ARRAY_
TYPE); | |
1686 gpu_get_print("GL_SELECTION_BUFFER_SIZE", GL_SELECTION_BUFFER_SIZE); | |
1687 gpu_get_print("GL_SEPARABLE_2D", GL_SEPARABLE_2D); | |
1688 gpu_get_print("GL_SHADE_MODEL", GL_SHADE_MODEL); | |
1689 gpu_get_print("GL_SMOOTH_LINE_WIDTH_RANGE", GL_SMOOTH_LINE_WIDTH_RANGE); | |
1690 gpu_get_print("GL_SMOOTH_LINE_WIDTH_GRANULARITY", GL_SMOOTH_LINE_WIDTH_G
RANULARITY); | |
1691 gpu_get_print("GL_SMOOTH_POINT_SIZE_RANGE", GL_SMOOTH_POINT_SIZE_RANGE); | |
1692 gpu_get_print("GL_SMOOTH_POINT_SIZE_GRANULARITY", GL_SMOOTH_POINT_SIZE_G
RANULARITY); | |
1693 gpu_get_print("GL_STENCIL_BACK_FAIL", GL_STENCIL_BACK_FAIL); | |
1694 gpu_get_print("GL_STENCIL_BACK_FUNC", GL_STENCIL_BACK_FUNC); | |
1695 gpu_get_print("GL_STENCIL_BACK_PASS_DEPTH_FAIL", GL_STENCIL_BACK_PASS_DE
PTH_FAIL); | |
1696 gpu_get_print("GL_STENCIL_BACK_PASS_DEPTH_PASS", GL_STENCIL_BACK_PASS_DE
PTH_PASS); | |
1697 gpu_get_print("GL_STENCIL_BACK_REF", GL_STENCIL_BACK_REF); | |
1698 gpu_get_print("GL_STENCIL_BACK_VALUE_MASK", GL_STENCIL_BACK_VALUE_MASK); | |
1699 gpu_get_print("GL_STENCIL_BACK_WRITEMASK", GL_STENCIL_BACK_WRITEMASK); | |
1700 gpu_get_print("GL_STENCIL_BITS", GL_STENCIL_BITS); | |
1701 gpu_get_print("GL_STENCIL_CLEAR_VALUE", GL_STENCIL_CLEAR_VALUE); | |
1702 gpu_get_print("GL_STENCIL_FAIL", GL_STENCIL_FAIL); | |
1703 gpu_get_print("GL_STENCIL_FUNC", GL_STENCIL_FUNC); | |
1704 gpu_get_print("GL_STENCIL_PASS_DEPTH_FAIL", GL_STENCIL_PASS_DEPTH_FAIL); | |
1705 gpu_get_print("GL_STENCIL_PASS_DEPTH_PASS", GL_STENCIL_PASS_DEPTH_PASS); | |
1706 gpu_get_print("GL_STENCIL_REF", GL_STENCIL_REF); | |
1707 gpu_get_print("GL_STENCIL_TEST", GL_STENCIL_TEST); | |
1708 gpu_get_print("GL_STENCIL_VALUE_MASK", GL_STENCIL_VALUE_MASK); | |
1709 gpu_get_print("GL_STENCIL_WRITEMASK", GL_STENCIL_WRITEMASK); | |
1710 gpu_get_print("GL_STEREO", GL_STEREO); | |
1711 gpu_get_print("GL_SUBPIXEL_BITS", GL_SUBPIXEL_BITS); | |
1712 gpu_get_print("GL_TEXTURE_1D", GL_TEXTURE_1D); | |
1713 gpu_get_print("GL_TEXTURE_BINDING_1D", GL_TEXTURE_BINDING_1D); | |
1714 gpu_get_print("GL_TEXTURE_2D", GL_TEXTURE_2D); | |
1715 gpu_get_print("GL_TEXTURE_BINDING_2D", GL_TEXTURE_BINDING_2D); | |
1716 gpu_get_print("GL_TEXTURE_3D", GL_TEXTURE_3D); | |
1717 gpu_get_print("GL_TEXTURE_BINDING_3D", GL_TEXTURE_BINDING_3D); | |
1718 gpu_get_print("GL_TEXTURE_BINDING_CUBE_MAP", GL_TEXTURE_BINDING_CUBE_MAP
); | |
1719 gpu_get_print("GL_TEXTURE_COMPRESSION_HINT", GL_TEXTURE_COMPRESSION_HINT
); | |
1720 gpu_get_print("GL_TEXTURE_COORD_ARRAY", GL_TEXTURE_COORD_ARRAY); | |
1721 gpu_get_print("GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING", GL_TEXTURE_COORD_
ARRAY_BUFFER_BINDING); | |
1722 gpu_get_print("GL_TEXTURE_COORD_ARRAY_SIZE", GL_TEXTURE_COORD_ARRAY_SIZE
); | |
1723 gpu_get_print("GL_TEXTURE_COORD_ARRAY_STRIDE", GL_TEXTURE_COORD_ARRAY_ST
RIDE); | |
1724 gpu_get_print("GL_TEXTURE_COORD_ARRAY_TYPE", GL_TEXTURE_COORD_ARRAY_TYPE
); | |
1725 gpu_get_print("GL_TEXTURE_CUBE_MAP", GL_TEXTURE_CUBE_MAP); | |
1726 gpu_get_print("GL_TEXTURE_GEN_Q", GL_TEXTURE_GEN_Q); | |
1727 gpu_get_print("GL_TEXTURE_GEN_R", GL_TEXTURE_GEN_R); | |
1728 gpu_get_print("GL_TEXTURE_GEN_S", GL_TEXTURE_GEN_S); | |
1729 gpu_get_print("GL_TEXTURE_GEN_T", GL_TEXTURE_GEN_T); | |
1730 gpu_get_print("GL_TEXTURE_MATRIX", GL_TEXTURE_MATRIX); | |
1731 gpu_get_print("GL_TEXTURE_STACK_DEPTH", GL_TEXTURE_STACK_DEPTH); | |
1732 gpu_get_print("GL_TRANSPOSE_COLOR_MATRIX", GL_TRANSPOSE_COLOR_MATRIX); | |
1733 gpu_get_print("GL_TRANSPOSE_MODELVIEW_MATRIX", GL_TRANSPOSE_MODELVIEW_MA
TRIX); | |
1734 gpu_get_print("GL_TRANSPOSE_PROJECTION_MATRIX", GL_TRANSPOSE_PROJECTION_
MATRIX); | |
1735 gpu_get_print("GL_TRANSPOSE_TEXTURE_MATRIX", GL_TRANSPOSE_TEXTURE_MATRIX
); | |
1736 gpu_get_print("GL_UNPACK_ALIGNMENT", GL_UNPACK_ALIGNMENT); | |
1737 gpu_get_print("GL_UNPACK_IMAGE_HEIGHT", GL_UNPACK_IMAGE_HEIGHT); | |
1738 gpu_get_print("GL_UNPACK_LSB_FIRST", GL_UNPACK_LSB_FIRST); | |
1739 gpu_get_print("GL_UNPACK_ROW_LENGTH", GL_UNPACK_ROW_LENGTH); | |
1740 gpu_get_print("GL_UNPACK_SKIP_IMAGES", GL_UNPACK_SKIP_IMAGES); | |
1741 gpu_get_print("GL_UNPACK_SKIP_PIXELS", GL_UNPACK_SKIP_PIXELS); | |
1742 gpu_get_print("GL_UNPACK_SKIP_ROWS", GL_UNPACK_SKIP_ROWS); | |
1743 gpu_get_print("GL_UNPACK_SWAP_BYTES", GL_UNPACK_SWAP_BYTES); | |
1744 gpu_get_print("GL_VERTEX_ARRAY", GL_VERTEX_ARRAY); | |
1745 gpu_get_print("GL_VERTEX_ARRAY_BUFFER_BINDING", GL_VERTEX_ARRAY_BUFFER_B
INDING); | |
1746 gpu_get_print("GL_VERTEX_ARRAY_SIZE", GL_VERTEX_ARRAY_SIZE); | |
1747 gpu_get_print("GL_VERTEX_ARRAY_STRIDE", GL_VERTEX_ARRAY_STRIDE); | |
1748 gpu_get_print("GL_VERTEX_ARRAY_TYPE", GL_VERTEX_ARRAY_TYPE); | |
1749 gpu_get_print("GL_VERTEX_PROGRAM_POINT_SIZE", GL_VERTEX_PROGRAM_POINT_SI
ZE); | |
1750 gpu_get_print("GL_VERTEX_PROGRAM_TWO_SIDE", GL_VERTEX_PROGRAM_TWO_SIDE); | |
1751 gpu_get_print("GL_VIEWPORT", GL_VIEWPORT); | |
1752 gpu_get_print("GL_ZOOM_X", GL_ZOOM_X); | |
1753 gpu_get_print("GL_ZOOM_Y", GL_ZOOM_Y); | |
1754 } | |
1755 | |
LEFT | RIGHT |