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