1242 lines
32 KiB
C++
1242 lines
32 KiB
C++
|
/*
|
||
|
|
===========================================================================
|
||
|
|
|
||
|
|
Doom 3 GPL Source Code
|
||
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
||
|
|
|
||
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
||
|
|
|
||
|
|
Doom 3 Source Code 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.
|
||
|
|
|
||
|
|
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
|
||
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
||
|
|
|
||
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
||
|
|
|
||
|
|
===========================================================================
|
||
|
|
*/
|
||
|
|
/*
|
||
|
|
** WIN_GLIMP.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_SwapBuffers
|
||
|
|
** GLimp_Init
|
||
|
|
** GLimp_Shutdown
|
||
|
|
** GLimp_SetGamma
|
||
|
|
**
|
||
|
|
** Note that the GLW_xxx functions are Windows specific GL-subsystem
|
||
|
|
** related functions that are relevant ONLY to win_glimp.c
|
||
|
|
*/
|
||
|
|
#include "../../idlib/precompiled.h"
|
||
|
|
#pragma hdrstop
|
||
|
|
|
||
|
|
#include "win_local.h"
|
||
|
|
#include "rc/AFEditor_resource.h"
|
||
|
|
#include "rc/doom_resource.h"
|
||
|
|
#include "../../renderer/tr_local.h"
|
||
|
|
|
||
|
|
static void GLW_InitExtensions( void );
|
||
|
|
|
||
|
|
|
||
|
|
// WGL_ARB_extensions_string
|
||
|
|
PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB;
|
||
|
|
|
||
|
|
// WGL_EXT_swap_interval
|
||
|
|
PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT;
|
||
|
|
|
||
|
|
// WGL_ARB_pixel_format
|
||
|
|
PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB;
|
||
|
|
PFNWGLGETPIXELFORMATATTRIBFVARBPROC wglGetPixelFormatAttribfvARB;
|
||
|
|
PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB;
|
||
|
|
|
||
|
|
// WGL_ARB_pbuffer
|
||
|
|
PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB;
|
||
|
|
PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB;
|
||
|
|
PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB;
|
||
|
|
PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB;
|
||
|
|
PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB;
|
||
|
|
|
||
|
|
// WGL_ARB_render_texture
|
||
|
|
PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB;
|
||
|
|
PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB;
|
||
|
|
PFNWGLSETPBUFFERATTRIBARBPROC wglSetPbufferAttribARB;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* ARB_pixel_format */
|
||
|
|
#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
|
||
|
|
#define WGL_DRAW_TO_WINDOW_ARB 0x2001
|
||
|
|
#define WGL_DRAW_TO_BITMAP_ARB 0x2002
|
||
|
|
#define WGL_ACCELERATION_ARB 0x2003
|
||
|
|
#define WGL_NEED_PALETTE_ARB 0x2004
|
||
|
|
#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
|
||
|
|
#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
|
||
|
|
#define WGL_SWAP_METHOD_ARB 0x2007
|
||
|
|
#define WGL_NUMBER_OVERLAYS_ARB 0x2008
|
||
|
|
#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
|
||
|
|
#define WGL_TRANSPARENT_ARB 0x200A
|
||
|
|
#define WGL_SHARE_DEPTH_ARB 0x200C
|
||
|
|
#define WGL_SHARE_STENCIL_ARB 0x200D
|
||
|
|
#define WGL_SHARE_ACCUM_ARB 0x200E
|
||
|
|
#define WGL_SUPPORT_GDI_ARB 0x200F
|
||
|
|
#define WGL_SUPPORT_OPENGL_ARB 0x2010
|
||
|
|
#define WGL_DOUBLE_BUFFER_ARB 0x2011
|
||
|
|
#define WGL_STEREO_ARB 0x2012
|
||
|
|
#define WGL_PIXEL_TYPE_ARB 0x2013
|
||
|
|
#define WGL_COLOR_BITS_ARB 0x2014
|
||
|
|
#define WGL_RED_BITS_ARB 0x2015
|
||
|
|
#define WGL_RED_SHIFT_ARB 0x2016
|
||
|
|
#define WGL_GREEN_BITS_ARB 0x2017
|
||
|
|
#define WGL_GREEN_SHIFT_ARB 0x2018
|
||
|
|
#define WGL_BLUE_BITS_ARB 0x2019
|
||
|
|
#define WGL_BLUE_SHIFT_ARB 0x201A
|
||
|
|
#define WGL_ALPHA_BITS_ARB 0x201B
|
||
|
|
#define WGL_ALPHA_SHIFT_ARB 0x201C
|
||
|
|
#define WGL_ACCUM_BITS_ARB 0x201D
|
||
|
|
#define WGL_ACCUM_RED_BITS_ARB 0x201E
|
||
|
|
#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
|
||
|
|
#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
|
||
|
|
#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
|
||
|
|
#define WGL_DEPTH_BITS_ARB 0x2022
|
||
|
|
#define WGL_STENCIL_BITS_ARB 0x2023
|
||
|
|
#define WGL_AUX_BUFFERS_ARB 0x2024
|
||
|
|
#define WGL_NO_ACCELERATION_ARB 0x2025
|
||
|
|
#define WGL_GENERIC_ACCELERATION_ARB 0x2026
|
||
|
|
#define WGL_FULL_ACCELERATION_ARB 0x2027
|
||
|
|
#define WGL_SWAP_EXCHANGE_ARB 0x2028
|
||
|
|
#define WGL_SWAP_COPY_ARB 0x2029
|
||
|
|
#define WGL_SWAP_UNDEFINED_ARB 0x202A
|
||
|
|
#define WGL_TYPE_RGBA_ARB 0x202B
|
||
|
|
#define WGL_TYPE_COLORINDEX_ARB 0x202C
|
||
|
|
#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
|
||
|
|
#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
|
||
|
|
#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
|
||
|
|
#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
|
||
|
|
#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
|
||
|
|
|
||
|
|
/* ARB_multisample */
|
||
|
|
#define WGL_SAMPLE_BUFFERS_ARB 0x2041
|
||
|
|
#define WGL_SAMPLES_ARB 0x2042
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// function declaration
|
||
|
|
//
|
||
|
|
bool QGL_Init( const char *dllname );
|
||
|
|
void QGL_Shutdown( void );
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
========================
|
||
|
|
GLimp_GetOldGammaRamp
|
||
|
|
========================
|
||
|
|
*/
|
||
|
|
static void GLimp_SaveGamma( void ) {
|
||
|
|
HDC hDC;
|
||
|
|
BOOL success;
|
||
|
|
|
||
|
|
hDC = GetDC( GetDesktopWindow() );
|
||
|
|
success = GetDeviceGammaRamp( hDC, win32.oldHardwareGamma );
|
||
|
|
common->DPrintf( "...getting default gamma ramp: %s\n", success ? "success" : "failed" );
|
||
|
|
ReleaseDC( GetDesktopWindow(), hDC );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
========================
|
||
|
|
GLimp_RestoreGamma
|
||
|
|
========================
|
||
|
|
*/
|
||
|
|
static void GLimp_RestoreGamma( void ) {
|
||
|
|
HDC hDC;
|
||
|
|
BOOL success;
|
||
|
|
|
||
|
|
// if we never read in a reasonable looking
|
||
|
|
// table, don't write it out
|
||
|
|
if ( win32.oldHardwareGamma[0][255] == 0 ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
hDC = GetDC( GetDesktopWindow() );
|
||
|
|
success = SetDeviceGammaRamp( hDC, win32.oldHardwareGamma );
|
||
|
|
common->DPrintf ( "...restoring hardware gamma: %s\n", success ? "success" : "failed" );
|
||
|
|
ReleaseDC( GetDesktopWindow(), hDC );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
========================
|
||
|
|
GLimp_SetGamma
|
||
|
|
|
||
|
|
The renderer calls this when the user adjusts r_gamma or r_brightness
|
||
|
|
========================
|
||
|
|
*/
|
||
|
|
void GLimp_SetGamma( unsigned short red[256], unsigned short green[256], unsigned short blue[256] ) {
|
||
|
|
unsigned short table[3][256];
|
||
|
|
int i;
|
||
|
|
|
||
|
|
if ( !win32.hDC ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( i = 0; i < 256; i++ ) {
|
||
|
|
table[0][i] = red[i];
|
||
|
|
table[1][i] = green[i];
|
||
|
|
table[2][i] = blue[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !SetDeviceGammaRamp( win32.hDC, table ) ) {
|
||
|
|
common->Printf( "WARNING: SetDeviceGammaRamp failed.\n" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
=============================================================================
|
||
|
|
|
||
|
|
WglExtension Grabbing
|
||
|
|
|
||
|
|
This is gross -- creating a window just to get a context to get the wgl extensions
|
||
|
|
|
||
|
|
=============================================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
====================
|
||
|
|
FakeWndProc
|
||
|
|
|
||
|
|
Only used to get wglExtensions
|
||
|
|
====================
|
||
|
|
*/
|
||
|
|
LONG WINAPI FakeWndProc (
|
||
|
|
HWND hWnd,
|
||
|
|
UINT uMsg,
|
||
|
|
WPARAM wParam,
|
||
|
|
LPARAM lParam) {
|
||
|
|
|
||
|
|
if ( uMsg == WM_DESTROY ) {
|
||
|
|
PostQuitMessage(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( uMsg != WM_CREATE ) {
|
||
|
|
return DefWindowProc(hWnd, uMsg, wParam, lParam);
|
||
|
|
}
|
||
|
|
|
||
|
|
const static PIXELFORMATDESCRIPTOR pfd = {
|
||
|
|
sizeof(PIXELFORMATDESCRIPTOR),
|
||
|
|
1,
|
||
|
|
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
|
||
|
|
PFD_TYPE_RGBA,
|
||
|
|
24,
|
||
|
|
0, 0, 0, 0, 0, 0,
|
||
|
|
8, 0,
|
||
|
|
0, 0, 0, 0,
|
||
|
|
24, 8,
|
||
|
|
0,
|
||
|
|
PFD_MAIN_PLANE,
|
||
|
|
0,
|
||
|
|
0,
|
||
|
|
0,
|
||
|
|
0,
|
||
|
|
};
|
||
|
|
int pixelFormat;
|
||
|
|
HDC hDC;
|
||
|
|
HGLRC hGLRC;
|
||
|
|
|
||
|
|
hDC = GetDC(hWnd);
|
||
|
|
|
||
|
|
// Set up OpenGL
|
||
|
|
pixelFormat = ChoosePixelFormat(hDC, &pfd);
|
||
|
|
SetPixelFormat(hDC, pixelFormat, &pfd);
|
||
|
|
hGLRC = qwglCreateContext(hDC);
|
||
|
|
qwglMakeCurrent(hDC, hGLRC);
|
||
|
|
|
||
|
|
// free things
|
||
|
|
wglMakeCurrent(NULL, NULL);
|
||
|
|
wglDeleteContext(hGLRC);
|
||
|
|
ReleaseDC(hWnd, hDC);
|
||
|
|
|
||
|
|
return DefWindowProc(hWnd, uMsg, wParam, lParam);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
==================
|
||
|
|
GLW_GetWGLExtensionsWithFakeWindow
|
||
|
|
==================
|
||
|
|
*/
|
||
|
|
void GLW_CheckWGLExtensions( HDC hDC ) {
|
||
|
|
wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
|
||
|
|
GLimp_ExtensionPointer("wglGetExtensionsStringARB");
|
||
|
|
if ( wglGetExtensionsStringARB ) {
|
||
|
|
glConfig.wgl_extensions_string = (const char *) wglGetExtensionsStringARB(hDC);
|
||
|
|
} else {
|
||
|
|
glConfig.wgl_extensions_string = "";
|
||
|
|
}
|
||
|
|
|
||
|
|
// WGL_EXT_swap_control
|
||
|
|
wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) GLimp_ExtensionPointer( "wglSwapIntervalEXT" );
|
||
|
|
r_swapInterval.SetModified(); // force a set next frame
|
||
|
|
|
||
|
|
// WGL_ARB_pixel_format
|
||
|
|
wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)GLimp_ExtensionPointer("wglGetPixelFormatAttribivARB");
|
||
|
|
wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)GLimp_ExtensionPointer("wglGetPixelFormatAttribfvARB");
|
||
|
|
wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)GLimp_ExtensionPointer("wglChoosePixelFormatARB");
|
||
|
|
|
||
|
|
// WGL_ARB_pbuffer
|
||
|
|
wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)GLimp_ExtensionPointer("wglCreatePbufferARB");
|
||
|
|
wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)GLimp_ExtensionPointer("wglGetPbufferDCARB");
|
||
|
|
wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)GLimp_ExtensionPointer("wglReleasePbufferDCARB");
|
||
|
|
wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)GLimp_ExtensionPointer("wglDestroyPbufferARB");
|
||
|
|
wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)GLimp_ExtensionPointer("wglQueryPbufferARB");
|
||
|
|
|
||
|
|
// WGL_ARB_render_texture
|
||
|
|
wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)GLimp_ExtensionPointer("wglBindTexImageARB");
|
||
|
|
wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)GLimp_ExtensionPointer("wglReleaseTexImageARB");
|
||
|
|
wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)GLimp_ExtensionPointer("wglSetPbufferAttribARB");
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
==================
|
||
|
|
GLW_GetWGLExtensionsWithFakeWindow
|
||
|
|
==================
|
||
|
|
*/
|
||
|
|
static void GLW_GetWGLExtensionsWithFakeWindow( void ) {
|
||
|
|
HWND hWnd;
|
||
|
|
MSG msg;
|
||
|
|
|
||
|
|
// Create a window for the sole purpose of getting
|
||
|
|
// a valid context to get the wglextensions
|
||
|
|
hWnd = CreateWindow(WIN32_FAKE_WINDOW_CLASS_NAME, GAME_NAME,
|
||
|
|
WS_OVERLAPPEDWINDOW,
|
||
|
|
40, 40,
|
||
|
|
640,
|
||
|
|
480,
|
||
|
|
NULL, NULL, win32.hInstance, NULL );
|
||
|
|
if ( !hWnd ) {
|
||
|
|
common->FatalError( "GLW_GetWGLExtensionsWithFakeWindow: Couldn't create fake window" );
|
||
|
|
}
|
||
|
|
|
||
|
|
HDC hDC = GetDC( hWnd );
|
||
|
|
HGLRC gRC = wglCreateContext( hDC );
|
||
|
|
wglMakeCurrent( hDC, gRC );
|
||
|
|
GLW_CheckWGLExtensions( hDC );
|
||
|
|
wglDeleteContext( gRC );
|
||
|
|
ReleaseDC( hWnd, hDC );
|
||
|
|
|
||
|
|
DestroyWindow( hWnd );
|
||
|
|
while ( GetMessage( &msg, NULL, 0, 0 ) ) {
|
||
|
|
TranslateMessage( &msg );
|
||
|
|
DispatchMessage( &msg );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
/*
|
||
|
|
====================
|
||
|
|
GLW_WM_CREATE
|
||
|
|
====================
|
||
|
|
*/
|
||
|
|
void GLW_WM_CREATE( HWND hWnd ) {
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
====================
|
||
|
|
GLW_InitDriver
|
||
|
|
|
||
|
|
Set the pixelformat for the window before it is
|
||
|
|
shown, and create the rendering context
|
||
|
|
====================
|
||
|
|
*/
|
||
|
|
static bool GLW_InitDriver( glimpParms_t parms ) {
|
||
|
|
PIXELFORMATDESCRIPTOR src =
|
||
|
|
{
|
||
|
|
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
|
||
|
|
1, // version number
|
||
|
|
PFD_DRAW_TO_WINDOW | // support window
|
||
|
|
PFD_SUPPORT_OPENGL | // support OpenGL
|
||
|
|
PFD_DOUBLEBUFFER, // double buffered
|
||
|
|
PFD_TYPE_RGBA, // RGBA type
|
||
|
|
32, // 32-bit color depth
|
||
|
|
0, 0, 0, 0, 0, 0, // color bits ignored
|
||
|
|
8, // 8 bit destination alpha
|
||
|
|
0, // shift bit ignored
|
||
|
|
0, // no accumulation buffer
|
||
|
|
0, 0, 0, 0, // accum bits ignored
|
||
|
|
24, // 24-bit z-buffer
|
||
|
|
8, // 8-bit stencil buffer
|
||
|
|
0, // no auxiliary buffer
|
||
|
|
PFD_MAIN_PLANE, // main layer
|
||
|
|
0, // reserved
|
||
|
|
0, 0, 0 // layer masks ignored
|
||
|
|
};
|
||
|
|
|
||
|
|
common->Printf( "Initializing OpenGL driver\n" );
|
||
|
|
|
||
|
|
//
|
||
|
|
// get a DC for our window if we don't already have one allocated
|
||
|
|
//
|
||
|
|
if ( win32.hDC == NULL ) {
|
||
|
|
common->Printf( "...getting DC: " );
|
||
|
|
|
||
|
|
if ( ( win32.hDC = GetDC( win32.hWnd ) ) == NULL ) {
|
||
|
|
common->Printf( "^3failed^0\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
common->Printf( "succeeded\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
// the multisample path uses the wgl
|
||
|
|
if ( wglChoosePixelFormatARB && parms.multiSamples > 1 ) {
|
||
|
|
int iAttributes[20];
|
||
|
|
FLOAT fAttributes[] = {0, 0};
|
||
|
|
UINT numFormats;
|
||
|
|
|
||
|
|
// FIXME: specify all the other stuff
|
||
|
|
iAttributes[0] = WGL_SAMPLE_BUFFERS_ARB;
|
||
|
|
iAttributes[1] = 1;
|
||
|
|
iAttributes[2] = WGL_SAMPLES_ARB;
|
||
|
|
iAttributes[3] = parms.multiSamples;
|
||
|
|
iAttributes[4] = WGL_DOUBLE_BUFFER_ARB;
|
||
|
|
iAttributes[5] = TRUE;
|
||
|
|
iAttributes[6] = WGL_STENCIL_BITS_ARB;
|
||
|
|
iAttributes[7] = 8;
|
||
|
|
iAttributes[8] = WGL_DEPTH_BITS_ARB;
|
||
|
|
iAttributes[9] = 24;
|
||
|
|
iAttributes[10] = WGL_RED_BITS_ARB;
|
||
|
|
iAttributes[11] = 8;
|
||
|
|
iAttributes[12] = WGL_BLUE_BITS_ARB;
|
||
|
|
iAttributes[13] = 8;
|
||
|
|
iAttributes[14] = WGL_GREEN_BITS_ARB;
|
||
|
|
iAttributes[15] = 8;
|
||
|
|
iAttributes[16] = WGL_ALPHA_BITS_ARB;
|
||
|
|
iAttributes[17] = 8;
|
||
|
|
iAttributes[18] = 0;
|
||
|
|
iAttributes[19] = 0;
|
||
|
|
|
||
|
|
wglChoosePixelFormatARB( win32.hDC, iAttributes, fAttributes, 1, &win32.pixelformat, &numFormats );
|
||
|
|
} else {
|
||
|
|
// this is the "classic" choose pixel format path
|
||
|
|
|
||
|
|
// eventually we may need to have more fallbacks, but for
|
||
|
|
// now, ask for everything
|
||
|
|
if ( parms.stereo ) {
|
||
|
|
common->Printf( "...attempting to use stereo\n" );
|
||
|
|
src.dwFlags |= PFD_STEREO;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// choose, set, and describe our desired pixel format. If we're
|
||
|
|
// using a minidriver then we need to bypass the GDI functions,
|
||
|
|
// otherwise use the GDI functions.
|
||
|
|
//
|
||
|
|
if ( ( win32.pixelformat = ChoosePixelFormat( win32.hDC, &src ) ) == 0 ) {
|
||
|
|
common->Printf( "...^3GLW_ChoosePFD failed^0\n");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
common->Printf( "...PIXELFORMAT %d selected\n", win32.pixelformat );
|
||
|
|
}
|
||
|
|
|
||
|
|
// get the full info
|
||
|
|
DescribePixelFormat( win32.hDC, win32.pixelformat, sizeof( win32.pfd ), &win32.pfd );
|
||
|
|
glConfig.colorBits = win32.pfd.cColorBits;
|
||
|
|
glConfig.depthBits = win32.pfd.cDepthBits;
|
||
|
|
glConfig.stencilBits = win32.pfd.cStencilBits;
|
||
|
|
|
||
|
|
// XP seems to set this incorrectly
|
||
|
|
if ( !glConfig.stencilBits ) {
|
||
|
|
glConfig.stencilBits = 8;
|
||
|
|
}
|
||
|
|
|
||
|
|
// the same SetPixelFormat is used either way
|
||
|
|
if ( SetPixelFormat( win32.hDC, win32.pixelformat, &win32.pfd ) == FALSE ) {
|
||
|
|
common->Printf( "...^3SetPixelFormat failed^0\n", win32.hDC );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// startup the OpenGL subsystem by creating a context and making it current
|
||
|
|
//
|
||
|
|
common->Printf( "...creating GL context: " );
|
||
|
|
if ( ( win32.hGLRC = qwglCreateContext( win32.hDC ) ) == 0 ) {
|
||
|
|
common->Printf( "^3failed^0\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
common->Printf( "succeeded\n" );
|
||
|
|
|
||
|
|
common->Printf( "...making context current: " );
|
||
|
|
if ( !qwglMakeCurrent( win32.hDC, win32.hGLRC ) ) {
|
||
|
|
qwglDeleteContext( win32.hGLRC );
|
||
|
|
win32.hGLRC = NULL;
|
||
|
|
common->Printf( "^3failed^0\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
common->Printf( "succeeded\n" );
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
====================
|
||
|
|
GLW_CreateWindowClasses
|
||
|
|
====================
|
||
|
|
*/
|
||
|
|
static void GLW_CreateWindowClasses( void ) {
|
||
|
|
WNDCLASS wc;
|
||
|
|
|
||
|
|
//
|
||
|
|
// register the window class if necessary
|
||
|
|
//
|
||
|
|
if ( win32.windowClassRegistered ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
memset( &wc, 0, sizeof( wc ) );
|
||
|
|
|
||
|
|
wc.style = 0;
|
||
|
|
wc.lpfnWndProc = (WNDPROC) MainWndProc;
|
||
|
|
wc.cbClsExtra = 0;
|
||
|
|
wc.cbWndExtra = 0;
|
||
|
|
wc.hInstance = win32.hInstance;
|
||
|
|
wc.hIcon = LoadIcon( win32.hInstance, MAKEINTRESOURCE(IDI_ICON1));
|
||
|
|
wc.hCursor = LoadCursor (NULL,IDC_ARROW);
|
||
|
|
wc.hbrBackground = (struct HBRUSH__ *)COLOR_GRAYTEXT;
|
||
|
|
wc.lpszMenuName = 0;
|
||
|
|
wc.lpszClassName = WIN32_WINDOW_CLASS_NAME;
|
||
|
|
|
||
|
|
if ( !RegisterClass( &wc ) ) {
|
||
|
|
common->FatalError( "GLW_CreateWindow: could not register window class" );
|
||
|
|
}
|
||
|
|
common->Printf( "...registered window class\n" );
|
||
|
|
|
||
|
|
// now register the fake window class that is only used
|
||
|
|
// to get wgl extensions
|
||
|
|
wc.style = 0;
|
||
|
|
wc.lpfnWndProc = (WNDPROC) FakeWndProc;
|
||
|
|
wc.cbClsExtra = 0;
|
||
|
|
wc.cbWndExtra = 0;
|
||
|
|
wc.hInstance = win32.hInstance;
|
||
|
|
wc.hIcon = LoadIcon( win32.hInstance, MAKEINTRESOURCE(IDI_ICON1));
|
||
|
|
wc.hCursor = LoadCursor (NULL,IDC_ARROW);
|
||
|
|
wc.hbrBackground = (struct HBRUSH__ *)COLOR_GRAYTEXT;
|
||
|
|
wc.lpszMenuName = 0;
|
||
|
|
wc.lpszClassName = WIN32_FAKE_WINDOW_CLASS_NAME;
|
||
|
|
|
||
|
|
if ( !RegisterClass( &wc ) ) {
|
||
|
|
common->FatalError( "GLW_CreateWindow: could not register window class" );
|
||
|
|
}
|
||
|
|
common->Printf( "...registered fake window class\n" );
|
||
|
|
|
||
|
|
win32.windowClassRegistered = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
=======================
|
||
|
|
GLW_CreateWindow
|
||
|
|
|
||
|
|
Responsible for creating the Win32 window.
|
||
|
|
If cdsFullscreen is true, it won't have a border
|
||
|
|
=======================
|
||
|
|
*/
|
||
|
|
static bool GLW_CreateWindow( glimpParms_t parms ) {
|
||
|
|
int stylebits;
|
||
|
|
int x, y, w, h;
|
||
|
|
int exstyle;
|
||
|
|
|
||
|
|
//
|
||
|
|
// compute width and height
|
||
|
|
//
|
||
|
|
if ( parms.fullScreen ) {
|
||
|
|
exstyle = WS_EX_TOPMOST;
|
||
|
|
stylebits = WS_POPUP|WS_VISIBLE|WS_SYSMENU;
|
||
|
|
|
||
|
|
x = 0;
|
||
|
|
y = 0;
|
||
|
|
w = parms.width;
|
||
|
|
h = parms.height;
|
||
|
|
} else {
|
||
|
|
RECT r;
|
||
|
|
|
||
|
|
// adjust width and height for window border
|
||
|
|
r.bottom = parms.height;
|
||
|
|
r.left = 0;
|
||
|
|
r.top = 0;
|
||
|
|
r.right = parms.width;
|
||
|
|
|
||
|
|
exstyle = 0;
|
||
|
|
stylebits = WINDOW_STYLE|WS_SYSMENU;
|
||
|
|
AdjustWindowRect (&r, stylebits, FALSE);
|
||
|
|
|
||
|
|
w = r.right - r.left;
|
||
|
|
h = r.bottom - r.top;
|
||
|
|
|
||
|
|
x = win32.win_xpos.GetInteger();
|
||
|
|
y = win32.win_ypos.GetInteger();
|
||
|
|
|
||
|
|
// adjust window coordinates if necessary
|
||
|
|
// so that the window is completely on screen
|
||
|
|
if ( x + w > win32.desktopWidth ) {
|
||
|
|
x = ( win32.desktopWidth - w );
|
||
|
|
}
|
||
|
|
if ( y + h > win32.desktopHeight ) {
|
||
|
|
y = ( win32.desktopHeight - h );
|
||
|
|
}
|
||
|
|
if ( x < 0 ) {
|
||
|
|
x = 0;
|
||
|
|
}
|
||
|
|
if ( y < 0 ) {
|
||
|
|
y = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
win32.hWnd = CreateWindowEx (
|
||
|
|
exstyle,
|
||
|
|
WIN32_WINDOW_CLASS_NAME,
|
||
|
|
GAME_NAME,
|
||
|
|
stylebits,
|
||
|
|
x, y, w, h,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
win32.hInstance,
|
||
|
|
NULL);
|
||
|
|
|
||
|
|
if ( !win32.hWnd ) {
|
||
|
|
common->Printf( "^3GLW_CreateWindow() - Couldn't create window^0\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
::SetTimer( win32.hWnd, 0, 100, NULL );
|
||
|
|
|
||
|
|
ShowWindow( win32.hWnd, SW_SHOW );
|
||
|
|
UpdateWindow( win32.hWnd );
|
||
|
|
common->Printf( "...created window @ %d,%d (%dx%d)\n", x, y, w, h );
|
||
|
|
|
||
|
|
if ( !GLW_InitDriver( parms ) ) {
|
||
|
|
ShowWindow( win32.hWnd, SW_HIDE );
|
||
|
|
DestroyWindow( win32.hWnd );
|
||
|
|
win32.hWnd = NULL;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetForegroundWindow( win32.hWnd );
|
||
|
|
SetFocus( win32.hWnd );
|
||
|
|
|
||
|
|
glConfig.isFullscreen = parms.fullScreen;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
static void PrintCDSError( int value ) {
|
||
|
|
switch ( value ) {
|
||
|
|
case DISP_CHANGE_RESTART:
|
||
|
|
common->Printf( "restart required\n" );
|
||
|
|
break;
|
||
|
|
case DISP_CHANGE_BADPARAM:
|
||
|
|
common->Printf( "bad param\n" );
|
||
|
|
break;
|
||
|
|
case DISP_CHANGE_BADFLAGS:
|
||
|
|
common->Printf( "bad flags\n" );
|
||
|
|
break;
|
||
|
|
case DISP_CHANGE_FAILED:
|
||
|
|
common->Printf( "DISP_CHANGE_FAILED\n" );
|
||
|
|
break;
|
||
|
|
case DISP_CHANGE_BADMODE:
|
||
|
|
common->Printf( "bad mode\n" );
|
||
|
|
break;
|
||
|
|
case DISP_CHANGE_NOTUPDATED:
|
||
|
|
common->Printf( "not updated\n" );
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
common->Printf( "unknown error %d\n", value );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLW_SetFullScreen
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
static bool GLW_SetFullScreen( glimpParms_t parms ) {
|
||
|
|
#if 0
|
||
|
|
// for some reason, bounds checker claims that windows is
|
||
|
|
// writing past the bounds of dm in the get display frequency call
|
||
|
|
union {
|
||
|
|
DEVMODE dm;
|
||
|
|
byte filler[1024];
|
||
|
|
} hack;
|
||
|
|
#endif
|
||
|
|
DEVMODE dm;
|
||
|
|
int cdsRet;
|
||
|
|
|
||
|
|
DEVMODE devmode;
|
||
|
|
int modeNum;
|
||
|
|
bool matched;
|
||
|
|
|
||
|
|
// first make sure the user is not trying to select a mode that his card/monitor can't handle
|
||
|
|
matched = false;
|
||
|
|
for ( modeNum = 0 ; ; modeNum++ ) {
|
||
|
|
if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
|
||
|
|
if ( matched ) {
|
||
|
|
// we got a resolution match, but not a frequency match
|
||
|
|
// so disable the frequency requirement
|
||
|
|
common->Printf( "...^3%dhz is unsupported at %dx%d^0\n", parms.displayHz, parms.width, parms.height );
|
||
|
|
parms.displayHz = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
common->Printf( "...^3%dx%d is unsupported in 32 bit^0\n", parms.width, parms.height );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if ( (int)devmode.dmPelsWidth >= parms.width
|
||
|
|
&& (int)devmode.dmPelsHeight >= parms.height
|
||
|
|
&& devmode.dmBitsPerPel == 32 ) {
|
||
|
|
|
||
|
|
matched = true;
|
||
|
|
|
||
|
|
if ( parms.displayHz == 0 || devmode.dmDisplayFrequency == parms.displayHz ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
memset( &dm, 0, sizeof( dm ) );
|
||
|
|
dm.dmSize = sizeof( dm );
|
||
|
|
|
||
|
|
dm.dmPelsWidth = parms.width;
|
||
|
|
dm.dmPelsHeight = parms.height;
|
||
|
|
dm.dmBitsPerPel = 32;
|
||
|
|
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
|
||
|
|
|
||
|
|
if ( parms.displayHz != 0 ) {
|
||
|
|
dm.dmDisplayFrequency = parms.displayHz;
|
||
|
|
dm.dmFields |= DM_DISPLAYFREQUENCY;
|
||
|
|
}
|
||
|
|
|
||
|
|
common->Printf( "...calling CDS: " );
|
||
|
|
|
||
|
|
// try setting the exact mode requested, because some drivers don't report
|
||
|
|
// the low res modes in EnumDisplaySettings, but still work
|
||
|
|
if ( ( cdsRet = ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL ) {
|
||
|
|
common->Printf( "ok\n" );
|
||
|
|
win32.cdsFullscreen = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// the exact mode failed, so scan EnumDisplaySettings for the next largest mode
|
||
|
|
//
|
||
|
|
common->Printf( "^3failed^0, " );
|
||
|
|
|
||
|
|
PrintCDSError( cdsRet );
|
||
|
|
|
||
|
|
common->Printf( "...trying next higher resolution:" );
|
||
|
|
|
||
|
|
// we could do a better matching job here...
|
||
|
|
for ( modeNum = 0 ; ; modeNum++ ) {
|
||
|
|
if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if ( (int)devmode.dmPelsWidth >= parms.width
|
||
|
|
&& (int)devmode.dmPelsHeight >= parms.height
|
||
|
|
&& devmode.dmBitsPerPel == 32 ) {
|
||
|
|
|
||
|
|
if ( ( cdsRet = ChangeDisplaySettings( &devmode, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL ) {
|
||
|
|
common->Printf( "ok\n" );
|
||
|
|
win32.cdsFullscreen = true;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
common->Printf( "\n...^3no high res mode found^0\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_Init
|
||
|
|
|
||
|
|
This is the platform specific OpenGL initialization function. It
|
||
|
|
is responsible for loading OpenGL, initializing it,
|
||
|
|
creating a window of the appropriate size, doing
|
||
|
|
fullscreen manipulations, etc. Its overall responsibility is
|
||
|
|
to make sure that a functional OpenGL subsystem is operating
|
||
|
|
when it returns to the ref.
|
||
|
|
|
||
|
|
If there is any failure, the renderer will revert back to safe
|
||
|
|
parameters and try again.
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
bool GLimp_Init( glimpParms_t parms ) {
|
||
|
|
const char *driverName;
|
||
|
|
HDC hDC;
|
||
|
|
|
||
|
|
common->Printf( "Initializing OpenGL subsystem\n" );
|
||
|
|
|
||
|
|
// check our desktop attributes
|
||
|
|
hDC = GetDC( GetDesktopWindow() );
|
||
|
|
win32.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
|
||
|
|
win32.desktopWidth = GetDeviceCaps( hDC, HORZRES );
|
||
|
|
win32.desktopHeight = GetDeviceCaps( hDC, VERTRES );
|
||
|
|
ReleaseDC( GetDesktopWindow(), hDC );
|
||
|
|
|
||
|
|
// we can't run in a window unless it is 32 bpp
|
||
|
|
if ( win32.desktopBitsPixel < 32 && !parms.fullScreen ) {
|
||
|
|
common->Printf("^3Windowed mode requires 32 bit desktop depth^0\n");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// save the hardware gamma so it can be
|
||
|
|
// restored on exit
|
||
|
|
GLimp_SaveGamma();
|
||
|
|
|
||
|
|
// create our window classes if we haven't already
|
||
|
|
GLW_CreateWindowClasses();
|
||
|
|
|
||
|
|
// this will load the dll and set all our qgl* function pointers,
|
||
|
|
// but doesn't create a window
|
||
|
|
|
||
|
|
// r_glDriver is only intended for using instrumented OpenGL
|
||
|
|
// dlls. Normal users should never have to use it, and it is
|
||
|
|
// not archived.
|
||
|
|
driverName = r_glDriver.GetString()[0] ? r_glDriver.GetString() : "opengl32";
|
||
|
|
if ( !QGL_Init( driverName ) ) {
|
||
|
|
common->Printf( "^3GLimp_Init() could not load r_glDriver \"%s\"^0\n", driverName );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// getting the wgl extensions involves creating a fake window to get a context,
|
||
|
|
// which is pretty disgusting, and seems to mess with the AGP VAR allocation
|
||
|
|
GLW_GetWGLExtensionsWithFakeWindow();
|
||
|
|
|
||
|
|
// try to change to fullscreen
|
||
|
|
if ( parms.fullScreen ) {
|
||
|
|
if ( !GLW_SetFullScreen( parms ) ) {
|
||
|
|
GLimp_Shutdown();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// try to create a window with the correct pixel format
|
||
|
|
// and init the renderer context
|
||
|
|
if ( !GLW_CreateWindow( parms ) ) {
|
||
|
|
GLimp_Shutdown();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// wglSwapinterval, etc
|
||
|
|
GLW_CheckWGLExtensions( win32.hDC );
|
||
|
|
|
||
|
|
// check logging
|
||
|
|
GLimp_EnableLogging( ( r_logFile.GetInteger() != 0 ) );
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_SetScreenParms
|
||
|
|
|
||
|
|
Sets up the screen based on passed parms..
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
bool GLimp_SetScreenParms( glimpParms_t parms ) {
|
||
|
|
int exstyle;
|
||
|
|
int stylebits;
|
||
|
|
int x, y, w, h;
|
||
|
|
DEVMODE dm;
|
||
|
|
|
||
|
|
memset( &dm, 0, sizeof( dm ) );
|
||
|
|
dm.dmSize = sizeof( dm );
|
||
|
|
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
|
||
|
|
if ( parms.displayHz != 0 ) {
|
||
|
|
dm.dmDisplayFrequency = parms.displayHz;
|
||
|
|
dm.dmFields |= DM_DISPLAYFREQUENCY;
|
||
|
|
}
|
||
|
|
|
||
|
|
win32.cdsFullscreen = parms.fullScreen;
|
||
|
|
glConfig.isFullscreen = parms.fullScreen;
|
||
|
|
|
||
|
|
if ( parms.fullScreen ) {
|
||
|
|
exstyle = WS_EX_TOPMOST;
|
||
|
|
stylebits = WS_POPUP|WS_VISIBLE|WS_SYSMENU;
|
||
|
|
SetWindowLong( win32.hWnd, GWL_STYLE, stylebits );
|
||
|
|
SetWindowLong( win32.hWnd, GWL_EXSTYLE, exstyle );
|
||
|
|
dm.dmPelsWidth = parms.width;
|
||
|
|
dm.dmPelsHeight = parms.height;
|
||
|
|
dm.dmBitsPerPel = 32;
|
||
|
|
x = y = w = h = 0;
|
||
|
|
} else {
|
||
|
|
RECT r;
|
||
|
|
|
||
|
|
// adjust width and height for window border
|
||
|
|
r.bottom = parms.height;
|
||
|
|
r.left = 0;
|
||
|
|
r.top = 0;
|
||
|
|
r.right = parms.width;
|
||
|
|
|
||
|
|
w = r.right - r.left;
|
||
|
|
h = r.bottom - r.top;
|
||
|
|
|
||
|
|
x = win32.win_xpos.GetInteger();
|
||
|
|
y = win32.win_ypos.GetInteger();
|
||
|
|
|
||
|
|
// adjust window coordinates if necessary
|
||
|
|
// so that the window is completely on screen
|
||
|
|
if ( x + w > win32.desktopWidth ) {
|
||
|
|
x = ( win32.desktopWidth - w );
|
||
|
|
}
|
||
|
|
if ( y + h > win32.desktopHeight ) {
|
||
|
|
y = ( win32.desktopHeight - h );
|
||
|
|
}
|
||
|
|
if ( x < 0 ) {
|
||
|
|
x = 0;
|
||
|
|
}
|
||
|
|
if ( y < 0 ) {
|
||
|
|
y = 0;
|
||
|
|
}
|
||
|
|
dm.dmPelsWidth = win32.desktopWidth;
|
||
|
|
dm.dmPelsHeight = win32.desktopHeight;
|
||
|
|
dm.dmBitsPerPel = win32.desktopBitsPixel;
|
||
|
|
exstyle = 0;
|
||
|
|
stylebits = WINDOW_STYLE|WS_SYSMENU;
|
||
|
|
AdjustWindowRect (&r, stylebits, FALSE);
|
||
|
|
SetWindowLong( win32.hWnd, GWL_STYLE, stylebits );
|
||
|
|
SetWindowLong( win32.hWnd, GWL_EXSTYLE, exstyle );
|
||
|
|
common->Printf( "%i %i %i %i\n", x, y, w, h );
|
||
|
|
}
|
||
|
|
bool ret = ( ChangeDisplaySettings( &dm, parms.fullScreen ? CDS_FULLSCREEN : 0 ) == DISP_CHANGE_SUCCESSFUL );
|
||
|
|
SetWindowPos( win32.hWnd, parms.fullScreen ? HWND_TOPMOST : HWND_NOTOPMOST, x, y, w, h, parms.fullScreen ? SWP_NOSIZE | SWP_NOMOVE : SWP_SHOWWINDOW );
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_Shutdown
|
||
|
|
|
||
|
|
This routine does all OS specific shutdown procedures for the OpenGL
|
||
|
|
subsystem.
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
void GLimp_Shutdown( void ) {
|
||
|
|
const char *success[] = { "failed", "success" };
|
||
|
|
int retVal;
|
||
|
|
|
||
|
|
common->Printf( "Shutting down OpenGL subsystem\n" );
|
||
|
|
|
||
|
|
// set current context to NULL
|
||
|
|
if ( qwglMakeCurrent ) {
|
||
|
|
retVal = qwglMakeCurrent( NULL, NULL ) != 0;
|
||
|
|
common->Printf( "...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] );
|
||
|
|
}
|
||
|
|
|
||
|
|
// delete HGLRC
|
||
|
|
if ( win32.hGLRC ) {
|
||
|
|
retVal = qwglDeleteContext( win32.hGLRC ) != 0;
|
||
|
|
common->Printf( "...deleting GL context: %s\n", success[retVal] );
|
||
|
|
win32.hGLRC = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// release DC
|
||
|
|
if ( win32.hDC ) {
|
||
|
|
retVal = ReleaseDC( win32.hWnd, win32.hDC ) != 0;
|
||
|
|
common->Printf( "...releasing DC: %s\n", success[retVal] );
|
||
|
|
win32.hDC = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// destroy window
|
||
|
|
if ( win32.hWnd ) {
|
||
|
|
common->Printf( "...destroying window\n" );
|
||
|
|
ShowWindow( win32.hWnd, SW_HIDE );
|
||
|
|
DestroyWindow( win32.hWnd );
|
||
|
|
win32.hWnd = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// reset display settings
|
||
|
|
if ( win32.cdsFullscreen ) {
|
||
|
|
common->Printf( "...resetting display\n" );
|
||
|
|
ChangeDisplaySettings( 0, 0 );
|
||
|
|
win32.cdsFullscreen = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// close the thread so the handle doesn't dangle
|
||
|
|
if ( win32.renderThreadHandle ) {
|
||
|
|
common->Printf( "...closing smp thread\n" );
|
||
|
|
CloseHandle( win32.renderThreadHandle );
|
||
|
|
win32.renderThreadHandle = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// restore gamma
|
||
|
|
GLimp_RestoreGamma();
|
||
|
|
|
||
|
|
// shutdown QGL subsystem
|
||
|
|
QGL_Shutdown();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
=====================
|
||
|
|
GLimp_SwapBuffers
|
||
|
|
=====================
|
||
|
|
*/
|
||
|
|
void GLimp_SwapBuffers( void ) {
|
||
|
|
//
|
||
|
|
// wglSwapinterval is a windows-private extension,
|
||
|
|
// so we must check for it here instead of portably
|
||
|
|
//
|
||
|
|
if ( r_swapInterval.IsModified() ) {
|
||
|
|
r_swapInterval.ClearModified();
|
||
|
|
|
||
|
|
if ( wglSwapIntervalEXT ) {
|
||
|
|
wglSwapIntervalEXT( r_swapInterval.GetInteger() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
qwglSwapBuffers( win32.hDC );
|
||
|
|
|
||
|
|
//Sys_DebugPrintf( "*** SwapBuffers() ***\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===========================================================
|
||
|
|
|
||
|
|
SMP acceleration
|
||
|
|
|
||
|
|
===========================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
//#define REALLOC_DC
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_ActivateContext
|
||
|
|
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
void GLimp_ActivateContext( void ) {
|
||
|
|
if ( !qwglMakeCurrent( win32.hDC, win32.hGLRC ) ) {
|
||
|
|
win32.wglErrors++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_DeactivateContext
|
||
|
|
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
void GLimp_DeactivateContext( void ) {
|
||
|
|
qglFinish();
|
||
|
|
if ( !qwglMakeCurrent( win32.hDC, NULL ) ) {
|
||
|
|
win32.wglErrors++;
|
||
|
|
}
|
||
|
|
#ifdef REALLOC_DC
|
||
|
|
// makeCurrent NULL frees the DC, so get another
|
||
|
|
if ( ( win32.hDC = GetDC( win32.hWnd ) ) == NULL ) {
|
||
|
|
win32.wglErrors++;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_RenderThreadWrapper
|
||
|
|
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
static void GLimp_RenderThreadWrapper( void ) {
|
||
|
|
win32.glimpRenderThread();
|
||
|
|
|
||
|
|
// unbind the context before we die
|
||
|
|
qwglMakeCurrent( win32.hDC, NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
=======================
|
||
|
|
GLimp_SpawnRenderThread
|
||
|
|
|
||
|
|
Returns false if the system only has a single processor
|
||
|
|
=======================
|
||
|
|
*/
|
||
|
|
bool GLimp_SpawnRenderThread( void (*function)( void ) ) {
|
||
|
|
SYSTEM_INFO info;
|
||
|
|
|
||
|
|
// check number of processors
|
||
|
|
GetSystemInfo( &info );
|
||
|
|
if ( info.dwNumberOfProcessors < 2 ) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// create the IPC elements
|
||
|
|
win32.renderCommandsEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
|
||
|
|
win32.renderCompletedEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
|
||
|
|
win32.renderActiveEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
|
||
|
|
|
||
|
|
win32.glimpRenderThread = function;
|
||
|
|
|
||
|
|
win32.renderThreadHandle = CreateThread(
|
||
|
|
NULL, // LPSECURITY_ATTRIBUTES lpsa,
|
||
|
|
0, // DWORD cbStack,
|
||
|
|
(LPTHREAD_START_ROUTINE)GLimp_RenderThreadWrapper, // LPTHREAD_START_ROUTINE lpStartAddr,
|
||
|
|
0, // LPVOID lpvThreadParm,
|
||
|
|
0, // DWORD fdwCreate,
|
||
|
|
&win32.renderThreadId );
|
||
|
|
|
||
|
|
if ( !win32.renderThreadHandle ) {
|
||
|
|
common->Error( "GLimp_SpawnRenderThread: failed" );
|
||
|
|
}
|
||
|
|
|
||
|
|
SetThreadPriority( win32.renderThreadHandle, THREAD_PRIORITY_ABOVE_NORMAL );
|
||
|
|
#if 0
|
||
|
|
// make sure they always run on different processors
|
||
|
|
SetThreadAffinityMask( GetCurrentThread, 1 );
|
||
|
|
SetThreadAffinityMask( win32.renderThreadHandle, 2 );
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//#define DEBUG_PRINTS
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_BackEndSleep
|
||
|
|
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
void *GLimp_BackEndSleep( void ) {
|
||
|
|
void *data;
|
||
|
|
|
||
|
|
#ifdef DEBUG_PRINTS
|
||
|
|
OutputDebugString( "-->GLimp_BackEndSleep\n" );
|
||
|
|
#endif
|
||
|
|
ResetEvent( win32.renderActiveEvent );
|
||
|
|
|
||
|
|
// after this, the front end can exit GLimp_FrontEndSleep
|
||
|
|
SetEvent( win32.renderCompletedEvent );
|
||
|
|
|
||
|
|
WaitForSingleObject( win32.renderCommandsEvent, INFINITE );
|
||
|
|
|
||
|
|
ResetEvent( win32.renderCompletedEvent );
|
||
|
|
ResetEvent( win32.renderCommandsEvent );
|
||
|
|
|
||
|
|
data = win32.smpData;
|
||
|
|
|
||
|
|
// after this, the main thread can exit GLimp_WakeRenderer
|
||
|
|
SetEvent( win32.renderActiveEvent );
|
||
|
|
|
||
|
|
#ifdef DEBUG_PRINTS
|
||
|
|
OutputDebugString( "<--GLimp_BackEndSleep\n" );
|
||
|
|
#endif
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_FrontEndSleep
|
||
|
|
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
void GLimp_FrontEndSleep( void ) {
|
||
|
|
#ifdef DEBUG_PRINTS
|
||
|
|
OutputDebugString( "-->GLimp_FrontEndSleep\n" );
|
||
|
|
#endif
|
||
|
|
WaitForSingleObject( win32.renderCompletedEvent, INFINITE );
|
||
|
|
|
||
|
|
#ifdef DEBUG_PRINTS
|
||
|
|
OutputDebugString( "<--GLimp_FrontEndSleep\n" );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
volatile bool renderThreadActive;
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_WakeBackEnd
|
||
|
|
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
void GLimp_WakeBackEnd( void *data ) {
|
||
|
|
int r;
|
||
|
|
|
||
|
|
#ifdef DEBUG_PRINTS
|
||
|
|
OutputDebugString( "-->GLimp_WakeBackEnd\n" );
|
||
|
|
#endif
|
||
|
|
win32.smpData = data;
|
||
|
|
|
||
|
|
if ( renderThreadActive ) {
|
||
|
|
common->FatalError( "GLimp_WakeBackEnd: already active" );
|
||
|
|
}
|
||
|
|
|
||
|
|
r = WaitForSingleObject( win32.renderActiveEvent, 0 );
|
||
|
|
if ( r == WAIT_OBJECT_0 ) {
|
||
|
|
common->FatalError( "GLimp_WakeBackEnd: already signaled" );
|
||
|
|
}
|
||
|
|
|
||
|
|
r = WaitForSingleObject( win32.renderCommandsEvent, 0 );
|
||
|
|
if ( r == WAIT_OBJECT_0 ) {
|
||
|
|
common->FatalError( "GLimp_WakeBackEnd: commands already signaled" );
|
||
|
|
}
|
||
|
|
|
||
|
|
// after this, the renderer can continue through GLimp_RendererSleep
|
||
|
|
SetEvent( win32.renderCommandsEvent );
|
||
|
|
|
||
|
|
r = WaitForSingleObject( win32.renderActiveEvent, 5000 );
|
||
|
|
|
||
|
|
if ( r == WAIT_TIMEOUT ) {
|
||
|
|
common->FatalError( "GLimp_WakeBackEnd: WAIT_TIMEOUT" );
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef DEBUG_PRINTS
|
||
|
|
OutputDebugString( "<--GLimp_WakeBackEnd\n" );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
//===================================================================
|
||
|
|
|
||
|
|
/*
|
||
|
|
===================
|
||
|
|
GLimp_ExtensionPointer
|
||
|
|
|
||
|
|
Returns a function pointer for an OpenGL extension entry point
|
||
|
|
===================
|
||
|
|
*/
|
||
|
|
GLExtension_t GLimp_ExtensionPointer( const char *name ) {
|
||
|
|
void (*proc)(void);
|
||
|
|
|
||
|
|
proc = (GLExtension_t)qwglGetProcAddress( name );
|
||
|
|
|
||
|
|
if ( !proc ) {
|
||
|
|
common->Printf( "Couldn't find proc address for: %s\n", name );
|
||
|
|
}
|
||
|
|
|
||
|
|
return proc;
|
||
|
|
}
|
||
|
|
|