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