nglVideoMode::nglVideoMode()
{
#ifdef __NGL_MACHO__
mDisplay = CGMainDisplayID();
#endif
Init();
#ifdef __NGL_MACHO__
CFDictionaryRef displayMode ;
CFNumberRef number ;
displayMode = (CFDictionaryRef) CGDisplayCurrentMode((CGDirectDisplayID)mDisplay) ;
/* Get the height and width of this display mode. Print them out. */
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayWidth ) ;
CFNumberGetValue( number, kCFNumberLongType, &mWidth ) ;
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayHeight ) ;
CFNumberGetValue( number, kCFNumberLongType, &mHeight ) ;
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayRefreshRate ) ;
CFNumberGetValue( number, kCFNumberLongType, &mRate ) ;
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayBitsPerPixel ) ;
CFNumberGetValue( number, kCFNumberLongType, &mBPP ) ;
#else
mWidth = 800;
mHeight = 600;
mBPP = 32;
mRate = 60;
#endif
}
static int Open(void * hwnd)
{
CGLRendererInfoObj renderer;
long numRenderer;
CGDirectDisplayID l[32];
CGDisplayCount count;
SYS_ASSERT(g_pCGLC == 0);
UNUSED(hwnd);
CGGetActiveDisplayList (sizeof(l), l, &count);
#ifdef _DEBUG
// Debug in multiple monitor. Use the secondary monitor for rendering
g_cgDisplayID = l[count-1];
#else
g_cgDisplayID = CGMainDisplayID ();
#endif
g_cgPrevDisplayMode = CGDisplayCurrentMode (g_cgDisplayID);
g_cgDisplayModeList = CGDisplayAvailableModes (g_cgDisplayID);
CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(g_cgDisplayID), &renderer, &numRenderer);
CGLDestroyRendererInfo(renderer);
return 0;
}
void QuartzToggler::emitRate() {
double rate = 0.0;
CFNumberGetValue(static_cast<CFNumberRef>(CFDictionaryGetValue(CGDisplayCurrentMode(activeDspys[widgetScreen]), kCGDisplayRefreshRate)), kCFNumberDoubleType, &rate);
emit rateChange(static_cast<int>(rate * 10.0 + 0.5));
}
int _glfwPlatformInit( void )
{
struct timeval tv;
UInt32 nullDummy = 0;
_glfwWin.MacWindow = NULL;
_glfwWin.AGLContext = NULL;
_glfwWin.WindowFunctions = NULL;
_glfwWin.MouseUPP = NULL;
_glfwWin.CommandUPP = NULL;
_glfwWin.KeyboardUPP = NULL;
_glfwWin.WindowUPP = NULL;
_glfwInput.Modifiers = 0;
_glfwLibs.OpenGLFramework
= CFBundleGetBundleWithIdentifier( CFSTR( "com.apple.opengl" ) );
if( _glfwLibs.OpenGLFramework == NULL )
{
return GL_FALSE;
}
_glfwDesktopVideoMode = CGDisplayCurrentMode( kCGDirectMainDisplay );
if( _glfwDesktopVideoMode == NULL )
{
return GL_FALSE;
}
_glfwInitThreads();
if( !_glfwChangeToResourcesDirectory() )
{
return GL_FALSE;
}
if( !_glfwInstallEventHandlers() )
{
_glfwPlatformTerminate();
return GL_FALSE;
}
// Ugly hack to reduce the nasty jump that occurs at the first non-
// sys keypress, caused by OS X loading certain meta scripts used
// for lexical- and raw keycode translation - instead of letting
// this happen while our application is running, we do some blunt
// function calls in advance just to get the script caching out of
// the way, BEFORE our window/screen is opened. These calls might
// generate err return codes, but we don't care in this case.
// NOTE: KCHRPtr is declared globally, because we need it later on.
KCHRPtr = (void *)GetScriptVariable( smCurrentScript, smKCHRCache );
KeyTranslate( KCHRPtr, 0, &nullDummy );
UppercaseText( (char *)&nullDummy, 0, smSystemScript );
gettimeofday( &tv, NULL );
_glfwTimer.t0 = tv.tv_sec + (double) tv.tv_usec / 1000000.0;
return GL_TRUE;
}
wxVideoMode wxDisplayImplMacOSX::GetCurrentMode() const
{
CFDictionaryRef theValue = CGDisplayCurrentMode( m_id );
return wxVideoMode(
wxCFDictKeyToInt( theValue, kCGDisplayWidth ),
wxCFDictKeyToInt( theValue, kCGDisplayHeight ),
wxCFDictKeyToInt( theValue, kCGDisplayBitsPerPixel ),
wxCFDictKeyToInt( theValue, kCGDisplayRefreshRate ));
}
QuartzToggler::QuartzToggler() :
originalMode(NULL),
activeDspys(NULL),
widgetScreen(0),
isFull(false)
{
CGDisplayCount dspyCnt = 0;
CGGetActiveDisplayList(0, 0, &dspyCnt);
activeDspys = new CGDirectDisplayID[dspyCnt];
CGGetActiveDisplayList(dspyCnt, activeDspys, &dspyCnt);
infoVector.resize(dspyCnt);
fullResIndex.resize(dspyCnt);
fullRateIndex.resize(dspyCnt);
for (CGDisplayCount i = 0; i < dspyCnt; ++i) {
CGDirectDisplayID display = activeDspys[i];
CFDictionaryRef currentMode = CGDisplayCurrentMode(display);
CFArrayRef modesArray = CGDisplayAvailableModes(display);
CFIndex numModes = CFArrayGetCount(modesArray);
CFNumberRef bpp = static_cast<CFNumberRef>(CFDictionaryGetValue(currentMode, kCGDisplayBitsPerPixel));
for (CFIndex j = 0; j < numModes; ++j) {
CFDictionaryRef mode = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(modesArray, j));
if (CFNumberCompare(bpp, static_cast<CFNumberRef>(CFDictionaryGetValue(mode, kCGDisplayBitsPerPixel)), NULL) == kCFCompareEqualTo) {
addMode(mode, infoVector[i], NULL, NULL);
}
}
}
originalMode = CGDisplayCurrentMode(activeDspys[widgetScreen]);
for (CGDisplayCount i = 0; i < dspyCnt; ++i) {
unsigned resIndex = 0;
unsigned rateIndex = 0;
addMode(CGDisplayCurrentMode(activeDspys[i]), infoVector[i], &resIndex, &rateIndex);
fullResIndex[i] = resIndex;
fullRateIndex[i] = rateIndex;
}
}
DisplayMode NPAPICoreMacOSPlatform::GetCurrentDisplayMode()
{
CFDictionaryRef currentMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
DisplayMode mode;
mode.width = GetModeWidth(currentMode);
mode.height = GetModeHeight(currentMode);
mode.refreshRate = GetModeRefreshRate(currentMode);
mode.bpp = GetModeBitsPerPixel(currentMode);
return mode;
}
Status GetVideoMode(int* xres, int* yres, int* bpp, int* freq)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
CGDisplayModeRef currentMode = CGDisplayCopyDisplayMode(kCGDirectMainDisplay);
#else
CFDictionaryRef currentMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
#endif
if(xres)
*xres = (int)CGDisplayPixelsWide(kCGDirectMainDisplay);
if(yres)
*yres = (int)CGDisplayPixelsHigh(kCGDirectMainDisplay);
if(bpp)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
// CGDisplayBitsPerPixel was deprecated in OS X 10.6
CFStringRef pixelEncoding = CGDisplayModeCopyPixelEncoding(currentMode);
if (CFStringCompare(pixelEncoding, CFSTR(IO32BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
*bpp = 32;
else if (CFStringCompare(pixelEncoding, CFSTR(IO16BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
*bpp = 16;
else if (CFStringCompare(pixelEncoding, CFSTR(IO8BitIndexedPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
*bpp = 8;
else // error
*bpp = 0;
// We're responsible for this
CFRelease(pixelEncoding);
#else
CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(currentMode, kCGDisplayBitsPerPixel);
CFNumberGetValue(num, kCFNumberIntType, bpp);
#endif
}
if(freq)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
*freq = (int)CGDisplayModeGetRefreshRate(currentMode);
#else
CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(currentMode, kCGDisplayRefreshRate);
CFNumberGetValue(num, kCFNumberIntType, freq);
#endif
}
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
// We're responsible for this
CGDisplayModeRelease(currentMode);
#endif
return INFO::OK;
}
static Bool
QuartzRandRCopyCurrentModeInfo(CGDirectDisplayID screenId,
QuartzModeInfoPtr pMode)
{
CFDictionaryRef curModeRef = CGDisplayCurrentMode(screenId);
if (!curModeRef)
return FALSE;
QuartzRandRGetModeInfo(curModeRef, pMode);
pMode->ref = (void *)curModeRef;
CFRetain(pMode->ref);
return TRUE;
}
DisplayMode CoreMacOSPlatform::GetCurrentDisplayMode()
{
CFDictionaryRef currentMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
// look at each mode in the available list
//CFDictionaryRef modeSystem = (CFDictionaryRef)CFArrayGetValueAtIndex(currentMode, mode);
DisplayMode mode;
mode.width = GetModeWidth(currentMode);
mode.height = GetModeHeight(currentMode);
mode.refreshRate = GetModeRefreshRate(currentMode);
mode.bpp = GetModeBitsPerPixel(currentMode);
return mode;
}
static void modewhacker( CGDirectDisplayID dspy )
{
int i;
CFDictionaryRef mode;
CFDictionaryRef originalMode;
boolean_t exactMatch;
CGDisplayErr err;
originalMode = CGDisplayCurrentMode( dspy );
if ( originalMode == NULL )
{
printf( "Display is invalid\n" );
return;
}
for ( i = 0; i < (sizeof myModeList / sizeof myModeList[0]); ++i )
{
printf( "Display 0x%x: Looking for %ld x %ld, %ld Bits Per Pixel\n",
(unsigned int)dspy,
myModeList[i].width,
myModeList[i].height,
myModeList[i].bitsPerPixel );
mode = CGDisplayBestModeForParameters(dspy,
myModeList[i].bitsPerPixel,
myModeList[i].width,
myModeList[i].height,
&exactMatch);
if ( exactMatch )
printf( "Found an exact match, switching modes:\n" );
else
printf( "Found a mode, switching modes:\n" );
printDesc( mode );
sleep( 1 ); // Short pause, then switch
err = CGDisplaySwitchToMode(dspy, mode);
if ( err != CGDisplayNoErr )
{
printf( "Oops! Mode switch failed?!?? (%d)\n", err );
break;
}
printf( "Pausing for 5 seconds...\n" );
sleep( 5 );
}
err = CGDisplaySwitchToMode(dspy, originalMode);
if ( err != CGDisplayNoErr )
printf( "Oops! Mode restore failed?!?? (%d)\n", err );
}
void gdip_get_display_dpi_carbon (float *h_dpi, float *v_dpi) {
if (getenv ("MONO_MWF_MAC_DETECT_DPI") != NULL) {
CFDictionaryRef mode_dict = CGDisplayCurrentMode (kCGDirectMainDisplay);
io_connect_t display_port = CGDisplayIOServicePort (kCGDirectMainDisplay);
CFDictionaryRef display_dict = IOCreateDisplayInfoDictionary (display_port, 0);
const float mmpi = 25.4;
float h_size = (float) gdip_get_int_from_dict_for_key (display_dict, CFSTR (kDisplayHorizontalImageSize)) / mmpi;
float v_size = (float) gdip_get_int_from_dict_for_key (display_dict, CFSTR (kDisplayVerticalImageSize)) / mmpi;
*h_dpi = (float) gdip_get_int_from_dict_for_key (mode_dict, kCGDisplayWidth) / h_size;
*v_dpi = (float) gdip_get_int_from_dict_for_key (mode_dict, kCGDisplayHeight) / v_size;
CFRelease (display_dict);
} else {
*h_dpi = *v_dpi = 96.0f;
}
}
int fs_ml_video_mode_get_current(fs_ml_video_mode *mode) {
mode->width = 0;
mode->height = 0;
mode->fps = 0;
mode->bpp = 0;
mode->flags = 0;
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1060
// CGDisplayCurrentMode is deprecated in Mac OS X 10.6, so we use
// the new API here
CGDirectDisplayID currentDisplay = CGDisplayPrimaryDisplay(
kCGDirectMainDisplay);
CGDisplayModeRef currentMode = CGDisplayCopyDisplayMode(
currentDisplay);
mode->width = CGDisplayModeGetWidth(currentMode);
mode->height = CGDisplayModeGetHeight(currentMode);
mode->fps = CGDisplayModeGetRefreshRate(currentMode);
CGDisplayModeRelease(currentMode);
#else
CFNumberRef number;
long refresh, width, height;
CFDictionaryRef currentMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
number = CFDictionaryGetValue(currentMode, kCGDisplayWidth);
CFNumberGetValue(number, kCFNumberLongType, &width);
number = CFDictionaryGetValue(currentMode, kCGDisplayHeight);
CFNumberGetValue(number, kCFNumberLongType, &height);
number = CFDictionaryGetValue(currentMode, kCGDisplayRefreshRate);
CFNumberGetValue(number, kCFNumberLongType, &refresh);
mode->width = width;
mode->height = height;
mode->fps = refresh;
#endif
//fs_log("WARNING: assuming 60 Hz refresh rate on Mac OS X\n");
//mode->fps = 60;
if (mode->fps == 0) {
fs_log("WARNING: refresh rate was not detected\n");
fs_log("full video sync will not be enabled automatically, but can "
"be forced\n");
}
return 0;
}
int _glfwPlatformInit( void )
{
_glfwWin.MacWindow = NULL;
_glfwWin.AGLContext = NULL;
_glfwWin.WindowFunctions = NULL;
_glfwWin.MouseUPP = NULL;
_glfwWin.CommandUPP = NULL;
_glfwWin.KeyboardUPP = NULL;
_glfwWin.WindowUPP = NULL;
_glfwInput.Modifiers = 0;
_glfwLibs.OpenGLFramework
= CFBundleGetBundleWithIdentifier( CFSTR( "com.apple.opengl" ) );
if ( _glfwLibs.OpenGLFramework == NULL )
{
return GL_FALSE;
}
_glfwDesktopVideoMode = CGDisplayCurrentMode( kCGDirectMainDisplay );
if ( _glfwDesktopVideoMode == NULL )
{
return GL_FALSE;
}
_glfwInitThreads();
if ( !_glfwChangeToResourcesDirectory() )
{
return GL_FALSE;
}
if ( !_glfwInstallEventHandlers() )
{
_glfwPlatformTerminate();
return GL_FALSE;
}
_glfwTimer.t0 = GetCurrentEventTime();
return GL_TRUE;
}
////////////////////////////////////////////////////////////
/// Get current desktop video mode
////////////////////////////////////////////////////////////
void VideoModeGetDesktopMode(struct VideoMode * Mode)
{
// Ceylo -- using same implementation as in OSXCarbon
CFDictionaryRef CurrentVideoMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
// Get video mode width
CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(CurrentVideoMode, kCGDisplayWidth),
kCFNumberIntType,
Mode.Width);
// Get video mode height
CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(CurrentVideoMode, kCGDisplayHeight),
kCFNumberIntType,
Mode.Height);
// Get video mode depth
CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(CurrentVideoMode, kCGDisplayBitsPerPixel),
kCFNumberIntType,
Mode.BitsPerPixel);
}
void QuartzToggler::setFullMode(const bool enable) {
CGDirectDisplayID display = activeDspys[widgetScreen];
CFDictionaryRef currentMode = CGDisplayCurrentMode(display);
CFDictionaryRef mode = currentMode;
if (enable) {
int bpp = 0;
CFNumberGetValue(static_cast<CFNumberRef>(CFDictionaryGetValue(currentMode, kCGDisplayBitsPerPixel)), kCFNumberIntType, &bpp);
mode = CGDisplayBestModeForParametersAndRefreshRate(
display,
bpp,
infoVector[widgetScreen][fullResIndex[widgetScreen]].w,
infoVector[widgetScreen][fullResIndex[widgetScreen]].h,
infoVector[widgetScreen][fullResIndex[widgetScreen]].rates[fullRateIndex[widgetScreen]] / 10.0,
NULL
);
if (!isFull)
originalMode = currentMode;
} else if (isFull)
mode = originalMode;
if (mode != currentMode) {
CGDisplaySwitchToMode(display, mode);
double oldRate = 0.0;
double newRate = 0.0;
CFNumberGetValue(static_cast<CFNumberRef>(CFDictionaryGetValue(currentMode, kCGDisplayRefreshRate)), kCFNumberDoubleType, &oldRate);
CFNumberGetValue(static_cast<CFNumberRef>(CFDictionaryGetValue(mode, kCGDisplayRefreshRate)), kCFNumberDoubleType, &newRate);
if (static_cast<int>(oldRate * 10.0 + 0.5) != static_cast<int>(newRate * 10.0 + 0.5))
emit rateChange(static_cast<int>(newRate * 10.0 + 0.5));
}
isFull = enable;
}
static int Open(void * hwnd)
{
CGDirectDisplayID l[32];
CGDisplayCount count;
CGGetActiveDisplayList (sizeof(l), l, &count);
SYS_ASSERT(g_pAGLC == 0);
SYS_ASSERT(hwnd);
static Rect rect;
g_pRect = ▭
g_hWnd = (WindowPtr) hwnd;
#ifdef _DEBUG
// Debug in multiple monitor. Use the secondary monitor for rendering
g_cgDisplayID = l[count-1];
#else
g_cgDisplayID = CGMainDisplayID ();
#endif
g_cgPrevDisplayMode = CGDisplayCurrentMode (g_cgDisplayID);
g_cgOldDisplayModeRestore = 0;
g_cgDisplayModeList = CGDisplayAvailableModes (g_cgDisplayID);
return 0;
}
static Bool
QuartzRandREnumerateModes(ScreenPtr pScreen,
QuartzModeCallback callback,
void *data)
{
Bool retval = FALSE;
QuartzScreenPtr pQuartzScreen = QUARTZ_PRIV(pScreen);
/* Just an 800x600 fallback if we have no attached heads */
if (pQuartzScreen->displayIDs) {
CFDictionaryRef curModeRef, modeRef;
long curBpp;
CFArrayRef modes;
QuartzModeInfo modeInfo;
int i;
CGDirectDisplayID screenId = pQuartzScreen->displayIDs[0];
curModeRef = CGDisplayCurrentMode(screenId);
if (!curModeRef)
return FALSE;
curBpp = getDictLong(curModeRef, kCGDisplayBitsPerPixel);
modes = CGDisplayAvailableModes(screenId);
if (!modes)
return FALSE;
for (i = 0; i < CFArrayGetCount(modes); i++) {
int cb;
modeRef = (CFDictionaryRef)CFArrayGetValueAtIndex(modes, i);
/* Skip modes that are not usable on the current display or have a
different pixel encoding than the current mode. */
if (((unsigned long)getDictLong(modeRef, kCGDisplayIOFlags) &
kDisplayModeUsableFlags) != kDisplayModeUsableFlags)
continue;
if (getDictLong(modeRef, kCGDisplayBitsPerPixel) != curBpp)
continue;
QuartzRandRGetModeInfo(modeRef, &modeInfo);
modeInfo.ref = (void *)modeRef;
cb = callback(pScreen, &modeInfo, data);
if (cb == CALLBACK_CONTINUE)
retval = TRUE;
else if (cb == CALLBACK_SUCCESS)
return TRUE;
else if (cb == CALLBACK_ERROR)
return FALSE;
}
}
switch (callback(pScreen, &pQuartzScreen->rootlessMode, data)) {
case CALLBACK_SUCCESS:
return TRUE;
case CALLBACK_ERROR:
return FALSE;
case CALLBACK_CONTINUE:
retval = TRUE;
default:
break;
}
switch (callback(pScreen, &pQuartzScreen->fullscreenMode, data)) {
case CALLBACK_SUCCESS:
return TRUE;
case CALLBACK_ERROR:
return FALSE;
case CALLBACK_CONTINUE:
retval = TRUE;
default:
break;
}
return retval;
}
bool macosxSetScreenResolution(QSize resolution, QPoint screenPoint)
{
CGDirectDisplayID display = displayAtPoint(screenPoint);
if (display == kCGNullDirectDisplay)
{
return false;
}
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
if (CGDisplayCopyAllDisplayModes != NULL)
{
bool ok = false;
CGDisplayModeRef currentMainDisplayMode = CGDisplayCopyDisplayMode(display);
CFStringRef currentPixelEncoding = CGDisplayModeCopyPixelEncoding(currentMainDisplayMode);
CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(display, NULL);
for (CFIndex i = 0, c = CFArrayGetCount(displayModes); i < c; i++)
{
bool isEqual = false;
CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
CFStringRef pixelEncoding = CGDisplayModeCopyPixelEncoding(mode);
if (CFStringCompare(pixelEncoding, currentPixelEncoding, 0) == kCFCompareEqualTo
&& CGDisplayModeGetWidth(mode) == (size_t)resolution.width()
&& CGDisplayModeGetHeight(mode) == (size_t)resolution.height())
{
isEqual = true;
}
CFRelease(pixelEncoding);
if (isEqual)
{
CGDisplaySetDisplayMode(display, mode, NULL);
ok = true;
break;
}
}
CFRelease(currentPixelEncoding);
CFRelease(displayModes);
return ok;
}
else
#endif
{
CFDictionaryRef currentMainDisplayMode = CGDisplayCurrentMode(display);
int bpp;
dictget(currentMainDisplayMode, Int, kCGDisplayBitsPerPixel, &bpp);
boolean_t exactMatch = false;
CFDictionaryRef bestMode = CGDisplayBestModeForParameters(display, bpp, resolution.width(), resolution.height(), &exactMatch);
if (bestMode != NULL)
{
if (!exactMatch)
{
qWarning("No optimal display mode for requested parameters.");
}
CGDisplaySwitchToMode(display, bestMode);
return true;
}
else
{
qWarning("Bad resolution change: Invalid display.");
return false;
}
}
}
unsigned char HaveOpenGLCapsChanged (GLCaps aDisplayCaps[],
CGDisplayCount dspyCnt)
{
CGDisplayCount maxDisplays = 32;
CGDirectDisplayID activeDspys[32];
CGDisplayErr theError;
short i;
CGDisplayCount newDspyCnt = 0;
if (NULL == aDisplayCaps) return 1;
theError = CGGetActiveDisplayList(maxDisplays, activeDspys, &newDspyCnt);
// if theError getting list mark as changed
if (theError) return 1;
// if number of displays not equal
if (dspyCnt != newDspyCnt) return 1;
for (i = 0; i < dspyCnt; i++) {
// get device ids
if (aDisplayCaps[i].cgDisplayID != activeDspys[i]) return 1;
if (aDisplayCaps[i].cglDisplayMask !=
CGDisplayIDToOpenGLDisplayMask(activeDspys[i])) return 1;
// get current geometry
{
CGRect displayRect = CGDisplayBounds (activeDspys[i]);
// get mode dictionary
CFDictionaryRef dispMode = CGDisplayCurrentMode (activeDspys[i]);
// check for all geometry matches
if (aDisplayCaps[i].deviceWidth != (long) displayRect.size.width)
return 1;
if (aDisplayCaps[i].deviceHeight != (long) displayRect.size.height)
return 1;
if (aDisplayCaps[i].deviceOriginX != (long) displayRect.origin.x)
return 1;
if (aDisplayCaps[i].deviceOriginY != (long) displayRect.origin.y)
return 1;
if (aDisplayCaps[i].deviceDepth !=
(short) _getDictLong (dispMode, kCGDisplayBitsPerPixel))
return 1;
if (aDisplayCaps[i].deviceRefresh !=
(short)(_getDictDouble (dispMode, kCGDisplayRefreshRate) + 0.5))
return 1; // round to GLint
}
// get renderer info based on gDevice
{
CGLRendererInfoObj info;
long j;
GLint numRenderers = 0, rv = 0;
CGLError theErr = 0;
GLint deviceVRAM; // video memory in bytes
unsigned long rendererID; // renderer ID
theErr = CGLQueryRendererInfo (aDisplayCaps[i].cglDisplayMask,
&info, &numRenderers);
if(0 == theErr) {
CGLDescribeRenderer (info, 0, kCGLRPRendererCount, &numRenderers);
for (j = 0; j < numRenderers; j++) {
// find accelerated renderer (assume only one)
CGLDescribeRenderer (info, j, kCGLRPAccelerated, &rv);
if (true == rv) { // if accelerated
// what is the renderer ID
CGLDescribeRenderer (info, j, kCGLRPRendererID, (GLint *)&rendererID);
if (rendererID != aDisplayCaps[i].rendererID) // check match
return 1;
// what is the VRAM
CGLDescribeRenderer (info, j, kCGLRPVideoMemory, &deviceVRAM);
if (deviceVRAM != aDisplayCaps[i].deviceVRAM) // check match
return 1;
break; // done
}
}
}
CGLDestroyRendererInfo (info);
}
}
return 0;
}
void CheckOpenGLCaps (CGDisplayCount maxDspys,
GLCaps dCaps[],
CGDisplayCount * dCnt)
{
CGLContextObj curr_ctx = 0;
CGDirectDisplayID dspys[32];
CGDisplayErr theErr;
short i;
short size = sizeof (GLCaps);
// no devices
*dCnt = 0;
if (maxDspys == 0) { // find number of displays
*dCnt = 0;
theErr = CGGetActiveDisplayList (32, dspys, dCnt);
if (theErr) // theErr getting list
*dCnt = 0; // 0 displays since can't correctly find any
// zero list to ensure the routines are used correctly
memset (dspys, 0, sizeof (CGDirectDisplayID) * *dCnt);
return; // return dCnt
}
if (NULL == dCaps) return;
theErr = CGGetActiveDisplayList(maxDspys, dspys, dCnt);
if (theErr) return; // theErr getting list
if (0 == *dCnt) return; // no displays
memset (dCaps, 0, size * *dCnt); // zero memory
for (i = 0; i < *dCnt; i++) {
// get device ids
dCaps[i].cgDisplayID = dspys[i];
dCaps[i].cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(dspys[i]);
{ // get current geometry
CGRect displayRect = CGDisplayBounds (dspys[i]);
// get mode dictionary
CFDictionaryRef dispMode = CGDisplayCurrentMode (dspys[i]);
dCaps[i].deviceWidth = (long) displayRect.size.width;
dCaps[i].deviceHeight = (long) displayRect.size.height;
dCaps[i].deviceOriginX = (long) displayRect.origin.x;
dCaps[i].deviceOriginY = (long) displayRect.origin.y;
dCaps[i].deviceDepth = (short) _getDictLong (dispMode,
kCGDisplayBitsPerPixel);
dCaps[i].deviceRefresh = (short) (_getDictDouble (dispMode,
kCGDisplayRefreshRate) + 0.5);
}
{ // get renderer info based on gDevice
CGLRendererInfoObj info;
long j;
GLint numRenderers = 0;
GLint rv = 0;
CGLError theErr2 = 0;
theErr2 = CGLQueryRendererInfo (dCaps[i].cglDisplayMask,
&info,
&numRenderers);
if(0 == theErr2) {
CGLDescribeRenderer (info, 0, kCGLRPRendererCount, &numRenderers);
for (j = 0; j < numRenderers; j++) {
// find accelerated renderer (assume only one)
CGLDescribeRenderer (info, j, kCGLRPAccelerated, &rv);
if (true == rv) { // if accelerated
// what is the renderer ID
CGLDescribeRenderer (info, j, kCGLRPRendererID,
&dCaps[i].rendererID);
// can we do full screen?
CGLDescribeRenderer (info, j, kCGLRPFullScreen, &rv);
dCaps[i].fullScreenCapable = (bool) rv;
// what is the VRAM?
CGLDescribeRenderer (info, j, kCGLRPVideoMemory,
&dCaps[i].deviceVRAM);
// what is the current texture memory?
CGLDescribeRenderer (info, j, kCGLRPTextureMemory,
&dCaps[i].deviceTextureRAM);
break; // done
}
}
}
CGLDestroyRendererInfo (info);
}
{ // build context and context specific info
CGLPixelFormatAttribute attribs[] = { kCGLPFADisplayMask,
dCaps[i].cglDisplayMask,
(CGLPixelFormatAttribute)0 };
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLContextObj cglContext;
curr_ctx = CGLGetCurrentContext (); // get current CGL context
CGLChoosePixelFormat (attribs, &pixelFormat, &numPixelFormats);
if (pixelFormat) {
CGLCreateContext(pixelFormat, NULL, &cglContext);
CGLDestroyPixelFormat (pixelFormat);
CGLSetCurrentContext (cglContext);
if (cglContext) {
const GLubyte * strExt;
const GLubyte * strRend;
const GLubyte * strVers;
const GLubyte * strVend;
// get renderer strings
strRend = glGetString (GL_RENDERER);
strncpy (dCaps[i].strRendererName, (char *) strRend, 255);
strVend = glGetString (GL_VENDOR);
strncpy (dCaps[i].strRendererVendor, (char *) strVend, 255);
strVers = glGetString (GL_VERSION);
strncpy (dCaps[i].strRendererVersion, (char *) strVers, 255);
{ // get BCD version
short j = 0;
short shiftVal = 8;
while (((strVers[j] <= '9') && (strVers[j] >= '0')) ||
(strVers[j] == '.')) {
// get only basic version info (until first non-digit or non-.)
if ((strVers[j] <= '9') && (strVers[j] >= '0')) {
dCaps[i].glVersion += (strVers[j] - '0') << shiftVal;
shiftVal -= 4;
}
j++;
}
}
strExt = glGetString (GL_EXTENSIONS);
// get caps
glGetIntegerv (GL_MAX_TEXTURE_UNITS,
&dCaps[i].textureUnits);
glGetIntegerv (GL_MAX_TEXTURE_SIZE,
&dCaps[i].maxTextureSize);
glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE,
&dCaps[i].max3DTextureSize);
glGetIntegerv (GL_MAX_CUBE_MAP_TEXTURE_SIZE,
&dCaps[i].maxCubeMapTextureSize);
// get functionality info
dCaps[i].fSpecularVector =
gluCheckExtension ((const GLubyte *) "GL_APPLE_specular_vector", strExt);
dCaps[i].fTransformHint =
gluCheckExtension ((const GLubyte *) "GL_APPLE_transform_hint", strExt);
dCaps[i].fPackedPixels =
gluCheckExtension ((const GLubyte *) "GL_APPLE_packed_pixels", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_APPLE_packed_pixel", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fClientStorage =
gluCheckExtension ((const GLubyte *) "GL_APPLE_client_storage", strExt);
dCaps[i].fYCbCr =
gluCheckExtension ((const GLubyte *) "GL_APPLE_ycbcr_422", strExt);
dCaps[i].fTextureRange =
gluCheckExtension ((const GLubyte *) "GL_APPLE_texture_range", strExt);
dCaps[i].fFence =
gluCheckExtension ((const GLubyte *) "GL_APPLE_fence", strExt);
dCaps[i].fVAR =
gluCheckExtension ((const GLubyte *) "GL_APPLE_vertex_array_range", strExt);
dCaps[i].fVAO =
gluCheckExtension ((const GLubyte *) "GL_APPLE_vertex_array_object", strExt);
dCaps[i].fElementArray =
gluCheckExtension ((const GLubyte *) "GL_APPLE_element_array", strExt);
dCaps[i].fVPEvals =
gluCheckExtension ((const GLubyte *) "GL_APPLE_vertex_program_evaluators",strExt);
dCaps[i].fFloatPixels =
gluCheckExtension ((const GLubyte *) "GL_APPLE_float_pixels", strExt);
dCaps[i].fFlushRenderer =
gluCheckExtension ((const GLubyte *) "GL_APPLE_flush_render", strExt);
dCaps[i].fPixelBuffer =
gluCheckExtension ((const GLubyte *) "GL_APPLE_pixel_buffer", strExt);
dCaps[i].fImaging =
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fTransposeMatrix =
gluCheckExtension ((const GLubyte *) "GL_ARB_transpose_matrix", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fMultitexture =
gluCheckExtension ((const GLubyte *) "GL_ARB_multitexture", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvAdd =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_add", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_env_add", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvCombine =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_combine", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvDot3 =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_dot3", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvCrossbar =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_crossbar", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fTexCubeMap =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_cube_map", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexCompress =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_compression", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fMultisample =
gluCheckExtension ((const GLubyte *) "GL_ARB_multisample", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexBorderClamp =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_border_clamp", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fPointParam =
gluCheckExtension ((const GLubyte *) "GL_ARB_point_parameters", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fVertexProg =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_program", strExt);
dCaps[i].fFragmentProg =
gluCheckExtension ((const GLubyte *) "GL_ARB_fragment_program", strExt);
dCaps[i].fTexMirrorRepeat =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_mirrored_repeat", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fDepthTex =
gluCheckExtension ((const GLubyte *) "GL_ARB_depth_texture", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fShadow =
gluCheckExtension ((const GLubyte *) "GL_ARB_shadow", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fShadowAmbient =
gluCheckExtension ((const GLubyte *) "GL_ARB_shadow_ambient", strExt);
dCaps[i].fVertexBlend =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_blend", strExt);
dCaps[i].fWindowPos =
gluCheckExtension ((const GLubyte *) "GL_ARB_window_pos", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fTex3D =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture3D", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fClipVolHint =
gluCheckExtension ((const GLubyte *) "GL_EXT_clip_volume_hint", strExt);
dCaps[i].fRescaleNorm =
gluCheckExtension ((const GLubyte *) "GL_EXT_rescale_normal", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fBlendColor =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_color", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fBlendMinMax =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_minmax", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fBlendSub =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_subtract", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fCVA =
gluCheckExtension ((const GLubyte *) "GL_EXT_compiled_vertex_array", strExt);
dCaps[i].fTexLODBias =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_lod_bias", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fABGR =
gluCheckExtension ((const GLubyte *) "GL_EXT_abgr", strExt);
dCaps[i].fBGRA =
gluCheckExtension ((const GLubyte *) "GL_EXT_bgra", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fTexFilterAniso =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_filter_anisotropic",strExt);
dCaps[i].fPaletteTex =
gluCheckExtension ((const GLubyte *) "GL_EXT_paletted_texture", strExt);
dCaps[i].fShareTexPalette =
gluCheckExtension ((const GLubyte *) "GL_EXT_shared_texture_palette", strExt);
dCaps[i].fSecColor =
gluCheckExtension ((const GLubyte *) "GL_EXT_secondary_color", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fTexCompressS3TC =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_compression_s3tc", strExt);
dCaps[i].fTexRect =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_rectangle", strExt);
dCaps[i].fFogCoord =
gluCheckExtension ((const GLubyte *) "GL_EXT_fog_coord", strExt);
dCaps[i].fDrawRangeElements =
gluCheckExtension ((const GLubyte *) "GL_EXT_draw_range_elements", strExt);
dCaps[i].fStencilWrap =
gluCheckExtension ((const GLubyte *) "GL_EXT_stencil_wrap", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fBlendFuncSep =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_func_separate", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fMultiDrawArrays =
gluCheckExtension ((const GLubyte *) "GL_EXT_multi_draw_arrays", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fShadowFunc =
gluCheckExtension ((const GLubyte *) "GL_EXT_shadow_funcs", strExt);
dCaps[i].fStencil2Side =
gluCheckExtension ((const GLubyte *) "GL_EXT_stencil_two_side", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fColorSubtable =
gluCheckExtension ((const GLubyte *) "GL_EXT_color_subtable", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fConvolution =
gluCheckExtension ((const GLubyte *) "GL_EXT_convolution", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fHistogram =
gluCheckExtension ((const GLubyte *) "GL_EXT_histogram", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fColorTable =
gluCheckExtension ((const GLubyte *) "GL_SGI_color_table", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fColorMatrix =
gluCheckExtension ((const GLubyte *) "GL_SGI_color_matrix", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fTexEdgeClamp =
gluCheckExtension ((const GLubyte *) "GL_SGIS_texture_edge_clamp", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fGenMipmap =
gluCheckExtension ((const GLubyte *) "GL_SGIS_generate_mipmap", strExt);
dCaps[i].fTexLOD =
gluCheckExtension ((const GLubyte *) "GL_SGIS_texture_lod", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fPointCull =
gluCheckExtension ((const GLubyte *) "GL_ATI_point_cull_mode", strExt);
dCaps[i].fTexMirrorOnce =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_mirror_once", strExt);
dCaps[i].fPNtriangles =
gluCheckExtension ((const GLubyte *) "GL_ATI_pn_triangles", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ATIX_pn_triangles", strExt);
dCaps[i].fTextFragShader =
gluCheckExtension ((const GLubyte *) "GL_ATI_text_fragment_shader", strExt);
dCaps[i].fATIBlendEqSep =
gluCheckExtension ((const GLubyte *) "GL_ATI_blend_equation_separate", strExt);
dCaps[i].fBlendWeightMinMax =
gluCheckExtension ((const GLubyte *) "GL_ATI_blend_weighted_minmax", strExt);
dCaps[i].fCombine3 =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_env_combine3", strExt);
dCaps[i].fSepStencil =
gluCheckExtension ((const GLubyte *) "GL_ATI_separate_stencil", strExt);
dCaps[i].fArrayRevComps4Byte =
gluCheckExtension ((const GLubyte *) "GL_ATI_array_rev_comps_in_4_bytes",strExt);
dCaps[i].fNVPointSprite =
gluCheckExtension ((const GLubyte *) "GL_NV_point_sprite", strExt);
dCaps[i].fRegCombiners =
gluCheckExtension ((const GLubyte *) "GL_NV_register_combiners", strExt);
dCaps[i].fRegCombiners2 =
gluCheckExtension ((const GLubyte *) "GL_NV_register_combiners2", strExt);
dCaps[i].fTexEnvCombine4 =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_env_combine4", strExt);
dCaps[i].fBlendSquare =
gluCheckExtension ((const GLubyte *) "GL_NV_blend_square", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fFogDist =
gluCheckExtension ((const GLubyte *) "GL_NV_fog_distance", strExt);
dCaps[i].fMultisampleFilterHint =
gluCheckExtension ((const GLubyte *) "GL_NV_multisample_filter_hint", strExt);
dCaps[i].fTexGenReflect =
gluCheckExtension ((const GLubyte *) "GL_NV_texgen_reflection", strExt);
dCaps[i].fTexShader =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_shader", strExt);
dCaps[i].fTexShader2 =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_shader2", strExt);
dCaps[i].fTexShader3 =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_shader3", strExt);
dCaps[i].fDepthClamp =
gluCheckExtension ((const GLubyte *) "GL_NV_depth_clamp", strExt);
dCaps[i].fLightMaxExp =
gluCheckExtension ((const GLubyte *) "GL_NV_light_max_exponent", strExt);
dCaps[i].fRasterPosClip =
gluCheckExtension ((const GLubyte *) "GL_IBM_rasterpos_clip", strExt);
dCaps[i].fConvBorderModes =
gluCheckExtension ((const GLubyte *) "GL_HP_convolution_border_modes", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fAuxDeptStencil =
gluCheckExtension ((const GLubyte *) "GL_APPLE_aux_depth_stencil", strExt);
dCaps[i].fFlushBufferRange =
gluCheckExtension ((const GLubyte *) "GL_APPLE_flush_buffer_range", strExt);
dCaps[i].fObjectPurgeable =
gluCheckExtension ((const GLubyte *) "GL_APPLE_object_purgeable", strExt);
dCaps[i].fDrawBuffers =
gluCheckExtension ((const GLubyte *) "GL_ARB_draw_buffers", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fFragmentProgShadow =
gluCheckExtension ((const GLubyte *) "GL_ARB_fragment_program_shadow", strExt);
dCaps[i].fFragmentShader =
gluCheckExtension ((const GLubyte *) "GL_ARB_fragment_shader", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fHalfFloatPixel =
gluCheckExtension ((const GLubyte *) "GL_ARB_half_float_pixel", strExt);
dCaps[i].fOcclusionQuery =
gluCheckExtension ((const GLubyte *) "GL_ARB_occlusion_query", strExt) ||
(dCaps[i].glVersion >= 0x0150);
dCaps[i].fPBO =
gluCheckExtension ((const GLubyte *) "GL_ARB_pixel_buffer_object", strExt) ||
(dCaps[i].glVersion >= 0x0210);
dCaps[i].fPointSprite =
gluCheckExtension ((const GLubyte *) "GL_ARB_point_sprite", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fShaderObjects =
gluCheckExtension ((const GLubyte *) "GL_ARB_shader_objects", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fShaderTextureLOD =
gluCheckExtension ((const GLubyte *) "GL_ARB_shader_texture_lod", strExt);
dCaps[i].fShadingLanguage100 =
gluCheckExtension ((const GLubyte *) "GL_ARB_shading_language_100", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fTexFloat =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_float", strExt);
dCaps[i].fTexNPOT =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_non_power_of_two", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fVBO =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_buffer_object", strExt) ||
(dCaps[i].glVersion >= 0x0150);
dCaps[i].fVertexShader =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_shader", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fTexComp3dc =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_compression_3dc", strExt);
dCaps[i].fTexATIfloat =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_float", strExt);
dCaps[i].fBlendEqSep =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_equation_separate", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fDepthBounds =
gluCheckExtension ((const GLubyte *) "GL_EXT_depth_bounds_test", strExt);
dCaps[i].fFBOblit =
gluCheckExtension ((const GLubyte *) "GL_EXT_framebuffer_blit", strExt);
dCaps[i].fFBO =
gluCheckExtension ((const GLubyte *) "GL_EXT_framebuffer_object", strExt);
dCaps[i].fGeometryShader4 =
gluCheckExtension ((const GLubyte *) "GL_EXT_geometry_shader4", strExt);
dCaps[i].fGPUProgParams =
gluCheckExtension ((const GLubyte *) "GL_EXT_gpu_program_parameters", strExt);
dCaps[i].fGPUShader4 =
gluCheckExtension ((const GLubyte *) "GL_EXT_gpu_shader4", strExt);
dCaps[i].fDepthStencil =
gluCheckExtension ((const GLubyte *) "GL_EXT_packed_depth_stencil", strExt);
dCaps[i].fSepSpecColor =
gluCheckExtension ((const GLubyte *) "GL_EXT_separate_specular_color", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fTexCompDXT1 =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_compression_dxt1", strExt);
dCaps[i].fTexMirrorClamp =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_mirror_clamp", strExt);
dCaps[i].fTexSRGB =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_sRGB", strExt) ||
(dCaps[i].glVersion >= 0x0210);
if (dCaps[i].fTexRect) // only check if extension supported
glGetIntegerv (GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT,
&dCaps[i].maxRectTextureSize);
else
dCaps[i].maxRectTextureSize = 0;
CGLDestroyContext (cglContext);
}
}
CGLSetCurrentContext (curr_ctx); // reset current CGL context
}
}
}
bool macosxAppendAvailableScreenResolutions(QList<QSize> &resolutions, QSize minSize, QPoint screenPoint)
{
CGDirectDisplayID display = displayAtPoint(screenPoint);
if (display == kCGNullDirectDisplay)
{
return false;
}
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
bool modern = (CGDisplayCopyAllDisplayModes != NULL); // where 'modern' means >= 10.6
#endif
CFArrayRef displayModes;
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
if (modern)
{
displayModes = CGDisplayCopyAllDisplayModes(display, NULL);
}
else
#endif
{
displayModes = CGDisplayAvailableModes(display);
}
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
CFStringRef currentPixelEncoding = NULL;
#endif
double currentRefreshRate;
int curBPP, curBPS, curSPP;
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
if (modern)
{
CGDisplayModeRef currentDisplayMode = CGDisplayCopyDisplayMode(display);
currentRefreshRate = CGDisplayModeGetRefreshRate(currentDisplayMode);
currentPixelEncoding = CGDisplayModeCopyPixelEncoding(currentDisplayMode);
CFRelease(currentDisplayMode);
}
else
#endif
{
CFDictionaryRef currentDisplayMode = CGDisplayCurrentMode(display);
dictget(currentDisplayMode, Double, kCGDisplayRefreshRate, ¤tRefreshRate);
dictget(currentDisplayMode, Int, kCGDisplayBitsPerPixel, &curBPP);
dictget(currentDisplayMode, Int, kCGDisplayBitsPerSample, &curBPS);
dictget(currentDisplayMode, Int, kCGDisplaySamplesPerPixel, &curSPP);
}
for (CFIndex j = 0, c = CFArrayGetCount(displayModes); j < c; j++)
{
int width, height;
double refreshRate;
bool pixelEncodingsEqual;
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
if (modern)
{
CGDisplayModeRef displayMode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, j);
width = (int)CGDisplayModeGetWidth(displayMode);
height = (int)CGDisplayModeGetHeight(displayMode);
refreshRate = CGDisplayModeGetRefreshRate(displayMode);
CFStringRef pixelEncoding = CGDisplayModeCopyPixelEncoding(displayMode);
pixelEncodingsEqual = (CFStringCompare(pixelEncoding, currentPixelEncoding, 0) == kCFCompareEqualTo);
CFRelease(pixelEncoding);
}
else
#endif
{
CFDictionaryRef displayMode = (CFDictionaryRef)CFArrayGetValueAtIndex(displayModes, j);
dictget(displayMode, Int, kCGDisplayWidth, &width);
dictget(displayMode, Int, kCGDisplayHeight, &height);
dictget(displayMode, Double, kCGDisplayRefreshRate, &refreshRate);
int bpp, bps, spp;
dictget(displayMode, Int, kCGDisplayBitsPerPixel, &bpp);
dictget(displayMode, Int, kCGDisplayBitsPerSample, &bps);
dictget(displayMode, Int, kCGDisplaySamplesPerPixel, &spp);
pixelEncodingsEqual = (bpp == curBPP && bps == curBPS && spp == curSPP);
}
QSize res(width, height);
if (!resolutions.contains(res)
&& width >= minSize.width() && height >= minSize.height()
&& refreshRate == currentRefreshRate && pixelEncodingsEqual)
{
resolutions += res;
}
}
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
if (modern)
{
CFRelease(currentPixelEncoding);
CFRelease(displayModes);
}
#endif
return true;
}
bool OpenGLApp::initAPI(){
initialMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
dmodes = CGDisplayAvailableModes(kCGDirectMainDisplay);
int count = CFArrayGetCount(dmodes);
Array <DispRes> modes;
int foundMode = -1;
for (int i = 0; i < count; i++){
CFDictionaryRef mode = (CFDictionaryRef) CFArrayGetValueAtIndex(dmodes, i);
long bitsPerPixel = GetDictionaryLong(mode, kCGDisplayBitsPerPixel);
Boolean safeForHardware = GetDictionaryBoolean(mode, kCGDisplayModeIsSafeForHardware);
Boolean stretched = GetDictionaryBoolean(mode, kCGDisplayModeIsStretched);
if (bitsPerPixel < colorBits || !safeForHardware || stretched) continue;
long width = GetDictionaryLong(mode, kCGDisplayWidth);
long height = GetDictionaryLong(mode, kCGDisplayHeight);
long refreshRate = GetDictionaryLong(mode, kCGDisplayRefreshRate);
// printf("Mode: %dx%dx%d @ %d\n", width, height, bitsPerPixel, refreshRate);
if (width >= 640 && height >= 480){
modes.add(newRes(width, height, i));
if (width == fullscreenWidth && height == fullscreenHeight){
foundMode = i;
}
}
}
resolution->clear();
modes.sort(dComp);
char str[64];
for (uint i = 0; i < modes.getCount(); i++){
sprintf(str, "%dx%d", modes[i].w, modes[i].h);
int index = resolution->addItemUnique(str);
if (modes[i].index == foundMode) resolution->selectItem(index);
}
if (fullscreen){
if (foundMode < 0 || CGDisplaySwitchToMode(kCGDirectMainDisplay, (CFDictionaryRef) CFArrayGetValueAtIndex(dmodes, foundMode)) != kCGErrorSuccess){
sprintf(str, "Couldn't set fullscreen to %dx%d.", fullscreenWidth, fullscreenHeight);
ErrorMsg(str);
fullscreen = false;
}
}
Rect rect;
if (fullscreen){
rect.left = 0;
rect.top = 0;
} else {
long w = GetDictionaryLong(initialMode, kCGDisplayWidth);
long h = GetDictionaryLong(initialMode, kCGDisplayHeight);
rect.left = (w - width) / 2;
rect.top = (h - height) / 2;
}
rect.right = rect.left + width;
rect.bottom = rect.top + height;
WindowAttributes attributes = fullscreen? (kWindowNoTitleBarAttribute | kWindowNoShadowAttribute) : (kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute);
OSStatus error = CreateNewWindow(kDocumentWindowClass, attributes, &rect, &window);
if (error != noErr || window == NULL){
ErrorMsg("Couldn't create window");
return false;
}
GDHandle screen = GetGWorldDevice(GetWindowPort(window));
if (screen == NULL){
ErrorMsg("Couldn't get device");
ReleaseWindow(window);
return false;
}
AGLPixelFormat pixelFormat;
while (true){
GLint attributes[] = {
fullscreen? AGL_FULLSCREEN : AGL_WINDOW,
AGL_RGBA,
AGL_DOUBLEBUFFER,
AGL_RED_SIZE, 8,
AGL_GREEN_SIZE, 8,
AGL_BLUE_SIZE, 8,
AGL_ALPHA_SIZE, (colorBits > 24)? 8 : 0,
AGL_DEPTH_SIZE, depthBits,
AGL_STENCIL_SIZE, stencilBits,
AGL_SAMPLE_BUFFERS_ARB, (antiAliasSamples > 0),
AGL_SAMPLES_ARB, antiAliasSamples,
AGL_NONE
};
pixelFormat = aglChoosePixelFormat(&screen, 1, attributes);
if (pixelFormat != NULL) break;
antiAliasSamples -= 2;
if (antiAliasSamples < 0){
ErrorMsg("No suitable pixel format");
ReleaseWindow(window);
return false;
}
}
glContext = aglCreateContext(pixelFormat, NULL);
aglDestroyPixelFormat(pixelFormat);
if (glContext == NULL){
ErrorMsg("Couldn't create context");
ReleaseWindow(window);
return false;
}
if (fullscreen){
CGCaptureAllDisplays();
aglSetFullScreen(glContext, 0, 0, 0, 0);
} else {
if (!aglSetDrawable(glContext, GetWindowPort(window))){
ErrorMsg("Couldn't set drawable");
aglDestroyContext(glContext);
ReleaseWindow(window);
return false;
}
}
if (!aglSetCurrentContext(glContext)){
ErrorMsg("Couldn't make context current");
aglDestroyContext(glContext);
ReleaseWindow(window);
return false;
}
setWindowTitle(getTitle());
ShowWindow(window);
initExtensions();
if (antiAliasSamples > 0){
glEnable(GL_MULTISAMPLE_ARB);
}
if (fullscreen) captureMouse(!configDialog->isVisible());
renderer = new OpenGLRenderer(glContext);
renderer->setViewport(width, height);
antiAlias->selectItem(antiAliasSamples / 2);
linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP);
defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp);
blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA);
noDepthTest = renderer->addDepthState(false, false);
noDepthWrite = renderer->addDepthState(true, false);
cullNone = renderer->addRasterizerState(CULL_NONE);
cullBack = renderer->addRasterizerState(CULL_BACK);
cullFront = renderer->addRasterizerState(CULL_FRONT);
return true;
}
PsychError SCREENReadNormalizedGammaTable(void)
{
int i, screenNumber, numEntries, reallutsize, physicalDisplay, outputId;
float *redTable, *greenTable, *blueTable;
double *gammaTable;
//all subfunctions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumOutputArgs(3));
PsychErrorExit(PsychCapNumInputArgs(2));
// Get optional physicalDisplay argument - It defaults to zero:
physicalDisplay = -1;
PsychCopyInIntegerArg(2, FALSE, &physicalDisplay);
// Read in the screen number:
// On OS/X we also accept screen indices for physical displays (as opposed to active dispays).
// This only makes a difference in mirror-mode, where there is only 1 active display, but that
// corresponds to two physical displays which can have different gamma setting requirements:
if ((PSYCH_SYSTEM == PSYCH_OSX) && (physicalDisplay > 0)) {
PsychCopyInIntegerArg(1, TRUE, &screenNumber);
if (screenNumber < 1) PsychErrorExitMsg(PsychError_user, "A 'screenNumber' that is smaller than one provided, although 'physicalDisplay' flag set. This is not allowed!");
// Invert screenNumber as a sign its a physical display, not an active display:
screenNumber = -1 * screenNumber;
}
else {
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
}
if ((PSYCH_SYSTEM == PSYCH_LINUX) && (physicalDisplay > -1)) {
// Affect one specific display output for given screen:
outputId = physicalDisplay;
}
else {
// Other OS'es, and Linux with default setting: Affect all outputs
// for a screen.
outputId = -1;
}
// Retrieve gamma table:
PsychReadNormalizedGammaTable(screenNumber, outputId, &numEntries, &redTable, &greenTable, &blueTable);
// Copy it out to runtime:
PsychAllocOutDoubleMatArg(1, FALSE, numEntries, 3, 0, &gammaTable);
for(i=0;i<numEntries;i++){
gammaTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 0, 0)]=(double)redTable[i];
gammaTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 1, 0)]=(double)greenTable[i];
gammaTable[PsychIndexElementFrom3DArray(numEntries, 3, 0, i, 2, 0)]=(double)blueTable[i];
}
// Copy out optional DAC resolution value:
PsychCopyOutDoubleArg(2, FALSE, (double) PsychGetDacBitsFromDisplay(screenNumber));
// We default to the assumption that the real size of the hardware LUT is identical to
// the size of the returned LUT:
reallutsize = numEntries;
#if PSYCH_SYSTEM == PSYCH_OSX
// On OS-X we query the real LUT size from the OS and return that value:
CGDirectDisplayID displayID;
CFMutableDictionaryRef properties;
CFNumberRef cfGammaLength;
SInt32 lutslotcount;
io_service_t displayService;
kern_return_t kr;
CFMutableArrayRef framebufferTimings0 = 0;
CFDataRef framebufferTimings1 = 0;
IODetailedTimingInformationV2 *framebufferTiming = NULL;
// Retrieve display handle for screen:
PsychGetCGDisplayIDFromScreenNumber(&displayID, screenNumber);
if (PsychPrefStateGet_Verbosity()>5) printf("PTB-DEBUG: Screen %i has framebuffer address %p.\n", screenNumber, CGDisplayBaseAddress(displayID));
// Retrieve low-level IOKit service port for this display:
displayService = CGDisplayIOServicePort(displayID);
// Obtain the properties from that service
kr = IORegistryEntryCreateCFProperties(displayService, &properties, NULL, 0);
if((kr == kIOReturnSuccess) && ((cfGammaLength = (CFNumberRef) CFDictionaryGetValue(properties, CFSTR(kIOFBGammaCountKey)))!=NULL))
{
CFNumberGetValue(cfGammaLength, kCFNumberSInt32Type, &lutslotcount);
CFRelease(properties);
reallutsize = (int) lutslotcount;
}
else {
// Failed!
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to query real size of video LUT for screen %i! Will return safe default of %i slots.\n", screenNumber, reallutsize);
}
if (PsychPrefStateGet_Verbosity()>9) {
CFDictionaryRef currentMode;
CFNumberRef n;
int modeId;
currentMode = CGDisplayCurrentMode(displayID);
n=CFDictionaryGetValue(currentMode, kCGDisplayMode);
CFNumberGetValue(n, kCFNumberIntType, &modeId);
printf("Current mode has id %i\n\n", modeId);
kr = IORegistryEntryCreateCFProperties(displayService, &properties, NULL, 0);
if((kr == kIOReturnSuccess) && ((framebufferTimings0 = (CFMutableArrayRef) CFDictionaryGetValue(properties, CFSTR(kIOFBDetailedTimingsKey) ) )!=NULL))
{
for (i=0; i<CFArrayGetCount(framebufferTimings0); i++) {
if ((framebufferTimings1 = CFArrayGetValueAtIndex(framebufferTimings0, i)) != NULL) {
if ((framebufferTiming = (IODetailedTimingInformationV2*) CFDataGetBytePtr(framebufferTimings1)) != NULL) {
printf("[%i] : VActive = %li, VBL = %li, VSYNC = %li, VSYNCWIDTH = %li , VBORDERBOT = %li, VTOTAL = %li \n", i, framebufferTiming->verticalActive, framebufferTiming->verticalBlanking, framebufferTiming->verticalSyncOffset, framebufferTiming->verticalSyncPulseWidth, framebufferTiming->verticalBorderBottom, framebufferTiming->verticalActive + framebufferTiming->verticalBlanking);
}
}
}
CFRelease(properties);
}
else {
// Failed!
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to query STUFF for screen %i --> %p!\n", screenNumber, properties);
}
}
#endif
// Copy out optional real LUT size (number of slots):
PsychCopyOutDoubleArg(3, FALSE, (double) reallutsize);
return(PsychError_none);
}
DisplayInfo MythDisplay::GetDisplayInfo(int video_rate)
{
DisplayInfo ret;
#if defined(Q_WS_MAC)
CGDirectDisplayID disp = GetOSXDisplay(GetWindowID());
if (!disp)
return ret;
CFDictionaryRef ref = CGDisplayCurrentMode(disp);
float rate = 0.0f;
if (ref)
rate = get_float_CF(ref, kCGDisplayRefreshRate);
if (VALID_RATE(rate))
ret.rate = 1000000.0f / rate;
else
ret.rate = fix_rate(video_rate);
CGSize size_in_mm = CGDisplayScreenSize(disp);
ret.size = QSize((uint) size_in_mm.width, (uint) size_in_mm.height);
uint width = (uint)CGDisplayPixelsWide(disp);
uint height = (uint)CGDisplayPixelsHigh(disp);
ret.res = QSize(width, height);
#elif defined(Q_WS_WIN)
HDC hdc = GetDC(GetWindowID());
int rate = 0;
if (hdc)
{
rate = GetDeviceCaps(hdc, VREFRESH);
int width = GetDeviceCaps(hdc, HORZSIZE);
int height = GetDeviceCaps(hdc, VERTSIZE);
ret.size = QSize((uint)width, (uint)height);
width = GetDeviceCaps(hdc, HORZRES);
height = GetDeviceCaps(hdc, VERTRES);
ret.res = QSize((uint)width, (uint)height);
}
if (VALID_RATE(rate))
{
// see http://support.microsoft.com/kb/2006076
switch (rate)
{
case 23:
ret.rate = 41708;
break; // 23.976Hz
case 29:
ret.rate = 33367;
break; // 29.970Hz
case 47:
ret.rate = 20854;
break; // 47.952Hz
case 59:
ret.rate = 16683;
break; // 59.940Hz
case 71:
ret.rate = 13903;
break; // 71.928Hz
case 119:
ret.rate = 8342;
break; // 119.880Hz
default:
ret.rate = 1000000.0f / (float)rate;
}
}
else
ret.rate = fix_rate(video_rate);
#elif USING_X11
MythXDisplay *disp = OpenMythXDisplay();
if (!disp)
return ret;
float rate = disp->GetRefreshRate();
if (VALID_RATE(rate))
ret.rate = 1000000.0f / rate;
else
ret.rate = fix_rate(video_rate);
ret.res = disp->GetDisplaySize();
ret.size = disp->GetDisplayDimensions();
delete disp;
#endif
return ret;
}
bool gl_initialize(int screen_wid,int screen_high,bool lock_fps_refresh,int fsaa_mode,bool reset,char *err_str)
{
GLint ntxtunit,ntxtsize;
#ifdef D3_OS_MAC
long swapint,rect[4];
CGLContextObj current_ctx;
CFDictionaryRef mode_info;
CFNumberRef cf_rate;
#else
GLenum glew_error;
#endif
// setup rendering sizes
setup.screen.x_sz=screen_wid;
setup.screen.y_sz=screen_high;
// normal attributes
SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
// full screen anti-aliasing attributes
switch (fsaa_mode) {
case fsaa_mode_low:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,2);
break;
case fsaa_mode_medium:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,4);
break;
case fsaa_mode_high:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,6);
break;
}
// start window or full screen
if (gl_in_window_mode()) {
surface=SDL_SetVideoMode(setup.screen.x_sz,setup.screen.y_sz,32,SDL_OPENGL|SDL_HWSURFACE);
SDL_WM_SetCaption("dim3",NULL);
}
else {
surface=SDL_SetVideoMode(setup.screen.x_sz,setup.screen.y_sz,32,SDL_OPENGL|SDL_FULLSCREEN);
}
if (surface==NULL) {
sprintf(err_str,"SDL: Could not set video mode (Error: %s)",SDL_GetError());
return(FALSE);
}
// work around the dock losing minimize buttons because
// of SDL luncancy
#ifdef D3_OS_MAC
if (!gl_in_window_mode()) SetSystemUIMode(kUIModeContentSuppressed,0);
#endif
// use glew on linux and windows
#ifndef D3_OS_MAC
glew_error=glewInit();
if (glew_error!=GL_NO_ERROR) {
strcpy(err_str,glewGetErrorString(glew_error));
return(FALSE);
}
#endif
// grab openGL attributes
strncpy(render_info.name,(char*)glGetString(GL_RENDERER),64);
render_info.name[63]=0x0;
strncpy(render_info.ext_string,(char*)glGetString(GL_EXTENSIONS),8192);
render_info.ext_string[8191]=0x0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS,&ntxtunit);
render_info.texture_unit_count=(int)ntxtunit;
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&ntxtsize);
render_info.texture_max_size=(int)ntxtsize;
// in case screen is bigger than desired drawing surface
render_info.monitor_x_sz=surface->w;
render_info.monitor_y_sz=surface->h;
render_info.view_x=(render_info.monitor_x_sz-setup.screen.x_sz)>>1;
render_info.view_y=(render_info.monitor_y_sz-setup.screen.y_sz)>>1;
// determine the referesh rate
render_info.monitor_refresh_rate=60; // windows XP has a stuck refresh rate of 60
#ifdef D3_OS_MAC
mode_info=CGDisplayCurrentMode(CGMainDisplayID());
if (mode_info!=NULL) {
cf_rate=(CFNumberRef)CFDictionaryGetValue(mode_info,kCGDisplayRefreshRate);
if (cf_rate) {
CFNumberGetValue(cf_rate,kCFNumberIntType,&render_info.monitor_refresh_rate);
if (render_info.monitor_refresh_rate==0) render_info.monitor_refresh_rate=60;
}
}
#endif
// clear the entire window so it doesn't flash
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapBuffers();
// setup renderer
#ifdef D3_OS_MAC
current_ctx=CGLGetCurrentContext();
rect[0]=render_info.view_x;
rect[1]=render_info.view_y;
rect[2]=setup.screen.x_sz;
rect[3]=setup.screen.y_sz;
CGLSetParameter(current_ctx,kCGLCPSwapRectangle,rect);
CGLEnable(current_ctx,kCGLCESwapRectangle);
if (lock_fps_refresh) {
swapint=1;
CGLSetParameter(current_ctx,kCGLCPSwapInterval,&swapint);
}
#endif
glViewport(render_info.view_x,render_info.view_y,setup.screen.x_sz,setup.screen.y_sz);
// perspective correction
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
// smoothing and anti-aliasing
glDisable(GL_DITHER);
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
if (fsaa_mode!=fsaa_mode_none) glEnable(GL_MULTISAMPLE);
// texture compression
glHint(GL_TEXTURE_COMPRESSION_HINT,GL_NICEST);
glHint(GL_GENERATE_MIPMAP_HINT,GL_NICEST);
// all alphas by 8 bit component
glDisable(GL_ALPHA_TEST);
// texture utility initialize
gl_texture_initialize();
// do an initial draw
if (!reset) {
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapBuffers();
}
return(TRUE);
}
