diff --git a/CMakeLists.txt b/CMakeLists.txt index c6a9b9d09..d6ab70dc1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -73,6 +73,7 @@ else() endif() # Misc +option(XASH_USE_STB_SPRINTF "Use stb_sprintf implementation for sprintf" ON) option(XASH_NO_INSTALL_RUNSCRIPT "Don't install xash3d.sh" OFF) option(XASH_NO_INSTALL_VGUI_BIN "Don't bundle proprietary VGUI" OFF) if(WIN32) # Autodownload for lazy developers using Windows diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt index c6113a927..91408c1c4 100644 --- a/engine/CMakeLists.txt +++ b/engine/CMakeLists.txt @@ -171,6 +171,10 @@ if(XASH_NO_ASYNC_NS_RESOLVE) add_definitions(-DXASH_NO_ASYNC_NS_RESOLVE) endif() +if(XASH_USE_STB_SPRINTF) + add_definitions(-DXASH_USE_STB_SPRINTF) +endif() + fwgs_set_default_properties(${XASH_ENGINE}) if(NOT WIN32) diff --git a/engine/client/gl_local.h b/engine/client/gl_local.h index 6dc0ae21a..83ec5b92f 100644 --- a/engine/client/gl_local.h +++ b/engine/client/gl_local.h @@ -701,6 +701,7 @@ extern convar_t *r_fastsky; extern convar_t *r_vbo; extern convar_t *r_bump; extern convar_t *r_strobe; +extern convar_t *r_underwater_distortion; extern convar_t *mp_decals; diff --git a/engine/client/gl_rmain.c b/engine/client/gl_rmain.c index 3e97a6578..f6c607a8c 100644 --- a/engine/client/gl_rmain.c +++ b/engine/client/gl_rmain.c @@ -837,10 +837,10 @@ R_SetupGL */ static void R_SetupGL( void ) { - if( RI.refdef.waterlevel >= 3 ) + if( r_underwater_distortion->value && RI.refdef.waterlevel >= 3 ) { float f; - f = sin( cl.time * 0.4f * ( M_PI * 2.7f )); + f = sin( cl.time * r_underwater_distortion->value * ( M_PI * 2.7f )); RI.refdef.fov_x += f; RI.refdef.fov_y -= f; } diff --git a/engine/client/keys.c b/engine/client/keys.c index 15beae671..356fbca2f 100644 --- a/engine/client/keys.c +++ b/engine/client/keys.c @@ -846,11 +846,11 @@ CL_CharEvent Normal keyboard characters, already shifted / capslocked / etc =================== */ -void CL_CharEvent( int key ) +void CL_CharEvent( int ch ) { // the console key should never be used as a char #ifdef _WIN32 - if( key == '`' || key == '~' ) return; + if( ch == '`' || ch == '~' ) return; #if 0 if( cls.key_dest == key_console && !Con_Visible( )) @@ -861,13 +861,17 @@ void CL_CharEvent( int key ) #endif #endif // distribute the key down event to the apropriate handler - if( cls.key_dest == key_console || cls.key_dest == key_message ) + + Con_CharEvent( ch ); // a1ba: no need for checks, as Con_CharEvent already it does + + if( cls.key_dest == key_menu ) { - Con_CharEvent( key ); + UI_CharEvent( ch ); } - else if( cls.key_dest == key_menu ) + else if( cls.key_dest == key_game ) // typing support for VGUI { - UI_CharEvent( key ); + VGui_KeyEvent( ch, 2 ); } + } #endif diff --git a/engine/client/touch.c b/engine/client/touch.c index c148527e9..e9167faba 100644 --- a/engine/client/touch.c +++ b/engine/client/touch.c @@ -1678,16 +1678,17 @@ int IN_TouchEvent( touchEventType type, int fingerID, float x, float y, float dx } - VGui_MouseMove( TO_SCRN_X(x), TO_SCRN_Y(y) ); + if( VGui_IsActive() ) + { + VGui_MouseMove( TO_SCRN_X(x), TO_SCRN_Y(y) ); - if( type == event_down ) - VGui_KeyEvent(241, 1); - if( type == event_up ) - VGui_KeyEvent(241, 0); + if( type != event_motion ) + VGui_KeyEvent( K_MOUSE1, type == event_down ? 1 : 0 ); - // allow scoreboard scroll - if( host.mouse_visible && type == event_motion ) - return 0; + // allow scoreboard scroll + if( host.mouse_visible && type == event_motion ) + return 0; + } if( !touch.initialized || (!touch_enable->integer && !touch.clientonly) ) { diff --git a/engine/client/vgui/vgui_draw.c b/engine/client/vgui/vgui_draw.c index 0f4fea550..92e4c8ab7 100644 --- a/engine/client/vgui/vgui_draw.c +++ b/engine/client/vgui/vgui_draw.c @@ -34,6 +34,7 @@ static enum VGUI_DefaultCursor s_currentCursor; #include "platform/sdl/events.h" static SDL_Cursor* s_pDefaultCursor[20]; #endif +static void *s_pVGuiSupport; // vgui_support library void VGUI_DrawInit( void ); void VGUI_DrawShutdown( void ); @@ -77,7 +78,7 @@ void GAME_EXPORT VGUI_GetMousePos( int *_x, int *_y ) { float xscale = scr_width->value / (float)clgame.scrInfo.iWidth; float yscale = scr_height->value / (float)clgame.scrInfo.iHeight; - int x,y; + int x, y; CL_GetMousePosition( &x, &y ); *_x = x / xscale, *_y = y / yscale; @@ -133,7 +134,7 @@ void GAME_EXPORT VGUI_CursorSelect(enum VGUI_DefaultCursor cursor ) { SDL_ShowCursor( false ); if( host.mouse_visible ) - SDL_GetRelativeMouseState( 0, 0 ); + SDL_GetRelativeMouseState( NULL, NULL ); } //SDL_SetRelativeMouseMode(false); #endif @@ -151,12 +152,14 @@ byte GAME_EXPORT VGUI_GetColor( int i, int j) // Define and initialize vgui API -void GAME_EXPORT VGUI_SetVisible ( qboolean state ) +void GAME_EXPORT VGUI_SetVisible( qboolean state ) { host.mouse_visible=state; #ifdef XASH_SDL SDL_ShowCursor( state ); - if(!state) SDL_GetRelativeMouseState( 0, 0 ); + if( !state ) + SDL_GetRelativeMouseState( NULL, NULL ); + SDLash_EnableTextInput( state, true ); #endif } @@ -171,7 +174,7 @@ int GAME_EXPORT VGUI_UtfProcessChar( int in ) vguiapi_t vgui = { - false, //Not initialized yet + false, // Not initialized yet VGUI_DrawInit, VGUI_DrawShutdown, VGUI_SetupDrawingText, @@ -201,11 +204,12 @@ vguiapi_t vgui = NULL, NULL, NULL, -} ; - - -void *lib; //vgui_support library +}; +qboolean VGui_IsActive( void ) +{ + return vgui.initialized; +} /* ================ @@ -226,14 +230,15 @@ void VGui_Startup( int width, int height ) if( failed ) return; -#ifdef XASH_INTERNAL_GAMELIBS + if( !vgui.initialized ) { - lib = Com_LoadLibrary( "client", false ); +#ifdef XASH_INTERNAL_GAMELIBS + s_pVGuiSupport = Com_LoadLibrary( "client", false ); - if( lib ) + if( s_pVGuiSupport ) { - F = Com_GetProcAddress( lib, "InitVGUISupportAPI" ); + F = Com_GetProcAddress( s_pVGuiSupport, "InitVGUISupportAPI" ); if( F ) { F( &vgui ); @@ -242,14 +247,11 @@ void VGui_Startup( int width, int height ) MsgDev( D_INFO, "vgui_support: found interal client support\n" ); } } - } -#endif +#endif // XASH_INTERNAL_GAMELIBS - if( !vgui.initialized ) - { Com_ResetLibraryError(); - // hack: load vgui with correct path first if specified. + // HACKHACK: load vgui with correct path first if specified. // it will be reused while resolving vgui support and client deps if( Sys_GetParmFromCmdLine( "-vguilib", vguilib ) ) { @@ -257,6 +259,7 @@ void VGui_Startup( int width, int height ) Q_strncpy( vguiloader, "vgui_support.dll", 256 ); else Q_strncpy( vguiloader, VGUI_SUPPORT_DLL, 256 ); + if( !Com_LoadLibrary( vguilib, false ) ) MsgDev( D_WARN, "VGUI preloading failed. Default library will be used!\n"); } @@ -267,14 +270,14 @@ void VGui_Startup( int width, int height ) if( !vguiloader[0] && !Sys_GetParmFromCmdLine( "-vguiloader", vguiloader ) ) Q_strncpy( vguiloader, VGUI_SUPPORT_DLL, 256 ); - lib = Com_LoadLibrary( vguiloader, false ); + s_pVGuiSupport = Com_LoadLibrary( vguiloader, false ); - if( !lib ) + if( !s_pVGuiSupport ) { - lib = Com_LoadLibrary( va( "../%s", vguiloader ), false ); + s_pVGuiSupport = Com_LoadLibrary( va( "../%s", vguiloader ), false ); } - if( !lib ) + if( !s_pVGuiSupport ) { if( FS_SysFileExists( vguiloader, false ) ) MsgDev( D_ERROR, "Failed to load vgui_support library: %s", Com_GetLibraryError() ); @@ -283,7 +286,7 @@ void VGui_Startup( int width, int height ) } else { - F = Com_GetProcAddress( lib, "InitAPI" ); + F = Com_GetProcAddress( s_pVGuiSupport, "InitAPI" ); if( F ) { F( &vgui ); @@ -338,9 +341,11 @@ void VGui_Shutdown( void ) { if( vgui.Shutdown ) vgui.Shutdown(); - if( lib ) - Com_FreeLibrary( lib ); - lib = NULL; + + if( s_pVGuiSupport ) + Com_FreeLibrary( s_pVGuiSupport ); + s_pVGuiSupport = NULL; + vgui.initialized = false; } @@ -349,7 +354,8 @@ void VGUI_InitKeyTranslationTable( void ) { static qboolean bInitted = false; - if( bInitted ) return; + if( bInitted ) + return; bInitted = true; // set virtual key translation table @@ -480,10 +486,12 @@ void VGui_KeyEvent( int key, int down ) { if( !vgui.initialized ) return; + #ifdef XASH_SDL if( host.mouse_visible ) SDLash_EnableTextInput( 1, false ); #endif + switch( key ) { case K_MOUSE1: @@ -546,7 +554,7 @@ void GAME_EXPORT VGUI_DrawShutdown( void ) for( i = 1; i < g_textureId; i++ ) { - GL_FreeImage( va( "*vgui%i", i )); + GL_FreeImage( va( "*vgui%i", i )); } } @@ -754,8 +762,6 @@ void VGui_Paint() vgui.Paint(); } - - void VGui_RunFrame() { //stub diff --git a/engine/client/vgui/vgui_draw.h b/engine/client/vgui/vgui_draw.h index 28efca91c..5b4aa12c3 100644 --- a/engine/client/vgui/vgui_draw.h +++ b/engine/client/vgui/vgui_draw.h @@ -33,6 +33,7 @@ void VGui_Paint(); void VGui_RunFrame(); void VGui_KeyEvent( int key, int down ); void VGui_MouseMove( int x, int y ); +qboolean VGui_IsActive( void ); void *pfnVGui_GetPanel(); #ifdef __cplusplus } diff --git a/engine/client/vid_common.c b/engine/client/vid_common.c index 606f0bcaf..003c21d4b 100644 --- a/engine/client/vid_common.c +++ b/engine/client/vid_common.c @@ -79,6 +79,7 @@ convar_t *r_fastsky; convar_t *r_vbo; convar_t *r_bump; convar_t *r_strobe; +convar_t *r_underwater_distortion; convar_t *mp_decals; convar_t *vid_displayfrequency; @@ -869,6 +870,7 @@ void GL_InitCommands( void ) r_decals = Cvar_Get( "r_decals", "4096", 0, "sets the maximum number of decals" ); r_xpos = Cvar_Get( "r_xpos", "130", CVAR_GLCONFIG, "window position by horizontal" ); r_ypos = Cvar_Get( "r_ypos", "48", CVAR_GLCONFIG, "window position by vertical" ); + r_underwater_distortion = Cvar_Get( "r_underwater_distortion", "0.4", CVAR_ARCHIVE, "underwater distortion speed" ); mp_decals = Cvar_Get( "mp_decals", "300", CVAR_ARCHIVE, "sets the maximum number of decals in multiplayer" ); gl_picmip = Cvar_Get( "gl_picmip", "0", CVAR_GLCONFIG, "reduces resolution of textures by powers of 2" ); diff --git a/engine/common/common.h b/engine/common/common.h index 213dc9f02..b1257eee4 100644 --- a/engine/common/common.h +++ b/engine/common/common.h @@ -962,7 +962,7 @@ qboolean CL_IsIntermission( void ); void CL_WarnLostSplitPacket( void ); float CL_GetServerTime( void ); float CL_GetLerpFrac( void ); -void CL_CharEvent( int key ); +void CL_CharEvent( int ch ); qboolean CL_DisableVisibility( void ); int CL_PointContents( const vec3_t point ); char *COM_ParseFile( char *data, char *token ); diff --git a/engine/common/crtlib.c b/engine/common/crtlib.c index 96a312f88..ee93a69f0 100644 --- a/engine/common/crtlib.c +++ b/engine/common/crtlib.c @@ -323,6 +323,7 @@ const char* Q_timestamp( int format ) return timestamp; } + #ifndef XASH_SKIPCRTLIB char *Q_strstr( const char *string, const char *string2 ) { @@ -371,15 +372,13 @@ char *Q_stristr( const char *string, const char *string2 ) } return (char *)string; } -#ifndef USE_STB_SPRINTF -#define USE_STB_SPRINTF 1 -#endif -#if USE_STB_SPRINTF -#define STB_SPRINTF_IMPLEMENTATION -#define STB_SPRINTF_DECORATE(name) Q_##name -#undef Q_vsprintf -#include "stb/stb_sprintf.h" -#else + +#if XASH_USE_STB_SPRINTF + #define STB_SPRINTF_IMPLEMENTATION + #define STB_SPRINTF_DECORATE(name) Q_##name + #undef Q_vsprintf + #include "stb/stb_sprintf.h" +#else // XASH_USE_STB_SPRINTF int Q_vsnprintf( char *buffer, size_t buffersize, const char *format, va_list args ) { int result; @@ -417,8 +416,9 @@ int Q_sprintf( char *buffer, const char *format, ... ) return result; } -#endif // USE_STB_SRPINTF +#endif // XASH_USE_STB_SPRINTF #endif // XASH_SKIPCRTLIB + char *Q_pretifymem( float value, int digitsafterdecimal ) { static char output[8][32]; diff --git a/engine/platform/android/android_nosdl.c b/engine/platform/android/android_nosdl.c index f786b8646..81222ef4d 100644 --- a/engine/platform/android/android_nosdl.c +++ b/engine/platform/android/android_nosdl.c @@ -398,9 +398,7 @@ void Android_RunEvents() } // otherwise just push it by char, text render will decode unicode strings - Con_CharEvent( ch ); - if( cls.key_dest == key_menu ) - UI_CharEvent ( ch ); + CL_CharEvent( ch ); } events.inputtext[0] = 0; // no more text diff --git a/engine/platform/sdl/events.c b/engine/platform/sdl/events.c index 8875ec4af..79bea9d3f 100644 --- a/engine/platform/sdl/events.c +++ b/engine/platform/sdl/events.c @@ -34,9 +34,7 @@ static SDL_Joystick *joy; static SDL_GameController *gamecontroller; void R_ChangeDisplaySettingsFast( int w, int h ); -void SDLash_SendCharEvent( int ch ); -#define DECLARE_KEY_RANGE( min, max, repl ) if( keynum >= (min) && keynum <= (max) ) { keynum = keynum - (min) + (repl); } void SDLash_KeyEvent( SDL_KeyboardEvent key, int down ) { @@ -49,16 +47,24 @@ void SDLash_KeyEvent( SDL_KeyboardEvent key, int down ) if( keynum >= SDL_SCANCODE_A && keynum <= SDL_SCANCODE_Z ) { keynum = keynum - SDL_SCANCODE_A + 1; - SDLash_SendCharEvent( keynum ); + CL_CharEvent( keynum ); } return; } } +#define DECLARE_KEY_RANGE( min, max, repl ) \ + if( keynum >= (min) && keynum <= (max) ) \ + { \ + keynum = keynum - (min) + (repl); \ + } + DECLARE_KEY_RANGE( SDL_SCANCODE_A, SDL_SCANCODE_Z, 'a' ) else DECLARE_KEY_RANGE( SDL_SCANCODE_1, SDL_SCANCODE_9, '1' ) else DECLARE_KEY_RANGE( SDL_SCANCODE_F1, SDL_SCANCODE_F12, K_F1 ) + +#undef DECLARE_KEY_RANGE else { switch( keynum ) @@ -123,6 +129,13 @@ void SDLash_KeyEvent( SDL_KeyboardEvent key, int down ) host.force_draw_version_time = host.realtime + FORCE_DRAW_VERSION_TIME; break; } + // don't console spam on known functional buttons, but not used in engine + case SDL_SCANCODE_MUTE: + case SDL_SCANCODE_VOLUMEUP: + case SDL_SCANCODE_VOLUMEDOWN: + case SDL_SCANCODE_BRIGHTNESSDOWN: + case SDL_SCANCODE_BRIGHTNESSUP: + return; case SDL_SCANCODE_UNKNOWN: { if( down ) MsgDev( D_INFO, "SDLash_KeyEvent: Unknown scancode\n" ); @@ -137,7 +150,7 @@ void SDLash_KeyEvent( SDL_KeyboardEvent key, int down ) Key_Event( keynum, down ); } -void SDLash_MouseEvent(SDL_MouseButtonEvent button) +void SDLash_MouseEvent( SDL_MouseButtonEvent button ) { int down = button.type == SDL_MOUSEBUTTONDOWN ? 1 : 0; if( in_mouseinitialized && !m_ignore->integer && button.which != SDL_TOUCH_MOUSEID ) @@ -146,13 +159,13 @@ void SDLash_MouseEvent(SDL_MouseButtonEvent button) } } -void SDLash_WheelEvent(SDL_MouseWheelEvent wheel) +void SDLash_WheelEvent( SDL_MouseWheelEvent wheel ) { wheelbutton = wheel.y < 0 ? K_MWHEELDOWN : K_MWHEELUP; Key_Event( wheelbutton, true ); } -void SDLash_InputEvent(SDL_TextInputEvent input) +void SDLash_InputEvent( SDL_TextInputEvent input ) { int i; @@ -169,19 +182,10 @@ void SDLash_InputEvent(SDL_TextInputEvent input) if( !ch ) continue; - SDLash_SendCharEvent( ch ); + CL_CharEvent( ch ); } } -void SDLash_SendCharEvent( int ch ) -{ - Con_CharEvent( ch ); - if( cls.key_dest == key_menu ) - UI_CharEvent ( ch ); - if( cls.key_dest == key_game ) - VGui_KeyEvent( ch, 2 ); -} - void SDLash_EnableTextInput( int enable, qboolean force ) { if( force ) @@ -383,7 +387,6 @@ void SDLash_EventFilter( void *ev ) }; // TODO: Use joyinput funcs, for future multiple gamepads support - if( Joy_IsActive() ) Key_Event( sdlControllerButtonToEngine[event->cbutton.button], event->cbutton.state ); break; diff --git a/engine/platform/sdl/gl_sdl.c b/engine/platform/sdl/gl_sdl.c index 9ba687052..b2ae00a40 100644 --- a/engine/platform/sdl/gl_sdl.c +++ b/engine/platform/sdl/gl_sdl.c @@ -13,12 +13,15 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */ #include "common.h" -#if XASH_VIDEO == VIDEO_SDL && !defined XASH_GL_STATIC +#if XASH_VIDEO == VIDEO_SDL #include "client.h" #include "gl_local.h" #include "mod_local.h" #include "gl_vidnt.h" #include +#ifdef XASH_NANOGL +#include +#endif #ifdef WIN32 // Enable NVIDIA High Performance Graphics while using Integrated Graphics. @@ -28,312 +31,319 @@ __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001; __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1; #endif +#ifndef XASH_GL_STATIC +#define GL_CALL( x ) #x, (void **)&p##x +#define GL_CALL_EX( x, y ) #x, (void **)&p##y +#else +#define GL_CALL( x ) #x, NULL +#define GL_CALL_EX( x, y ) #x, NULL +#endif static dllfunc_t opengl_110funcs[] = { -{ "glClearColor" , (void **)&pglClearColor }, -{ "glClear" , (void **)&pglClear }, -{ "glAlphaFunc" , (void **)&pglAlphaFunc }, -{ "glBlendFunc" , (void **)&pglBlendFunc }, -{ "glCullFace" , (void **)&pglCullFace }, -{ "glDrawBuffer" , (void **)&pglDrawBuffer }, -{ "glReadBuffer" , (void **)&pglReadBuffer }, -{ "glEnable" , (void **)&pglEnable }, -{ "glDisable" , (void **)&pglDisable }, -{ "glEnableClientState" , (void **)&pglEnableClientState }, -{ "glDisableClientState" , (void **)&pglDisableClientState }, -{ "glGetBooleanv" , (void **)&pglGetBooleanv }, -{ "glGetDoublev" , (void **)&pglGetDoublev }, -{ "glGetFloatv" , (void **)&pglGetFloatv }, -{ "glGetIntegerv" , (void **)&pglGetIntegerv }, -{ "glGetError" , (void **)&pglGetError }, -{ "glGetString" , (void **)&pglGetString }, -{ "glFinish" , (void **)&pglFinish }, -{ "glFlush" , (void **)&pglFlush }, -{ "glClearDepth" , (void **)&pglClearDepth }, -{ "glDepthFunc" , (void **)&pglDepthFunc }, -{ "glDepthMask" , (void **)&pglDepthMask }, -{ "glDepthRange" , (void **)&pglDepthRange }, -{ "glFrontFace" , (void **)&pglFrontFace }, -{ "glDrawElements" , (void **)&pglDrawElements }, -{ "glDrawArrays" , (void **)&pglDrawArrays }, -{ "glColorMask" , (void **)&pglColorMask }, -{ "glIndexPointer" , (void **)&pglIndexPointer }, -{ "glVertexPointer" , (void **)&pglVertexPointer }, -{ "glNormalPointer" , (void **)&pglNormalPointer }, -{ "glColorPointer" , (void **)&pglColorPointer }, -{ "glTexCoordPointer" , (void **)&pglTexCoordPointer }, -{ "glArrayElement" , (void **)&pglArrayElement }, -{ "glColor3f" , (void **)&pglColor3f }, -{ "glColor3fv" , (void **)&pglColor3fv }, -{ "glColor4f" , (void **)&pglColor4f }, -{ "glColor4fv" , (void **)&pglColor4fv }, -{ "glColor3ub" , (void **)&pglColor3ub }, -{ "glColor4ub" , (void **)&pglColor4ub }, -{ "glColor4ubv" , (void **)&pglColor4ubv }, -{ "glTexCoord1f" , (void **)&pglTexCoord1f }, -{ "glTexCoord2f" , (void **)&pglTexCoord2f }, -{ "glTexCoord3f" , (void **)&pglTexCoord3f }, -{ "glTexCoord4f" , (void **)&pglTexCoord4f }, -{ "glTexGenf" , (void **)&pglTexGenf }, -{ "glTexGenfv" , (void **)&pglTexGenfv }, -{ "glTexGeni" , (void **)&pglTexGeni }, -{ "glVertex2f" , (void **)&pglVertex2f }, -{ "glVertex3f" , (void **)&pglVertex3f }, -{ "glVertex3fv" , (void **)&pglVertex3fv }, -{ "glNormal3f" , (void **)&pglNormal3f }, -{ "glNormal3fv" , (void **)&pglNormal3fv }, -{ "glBegin" , (void **)&pglBegin }, -{ "glEnd" , (void **)&pglEnd }, -{ "glLineWidth" , (void**)&pglLineWidth }, -{ "glPointSize" , (void**)&pglPointSize }, -{ "glMatrixMode" , (void **)&pglMatrixMode }, -{ "glOrtho" , (void **)&pglOrtho }, -{ "glRasterPos2f" , (void **)&pglRasterPos2f }, -{ "glFrustum" , (void **)&pglFrustum }, -{ "glViewport" , (void **)&pglViewport }, -{ "glPushMatrix" , (void **)&pglPushMatrix }, -{ "glPopMatrix" , (void **)&pglPopMatrix }, -{ "glPushAttrib" , (void **)&pglPushAttrib }, -{ "glPopAttrib" , (void **)&pglPopAttrib }, -{ "glLoadIdentity" , (void **)&pglLoadIdentity }, -{ "glLoadMatrixd" , (void **)&pglLoadMatrixd }, -{ "glLoadMatrixf" , (void **)&pglLoadMatrixf }, -{ "glMultMatrixd" , (void **)&pglMultMatrixd }, -{ "glMultMatrixf" , (void **)&pglMultMatrixf }, -{ "glRotated" , (void **)&pglRotated }, -{ "glRotatef" , (void **)&pglRotatef }, -{ "glScaled" , (void **)&pglScaled }, -{ "glScalef" , (void **)&pglScalef }, -{ "glTranslated" , (void **)&pglTranslated }, -{ "glTranslatef" , (void **)&pglTranslatef }, -{ "glReadPixels" , (void **)&pglReadPixels }, -{ "glDrawPixels" , (void **)&pglDrawPixels }, -{ "glStencilFunc" , (void **)&pglStencilFunc }, -{ "glStencilMask" , (void **)&pglStencilMask }, -{ "glStencilOp" , (void **)&pglStencilOp }, -{ "glClearStencil" , (void **)&pglClearStencil }, -{ "glIsEnabled" , (void **)&pglIsEnabled }, -{ "glIsList" , (void **)&pglIsList }, -{ "glIsTexture" , (void **)&pglIsTexture }, -{ "glTexEnvf" , (void **)&pglTexEnvf }, -{ "glTexEnvfv" , (void **)&pglTexEnvfv }, -{ "glTexEnvi" , (void **)&pglTexEnvi }, -{ "glTexParameterf" , (void **)&pglTexParameterf }, -{ "glTexParameterfv" , (void **)&pglTexParameterfv }, -{ "glTexParameteri" , (void **)&pglTexParameteri }, -{ "glHint" , (void **)&pglHint }, -{ "glPixelStoref" , (void **)&pglPixelStoref }, -{ "glPixelStorei" , (void **)&pglPixelStorei }, -{ "glGenTextures" , (void **)&pglGenTextures }, -{ "glDeleteTextures" , (void **)&pglDeleteTextures }, -{ "glBindTexture" , (void **)&pglBindTexture }, -{ "glTexImage1D" , (void **)&pglTexImage1D }, -{ "glTexImage2D" , (void **)&pglTexImage2D }, -{ "glTexSubImage1D" , (void **)&pglTexSubImage1D }, -{ "glTexSubImage2D" , (void **)&pglTexSubImage2D }, -{ "glCopyTexImage1D" , (void **)&pglCopyTexImage1D }, -{ "glCopyTexImage2D" , (void **)&pglCopyTexImage2D }, -{ "glCopyTexSubImage1D" , (void **)&pglCopyTexSubImage1D }, -{ "glCopyTexSubImage2D" , (void **)&pglCopyTexSubImage2D }, -{ "glScissor" , (void **)&pglScissor }, -{ "glGetTexEnviv" , (void **)&pglGetTexEnviv }, -{ "glPolygonOffset" , (void **)&pglPolygonOffset }, -{ "glPolygonMode" , (void **)&pglPolygonMode }, -{ "glPolygonStipple" , (void **)&pglPolygonStipple }, -{ "glClipPlane" , (void **)&pglClipPlane }, -{ "glGetClipPlane" , (void **)&pglGetClipPlane }, -{ "glShadeModel" , (void **)&pglShadeModel }, -{ "glFogfv" , (void **)&pglFogfv }, -{ "glFogf" , (void **)&pglFogf }, -{ "glFogi" , (void **)&pglFogi }, +{ GL_CALL( glClearColor ) }, +{ GL_CALL( glClear ) }, +{ GL_CALL( glAlphaFunc ) }, +{ GL_CALL( glBlendFunc ) }, +{ GL_CALL( glCullFace ) }, +{ GL_CALL( glDrawBuffer ) }, +{ GL_CALL( glReadBuffer ) }, +{ GL_CALL( glEnable ) }, +{ GL_CALL( glDisable ) }, +{ GL_CALL( glEnableClientState ) }, +{ GL_CALL( glDisableClientState ) }, +{ GL_CALL( glGetBooleanv ) }, +{ GL_CALL( glGetDoublev ) }, +{ GL_CALL( glGetFloatv ) }, +{ GL_CALL( glGetIntegerv ) }, +{ GL_CALL( glGetError ) }, +{ GL_CALL( glGetString ) }, +{ GL_CALL( glFinish ) }, +{ GL_CALL( glFlush ) }, +{ GL_CALL( glClearDepth ) }, +{ GL_CALL( glDepthFunc ) }, +{ GL_CALL( glDepthMask ) }, +{ GL_CALL( glDepthRange ) }, +{ GL_CALL( glFrontFace ) }, +{ GL_CALL( glDrawElements ) }, +{ GL_CALL( glDrawArrays ) }, +{ GL_CALL( glColorMask ) }, +{ GL_CALL( glIndexPointer ) }, +{ GL_CALL( glVertexPointer ) }, +{ GL_CALL( glNormalPointer ) }, +{ GL_CALL( glColorPointer ) }, +{ GL_CALL( glTexCoordPointer ) }, +{ GL_CALL( glArrayElement ) }, +{ GL_CALL( glColor3f ) }, +{ GL_CALL( glColor3fv ) }, +{ GL_CALL( glColor4f ) }, +{ GL_CALL( glColor4fv ) }, +{ GL_CALL( glColor3ub ) }, +{ GL_CALL( glColor4ub ) }, +{ GL_CALL( glColor4ubv ) }, +{ GL_CALL( glTexCoord1f ) }, +{ GL_CALL( glTexCoord2f ) }, +{ GL_CALL( glTexCoord3f ) }, +{ GL_CALL( glTexCoord4f ) }, +{ GL_CALL( glTexGenf ) }, +{ GL_CALL( glTexGenfv ) }, +{ GL_CALL( glTexGeni ) }, +{ GL_CALL( glVertex2f ) }, +{ GL_CALL( glVertex3f ) }, +{ GL_CALL( glVertex3fv ) }, +{ GL_CALL( glNormal3f ) }, +{ GL_CALL( glNormal3fv ) }, +{ GL_CALL( glBegin ) }, +{ GL_CALL( glEnd ) }, +{ GL_CALL( glLineWidth ) }, +{ GL_CALL( glPointSize ) }, +{ GL_CALL( glMatrixMode ) }, +{ GL_CALL( glOrtho ) }, +{ GL_CALL( glRasterPos2f ) }, +{ GL_CALL( glFrustum ) }, +{ GL_CALL( glViewport ) }, +{ GL_CALL( glPushMatrix ) }, +{ GL_CALL( glPopMatrix ) }, +{ GL_CALL( glPushAttrib ) }, +{ GL_CALL( glPopAttrib ) }, +{ GL_CALL( glLoadIdentity ) }, +{ GL_CALL( glLoadMatrixd ) }, +{ GL_CALL( glLoadMatrixf ) }, +{ GL_CALL( glMultMatrixd ) }, +{ GL_CALL( glMultMatrixf ) }, +{ GL_CALL( glRotated ) }, +{ GL_CALL( glRotatef ) }, +{ GL_CALL( glScaled ) }, +{ GL_CALL( glScalef ) }, +{ GL_CALL( glTranslated ) }, +{ GL_CALL( glTranslatef ) }, +{ GL_CALL( glReadPixels ) }, +{ GL_CALL( glDrawPixels ) }, +{ GL_CALL( glStencilFunc ) }, +{ GL_CALL( glStencilMask ) }, +{ GL_CALL( glStencilOp ) }, +{ GL_CALL( glClearStencil ) }, +{ GL_CALL( glIsEnabled ) }, +{ GL_CALL( glIsList ) }, +{ GL_CALL( glIsTexture ) }, +{ GL_CALL( glTexEnvf ) }, +{ GL_CALL( glTexEnvfv ) }, +{ GL_CALL( glTexEnvi ) }, +{ GL_CALL( glTexParameterf ) }, +{ GL_CALL( glTexParameterfv ) }, +{ GL_CALL( glTexParameteri ) }, +{ GL_CALL( glHint ) }, +{ GL_CALL( glPixelStoref ) }, +{ GL_CALL( glPixelStorei ) }, +{ GL_CALL( glGenTextures ) }, +{ GL_CALL( glDeleteTextures ) }, +{ GL_CALL( glBindTexture ) }, +{ GL_CALL( glTexImage1D ) }, +{ GL_CALL( glTexImage2D ) }, +{ GL_CALL( glTexSubImage1D ) }, +{ GL_CALL( glTexSubImage2D ) }, +{ GL_CALL( glCopyTexImage1D ) }, +{ GL_CALL( glCopyTexImage2D ) }, +{ GL_CALL( glCopyTexSubImage1D ) }, +{ GL_CALL( glCopyTexSubImage2D ) }, +{ GL_CALL( glScissor ) }, +{ GL_CALL( glGetTexEnviv ) }, +{ GL_CALL( glPolygonOffset ) }, +{ GL_CALL( glPolygonMode ) }, +{ GL_CALL( glPolygonStipple ) }, +{ GL_CALL( glClipPlane ) }, +{ GL_CALL( glGetClipPlane ) }, +{ GL_CALL( glShadeModel ) }, +{ GL_CALL( glFogfv ) }, +{ GL_CALL( glFogf ) }, +{ GL_CALL( glFogi ) }, { NULL, NULL } }; static dllfunc_t pointparametersfunc[] = { -{ "glPointParameterfEXT" , (void **)&pglPointParameterfEXT }, -{ "glPointParameterfvEXT" , (void **)&pglPointParameterfvEXT }, +{ GL_CALL( glPointParameterfEXT ) }, +{ GL_CALL( glPointParameterfvEXT ) }, { NULL, NULL } }; static dllfunc_t drawrangeelementsfuncs[] = { -{ "glDrawRangeElements" , (void **)&pglDrawRangeElements }, +{ GL_CALL( glDrawRangeElements ) }, { NULL, NULL } }; static dllfunc_t drawrangeelementsextfuncs[] = { -{ "glDrawRangeElementsEXT" , (void **)&pglDrawRangeElementsEXT }, +{ GL_CALL( glDrawRangeElementsEXT ) }, { NULL, NULL } }; static dllfunc_t debugoutputfuncs[] = { -{ "glDebugMessageControlARB" , (void **)&pglDebugMessageControlARB }, -{ "glDebugMessageInsertARB" , (void **)&pglDebugMessageInsertARB }, -{ "glDebugMessageCallbackARB" , (void **)&pglDebugMessageCallbackARB }, -{ "glGetDebugMessageLogARB" , (void **)&pglGetDebugMessageLogARB }, -{ NULL , NULL } +{ GL_CALL( glDebugMessageControlARB ) }, +{ GL_CALL( glDebugMessageInsertARB ) }, +{ GL_CALL( glDebugMessageCallbackARB ) }, +{ GL_CALL( glGetDebugMessageLogARB ) }, +{ NULL, NULL } }; static dllfunc_t sgis_multitexturefuncs[] = { -{ "glSelectTextureSGIS" , (void **)&pglSelectTextureSGIS }, -{ "glMTexCoord2fSGIS" , (void **)&pglMTexCoord2fSGIS }, +{ GL_CALL( glSelectTextureSGIS ) }, +{ GL_CALL( glMTexCoord2fSGIS ) }, // , { NULL, NULL } }; static dllfunc_t multitexturefuncs[] = { -{ "glMultiTexCoord1fARB" , (void **)&pglMultiTexCoord1f }, -{ "glMultiTexCoord2fARB" , (void **)&pglMultiTexCoord2f }, -{ "glMultiTexCoord3fARB" , (void **)&pglMultiTexCoord3f }, -{ "glMultiTexCoord4fARB" , (void **)&pglMultiTexCoord4f }, -{ "glActiveTextureARB" , (void **)&pglActiveTextureARB }, -{ "glClientActiveTextureARB" , (void **)&pglClientActiveTexture }, -{ "glClientActiveTextureARB" , (void **)&pglClientActiveTextureARB }, +{ GL_CALL_EX( glMultiTexCoord1fARB, glMultiTexCoord1f ) }, +{ GL_CALL_EX( glMultiTexCoord2fARB, glMultiTexCoord2f ) }, +{ GL_CALL_EX( glMultiTexCoord3fARB, glMultiTexCoord3f ) }, +{ GL_CALL_EX( glMultiTexCoord4fARB, glMultiTexCoord4f ) }, +{ GL_CALL( glActiveTextureARB ) }, +{ GL_CALL_EX( glClientActiveTextureARB, glClientActiveTexture ) }, +{ GL_CALL( glClientActiveTextureARB ) }, { NULL, NULL } }; static dllfunc_t compiledvertexarrayfuncs[] = { -{ "glLockArraysEXT" , (void **)&pglLockArraysEXT }, -{ "glUnlockArraysEXT" , (void **)&pglUnlockArraysEXT }, +{ GL_CALL( glLockArraysEXT ) }, +{ GL_CALL( glUnlockArraysEXT ) }, { NULL, NULL } }; static dllfunc_t texture3dextfuncs[] = { -{ "glTexImage3DEXT" , (void **)&pglTexImage3D }, -{ "glTexSubImage3DEXT" , (void **)&pglTexSubImage3D }, -{ "glCopyTexSubImage3DEXT" , (void **)&pglCopyTexSubImage3D }, +{ GL_CALL_EX( glTexImage3DEXT, glTexImage3D ) }, +{ GL_CALL_EX( glTexSubImage3DEXT, glTexSubImage3D ) }, +{ GL_CALL_EX( glCopyTexSubImage3DEXT, glCopyTexSubImage3D ) }, { NULL, NULL } }; static dllfunc_t atiseparatestencilfuncs[] = { -{ "glStencilOpSeparateATI" , (void **)&pglStencilOpSeparate }, -{ "glStencilFuncSeparateATI" , (void **)&pglStencilFuncSeparate }, +{ GL_CALL_EX( glStencilOpSeparateATI, glStencilOpSeparate ) }, +{ GL_CALL_EX( glStencilFuncSeparateATI, glStencilFuncSeparate ) }, { NULL, NULL } }; static dllfunc_t gl2separatestencilfuncs[] = { -{ "glStencilOpSeparate" , (void **)&pglStencilOpSeparate }, -{ "glStencilFuncSeparate" , (void **)&pglStencilFuncSeparate }, +{ GL_CALL( glStencilOpSeparate ) }, +{ GL_CALL( glStencilFuncSeparate ) }, { NULL, NULL } }; static dllfunc_t stenciltwosidefuncs[] = { -{ "glActiveStencilFaceEXT" , (void **)&pglActiveStencilFaceEXT }, +{ GL_CALL( glActiveStencilFaceEXT ) }, { NULL, NULL } }; static dllfunc_t blendequationfuncs[] = { -{ "glBlendEquationEXT" , (void **)&pglBlendEquationEXT }, +{ GL_CALL( glBlendEquationEXT ) }, { NULL, NULL } }; static dllfunc_t shaderobjectsfuncs[] = { -{ "glDeleteObjectARB" , (void **)&pglDeleteObjectARB }, -{ "glGetHandleARB" , (void **)&pglGetHandleARB }, -{ "glDetachObjectARB" , (void **)&pglDetachObjectARB }, -{ "glCreateShaderObjectARB" , (void **)&pglCreateShaderObjectARB }, -{ "glShaderSourceARB" , (void **)&pglShaderSourceARB }, -{ "glCompileShaderARB" , (void **)&pglCompileShaderARB }, -{ "glCreateProgramObjectARB" , (void **)&pglCreateProgramObjectARB }, -{ "glAttachObjectARB" , (void **)&pglAttachObjectARB }, -{ "glLinkProgramARB" , (void **)&pglLinkProgramARB }, -{ "glUseProgramObjectARB" , (void **)&pglUseProgramObjectARB }, -{ "glValidateProgramARB" , (void **)&pglValidateProgramARB }, -{ "glUniform1fARB" , (void **)&pglUniform1fARB }, -{ "glUniform2fARB" , (void **)&pglUniform2fARB }, -{ "glUniform3fARB" , (void **)&pglUniform3fARB }, -{ "glUniform4fARB" , (void **)&pglUniform4fARB }, -{ "glUniform1iARB" , (void **)&pglUniform1iARB }, -{ "glUniform2iARB" , (void **)&pglUniform2iARB }, -{ "glUniform3iARB" , (void **)&pglUniform3iARB }, -{ "glUniform4iARB" , (void **)&pglUniform4iARB }, -{ "glUniform1fvARB" , (void **)&pglUniform1fvARB }, -{ "glUniform2fvARB" , (void **)&pglUniform2fvARB }, -{ "glUniform3fvARB" , (void **)&pglUniform3fvARB }, -{ "glUniform4fvARB" , (void **)&pglUniform4fvARB }, -{ "glUniform1ivARB" , (void **)&pglUniform1ivARB }, -{ "glUniform2ivARB" , (void **)&pglUniform2ivARB }, -{ "glUniform3ivARB" , (void **)&pglUniform3ivARB }, -{ "glUniform4ivARB" , (void **)&pglUniform4ivARB }, -{ "glUniformMatrix2fvARB" , (void **)&pglUniformMatrix2fvARB }, -{ "glUniformMatrix3fvARB" , (void **)&pglUniformMatrix3fvARB }, -{ "glUniformMatrix4fvARB" , (void **)&pglUniformMatrix4fvARB }, -{ "glGetObjectParameterfvARB" , (void **)&pglGetObjectParameterfvARB }, -{ "glGetObjectParameterivARB" , (void **)&pglGetObjectParameterivARB }, -{ "glGetInfoLogARB" , (void **)&pglGetInfoLogARB }, -{ "glGetAttachedObjectsARB" , (void **)&pglGetAttachedObjectsARB }, -{ "glGetUniformLocationARB" , (void **)&pglGetUniformLocationARB }, -{ "glGetActiveUniformARB" , (void **)&pglGetActiveUniformARB }, -{ "glGetUniformfvARB" , (void **)&pglGetUniformfvARB }, -{ "glGetUniformivARB" , (void **)&pglGetUniformivARB }, -{ "glGetShaderSourceARB" , (void **)&pglGetShaderSourceARB }, -{ "glVertexAttribPointerARB" , (void **)&pglVertexAttribPointerARB }, -{ "glEnableVertexAttribArrayARB" , (void **)&pglEnableVertexAttribArrayARB }, -{ "glDisableVertexAttribArrayARB" , (void **)&pglDisableVertexAttribArrayARB }, -{ "glBindAttribLocationARB" , (void **)&pglBindAttribLocationARB }, -{ "glGetActiveAttribARB" , (void **)&pglGetActiveAttribARB }, -{ "glGetAttribLocationARB" , (void **)&pglGetAttribLocationARB }, +{ GL_CALL( glDeleteObjectARB ) }, +{ GL_CALL( glGetHandleARB ) }, +{ GL_CALL( glDetachObjectARB ) }, +{ GL_CALL( glCreateShaderObjectARB ) }, +{ GL_CALL( glShaderSourceARB ) }, +{ GL_CALL( glCompileShaderARB ) }, +{ GL_CALL( glCreateProgramObjectARB ) }, +{ GL_CALL( glAttachObjectARB ) }, +{ GL_CALL( glLinkProgramARB ) }, +{ GL_CALL( glUseProgramObjectARB ) }, +{ GL_CALL( glValidateProgramARB ) }, +{ GL_CALL( glUniform1fARB ) }, +{ GL_CALL( glUniform2fARB ) }, +{ GL_CALL( glUniform3fARB ) }, +{ GL_CALL( glUniform4fARB ) }, +{ GL_CALL( glUniform1iARB ) }, +{ GL_CALL( glUniform2iARB ) }, +{ GL_CALL( glUniform3iARB ) }, +{ GL_CALL( glUniform4iARB ) }, +{ GL_CALL( glUniform1fvARB ) }, +{ GL_CALL( glUniform2fvARB ) }, +{ GL_CALL( glUniform3fvARB ) }, +{ GL_CALL( glUniform4fvARB ) }, +{ GL_CALL( glUniform1ivARB ) }, +{ GL_CALL( glUniform2ivARB ) }, +{ GL_CALL( glUniform3ivARB ) }, +{ GL_CALL( glUniform4ivARB ) }, +{ GL_CALL( glUniformMatrix2fvARB ) }, +{ GL_CALL( glUniformMatrix3fvARB ) }, +{ GL_CALL( glUniformMatrix4fvARB ) }, +{ GL_CALL( glGetObjectParameterfvARB ) }, +{ GL_CALL( glGetObjectParameterivARB ) }, +{ GL_CALL( glGetInfoLogARB ) }, +{ GL_CALL( glGetAttachedObjectsARB ) }, +{ GL_CALL( glGetUniformLocationARB ) }, +{ GL_CALL( glGetActiveUniformARB ) }, +{ GL_CALL( glGetUniformfvARB ) }, +{ GL_CALL( glGetUniformivARB ) }, +{ GL_CALL( glGetShaderSourceARB ) }, +{ GL_CALL( glVertexAttribPointerARB ) }, +{ GL_CALL( glEnableVertexAttribArrayARB ) }, +{ GL_CALL( glDisableVertexAttribArrayARB ) }, +{ GL_CALL( glBindAttribLocationARB ) }, +{ GL_CALL( glGetActiveAttribARB ) }, +{ GL_CALL( glGetAttribLocationARB ) }, { NULL, NULL } }; static dllfunc_t vertexshaderfuncs[] = { -{ "glVertexAttribPointerARB" , (void **)&pglVertexAttribPointerARB }, -{ "glEnableVertexAttribArrayARB" , (void **)&pglEnableVertexAttribArrayARB }, -{ "glDisableVertexAttribArrayARB" , (void **)&pglDisableVertexAttribArrayARB }, -{ "glBindAttribLocationARB" , (void **)&pglBindAttribLocationARB }, -{ "glGetActiveAttribARB" , (void **)&pglGetActiveAttribARB }, -{ "glGetAttribLocationARB" , (void **)&pglGetAttribLocationARB }, +{ GL_CALL( glVertexAttribPointerARB ) }, +{ GL_CALL( glEnableVertexAttribArrayARB ) }, +{ GL_CALL( glDisableVertexAttribArrayARB ) }, +{ GL_CALL( glBindAttribLocationARB ) }, +{ GL_CALL( glGetActiveAttribARB ) }, +{ GL_CALL( glGetAttribLocationARB ) }, { NULL, NULL } }; static dllfunc_t vbofuncs[] = { -{ "glBindBufferARB" , (void **)&pglBindBufferARB }, -{ "glDeleteBuffersARB" , (void **)&pglDeleteBuffersARB }, -{ "glGenBuffersARB" , (void **)&pglGenBuffersARB }, -{ "glIsBufferARB" , (void **)&pglIsBufferARB }, -{ "glMapBufferARB" , (void **)&pglMapBufferARB }, -{ "glUnmapBufferARB" , (void **)&pglUnmapBufferARB }, -{ "glBufferDataARB" , (void **)&pglBufferDataARB }, -{ "glBufferSubDataARB" , (void **)&pglBufferSubDataARB }, +{ GL_CALL( glBindBufferARB ) }, +{ GL_CALL( glDeleteBuffersARB ) }, +{ GL_CALL( glGenBuffersARB ) }, +{ GL_CALL( glIsBufferARB ) }, +{ GL_CALL( glMapBufferARB ) }, +{ GL_CALL( glUnmapBufferARB ) }, // , +{ GL_CALL( glBufferDataARB ) }, +{ GL_CALL( glBufferSubDataARB ) }, { NULL, NULL} }; static dllfunc_t occlusionfunc[] = { -{ "glGenQueriesARB" , (void **)&pglGenQueriesARB }, -{ "glDeleteQueriesARB" , (void **)&pglDeleteQueriesARB }, -{ "glIsQueryARB" , (void **)&pglIsQueryARB }, -{ "glBeginQueryARB" , (void **)&pglBeginQueryARB }, -{ "glEndQueryARB" , (void **)&pglEndQueryARB }, -{ "glGetQueryivARB" , (void **)&pglGetQueryivARB }, -{ "glGetQueryObjectivARB" , (void **)&pglGetQueryObjectivARB }, -{ "glGetQueryObjectuivARB" , (void **)&pglGetQueryObjectuivARB }, +{ GL_CALL( glGenQueriesARB ) }, +{ GL_CALL( glDeleteQueriesARB ) }, +{ GL_CALL( glIsQueryARB ) }, +{ GL_CALL( glBeginQueryARB ) }, +{ GL_CALL( glEndQueryARB ) }, +{ GL_CALL( glGetQueryivARB ) }, +{ GL_CALL( glGetQueryObjectivARB ) }, //, +{ GL_CALL( glGetQueryObjectuivARB ) }, { NULL, NULL } }; static dllfunc_t texturecompressionfuncs[] = { -{ "glCompressedTexImage3DARB" , (void **)&pglCompressedTexImage3DARB }, -{ "glCompressedTexImage2DARB" , (void **)&pglCompressedTexImage2DARB }, -{ "glCompressedTexImage1DARB" , (void **)&pglCompressedTexImage1DARB }, -{ "glCompressedTexSubImage3DARB" , (void **)&pglCompressedTexSubImage3DARB }, -{ "glCompressedTexSubImage2DARB" , (void **)&pglCompressedTexSubImage2DARB }, -{ "glCompressedTexSubImage1DARB" , (void **)&pglCompressedTexSubImage1DARB }, -{ "glGetCompressedTexImageARB" , (void **)&pglGetCompressedTexImage }, +{ GL_CALL( glCompressedTexImage3DARB ) }, +{ GL_CALL( glCompressedTexImage2DARB ) }, +{ GL_CALL( glCompressedTexImage1DARB ) }, +{ GL_CALL( glCompressedTexSubImage3DARB ) }, +{ GL_CALL( glCompressedTexSubImage2DARB ) }, +{ GL_CALL( glCompressedTexSubImage1DARB ) }, +{ GL_CALL_EX( glGetCompressedTexImageARB, glGetCompressedTexImage ) }, { NULL, NULL } }; @@ -421,10 +431,10 @@ void GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cv if( parm->integer == 0 || ( gl_extensions->integer == 0 && r_ext != GL_OPENGL_110 )) { MsgDev( D_NOTE, "- disabled\n" ); - GL_SetExtension( r_ext, 0 ); + GL_SetExtension( r_ext, false ); return; // nothing to process at } - GL_SetExtension( r_ext, 1 ); + GL_SetExtension( r_ext, true ); } if(( name[2] == '_' || name[3] == '_' ) && !Q_strstr( glConfig.extensions_string, name )) @@ -435,17 +445,21 @@ void GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cv } // clear exports +#ifndef XASH_GL_STATIC // we don't use function ptrs if static for( func = funcs; func && func->name; func++ ) *func->func = NULL; +#endif GL_SetExtension( r_ext, true ); // predict extension state +#ifndef XASH_GL_STATIC // we don't use function ptrs if static for( func = funcs; func && func->name != NULL; func++ ) { // functions are cleared before all the extensions are evaluated if(!(*func->func = (void *)GL_GetProcAddress( func->name ))) GL_SetExtension( r_ext, false ); // one or more functions are invalid, extension will be disabled } +#endif if( GL_Support( r_ext )) MsgDev( D_NOTE, "- ^2enabled\n" ); @@ -477,25 +491,40 @@ void GL_SetupAttributes() int samples; #if !defined(_WIN32) - SDL_SetHint("SDL_VIDEO_X11_XRANDR", "1"); - SDL_SetHint("SDL_VIDEO_X11_XVIDMODE", "1"); + SDL_SetHint( "SDL_VIDEO_X11_XRANDR", "1" ); + SDL_SetHint( "SDL_VIDEO_X11_XVIDMODE", "1" ); #endif - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); - SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, gl_stencilbits->integer ); + SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); + SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ); + + SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 24 ); + SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, gl_stencilbits->integer ); +#ifdef XASH_GLES + SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES ); + SDL_GL_SetAttribute( SDL_GL_CONTEXT_EGL, 1 ); + +#ifdef XASH_NANOGL + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 1 ); + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1 ); +#elif defined( XASH_WES ) || defined( XASH_REGAL ) + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 2 ); + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 0 ); +#endif + +#else // XASH_GLES if( Sys_CheckParm( "-gldebug" ) && host.developer >= 1 ) { MsgDev( D_NOTE, "Creating an extended GL context for debug...\n" ); SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG ); glw_state.extended = true; } +#endif // XASH_GLES switch( gl_msaa->integer ) { @@ -521,20 +550,61 @@ void GL_SetupAttributes() } } -void GL_InitExtensions( void ) +#ifdef XASH_GLES +void GL_InitExtensionsGLES( void ) { - // initialize gl extensions - GL_CheckExtension( "OpenGL 1.1.0", opengl_110funcs, NULL, GL_OPENGL_110 ); + // initalize until base opengl functions loaded + GL_SetExtension( GL_DRAW_RANGEELEMENTS_EXT, true ); + GL_SetExtension( GL_ARB_MULTITEXTURE, true ); + pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units ); + glConfig.max_texture_coords = glConfig.max_texture_units = 4; - // get our various GL strings - glConfig.vendor_string = pglGetString( GL_VENDOR ); - glConfig.renderer_string = pglGetString( GL_RENDERER ); - glConfig.version_string = pglGetString( GL_VERSION ); - glConfig.extensions_string = pglGetString( GL_EXTENSIONS ); - MsgDev( D_INFO, "Video: %s\n", glConfig.renderer_string ); + GL_SetExtension( GL_ENV_COMBINE_EXT, true ); + GL_SetExtension( GL_DOT3_ARB_EXT, true ); + GL_SetExtension( GL_TEXTURE_3D_EXT, false ); + GL_SetExtension( GL_SGIS_MIPMAPS_EXT, true ); // gles specs + GL_SetExtension( GL_ARB_VERTEX_BUFFER_OBJECT_EXT, true ); // gles specs - // initalize until base opengl functions loaded + // hardware cubemaps + GL_CheckExtension( "GL_OES_texture_cube_map", NULL, "gl_texture_cubemap", GL_TEXTURECUBEMAP_EXT ); + + if( GL_Support( GL_TEXTURECUBEMAP_EXT )) + pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size ); + + GL_SetExtension( GL_ARB_SEAMLESS_CUBEMAP, false ); + + GL_SetExtension( GL_EXT_POINTPARAMETERS, false ); + GL_CheckExtension( "GL_OES_texture_npot", NULL, "gl_texture_npot", GL_ARB_TEXTURE_NPOT_EXT ); + + GL_SetExtension( GL_TEXTURE_COMPRESSION_EXT, false ); + GL_SetExtension( GL_CUSTOM_VERTEX_ARRAY_EXT, false ); + GL_SetExtension( GL_CLAMPTOEDGE_EXT, true ); // by gles1 specs + GL_SetExtension( GL_ANISOTROPY_EXT, false ); + GL_SetExtension( GL_TEXTURE_LODBIAS, false ); + GL_SetExtension( GL_CLAMP_TEXBORDER_EXT, false ); + GL_SetExtension( GL_BLEND_MINMAX_EXT, false ); + GL_SetExtension( GL_BLEND_SUBTRACT_EXT, false ); + GL_SetExtension( GL_SEPARATESTENCIL_EXT, false ); + GL_SetExtension( GL_STENCILTWOSIDE_EXT, false ); + GL_SetExtension( GL_TEXTURE_ENV_ADD_EXT,false ); + GL_SetExtension( GL_SHADER_OBJECTS_EXT, false ); + GL_SetExtension( GL_SHADER_GLSL100_EXT, false ); + GL_SetExtension( GL_VERTEX_SHADER_EXT,false ); + GL_SetExtension( GL_FRAGMENT_SHADER_EXT, false ); + GL_SetExtension( GL_SHADOW_EXT, false ); + GL_SetExtension( GL_ARB_DEPTH_FLOAT_EXT, false ); + GL_SetExtension( GL_OCCLUSION_QUERIES_EXT,false ); + GL_CheckExtension( "GL_OES_depth_texture", NULL, "gl_depthtexture", GL_DEPTH_TEXTURE ); + + glConfig.texRectangle = glConfig.max_2d_rectangle_size = 0; // no rectangle + Cvar_FullSet( "gl_allow_mirrors", "0", CVAR_READ_ONLY); // No support for GLES + +} +#else +void GL_InitExtensionsBigGL() +{ + // initalize until base opengl functions loaded GL_CheckExtension( "glDrawRangeElements", drawrangeelementsfuncs, "gl_drawrangeelments", GL_DRAW_RANGEELEMENTS_EXT ); if( !GL_Support( GL_DRAW_RANGEELEMENTS_EXT )) @@ -676,35 +746,8 @@ void GL_InitExtensions( void ) } else glConfig.texRectangle = glConfig.max_2d_rectangle_size = 0; // no rectangle - glConfig.max_2d_texture_size = 0; - pglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.max_2d_texture_size ); - if( glConfig.max_2d_texture_size <= 0 ) glConfig.max_2d_texture_size = 256; - - Cvar_Get( "gl_max_texture_size", "0", CVAR_INIT, "opengl texture max dims" ); - Cvar_Set( "gl_max_texture_size", va( "%i", glConfig.max_2d_texture_size )); - - pglGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig.max_vertex_uniforms ); - pglGetIntegerv( GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig.max_vertex_attribs ); - - // MCD has buffering issues -#ifdef _WIN32 - if(Q_strstr( glConfig.renderer_string, "gdi" )) - Cvar_SetFloat( "gl_finish", 1 ); -#endif - -#ifdef XASH_GLES - Cvar_FullSet( "gl_allow_mirrors", "0", CVAR_READ_ONLY); // No support for GLES -#endif - Cvar_Set( "gl_anisotropy", va( "%f", bound( 0, gl_texture_anisotropy->value, glConfig.max_texture_anisotropy ))); - // software mipmap generator does wrong result with NPOT textures ... - if( !GL_Support( GL_SGIS_MIPMAPS_EXT )) - GL_SetExtension( GL_ARB_TEXTURE_NPOT_EXT, false ); - - if( GL_Support( GL_TEXTURE_COMPRESSION_EXT )) - Image_AddCmdFlags( IL_DDS_HARDWARE ); - // enable gldebug if allowed if( GL_Support( GL_DEBUG_OUTPUT )) { @@ -722,8 +765,53 @@ void GL_InitExtensions( void ) if( host.developer >= D_NOTE ) pglDebugMessageControlARB( GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW_ARB, 0, NULL, true ); } +} +#endif + +void GL_InitExtensions( void ) +{ + // initialize gl extensions + GL_CheckExtension( "OpenGL 1.1.0", opengl_110funcs, NULL, GL_OPENGL_110 ); + + // get our various GL strings + glConfig.vendor_string = pglGetString( GL_VENDOR ); + glConfig.renderer_string = pglGetString( GL_RENDERER ); + glConfig.version_string = pglGetString( GL_VERSION ); + glConfig.extensions_string = pglGetString( GL_EXTENSIONS ); + MsgDev( D_INFO, "Video: %s\n", glConfig.renderer_string ); + +#ifdef XASH_GLES + GL_InitExtensionsGLES(); +#else + GL_InitExtensionsBigGL(); +#endif + + glConfig.max_2d_texture_size = 0; + pglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.max_2d_texture_size ); + if( glConfig.max_2d_texture_size <= 0 ) glConfig.max_2d_texture_size = 256; + + Cvar_Get( "gl_max_texture_size", "0", CVAR_INIT, "opengl texture max dims" ); + Cvar_Set( "gl_max_texture_size", va( "%i", glConfig.max_2d_texture_size )); + + pglGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig.max_vertex_uniforms ); + pglGetIntegerv( GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig.max_vertex_attribs ); + Cvar_Set( "gl_anisotropy", va( "%f", bound( 0, gl_texture_anisotropy->value, glConfig.max_texture_anisotropy ))); + + // software mipmap generator does wrong result with NPOT textures ... + if( !GL_Support( GL_SGIS_MIPMAPS_EXT )) + GL_SetExtension( GL_ARB_TEXTURE_NPOT_EXT, false ); + + if( GL_Support( GL_TEXTURE_COMPRESSION_EXT )) + Image_AddCmdFlags( IL_DDS_HARDWARE ); + + // MCD has buffering issues +#ifdef _WIN32 + if(Q_strstr( glConfig.renderer_string, "gdi" )) + Cvar_SetFloat( "gl_finish", 1 ); +#endif + glw_state.initialized = true; tr.framecount = tr.visframecount = 1; @@ -738,6 +826,9 @@ GL_CreateContext qboolean GL_CreateContext( void ) { int colorBits[3]; +#ifdef XASH_NANOGL + nanoGL_Init(); +#endif if( ( glw_state.context = SDL_GL_CreateContext( host.hWnd ) ) == NULL) { @@ -757,6 +848,11 @@ qboolean GL_CreateContext( void ) SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &glConfig.msaasamples ); +#ifdef XASH_WES + void wes_init(); + wes_init(); +#endif + return true; } @@ -776,6 +872,10 @@ qboolean GL_UpdateContext( void ) return true; } +#ifndef EGL_LIB +#define EGL_LIB NULL +#endif + /* ================= GL_DeleteContext @@ -803,7 +903,7 @@ qboolean R_Init_OpenGL( void ) { GL_SetupAttributes(); - if( SDL_GL_LoadLibrary( NULL ) ) + if( SDL_GL_LoadLibrary( EGL_LIB ) ) { MsgDev( D_ERROR, "Couldn't initialize OpenGL: %s\n", SDL_GetError()); return false; diff --git a/engine/platform/sdl/gl_sdl_static.c b/engine/platform/sdl/gl_sdl_static.c deleted file mode 100644 index 857524675..000000000 --- a/engine/platform/sdl/gl_sdl_static.c +++ /dev/null @@ -1,666 +0,0 @@ -/* -gl_vid_android.c - nanogl video backend -Copyright (C) 2016 mittorn - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. -*/ - - - -#include "common.h" -#if XASH_VIDEO == VIDEO_SDL && defined XASH_GL_STATIC -#include "client.h" -#include "gl_local.h" -#include "mod_local.h" -#include "input.h" -#include "gl_vidnt.h" -#ifdef XASH_NANOGL -#include -#endif -static char* opengl_110funcs[] = -{ - "glClearColor" , - "glClear" , - "glAlphaFunc" , - "glBlendFunc" , - "glCullFace" , - "glDrawBuffer" , - "glReadBuffer" , - "glEnable" , - "glDisable" , - "glEnableClientState" , - "glDisableClientState" , - "glGetBooleanv" , - "glGetDoublev" , - "glGetFloatv" , - "glGetIntegerv" , - "glGetError" , - "glGetString" , - "glFinish" , - "glFlush" , - "glClearDepth" , - "glDepthFunc" , - "glDepthMask" , - "glDepthRange" , - "glFrontFace" , - "glDrawElements" , - "glColorMask" , - "glIndexPointer" , - "glVertexPointer" , - "glNormalPointer" , - "glColorPointer" , - "glTexCoordPointer" , - "glArrayElement" , - "glColor3f" , - "glColor3fv" , - "glColor4f" , - "glColor4fv" , - "glColor3ub" , - "glColor4ub" , - "glColor4ubv" , - "glTexCoord1f" , - "glTexCoord2f" , - "glTexCoord3f" , - "glTexCoord4f" , - "glTexGenf" , - "glTexGenfv" , - "glTexGeni" , - "glVertex2f" , - "glVertex3f" , - "glVertex3fv" , - "glNormal3f" , - "glNormal3fv" , - "glBegin" , - "glEnd" , - "glLineWidth" , - "glPointSize" , - "glMatrixMode" , - "glOrtho" , - "glRasterPos2f" , - "glFrustum" , - "glViewport" , - "glPushMatrix" , - "glPopMatrix" , - "glPushAttrib" , - "glPopAttrib" , - "glLoadIdentity" , - "glLoadMatrixd" , - "glLoadMatrixf" , - "glMultMatrixd" , - "glMultMatrixf" , - "glRotated" , - "glRotatef" , - "glScaled" , - "glScalef" , - "glTranslated" , - "glTranslatef" , - "glReadPixels" , - "glDrawPixels" , - "glStencilFunc" , - "glStencilMask" , - "glStencilOp" , - "glClearStencil" , - "glIsEnabled" , - "glIsList" , - "glIsTexture" , - "glTexEnvf" , - "glTexEnvfv" , - "glTexEnvi" , - "glTexParameterf" , - "glTexParameterfv" , - "glTexParameteri" , - "glHint" , - "glPixelStoref" , - "glPixelStorei" , - "glGenTextures" , - "glDeleteTextures" , - "glBindTexture" , - "glTexImage1D" , - "glTexImage2D" , - "glTexSubImage1D" , - "glTexSubImage2D" , - "glCopyTexImage1D" , - "glCopyTexImage2D" , - "glCopyTexSubImage1D" , - "glCopyTexSubImage2D" , - "glScissor" , - "glGetTexEnviv" , - "glPolygonOffset" , - "glPolygonMode" , - "glPolygonStipple" , - "glClipPlane" , - "glGetClipPlane" , - "glShadeModel" , - "glFogfv" , - "glFogf" , - "glFogi" , - NULL -}; - -static char* pointparametersfunc[] = -{ -"glPointParameterfEXT" , -"glPointParameterfvEXT" , -NULL -}; - -static char* drawrangeelementsfuncs[] = -{ - "glDrawRangeElements" , - NULL -}; - -static char* drawrangeelementsextfuncs[] = -{ - "glDrawRangeElementsEXT" , - NULL -}; - -static char* sgis_multitexturefuncs[] = -{ - "glSelectTextureSGIS" , - "glMTexCoord2fSGIS" , - NULL -}; - -static char* multitexturefuncs[] = -{ - "glMultiTexCoord1fARB" , - "glMultiTexCoord2fARB" , - "glMultiTexCoord3fARB" , - "glMultiTexCoord4fARB" , - "glActiveTextureARB" , - "glClientActiveTextureARB" , - "glClientActiveTextureARB" , - NULL -}; - -static char* compiledvertexarrayfuncs[] = -{ - "glLockArraysEXT" , - "glUnlockArraysEXT" , - "glDrawArrays" , - NULL -}; - -static char* texture3dextfuncs[] = -{ - "glTexImage3DEXT" , - "glTexSubImage3DEXT" , - "glCopyTexSubImage3DEXT" , - NULL -}; - -static char* atiseparatestencilfuncs[] = -{ - "glStencilOpSeparateATI" , - "glStencilFuncSeparateATI" , - NULL -}; - -static char* gl2separatestencilfuncs[] = -{ - "glStencilOpSeparate" , - "glStencilFuncSeparate" , - NULL -}; - -static char* stenciltwosidefuncs[] = -{ - "glActiveStencilFaceEXT" , - NULL -}; - -static char* blendequationfuncs[] = -{ - "glBlendEquationEXT" , - NULL -}; - -static char* shaderobjectsfuncs[] = -{ - "glDeleteObjectARB" , - "glGetHandleARB" , - "glDetachObjectARB" , - "glCreateShaderObjectARB" , - "glShaderSourceARB" , - "glCompileShaderARB" , - "glCreateProgramObjectARB" , - "glAttachObjectARB" , - "glLinkProgramARB" , - "glUseProgramObjectARB" , - "glValidateProgramARB" , - "glUniform1fARB" , - "glUniform2fARB" , - "glUniform3fARB" , - "glUniform4fARB" , - "glUniform1iARB" , - "glUniform2iARB" , - "glUniform3iARB" , - "glUniform4iARB" , - "glUniform1fvARB" , - "glUniform2fvARB" , - "glUniform3fvARB" , - "glUniform4fvARB" , - "glUniform1ivARB" , - "glUniform2ivARB" , - "glUniform3ivARB" , - "glUniform4ivARB" , - "glUniformMatrix2fvARB" , - "glUniformMatrix3fvARB" , - "glUniformMatrix4fvARB" , - "glGetObjectParameterfvARB" , - "glGetObjectParameterivARB" , - "glGetInfoLogARB" , - "glGetAttachedObjectsARB" , - "glGetUniformLocationARB" , - "glGetActiveUniformARB" , - "glGetUniformfvARB" , - "glGetUniformivARB" , - "glGetShaderSourceARB" , - "glVertexAttribPointerARB" , - "glEnableVertexAttribArrayARB" , - "glDisableVertexAttribArrayARB" , - "glBindAttribLocationARB" , - "glGetActiveAttribARB" , - "glGetAttribLocationARB" , - NULL -}; - -static char* vertexshaderfuncs[] = -{ - "glVertexAttribPointerARB" , - "glEnableVertexAttribArrayARB" , - "glDisableVertexAttribArrayARB" , - "glBindAttribLocationARB" , - "glGetActiveAttribARB" , - "glGetAttribLocationARB" , - NULL -}; - -static char* vbofuncs[] = -{ - "glBindBufferARB" , - "glDeleteBuffersARB" , - "glGenBuffersARB" , - "glIsBufferARB" , - "glMapBufferARB" , - "glUnmapBufferARB" , - "glBufferDataARB" , - "glBufferSubDataARB" , - NULL -}; - -static char* occlusionfunc[] = -{ - "glGenQueriesARB" , - "glDeleteQueriesARB" , - "glIsQueryARB" , - "glBeginQueryARB" , - "glEndQueryARB" , - "glGetQueryivARB" , - "glGetQueryObjectivARB" , - "glGetQueryObjectuivARB" , - NULL -}; - -static char* texturecompressionfuncs[] = -{ - "glCompressedTexImage3DARB" , - "glCompressedTexImage2DARB" , - "glCompressedTexImage1DARB" , - "glCompressedTexSubImage3DARB" , - "glCompressedTexSubImage2DARB" , - "glCompressedTexSubImage1DARB" , - "glGetCompressedTexImageARB" , - NULL -}; - - -/* -================= -GL_GetProcAddress -================= -*/ -void EXPORT *GL_GetProcAddress( const char *name ) -{ -#if defined( XASH_GLES ) - void *func = nanoGL_GetProcAddress( name ); -#else - void *func = SDL_GL_GetProcAddress( name ); -#endif - - if( !func ) - { - MsgDev( D_ERROR, "Error: GL_GetProcAddress failed for %s", name ); - } - return func; -} - - -void GL_InitExtensions( void ) -{ - // initialize gl extensions - GL_CheckExtension( "OpenGL 1.1.0", (void*)opengl_110funcs, NULL, GL_OPENGL_110 ); - - // get our various GL strings - glConfig.vendor_string = pglGetString( GL_VENDOR ); - glConfig.renderer_string = pglGetString( GL_RENDERER ); - glConfig.version_string = pglGetString( GL_VERSION ); - glConfig.extensions_string = pglGetString( GL_EXTENSIONS ); - MsgDev( D_INFO, "Video: %s\n", glConfig.renderer_string ); - - // initalize until base opengl functions loaded - - GL_SetExtension( GL_DRAW_RANGEELEMENTS_EXT, true ); - GL_SetExtension( GL_ARB_MULTITEXTURE, true ); - pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units ); - glConfig.max_texture_coords = glConfig.max_texture_units = 4; - - GL_SetExtension( GL_ENV_COMBINE_EXT, true ); - GL_SetExtension( GL_DOT3_ARB_EXT, true ); - GL_SetExtension( GL_TEXTURE_3D_EXT, false ); - GL_SetExtension( GL_SGIS_MIPMAPS_EXT, true ); // gles specs - GL_SetExtension( GL_ARB_VERTEX_BUFFER_OBJECT_EXT, true ); // gles specs - - // hardware cubemaps - GL_CheckExtension( "GL_OES_texture_cube_map", NULL, "gl_texture_cubemap", GL_TEXTURECUBEMAP_EXT ); - - if( GL_Support( GL_TEXTURECUBEMAP_EXT )) - { - pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size ); - } - GL_SetExtension( GL_ARB_SEAMLESS_CUBEMAP, false ); - - GL_SetExtension( GL_EXT_POINTPARAMETERS, false ); - GL_CheckExtension( "GL_OES_texture_npot", NULL, "gl_texture_npot", GL_ARB_TEXTURE_NPOT_EXT ); - - GL_SetExtension( GL_TEXTURE_COMPRESSION_EXT, false ); - GL_SetExtension( GL_CUSTOM_VERTEX_ARRAY_EXT, false ); - GL_SetExtension( GL_CLAMPTOEDGE_EXT, true ); // by gles1 specs - GL_SetExtension( GL_ANISOTROPY_EXT, false ); - GL_SetExtension( GL_TEXTURE_LODBIAS, false ); - GL_SetExtension( GL_CLAMP_TEXBORDER_EXT, false ); - GL_SetExtension( GL_BLEND_MINMAX_EXT, false ); - GL_SetExtension( GL_BLEND_SUBTRACT_EXT, false ); - GL_SetExtension( GL_SEPARATESTENCIL_EXT, false ); - GL_SetExtension( GL_STENCILTWOSIDE_EXT, false ); - GL_SetExtension( GL_TEXTURE_ENV_ADD_EXT,false ); - GL_SetExtension( GL_SHADER_OBJECTS_EXT, false ); - GL_SetExtension( GL_SHADER_GLSL100_EXT, false ); - GL_SetExtension( GL_VERTEX_SHADER_EXT,false ); - GL_SetExtension( GL_FRAGMENT_SHADER_EXT, false ); - GL_SetExtension( GL_SHADOW_EXT, false ); - GL_SetExtension( GL_ARB_DEPTH_FLOAT_EXT, false ); - GL_SetExtension( GL_OCCLUSION_QUERIES_EXT,false ); - GL_CheckExtension( "GL_OES_depth_texture", NULL, "gl_depthtexture", GL_DEPTH_TEXTURE ); - - glConfig.texRectangle = glConfig.max_2d_rectangle_size = 0; // no rectangle - - glConfig.max_2d_texture_size = 0; - pglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.max_2d_texture_size ); - if( glConfig.max_2d_texture_size <= 0 ) glConfig.max_2d_texture_size = 256; - - Cvar_Get( "gl_max_texture_size", "0", CVAR_INIT, "opengl texture max dims" ); - Cvar_Set( "gl_max_texture_size", va( "%i", glConfig.max_2d_texture_size )); - - pglGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig.max_vertex_uniforms ); - pglGetIntegerv( GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig.max_vertex_attribs ); - - // MCD has buffering issues -#ifdef _WIN32 - if(Q_strstr( glConfig.renderer_string, "gdi" )) - Cvar_SetFloat( "gl_finish", 1 ); -#endif - -#ifdef XASH_GLES - Cvar_FullSet( "gl_allow_mirrors", "0", CVAR_READ_ONLY); // No support for GLES -#endif - - Cvar_Set( "gl_anisotropy", va( "%f", bound( 0, gl_texture_anisotropy->value, glConfig.max_texture_anisotropy ))); - - // software mipmap generator does wrong result with NPOT textures ... - if( !GL_Support( GL_SGIS_MIPMAPS_EXT )) - GL_SetExtension( GL_ARB_TEXTURE_NPOT_EXT, false ); - - if( GL_Support( GL_TEXTURE_COMPRESSION_EXT )) - Image_AddCmdFlags( IL_DDS_HARDWARE ); - - glw_state.initialized = true; - - tr.framecount = tr.visframecount = 1; -} - - -/* -================= -GL_CheckExtension -================= -*/ -void GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext ) -{ - const dllfunc_t *func; - convar_t *parm; - - MsgDev( D_NOTE, "GL_CheckExtension: %s ", name ); - - if( cvarname ) - { - // system config disable extensions - parm = Cvar_Get( cvarname, "1", CVAR_GLCONFIG, va( "enable or disable %s", name )); - - if( parm->integer == 0 || ( gl_extensions->integer == 0 && r_ext != GL_OPENGL_110 )) - { - MsgDev( D_NOTE, "- disabled\n" ); - GL_SetExtension( r_ext, 0 ); - return; // nothing to process at - } - GL_SetExtension( r_ext, 1 ); - } - - if(( name[2] == '_' || name[3] == '_' ) && !Q_strstr( glConfig.extensions_string, name )) - { - GL_SetExtension( r_ext, false ); // update render info - MsgDev( D_NOTE, "- ^1failed\n" ); - return; - } - - - GL_SetExtension( r_ext, true ); // predict extension state - - if( GL_Support( r_ext )) - MsgDev( D_NOTE, "- ^2enabled\n" ); - else MsgDev( D_NOTE, "- ^1failed\n" ); -} - -/* -=============== -GL_UpdateSwapInterval -=============== -*/ -void GL_UpdateSwapInterval( void ) -{ - if( gl_swapInterval->modified ) - { - gl_swapInterval->modified = false; - if( SDL_GL_SetSwapInterval(gl_swapInterval->integer) ) - MsgDev(D_ERROR, "SDL_GL_SetSwapInterval: %s\n", SDL_GetError()); - } -} - -/* -================== -GL_SetupAttributes -================== -*/ -void GL_SetupAttributes() -{ - int samples; - - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); - - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, gl_stencilbits->integer ); - - SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES); - -#ifdef XASH_GLES - SDL_GL_SetAttribute(SDL_GL_CONTEXT_EGL, 1); -#ifdef XASH_NANOGL - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); -#endif // XASH_NANOGL - -#if defined( XASH_WES ) || defined( XASH_REGAL ) - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0); -#endif // defined( XASH_WES ) || defined( XASH_REGAL ) -#endif // XASH_GLES - - switch( gl_msaa->integer ) - { - case 2: - case 4: - case 8: - case 16: - samples = gl_msaa->integer; - break; - default: - samples = 0; // don't use, because invalid parameter is passed - } - - if( samples ) - { - SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); - SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples); - } - else - { - SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0); - SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0); - } -} - -/* -================= -GL_CreateContext -================= -*/ -qboolean GL_CreateContext( void ) -{ - int colorBits[3]; -#ifdef XASH_NANOGL - nanoGL_Init(); -#endif - - if( ( glw_state.context = SDL_GL_CreateContext( host.hWnd ) ) == NULL) - { - MsgDev(D_ERROR, "GL_CreateContext: %s\n", SDL_GetError()); - return GL_DeleteContext(); - } - - SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &colorBits[0] ); - SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &colorBits[1] ); - SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &colorBits[2] ); - glConfig.color_bits = colorBits[0] + colorBits[1] + colorBits[2]; - - SDL_GL_GetAttribute( SDL_GL_ALPHA_SIZE, &glConfig.alpha_bits ); - SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &glConfig.depth_bits ); - SDL_GL_GetAttribute( SDL_GL_STENCIL_SIZE, &glConfig.stencil_bits ); - glState.stencilEnabled = glConfig.stencil_bits ? true : false; - - SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &glConfig.msaasamples ); - -#ifdef XASH_WES - void wes_init(); - wes_init(); -#endif - - return true; -} - -/* -================= -GL_UpdateContext -================= -*/ -qboolean GL_UpdateContext( void ) -{ - if(!( SDL_GL_MakeCurrent( host.hWnd, glw_state.context ) ) ) - { - MsgDev(D_ERROR, "GL_UpdateContext: %s", SDL_GetError()); - return GL_DeleteContext(); - } - return true; -} - -#ifndef EGL_LIB -#define EGL_LIB NULL -#endif - - -/* -================= -GL_DeleteContext -================= -*/ -qboolean GL_DeleteContext( void ) -{ - if( glw_state.context ) - SDL_GL_DeleteContext(glw_state.context); - glw_state.context = NULL; - - return false; -} - - -/* -================== -R_Init_OpenGL -================== -*/ -qboolean R_Init_OpenGL( void ) -{ - GL_SetupAttributes(); - - if( SDL_GL_LoadLibrary( EGL_LIB ) ) - { - MsgDev( D_ERROR, "Couldn't initialize OpenGL: %s\n", SDL_GetError()); - return false; - } - - return VID_SetMode(); -} - - -/* -================== -R_Free_OpenGL -================== -*/ -void R_Free_OpenGL( void ) -{ - GL_DeleteContext (); - - VID_DestroyWindow (); - - SDL_GL_UnloadLibrary (); - - // now all extensions are disabled - Q_memset( glConfig.extension, 0, sizeof( glConfig.extension[0] ) * GL_EXTCOUNT ); - glw_state.initialized = false; -} -#endif // XASH_VIDEO diff --git a/vgui_support/vgui_int.cpp b/vgui_support/vgui_int.cpp index 5f2c44d10..2c61df887 100644 --- a/vgui_support/vgui_int.cpp +++ b/vgui_support/vgui_int.cpp @@ -36,8 +36,10 @@ CEngineApp staticApp; void VGui_Startup( int width, int height ) { - if(!g_FontCache) + if( !g_FontCache ) + { g_FontCache = new FontCache(); + } if( rootpanel ) {