Vegastrike 0.5.1 rc1  1.0
Original sources for Vegastrike Evolved
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gl_init.cpp
Go to the documentation of this file.
1 /*
2  * Vega Strike
3  * Copyright (C) 2001-2002 Daniel Horn
4  *
5  * http://vegastrike.sourceforge.net/
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21 #define GL_INIT_CPP
22 #include "gl_globals.h"
23 #undef GL_INIT_CPP
24 #include "gl_include.h"
25 #include "vs_globals.h"
26 #include "xml_support.h"
27 #include "config_xml.h"
28 #include "winsys.h"
29 #include <assert.h>
30 #include "gfxlib.h"
31 #include <string>
32 
33 #if !defined (_WIN32) && !defined (__CYGWIN__)
34 
35 //#if !(defined(__APPLE__) || defined(MACOSX))
36 //#define GL_GLEXT_PROTOTYPES 1
37 //#define GLX_GLXEXT_PROTOTYPES 1
38 //#define GLX_GLXEXT_LEGACY 1
39 
40 //# include <GL/glxext.h>
41 //# include <GL/glx.h>
42 //# include <GL/glxext.h>
43 //#endif
44 
45 #include <stdlib.h>
46 
47 #else
48 #ifndef NOMINMAX
49 #define NOMINMAX
50 #endif //tells VCC not to generate min/max macros
51 #include <windows.h>
52 #endif
53 #define GL_GLEXT_PROTOTYPES 1
54 #if defined (__APPLE__) || defined (MACOSX)
55  #include <OpenGL/gl.h>
56  #include <OpenGL/glext.h>
57 #else
58  #include <GL/gl.h>
59  #include <GL/glext.h>
60 #endif
61 #ifdef GL_EXT_compiled_vertex_array
62 # ifndef PFNGLLOCKARRAYSEXTPROC
63 # undef GL_EXT_compiled_vertex_array
64 # endif
65 #endif
66 #if !defined (IRIX)
67 //typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
68 //typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
69 
70 #if !defined (__APPLE__) && !defined (MACOSX) && !defined (WIN32) && !defined (__HAIKU__)
71  # define GLX_GLXEXT_PROTOTYPES 1
72  # define GLX_GLXEXT_LEGACY 1
73  # include <GL/glx.h>
74  # include <GL/glext.h>
75 #endif
76 #endif
77 
78 #include <stdio.h>
79 #include "gl_init.h"
80 #define WINDOW_TITLE "Vega Strike " VERSION
81 
82 #if defined (CG_SUPPORT)
83 #include "cg_global.h"
84 #endif
85 
86 #if !defined (__APPLE__)
87 
88 PFNGLBINDBUFFERARBPROC glBindBufferARB_p = 0;
89 PFNGLGENBUFFERSARBPROC glGenBuffersARB_p = 0;
90 PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB_p = 0;
91 PFNGLBUFFERDATAARBPROC glBufferDataARB_p = 0;
92 PFNGLMAPBUFFERARBPROC glMapBufferARB_p = 0;
93 PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB_p = 0;
94 
95 PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB_p = 0;
96 PFNGLCLIENTACTIVETEXTUREARBPROC glActiveTextureARB_p = 0;
97 PFNGLCOLORTABLEEXTPROC glColorTable_p = 0;
98 PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB_p = 0;
99 PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB_p = 0;
100 
101 PFNGLLOCKARRAYSEXTPROC glLockArraysEXT_p = 0;
102 PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT_p = 0;
103 PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D_p = 0;
104 PFNGLMULTIDRAWARRAYSEXTPROC glMultiDrawArrays_p = 0;
105 PFNGLMULTIDRAWELEMENTSEXTPROC glMultiDrawElements_p = 0;
106 
107 PFNGLGETSHADERIVPROC glGetShaderiv_p = 0;
108 PFNGLGETPROGRAMIVPROC glGetProgramiv_p = 0;
109 PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog_p = 0;
110 PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog_p = 0;
111 PFNGLCREATESHADERPROC glCreateShader_p = 0;
112 PFNGLSHADERSOURCEPROC glShaderSource_p = 0;
113 PFNGLCOMPILESHADERPROC glCompileShader_p = 0;
114 PFNGLCREATEPROGRAMPROC glCreateProgram_p = 0;
115 PFNGLATTACHSHADERPROC glAttachShader_p = 0;
116 PFNGLLINKPROGRAMPROC glLinkProgram_p = 0;
117 PFNGLUSEPROGRAMPROC glUseProgram_p = 0;
118 PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation_p = 0;
119 PFNGLUNIFORM1FPROC glUniform1f_p = 0;
120 PFNGLUNIFORM2FPROC glUniform2f_p = 0;
121 PFNGLUNIFORM3FPROC glUniform3f_p = 0;
122 PFNGLUNIFORM4FPROC glUniform4f_p = 0;
123 
124 PFNGLUNIFORM1IPROC glUniform1i_p = 0;
125 PFNGLUNIFORM2IPROC glUniform2i_p = 0;
126 PFNGLUNIFORM3IPROC glUniform3i_p = 0;
127 PFNGLUNIFORM4IPROC glUniform4i_p = 0;
128 
129 PFNGLUNIFORM1FVPROC glUniform1fv_p = 0;
130 PFNGLUNIFORM2FVPROC glUniform2fv_p = 0;
131 PFNGLUNIFORM3FVPROC glUniform3fv_p = 0;
132 PFNGLUNIFORM4FVPROC glUniform4fv_p = 0;
133 
134 PFNGLUNIFORM1IVPROC glUniform1iv_p = 0;
135 PFNGLUNIFORM2IVPROC glUniform2iv_p = 0;
136 PFNGLUNIFORM3IVPROC glUniform3iv_p = 0;
137 PFNGLUNIFORM4IVPROC glUniform4iv_p = 0;
138 
139 PFNGLDELETESHADERPROC glDeleteShader_p = 0;
140 PFNGLDELETEPROGRAMPROC glDeleteProgram_p = 0;
141 
142 #endif /* __APPLE_PANTHER_GCC33_CLI__ */
143 
144 typedef void ( *(*get_gl_proc_fptr_t)(const GLubyte*) )();
145 #ifdef _WIN32
146 typedef char*GET_GL_PTR_TYP;
147 #define GET_GL_PROC wglGetProcAddress
148 #else
149  #if defined(__HAIKU__)
150  typedef char * GET_GL_PTR_TYP;
151  #define GET_GL_PROC glutGetProcAddress
152  #else
153  typedef GLubyte*GET_GL_PTR_TYP;
154  #define GET_GL_PROC glXGetProcAddressARB
155  #endif
156 #endif
157 
158 #if defined (CG_SUPPORT)
159 CG_Cloak *cloak_cg = new CG_Cloak();
160 #endif
161 
162 /* CENTRY */
163 int vsExtensionSupported( const char *extension )
164 {
165  static const GLubyte *extensions = NULL;
166  const GLubyte *start;
167  GLubyte *where, *terminator;
168 
169  /* Extension names should not have spaces. */
170  where = (GLubyte*) strchr( extension, ' ' );
171  if (where || *extension == '\0')
172  return 0;
173  if (!extensions)
174  extensions = glGetString( GL_EXTENSIONS );
175  /* It takes a bit of care to be fool-proof about parsing the
176  * OpenGL extensions string. Don't be fooled by sub-strings,
177  * etc. */
178  start = extensions;
179  for (;;) {
180  /* If your application crashes in the strstr routine below,
181  * you are probably calling vsExtensionSupported without
182  * having a current window. Calling glGetString without
183  * a current OpenGL context has unpredictable results.
184  * Please fix your program. */
185  where = (GLubyte*) strstr( (const char*) start, extension );
186  if (!where)
187  break;
188  terminator = where+strlen( extension );
189  if (where == start || *(where-1) == ' ')
190  if (*terminator == ' ' || *terminator == '\0')
191  return 1;
192  start = terminator;
193  }
194  return 0;
195 }
196 
197 bool vsVendorMatch( const char *vendor )
198 {
199  static const GLubyte *_glvendor = NULL;
200 
201  if (_glvendor == NULL) {
202  _glvendor = glGetString( GL_VENDOR );
203  if (_glvendor != NULL)
204  VSFileSystem::vs_dprintf(1, "OpenGL Vendor: %s\n", (const char*)_glvendor);
205  }
206 
207  if (_glvendor != NULL) {
208  // NOTE: Don't be fooled by substrings withing words
209  // Should match whole-words ONLY
210 
211  static const std::string glvendor = strtolower(std::string((const char*)_glvendor));
212  static const std::string::size_type glvendor_sz = glvendor.length();
213  std::string svendor = strtolower(vendor);
214  std::string::size_type svendor_sz = svendor.length();
215  std::string::size_type pos = glvendor.find(svendor);
216 
217  if (pos == std::string::npos)
218  return false;
219 
220  if ((pos > 0) && isalnum(glvendor[pos-1]))
221  return false;
222 
223  if ((pos+svendor_sz) < glvendor_sz && isalnum(glvendor[pos+svendor_sz]))
224  return false;
225 
226  return true;
227  } else {
228  return false;
229  }
230 }
231 
232 void init_opengl_extensions()
233 {
234  const unsigned char *extensions = glGetString( GL_EXTENSIONS );
235 
236  VSFileSystem::vs_dprintf( '3', "OpenGL Extensions supported: %s\n", extensions );
237 
238 #ifndef NO_COMPILEDVERTEXARRAY_SUPPORT
239  if ( vsExtensionSupported( "GL_EXT_compiled_vertex_array" )
240  && XMLSupport::parse_bool( vs_config->getVariable( "graphics", "LockVertexArrays", "true" ) ) ) {
241 #ifdef __APPLE__
242 #ifndef __APPLE_PANTHER_GCC33_CLI__
243 #if defined (glLockArraysEXT) && defined (glUnlockArraysEXT)
244  glLockArraysEXT_p = &glLockArraysEXT;
245  glUnlockArraysEXT_p = &glUnlockArraysEXT;
246 #else
247  glLockArraysEXT_p = 0;
248  glUnlockArraysEXT_p = 0;
249 #endif
250 #endif /*__APPLE_PANTHER_GCC33_CLI__*/
251 #else
252  glLockArraysEXT_p = (PFNGLLOCKARRAYSEXTPROC)
253  GET_GL_PROC( (GET_GL_PTR_TYP) "glLockArraysEXT" );
254  glUnlockArraysEXT_p = (PFNGLUNLOCKARRAYSEXTPROC)
255  GET_GL_PROC( (GET_GL_PTR_TYP) "glUnlockArraysEXT" );
256 #endif
257  VSFileSystem::vs_dprintf( 3, "OpenGL::GL_EXT_compiled_vertex_array supported\n" );
258  } else {
259 #ifdef __APPLE__
260 #ifndef __APPLE_PANTHER_GCC33_CLI__
261  glLockArraysEXT_p = 0;
262  glUnlockArraysEXT_p = 0;
263 #endif /*__APPLE_PANTHER_GCC33_CLI__*/
264 #endif
265  VSFileSystem::vs_dprintf( 2, "OpenGL::GL_EXT_compiled_vertex_array unsupported\n" );
266  }
267 #endif
268 #ifndef __APPLE__
269  if ( vsExtensionSupported( "GL_EXT_multi_draw_arrays" ) ) {
270  glMultiDrawArrays_p = (PFNGLMULTIDRAWARRAYSEXTPROC)
271  GET_GL_PROC( (GET_GL_PTR_TYP) "glMultiDrawArraysEXT" );
272  glMultiDrawElements_p = (PFNGLMULTIDRAWELEMENTSEXTPROC)
273  GET_GL_PROC( (GET_GL_PTR_TYP) "glMultiDrawElementsEXT" );
274  VSFileSystem::vs_dprintf( 3, "OpenGL::GL_EXT_multi_draw_arrays supported\n" );
275  } else {
276  glMultiDrawArrays_p = 0;
277  glMultiDrawElements_p = 0;
278  VSFileSystem::vs_dprintf( 2, "OpenGL::GL_EXT_multi_draw_arrays unsupported\n" );
279  }
280 #endif
281 
282 #ifdef __APPLE__
283 #ifndef __APPLE__
284  glColorTable_p = glColorTableEXT;
285  glMultiTexCoord2fARB_p = glMultiTexCoord2fARB;
286  glMultiTexCoord4fARB_p = glMultiTexCoord4fARB;
287  glClientActiveTextureARB_p = glClientActiveTextureARB;
288  glActiveTextureARB_p = glActiveTextureARB;
289 #endif /*__APPLE_PANTHER_GCC33_CLI__*/
290 #else
291 #ifndef NO_VBO_SUPPORT
292  glBindBufferARB_p = (PFNGLBINDBUFFERARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glBindBuffer" );
293  glGenBuffersARB_p = (PFNGLGENBUFFERSARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glGenBuffers" );
294  glDeleteBuffersARB_p = (PFNGLDELETEBUFFERSARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glDeleteBuffers" );
295  glBufferDataARB_p = (PFNGLBUFFERDATAARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glBufferData" );
296  glMapBufferARB_p = (PFNGLMAPBUFFERARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glMapBuffer" );
297  glUnmapBufferARB_p = (PFNGLUNMAPBUFFERARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUnmapBuffer" );
298 #endif
299 
300  glColorTable_p = (PFNGLCOLORTABLEEXTPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glColorTableEXT" );
301  glMultiTexCoord2fARB_p = (PFNGLMULTITEXCOORD2FARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glMultiTexCoord2fARB" );
302  glMultiTexCoord4fARB_p = (PFNGLMULTITEXCOORD4FARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glMultiTexCoord4fARB" );
303  glClientActiveTextureARB_p = (PFNGLCLIENTACTIVETEXTUREARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glClientActiveTextureARB" );
304  glActiveTextureARB_p = (PFNGLCLIENTACTIVETEXTUREARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glActiveTextureARB" );
305  if (!glMultiTexCoord2fARB_p)
306  glMultiTexCoord2fARB_p = (PFNGLMULTITEXCOORD2FARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glMultiTexCoord2fEXT" );
307  if (!glMultiTexCoord4fARB_p)
308  glMultiTexCoord4fARB_p = (PFNGLMULTITEXCOORD4FARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glMultiTexCoord4fEXT" );
309  if (!glClientActiveTextureARB_p)
310  glClientActiveTextureARB_p = (PFNGLCLIENTACTIVETEXTUREARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glClientActiveTextureEXT" );
311  if (!glActiveTextureARB_p)
312  glActiveTextureARB_p = (PFNGLCLIENTACTIVETEXTUREARBPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glActiveTextureEXT" );
313  if (!glCompressedTexImage2D_p)
314  glCompressedTexImage2D_p = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glCompressedTexImage2D" );
315  if (!glGetShaderiv_p)
316  glGetShaderiv_p = (PFNGLGETSHADERIVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glGetShaderiv" );
317  if (!glGetProgramiv_p)
318  glGetProgramiv_p = (PFNGLGETPROGRAMIVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glGetProgramiv" );
319  if (!glGetShaderInfoLog_p)
320  glGetShaderInfoLog_p = (PFNGLGETSHADERINFOLOGPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glGetShaderInfoLog" );
321  if (!glGetProgramInfoLog_p)
322  glGetProgramInfoLog_p = (PFNGLGETPROGRAMINFOLOGPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glGetProgramInfoLog" );
323  if (!glCreateShader_p)
324  glCreateShader_p = (PFNGLCREATESHADERPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glCreateShader" );
325  if (!glCreateProgram_p)
326  glCreateProgram_p = (PFNGLCREATEPROGRAMPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glCreateProgram" );
327  if (!glShaderSource_p)
328  glShaderSource_p = (PFNGLSHADERSOURCEPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glShaderSource" );
329  if (!glCompileShader_p)
330  glCompileShader_p = (PFNGLCOMPILESHADERPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glCompileShader" );
331  if (!glAttachShader_p)
332  glAttachShader_p = (PFNGLATTACHSHADERPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glAttachShader" );
333  if (!glLinkProgram_p)
334  glLinkProgram_p = (PFNGLLINKPROGRAMPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glLinkProgram" );
335  if (!glUseProgram_p)
336  glUseProgram_p = (PFNGLUSEPROGRAMPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUseProgram" );
337  if (!glGetUniformLocation_p)
338  glGetUniformLocation_p = (PFNGLGETUNIFORMLOCATIONPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glGetUniformLocation" );
339  if (!glUniform1f_p)
340  glUniform1f_p = (PFNGLUNIFORM1FPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform1f" );
341  if (!glUniform2f_p)
342  glUniform2f_p = (PFNGLUNIFORM2FPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform2f" );
343  if (!glUniform3f_p)
344  glUniform3f_p = (PFNGLUNIFORM3FPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform3f" );
345  if (!glUniform4f_p)
346  glUniform4f_p = (PFNGLUNIFORM4FPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform4f" );
347  if (!glUniform1i_p)
348  glUniform1i_p = (PFNGLUNIFORM1IPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform1i" );
349  if (!glUniform2i_p)
350  glUniform2i_p = (PFNGLUNIFORM2IPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform2i" );
351  if (!glUniform3i_p)
352  glUniform3i_p = (PFNGLUNIFORM3IPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform3i" );
353  if (!glUniform4i_p)
354  glUniform4i_p = (PFNGLUNIFORM4IPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform4i" );
355  if (!glUniform1fv_p)
356  glUniform1fv_p = (PFNGLUNIFORM1FVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform1fv" );
357  if (!glUniform2fv_p)
358  glUniform2fv_p = (PFNGLUNIFORM2FVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform2fv" );
359  if (!glUniform3fv_p)
360  glUniform3fv_p = (PFNGLUNIFORM3FVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform3fv" );
361  if (!glUniform4fv_p)
362  glUniform4fv_p = (PFNGLUNIFORM4FVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform4fv" );
363  if (!glUniform1iv_p)
364  glUniform1iv_p = (PFNGLUNIFORM1IVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform1iv" );
365  if (!glUniform2iv_p)
366  glUniform2iv_p = (PFNGLUNIFORM2IVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform2iv" );
367  if (!glUniform3iv_p)
368  glUniform3iv_p = (PFNGLUNIFORM3IVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform3iv" );
369  if (!glUniform4iv_p)
370  glUniform4iv_p = (PFNGLUNIFORM4IVPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glUniform4iv" );
371  if (!glDeleteShader_p)
372  glDeleteShader_p = (PFNGLDELETESHADERPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glDeleteShader" );
373  if (!glDeleteProgram_p)
374  glDeleteProgram_p = (PFNGLDELETEPROGRAMPROC) GET_GL_PROC( (GET_GL_PTR_TYP) "glDeleteProgram" );
375  //fixme
376 #endif
377 
378 #ifdef GL_FOG_DISTANCE_MODE_NV
379  if ( vsExtensionSupported( "GL_NV_fog_distance" ) ) {
380  VSFileSystem::vs_dprintf( 3, "OpenGL::Accurate Fog Distance supported\n" );
381  int foglev = XMLSupport::parse_int( vs_config->getVariable( "graphics", "fogdetail", "0" ) );
382  switch (foglev)
383  {
384  case 0:
385  glFogi( GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV );
386  break;
387  case 1:
388  glFogi( GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE );
389  break;
390  case 2:
391  glFogi( GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV );
392  break;
393  }
394  } else {
395 #endif
396  VSFileSystem::vs_dprintf( 2, "OpenGL::Accurate Fog Distance unsupported\n" );
397 #ifdef GL_FOG_DISTANCE_MODE_NV
398  }
399 #endif
400  if ( vsExtensionSupported( "GL_ARB_texture_compression" ) ) {
401  VSFileSystem::vs_dprintf( 3, "OpenGL::Generic Texture Compression supported\n" );
402  } else {
403  VSFileSystem::vs_dprintf( 1, "OpenGL::Generic Texture Compression unsupported\n" );
404  gl_options.compression = 0;
405  }
406  if ( vsExtensionSupported( "GL_EXT_texture_compression_s3tc" ) ) {
407  VSFileSystem::vs_dprintf( 3, "OpenGL::S3TC Texture Compression supported\n" );
408  //should be true;
409  } else {
410  gl_options.s3tc = false;
411  VSFileSystem::vs_dprintf( 1, "OpenGL::S3TC Texture Compression unsupported\n" );
412  }
413  if ( (glMultiTexCoord2fARB_p && glMultiTexCoord4fARB_p && glClientActiveTextureARB_p && glActiveTextureARB_p)
414  && ( vsExtensionSupported( "GL_ARB_multitexture" ) || vsExtensionSupported( "GL_EXT_multitexture" ) ) ) {
415  GLint multitex = gl_options.Multitexture;
416  glGetIntegerv( GL_MAX_TEXTURE_UNITS, &multitex );
417  if (multitex > 1)
418  gl_options.Multitexture = multitex;
419 
420  else
421  gl_options.Multitexture = 0;
422  //gl_options.Multitexture = 1*gl_options.Multitexture;//might be zero by input
423  if (gl_options.Multitexture)
424  VSFileSystem::vs_dprintf( 3, "OpenGL::Multitexture supported (%d units)\n", gl_options.Multitexture );
425  } else {
426  gl_options.Multitexture = 0;
427  VSFileSystem::vs_dprintf( 2, "OpenGL::Multitexture unsupported\n" );
428  }
429  if ( vsExtensionSupported( "GL_ARB_texture_cube_map" ) || vsExtensionSupported( "GL_EXT_texture_cube_map" ) ) {
430  gl_options.cubemap = 1;
431  VSFileSystem::vs_dprintf( 3, "OpenGL::TextureCubeMapExt supported\n" );
432  } else {
433  gl_options.cubemap = 0;
434  VSFileSystem::vs_dprintf( 1, "OpenGL::TextureCubeMapExt unsupported\n" );
435  }
436  if ( vsExtensionSupported( "GL_EXT_texture_edge_clamp" ) || vsExtensionSupported( "GL_SGIS_texture_edge_clamp" ) ) {
437  VSFileSystem::vs_dprintf( 3, "OpenGL::S3TC Texture Clamp-to-Edge supported\n" );
438  // should be true
439  } else {
440  gl_options.ext_clamp_to_edge = false;
441  VSFileSystem::vs_dprintf( 1, "OpenGL::S3TC Texture Clamp-to-Edge unsupported\n" );
442  }
443  if ( vsExtensionSupported( "GL_ARB_texture_border_clamp" ) || vsExtensionSupported( "GL_SGIS_texture_border_clamp" ) ) {
444  VSFileSystem::vs_dprintf( 3, "OpenGL::S3TC Texture Clamp-to-Border supported\n" );
445  // should be true
446  } else {
447  gl_options.ext_clamp_to_border = false;
448  VSFileSystem::vs_dprintf( 1, "OpenGL::S3TC Texture Clamp-to-Border unsupported\n" );
449  }
450  if ( vsExtensionSupported( "GL_ARB_framebuffer_sRGB" ) || vsExtensionSupported( "GL_EXT_framebuffer_sRGB" ) ) {
451  VSFileSystem::vs_dprintf( 3, "OpenGL::sRGB Framebuffer supported\n" );
452  GLboolean srgbCapable = true;
453 
454  if ( vsExtensionSupported( "GL_EXT_framebuffer_sRGB" ) ) {
455  // TODO: GL_EXT_framebuffer_sRGB allows us to query sRGB capability easily.
456  // The ARB variant requires us to use GLX and GLW stuff, which would be harder to do portably
457  // For now, we'll just assume the ARB variant supports it, since it's quite probable that it
458  // does for most framebuffer visuals.
459  srgbCapable = false;
460  glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, &srgbCapable);
461  }
462 
463  if (srgbCapable) {
464  gl_options.ext_srgb_framebuffer = true;
465  } else {
466  VSFileSystem::vs_dprintf( 1, "OpenGL::sRGB Framebuffer unsupported by visual\n" );
467  gl_options.ext_srgb_framebuffer = false;
468  }
469  } else {
470  gl_options.ext_srgb_framebuffer = false;
471  VSFileSystem::vs_dprintf( 1, "OpenGL::sRGB Framebuffer unsupported\n" );
472  }
473  if ( vsExtensionSupported( "GL_NV_fragment_program2" ) ) {
474  gl_options.nv_fp2 = true;
475  VSFileSystem::vs_dprintf( 3, "OpenGL::NV_fragment_program2 supported\n" );
476  } else {
477  gl_options.nv_fp2 = false;
478  VSFileSystem::vs_dprintf( 1, "OpenGL::NV_fragment_program2 unsupported\n" );
479  }
480  if ( GFXDefaultShaderSupported() )
481  if (gl_options.Multitexture < 16)
482  gl_options.Multitexture = 16;
483  //only support shaders on ps_2_0 cards
484 
485  // some useful generic limits
486  GLint max_vertices=-1, max_indices=-1;
487  glGetIntegerv( GL_MAX_ELEMENTS_INDICES, &max_indices );
488  glGetIntegerv( GL_MAX_ELEMENTS_VERTICES, &max_vertices );
489  gl_options.max_array_indices = max_indices;
490  gl_options.max_array_vertices = max_vertices;
491 
492  VSFileSystem::vs_dprintf( 1, "Max vertex array indices: %d\n", gl_options.max_array_indices );
493  VSFileSystem::vs_dprintf( 1, "Max vertex array vertices: %d\n", gl_options.max_array_vertices );
494 }
495 
496 static void initfov()
497 {
498  g_game.fov = XMLSupport::parse_float( vs_config->getVariable( "graphics", "fov", "78" ) );
499  g_game.aspect = XMLSupport::parse_float( vs_config->getVariable( "graphics", "aspect", "1.33" ) );
500  g_game.znear = XMLSupport::parse_float( vs_config->getVariable( "graphics", "znear", "1" ) );
501  g_game.zfar = XMLSupport::parse_float( vs_config->getVariable( "graphics", "zfar", "100000" ) );
502  g_game.detaillevel = XMLSupport::parse_float( vs_config->getVariable( "graphics", "ModelDetail", "1" ) );
503  g_game.use_textures = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UseTextures", "true" ) );
504  g_game.use_ship_textures = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UseShipTextures", "false" ) );
505  g_game.use_planet_textures = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UsePlanetTextures", "false" ) );
506  g_game.use_logos = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UseLogos", "true" ) );
507  g_game.use_sprites = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UseVSSprites", "true" ) );
508  g_game.use_animations = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UseAnimations", "true" ) );
509  g_game.use_videos = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "UseVideos", "true" ) );
510 
511  /*
512  * FILE * fp = fopen ("glsetup.txt","r");
513  * if (fp) {
514  * VSFileSystem::Fscanf (fp,"fov %f\n",&g_game.fov);
515  * VSFileSystem::Fscanf (fp,"aspect %f\n",&g_game.aspect);
516  * VSFileSystem::Fscanf (fp,"znear %f\n",&g_game.znear);
517  * VSFileSystem::Fscanf (fp,"zfar %f\n",&g_game.zfar);
518  * VSFileSystem::Close (fp);
519  * }
520  */
521 }
522 
523 static void Reshape( int x, int y )
524 {
525  g_game.x_resolution = x;
526  g_game.y_resolution = y;
527  VSFileSystem::vs_dprintf( 3, "Reshaping %d %d", x, y );
528 }
529 
530 extern void GFXInitTextureManager();
531 
532 void GFXInit( int argc, char **argv )
533 {
534  char vsname[12] = "Vega Strike";
535  char vsicon[9] = "vega.ico";
536  winsys_init (&argc,argv,&vsname[0],&vsicon[0]);
537  /* Ingore key-repeat messages */
538  winsys_enable_key_repeat( false );
539 
540  glViewport( 0, 0, g_game.x_resolution, g_game.y_resolution );
541  float clearcol[4];
542  gl_options.wireframe = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "use_wireframe", "0" ) );
543  gl_options.max_texture_dimension =
544  XMLSupport::parse_int( vs_config->getVariable( "graphics", "max_texture_dimension", "65536" ) );
545  gl_options.max_movie_dimension =
546  XMLSupport::parse_int( vs_config->getVariable( "graphics", "max_movie_dimension", "65536" ) );
547 
548  gl_options.rect_textures =
549  XMLSupport::parse_bool( vs_config->getVariable( "graphics", "rect_textures",
550  ( vsExtensionSupported( "GL_ARB_texture_non_power_of_two" )
551  || vsExtensionSupported( "GL_ARB_texture_rectangle" )
552  || vsExtensionSupported( "GL_NV_texture_rectangle" )
553  ) ? "true" : "false" ) );
554 
555  if (gl_options.rect_textures) {
556  VSFileSystem::vs_dprintf(3, "RECT textures supported\n");
557 
558  // Fetch max rect textue dimension
559  GLint max_rect_dimension = 65535;
560  glGetIntegerv(
561  GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB,
562  &max_rect_dimension);
563 
564  gl_options.max_rect_dimension = max_rect_dimension;
565  VSFileSystem::vs_dprintf(3, "RECT max texture dimension: %d\n", max_rect_dimension);
566  }
567 
568  gl_options.pot_video_textures =
569  XMLSupport::parse_bool( vs_config->getVariable( "graphics", "pot_video_textures",
570  ( gl_options.rect_textures
571  || ( vsExtensionSupported( "GL_ARB_texture_non_power_of_two" )
572  && vsVendorMatch("nvidia") )
573  ) ? "false" : "true" ) );
574 
575  if (!gl_options.pot_video_textures && gl_options.rect_textures) {
576  // Enforce max rect texture for movies, which use them
577  if (gl_options.max_movie_dimension > gl_options.max_rect_dimension)
578  gl_options.max_movie_dimension = gl_options.max_rect_dimension;
579  }
580 
581  if (gl_options.pot_video_textures)
582  VSFileSystem::vs_dprintf(1, "Forcing POT video textures\n");
583  else
584  VSFileSystem::vs_dprintf(3, "Using NPOT video textures\n");
585 
586  gl_options.smooth_shade = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "SmoothShade", "true" ) );
587  gl_options.mipmap = XMLSupport::parse_int( vs_config->getVariable( "graphics", "mipmapdetail", "2" ) );
588  gl_options.compression = XMLSupport::parse_int( vs_config->getVariable( "graphics", "texture_compression", "0" ) );
589  gl_options.Multitexture = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "reflection", "true" ) );
590  gl_options.smooth_lines = XMLSupport::parse_bool( vs_config->getVariable( "graphics/mesh", "smooth_lines", "true" ) );
591  gl_options.smooth_points = XMLSupport::parse_bool( vs_config->getVariable( "graphics/mesh", "smooth_points", "true" ) );
592 
593  gl_options.display_lists = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "displaylists", "false" ) );
594  gl_options.s3tc = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "s3tc", "true" ) );
595  gl_options.ext_clamp_to_edge = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "ext_clamp_to_edge", "true" ) );
596  gl_options.ext_clamp_to_border = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "ext_clamp_to_border", "true" ) );
597 
598  vs_config->getColor( "space_background", clearcol );
599  glClearColor( clearcol[0], clearcol[1], clearcol[2], clearcol[3] );
600  winsys_set_reshape_func( Reshape );
601  initfov();
602  glShadeModel( GL_SMOOTH );
603  glEnable( GL_CULL_FACE );
604  glCullFace( GL_BACK );
605  glShadeModel( GL_SMOOTH );
606  glEnable( GL_DEPTH_TEST );
607  glDepthFunc( GL_LESS );
608  if (gl_options.wireframe)
609  glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
610  if (gl_options.smooth_shade == 0)
611  glShadeModel( GL_FLAT );
612  glEnable( GL_ALPHA_TEST );
613  glAlphaFunc( GL_GREATER, 0.0 );
614 
615  init_opengl_extensions();
616  GFXInitTextureManager();
617  if (gl_options.Multitexture)
618  GFXActiveTexture( 0 );
619  glEnable( GL_TEXTURE_2D ); //use two-dimensional texturing
620  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
621  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
622 
623 #if defined (IRIX)
624  glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
625 #endif
626  if ( vsExtensionSupported( "GL_EXT_color_table" ) || vsExtensionSupported( "GL_EXT_shared_texture_palette" ) ) {
627  gl_options.PaletteExt = 1;
628  VSFileSystem::vs_dprintf(3, "OpenGL::EXTColorTable supported\n");
629  } else {
630  gl_options.PaletteExt = 0;
631  VSFileSystem::vs_dprintf( 2, "OpenGL::EXTColorTable unsupported\n" );
632  }
633  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
634  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
635  glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
636  if (gl_options.Multitexture) {
637  for (int i = 1; i < 4; ++i) {
638  GFXActiveTexture( i );
639  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
640  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
641  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
642  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
643  GFXTextureEnv( i, GFXADDTEXTURE );
644  glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 );
645  glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
646  glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
647  glPixelStorei( GL_UNPACK_SWAP_BYTES, 0 );
648  // Choose cubemap or spheremap coordinates.
649  if (i == 1) {
650 #ifdef NV_CUBE_MAP
651  GFXToggleTexture( true, 1, CUBEMAP );
652  GFXTextureCoordGenMode( 1, CUBE_MAP_GEN, NULL, NULL );
653 #else
654  const float tempo[4] = {1, 0, 0, 0};
655  GFXToggleTexture( true, 1, TEXTURE2D );
656  GFXTextureCoordGenMode( 1, SPHERE_MAP_GEN, tempo, tempo );
657 #endif
658  }
659  }
660  }
661  GFXActiveTexture( 0 );
662  glClearDepth( 1 );
663  glEnable( GL_BLEND );
664  glDisable( GL_ALPHA_TEST );
665  GFXBlendMode( ONE, ZERO );
666 
667  glColor3f( 0, 0, 0 );
668  glMatrixMode( GL_MODELVIEW );
669  glLoadIdentity();
670  glMatrixMode( GL_TEXTURE );
671  glLoadIdentity(); //set all matricies to identity
672  glMatrixMode( GL_PROJECTION );
673  glLoadIdentity();
674 
675  glEnable( GL_LIGHTING );
676 
677  glDisable( GL_NORMALIZE );
678 
679  glDisable( GL_LINE_SMOOTH );
680  glDisable( GL_POINT_SMOOTH );
681 
682  int con;
683  GFXCreateLightContext( con );
684  //glutSetCursor(GLUT_CURSOR_NONE);
685  /* Avoid scrambled screen on startup - Twice, for triple buffering */
686  if ( XMLSupport::parse_bool( vs_config->getVariable( "graphics", "ClearOnStartup", "true" ) ) ) {
687  glClear( GL_COLOR_BUFFER_BIT );
688  winsys_swap_buffers();
689  glClear( GL_COLOR_BUFFER_BIT );
690  winsys_swap_buffers();
691  }
692  winsys_show_cursor( false );
693 }
694 
695 #if defined (IRIX)
696 #include "lin_time.h"
697 
698 /*
699 ** Update the game counter, generate a redisplay request.
700 */
701 void idle_loop( void )
702 {
703  UpdateTime();
704  glutPostRedisplay();
705 }
706 
707 /*
708 ** Install idle loop only if window is visible.
709 */
710 void visible( int vis )
711 {
712  glutIdleFunc( vis == GLUT_VISIBLE ? idle_loop : NULL );
713 }
714 
715 /*
716 ** Install the display and visibility callback functions,
717 ** start the main loop.
718 */
719 void GFXLoop( void (*main_loop)( void ) )
720 {
721  glutDisplayFunc( main_loop );
722  glutVisibilityFunc( visible );
723  static bool are_we_looping = false;
725  if (!are_we_looping) {
726  are_we_looping = true;
727  glutMainLoop();
728  }
729 }
730 #else
731 
732 void GFXLoop( void main_loop() )
733 {
734  winsys_set_display_func( main_loop );
735  winsys_set_idle_func( main_loop );
736 
737  //glutDisplayFunc(main_loop);
738  //glutIdleFunc (main_loop);
739  static bool are_we_looping = false;
741  if (!are_we_looping) {
742  are_we_looping = true;
743  winsys_process_events();
744  }
745 }
746 #endif
747 
748 void GFXShutdown()
749 {
750  extern void GFXDestroyAllLights();
751 
752  GFXDestroyAllTextures();
753  GFXDestroyAllLights();
754  if (gl_options.fullscreen)
755  winsys_shutdown();
756 }
757