wxVideoMode wxDisplay::GetCurrentMode() const
{
unsigned long dwDMVer;
wxVideoMode RetMode;
Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
if (dwDMVer >= 0x020000) //version 2?
{
VDSwitchInfoRec sMode; //Note - csMode member also contains the bit depth
if (DMGetDisplayMode(m_priv->m_hndl, &sMode) == noErr)
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
wxASSERT(uppMLI);
DMModeTransRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.psMode = &sMode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
if ( sModeInfo.bMatched == true )
{
RetMode = sModeInfo.Mode;
break;
}
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
}
else //Can't get current mode?
{
wxLogSysError(wxString::Format(wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
(unsigned int) dwDMVer));
}
}
else //DM ver 1
{
wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
);
}
return RetMode;
}
OSErr RVRequestVideoSetting (VideoRequestRecPtr requestRecPtr)
{
Boolean displayMgrPresent;
short iCount = 0; // just a counter of GDevices we have seen
DMDisplayModeListIteratorUPP myModeIteratorProc = nil; // for DM2.0 searches
SpBlock spBlock;
Boolean suppliedGDevice;
DisplayIDType theDisplayID; // for DM2.0 searches
DMListIndexType theDisplayModeCount; // for DM2.0 searches
DMListType theDisplayModeList; // for DM2.0 searches
long value = 0;
GDHandle walkDevice = nil; // for everybody
Gestalt(gestaltDisplayMgrAttr,&value);
displayMgrPresent=value&(1<<gestaltDisplayMgrPresent);
displayMgrPresent=displayMgrPresent && (SVersion(&spBlock)==noErr); // need slot manager
if (displayMgrPresent)
{
// init the needed data before we start
if (requestRecPtr->screenDevice) // user wants a specifc device?
{
walkDevice = requestRecPtr->screenDevice;
suppliedGDevice = true;
}
else
{
walkDevice = DMGetFirstScreenDevice (dmOnlyActiveDisplays); // for everybody
suppliedGDevice = false;
}
myModeIteratorProc = NewDMDisplayModeListIteratorProc(ModeListIterator); // for DM2.0 searches
// Note that we are hosed if somebody changes the gdevice list behind our backs while we are iterating....
// ...now do the loop if we can start
if( walkDevice && myModeIteratorProc) do // start the search
{
iCount++; // GDevice we are looking at (just a counter)
if( noErr == DMGetDisplayIDByGDevice( walkDevice, &theDisplayID, false ) ) // DM1.0 does not need this, but it fits in the loop
{
theDisplayModeCount = 0; // for DM2.0 searches
if (noErr == DMNewDisplayModeList(theDisplayID, 0, 0, &theDisplayModeCount, &theDisplayModeList) )
{
// search NuBus & PCI the new kool way through Display Manager 2.0
GetRequestTheDM2Way (requestRecPtr, walkDevice, myModeIteratorProc, theDisplayModeCount, &theDisplayModeList);
DMDisposeList(theDisplayModeList); // now toss the lists for this gdevice and go on to the next one
}
else
{
// search NuBus only the old disgusting way through the slot manager
GetRequestTheDM1Way (requestRecPtr, walkDevice);
}
}
} while ( !suppliedGDevice && nil != (walkDevice = DMGetNextScreenDevice ( walkDevice, dmOnlyActiveDisplays )) ); // go until no more gdevices
if( myModeIteratorProc )
DisposeRoutineDescriptor(myModeIteratorProc);
return (noErr); // we were able to get the look for a match
}
return (-1); // return a generic error
}
wxArrayVideoModes
wxDisplay::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes Modes;
unsigned long dwDMVer;
Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
if (dwDMVer >= 0x020000) //version 2?
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr, wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
wxASSERT(uppMLI);
DMModeIteratorRec sModeInfo;
sModeInfo.pModes = &Modes;
sModeInfo.pMatchMode = &mode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
}
else //DM 1.0, 1.2, 1.x
{
wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
);
}
return Modes;
}
OSStatus PickMonitor (DisplayIDType *inOutDisplayID, WindowRef parentWindow)
{
WindowRef theWindow;
OSStatus status = noErr;
static const ControlID kUserPane = { 'MONI', 1 };
// Fetch the dialog
IBNibRef aslNib;
CFBundleRef theBundle = CFBundleGetMainBundle();
status = CreateNibReferenceWithCFBundle(theBundle, CFSTR("ASLCore"), &aslNib);
status = ::CreateWindowFromNib(aslNib, CFSTR( "Pick Monitor" ), &theWindow );
if (status != noErr)
{
assert(false);
return userCanceledErr;
}
#if 0
// Put game name in window title. By default the title includes the token <<<kGameName>>>.
Str255 windowTitle;
GetWTitle(theWindow, windowTitle);
FormatPStringWithGameName(windowTitle);
SetWTitle(theWindow, windowTitle);
#endif
// Set up the controls
ControlRef monitorPane;
GetControlByID( theWindow, &kUserPane, &monitorPane );
assert(monitorPane);
SetupPickMonitorPane(monitorPane, *inOutDisplayID);
// Create our UPP and install the handler.
EventTypeSpec cmdEvent = { kEventClassCommand, kEventCommandProcess };
EventHandlerUPP handler = NewEventHandlerUPP( PickMonitorHandler );
InstallWindowEventHandler( theWindow, handler, 1, &cmdEvent, theWindow, NULL );
// Show the window
if (parentWindow)
ShowSheetWindow( theWindow, parentWindow );
else
ShowWindow( theWindow );
// Now we run modally. We will remain here until the PrefHandler
// calls QuitAppModalLoopForWindow if the user clicks OK or
// Cancel.
RunAppModalLoopForWindow( theWindow );
// OK, we're done. Dispose of our window and our UPP.
// We do the UPP last because DisposeWindow can send out
// CarbonEvents, and we haven't explicitly removed our
// handler. If we disposed the UPP, the Toolbox might try
// to call it. That would be bad.
TearDownPickMonitorPane(monitorPane);
if (parentWindow)
HideSheetWindow( theWindow );
DisposeWindow( theWindow );
DisposeEventHandlerUPP( handler );
// Return settings to caller
if (sSelectedDevice != 0)
{
// Read back the controls
DMGetDisplayIDByGDevice (sSelectedDevice, &*inOutDisplayID, true);
return noErr;
}
else
return userCanceledErr;
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
{
unsigned long dwDMVer;
Gestalt(gestaltDisplayMgrVers, (long*)&dwDMVer);
if (GetCount() == 1 || dwDMVer >= 0x020000)
{
if (mode == wxDefaultVideoMode)
{
//#ifndef __DARWIN__
// Handle hDisplayState;
// if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
// {
// wxLogSysError(wxT("Could not lock display for display mode changing!"));
// return false;
// }
// wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
// DMEndConfigureDisplays(hDisplayState);
// return true;
//#else
//hmmmmm....
return true;
//#endif
}
//0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
//DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
//so we have to use this icky structure
VDSwitchInfoRec sMode;
memset(&sMode, 0, sizeof(VDSwitchInfoRec) );
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
wxASSERT(uppMLI);
DMModeInfoRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.pMode = &mode;
unsigned int i;
for(i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
if (sModeInfo.bMatched == true)
{
sMode = sModeInfo.sMode;
break;
}
}
if(i == nNumModes)
return false;
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
// For the really paranoid -
// unsigned long flags;
// Boolean bok;
// wxASSERT(noErr == DMCheckDisplayMode(m_priv->m_hndl, sMode.csData,
// sMode.csMode, &flags, NULL, &bok));
// wxASSERT(bok);
Handle hDisplayState;
if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
{
wxLogSysError(wxT("Could not lock display for display mode changing!"));
return false;
}
unsigned long dwBPP = (unsigned long) mode.bpp;
if (DMSetDisplayMode(m_priv->m_hndl, sMode.csData,
(unsigned long*) &(dwBPP), NULL
//(unsigned long) &sMode
, hDisplayState
) != noErr)
{
DMEndConfigureDisplays(hDisplayState);
wxMessageBox(wxString::Format(wxT("Could not set the display mode")));
return false;
}
DMEndConfigureDisplays(hDisplayState);
}
else //DM 1.0, 1.2, 1.x
{
wxLogSysError(wxString::Format(wxT("Monitor gravitation not supported yet. dwDMVer:%u"),
(unsigned int) dwDMVer));
return false;
}
return true;
}
void CheckOpenGLCaps (CGDisplayCount maxDspys,
GLCaps dCaps[],
CGDisplayCount * dCnt)
{
CGLContextObj curr_ctx = 0;
CGDirectDisplayID dspys[32];
CGDisplayErr err;
unsigned short i;
short size = sizeof (GLCaps);
// no devices
*dCnt = 0;
if (maxDspys == 0) { // find number of displays
*dCnt = 0;
err = CGGetActiveDisplayList (32, dspys, dCnt);
if (err) // err 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;
err = CGGetActiveDisplayList(maxDspys, dspys, dCnt);
if (err) return; // err 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);
}
{ // find gDevice device by bounds
GDHandle hGD;
for (hGD = GetDeviceList (); hGD; hGD = GetNextDevice (hGD))
{
if (!TestDeviceAttribute (hGD, screenDevice) ||
!TestDeviceAttribute (hGD, screenActive))
continue;
// if postion and sizes match
if (((*hGD)->gdRect.top == dCaps[i].deviceOriginY) &&
((*hGD)->gdRect.left == dCaps[i].deviceOriginX) &&
(((*hGD)->gdRect.bottom - (*hGD)->gdRect.top) ==
dCaps[i].deviceHeight) &&
(((*hGD)->gdRect.right - (*hGD)->gdRect.left) ==
dCaps[i].deviceWidth)) {
dCaps[i].hGDevice = hGD;
break;
}
}
if (dCaps[i].hGDevice == NULL)
return; // err
if (noErr != DMGetDisplayIDByGDevice (dCaps[i].hGDevice,
&dCaps[i].displayID, false))
dCaps[i].displayID = 0; // err getting display ID
}
{ // get renderer info based on gDevice
CGLRendererInfoObj info;
long j, numRenderers = 0, rv = 0;
err = (CGLError)0;
err = CGLQueryRendererInfo (dCaps[i].cglDisplayMask,
&info,
&numRenderers);
if (0 == err) {
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,
(long *)&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[] = { (CGLPixelFormatAttribute)kCGLPFADisplayMask,
(CGLPixelFormatAttribute)dCaps[i].cglDisplayMask,
(CGLPixelFormatAttribute)NULL };
CGLPixelFormatObj pixelFormat = NULL;
long 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, (const char*)strRend, 255);
strVend = glGetString (GL_VENDOR);
strncpy (dCaps[i].strRendererVendor, (const char*)strVend, 255);
strVers = glGetString (GL_VERSION);
strncpy (dCaps[i].strRendererVersion, (const 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].fBlendEqSep =
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].fPointSprite =
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*)(const GLubyte*)"GL_ARB_imaging", strExt);
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
}
}
}