glw_imp.c File Reference

#include <assert.h>
#include <windows.h>
#include "../ref_gl/gl_local.h"
#include "glw_win.h"
#include "winquake.h"

Go to the source code of this file.

Macros
#define	WINDOW_CLASS_NAME   "Quake 2"
#define	OSR2_BUILD_NUMBER   1111

Functions
static qboolean	GLimp_SwitchFullscreen (int width, int height)
qboolean	GLimp_InitGL (void)
static qboolean	VerifyDriver (void)
qboolean	VID_CreateWindow (int width, int height, qboolean fullscreen)
rserr_t	GLimp_SetMode (int *pwidth, int *pheight, int mode, qboolean fullscreen)
void	GLimp_Shutdown (void)
qboolean	GLimp_Init (void *hinstance, void *wndproc)
void	GLimp_BeginFrame (float camera_separation)
void	GLimp_EndFrame (void)
void	GLimp_AppActivate (qboolean active)

Variables
glwstate_t	glw_state
cvar_t *	vid_fullscreen
cvar_t *	vid_ref

Macro Definition Documentation

OSR2_BUILD_NUMBER

#define OSR2_BUILD_NUMBER   1111

WINDOW_CLASS_NAME

#define WINDOW_CLASS_NAME   "Quake 2"

Definition at line 62 of file glw_imp.c.

Function Documentation

GLimp_AppActivate()

void GLimp_AppActivate

(

qboolean

active

)

Definition at line 604 of file glw_imp.c.

{
    if ( active )
    {
        SetForegroundWindow( glw_state.hWnd );
        ShowWindow( glw_state.hWnd, SW_RESTORE );
    }
    else
    {
        if ( vid_fullscreen->value )
            ShowWindow( glw_state.hWnd, SW_MINIMIZE );
    }
}

Referenced by GetRefAPI().

GLimp_BeginFrame()

void GLimp_BeginFrame

(

float

camera_separation

)

Definition at line 554 of file glw_imp.c.

{
    if ( gl_bitdepth->modified )
    {
        if ( gl_bitdepth->value != 0 && !glw_state.allowdisplaydepthchange )
        {
            ri.Cvar_SetValue( "gl_bitdepth", 0 );
            ri.Con_Printf( PRINT_ALL, "gl_bitdepth requires Win95 OSR2.x or WinNT 4.x\n" );
        }
        gl_bitdepth->modified = false;
    }
 
    if ( camera_separation < 0 && gl_state.stereo_enabled )
    {
        qglDrawBuffer( GL_BACK_LEFT );
    }
    else if ( camera_separation > 0 && gl_state.stereo_enabled )
    {
        qglDrawBuffer( GL_BACK_RIGHT );
    }
    else
    {
        qglDrawBuffer( GL_BACK );
    }
}

Referenced by R_BeginFrame().

GLimp_EndFrame()

void GLimp_EndFrame

(

void

)

Definition at line 587 of file glw_imp.c.

{
    int     err;
 
    err = qglGetError();
    assert( err == GL_NO_ERROR );
 
    if ( stricmp( gl_drawbuffer->string, "GL_BACK" ) == 0 )
    {
        if ( !qwglSwapBuffers( glw_state.hDC ) )
            ri.Sys_Error( ERR_FATAL, "GLimp_EndFrame() - SwapBuffers() failed!\n" );
    }
}

Referenced by GetRefAPI().

GLimp_Init()

qboolean GLimp_Init	(	void *	hinstance,
		void *	wndproc
	)

Definition at line 347 of file glw_imp.c.

{
#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
    {
        ri.Con_Printf( PRINT_ALL, "GLimp_Init() - GetVersionEx failed\n" );
        return false;
    }
 
    glw_state.hInstance = ( HINSTANCE ) hinstance;
    glw_state.wndproc = wndproc;
 
    return true;
}

Referenced by R_Init().

GLimp_InitGL()

qboolean GLimp_InitGL

(

void

)

Definition at line 390 of file glw_imp.c.

{
    PIXELFORMATDESCRIPTOR pfd = 
    {
        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
        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;
    cvar_t *stereo;
    
    stereo = ri.Cvar_Get( "cl_stereo", "0", 0 );
 
    /*
    ** set PFD_STEREO if necessary
    */
    if ( stereo->value != 0 )
    {
        ri.Con_Printf( PRINT_ALL, "...attempting to use stereo\n" );
        pfd.dwFlags |= PFD_STEREO;
        gl_state.stereo_enabled = true;
    }
    else
    {
        gl_state.stereo_enabled = false;
    }
 
    /*
    ** figure out if we're running on a minidriver or not
    */
    if ( strstr( gl_driver->string, "opengl32" ) != 0 )
        glw_state.minidriver = false;
    else
        glw_state.minidriver = true;
 
    /*
    ** Get a DC for the specified window
    */
    if ( glw_state.hDC != NULL )
        ri.Con_Printf( PRINT_ALL, "GLimp_Init() - non-NULL DC exists\n" );
 
    if ( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
    {
        ri.Con_Printf( PRINT_ALL, "GLimp_Init() - GetDC failed\n" );
        return false;
    }
 
    if ( glw_state.minidriver )
    {
        if ( (pixelformat = qwglChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
        {
            ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglChoosePixelFormat failed\n");
            return false;
        }
        if ( qwglSetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
        {
            ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglSetPixelFormat failed\n");
            return false;
        }
        qwglDescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
    }
    else
    {
        if ( ( pixelformat = ChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
        {
            ri.Con_Printf (PRINT_ALL, "GLimp_Init() - ChoosePixelFormat failed\n");
            return false;
        }
        if ( SetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
        {
            ri.Con_Printf (PRINT_ALL, "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;
        }
    }
 
    /*
    ** report if stereo is desired but unavailable
    */
    if ( !( pfd.dwFlags & PFD_STEREO ) && ( stereo->value != 0 ) ) 
    {
        ri.Con_Printf( PRINT_ALL, "...failed to select stereo pixel format\n" );
        ri.Cvar_SetValue( "cl_stereo", 0 );
        gl_state.stereo_enabled = false;
    }
 
    /*
    ** startup the OpenGL subsystem by creating a context and making
    ** it current
    */
    if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
    {
        ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglCreateContext failed\n");
 
        goto fail;
    }
 
    if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
    {
        ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglMakeCurrent failed\n");
 
        goto fail;
    }
 
    if ( !VerifyDriver() )
    {
        ri.Con_Printf( PRINT_ALL, "GLimp_Init() - no hardware acceleration detected\n" );
        goto fail;
    }
 
    /*
    ** print out PFD specifics 
    */
    ri.Con_Printf( PRINT_ALL, "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;
}

Referenced by VID_CreateWindow().

GLimp_SetMode()

rserr_t GLimp_SetMode	(	int *	pwidth,
		int *	pheight,
		int	mode,
		qboolean	fullscreen
	)

Definition at line 159 of file glw_imp.c.

{
    int width, height;
    const char *win_fs[] = { "W", "FS" };
 
    ri.Con_Printf( PRINT_ALL, "Initializing OpenGL display\n");
 
    ri.Con_Printf (PRINT_ALL, "...setting mode %d:", mode );
 
    if ( !ri.Vid_GetModeInfo( &width, &height, mode ) )
    {
        ri.Con_Printf( PRINT_ALL, " invalid mode\n" );
        return rserr_invalid_mode;
    }
 
    ri.Con_Printf( PRINT_ALL, " %d %d %s\n", width, height, win_fs[fullscreen] );
 
    // destroy the existing window
    if (glw_state.hWnd)
    {
        GLimp_Shutdown ();
    }
 
    // do a CDS if needed
    if ( fullscreen )
    {
        DEVMODE dm;
 
        ri.Con_Printf( PRINT_ALL, "...attempting fullscreen\n" );
 
        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;
            ri.Con_Printf( PRINT_ALL, "...using gl_bitdepth of %d\n", ( int ) gl_bitdepth->value );
        }
        else
        {
            HDC hdc = GetDC( NULL );
            int bitspixel = GetDeviceCaps( hdc, BITSPIXEL );
 
            ri.Con_Printf( PRINT_ALL, "...using desktop display depth of %d\n", bitspixel );
 
            ReleaseDC( 0, hdc );
        }
 
        ri.Con_Printf( PRINT_ALL, "...calling CDS: " );
        if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
        {
            *pwidth = width;
            *pheight = height;
 
            gl_state.fullscreen = true;
 
            ri.Con_Printf( PRINT_ALL, "ok\n" );
 
            if ( !VID_CreateWindow (width, height, true) )
                return rserr_invalid_mode;
 
            return rserr_ok;
        }
        else
        {
            *pwidth = width;
            *pheight = height;
 
            ri.Con_Printf( PRINT_ALL, "failed\n" );
 
            ri.Con_Printf( PRINT_ALL, "...calling CDS assuming dual monitors:" );
 
            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 )
            {
                ri.Con_Printf( PRINT_ALL, " failed\n" );
 
                ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
 
                ChangeDisplaySettings( 0, 0 );
 
                *pwidth = width;
                *pheight = height;
                gl_state.fullscreen = false;
                if ( !VID_CreateWindow (width, height, false) )
                    return rserr_invalid_mode;
                return rserr_invalid_fullscreen;
            }
            else
            {
                ri.Con_Printf( PRINT_ALL, " ok\n" );
                if ( !VID_CreateWindow (width, height, true) )
                    return rserr_invalid_mode;
 
                gl_state.fullscreen = true;
                return rserr_ok;
            }
        }
    }
    else
    {
        ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
 
        ChangeDisplaySettings( 0, 0 );
 
        *pwidth = width;
        *pheight = height;
        gl_state.fullscreen = false;
        if ( !VID_CreateWindow (width, height, false) )
            return rserr_invalid_mode;
    }
 
    return rserr_ok;
}

Referenced by R_SetMode().

GLimp_Shutdown()

void GLimp_Shutdown

(

void

)

Definition at line 302 of file glw_imp.c.

{
    if ( qwglMakeCurrent && !qwglMakeCurrent( NULL, NULL ) )
        ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - wglMakeCurrent failed\n");
    if ( glw_state.hGLRC )
    {
        if (  qwglDeleteContext && !qwglDeleteContext( glw_state.hGLRC ) )
            ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - wglDeleteContext failed\n");
        glw_state.hGLRC = NULL;
    }
    if (glw_state.hDC)
    {
        if ( !ReleaseDC( glw_state.hWnd, glw_state.hDC ) )
            ri.Con_Printf( PRINT_ALL, "ref_gl::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;
    }
}

Referenced by GLimp_SetMode(), and R_Shutdown().

GLimp_SwitchFullscreen()

static qboolean GLimp_SwitchFullscreen ( int  width, int  height  )

static

VerifyDriver()

static qboolean VerifyDriver ( void  )

static

Definition at line 47 of file glw_imp.c.

{
    char buffer[1024];
 
    strcpy( buffer, qglGetString( GL_RENDERER ) );
    strlwr( buffer );
    if ( strcmp( buffer, "gdi generic" ) == 0 )
        if ( !glw_state.mcd_accelerated )
            return false;
    return true;
}

Referenced by GLimp_InitGL().

VID_CreateWindow()

qboolean VID_CreateWindow	(	int	width,
		int	height,
		qboolean	fullscreen
	)

Definition at line 64 of file glw_imp.c.

{
    WNDCLASS        wc;
    RECT            r;
    cvar_t          *vid_xpos, *vid_ypos;
    int             stylebits;
    int             x, y, w, h;
    int             exstyle;
 
    /* 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         = 0;
    wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
    wc.hbrBackground = (void *)COLOR_GRAYTEXT;
    wc.lpszMenuName  = 0;
    wc.lpszClassName = WINDOW_CLASS_NAME;
 
    if (!RegisterClass (&wc) )
        ri.Sys_Error (ERR_FATAL, "Couldn't register window class");
 
    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
    {
        vid_xpos = ri.Cvar_Get ("vid_xpos", "0", 0);
        vid_ypos = ri.Cvar_Get ("vid_ypos", "0", 0);
        x = vid_xpos->value;
        y = vid_ypos->value;
    }
 
    glw_state.hWnd = CreateWindowEx (
         exstyle, 
         WINDOW_CLASS_NAME,
         "Quake 2",
         stylebits,
         x, y, w, h,
         NULL,
         NULL,
         glw_state.hInstance,
         NULL);
 
    if (!glw_state.hWnd)
        ri.Sys_Error (ERR_FATAL, "Couldn't create window");
    
    ShowWindow( glw_state.hWnd, SW_SHOW );
    UpdateWindow( glw_state.hWnd );
 
    // init all the gl stuff for the window
    if (!GLimp_InitGL ())
    {
        ri.Con_Printf( PRINT_ALL, "VID_CreateWindow() - GLimp_InitGL failed\n");
        return false;
    }
 
    SetForegroundWindow( glw_state.hWnd );
    SetFocus( glw_state.hWnd );
 
    // let the sound and input subsystems know about the new window
    ri.Vid_NewWindow (width, height);
 
    return true;
}

Referenced by GLimp_SetMode().

Variable Documentation

glw_state

glwstate_t glw_state

Definition at line 42 of file glw_imp.c.

Referenced by GLimp_AppActivate(), GLimp_BeginFrame(), GLimp_EnableLogging(), GLimp_EndFrame(), GLimp_Init(), GLimp_InitGL(), GLimp_LogNewFrame(), GLimp_SetMode(), GLimp_Shutdown(), logAccum(), logAlphaFunc(), logAreTexturesResident(), logArrayElement(), logBegin(), logBindTexture(), logBitmap(), logBlendFunc(), logCallList(), logCallLists(), logClear(), logClearAccum(), logClearColor(), logClearDepth(), logClearIndex(), logClearStencil(), logClipPlane(), logColor3b(), logColor3bv(), logColor3d(), logColor3dv(), logColor3f(), logColor3fv(), logColor3i(), logColor3iv(), logColor3s(), logColor3sv(), logColor3ub(), logColor3ubv(), logColor4f(), logColor4fv(), logDisable(), logEnable(), logHint(), logPolygonMode(), logTexEnvf(), logTexEnvi(), logTexParameterf(), logTexParameteri(), QGL_Init(), QGL_Shutdown(), VerifyDriver(), and VID_CreateWindow().

vid_fullscreen

cvar_t* vid_fullscreen

Definition at line 46 of file vid_dll.c.

Referenced by GLimp_AppActivate(), SWimp_AppActivate(), and VID_CreateWindow().

vid_ref

cvar_t* vid_ref

Definition at line 43 of file vid_dll.c.