mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-24 05:11:21 +00:00
1865 lines
50 KiB
Text
1865 lines
50 KiB
Text
/*
|
||
===========================================================================
|
||
|
||
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.
|
||
|
||
===========================================================================
|
||
*/
|
||
|
||
// -*- mode: objc -*-
|
||
#import "../../idlib/precompiled.h"
|
||
|
||
#import "../../renderer/tr_local.h"
|
||
|
||
#import "macosx_glimp.h"
|
||
|
||
#import "macosx_local.h"
|
||
#import "macosx_sys.h"
|
||
#import "macosx_display.h"
|
||
|
||
#import <AppKit/AppKit.h>
|
||
#import <Foundation/Foundation.h>
|
||
|
||
#import <mach-o/dyld.h>
|
||
#import <mach/mach.h>
|
||
#import <mach/mach_error.h>
|
||
|
||
static idCVar r_minDisplayRefresh( "r_minDisplayRefresh", "0", CVAR_ARCHIVE | CVAR_INTEGER, "" );
|
||
static idCVar r_maxDisplayRefresh( "r_maxDisplayRefresh", "0", CVAR_ARCHIVE | CVAR_INTEGER, "" );
|
||
static idCVar r_screen( "r_screen", "-1", CVAR_ARCHIVE | CVAR_INTEGER, "which display to use" );
|
||
|
||
static void GLW_InitExtensions( void );
|
||
static bool CreateGameWindow( glimpParms_t parms );
|
||
static unsigned long Sys_QueryVideoMemory();
|
||
CGDisplayErr Sys_CaptureActiveDisplays(void);
|
||
|
||
glwstate_t glw_state;
|
||
static bool isHidden = false;
|
||
|
||
@interface NSOpenGLContext (CGLContextAccess)
|
||
- (CGLContextObj) cglContext;
|
||
@end
|
||
|
||
@implementation NSOpenGLContext (CGLContextAccess)
|
||
- (CGLContextObj) cglContext;
|
||
{
|
||
return _contextAuxiliary;
|
||
}
|
||
@end
|
||
|
||
/*
|
||
============
|
||
CheckErrors
|
||
============
|
||
*/
|
||
void CheckErrors( void ) {
|
||
GLenum err;
|
||
|
||
err = qglGetError();
|
||
if ( err != GL_NO_ERROR ) {
|
||
common->Error( "glGetError: %s\n", qglGetString( err ) );
|
||
}
|
||
}
|
||
|
||
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
||
|
||
unsigned int QGLBeginStarted = 0;
|
||
|
||
void QGLErrorBreak(void) { }
|
||
|
||
void QGLCheckError( const char *message ) {
|
||
GLenum error;
|
||
static unsigned int errorCount = 0;
|
||
|
||
error = _glGetError();
|
||
if (error != GL_NO_ERROR) {
|
||
if (errorCount == 100) {
|
||
common->Printf("100 GL errors printed ... disabling further error reporting.\n");
|
||
} else if (errorCount < 100) {
|
||
if (errorCount == 0) {
|
||
common->Warning("BREAK ON QGLErrorBreak to stop at the GL errors\n");
|
||
}
|
||
common->Warning("OpenGL Error(%s): 0x%04x -- %s\n", message, (int)error, gluErrorString(error));
|
||
QGLErrorBreak();
|
||
}
|
||
errorCount++;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/*
|
||
** GLimp_SetMode
|
||
*/
|
||
|
||
bool GLimp_SetMode( glimpParms_t parms ) {
|
||
if ( !CreateGameWindow( parms ) ) {
|
||
common->Printf( "GLimp_SetMode: window could not be created!\n" );
|
||
return false;
|
||
}
|
||
|
||
glConfig.vidWidth = parms.width;
|
||
glConfig.vidHeight = parms.height;
|
||
glConfig.isFullscreen = parms.fullScreen;
|
||
|
||
// draw something to show that GL is alive
|
||
qglClearColor( 0.5, 0.5, 0.7, 0 );
|
||
qglClear( GL_COLOR_BUFFER_BIT );
|
||
GLimp_SwapBuffers();
|
||
|
||
qglClearColor( 0.5, 0.5, 0.7, 0 );
|
||
qglClear( GL_COLOR_BUFFER_BIT );
|
||
GLimp_SwapBuffers();
|
||
|
||
Sys_UnfadeScreen( Sys_DisplayToUse(), NULL );
|
||
|
||
CheckErrors();
|
||
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
=================
|
||
GetPixelAttributes
|
||
=================
|
||
*/
|
||
|
||
#define ADD_ATTR(x) \
|
||
do { \
|
||
if (attributeIndex >= attributeSize) { \
|
||
attributeSize *= 2; \
|
||
pixelAttributes = (NSOpenGLPixelFormatAttribute *)NSZoneRealloc(NULL, pixelAttributes, sizeof(*pixelAttributes) * attributeSize); \
|
||
} \
|
||
pixelAttributes[attributeIndex] = (NSOpenGLPixelFormatAttribute)x; \
|
||
attributeIndex++; \
|
||
if ( verbose ) { \
|
||
common->Printf( "Adding pixel attribute: %d (%s)\n", x, #x); \
|
||
} \
|
||
} while(0)
|
||
|
||
static NSOpenGLPixelFormatAttribute *GetPixelAttributes( unsigned int multisamples ) {
|
||
NSOpenGLPixelFormatAttribute *pixelAttributes;
|
||
unsigned int attributeIndex = 0;
|
||
unsigned int attributeSize = 128;
|
||
int verbose;
|
||
unsigned int colorDepth;
|
||
unsigned int desktopColorDepth;
|
||
unsigned int depthBits;
|
||
unsigned int stencilBits;
|
||
unsigned int buffers;
|
||
|
||
verbose = 0;
|
||
|
||
pixelAttributes = (NSOpenGLPixelFormatAttribute *)NSZoneMalloc(NULL, sizeof(*pixelAttributes) * attributeSize);
|
||
|
||
// only greater or equal attributes will be selected
|
||
ADD_ATTR( NSOpenGLPFAMinimumPolicy );
|
||
ADD_ATTR( 1 );
|
||
|
||
if ( cvarSystem->GetCVarBool( "r_fullscreen" ) ) {
|
||
ADD_ATTR(NSOpenGLPFAFullScreen);
|
||
}
|
||
|
||
ADD_ATTR(NSOpenGLPFAScreenMask);
|
||
ADD_ATTR(CGDisplayIDToOpenGLDisplayMask(Sys_DisplayToUse()));
|
||
|
||
// Require hardware acceleration
|
||
ADD_ATTR(NSOpenGLPFAAccelerated);
|
||
|
||
// Require double-buffer
|
||
ADD_ATTR(NSOpenGLPFADoubleBuffer);
|
||
|
||
// color bits
|
||
ADD_ATTR(NSOpenGLPFAColorSize);
|
||
colorDepth = 32;
|
||
if ( !cvarSystem->GetCVarBool( "r_fullscreen" ) ) {
|
||
desktopColorDepth = [[glw_state.desktopMode objectForKey: (id)kCGDisplayBitsPerPixel] intValue];
|
||
if ( desktopColorDepth != 32 ) {
|
||
common->Warning( "Desktop display colors should be 32 bits for window rendering" );
|
||
}
|
||
}
|
||
ADD_ATTR(colorDepth);
|
||
|
||
// Specify the number of depth bits
|
||
ADD_ATTR( NSOpenGLPFADepthSize );
|
||
depthBits = 24;
|
||
ADD_ATTR( depthBits );
|
||
|
||
// Specify the number of stencil bits
|
||
stencilBits = 8;
|
||
ADD_ATTR( NSOpenGLPFAStencilSize );
|
||
ADD_ATTR( stencilBits );
|
||
|
||
// Specify destination alpha
|
||
ADD_ATTR( NSOpenGLPFAAlphaSize );
|
||
ADD_ATTR( 8 );
|
||
|
||
if ( multisamples ) {
|
||
buffers = 1;
|
||
ADD_ATTR( NSOpenGLPFASampleBuffers );
|
||
ADD_ATTR( buffers );
|
||
ADD_ATTR( NSOpenGLPFASamples );
|
||
ADD_ATTR( multisamples );
|
||
}
|
||
|
||
// Terminate the list
|
||
ADD_ATTR(0);
|
||
|
||
return pixelAttributes;
|
||
}
|
||
|
||
void Sys_UpdateWindowMouseInputRect(void) {
|
||
NSRect windowRect, screenRect;
|
||
NSScreen *screen;
|
||
|
||
/*
|
||
|
||
// TTimo - I guess glw_state.window is bogus .. getting crappy data out of this
|
||
|
||
// It appears we need to flip the coordinate system here. This means we need
|
||
// to know the size of the screen.
|
||
screen = [glw_state.window screen];
|
||
screenRect = [screen frame];
|
||
windowRect = [glw_state.window frame];
|
||
windowRect.origin.y = screenRect.size.height - (windowRect.origin.y + windowRect.size.height);
|
||
|
||
Sys_SetMouseInputRect( CGRectMake( windowRect.origin.x, windowRect.origin.y, windowRect.size.width, windowRect.size.height ) );
|
||
*/
|
||
|
||
Sys_SetMouseInputRect( CGDisplayBounds( glw_state.display ) );
|
||
}
|
||
|
||
// This is needed since CGReleaseAllDisplays() restores the gamma on the displays and we want to fade it up rather than just flickering all the displays
|
||
static void ReleaseAllDisplays() {
|
||
CGDisplayCount displayIndex;
|
||
|
||
common->Printf("Releasing displays\n");
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
CGDisplayRelease(glw_state.originalDisplayGammaTables[displayIndex].display);
|
||
}
|
||
}
|
||
|
||
/*
|
||
=================
|
||
CreateGameWindow
|
||
=================
|
||
*/
|
||
static bool CreateGameWindow( glimpParms_t parms ) {
|
||
const char *windowed[] = { "Windowed", "Fullscreen" };
|
||
NSOpenGLPixelFormatAttribute *pixelAttributes;
|
||
NSOpenGLPixelFormat *pixelFormat;
|
||
CGDisplayErr err;
|
||
unsigned int multisamples;
|
||
const long swap_limit = false;
|
||
int nsOpenGLCPSwapLimit = 203;
|
||
|
||
glw_state.display = Sys_DisplayToUse();
|
||
glw_state.desktopMode = (NSDictionary *)CGDisplayCurrentMode( glw_state.display );
|
||
if ( !glw_state.desktopMode ) {
|
||
common->Error( "Could not get current graphics mode for display 0x%08x\n", glw_state.display );
|
||
}
|
||
|
||
common->Printf( " %d %d %s\n", parms.width, parms.height, windowed[ parms.fullScreen ] );
|
||
|
||
if (parms.fullScreen) {
|
||
|
||
// We'll set up the screen resolution first in case that effects the list of pixel
|
||
// formats that are available (for example, a smaller frame buffer might mean more
|
||
// bits for depth/stencil buffers). Allow stretched video modes if we are in fallback mode.
|
||
glw_state.gameMode = Sys_GetMatchingDisplayMode(parms);
|
||
if (!glw_state.gameMode) {
|
||
common->Printf( "Unable to find requested display mode.\n");
|
||
return false;
|
||
}
|
||
|
||
// Fade all screens to black
|
||
// Sys_FadeScreens();
|
||
|
||
err = Sys_CaptureActiveDisplays();
|
||
if ( err != CGDisplayNoErr ) {
|
||
CGDisplayRestoreColorSyncSettings();
|
||
common->Printf( " Unable to capture displays err = %d\n", err );
|
||
return false;
|
||
}
|
||
|
||
err = CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.gameMode);
|
||
if ( err != CGDisplayNoErr ) {
|
||
CGDisplayRestoreColorSyncSettings();
|
||
ReleaseAllDisplays();
|
||
common->Printf( " Unable to set display mode, err = %d\n", err );
|
||
return false;
|
||
}
|
||
} else {
|
||
glw_state.gameMode = glw_state.desktopMode;
|
||
}
|
||
|
||
// Get the GL pixel format
|
||
pixelFormat = nil;
|
||
multisamples = cvarSystem->GetCVarInteger( "r_multiSamples" );
|
||
while ( !pixelFormat ) {
|
||
pixelAttributes = GetPixelAttributes( multisamples );
|
||
pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes: pixelAttributes] autorelease];
|
||
NSZoneFree(NULL, pixelAttributes);
|
||
if ( pixelFormat || multisamples == 0 )
|
||
break;
|
||
multisamples >>= 1;
|
||
}
|
||
cvarSystem->SetCVarInteger( "r_multiSamples", multisamples );
|
||
|
||
if (!pixelFormat) {
|
||
CGDisplayRestoreColorSyncSettings();
|
||
CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.desktopMode);
|
||
ReleaseAllDisplays();
|
||
common->Printf( " No pixel format found\n");
|
||
return false;
|
||
}
|
||
|
||
// Create a context with the desired pixel attributes
|
||
OSX_SetGLContext([[NSOpenGLContext alloc] initWithFormat: pixelFormat shareContext: nil]);
|
||
if ( !OSX_GetNSGLContext() ) {
|
||
CGDisplayRestoreColorSyncSettings();
|
||
CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.desktopMode);
|
||
ReleaseAllDisplays();
|
||
common->Printf( "... +[NSOpenGLContext createWithFormat:share:] failed.\n" );
|
||
return false;
|
||
}
|
||
#ifdef __ppc__
|
||
long system_version = 0;
|
||
Gestalt( gestaltSystemVersion, &system_version );
|
||
if ( parms.width <= 1024 && parms.height <= 768 && system_version <= 0x1045 ) {
|
||
[ OSX_GetNSGLContext() setValues: &swap_limit forParameter: (NSOpenGLContextParameter)nsOpenGLCPSwapLimit ];
|
||
}
|
||
#endif
|
||
|
||
if ( !parms.fullScreen ) {
|
||
NSScreen* screen;
|
||
NSRect windowRect;
|
||
int displayIndex;
|
||
int displayCount;
|
||
|
||
displayIndex = r_screen.GetInteger();
|
||
displayCount = [[NSScreen screens] count];
|
||
if ( displayIndex < 0 || displayIndex >= displayCount ) {
|
||
screen = [NSScreen mainScreen];
|
||
} else {
|
||
screen = [[NSScreen screens] objectAtIndex:displayIndex];
|
||
}
|
||
|
||
NSRect r = [screen frame];
|
||
windowRect.origin.x = ((short)r.size.width - parms.width) / 2;
|
||
windowRect.origin.y = ((short)r.size.height - parms.height) / 2;
|
||
windowRect.size.width = parms.width;
|
||
windowRect.size.height = parms.height;
|
||
|
||
glw_state.window = [NSWindow alloc];
|
||
[glw_state.window initWithContentRect:windowRect styleMask:NSTitledWindowMask backing:NSBackingStoreRetained defer:NO screen:screen];
|
||
|
||
[glw_state.window setTitle: @GAME_NAME];
|
||
|
||
[glw_state.window orderFront: nil];
|
||
|
||
// Always get mouse moved events (if mouse support is turned off (rare)
|
||
// the event system will filter them out.
|
||
[glw_state.window setAcceptsMouseMovedEvents: YES];
|
||
|
||
// Direct the context to draw in this window
|
||
[OSX_GetNSGLContext() setView: [glw_state.window contentView]];
|
||
|
||
// Sync input rect with where the window actually is...
|
||
Sys_UpdateWindowMouseInputRect();
|
||
} else {
|
||
CGLError err;
|
||
|
||
glw_state.window = NULL;
|
||
|
||
err = CGLSetFullScreen(OSX_GetCGLContext());
|
||
if (err) {
|
||
CGDisplayRestoreColorSyncSettings();
|
||
CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.desktopMode);
|
||
ReleaseAllDisplays();
|
||
common->Printf("CGLSetFullScreen -> %d (%s)\n", err, CGLErrorString(err));
|
||
return false;
|
||
}
|
||
|
||
Sys_SetMouseInputRect( CGDisplayBounds( glw_state.display ) );
|
||
}
|
||
|
||
#ifndef USE_CGLMACROS
|
||
// Make this the current context
|
||
OSX_GLContextSetCurrent();
|
||
#endif
|
||
|
||
// Store off the pixel format attributes that we actually got
|
||
[pixelFormat getValues: (long *) &glConfig.colorBits forAttribute: NSOpenGLPFAColorSize forVirtualScreen: 0];
|
||
[pixelFormat getValues: (long *) &glConfig.depthBits forAttribute: NSOpenGLPFADepthSize forVirtualScreen: 0];
|
||
[pixelFormat getValues: (long *) &glConfig.stencilBits forAttribute: NSOpenGLPFAStencilSize forVirtualScreen: 0];
|
||
|
||
glConfig.displayFrequency = [[glw_state.gameMode objectForKey: (id)kCGDisplayRefreshRate] intValue];
|
||
|
||
common->Printf( "ok\n" );
|
||
|
||
return true;
|
||
}
|
||
|
||
// This can be used to temporarily disassociate the GL context from the screen so that CoreGraphics can be used to draw to the screen.
|
||
void Sys_PauseGL () {
|
||
if (!glw_state.glPauseCount) {
|
||
qglFinish (); // must do this to ensure the queue is complete
|
||
|
||
// Have to call both to actually deallocate kernel resources and free the NSSurface
|
||
CGLClearDrawable(OSX_GetCGLContext());
|
||
[OSX_GetNSGLContext() clearDrawable];
|
||
}
|
||
glw_state.glPauseCount++;
|
||
}
|
||
|
||
// This can be used to reverse the pausing caused by Sys_PauseGL()
|
||
void Sys_ResumeGL () {
|
||
if (glw_state.glPauseCount) {
|
||
glw_state.glPauseCount--;
|
||
if (!glw_state.glPauseCount) {
|
||
if (!glConfig.isFullscreen) {
|
||
[OSX_GetNSGLContext() setView: [glw_state.window contentView]];
|
||
} else {
|
||
CGLError err;
|
||
|
||
err = CGLSetFullScreen(OSX_GetCGLContext());
|
||
if (err)
|
||
common->Printf("CGLSetFullScreen -> %d (%s)\n", err, CGLErrorString(err));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
===================
|
||
GLimp_Init
|
||
|
||
Don't return unless OpenGL has been properly initialized
|
||
===================
|
||
*/
|
||
|
||
#ifdef OMNI_TIMER
|
||
static void GLImp_Dump_Stamp_List_f(void) {
|
||
OTStampListDumpToFile(glThreadStampList, "/tmp/gl_stamps");
|
||
}
|
||
#endif
|
||
|
||
bool GLimp_Init( glimpParms_t parms ) {
|
||
char *buf;
|
||
|
||
common->Printf( "Initializing OpenGL subsystem\n" );
|
||
common->Printf( " fullscreen: %s\n", cvarSystem->GetCVarBool( "r_fullscreen" ) ? "yes" : "no" );
|
||
|
||
Sys_StoreGammaTables();
|
||
|
||
if ( !Sys_QueryVideoMemory() ) {
|
||
common->Error( "Could not initialize OpenGL. There does not appear to be an OpenGL-supported video card in your system.\n" );
|
||
}
|
||
|
||
if ( !GLimp_SetMode( parms ) ) {
|
||
common->Warning( "Could not initialize OpenGL\n" );
|
||
return false;
|
||
}
|
||
|
||
common->Printf( "------------------\n" );
|
||
|
||
// get our config strings
|
||
glConfig.vendor_string = (const char *)qglGetString( GL_VENDOR );
|
||
glConfig.renderer_string = (const char *)qglGetString( GL_RENDERER );
|
||
glConfig.version_string = (const char *)qglGetString( GL_VERSION );
|
||
glConfig.extensions_string = (const char *)qglGetString( GL_EXTENSIONS );
|
||
|
||
//
|
||
// chipset specific configuration
|
||
//
|
||
buf = (char *)malloc(strlen(glConfig.renderer_string) + 1);
|
||
strcpy( buf, glConfig.renderer_string );
|
||
|
||
// Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
|
||
free(buf);
|
||
|
||
GLW_InitExtensions();
|
||
|
||
/*
|
||
#ifndef USE_CGLMACROS
|
||
if (!r_enablerender->integer)
|
||
OSX_GLContextClearCurrent();
|
||
#endif
|
||
*/
|
||
return true;
|
||
}
|
||
|
||
|
||
/*
|
||
** GLimp_SwapBuffers
|
||
**
|
||
** 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_SwapBuffers( void ) {
|
||
if ( r_swapInterval.IsModified() ) {
|
||
r_swapInterval.ClearModified();
|
||
}
|
||
|
||
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
||
QGLCheckError("GLimp_EndFrame");
|
||
#endif
|
||
|
||
if (!glw_state.glPauseCount && !isHidden) {
|
||
glw_state.bufferSwapCount++;
|
||
[OSX_GetNSGLContext() flushBuffer];
|
||
}
|
||
|
||
/*
|
||
// Enable turning off GL at any point for performance testing
|
||
if (OSX_GLContextIsCurrent() != r_enablerender->integer) {
|
||
if (r_enablerender->integer) {
|
||
common->Printf("--- Enabling Renderer ---\n");
|
||
OSX_GLContextSetCurrent();
|
||
} else {
|
||
common->Printf("--- Disabling Renderer ---\n");
|
||
OSX_GLContextClearCurrent();
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
/*
|
||
** 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.
|
||
**
|
||
*/
|
||
|
||
static void _GLimp_RestoreOriginalVideoSettings() {
|
||
CGDisplayErr err;
|
||
|
||
// CGDisplayCurrentMode lies because we've captured the display and thus we won't
|
||
// get any notifications about what the current display mode really is. For now,
|
||
// we just always force it back to what mode we remember the desktop being in.
|
||
if (glConfig.isFullscreen) {
|
||
err = CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.desktopMode);
|
||
if ( err != CGDisplayNoErr )
|
||
common->Printf( " Unable to restore display mode!\n" );
|
||
|
||
ReleaseAllDisplays();
|
||
}
|
||
}
|
||
|
||
void GLimp_Shutdown( void ) {
|
||
CGDisplayCount displayIndex;
|
||
|
||
common->Printf("----- Shutting down GL -----\n");
|
||
|
||
Sys_FadeScreen(Sys_DisplayToUse());
|
||
|
||
if (OSX_GetNSGLContext()) {
|
||
#ifndef USE_CGLMACROS
|
||
OSX_GLContextClearCurrent();
|
||
#endif
|
||
// Have to call both to actually deallocate kernel resources and free the NSSurface
|
||
CGLClearDrawable(OSX_GetCGLContext());
|
||
[OSX_GetNSGLContext() clearDrawable];
|
||
|
||
[OSX_GetNSGLContext() release];
|
||
OSX_SetGLContext((id)nil);
|
||
}
|
||
|
||
_GLimp_RestoreOriginalVideoSettings();
|
||
|
||
Sys_UnfadeScreens();
|
||
|
||
// Restore the original gamma if needed.
|
||
// if (glConfig.deviceSupportsGamma) {
|
||
// common->Printf("Restoring ColorSync settings\n");
|
||
// CGDisplayRestoreColorSyncSettings();
|
||
// }
|
||
|
||
if (glw_state.window) {
|
||
[glw_state.window release];
|
||
glw_state.window = nil;
|
||
}
|
||
|
||
if (glw_state.log_fp) {
|
||
fclose(glw_state.log_fp);
|
||
glw_state.log_fp = 0;
|
||
}
|
||
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
free(glw_state.originalDisplayGammaTables[displayIndex].red);
|
||
free(glw_state.originalDisplayGammaTables[displayIndex].blue);
|
||
free(glw_state.originalDisplayGammaTables[displayIndex].green);
|
||
}
|
||
free(glw_state.originalDisplayGammaTables);
|
||
if (glw_state.tempTable.red) {
|
||
free(glw_state.tempTable.red);
|
||
free(glw_state.tempTable.blue);
|
||
free(glw_state.tempTable.green);
|
||
}
|
||
if (glw_state.inGameTable.red) {
|
||
free(glw_state.inGameTable.red);
|
||
free(glw_state.inGameTable.blue);
|
||
free(glw_state.inGameTable.green);
|
||
}
|
||
|
||
memset(&glConfig, 0, sizeof(glConfig));
|
||
// memset(&glState, 0, sizeof(glState));
|
||
memset(&glw_state, 0, sizeof(glw_state));
|
||
|
||
common->Printf("----- Done shutting down GL -----\n");
|
||
}
|
||
|
||
/*
|
||
===============
|
||
GLimp_LogComment
|
||
===============
|
||
*/
|
||
void GLimp_LogComment( char *comment ) { }
|
||
|
||
/*
|
||
===============
|
||
GLimp_SetGamma
|
||
===============
|
||
*/
|
||
void GLimp_SetGamma(unsigned short red[256],
|
||
unsigned short green[256],
|
||
unsigned short blue[256]) {
|
||
CGGammaValue redGamma[256], greenGamma[256], blueGamma[256];
|
||
CGTableCount i;
|
||
CGDisplayErr err;
|
||
|
||
for (i = 0; i < 256; i++) {
|
||
redGamma[i] = red[i] / 65535.0;
|
||
greenGamma[i] = green[i] / 65535.0;
|
||
blueGamma[i] = blue[i] / 65535.0;
|
||
}
|
||
|
||
err = CGSetDisplayTransferByTable(glw_state.display, 256, redGamma, greenGamma, blueGamma);
|
||
if (err != CGDisplayNoErr) {
|
||
common->Printf("GLimp_SetGamma: CGSetDisplayTransferByByteTable returned %d.\n", err);
|
||
}
|
||
|
||
// Store the gamma table that we ended up using so we can reapply it later when unhiding or to work around the bug where if you leave the game sitting and the monitor sleeps, when it wakes, the gamma isn't reset.
|
||
glw_state.inGameTable.display = glw_state.display;
|
||
Sys_GetGammaTable(&glw_state.inGameTable);
|
||
}
|
||
|
||
/*****************************************************************************/
|
||
|
||
#pragma mark -
|
||
#pragma mark <20> ATI_fragment_shader
|
||
|
||
static GLuint sGeneratingProgram = 0;
|
||
static int sCurrentPass;
|
||
static char sConstString[4096];
|
||
static char sPassString[2][4096];
|
||
static int sOpUsed;
|
||
static int sConstUsed;
|
||
static int sConst[8];
|
||
static GLfloat sConstVal[8][4];
|
||
|
||
static void _endPass (void) {
|
||
if (!sOpUsed) return;
|
||
sOpUsed = 0;
|
||
sCurrentPass ++;
|
||
}
|
||
|
||
GLuint glGenFragmentShadersATI (GLuint ID) {
|
||
qglGenProgramsARB(1, &ID);
|
||
return ID;
|
||
}
|
||
|
||
void glBindFragmentShaderATI (GLuint ID) {
|
||
qglBindProgramARB(GL_TEXT_FRAGMENT_SHADER_ATI, ID);
|
||
}
|
||
|
||
void glDeleteFragmentShaderATI (GLuint ID) {
|
||
// qglDeleteProgramsARB(1, &ID);
|
||
}
|
||
|
||
void glBeginFragmentShaderATI (void) {
|
||
int i;
|
||
|
||
sConstString[0] = 0;
|
||
for (i = 0; i < 8; i ++)
|
||
sConst[i] = 0;
|
||
|
||
sOpUsed = 0;
|
||
sPassString[0][0] = 0;
|
||
sPassString[1][0] = 0;
|
||
|
||
sCurrentPass = 0;
|
||
sGeneratingProgram = 1;
|
||
}
|
||
|
||
void glEndFragmentShaderATI (void) {
|
||
GLint errPos;
|
||
int i;
|
||
char fragString[4096];
|
||
|
||
sGeneratingProgram = 0;
|
||
|
||
// header
|
||
strcpy(fragString, "!!ATIfs1.0\n");
|
||
|
||
// constants
|
||
if (sConstString[0] || sConstUsed) {
|
||
strcat (fragString, "StartConstants;\n");
|
||
if (sConstUsed) {
|
||
for (i = 0; i < 8; i ++) {
|
||
if (sConst[i] == 1) {
|
||
char str[128];
|
||
sprintf (str, " CONSTANT c%d = program.env[%d];\n", i, i);
|
||
strcat (fragString, str);
|
||
}
|
||
}
|
||
}
|
||
if (sConstString[0]) {
|
||
strcat (fragString, sConstString);
|
||
}
|
||
strcat (fragString, "EndConstants;\n\n");
|
||
}
|
||
|
||
if (sCurrentPass == 0) {
|
||
strcat(fragString, "StartOutputPass;\n");
|
||
strcat(fragString, sPassString[0]);
|
||
strcat(fragString, "EndPass;\n");
|
||
} else {
|
||
strcat(fragString, "StartPrelimPass;\n");
|
||
strcat(fragString, sPassString[0]);
|
||
strcat(fragString, "EndPass;\n\n");
|
||
|
||
strcat(fragString, "StartOutputPass;\n");
|
||
strcat(fragString, sPassString[1]);
|
||
strcat(fragString, "EndPass;\n");
|
||
}
|
||
|
||
qglProgramStringARB(GL_TEXT_FRAGMENT_SHADER_ATI, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(fragString), fragString);
|
||
qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
|
||
if(errPos != -1) {
|
||
const GLubyte *errString = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
|
||
common->Warning("WARNING: glError at %d:%s when compiling atiFragmentShader %s", errPos, errString, fragString);
|
||
}
|
||
}
|
||
|
||
|
||
void glSetFragmentShaderConstantATI (GLuint num, const GLfloat *val) {
|
||
int constNum = num-GL_CON_0_ATI;
|
||
if (sGeneratingProgram) {
|
||
char str[128];
|
||
sprintf (str, " CONSTANT c%d = { %f, %f, %f, %f };\n", constNum, val[0], val[1], val[2], val[3]);
|
||
strcat (sConstString, str);
|
||
sConst[constNum] = 2;
|
||
}
|
||
else {
|
||
// According to Duane, frequent setting of fragment shader constants, even if they contain
|
||
// the same value, will cause a performance hit.
|
||
// According to Chris Bentley at ATI, this performance hit appears if you are using
|
||
// many different fragment shaders in each scene.
|
||
// So, we cache those values and only set the constants if they are different.
|
||
if (memcmp (val, sConstVal[constNum], sizeof(GLfloat)*8*4) != 0)
|
||
{
|
||
qglProgramEnvParameter4fvARB (GL_TEXT_FRAGMENT_SHADER_ATI, num-GL_CON_0_ATI, val);
|
||
memcpy (sConstVal[constNum], val, sizeof(GLfloat)*8*4);
|
||
}
|
||
}
|
||
}
|
||
|
||
char *makeArgStr(GLuint arg) {
|
||
// Since we return "str", it needs to be static to ensure that it retains
|
||
// its value outside this routine.
|
||
static char str[128];
|
||
|
||
strcpy (str, "");
|
||
|
||
if ( arg >= GL_REG_0_ATI && arg <= GL_REG_5_ATI ) {
|
||
sprintf(str, "r%d", arg - GL_REG_0_ATI);
|
||
} else if(arg >= GL_CON_0_ATI && arg <= GL_CON_7_ATI) {
|
||
if(!sConst[arg - GL_CON_0_ATI]) {
|
||
sConstUsed = 1;
|
||
sConst[arg - GL_CON_0_ATI] = 1;
|
||
}
|
||
sprintf(str, "c%d", arg - GL_CON_0_ATI);
|
||
} else if( arg >= GL_TEXTURE0_ARB && arg <= GL_TEXTURE31_ARB ) {
|
||
sprintf(str, "t%d", arg - GL_TEXTURE0_ARB);
|
||
} else if( arg == GL_PRIMARY_COLOR_ARB ) {
|
||
strcpy(str, "color0");
|
||
} else if(arg == GL_SECONDARY_INTERPOLATOR_ATI) {
|
||
strcpy(str, "color1");
|
||
} else if (arg == GL_ZERO) {
|
||
strcpy(str, "0");
|
||
} else if (arg == GL_ONE) {
|
||
strcpy(str, "1");
|
||
} else {
|
||
common->Warning("makeArgStr: bad arg value\n");
|
||
}
|
||
return str;
|
||
}
|
||
|
||
void glPassTexCoordATI (GLuint dst, GLuint coord, GLenum swizzle) {
|
||
char str[128] = "\0";
|
||
_endPass();
|
||
|
||
switch(swizzle) {
|
||
case GL_SWIZZLE_STR_ATI:
|
||
sprintf(str, " PassTexCoord r%d, %s.str;\n", dst - GL_REG_0_ATI, makeArgStr(coord));
|
||
break;
|
||
case GL_SWIZZLE_STQ_ATI:
|
||
sprintf(str, " PassTexCoord r%d, %s.stq;\n", dst - GL_REG_0_ATI, makeArgStr(coord));
|
||
break;
|
||
case GL_SWIZZLE_STR_DR_ATI:
|
||
sprintf(str, " PassTexCoord r%d, %s.str_dr;\n", dst - GL_REG_0_ATI, makeArgStr(coord));
|
||
break;
|
||
case GL_SWIZZLE_STQ_DQ_ATI:
|
||
sprintf(str, " PassTexCoord r%d, %s.stq_dq;\n", dst - GL_REG_0_ATI, makeArgStr(coord));
|
||
break;
|
||
default:
|
||
common->Warning("glPassTexCoordATI invalid swizzle;");
|
||
break;
|
||
}
|
||
strcat(sPassString[sCurrentPass], str);
|
||
}
|
||
|
||
void glSampleMapATI (GLuint dst, GLuint interp, GLenum swizzle) {
|
||
char str[128] = "\0";
|
||
_endPass();
|
||
|
||
switch(swizzle) {
|
||
case GL_SWIZZLE_STR_ATI:
|
||
sprintf(str, " SampleMap r%d, %s.str;\n", dst - GL_REG_0_ATI, makeArgStr(interp));
|
||
break;
|
||
case GL_SWIZZLE_STQ_ATI:
|
||
sprintf(str, " SampleMap r%d, %s.stq;\n", dst - GL_REG_0_ATI, makeArgStr(interp));
|
||
break;
|
||
case GL_SWIZZLE_STR_DR_ATI:
|
||
sprintf(str, " SampleMap r%d, %s.str_dr;\n", dst - GL_REG_0_ATI, makeArgStr(interp));
|
||
break;
|
||
case GL_SWIZZLE_STQ_DQ_ATI:
|
||
sprintf(str, " SampleMap r%d, %s.stq_dq;\n", dst - GL_REG_0_ATI, makeArgStr(interp));
|
||
break;
|
||
default:
|
||
common->Warning("glSampleMapATI invalid swizzle;");
|
||
break;
|
||
}
|
||
strcat(sPassString[sCurrentPass], str);
|
||
}
|
||
|
||
char *makeMaskStr(GLuint mask) {
|
||
// Since we return "str", it needs to be static to ensure that it retains
|
||
// its value outside this routine.
|
||
static char str[128];
|
||
|
||
strcpy (str, "");
|
||
|
||
switch (mask) {
|
||
case GL_NONE:
|
||
str[0] = '\0';
|
||
break;
|
||
case GL_RGBA:
|
||
strcpy(str, ".rgba");
|
||
break;
|
||
case GL_RGB:
|
||
strcpy(str, ".rgb");
|
||
break;
|
||
case GL_RED:
|
||
strcpy(str, ".r");
|
||
break;
|
||
case GL_GREEN:
|
||
strcpy(str, ".g");
|
||
break;
|
||
case GL_BLUE:
|
||
strcpy(str, ".b");
|
||
break;
|
||
case GL_ALPHA:
|
||
strcpy(str, ".a");
|
||
break;
|
||
default:
|
||
strcpy(str, ".");
|
||
if( mask & GL_RED_BIT_ATI )
|
||
strcat(str, "r");
|
||
if( mask & GL_GREEN_BIT_ATI )
|
||
strcat(str, "g");
|
||
if( mask & GL_BLUE_BIT_ATI )
|
||
strcat(str, "b");
|
||
break;
|
||
}
|
||
|
||
return str;
|
||
}
|
||
|
||
char *makeDstModStr(GLuint mod) {
|
||
// Since we return "str", it needs to be static to ensure that it retains
|
||
// its value outside this routine.
|
||
static char str[128];
|
||
|
||
strcpy (str, "");
|
||
|
||
if( mod == GL_NONE) {
|
||
str[0] = '\0';
|
||
return str;
|
||
}
|
||
if( mod & GL_2X_BIT_ATI) {
|
||
strcat(str, ".2x");
|
||
}
|
||
|
||
if( mod & GL_4X_BIT_ATI) {
|
||
strcat(str, ".4x");
|
||
}
|
||
|
||
if( mod & GL_8X_BIT_ATI) {
|
||
strcat(str, ".8x");
|
||
}
|
||
|
||
if( mod & GL_SATURATE_BIT_ATI) {
|
||
strcat(str, ".sat");
|
||
}
|
||
|
||
if( mod & GL_HALF_BIT_ATI) {
|
||
strcat(str, ".half");
|
||
}
|
||
|
||
if( mod & GL_QUARTER_BIT_ATI) {
|
||
strcat(str, ".quarter");
|
||
}
|
||
|
||
if( mod & GL_EIGHTH_BIT_ATI) {
|
||
strcat(str, ".eighth");
|
||
}
|
||
|
||
return str;
|
||
}
|
||
|
||
char *makeArgModStr(GLuint mod) {
|
||
// Since we return "str", it needs to be static to ensure that it retains
|
||
// its value outside this routine.
|
||
static char str[128];
|
||
|
||
strcpy (str, "");
|
||
|
||
if( mod == GL_NONE) {
|
||
str[0] = '\0';
|
||
return str;
|
||
}
|
||
if( mod & GL_NEGATE_BIT_ATI) {
|
||
strcat(str, ".neg");
|
||
}
|
||
|
||
if( mod & GL_2X_BIT_ATI) {
|
||
strcat(str, ".2x");
|
||
}
|
||
|
||
if( mod & GL_BIAS_BIT_ATI) {
|
||
strcat(str, ".bias");
|
||
}
|
||
|
||
if( mod & GL_COMP_BIT_ATI) {
|
||
strcat(str, ".comp");
|
||
}
|
||
|
||
return str;
|
||
}
|
||
|
||
void glColorFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod) {
|
||
char str[128] = "\0";
|
||
|
||
sOpUsed = 1;
|
||
|
||
switch(op) {
|
||
// Unary operators
|
||
case GL_MOV_ATI:
|
||
sprintf(str, " MOV r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
default:
|
||
common->Warning("glColorFragmentOp1ATI invalid op;\n");
|
||
break;
|
||
}
|
||
if(dstMask != GL_NONE) {
|
||
strcat(str, makeMaskStr(dstMask));
|
||
}
|
||
else {
|
||
strcat(str, ".rgb" );
|
||
}
|
||
|
||
if(dstMod != GL_NONE) {
|
||
strcat(str, makeDstModStr(dstMod));
|
||
}
|
||
strcat(str, ", ");
|
||
|
||
strcat(str, makeArgStr(arg1));
|
||
if(arg1Rep != GL_NONE) {
|
||
strcat(str, makeMaskStr(arg1Rep));
|
||
}
|
||
if(arg1Mod != GL_NONE) {
|
||
strcat(str, makeArgModStr(arg1Mod));
|
||
}
|
||
strcat(str, ";\n");
|
||
|
||
strcat(sPassString[sCurrentPass], str);
|
||
}
|
||
|
||
void glColorFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod) {
|
||
char str[128] = "\0";
|
||
|
||
if (!sOpUsed)
|
||
sprintf(str,"\n");
|
||
sOpUsed = 1;
|
||
|
||
switch(op) {
|
||
// Unary operators - fall back to Op1 routine.
|
||
case GL_MOV_ATI:
|
||
glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
|
||
return;
|
||
|
||
// Binary operators
|
||
case GL_ADD_ATI:
|
||
sprintf(str, " ADD r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_MUL_ATI:
|
||
sprintf(str, " MUL r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_SUB_ATI:
|
||
sprintf(str, " SUB r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_DOT3_ATI:
|
||
sprintf(str, " DOT3 r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_DOT4_ATI:
|
||
sprintf(str, " DOT4 r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
default:
|
||
common->Warning("glColorFragmentOp2ATI invalid op;");
|
||
break;
|
||
}
|
||
if(dstMask != GL_NONE) {
|
||
strcat(str, makeMaskStr(dstMask));
|
||
}
|
||
else {
|
||
strcat(str, ".rgb" );
|
||
}
|
||
if(dstMod != GL_NONE) {
|
||
strcat(str, makeDstModStr(dstMod));
|
||
}
|
||
strcat(str, ", ");
|
||
|
||
strcat(str, makeArgStr(arg1));
|
||
// if(arg1Rep != GL_NONE)
|
||
strcat(str, makeMaskStr(arg1Rep));
|
||
if(arg1Mod != GL_NONE) {
|
||
strcat(str, makeArgModStr(arg1Mod));
|
||
}
|
||
strcat(str, ", ");
|
||
|
||
strcat(str, makeArgStr(arg2));
|
||
// if(arg2Rep != GL_NONE)
|
||
strcat(str, makeMaskStr(arg2Rep));
|
||
if(arg2Mod != GL_NONE) {
|
||
strcat(str, makeArgModStr(arg2Mod));
|
||
}
|
||
strcat(str, ";\n");
|
||
|
||
strcat(sPassString[sCurrentPass], str);
|
||
}
|
||
|
||
void glColorFragmentOp3ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod) {
|
||
char str[128] = "\0";
|
||
|
||
sOpUsed = 1;
|
||
|
||
switch(op) {
|
||
// Unary operators - fall back to Op1 routine.
|
||
case GL_MOV_ATI:
|
||
glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
|
||
return;
|
||
|
||
// Binary operators - fall back to Op2 routine.
|
||
case GL_ADD_ATI:
|
||
case GL_MUL_ATI:
|
||
case GL_SUB_ATI:
|
||
case GL_DOT3_ATI:
|
||
case GL_DOT4_ATI:
|
||
glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
|
||
break;
|
||
|
||
// Ternary operators
|
||
case GL_MAD_ATI:
|
||
sprintf(str, " MAD r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_LERP_ATI:
|
||
sprintf(str, " LERP r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_CND_ATI:
|
||
sprintf(str, " CND r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_CND0_ATI:
|
||
sprintf(str, " CND0 r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
case GL_DOT2_ADD_ATI:
|
||
sprintf(str, " DOT2ADD r%d", dst - GL_REG_0_ATI);
|
||
break;
|
||
default:
|
||
common->Warning("glColorFragmentOp3ATI invalid op;");
|
||
break;
|
||
}
|
||
|
||
if(dstMask != GL_NONE) {
|
||
strcat(str, makeMaskStr(dstMask));
|
||
}
|
||
else {
|
||
strcat(str, ".rgb" );
|
||
}
|
||
if(dstMod != GL_NONE) {
|
||
strcat(str, makeDstModStr(dstMod));
|
||
}
|
||
strcat(str, ", ");
|
||
|
||
strcat(str, makeArgStr(arg1));
|
||
if(arg1Rep != GL_NONE) {
|
||
strcat(str, makeMaskStr(arg1Rep));
|
||
}
|
||
if(arg1Mod != GL_NONE) {
|
||
strcat(str, makeArgModStr(arg1Mod));
|
||
}
|
||
strcat(str, ", ");
|
||
|
||
strcat(str, makeArgStr(arg2));
|
||
if(arg2Rep != GL_NONE) {
|
||
strcat(str, makeMaskStr(arg2Rep));
|
||
}
|
||
if(arg2Mod != GL_NONE) {
|
||
strcat(str, makeArgModStr(arg2Mod));
|
||
}
|
||
strcat(str, ", ");
|
||
|
||
strcat(str, makeArgStr(arg3));
|
||
if(arg3Rep != GL_NONE) {
|
||
strcat(str, makeMaskStr(arg3Rep));
|
||
}
|
||
if(arg3Mod != GL_NONE) {
|
||
strcat(str, makeArgModStr(arg3Mod));
|
||
}
|
||
strcat(str, ";\n");
|
||
|
||
strcat(sPassString[sCurrentPass], str);
|
||
}
|
||
|
||
void glAlphaFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod) {
|
||
glColorFragmentOp1ATI ( op, dst, GL_ALPHA, dstMod, arg1, arg1Rep, arg1Mod);
|
||
}
|
||
|
||
void glAlphaFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod) {
|
||
glColorFragmentOp2ATI ( op, dst, GL_ALPHA, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
|
||
}
|
||
|
||
void glAlphaFragmentOp3ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod) {
|
||
glColorFragmentOp3ATI ( op, dst, GL_ALPHA, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
|
||
}
|
||
#pragma mark -
|
||
|
||
GLExtension_t GLimp_ExtensionPointer(const char *name) {
|
||
NSSymbol symbol;
|
||
char *symbolName;
|
||
|
||
// special case for ATI_fragment_shader calls to map to ATI_text_fragment_shader routines
|
||
if (!strcmp(name, "glGenFragmentShadersATI")) {
|
||
return (GLExtension_t)glGenFragmentShadersATI;
|
||
}
|
||
if (!strcmp(name, "glBindFragmentShaderATI")) {
|
||
return (GLExtension_t)glBindFragmentShaderATI;
|
||
}
|
||
if (!strcmp(name, "glDeleteFragmentShaderATI")) {
|
||
return (GLExtension_t)glDeleteFragmentShaderATI;
|
||
}
|
||
if (!strcmp(name, "glBeginFragmentShaderATI")) {
|
||
return (GLExtension_t)glBeginFragmentShaderATI;
|
||
}
|
||
if (!strcmp(name, "glEndFragmentShaderATI")) {
|
||
return (GLExtension_t)glEndFragmentShaderATI;
|
||
}
|
||
if (!strcmp(name, "glPassTexCoordATI")) {
|
||
return (GLExtension_t)glPassTexCoordATI;
|
||
}
|
||
if (!strcmp(name, "glSampleMapATI")) {
|
||
return (GLExtension_t)glSampleMapATI;
|
||
}
|
||
if (!strcmp(name, "glColorFragmentOp1ATI")) {
|
||
return (GLExtension_t)glColorFragmentOp1ATI;
|
||
}
|
||
if (!strcmp(name, "glColorFragmentOp2ATI")) {
|
||
return (GLExtension_t)glColorFragmentOp2ATI;
|
||
}
|
||
if (!strcmp(name, "glColorFragmentOp3ATI")) {
|
||
return (GLExtension_t)glColorFragmentOp3ATI;
|
||
}
|
||
if (!strcmp(name, "glAlphaFragmentOp1ATI")) {
|
||
return (GLExtension_t)glAlphaFragmentOp1ATI;
|
||
}
|
||
if (!strcmp(name, "glAlphaFragmentOp2ATI")) {
|
||
return (GLExtension_t)glAlphaFragmentOp2ATI;
|
||
}
|
||
if (!strcmp(name, "glAlphaFragmentOp3ATI")) {
|
||
return (GLExtension_t)glAlphaFragmentOp3ATI;
|
||
}
|
||
if (!strcmp(name, "glSetFragmentShaderConstantATI")) {
|
||
return (GLExtension_t)glSetFragmentShaderConstantATI;
|
||
}
|
||
|
||
// Prepend a '_' for the Unix C symbol mangling convention
|
||
symbolName = (char *)alloca(strlen(name) + 2);
|
||
strcpy(symbolName + 1, name);
|
||
symbolName[0] = '_';
|
||
|
||
if ( !NSIsSymbolNameDefined( symbolName ) ) {
|
||
return NULL;
|
||
}
|
||
|
||
symbol = NSLookupAndBindSymbol(symbolName);
|
||
if ( !symbol ) {
|
||
// shouldn't happen ...
|
||
return NULL;
|
||
}
|
||
|
||
return (GLExtension_t)(NSAddressOfSymbol(symbol));
|
||
}
|
||
|
||
void * wglGetProcAddress(const char *name) {
|
||
return (void *)GLimp_ExtensionPointer( name );
|
||
}
|
||
|
||
|
||
/*
|
||
** GLW_InitExtensions
|
||
*/
|
||
void GLW_InitExtensions( void ) { }
|
||
|
||
#define MAX_RENDERER_INFO_COUNT 128
|
||
|
||
// Returns zero if there are no hardware renderers. Otherwise, returns the max memory across all renderers (on the presumption that the screen that we'll use has the most memory).
|
||
unsigned long Sys_QueryVideoMemory() {
|
||
CGLError err;
|
||
CGLRendererInfoObj rendererInfo, rendererInfos[MAX_RENDERER_INFO_COUNT];
|
||
long rendererInfoIndex, rendererInfoCount = MAX_RENDERER_INFO_COUNT;
|
||
long rendererIndex, rendererCount;
|
||
long maxVRAM = 0, vram = 0;
|
||
long accelerated;
|
||
long rendererID;
|
||
long totalRenderers = 0;
|
||
|
||
err = CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(Sys_DisplayToUse()), rendererInfos, &rendererInfoCount);
|
||
if (err) {
|
||
common->Printf("CGLQueryRendererInfo -> %d\n", err);
|
||
return vram;
|
||
}
|
||
|
||
//common->Printf("rendererInfoCount = %d\n", rendererInfoCount);
|
||
for (rendererInfoIndex = 0; rendererInfoIndex < rendererInfoCount && totalRenderers < rendererInfoCount; rendererInfoIndex++) {
|
||
rendererInfo = rendererInfos[rendererInfoIndex];
|
||
//common->Printf("rendererInfo: 0x%08x\n", rendererInfo);
|
||
|
||
|
||
err = CGLDescribeRenderer(rendererInfo, 0, kCGLRPRendererCount, &rendererCount);
|
||
if (err) {
|
||
common->Printf("CGLDescribeRenderer(kCGLRPRendererID) -> %d\n", err);
|
||
continue;
|
||
}
|
||
//common->Printf(" rendererCount: %d\n", rendererCount);
|
||
|
||
for (rendererIndex = 0; rendererIndex < rendererCount; rendererIndex++) {
|
||
totalRenderers++;
|
||
//common->Printf(" rendererIndex: %d\n", rendererIndex);
|
||
|
||
rendererID = 0xffffffff;
|
||
err = CGLDescribeRenderer(rendererInfo, rendererIndex, kCGLRPRendererID, &rendererID);
|
||
if (err) {
|
||
common->Printf("CGLDescribeRenderer(kCGLRPRendererID) -> %d\n", err);
|
||
continue;
|
||
}
|
||
//common->Printf(" rendererID: 0x%08x\n", rendererID);
|
||
|
||
accelerated = 0;
|
||
err = CGLDescribeRenderer(rendererInfo, rendererIndex, kCGLRPAccelerated, &accelerated);
|
||
if (err) {
|
||
common->Printf("CGLDescribeRenderer(kCGLRPAccelerated) -> %d\n", err);
|
||
continue;
|
||
}
|
||
//common->Printf(" accelerated: %d\n", accelerated);
|
||
if (!accelerated)
|
||
continue;
|
||
|
||
vram = 0;
|
||
err = CGLDescribeRenderer(rendererInfo, rendererIndex, kCGLRPVideoMemory, &vram);
|
||
if (err) {
|
||
common->Printf("CGLDescribeRenderer -> %d\n", err);
|
||
continue;
|
||
}
|
||
//common->Printf(" vram: 0x%08x\n", vram);
|
||
|
||
// presumably we'll be running on the best card, so we'll take the max of the vrams
|
||
if (vram > maxVRAM)
|
||
maxVRAM = vram;
|
||
}
|
||
|
||
#if 0
|
||
err = CGLDestroyRendererInfo(rendererInfo);
|
||
if (err) {
|
||
common->Printf("CGLDestroyRendererInfo -> %d\n", err);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
return maxVRAM;
|
||
}
|
||
|
||
|
||
// We will set the Sys_IsHidden global to cause input to be handle differently (we'll just let NSApp handle events in this case). We also will unbind the GL context and restore the video mode.
|
||
bool Sys_Hide() {
|
||
if ( isHidden ) {
|
||
// Eh?
|
||
return false;
|
||
}
|
||
|
||
if ( !r_fullscreen.GetBool() ) {
|
||
// We only support hiding in fullscreen mode right now
|
||
return false;
|
||
}
|
||
|
||
isHidden = true;
|
||
|
||
// Don't need to store the current gamma since we always keep it around in glw_state.inGameTable.
|
||
|
||
Sys_FadeScreen(Sys_DisplayToUse());
|
||
|
||
// Disassociate the GL context from the screen
|
||
// Have to call both to actually deallocate kernel resources and free the NSSurface
|
||
CGLClearDrawable(OSX_GetCGLContext());
|
||
[OSX_GetNSGLContext() clearDrawable];
|
||
|
||
// Restore the original video mode
|
||
_GLimp_RestoreOriginalVideoSettings();
|
||
|
||
// Restore the original gamma if needed.
|
||
// if (glConfig.deviceSupportsGamma) {
|
||
// CGDisplayRestoreColorSyncSettings();
|
||
// }
|
||
|
||
// Release the screen(s)
|
||
ReleaseAllDisplays();
|
||
|
||
Sys_UnfadeScreens();
|
||
|
||
// Shut down the input system so the mouse and keyboard settings are restore to normal
|
||
Sys_ShutdownInput();
|
||
|
||
// Hide the application so that when the user clicks on our app icon, we'll get an unhide notification
|
||
[NSApp hide: nil];
|
||
|
||
return true;
|
||
}
|
||
|
||
CGDisplayErr Sys_CaptureActiveDisplays(void) {
|
||
CGDisplayErr err;
|
||
CGDisplayCount displayIndex;
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
const glwgamma_t *table;
|
||
table = &glw_state.originalDisplayGammaTables[displayIndex];
|
||
err = CGDisplayCapture(table->display);
|
||
if (err != CGDisplayNoErr)
|
||
return err;
|
||
}
|
||
return CGDisplayNoErr;
|
||
}
|
||
|
||
bool Sys_Unhide() {
|
||
CGDisplayErr err;
|
||
CGLError glErr;
|
||
|
||
if ( !isHidden) {
|
||
// Eh?
|
||
return false;
|
||
}
|
||
|
||
Sys_FadeScreens();
|
||
|
||
// Capture the screen(s)
|
||
err = Sys_CaptureActiveDisplays();
|
||
if (err != CGDisplayNoErr) {
|
||
Sys_UnfadeScreens();
|
||
common->Printf( "Unhide failed -- cannot capture the display again.\n" );
|
||
return false;
|
||
}
|
||
|
||
// Restore the game mode
|
||
err = CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.gameMode);
|
||
if ( err != CGDisplayNoErr ) {
|
||
ReleaseAllDisplays();
|
||
Sys_UnfadeScreens();
|
||
common->Printf( "Unhide failed -- Unable to set display mode\n" );
|
||
return false;
|
||
}
|
||
|
||
// Reassociate the GL context and the screen
|
||
glErr = CGLSetFullScreen(OSX_GetCGLContext());
|
||
if (glErr) {
|
||
ReleaseAllDisplays();
|
||
Sys_UnfadeScreens();
|
||
common->Printf( "Unhide failed: CGLSetFullScreen -> %d (%s)\n", err, CGLErrorString(glErr));
|
||
return false;
|
||
}
|
||
|
||
// Restore the current context
|
||
[OSX_GetNSGLContext() makeCurrentContext];
|
||
|
||
// Restore the gamma that the game had set
|
||
Sys_UnfadeScreen(Sys_DisplayToUse(), &glw_state.inGameTable);
|
||
|
||
// Restore the input system (last so if something goes wrong we don't eat the mouse)
|
||
Sys_InitInput();
|
||
|
||
isHidden = false;
|
||
return true;
|
||
}
|
||
|
||
bool GLimp_SpawnRenderThread( void (*function)( void ) ) {
|
||
return false;
|
||
}
|
||
|
||
void *GLimp_RendererSleep(void) {
|
||
return NULL;
|
||
}
|
||
|
||
void GLimp_FrontEndSleep(void) { }
|
||
|
||
void GLimp_WakeRenderer( void *data ) { }
|
||
|
||
void *GLimp_BackEndSleep( void ) {
|
||
return NULL;
|
||
}
|
||
|
||
void GLimp_WakeBackEnd( void *data ) {
|
||
}
|
||
|
||
// enable / disable context is just for the r_skipRenderContext debug option
|
||
void GLimp_DeactivateContext( void ) {
|
||
[NSOpenGLContext clearCurrentContext];
|
||
}
|
||
|
||
void GLimp_ActivateContext( void ) {
|
||
[OSX_GetNSGLContext() makeCurrentContext];
|
||
}
|
||
|
||
void GLimp_EnableLogging(bool stat) { }
|
||
|
||
NSDictionary *Sys_GetMatchingDisplayMode( glimpParms_t parms ) {
|
||
NSArray *displayModes;
|
||
NSDictionary *mode;
|
||
unsigned int modeIndex, modeCount, bestModeIndex;
|
||
int verbose;
|
||
// cvar_t *cMinFreq, *cMaxFreq;
|
||
int minFreq, maxFreq;
|
||
unsigned int colorDepth;
|
||
|
||
verbose = 0;
|
||
|
||
colorDepth = 32;
|
||
|
||
minFreq = r_minDisplayRefresh.GetInteger();
|
||
maxFreq = r_maxDisplayRefresh.GetInteger();
|
||
if ( minFreq > maxFreq ) {
|
||
common->Error( "r_minDisplayRefresh must be less than or equal to r_maxDisplayRefresh" );
|
||
}
|
||
|
||
displayModes = (NSArray *)CGDisplayAvailableModes(glw_state.display);
|
||
if (!displayModes) {
|
||
common->Error( "CGDisplayAvailableModes returned NULL -- 0x%0x is an invalid display", glw_state.display);
|
||
}
|
||
|
||
modeCount = [displayModes count];
|
||
if (verbose) {
|
||
common->Printf( "%d modes avaliable\n", modeCount);
|
||
common->Printf( "Current mode is %s\n", [[(id)CGDisplayCurrentMode(glw_state.display) description] cString]);
|
||
}
|
||
|
||
// Default to the current desktop mode
|
||
bestModeIndex = 0xFFFFFFFF;
|
||
|
||
for ( modeIndex = 0; modeIndex < modeCount; ++modeIndex ) {
|
||
id object;
|
||
int refresh;
|
||
|
||
mode = [displayModes objectAtIndex: modeIndex];
|
||
if (verbose) {
|
||
common->Printf( " mode %d -- %s\n", modeIndex, [[mode description] cString]);
|
||
}
|
||
|
||
// Make sure we get the right size
|
||
if ([[mode objectForKey: (id)kCGDisplayWidth] intValue] != parms.width ||
|
||
[[mode objectForKey: (id)kCGDisplayHeight] intValue] != parms.height) {
|
||
if (verbose)
|
||
common->Printf( " -- bad size\n");
|
||
continue;
|
||
}
|
||
|
||
// Make sure that our frequency restrictions are observed
|
||
refresh = [[mode objectForKey: (id)kCGDisplayRefreshRate] intValue];
|
||
if (minFreq && refresh < minFreq) {
|
||
if (verbose)
|
||
common->Printf( " -- refresh too low\n");
|
||
continue;
|
||
}
|
||
|
||
if (maxFreq && refresh > maxFreq) {
|
||
if (verbose)
|
||
common->Printf( " -- refresh too high\n");
|
||
continue;
|
||
}
|
||
|
||
if ([[mode objectForKey: (id)kCGDisplayBitsPerPixel] intValue] != colorDepth) {
|
||
if (verbose)
|
||
common->Printf( " -- bad depth\n");
|
||
continue;
|
||
}
|
||
|
||
object = [mode objectForKey: (id)kCGDisplayModeIsStretched];
|
||
if ( object ) {
|
||
if ( [object boolValue] != cvarSystem->GetCVarBool( "r_stretched" ) ) {
|
||
if (verbose)
|
||
common->Printf( " -- bad stretch setting\n");
|
||
continue;
|
||
}
|
||
}
|
||
else {
|
||
if ( cvarSystem->GetCVarBool( "r_stretched" ) ) {
|
||
if (verbose)
|
||
common->Printf( " -- stretch requested, stretch property not available\n");
|
||
continue;
|
||
}
|
||
}
|
||
|
||
bestModeIndex = modeIndex;
|
||
if (verbose)
|
||
common->Printf( " -- OK\n", bestModeIndex);
|
||
}
|
||
|
||
if (verbose)
|
||
common->Printf( " bestModeIndex = %d\n", bestModeIndex);
|
||
|
||
if (bestModeIndex == 0xFFFFFFFF) {
|
||
common->Printf( "No suitable display mode available.\n");
|
||
return nil;
|
||
}
|
||
|
||
return [displayModes objectAtIndex: bestModeIndex];
|
||
}
|
||
|
||
|
||
#define MAX_DISPLAYS 128
|
||
|
||
void Sys_GetGammaTable(glwgamma_t *table) {
|
||
CGTableCount tableSize = 512;
|
||
CGDisplayErr err;
|
||
|
||
table->tableSize = tableSize;
|
||
if (table->red)
|
||
free(table->red);
|
||
table->red = (float *)malloc(tableSize * sizeof(*table->red));
|
||
if (table->green)
|
||
free(table->green);
|
||
table->green = (float *)malloc(tableSize * sizeof(*table->green));
|
||
if (table->blue)
|
||
free(table->blue);
|
||
table->blue = (float *)malloc(tableSize * sizeof(*table->blue));
|
||
|
||
// TJW: We _could_ loop here if we get back the same size as our table, increasing the table size.
|
||
err = CGGetDisplayTransferByTable(table->display, tableSize, table->red, table->green, table->blue,
|
||
&table->tableSize);
|
||
if (err != CGDisplayNoErr) {
|
||
common->Printf("GLimp_Init: CGGetDisplayTransferByTable returned %d.\n", err);
|
||
table->tableSize = 0;
|
||
}
|
||
}
|
||
|
||
void Sys_SetGammaTable(glwgamma_t *table) { }
|
||
|
||
void Sys_StoreGammaTables() {
|
||
// Store the original gamma for all monitors so that we can fade and unfade them all
|
||
CGDirectDisplayID displays[MAX_DISPLAYS];
|
||
CGDisplayCount displayIndex;
|
||
CGDisplayErr err;
|
||
|
||
err = CGGetActiveDisplayList(MAX_DISPLAYS, displays, &glw_state.displayCount);
|
||
if (err != CGDisplayNoErr)
|
||
Sys_Error("Cannot get display list -- CGGetActiveDisplayList returned %d.\n", err);
|
||
|
||
glw_state.originalDisplayGammaTables = (glwgamma_t *)calloc(glw_state.displayCount, sizeof(*glw_state.originalDisplayGammaTables));
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
glwgamma_t *table;
|
||
|
||
table = &glw_state.originalDisplayGammaTables[displayIndex];
|
||
table->display = displays[displayIndex];
|
||
Sys_GetGammaTable(table);
|
||
}
|
||
}
|
||
|
||
|
||
// This isn't a mathematically correct fade, but we don't care that much.
|
||
void Sys_SetScreenFade(glwgamma_t *table, float fraction) {
|
||
CGTableCount tableSize;
|
||
CGGammaValue *red, *blue, *green;
|
||
CGTableCount gammaIndex;
|
||
|
||
// if (!glConfig.deviceSupportsGamma)
|
||
// return;
|
||
|
||
if (!(tableSize = table->tableSize))
|
||
// we couldn't get the table for this display for some reason
|
||
return;
|
||
|
||
// common->Printf("0x%08x %f\n", table->display, fraction);
|
||
|
||
red = glw_state.tempTable.red;
|
||
green = glw_state.tempTable.green;
|
||
blue = glw_state.tempTable.blue;
|
||
if (glw_state.tempTable.tableSize < tableSize) {
|
||
glw_state.tempTable.tableSize = tableSize;
|
||
red = (float *)realloc(red, sizeof(*red) * tableSize);
|
||
green = (float *)realloc(green, sizeof(*green) * tableSize);
|
||
blue = (float *)realloc(blue, sizeof(*blue) * tableSize);
|
||
glw_state.tempTable.red = red;
|
||
glw_state.tempTable.green = green;
|
||
glw_state.tempTable.blue = blue;
|
||
}
|
||
|
||
for (gammaIndex = 0; gammaIndex < table->tableSize; gammaIndex++) {
|
||
red[gammaIndex] = table->red[gammaIndex] * fraction;
|
||
blue[gammaIndex] = table->blue[gammaIndex] * fraction;
|
||
green[gammaIndex] = table->green[gammaIndex] * fraction;
|
||
}
|
||
|
||
CGSetDisplayTransferByTable(table->display, table->tableSize, red, green, blue);
|
||
}
|
||
|
||
// Fades all the active displays at the same time.
|
||
|
||
#define FADE_DURATION 0.5
|
||
void Sys_FadeScreens() {
|
||
CGDisplayCount displayIndex;
|
||
int stepIndex;
|
||
glwgamma_t *table;
|
||
NSTimeInterval start, current;
|
||
float time;
|
||
|
||
// if (!glConfig.deviceSupportsGamma)
|
||
// return;
|
||
|
||
common->Printf("Fading all displays\n");
|
||
|
||
start = [NSDate timeIntervalSinceReferenceDate];
|
||
time = 0.0;
|
||
while (time != FADE_DURATION) {
|
||
current = [NSDate timeIntervalSinceReferenceDate];
|
||
time = current - start;
|
||
if (time > FADE_DURATION)
|
||
time = FADE_DURATION;
|
||
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
table = &glw_state.originalDisplayGammaTables[displayIndex];
|
||
Sys_SetScreenFade(table, 1.0 - time / FADE_DURATION);
|
||
}
|
||
}
|
||
}
|
||
|
||
void Sys_FadeScreen(CGDirectDisplayID display) {
|
||
CGDisplayCount displayIndex;
|
||
glwgamma_t *table;
|
||
int stepIndex;
|
||
|
||
common->Printf( "FIXME: Sys_FadeScreen\n" );
|
||
|
||
return;
|
||
|
||
// if (!glConfig.deviceSupportsGamma)
|
||
// return;
|
||
|
||
common->Printf("Fading display 0x%08x\n", display);
|
||
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
if (display == glw_state.originalDisplayGammaTables[displayIndex].display) {
|
||
NSTimeInterval start, current;
|
||
float time;
|
||
|
||
start = [NSDate timeIntervalSinceReferenceDate];
|
||
time = 0.0;
|
||
|
||
table = &glw_state.originalDisplayGammaTables[displayIndex];
|
||
while (time != FADE_DURATION) {
|
||
current = [NSDate timeIntervalSinceReferenceDate];
|
||
time = current - start;
|
||
if (time > FADE_DURATION)
|
||
time = FADE_DURATION;
|
||
|
||
Sys_SetScreenFade(table, 1.0 - time / FADE_DURATION);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
common->Printf("Unable to find display to fade it\n");
|
||
}
|
||
|
||
void Sys_UnfadeScreens() {
|
||
CGDisplayCount displayIndex;
|
||
int stepIndex;
|
||
glwgamma_t *table;
|
||
NSTimeInterval start, current;
|
||
float time;
|
||
|
||
common->Printf( "FIXME: Sys_UnfadeScreens\n" );
|
||
|
||
return;
|
||
|
||
// if (!glConfig.deviceSupportsGamma)
|
||
// return;
|
||
|
||
common->Printf("Unfading all displays\n");
|
||
|
||
start = [NSDate timeIntervalSinceReferenceDate];
|
||
time = 0.0;
|
||
while (time != FADE_DURATION) {
|
||
current = [NSDate timeIntervalSinceReferenceDate];
|
||
time = current - start;
|
||
if (time > FADE_DURATION)
|
||
time = FADE_DURATION;
|
||
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
table = &glw_state.originalDisplayGammaTables[displayIndex];
|
||
Sys_SetScreenFade(table, time / FADE_DURATION);
|
||
}
|
||
}
|
||
}
|
||
|
||
void Sys_UnfadeScreen(CGDirectDisplayID display, glwgamma_t *table) {
|
||
CGDisplayCount displayIndex;
|
||
int stepIndex;
|
||
|
||
common->Printf( "FIXME: Sys_UnfadeScreen\n" );
|
||
|
||
return;
|
||
// if (!glConfig.deviceSupportsGamma)
|
||
// return;
|
||
|
||
common->Printf("Unfading display 0x%08x\n", display);
|
||
|
||
if (table) {
|
||
CGTableCount i;
|
||
|
||
common->Printf("Given table:\n");
|
||
for (i = 0; i < table->tableSize; i++) {
|
||
common->Printf(" %f %f %f\n", table->red[i], table->blue[i], table->green[i]);
|
||
}
|
||
}
|
||
|
||
// Search for the original gamma table for the display
|
||
if (!table) {
|
||
for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
|
||
if (display == glw_state.originalDisplayGammaTables[displayIndex].display) {
|
||
table = &glw_state.originalDisplayGammaTables[displayIndex];
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (table) {
|
||
NSTimeInterval start, current;
|
||
float time;
|
||
|
||
start = [NSDate timeIntervalSinceReferenceDate];
|
||
time = 0.0;
|
||
|
||
while (time != FADE_DURATION) {
|
||
current = [NSDate timeIntervalSinceReferenceDate];
|
||
time = current - start;
|
||
if (time > FADE_DURATION)
|
||
time = FADE_DURATION;
|
||
Sys_SetScreenFade(table, time / FADE_DURATION);
|
||
}
|
||
return;
|
||
}
|
||
|
||
common->Printf("Unable to find display to unfade it\n");
|
||
}
|
||
|
||
#define MAX_DISPLAYS 128
|
||
|
||
CGDirectDisplayID Sys_DisplayToUse(void) {
|
||
static bool gotDisplay = NO;
|
||
static CGDirectDisplayID displayToUse;
|
||
|
||
CGDisplayErr err;
|
||
CGDirectDisplayID displays[MAX_DISPLAYS];
|
||
CGDisplayCount displayCount;
|
||
int displayIndex;
|
||
|
||
if ( gotDisplay ) {
|
||
return displayToUse;
|
||
}
|
||
gotDisplay = YES;
|
||
|
||
err = CGGetActiveDisplayList( MAX_DISPLAYS, displays, &displayCount );
|
||
if ( err != CGDisplayNoErr ) {
|
||
common->Error("Cannot get display list -- CGGetActiveDisplayList returned %d.\n", err );
|
||
}
|
||
|
||
// -1, the default, means to use the main screen
|
||
displayIndex = r_screen.GetInteger();
|
||
|
||
if ( displayIndex < 0 || displayIndex >= displayCount ) {
|
||
// This is documented (in CGDirectDisplay.h) to be the main display. We want to
|
||
// return this instead of kCGDirectMainDisplay since this will allow us to compare
|
||
// display IDs.
|
||
displayToUse = displays[ 0 ];
|
||
} else {
|
||
displayToUse = displays[ displayIndex ];
|
||
}
|
||
|
||
return displayToUse;
|
||
}
|
||
|
||
/*
|
||
===================
|
||
GLimp_SetScreenParms
|
||
===================
|
||
*/
|
||
bool GLimp_SetScreenParms( glimpParms_t parms ) {
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
===================
|
||
Sys_GrabMouseCursor
|
||
===================
|
||
*/
|
||
void Sys_GrabMouseCursor( bool grabIt ) { }
|
||
|