This repository has been archived on 2022-06-27. You can view files and clone it, but cannot push or open issues or pull requests.
Xash3DArchive/render/glw_imp.c

556 lines
13 KiB
C

/*
Copyright (C) 1997-2001 Id Software, Inc.
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 2
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
** GLW_IMP.C
**
** This file contains ALL Win32 specific stuff having to do with the
** OpenGL refresh. When a port is being made the following functions
** must be implemented by the port:
**
** GLimp_EndFrame
** GLimp_Init
** GLimp_Shutdown
** GLimp_SwitchFullscreen
**
*/
#include <assert.h>
#include "gl_local.h"
static bool GLimp_SwitchFullscreen( int width, int height );
bool GLimp_InitGL (void);
glwstate_t glw_state;
static char wndname[128];
#define num_vidmodes ((int)(sizeof(vidmode) / sizeof(vidmode[0])) - 1)
typedef struct vidmode_s
{
const char *desc;
int width;
int height;
float pixelheight;
} vidmode_t;
vidmode_t vidmode[] =
{
{"Mode 0: 4x3", 640, 480, 1 },
{"Mode 1: 4x3", 800, 600, 1 },
{"Mode 2: 4x3", 1024, 768, 1 },
{"Mode 3: 4x3", 1152, 864, 1 },
{"Mode 4: 4x3", 1280, 960, 1 },
{"Mode 5: 4x3", 1400, 1050, 1 },
{"Mode 6: 4x3", 1600, 1200, 1 },
{"Mode 7: 4x3", 1920, 1440, 1 },
{"Mode 8: 4x3", 2048, 1536, 1 },
{"Mode 9: 14x9", 840, 540, 1 },
{"Mode 10: 14x9", 1680, 1080, 1 },
{"Mode 11: 16x9", 640, 360, 1 },
{"Mode 12: 16x9", 683, 384, 1 },
{"Mode 13: 16x9", 960, 540, 1 },
{"Mode 14: 16x9", 1280, 720, 1 },
{"Mode 15: 16x9", 1366, 768, 1 },
{"Mode 16: 16x9", 1920, 1080, 1 },
{"Mode 17: 16x9", 2560, 1440, 1 },
{"Mode 18: NTSC", 360, 240, 1.125 },
{"Mode 19: NTSC", 720, 480, 1.125 },
{"Mode 20: PAL ", 360, 283, 0.9545 },
{"Mode 21: PAL ", 720, 566, 0.9545 },
{NULL, 0, 0, 0 },
};
void R_GetVideoMode( int vid_mode )
{
int i = bound(0, vid_mode, num_vidmodes); // check range
Cvar_SetValue("width", vidmode[i].width );
Cvar_SetValue("height", vidmode[i].height );
Cvar_SetValue("r_mode", i ); // merge if out of bounds
MsgDev(D_NOTE, "Set: %s [%dx%d]\n", vidmode[i].desc, vidmode[i].width, vidmode[i].height );
}
static bool VerifyDriver( void )
{
char buffer[1024];
strcpy( buffer, qglGetString( GL_RENDERER ));
strlwr( buffer );
if (!strcmp( buffer, "gdi generic" ))
{
if ( !glw_state.mcd_accelerated )
return false;
}
return true;
}
/*
** VID_CreateWindow
*/
#define WINDOW_CLASS_NAME "Xash Window"
bool VID_CreateWindow( int width, int height, bool fullscreen )
{
WNDCLASS wc;
RECT r;
cvar_t *r_xpos, *r_ypos;
int stylebits;
int x, y, w, h;
int exstyle;
strcpy(wndname, FS_Title ); //critical stuff.
// Register the frame class
wc.style = 0;
wc.lpfnWndProc = (WNDPROC)glw_state.wndproc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = glw_state.hInstance;
wc.hIcon = LoadIcon( glw_state.hInstance, MAKEINTRESOURCE(101));
wc.hCursor = LoadCursor (NULL,IDC_ARROW);
wc.hbrBackground = (void *)COLOR_3DSHADOW;
wc.lpszMenuName = 0;
wc.lpszClassName = WINDOW_CLASS_NAME;
if (!RegisterClass (&wc))
{
Msg("Couldn't register window class");
return false;
}
if (fullscreen)
{
exstyle = WS_EX_TOPMOST;
stylebits = WS_POPUP|WS_VISIBLE;
}
else
{
exstyle = 0;
stylebits = WINDOW_STYLE;
}
r.left = 0;
r.top = 0;
r.right = width;
r.bottom = height;
AdjustWindowRect (&r, stylebits, FALSE);
w = r.right - r.left;
h = r.bottom - r.top;
if (fullscreen)
{
x = 0;
y = 0;
}
else
{
r_xpos = Cvar_Get ("r_xpos", "3", 0);
r_ypos = Cvar_Get ("r_ypos", "22", 0);
x = r_xpos->value;
y = r_ypos->value;
}
glw_state.hWnd = CreateWindowEx( exstyle, WINDOW_CLASS_NAME, wndname, stylebits, x, y, w, h, NULL, NULL, glw_state.hInstance, NULL);
if (!glw_state.hWnd)
{
Msg("Couldn't create window");
return false;
}
ShowWindow( glw_state.hWnd, SW_SHOW );
UpdateWindow( glw_state.hWnd );
// init all the gl stuff for the window
if (!GLimp_InitGL ())
{
Msg("VID_CreateWindow() - GLimp_InitGL failed\n");
return false;
}
SetForegroundWindow( glw_state.hWnd );
SetFocus( glw_state.hWnd );
return true;
}
/*
** GLimp_SetMode
*/
rserr_t GLimp_SetMode( int vid_mode, bool fullscreen )
{
int width, height;
R_GetVideoMode( vid_mode );
width = r_width->integer;
height = r_height->integer;
// destroy the existing window
if (glw_state.hWnd) GLimp_Shutdown();
// do a CDS if needed
if( fullscreen )
{
DEVMODE dm;
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
dm.dmPelsWidth = width;
dm.dmPelsHeight = height;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( gl_bitdepth->value != 0 )
{
dm.dmBitsPerPel = gl_bitdepth->value;
dm.dmFields |= DM_BITSPERPEL;
}
else
{
HDC hdc = GetDC( NULL );
int bitspixel = GetDeviceCaps( hdc, BITSPIXEL );
ReleaseDC( 0, hdc );
}
if( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
{
gl_state.fullscreen = true;
if( !VID_CreateWindow (width, height, true) )
return rserr_invalid_mode;
return rserr_ok;
}
else
{
dm.dmPelsWidth = width * 2;
dm.dmPelsHeight = height;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( gl_bitdepth->value != 0 )
{
dm.dmBitsPerPel = gl_bitdepth->value;
dm.dmFields |= DM_BITSPERPEL;
}
/*
** our first CDS failed, so maybe we're running on some weird dual monitor
** system
*/
if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
{
ChangeDisplaySettings( 0, 0 );
gl_state.fullscreen = false;
if ( !VID_CreateWindow (width, height, false) )
return rserr_invalid_mode;
return rserr_invalid_fullscreen;
}
else
{
if ( !VID_CreateWindow (width, height, true) )
return rserr_invalid_mode;
gl_state.fullscreen = true;
return rserr_ok;
}
}
}
else
{
ChangeDisplaySettings( 0, 0 );
gl_state.fullscreen = false;
if ( !VID_CreateWindow (width, height, false) )
return rserr_invalid_mode;
}
return rserr_ok;
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void )
{
if ( qwglMakeCurrent && !qwglMakeCurrent( NULL, NULL ) )
Msg("R_Shutdown() - wglMakeCurrent failed\n");
if ( glw_state.hGLRC )
{
if ( qwglDeleteContext && !qwglDeleteContext( glw_state.hGLRC ) )
Msg("R_Shutdown() - wglDeleteContext failed\n");
glw_state.hGLRC = NULL;
}
if (glw_state.hDC)
{
if ( !ReleaseDC( glw_state.hWnd, glw_state.hDC ) )
Msg("R_Shutdown() - ReleaseDC failed\n" );
glw_state.hDC = NULL;
}
if (glw_state.hWnd)
{
DestroyWindow ( glw_state.hWnd );
glw_state.hWnd = NULL;
}
if ( glw_state.log_fp )
{
fclose( glw_state.log_fp );
glw_state.log_fp = 0;
}
UnregisterClass (WINDOW_CLASS_NAME, glw_state.hInstance);
if ( gl_state.fullscreen )
{
ChangeDisplaySettings( 0, 0 );
gl_state.fullscreen = false;
}
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL. Under Win32 this means dealing with the pixelformats and
** doing the wgl interface stuff.
*/
bool GLimp_Init( void *hinstance, void *wndproc )
{
#define OSR2_BUILD_NUMBER 1111
OSVERSIONINFO vinfo;
vinfo.dwOSVersionInfoSize = sizeof(vinfo);
glw_state.allowdisplaydepthchange = false;
if ( GetVersionEx( &vinfo) )
{
if ( vinfo.dwMajorVersion > 4 )
{
glw_state.allowdisplaydepthchange = true;
}
else if ( vinfo.dwMajorVersion == 4 )
{
if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
glw_state.allowdisplaydepthchange = true;
}
else if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
{
if ( LOWORD( vinfo.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
{
glw_state.allowdisplaydepthchange = true;
}
}
}
}
else
{
Msg("GLimp_Init() - GetVersionEx failed\n" );
return false;
}
glw_state.hInstance = ( HINSTANCE ) hinstance;
glw_state.wndproc = wndproc;
return true;
}
bool GLimp_InitGL (void)
{
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
1, // version number
PFD_DRAW_TO_WINDOW | // support window
PFD_SUPPORT_OPENGL | // support OpenGL
PFD_GENERIC_ACCELERATED | // accelerated
PFD_DOUBLEBUFFER, // double buffered
PFD_TYPE_RGBA, // RGBA type
24, // 24-bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored
0, // no alpha buffer
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
32, // 32-bit z-buffer
0, // no stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
int pixelformat;
glw_state.minidriver = false;
/*
** Get a DC for the specified window
*/
if ( glw_state.hDC != NULL )
Msg("GLimp_Init() - non-NULL DC exists\n" );
if ( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
{
Msg("GLimp_Init() - GetDC failed\n" );
return false;
}
if ( glw_state.minidriver )
{
if ( (pixelformat = qwglChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
{
Msg("GLimp_Init() - qwglChoosePixelFormat failed\n");
return false;
}
if ( qwglSetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
{
Msg("GLimp_Init() - qwglSetPixelFormat failed\n");
return false;
}
qwglDescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
}
else
{
if ( ( pixelformat = ChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
{
Msg("GLimp_Init() - ChoosePixelFormat failed\n");
return false;
}
if ( SetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
{
Msg("GLimp_Init() - SetPixelFormat failed\n");
return false;
}
DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
if ( !( pfd.dwFlags & PFD_GENERIC_ACCELERATED ) )
{
extern cvar_t *gl_allow_software;
if ( gl_allow_software->value )
glw_state.mcd_accelerated = true;
else
glw_state.mcd_accelerated = false;
}
else
{
glw_state.mcd_accelerated = true;
}
}
/*
** startup the OpenGL subsystem by creating a context and making
** it current
*/
if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
{
Msg("GLimp_Init() - qwglCreateContext failed\n");
goto fail;
}
if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
{
Msg("GLimp_Init() - qwglMakeCurrent failed\n");
goto fail;
}
if ( !VerifyDriver() )
{
Msg("GLimp_Init() - no hardware acceleration detected\n" );
goto fail;
}
// Vertex arrays
qglEnableClientState (GL_VERTEX_ARRAY);
qglEnableClientState (GL_TEXTURE_COORD_ARRAY);
qglTexCoordPointer (2, GL_FLOAT, sizeof(tex_array[0]), tex_array[0]);
qglVertexPointer (3, GL_FLOAT, sizeof(vert_array[0]),vert_array[0]);
qglColorPointer (4, GL_FLOAT, sizeof(col_array[0]), col_array[0]);
/*
** print out PFD specifics
*/
MsgDev(D_NOTE, "GL PFD: color(%d-bits) Z(%d-bit)\n", ( int )pfd.cColorBits, ( int )pfd.cDepthBits );
return true;
fail:
if ( glw_state.hGLRC )
{
qwglDeleteContext( glw_state.hGLRC );
glw_state.hGLRC = NULL;
}
if ( glw_state.hDC )
{
ReleaseDC( glw_state.hWnd, glw_state.hDC );
glw_state.hDC = NULL;
}
return false;
}
/*
** GLimp_BeginFrame
*/
void GLimp_BeginFrame( void )
{
if ( gl_bitdepth->modified )
{
if ( gl_bitdepth->value != 0 && !glw_state.allowdisplaydepthchange )
{
Cvar_SetValue( "gl_bitdepth", 0 );
Msg("gl_bitdepth requires Win95 OSR2.x or WinNT 4.x\n" );
}
gl_bitdepth->modified = false;
}
qglDrawBuffer( GL_BACK );
}
/*
** GLimp_EndFrame
**
** Responsible for doing a swapbuffers and possibly for other stuff
** as yet to be determined. Probably better not to make this a GLimp
** function and instead do a call to GLimp_SwapBuffers.
*/
void GLimp_EndFrame (void)
{
int err;
err = qglGetError();
assert( err == GL_NO_ERROR );
if ( stricmp( gl_drawbuffer->string, "GL_BACK" ) == 0 )
{
if ( !qwglSwapBuffers( glw_state.hDC ) )
Sys_Error("GLimp_EndFrame() - SwapBuffers() failed!\n" );
}
}