1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
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.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 */
20 // gl_common.c -- OpenGL common routines
21
22 #include "quakedef.h"
23
24 const char *gl_vendor;
25 const char *gl_renderer;
26 const char *gl_version;
27 const char *gl_extensions;
28 qboolean fullsbardraw = false;
29
30
31 float vid_gamma = 1.0;
32
33 qboolean is8bit = false;
34 qboolean isPermedia = false;
35 qboolean gl_mtexable = false;
36 qcardtype gl_cardtype = GENERIC;
37 qboolean gl_var = false; //PENTA: vertex array range is available
38 qboolean gl_texcomp = false; // JP: texture compression available
39
40
41 //void (*qglColorTableEXT) (int, int, int, int, int, const void*);
42 //void (*qgl3DfxSetPaletteEXT) (GLuint *);
43
44 typedef void (*GLCOLORTABLEEXTPFN) (int, int, int, int, int, const void*) ;
45 GLCOLORTABLEEXTPFN qglColorTableEXT;
46
47 typedef void (*GL3DFXSETPALETTEEXTPFN) (GLuint *) ;
48 GL3DFXSETPALETTEEXTPFN qgl3DfxSetPaletteEXT;
49
50
51
52 //int texture_mode = GL_NEAREST;
53 //int texture_mode = GL_NEAREST_MIPMAP_NEAREST;
54 //int texture_mode = GL_NEAREST_MIPMAP_LINEAR;
55 int texture_mode = GL_LINEAR;
56 //int texture_mode = GL_LINEAR_MIPMAP_NEAREST;
57 //int texture_mode = GL_LINEAR_MIPMAP_LINEAR;
58
59 int texture_extension_number = 1;
60
61 float gldepthmin, gldepthmax;
62
63
64 //cvar_t gl_ztrick = {"gl_ztrick","1"}; PENTA: Removed
65
66 // <AWE> Two more extensions. Added already check for paletted texture to gl_vidnt.c.
67 // However any code for anisotropic texture filtering has still to be added to gl_vidnt.c.
68
69 // <AWE> true for "gl_EXT_paletted_texture" [GL_Upload8_EXT].
70 qboolean gl_palettedtex = false;
71
72 // <AWE> true for "GL_EXT_texture_filter_anisotropic".
73 qboolean gl_texturefilteranisotropic = false;
74 // <AWE> anistropic texture level [= 1.0f or max. value].//Penta?? Changed to 2.0 because 1.0 is just isotropic filtering
75 GLfloat gl_textureanisotropylevel = 2.0f;
76 // <AWE> On MacOSX X we use this var to store the state. 0 = off, 1 = on.
77 //cvar_t gl_anisotropic = { "gl_anisotropic", "0", 1 };
78
79
80 unsigned short d_8to16table[256];
81 unsigned d_8to24table[256];
82 unsigned char d_15to8table[65536];
83 unsigned char d_8to8graytable[256];
84
85
86 /*-----------------------------------------------------------------------*/
87
88 /*
89 <AWE> required for GL_Upload8_EXT ():
90 */
91
92 int Q_strncasecmp (char *s1,char *s2,int count);
93
94
VID_SetPalette(unsigned char * palette)95 void VID_SetPalette (unsigned char *palette)
96 {
97 byte *pal;
98 unsigned r,g,b;
99 unsigned a;
100 unsigned v;
101 int r1,g1,b1;
102 int j,k,l,m;
103 unsigned short i;
104 unsigned *table;
105 unsigned char *shade;
106 int dist, bestdist;
107
108 //
109 // 8 8 8 encoding
110 //
111 pal = palette;
112 table = d_8to24table;
113 shade = d_8to8graytable;
114 for (i=0 ; i<256 ; i++)
115 {
116 r = pal[0];
117 g = pal[1];
118 b = pal[2];
119 pal += 3;
120
121 //PENTA: fullbright colors
122 //a = i;//(i >= 192) ? 255 : 0;
123 a = 255;
124 v = (a<<24) + (r<<0) + (g<<8) + (b<<16);
125 *table++ = v;
126 //PENA: Grayscale conversion for bump maps
127 *shade++ = ((r+g+b)/3);
128 }
129 d_8to24table[255] &= 0xffffff; // 255 is transparent
130
131 // JACK: 3D distance calcs - k is last closest, l is the distance.
132 // FIXME: Precalculate this and cache to disk.
133 for (i=0; i < (1<<15); i++) {
134 /* Maps
135 000000000000000
136 000000000011111 = Red = 0x1F
137 000001111100000 = Blue = 0x03E0
138 111110000000000 = Grn = 0x7C00
139 */
140 r = ((i & 0x1F) << 3)+4;
141 g = ((i & 0x03E0) >> 2)+4;
142 b = ((i & 0x7C00) >> 7)+4;
143 pal = (unsigned char *)d_8to24table;
144 for (v=0,k=0,bestdist=10000*10000; v<256; v++,pal+=4) {
145 r1 = (int)r - (int)pal[0];
146 g1 = (int)g - (int)pal[1];
147 b1 = (int)b - (int)pal[2];
148 dist = (r1*r1)+(g1*g1)+(b1*b1);
149 if (dist < bestdist) {
150 k=v;
151 bestdist = dist;
152 }
153 }
154 d_15to8table[i]=k;
155 }
156 }
157
158 //BOOL gammaworks;
159
VID_ShiftPalette(unsigned char * palette)160 void VID_ShiftPalette (unsigned char *palette)
161 {
162 // extern byte ramps[3][256];
163
164 // VID_SetPalette (palette);
165
166 // gammaworks = SetDeviceGammaRamp (maindc, ramps);
167 }
168
169
170
CheckPalettedTexture(void)171 void CheckPalettedTexture (void)
172 {
173 if (strstr (gl_extensions, "GL_EXT_paletted_texture"))
174 {
175 gl_palettedtex = true;
176 Con_Printf ("Found GL_EXT_paletted_texture...\n");
177 }
178 }
179
180 /*
181 BINDTEXFUNCPTR bindTexFunc;
182
183 #define TEXTURE_EXT_STRING "GL_EXT_texture_object"
184
185 /*
186 PENTA; not used anymore
187 */
188 /*
189 void CheckArrayExtensions (void)
190 {
191 char *tmp;
192
193 // check for texture extension
194 tmp = (unsigned char *)glGetString(GL_EXTENSIONS);
195 while (*tmp)
196 {
197 if (strncmp((const char*)tmp, "GL_EXT_vertex_array", strlen("GL_EXT_vertex_array")) == 0)
198 {
199 if (
200 ((SAFE_GET_PROC (glArrayElementEXT, (void *), "glArrayElementEXT")) == NULL) ||
201 ((SAFE_GET_PROC (glColorPointerEXT, (void *), "glColorPointerEXT")) == NULL) ||
202 ((SAFE_GET_PROC (glTexCoordPointerEXT, (void *), "glTexCoordPointerEXT")) == NULL) ||
203 ((SAFE_GET_PROC (glVertexPointerEXT, (void *), "glVertexPointerEXT")) == NULL) )
204 {
205 Sys_Error ("GetProcAddress for vertex extension failed");
206 return;
207 }
208 return;
209 }
210 tmp++;
211 }
212
213 Sys_Error ("Vertex array extension not present");
214 }
215 */
216
CheckMultiTextureExtensions(void)217 void CheckMultiTextureExtensions(void)
218 {
219
220 if (strstr(gl_extensions, "GL_ARB_multitexture")) {
221
222 SAFE_GET_PROC (qglActiveTextureARB,PFNGLACTIVETEXTUREARBPROC,"glActiveTextureARB");
223 SAFE_GET_PROC (qglClientActiveTextureARB,PFNGLCLIENTACTIVETEXTUREARBPROC,"glClientActiveTextureARB");
224 SAFE_GET_PROC (qglMultiTexCoord1fARB,PFNGLMULTITEXCOORD1FARBPROC,"glMultiTexCoord1fARB");
225 SAFE_GET_PROC (qglMultiTexCoord2fARB,PFNGLMULTITEXCOORD2FARBPROC,"glMultiTexCoord2fARB");
226 SAFE_GET_PROC (qglMultiTexCoord2fvARB,PFNGLMULTITEXCOORD2FVARBPROC,"glMultiTexCoord2fvARB");
227 SAFE_GET_PROC (qglMultiTexCoord3fARB,PFNGLMULTITEXCOORD3FARBPROC,"glMultiTexCoord3fARB");
228 SAFE_GET_PROC (qglMultiTexCoord3fvARB,PFNGLMULTITEXCOORD3FVARBPROC,"glMultiTexCoord3fvARB");
229 gl_mtexable = true;
230
231 } else {
232 Sys_Error ("No multitexturing found.\nProbably your 3d-card is not supported.\n");
233 }
234 }
235
236
237 /*
238 PENTA: If we don't have these extensions then we don't continue
239 (how would we ever draw bump maps is these simpel ext's aren't supported)
240 */
CheckDiffuseBumpMappingExtensions(void)241 void CheckDiffuseBumpMappingExtensions(void)
242 {
243 if (!strstr(gl_extensions, "GL_EXT_texture_env_combine") &&
244 !strstr(gl_extensions, "GL_ARB_texture_env_combine") ) {
245 Sys_Error ("EXT_texture_env_combine not found.\nProbably your 3d-card is not supported.\n");
246 }
247
248 if (!strstr(gl_extensions, "GL_ARB_texture_env_dot3")) {
249 Sys_Error ("ARB_texture_env_dot3 not found.\nProbably your 3d-card is not supported.\n");
250 }
251 #if 0
252 if (!strstr(gl_extensions, "GL_ARB_texture_cube_map")) {
253 Sys_Error ("ARB_texture_cube_map not found.\nProbably your 3d-card is not supported.\n");
254 }
255 #endif
256 //Just spit a warning user prob has gl-1.2 or something
257 if (!strstr(gl_extensions, "GL_SGI_texture_edge_clamp") &&
258 !strstr(gl_extensions, "GL_EXT_texture_edge_clamp")) {
259 Con_Printf("Warning no edge_clamp extension found");
260 }
261 }
262
263 /*
264 PENTA: if we don't have these we continue with less eficient specular
265 */
CheckSpecularBumpMappingExtensions(void)266 void CheckSpecularBumpMappingExtensions(void)
267 {
268
269 if ( (strstr(gl_extensions, "GL_NV_register_combiners")) && (!COM_CheckParm ("-forcenonv")) ) {
270 gl_cardtype = GEFORCE; // GEFORCE3 checked later
271 SAFE_GET_PROC (qglCombinerParameterfvNV,PFNGLCOMBINERPARAMETERFVNVPROC,"glCombinerParameterfvNV");
272 SAFE_GET_PROC (qglCombinerParameterivNV,PFNGLCOMBINERPARAMETERIVNVPROC,"glCombinerParameterivNV");
273 SAFE_GET_PROC (qglCombinerParameterfNV,PFNGLCOMBINERPARAMETERFNVPROC,"glCombinerParameterfNV");
274 SAFE_GET_PROC (qglCombinerParameteriNV,PFNGLCOMBINERPARAMETERINVPROC,"glCombinerParameteriNV");
275 SAFE_GET_PROC (qglCombinerInputNV,PFNGLCOMBINERINPUTNVPROC,"glCombinerInputNV");
276 SAFE_GET_PROC (qglCombinerOutputNV,PFNGLCOMBINEROUTPUTNVPROC,"glCombinerOutputNV");
277 SAFE_GET_PROC (qglFinalCombinerInputNV,PFNGLFINALCOMBINERINPUTNVPROC,"glFinalCombinerInputNV");
278 SAFE_GET_PROC (qglGetCombinerInputParameterfvNV,PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC,"glGetCombinerInputParameterfvNV");
279 SAFE_GET_PROC (qglGetCombinerInputParameterivNV,PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC,"glGetCombinerInputParameterivNV");
280 SAFE_GET_PROC (qglGetCombinerOutputParameterfvNV,PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC,"glGetCombinerOutputParameterfvNV");
281 SAFE_GET_PROC (qglGetCombinerOutputParameterivNV,PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC,"glGetCombinerOutputParameterivNV");
282 SAFE_GET_PROC (qglGetFinalCombinerInputParameterfvNV,PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC,"glGetFinalCombinerInputfvNV");
283 SAFE_GET_PROC (qglGetFinalCombinerInputParameterivNV,PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC,"glGetFinalCombinerInputivNV");
284 }
285 }
286
287 /*
288 PENTA: if we have these we draw optimized
289 */
CheckGeforce3Extensions(void)290 void CheckGeforce3Extensions(void)
291 {
292 int supportedTmu;
293 glGetIntegerv(GL_MAX_ACTIVE_TEXTURES_ARB,&supportedTmu);
294 //Con_Printf("%i texture units\n",supportedTmu);
295
296 if (strstr(gl_extensions, "GL_EXT_texture3D")
297 && (supportedTmu >= 4) && (!COM_CheckParm ("-forcegf2"))
298 && (gl_cardtype == GEFORCE)
299 && strstr(gl_extensions, "GL_NV_vertex_program1_1")
300 && strstr(gl_extensions, "GL_NV_vertex_array_range"))
301 {
302 gl_cardtype = GEFORCE3;
303 SAFE_GET_PROC (qglTexImage3DEXT,PFNGLTEXIMAGE3DEXT,"glTexImage3DEXT");
304
305 //get vertex_program pointers
306 SAFE_GET_PROC (qglAreProgramsResidentNV,PFNGLAREPROGRAMSRESIDENTNVPROC,"glAreProgramsResidentNV");
307 SAFE_GET_PROC (qglBindProgramNV,PFNGLBINDPROGRAMNVPROC,"glBindProgramNV");
308 SAFE_GET_PROC (qglDeleteProgramsNV,PFNGLDELETEPROGRAMSNVPROC,"glDeleteProgramsNV");
309 SAFE_GET_PROC (qglExecuteProgramNV,PFNGLEXECUTEPROGRAMNVPROC,"glExecuteProgramNV");
310 SAFE_GET_PROC (qglGenProgramsNV,PFNGLGENPROGRAMSNVPROC,"glGenProgramsNV");
311 SAFE_GET_PROC (qglGetProgramParameterdvNV,PFNGLGETPROGRAMPARAMETERDVNVPROC,"glGetProgramParameterdvNV");
312 SAFE_GET_PROC (qglGetProgramParameterfvNV,PFNGLGETPROGRAMPARAMETERFVNVPROC,"glGetProgramParameterfvNV");
313 SAFE_GET_PROC (qglGetProgramivNV,PFNGLGETPROGRAMIVNVPROC,"glGetProgramivNV");
314 SAFE_GET_PROC (qglGetProgramStringNV,PFNGLGETPROGRAMSTRINGNVPROC,"glGetProgramStringNV");
315 SAFE_GET_PROC (qglGetTrackMatrixivNV,PFNGLGETTRACKMATRIXIVNVPROC,"glGetTrackMatrixivNV");
316 SAFE_GET_PROC (qglGetVertexAttribdvNV,PFNGLGETVERTEXATTRIBDVNVPROC,"glGetVertexAttribdvNV");
317 SAFE_GET_PROC (qglGetVertexAttribfvNV,PFNGLGETVERTEXATTRIBFVNVPROC,"glGetVertexAttribfvNV");
318 SAFE_GET_PROC (qglGetVertexAttribivNV,PFNGLGETVERTEXATTRIBIVNVPROC,"glGetVertexAttribivNV");
319 SAFE_GET_PROC (qglGetVertexAttribPointervNV,PFNGLGETVERTEXATTRIBPOINTERVNVPROC,"glGetVertexAttribPointervNV");
320 SAFE_GET_PROC (qglGetVertexAttribPointervNV,PFNGLGETVERTEXATTRIBPOINTERVNVPROC,"glGetVertexAttribPointerNV");
321 SAFE_GET_PROC (qglIsProgramNV,PFNGLISPROGRAMNVPROC,"glIsProgramNV");
322 SAFE_GET_PROC (qglLoadProgramNV,PFNGLLOADPROGRAMNVPROC,"glLoadProgramNV");
323 SAFE_GET_PROC (qglProgramParameter4dNV,PFNGLPROGRAMPARAMETER4DNVPROC,"glProgramParameter4dNV");
324 SAFE_GET_PROC (qglProgramParameter4dvNV,PFNGLPROGRAMPARAMETER4DVNVPROC,"glProgramParameter4dvNV");
325 SAFE_GET_PROC (qglProgramParameter4fNV,PFNGLPROGRAMPARAMETER4FNVPROC,"glProgramParameter4fNV");
326 SAFE_GET_PROC (qglProgramParameter4fvNV,PFNGLPROGRAMPARAMETER4FVNVPROC,"glProgramParameter4fvNV");
327 SAFE_GET_PROC (qglProgramParameters4dvNV,PFNGLPROGRAMPARAMETERS4DVNVPROC,"glProgramParameters4dvNV");
328 SAFE_GET_PROC (qglProgramParameters4fvNV,PFNGLPROGRAMPARAMETERS4FVNVPROC,"glProgramParameters4fvNV");
329 SAFE_GET_PROC (qglRequestResidentProgramsNV,PFNGLREQUESTRESIDENTPROGRAMSNVPROC,"glRequestResidentProgramsNV");
330 SAFE_GET_PROC (qglTrackMatrixNV,PFNGLTRACKMATRIXNVPROC,"glTrackMatrixNV");
331
332 //default to trilinear filtering on gf3
333 gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
334 gl_filter_max = GL_LINEAR;
335
336 }
337 }
338
339
340 //program wide pointer to the allocated agp mem block
341 void *AGP_Buffer;
342
343
CheckVertexArrayRange(void)344 void CheckVertexArrayRange(void)
345 {
346 /*
347 if (strstr(gl_extensions, "GL_NV_vertex_array_range"))
348 {
349 //get VAR pointers
350 SAFE_GET_PROC (glFlushVertexArrayRangeNV, PFNGLFLUSHVERTEXARRAYRANGENVPROC, "glFlushVertexArrayRangeNV");
351 SAFE_GET_PROC (glVertexArrayRangeNV, PFNGLVERTEXARRAYRANGENVPROC, "glVertexArrayRangeNV");
352 SAFE_GET_PROC (wglAllocateMemoryNV, PFNWGLALLOCATEMEMORYNVPROC, "wglAllocateMemoryNV");
353 SAFE_GET_PROC (wglFreeMemoryNV, PFNWGLFREEMEMORYNVPROC, "wglFreeMemoryNV");
354
355 if (wglAllocateMemoryNV != NULL) {
356 AGP_Buffer = wglAllocateMemoryNV(AGP_BUFFER_SIZE, 0.0, 0.0, 0.85);
357 if (AGP_Buffer) {
358 Con_Printf("Using %ikb AGP mem.\n",AGP_BUFFER_SIZE/1024);
359 gl_var = true;
360 } else {
361 Con_Printf("Failed to allocate %ikb AGP mem.\n",AGP_BUFFER_SIZE/1024);
362 gl_var = false;
363 }
364 }
365 } else {
366 */
367 gl_var = false;
368 // }
369
370 }
371
372
373 /*
374 PA: if we have these we draw optimized
375 */
CheckRadeonExtensions(void)376 void CheckRadeonExtensions(void)
377 {
378 int supportedTmu;
379 glGetIntegerv(GL_MAX_ACTIVE_TEXTURES_ARB,&supportedTmu);
380
381 if (strstr(gl_extensions, "GL_EXT_texture3D")
382 && (supportedTmu >= 4) && (!COM_CheckParm ("-forcegeneric"))
383 && strstr(gl_extensions, "GL_ATI_fragment_shader")
384 && strstr(gl_extensions, "GL_EXT_vertex_shader"))
385 {
386 Con_Printf("Using Radeon path.\n");
387 gl_cardtype = RADEON;
388
389 //get TEX3d pointers
390 SAFE_GET_PROC (qglTexImage3DEXT,PFNGLTEXIMAGE3DEXT,"glTexImage3DEXT");
391
392 //default to trilinear filtering on Radeon
393 gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
394 gl_filter_max = GL_LINEAR;
395 GL_CreateShadersRadeon();
396
397 }
398 }
399
CheckParheliaExtensions(void)400 void CheckParheliaExtensions(void)
401 {
402 int supportedTmu;
403 glGetIntegerv(GL_MAX_ACTIVE_TEXTURES_ARB,&supportedTmu);
404
405 if (strstr(gl_extensions, "GL_EXT_texture3D")
406 && (supportedTmu >= 4) && (COM_CheckParm ("-forceparhelia"))
407 && strstr(gl_extensions, "GL_MTX_fragment_shader")
408 && strstr(gl_extensions, "GL_EXT_vertex_shader"))
409 {
410 gl_cardtype = PARHELIA;
411
412 //get TEX3d pointers
413 SAFE_GET_PROC (qglTexImage3DEXT,PFNGLTEXIMAGE3DEXT,"glTexImage3DEXT");
414
415 //default to trilinear filtering on Parhelia
416 gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
417 gl_filter_max = GL_LINEAR;
418 GL_CreateShadersParhelia();
419 }
420 }
421
422
CheckARBFragmentExtensions(void)423 void CheckARBFragmentExtensions(void)
424 {
425 int supportedTmu;
426 glGetIntegerv(GL_MAX_ACTIVE_TEXTURES_ARB,&supportedTmu);
427
428 if (strstr(gl_extensions, "GL_EXT_texture3D")
429 && (supportedTmu >= 6) && (!COM_CheckParm ("-forcegeneric"))
430 && (!COM_CheckParm ("-noarb"))
431 && strstr(gl_extensions, "GL_ARB_fragment_program")
432 && strstr(gl_extensions, "GL_ARB_vertex_program"))
433 {
434 gl_cardtype = ARB;
435
436 //get TEX3d poiters wlgGetProcAddress
437 SAFE_GET_PROC (qglTexImage3DEXT,PFNGLTEXIMAGE3DEXT,"glTexImage3DEXT");
438
439 //default to trilinear filtering
440 gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
441 gl_filter_max = GL_LINEAR;
442 GL_CreateShadersARB();
443 }
444 }
445
446
CheckAnisotropicExtension(void)447 void CheckAnisotropicExtension(void)
448 {
449 if (strstr(gl_extensions, "GL_EXT_texture_filter_anisotropic") &&
450 ( COM_CheckParm ("-anisotropic") || COM_CheckParm ("-anisotropy")) )
451 {
452 GLfloat maxanisotropy;
453
454 if ( COM_CheckParm ("-anisotropy"))
455 gl_textureanisotropylevel = Q_atoi(com_argv[COM_CheckParm("-anisotropy")+1]);
456
457 glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxanisotropy);
458 if ( gl_textureanisotropylevel > maxanisotropy )
459 gl_textureanisotropylevel = maxanisotropy;
460
461 if ( gl_textureanisotropylevel < 1.0f )
462 gl_textureanisotropylevel = 1.0f;
463
464 Con_Printf("Anisotropic texture filter level %.0f\n",
465 gl_textureanisotropylevel);
466 gl_texturefilteranisotropic = true;
467 }
468 }
469
CheckTextureCompressionExtension(void)470 void CheckTextureCompressionExtension(void)
471 {
472 if (strstr(gl_extensions, "GL_ARB_texture_compression") )
473 {
474 Con_Printf("Texture compression available\n");
475 gl_texcomp = true;
476 }
477 }
478
479 qboolean gl_depthbounds;
480
CheckDepthBoundsExtension(void)481 void CheckDepthBoundsExtension(void) {
482 SAFE_GET_PROC (qglDepthBoundsNV,PFNGLDEPTHBOUNDSNV,"glDepthBoundsNV");
483 if (qglDepthBoundsNV != NULL) {
484 Con_Printf("Using depth bounds extension.\n");
485 gl_depthbounds = true;
486 } else {
487 gl_depthbounds = false;
488 }
489 }
490
491 /*
492 ===============
493 GL_Init
494 ===============
495 */
GL_Init(void)496 void GL_Init (void)
497 {
498 int supportedTmu;
499
500 gl_vendor = glGetString (GL_VENDOR);
501 Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
502 gl_renderer = glGetString (GL_RENDERER);
503 Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
504
505 gl_version = glGetString (GL_VERSION);
506 Con_Printf ("GL_VERSION: %s\n", gl_version);
507 gl_extensions = glGetString (GL_EXTENSIONS);
508 Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
509
510 Con_Printf ("%s %s\n", gl_renderer, gl_version);
511
512 if (Q_strncasecmp ((char *)gl_renderer,"PowerVR",7)==0)
513 fullsbardraw = true;
514
515 if (Q_strncasecmp ((char *)gl_renderer,"Permedia",8)==0)
516 isPermedia = true;
517
518 Con_Printf ("Checking paletted texture\n");
519 CheckPalettedTexture ();
520
521 Con_Printf ("Checking multitexture\n");
522 CheckMultiTextureExtensions ();
523
524 Con_Printf ("Checking diffuse bumpmap extensions\n");
525 CheckDiffuseBumpMappingExtensions ();
526
527 Con_Printf ("Checking ARB extensions\n");
528 CheckARBFragmentExtensions ();
529
530 if ( gl_cardtype != ARB )
531 {
532 Con_Printf ("Checking GeForce 1/2/4-MX\n");
533 CheckSpecularBumpMappingExtensions ();
534 Con_Printf ("Checking GeForce 3/4\n");
535 CheckGeforce3Extensions ();
536 Con_Printf ("Checking Radeon 8500+\n");
537 CheckRadeonExtensions ();
538 Con_Printf ("Checking Parhelia\n");
539 CheckParheliaExtensions ();
540 }
541
542 Con_Printf ("Checking VAR\n");
543 CheckVertexArrayRange ();
544 Con_Printf ("Checking AF\n");
545 CheckAnisotropicExtension ();
546 Con_Printf ("Checking TC\n");
547 CheckTextureCompressionExtension ();
548 Con_Printf ("Checking DB\n");
549 CheckDepthBoundsExtension ();
550
551 switch (gl_cardtype)
552 {
553 case GENERIC:
554 Con_Printf ("Using generic path.\n");
555 break;
556 case GEFORCE:
557 Con_Printf ("Using GeForce 1/2/4-MX path\n");
558 break;
559 case GEFORCE3:
560 Con_Printf ("Using GeForce 3/4 path\n");
561 break;
562 case RADEON:
563 Con_Printf ("Using Radeon path.\n");
564 break;
565 case PARHELIA:
566 Con_Printf ("Using Parhelia path.\n");
567 break;
568 case ARB:
569 Con_Printf ("Using ARB_fragment_program path.\n");
570 break;
571 }
572
573 glGetIntegerv (GL_MAX_ACTIVE_TEXTURES_ARB,&supportedTmu);
574 Con_Printf ("%i texture units\n",supportedTmu);
575
576 //PENTA: enable mlook by default, people kept mailing me about how to do mlook
577 Cbuf_AddText ("+mlook");
578
579 glClearColor (0.5,0.5,0.5,0.5);
580 glCullFace (GL_FRONT);
581 glEnable (GL_TEXTURE_2D);
582
583 glEnable (GL_ALPHA_TEST);
584 glAlphaFunc (GL_GREATER, 0.666);
585
586 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
587 glShadeModel (GL_FLAT);
588
589 glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
590 glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
591 glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
592 glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
593
594 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
595
596 // glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
597 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
598 #if 0
599 CheckArrayExtensions ();
600
601 glEnable (GL_VERTEX_ARRAY_EXT);
602 glEnable (GL_TEXTURE_COORD_ARRAY_EXT);
603 glVertexPointerEXT (3, GL_FLOAT, 0, 0, &glv.x);
604 glTexCoordPointerEXT (2, GL_FLOAT, 0, 0, &glv.s);
605 glColorPointerEXT (3, GL_FLOAT, 0, 0, &glv.r);
606 #endif
607
608 }
609
VID_Is8bit()610 qboolean VID_Is8bit() {
611 return is8bit;
612 }
613
614 #define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB
615
VID_Init8bitPalette(void)616 void VID_Init8bitPalette(void)
617 {
618 // Check for 8bit Extensions and initialize them.
619 int i;
620
621 if (COM_CheckParm ("-no8bit"))
622 return;
623
624
625
626 SAFE_GET_PROC (qglColorTableEXT,GLCOLORTABLEEXTPFN,"glColorTableEXT");
627
628
629 if (strstr (gl_extensions, "GL_EXT_shared_texture_palette") && qglColorTableEXT )
630
631 {
632
633 char thePalette[256*3];
634 char *oldPalette, *newPalette;
635
636 Con_SafePrintf("8-bit GL extensions enabled.\n");
637 glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
638 oldPalette = (char *) d_8to24table; //d_8to24table3dfx;
639 newPalette = thePalette;
640 for (i=0;i<256;i++) {
641 *newPalette++ = *oldPalette++;
642 *newPalette++ = *oldPalette++;
643 *newPalette++ = *oldPalette++;
644 oldPalette++;
645 }
646 qglColorTableEXT(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, (void *) thePalette);
647 is8bit = true;
648
649 }
650 /*
651 // 3DFX stuff
652 else if (strstr (gl_extensions, "3DFX_set_global_palette")
653 && (SAFE_GET_PROC (qgl3DfxSetPaletteEXT,GL3DFXSETPALETTEEXTPFN,"gl3DfxSetPaletteEXT")!= NULL)) {
654 GLubyte table[256][4];
655 char *oldpal;
656
657 Con_SafePrintf ("8-bit GL extensions enabled.\n");
658 glEnable ( GL_SHARED_TEXTURE_PALETTE_EXT );
659 oldpal = (char *) d_8to24table; //d_8to24table3dfx;
660 for (i=0;i<256;i++) {
661 table[i][2] = *oldpal++;
662 table[i][1] = *oldpal++;
663 table[i][0] = *oldpal++;
664 table[i][3] = 255;
665 oldpal++;
666 }
667 qgl3DfxSetPaletteEXT ((GLuint *)table);
668 is8bit = true;
669 }
670 */
671 }
672