newlines fixed

git-svn-id: svn://svn.icculus.org/quake3/trunk@6 edf5b092-35ff-0310-97b2-ce42778d08ea

1 files changed, 373 insertions, 373 deletions

diff --git a/code/macosx/macosx_display.m b/code/macosx/macosx_display.m
index b6f687c..52235a5 100755
--- a/code/macosx/macosx_display.m
+++ b/code/macosx/macosx_display.m
@@ -1,373 +1,373 @@
-/*

-===========================================================================

-Copyright (C) 1999-2005 Id Software, Inc.

-

-This file is part of Quake III Arena source code.

-

-Quake III Arena 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 2 of the License,

-or (at your option) any later version.

-

-Quake III Arena 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 Foobar; if not, write to the Free Software

-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

-===========================================================================

-*/

-

-#import "macosx_display.h"

-

-#include "tr_local.h"

-#import "macosx_local.h"

-

-#import <Foundation/Foundation.h>

-#import <IOKit/graphics/IOGraphicsTypes.h>  // for interpreting the kCGDisplayIOFlags element of the display mode

-

-

-NSDictionary *Sys_GetMatchingDisplayMode(qboolean allowStretchedModes)

-{

-    NSArray *displayModes;

-    NSDictionary *mode;

-    unsigned int modeIndex, modeCount, bestModeIndex;

-    int verbose;

-    cvar_t *cMinFreq, *cMaxFreq;

-    int minFreq, maxFreq;

-    unsigned int colorDepth;

-    

-    verbose = r_verbose->integer;

-

-    colorDepth = r_colorbits->integer;

-    if (colorDepth < 16 || !r_fullscreen->integer)

-        colorDepth = [[glw_state.desktopMode objectForKey: (id)kCGDisplayBitsPerPixel] intValue];

-

-    cMinFreq = ri.Cvar_Get("r_minDisplayRefresh", "0", CVAR_ARCHIVE);

-    cMaxFreq = ri.Cvar_Get("r_maxDisplayRefresh", "0", CVAR_ARCHIVE);

-

-    if (cMinFreq && cMaxFreq && cMinFreq->integer && cMaxFreq->integer &&

-        cMinFreq->integer > cMaxFreq->integer) {

-        ri.Error(ERR_FATAL, "r_minDisplayRefresh must be less than or equal to r_maxDisplayRefresh");

-    }

-

-    minFreq = cMinFreq ? cMinFreq->integer : 0;

-    maxFreq = cMaxFreq ? cMaxFreq->integer : 0;

-    

-    displayModes = (NSArray *)CGDisplayAvailableModes(glw_state.display);

-    if (!displayModes) {

-        ri.Error(ERR_FATAL, "CGDisplayAvailableModes returned NULL -- 0x%0x is an invalid display", glw_state.display);

-    }

-    

-    modeCount = [displayModes count];

-    if (verbose) {

-        ri.Printf(PRINT_ALL, "%d modes avaliable\n", modeCount);

-        ri.Printf(PRINT_ALL, "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) {

-            ri.Printf(PRINT_ALL, " mode %d -- %s\n", modeIndex, [[mode description] cString]);

-        }

-

-        // Make sure we get the right size

-        object = [mode objectForKey: (id)kCGDisplayWidth];

-

-        if ([[mode objectForKey: (id)kCGDisplayWidth] intValue] != glConfig.vidWidth ||

-            [[mode objectForKey: (id)kCGDisplayHeight] intValue] != glConfig.vidHeight) {

-            if (verbose)

-                ri.Printf(PRINT_ALL, " -- bad size\n");

-            continue;

-        }

-

-        if (!allowStretchedModes) {

-            if ([[mode objectForKey: (id)kCGDisplayIOFlags] intValue] & kDisplayModeStretchedFlag) {

-                if (verbose)

-                    ri.Printf(PRINT_ALL, " -- stretched modes disallowed\n");

-                continue;

-            }

-        }

-

-        // Make sure that our frequency restrictions are observed

-        refresh = [[mode objectForKey: (id)kCGDisplayRefreshRate] intValue];

-        if (minFreq &&  refresh < minFreq) {

-            if (verbose)

-                ri.Printf(PRINT_ALL, " -- refresh too low\n");

-            continue;

-        }

-

-        if (maxFreq && refresh > maxFreq) {

-            if (verbose)

-                ri.Printf(PRINT_ALL, " -- refresh too high\n");

-            continue;

-        }

-

-        if ([[mode objectForKey: (id)kCGDisplayBitsPerPixel] intValue] != colorDepth) {

-            if (verbose)

-                ri.Printf(PRINT_ALL, " -- bad depth\n");

-            continue;

-        }

-

-        bestModeIndex = modeIndex;

-        if (verbose)

-            ri.Printf(PRINT_ALL, " -- OK\n", bestModeIndex);

-    }

-

-    if (verbose)

-        ri.Printf(PRINT_ALL, " bestModeIndex = %d\n", bestModeIndex);

-

-    if (bestModeIndex == 0xFFFFFFFF) {

-        ri.Printf(PRINT_ALL, "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 = malloc(tableSize * sizeof(*table->red));

-    if (table->green)

-        free(table->green);

-    table->green = malloc(tableSize * sizeof(*table->green));

-    if (table->blue)

-        free(table->blue);

-    table->blue = 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) {

-        Com_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 = 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;

-    

-//    Com_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 = realloc(red, sizeof(*red) * tableSize);

-        green = realloc(green, sizeof(*green) * tableSize);

-        blue = 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;

-

-    Com_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;

-    

-    if (!glConfig.deviceSupportsGamma)

-        return;

-

-    Com_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;

-        }

-    }

-

-    Com_Printf("Unable to find display to fade it\n");

-}

-

-void Sys_UnfadeScreens()

-{

-    CGDisplayCount displayIndex;

-    int stepIndex;

-    glwgamma_t *table;

-    NSTimeInterval start, current;

-    float time;

-    

-    if (!glConfig.deviceSupportsGamma)

-        return;

-        

-    Com_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;

-    

-    if (!glConfig.deviceSupportsGamma)

-        return;

-    

-    Com_Printf("Unfading display 0x%08x\n", display);

-

-    if (table) {

-        CGTableCount i;

-        

-        Com_Printf("Given table:\n");

-        for (i = 0; i < table->tableSize; i++) {

-            Com_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;

-    }

-    

-    Com_Printf("Unable to find display to unfade it\n");

-}

-

-

-

+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+
+This file is part of Quake III Arena source code.
+
+Quake III Arena 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 2 of the License,
+or (at your option) any later version.
+
+Quake III Arena 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 Foobar; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+#import "macosx_display.h"
+
+#include "tr_local.h"
+#import "macosx_local.h"
+
+#import <Foundation/Foundation.h>
+#import <IOKit/graphics/IOGraphicsTypes.h>  // for interpreting the kCGDisplayIOFlags element of the display mode
+
+
+NSDictionary *Sys_GetMatchingDisplayMode(qboolean allowStretchedModes)
+{
+    NSArray *displayModes;
+    NSDictionary *mode;
+    unsigned int modeIndex, modeCount, bestModeIndex;
+    int verbose;
+    cvar_t *cMinFreq, *cMaxFreq;
+    int minFreq, maxFreq;
+    unsigned int colorDepth;
+    
+    verbose = r_verbose->integer;
+
+    colorDepth = r_colorbits->integer;
+    if (colorDepth < 16 || !r_fullscreen->integer)
+        colorDepth = [[glw_state.desktopMode objectForKey: (id)kCGDisplayBitsPerPixel] intValue];
+
+    cMinFreq = ri.Cvar_Get("r_minDisplayRefresh", "0", CVAR_ARCHIVE);
+    cMaxFreq = ri.Cvar_Get("r_maxDisplayRefresh", "0", CVAR_ARCHIVE);
+
+    if (cMinFreq && cMaxFreq && cMinFreq->integer && cMaxFreq->integer &&
+        cMinFreq->integer > cMaxFreq->integer) {
+        ri.Error(ERR_FATAL, "r_minDisplayRefresh must be less than or equal to r_maxDisplayRefresh");
+    }
+
+    minFreq = cMinFreq ? cMinFreq->integer : 0;
+    maxFreq = cMaxFreq ? cMaxFreq->integer : 0;
+    
+    displayModes = (NSArray *)CGDisplayAvailableModes(glw_state.display);
+    if (!displayModes) {
+        ri.Error(ERR_FATAL, "CGDisplayAvailableModes returned NULL -- 0x%0x is an invalid display", glw_state.display);
+    }
+    
+    modeCount = [displayModes count];
+    if (verbose) {
+        ri.Printf(PRINT_ALL, "%d modes avaliable\n", modeCount);
+        ri.Printf(PRINT_ALL, "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) {
+            ri.Printf(PRINT_ALL, " mode %d -- %s\n", modeIndex, [[mode description] cString]);
+        }
+
+        // Make sure we get the right size
+        object = [mode objectForKey: (id)kCGDisplayWidth];
+
+        if ([[mode objectForKey: (id)kCGDisplayWidth] intValue] != glConfig.vidWidth ||
+            [[mode objectForKey: (id)kCGDisplayHeight] intValue] != glConfig.vidHeight) {
+            if (verbose)
+                ri.Printf(PRINT_ALL, " -- bad size\n");
+            continue;
+        }
+
+        if (!allowStretchedModes) {
+            if ([[mode objectForKey: (id)kCGDisplayIOFlags] intValue] & kDisplayModeStretchedFlag) {
+                if (verbose)
+                    ri.Printf(PRINT_ALL, " -- stretched modes disallowed\n");
+                continue;
+            }
+        }
+
+        // Make sure that our frequency restrictions are observed
+        refresh = [[mode objectForKey: (id)kCGDisplayRefreshRate] intValue];
+        if (minFreq &&  refresh < minFreq) {
+            if (verbose)
+                ri.Printf(PRINT_ALL, " -- refresh too low\n");
+            continue;
+        }
+
+        if (maxFreq && refresh > maxFreq) {
+            if (verbose)
+                ri.Printf(PRINT_ALL, " -- refresh too high\n");
+            continue;
+        }
+
+        if ([[mode objectForKey: (id)kCGDisplayBitsPerPixel] intValue] != colorDepth) {
+            if (verbose)
+                ri.Printf(PRINT_ALL, " -- bad depth\n");
+            continue;
+        }
+
+        bestModeIndex = modeIndex;
+        if (verbose)
+            ri.Printf(PRINT_ALL, " -- OK\n", bestModeIndex);
+    }
+
+    if (verbose)
+        ri.Printf(PRINT_ALL, " bestModeIndex = %d\n", bestModeIndex);
+
+    if (bestModeIndex == 0xFFFFFFFF) {
+        ri.Printf(PRINT_ALL, "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 = malloc(tableSize * sizeof(*table->red));
+    if (table->green)
+        free(table->green);
+    table->green = malloc(tableSize * sizeof(*table->green));
+    if (table->blue)
+        free(table->blue);
+    table->blue = 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) {
+        Com_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 = 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;
+    
+//    Com_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 = realloc(red, sizeof(*red) * tableSize);
+        green = realloc(green, sizeof(*green) * tableSize);
+        blue = 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;
+
+    Com_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;
+    
+    if (!glConfig.deviceSupportsGamma)
+        return;
+
+    Com_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;
+        }
+    }
+
+    Com_Printf("Unable to find display to fade it\n");
+}
+
+void Sys_UnfadeScreens()
+{
+    CGDisplayCount displayIndex;
+    int stepIndex;
+    glwgamma_t *table;
+    NSTimeInterval start, current;
+    float time;
+    
+    if (!glConfig.deviceSupportsGamma)
+        return;
+        
+    Com_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;
+    
+    if (!glConfig.deviceSupportsGamma)
+        return;
+    
+    Com_Printf("Unfading display 0x%08x\n", display);
+
+    if (table) {
+        CGTableCount i;
+        
+        Com_Printf("Given table:\n");
+        for (i = 0; i < table->tableSize; i++) {
+            Com_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;
+    }
+    
+    Com_Printf("Unable to find display to unfade it\n");
+}
+
+
+