PsychError SCREENRect(void)
{
PsychWindowRecordType *windowRecord;
int screenNumber;
PsychRectType rect;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(1)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //Insist that the argument be present.
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
if(PsychIsScreenNumberArg(1)){
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
PsychGetScreenRect(screenNumber, rect);
PsychCopyOutRectArg(1, FALSE, rect);
}else if(PsychIsWindowIndexArg(1)){
PsychAllocInWindowRecordArg(1, TRUE, &windowRecord);
PsychOSProcessEvents(windowRecord, 0);
PsychCopyOutRectArg(1,FALSE, windowRecord->clientrect);
}else
PsychErrorExitMsg(PsychError_user, "Argument was recognized as neither a window index nor a screen pointer");
return(PsychError_none);
}
void PsychGetGlobalScreenRect(int screenNumber, double *rect)
{
// Create an empty rect:
PsychMakeRect(rect, 0, 0, 1, 1);
// Fill it with meaning by PsychGetScreenRect():
PsychGetScreenRect(screenNumber, rect);
}
/*
PsychGetVideoSettings()
Fills a structure describing the screen settings such as x, y, depth, frequency, etc.
Consider inverting the calling sequence so that this function is at the bottom of call hierarchy.
*/
void PsychGetScreenSettings(int screenNumber, PsychScreenSettingsType *settings)
{
settings->screenNumber=screenNumber;
PsychGetScreenRect(screenNumber, settings->rect);
PsychInitDepthStruct(&(settings->depth));
PsychGetScreenDepth(screenNumber, &(settings->depth));
settings->mode=PsychGetColorModeFromDepthStruct(&(settings->depth));
settings->nominalFrameRate=PsychGetNominalFramerate(screenNumber);
//settings->dacbits=PsychGetDacBits(screenNumber);
}
PsychError SCREENWindowSize(void)
{
PsychWindowRecordType *windowRecord;
int screenNumber;
PsychRectType rect;
double rectWidth, rectHeight;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()) {
PsychGiveHelp();
return(PsychError_none);
};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(1)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //Insist that the argument be present.
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
if(PsychIsScreenNumberArg(1)) {
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
PsychGetScreenRect(screenNumber, rect);
rectWidth=PsychGetWidthFromRect(rect);
rectHeight=PsychGetHeightFromRect(rect);
PsychCopyOutDoubleArg(1, kPsychArgOptional, rectWidth);
PsychCopyOutDoubleArg(2, kPsychArgOptional, rectHeight);
} else if(PsychIsWindowIndexArg(1)) {
PsychAllocInWindowRecordArg(1, TRUE, &windowRecord);
PsychOSProcessEvents(windowRecord, 0);
rectWidth=PsychGetWidthFromRect(windowRecord->rect);
rectHeight=PsychGetHeightFromRect(windowRecord->rect);
if (windowRecord->specialflags & kPsychHalfWidthWindow) {
// Special case for stereo: Only half the real window width:
rectWidth = rectWidth / 2;
}
if (windowRecord->specialflags & kPsychHalfHeightWindow) {
// Special case for stereo: Only half the real window width:
rectHeight = rectHeight / 2;
}
PsychCopyOutDoubleArg(1, kPsychArgOptional, rectWidth);
PsychCopyOutDoubleArg(2, kPsychArgOptional, rectHeight);
} else
PsychErrorExitMsg(PsychError_user, "Argument was recognized as neither a window index nor a screen pointer");
return(PsychError_none);
}
PsychError SCREENOpenWindow(void)
{
int screenNumber, numWindowBuffers, stereomode, multiSample, imagingmode;
PsychRectType rect, screenrect;
PsychColorType color;
PsychColorModeType mode;
boolean isArgThere, settingsMade, didWindowOpen, useAGL;
PsychScreenSettingsType screenSettings;
PsychWindowRecordType *windowRecord;
double dVals[4];
PsychDepthType specifiedDepth, possibleDepths, currentDepth, useDepth;
int dummy1;
double dummy2, dummy3, dummy4;
Boolean EmulateOldPTB = PsychPrefStateGet_EmulateOldPTB();
//just for debugging
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering SCREENOpen\n");
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the number of inputs
PsychErrorExit(PsychCapNumInputArgs(8)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the screen number from the windowPtrOrScreenNumber. This also checks to make sure that the specified screen exists.
PsychCopyInScreenNumberArg(kPsychUseDefaultArgPosition, TRUE, &screenNumber);
if(screenNumber==-1)
PsychErrorExitMsg(PsychError_user, "The specified onscreen window has no ancestral screen.");
/*
The depth checking is ugly because of this stupid depth structure stuff.
Instead get a descriptor of the current video settings, change the depth field,
and pass it to a validate function wich searches a list of valid video modes for the display.
There seems to be no point in checking the depths alone because the legality of a particular
depth depends on the other settings specified below. Its probably best to wait until we have
digested all settings and then test the full mode, declarin an invalid
mode and not an invalid pixel size. We could notice when the depth alone is specified
and in that case issue an invalid depth value.
*/
//find the PixelSize first because the color specifier depends on the screen depth.
PsychInitDepthStruct(¤tDepth); //get the current depth
PsychGetScreenDepth(screenNumber, ¤tDepth);
PsychInitDepthStruct(&possibleDepths); //get the possible depths
PsychGetScreenDepths(screenNumber, &possibleDepths);
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_WINDOWS
// MK Experimental Hack: Add the special depth values 64 and 128 to the depth struct. This should
// allows for 16 bpc, 32 bpc floating point color buffers on the latest ATI and NVidia hardware.
// "Should" means: It doesn't really work with any current driver, but we leave the testcode in
// in the hope for future OS and driver releases ;-)
// Unfortunately at this point of the init sequence, we are not able
// to check if these formats are supported by the hardware. Ugly ugly ugly...
PsychAddValueToDepthStruct(64, &possibleDepths);
PsychAddValueToDepthStruct(128, &possibleDepths);
#endif
// #if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
// On MacOS/X and Linux with ATI Radeon X1000/HD2000/HD3000 hardware and the special
// kernel support driver installed, we should be able to configure the hardwares
// framebuffers into ABGR2101010 mode, ie. 2 bits alpha, 10 bpc for red, green, blue.
// This needs support from the imaging pipeline, or manually converted stimuli, as
// the GPU doesn't format pixel data properly, only the CRTC scans out in that format.
// Anyway, allow this setting on OS/X and Linux:
// Update: Some FireGL cards (2008 and later) claim to support this on MS-Windows. Enable
// this option on Windows as well, so it is at least testable:
PsychAddValueToDepthStruct(30, &possibleDepths);
// #endif
PsychInitDepthStruct(&specifiedDepth); //get the requested depth and validate it.
isArgThere = PsychCopyInSingleDepthArg(4, FALSE, &specifiedDepth);
PsychInitDepthStruct(&useDepth);
if(isArgThere){ //if the argument is there check that the screen supports it...
if(!PsychIsMemberDepthStruct(&specifiedDepth, &possibleDepths))
PsychErrorExit(PsychError_invalidDepthArg);
else
PsychCopyDepthStruct(&useDepth, &specifiedDepth);
}else //otherwise use the default
PsychCopyDepthStruct(&useDepth, ¤tDepth);
// Initialize the rect argument to the screen rectangle:
PsychGetScreenRect(screenNumber, rect); //get the rect describing the screen bounds. This is the default Rect.
// Override it with a user supplied rect, if one was supplied:
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect );
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "OpenWindow called with invalid (empty) rect argument.");
if (PSYCH_SYSTEM == PSYCH_OSX) {
// OS/X system: Need to decide if we use a Carbon window + AGL
// or a fullscreen context with CGL:
// Default to AGL, switch to CGL if below constraints are met:
useAGL = TRUE;
// Window rect provided which has a different size than screen?
// We do not use windowed mode if the provided window rectangle either
// matches the target screens rectangle (and therefore its exact size)
// or its screens global rectangle.
PsychGetScreenRect(screenNumber, screenrect);
if (PsychMatchRect(screenrect, rect)) useAGL=FALSE;
PsychGetGlobalScreenRect(screenNumber, screenrect);
if (PsychMatchRect(screenrect, rect)) useAGL=FALSE;
// Override for use on f$%#$Fd OS/X 10.5.3 - 10.5.6 with NVidia GF 8800 GPU's:
if (PsychPrefStateGet_ConserveVRAM() & kPsychUseAGLCompositorForFullscreenWindows) useAGL = TRUE;
}
else {
// Non OS/X system: Do not use AGL ;-)
useAGL = FALSE;
}
//find the number of specified buffers.
//OS X: The number of backbuffers is not a property of the display mode but an attribute of the pixel format.
// Therefore the value is held by a window record and not a screen record.
numWindowBuffers=2;
PsychCopyInIntegerArg(5,FALSE,&numWindowBuffers);
if(numWindowBuffers < 1 || numWindowBuffers > kPsychMaxNumberWindowBuffers) PsychErrorExit(PsychError_invalidNumberBuffersArg);
// MK: Check for optional spec of stereoscopic display: 0 (the default) = monoscopic viewing.
// 1 == Stereo output via OpenGL built-in stereo facilities: This will drive any kind of
// stereo display hardware that is directly supported by MacOS-X.
// 2/3 == Stereo output via compressed frame output: Only one backbuffer is used for both
// views: The left view image is put into the top-half of the screen, the right view image
// is put into the bottom half of the screen. External hardware demangles this combi-image
// again into two separate images. CrystalEyes seems to be able to do this. One looses half
// of the vertical resolution, but potentially gains refresh rate...
// Future PTB version may include different stereo algorithms with an id > 1, e.g.,
// anaglyph stereo, interlaced stereo, ...
stereomode=0;
PsychCopyInIntegerArg(6,FALSE,&stereomode);
if(stereomode < 0 || stereomode > 10) PsychErrorExitMsg(PsychError_user, "Invalid stereomode provided (Valid between 0 and 10).");
if (stereomode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, stereo display functions are not supported in OS-9 PTB emulation mode.");
multiSample=0;
PsychCopyInIntegerArg(7,FALSE,&multiSample);
if(multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid multisample value provided (Valid are positive numbers >= 0).");
if (multiSample!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, anti-aliasing functions are not supported in OS-9 PTB emulation mode.");
imagingmode=0;
PsychCopyInIntegerArg(8,FALSE,&imagingmode);
if(imagingmode < 0) PsychErrorExitMsg(PsychError_user, "Invalid imaging mode provided (See 'help PsychImagingMode' for usage info).");
if (imagingmode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, imaging pipeline functions are not supported in OS-9 PTB emulation mode.");
// We require use of the imaging pipeline if stereomode for dualwindow display is requested.
// This makes heavy use of FBO's and blit operations, so imaging pipeline is needed.
if (stereomode==kPsychDualWindowStereo) {
// Dual window stereo requested, but imaging pipeline not enabled. Enable it:
imagingmode|= kPsychNeedFastBackingStore;
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Trying to enable imaging pipeline for dual-window stereo display mode...\n");
}
//set the video mode to change the pixel size. TO DO: Set the rect and the default color
PsychGetScreenSettings(screenNumber, &screenSettings);
PsychInitDepthStruct(&(screenSettings.depth));
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Here is where all the work goes on:
// If the screen is not already captured then to that:
if(!PsychIsScreenCaptured(screenNumber) && !useAGL) {
PsychCaptureScreen(screenNumber);
// We disable the call to PsychSetScreenSettings here: Its not useful, as it
// could only change color depth - which is something we don't want to do anyway here.
// If people want to change displays settings, they should use Screen('Resolution') instead,
// which is a more clever interface to PsychSetScreenSettings().
// settingsMade=PsychSetScreenSettings(screenNumber, &screenSettings);
//Capturing the screen and setting its settings always occur in conjunction
//There should be a check above to see if the display is captured and openWindow is attempting to chang
//the bit depth
}
#if PSYCH_SYSTEM == PSYCH_WINDOWS
// On M$-Windows we currently only support - and therefore require >= 30 bpp color depth.
if (PsychGetScreenDepthValue(screenNumber) < 30) {
// Display running at less than 30 bpp. OpenWindow will fail on M$-Windows anyway, so let's abort
// now.
// Output warning text:
printf("PTB-ERROR: Your display screen %i is not running at the required color depth of at least 30 bit.\n", screenNumber);
printf("PTB-ERROR: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-ERROR: This will not work on Microsoft Windows operating systems.\n");
printf("PTB-ERROR: Please use the 'Display settings' control panel of Windows to change the color depth to\n");
printf("PTB-ERROR: 32 bits per pixel ('True color' or 'Highest' setting) and then retry. It may be neccessary\n");
printf("PTB-ERROR: to restart Matlab after applying the change...\n");
fflush(NULL);
// Release the captured screen:
PsychRestoreScreenSettings(screenNumber);
PsychReleaseScreen(screenNumber);
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// Abort with Matlab error:
PsychErrorExitMsg(PsychError_user, "Insufficient color depth setting for display device (smaller than 30 bpp).");
}
#endif
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering PsychOpenOnscreenWindow\n");
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Create the onscreen window and perform initialization of everything except
// imaging pipeline and a few other special quirks. If sharedContextWindow is non-NULL,
// the new window will share its OpenGL context ressources with sharedContextWindow.
// This is typically used for dual-window stereo mode. Btw. If imaging pipeline is really
// active, we force multiSample to zero: This way the system backbuffer / pixelformat
// is enabled without multisampling support, as we do all the multisampling stuff ourselves
// within the imaging pipeline with multisampled drawbuffer FBO's...
didWindowOpen=PsychOpenOnscreenWindow(&screenSettings, &windowRecord, numWindowBuffers, stereomode, rect, ((imagingmode==0 || imagingmode==kPsychNeedFastOffscreenWindows) ? multiSample : 0), sharedContextWindow);
if (!didWindowOpen) {
if (!useAGL) {
PsychRestoreScreenSettings(screenNumber);
PsychReleaseScreen(screenNumber);
}
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// We use this dirty hack to exit with an error, but without printing
// an error message. The specific error message has been printed in
// PsychOpenOnscreenWindow() already..
PsychErrMsgTxt("");
}
// Sufficient display depth for full alpha-blending and such?
if (PsychGetScreenDepthValue(screenNumber) < 24) {
// Nope. Output a little warning.
printf("PTB-WARNING: Your display screen %i is not running at 24 bit color depth or higher.\n", screenNumber);
printf("PTB-WARNING: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-WARNING: This could cause failure to work correctly or visual artifacts in stimuli\n");
printf("PTB-WARNING: that involve Alpha-Blending. It can also cause drastically reduced color resolution\n");
printf("PTB-WARNING: for your stimuli! Please try to switch your display to 'True Color' (Windows)\n");
printf("PTB-WARNING: our 'Millions of Colors' (MacOS-X) to get rid of this warning and the visual artifacts.\n");
fflush(NULL);
}
// Define clear color: This depends on the color range of our onscreen window...
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color); //get from user
if(!isArgThere) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(windowRecord)); //or use the default
PsychCoerceColorMode(&color);
// Special setup code for dual window stereomode:
if (stereomode == kPsychDualWindowStereo) {
if (sharedContextWindow) {
// This is creation & setup of the slave onscreen window, ie. the one
// representing the right-eye view. This window doesn't do much. It
// is not used or referenced in the users experiment script. It receives
// its final image content during Screen('Flip') operation of the master
// onscreen window, then gets flipped in sync with the master window.
// Ok, we already have the slave window open and it shares its OpenGL context
// with the master window. Reset its internal reference to the master:
windowRecord->slaveWindow = NULL;
// Reset imagingmode for this window prior to imaging pipeline setup. This
// window is totally passive so it doesn't need the imaging pipeline.
imagingmode = 0;
// Assign this window to the master window as a slave:
sharedContextWindow->slaveWindow = windowRecord;
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// Activate the IdentitiyBlitChain for the slave window and add a single identity blit
// operation to it: This is needed in PsychPreFlipOperations() for final copy of stimulus
// image into this slave window:
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "IdentityBlitChain", "Builtin:IdentityBlit", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "IdentityBlitChain");
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Created master-slave window relationship for dual-window stereo display mode...\n");
// Special config finished. The master-slave combo should work from now on...
}
else {
// This is initial setup & creation of the master onscreen window, ie. the one
// representing the left-eye view and doing all the heavy work, acting as a
// proxy for both windows.
// Not much to do here. Just store its windowRecord as a reference for creation
// of the slave window. We'll need it for that purpose...
sharedContextWindow = windowRecord;
}
}
// Set special half-width flag for window if we are either in a dual-display/dual-view stereo mode or if
// if is requested as part of the imagingMode flag. This will cause PTB 2D drawing routines and window size
// query routines etc. to return an effective window width or window rect only half the real width.
if (windowRecord->stereomode==kPsychFreeFusionStereo || windowRecord->stereomode==kPsychFreeCrossFusionStereo || (imagingmode & kPsychHalfWidthWindow)) {
windowRecord->specialflags = windowRecord->specialflags | kPsychHalfWidthWindow;
imagingmode = imagingmode & (~kPsychHalfWidthWindow);
}
// Similar handling for windows of half the real height, except that none of our built-in stereo modes requires these,
// so this is only done on request from external code via the imagingmode flag kPsychHalfHeightWindow.
// One use of this is when using interleaved line stereo mode (PsychImaging(...'InterleavedLineStereo')) where windows
// only have a useable net height of half their physical height:
if (imagingmode & kPsychHalfHeightWindow) {
windowRecord->specialflags = windowRecord->specialflags | kPsychHalfHeightWindow;
imagingmode = imagingmode & (~kPsychHalfHeightWindow);
}
// Initialize internal image processing pipeline if requested:
PsychInitializeImagingPipeline(windowRecord, imagingmode, multiSample);
// On OS-X, if we are in quad-buffered frame sequential stereo mode, we automatically generate
// blue-line-sync style sync lines for use with stereo shutter glasses. We don't do this
// by default on Windows or Linux: These systems either don't have stereo capable hardware,
// or they have some and its drivers already take care of sync signal generation.
if ((PSYCH_SYSTEM == PSYCH_OSX) && (windowRecord->stereomode==kPsychOpenGLStereo)) {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Enabling internal blue line sync renderer for quad-buffered stereo...\n");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "LeftFinalizerBlitChain", "Builtin:RenderStereoSyncLine", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "LeftFinalizerBlitChain");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "RightFinalizerBlitChain", "Builtin:RenderStereoSyncLine", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "RightFinalizerBlitChain");
}
// Activate new onscreen window for userspace drawing: If imaging pipeline is active, this
// will bind the correct rendertargets for the first time:
PsychSetDrawingTarget(windowRecord);
// Set the clear color and perform a backbuffer-clear:
PsychConvertColorToDoubleVector(&color, windowRecord, windowRecord->clearColor);
PsychGLClear(windowRecord);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// Make sure no OpenGL errors happened up to this point:
PsychTestForGLErrors();
// If we are in logo-startup mode (former blue-screen mode) and double-buffering
// is enabled, then do an initial bufferswap & clear, so the display starts in
// the user selected background color instead of staying at the blue screen or
// logo display until the Matlab script first calls 'Flip'.
if ((PsychPrefStateGet_VisualDebugLevel()>=4) && numWindowBuffers>=2) {
// Do immediate bufferswap by an internal call to Screen('Flip'). This will also
// take care of clearing the backbuffer in preparation of first userspace drawing
// commands and such...
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
// Display now shows background color, so user knows that PTB's 'OpenWindow'
// procedure is successfully finished.
}
PsychTestForGLErrors();
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
// rect argument needs special treatment in stereo mode:
PsychMakeRect(&rect, windowRecord->rect[kPsychLeft], windowRecord->rect[kPsychTop],
windowRecord->rect[kPsychLeft] + PsychGetWidthFromRect(windowRecord->rect)/((windowRecord->specialflags & kPsychHalfWidthWindow) ? 2 : 1),
windowRecord->rect[kPsychTop] + PsychGetHeightFromRect(windowRecord->rect)/((windowRecord->specialflags & kPsychHalfHeightWindow) ? 2 : 1));
PsychCopyOutRectArg(2, FALSE, rect);
return(PsychError_none);
}
PsychError SCREENOpenWindow(void)
{
int screenNumber, numWindowBuffers, stereomode, multiSample, imagingmode;
PsychRectType rect;
PsychColorType color;
PsychColorModeType mode;
boolean isArgThere, settingsMade, didWindowOpen;
PsychScreenSettingsType screenSettings;
PsychWindowRecordType *windowRecord;
double dVals[4];
PsychDepthType specifiedDepth, possibleDepths, currentDepth, useDepth;
int dummy1;
double dummy2, dummy3, dummy4;
Boolean EmulateOldPTB = PsychPrefStateGet_EmulateOldPTB();
//just for debugging
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering SCREENOpen\n");
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the number of inputs
PsychErrorExit(PsychCapNumInputArgs(8)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the screen number from the windowPtrOrScreenNumber. This also checks to make sure that the specified screen exists.
PsychCopyInScreenNumberArg(kPsychUseDefaultArgPosition, TRUE, &screenNumber);
if(screenNumber==-1)
PsychErrorExitMsg(PsychError_user, "The specified offscreen window has no ancestral screen.");
/*
The depth checking is ugly because of this stupid depth structure stuff.
Instead get a descriptor of the current video settings, change the depth field,
and pass it to a validate function wich searches a list of valid video modes for the display.
There seems to be no point in checking the depths alone because the legality of a particular
depth depends on the other settings specified below. Its probably best to wait until we have
digested all settings and then test the full mode, declarin an invalid
mode and not an invalid pixel size. We could notice when the depth alone is specified
and in that case issue an invalid depth value.
*/
//find the PixelSize first because the color specifier depends on the screen depth.
PsychInitDepthStruct(¤tDepth); //get the current depth
PsychGetScreenDepth(screenNumber, ¤tDepth);
PsychInitDepthStruct(&possibleDepths); //get the possible depths
PsychGetScreenDepths(screenNumber, &possibleDepths);
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_WINDOWS
// MK Experimental Hack: Add the special depth values 30, 64 and 128 to the depth struct. This allows for
// 10 bpc color buffers and 16 bpc, 32 bpc floating point color buffers on the latest ATI
// and NVidia hardware. Unfortunately at this point of the init sequence, we are not able
// to check if these formats are supported by the hardware. Ugly ugly ugly...
PsychAddValueToDepthStruct(30, &possibleDepths);
PsychAddValueToDepthStruct(64, &possibleDepths);
PsychAddValueToDepthStruct(128, &possibleDepths);
#endif
PsychInitDepthStruct(&specifiedDepth); //get the requested depth and validate it.
isArgThere = PsychCopyInSingleDepthArg(4, FALSE, &specifiedDepth);
PsychInitDepthStruct(&useDepth);
if(isArgThere){ //if the argument is there check that the screen supports it...
if(!PsychIsMemberDepthStruct(&specifiedDepth, &possibleDepths))
PsychErrorExit(PsychError_invalidDepthArg);
else
PsychCopyDepthStruct(&useDepth, &specifiedDepth);
}else //otherwise use the default
PsychCopyDepthStruct(&useDepth, ¤tDepth);
//find the rect.
PsychGetScreenRect(screenNumber, rect); //get the rect describing the screen bounds. This is the default Rect.
// Override it with a user supplied rect, if one was supplied:
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect );
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "OpenWindow called with invalid (empty) rect argument.");
//find the number of specified buffers.
//OS X: The number of backbuffers is not a property of the display mode but an attribute of the pixel format.
// Therefore the value is held by a window record and not a screen record.
numWindowBuffers=2;
PsychCopyInIntegerArg(5,FALSE,&numWindowBuffers);
if(numWindowBuffers < 1 || numWindowBuffers > kPsychMaxNumberWindowBuffers) PsychErrorExit(PsychError_invalidNumberBuffersArg);
// MK: Check for optional spec of stereoscopic display: 0 (the default) = monoscopic viewing.
// 1 == Stereo output via OpenGL built-in stereo facilities: This will drive any kind of
// stereo display hardware that is directly supported by MacOS-X.
// 2/3 == Stereo output via compressed frame output: Only one backbuffer is used for both
// views: The left view image is put into the top-half of the screen, the right view image
// is put into the bottom half of the screen. External hardware demangles this combi-image
// again into two separate images. CrystalEyes seems to be able to do this. One looses half
// of the vertical resolution, but potentially gains refresh rate...
// Future PTB version may include different stereo algorithms with an id > 1, e.g.,
// anaglyph stereo, interlaced stereo, ...
stereomode=0;
PsychCopyInIntegerArg(6,FALSE,&stereomode);
if(stereomode < 0 || stereomode > 9) PsychErrorExitMsg(PsychError_user, "Invalid stereomode provided (Valid between 0 and 9).");
if (stereomode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, stereo display functions are not supported in OS-9 PTB emulation mode.");
multiSample=0;
PsychCopyInIntegerArg(7,FALSE,&multiSample);
if(multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid multisample value provided (Valid are positive numbers >= 0).");
if (multiSample!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, anti-aliasing functions are not supported in OS-9 PTB emulation mode.");
imagingmode=0;
PsychCopyInIntegerArg(8,FALSE,&imagingmode);
if(imagingmode < 0) PsychErrorExitMsg(PsychError_user, "Invalid imaging mode provided (See 'help PsychImagingMode' for usage info).");
if (imagingmode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, imaging pipeline functions are not supported in OS-9 PTB emulation mode.");
//set the video mode to change the pixel size. TO DO: Set the rect and the default color
PsychGetScreenSettings(screenNumber, &screenSettings);
PsychInitDepthStruct(&(screenSettings.depth));
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Here is where all the work goes on:
// If the screen is not already captured then to that:
if(~PsychIsScreenCaptured(screenNumber)) {
PsychCaptureScreen(screenNumber);
settingsMade=PsychSetScreenSettings(screenNumber, &screenSettings);
//Capturing the screen and setting its settings always occur in conjunction
//There should be a check above to see if the display is captured and openWindow is attempting to chang
//the bit depth
}
#if PSYCH_SYSTEM == PSYCH_WINDOWS
// On M$-Windows we currently only support - and therefore require >= 30 bpp color depth.
if (PsychGetScreenDepthValue(screenNumber) < 30) {
// Display running at less than 30 bpp. OpenWindow will fail on M$-Windows anyway, so let's abort
// now.
// Release the captured screen:
PsychReleaseScreen(screenNumber);
// Output warning text:
printf("PTB-ERROR: Your display screen %i is not running at the required color depth of at least 30 bit.\n", screenNumber);
printf("PTB-ERROR: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-ERROR: This will not work on Microsoft Windows operating systems.\n");
printf("PTB-ERROR: Please use the 'Display settings' control panel of Windows to change the color depth to\n");
printf("PTB-ERROR: 32 bits per pixel ('True color' or 'Highest' setting) and then retry. It may be neccessary\n");
printf("PTB-ERROR: to restart Matlab after applying the change...\n");
fflush(NULL);
// Abort with Matlab error:
PsychErrorExitMsg(PsychError_user, "Insufficient color depth setting for display device (smaller than 30 bpp).");
}
#endif
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering PsychOpenOnscreenWindow\n");
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
didWindowOpen=PsychOpenOnscreenWindow(&screenSettings, &windowRecord, numWindowBuffers, stereomode, rect, multiSample);
if (!didWindowOpen) {
PsychReleaseScreen(screenNumber);
// We use this dirty hack to exit with an error, but without printing
// an error message. The specific error message has been printed in
// PsychOpenOnscreenWindow() already..
PsychErrMsgTxt("");
}
// Sufficient display depth for full alpha-blending and such?
if (PsychGetScreenDepthValue(screenNumber) < 24) {
// Nope. Output a little warning.
printf("PTB-WARNING: Your display screen %i is not running at 24 bit color depth or higher.\n", screenNumber);
printf("PTB-WARNING: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-WARNING: This could cause failure to work correctly or visual artifacts in stimuli\n");
printf("PTB-WARNING: that involve Alpha-Blending. It can also cause drastically reduced color resolution\n");
printf("PTB-WARNING: for your stimuli! Please try to switch your display to 'True Color' (Windows)\n");
printf("PTB-WARNING: our 'Millions of Colors' (MacOS-X) to get rid of this warning and the visual artifacts.\n");
fflush(NULL);
}
// Define clear color: This depends on the color range of our onscreen window...
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color); //get from user
if(!isArgThere) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(windowRecord)); //or use the default
PsychCoerceColorMode(&color);
// Initialize internal image processing pipeline if requested:
PsychInitializeImagingPipeline(windowRecord, imagingmode);
// On OS-X, if we are int quad-buffered frame sequential stereo mode, we automatically generate
// blue-line-sync style sync lines for use with stereo shutter glasses. We don't do this
// by default on Windows or Linux: These systems either don't have stereo capable hardware,
// or they have some and its drivers already take care of sync signal generation.
if ((PSYCH_SYSTEM == PSYCH_OSX) && (windowRecord->stereomode==kPsychOpenGLStereo)) {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Enabling internal blue line sync renderer for quad-buffered stereo...\n");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "LeftFinalizerBlitChain", "Builtin:RenderStereoSyncLine", TRUE, "");
PsychPipelineEnableHook(windowRecord, "LeftFinalizerBlitChain");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "RightFinalizerBlitChain", "Builtin:RenderStereoSyncLine", TRUE, "");
PsychPipelineEnableHook(windowRecord, "RightFinalizerBlitChain");
}
// Activate new onscreen window for userspace drawing: If imaging pipeline is active, this
// will bind the correct rendertargets for the first time:
PsychSetGLContext(windowRecord);
PsychSetDrawingTarget(windowRecord);
// Set the clear color and perform a backbuffer-clear:
PsychConvertColorToDoubleVector(&color, windowRecord, dVals);
glClearColor(dVals[0], dVals[1], dVals[2], dVals[3]);
glClear(GL_COLOR_BUFFER_BIT);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// Make sure no OpenGL errors happened up to this point:
PsychTestForGLErrors();
// If we are in logo-startup mode (former blue-screen mode) and double-buffering
// is enabled, then do an initial bufferswap & clear, so the display starts in
// the user selected background color instead of staying at the blue screen or
// logo display until the Matlab script first calls 'Flip'.
if ((PsychPrefStateGet_VisualDebugLevel()>=4) && numWindowBuffers>=2) {
// Do immediate bufferswap by an internal call to Screen('Flip'). This will also
// take care of clearing the backbuffer in preparation of first userspace drawing
// commands and such...
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
// Display now shows background color, so user knows that PTB's 'OpenWindow'
// procedure is successfully finished.
}
PsychTestForGLErrors();
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
// rect argument needs special treatment in stereo mode:
if (windowRecord->stereomode==kPsychFreeFusionStereo || windowRecord->stereomode==kPsychFreeCrossFusionStereo) {
// Special case for stereo: Only half the real window width:
PsychMakeRect(&rect, windowRecord->rect[kPsychLeft],windowRecord->rect[kPsychTop],
windowRecord->rect[kPsychLeft] + PsychGetWidthFromRect(windowRecord->rect)/2,windowRecord->rect[kPsychBottom]);
}
else {
// Normal case:
PsychMakeRect(&rect, windowRecord->rect[kPsychLeft],windowRecord->rect[kPsychTop],windowRecord->rect[kPsychRight],windowRecord->rect[kPsychBottom]);
}
PsychCopyOutRectArg(2, FALSE, rect);
return(PsychError_none);
}
PsychError SCREENOpenWindow(void)
{
int screenNumber, numWindowBuffers, stereomode;
PsychRectType rect;
PsychColorType color;
PsychColorModeType mode;
boolean isArgThere, settingsMade, didWindowOpen;
PsychScreenSettingsType screenSettings;
PsychWindowRecordType *windowRecord;
PsychDepthType specifiedDepth, possibleDepths, currentDepth, useDepth;
//just for debugging
//printf("Entering SCREENOpen\n");
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the number of inputs
PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the screen number from the windowPtrOrScreenNumber. This also checks to make sure that the specified screen exists.
PsychCopyInScreenNumberArg(kPsychUseDefaultArgPosition, TRUE, &screenNumber);
if(screenNumber==-1)
PsychErrorExitMsg(PsychError_user, "The specified offscreen window has no ancestral screen.");
/*
The depth checking is ugly because of this stupid depth structure stuff.
Instead get a descriptor of the current video settings, change the depth field,
and pass it to a validate function wich searches a list of valid video modes for the display.
There seems to be no point in checking the depths alone because the legality of a particular
depth depends on the other settings specified below. Its probably best to wait until we have
digested all settings and then test the full mode, declarin an invalid
mode and not an invalid pixel size. We could notice when the depth alone is specified
and in that case issue an invalid depth value.
*/
//find the PixelSize first because the color specifier depends on the screen depth.
PsychInitDepthStruct(¤tDepth); //get the current depth
PsychGetScreenDepth(screenNumber, ¤tDepth);
PsychInitDepthStruct(&possibleDepths); //get the possible depths
PsychGetScreenDepths(screenNumber, &possibleDepths);
PsychInitDepthStruct(&specifiedDepth); //get the requested depth and validate it.
isArgThere = PsychCopyInSingleDepthArg(4, FALSE, &specifiedDepth);
PsychInitDepthStruct(&useDepth);
if(isArgThere){ //if the argument is there check that the screen supports it...
if(!PsychIsMemberDepthStruct(&specifiedDepth, &possibleDepths))
PsychErrorExit(PsychError_invalidDepthArg);
else
PsychCopyDepthStruct(&useDepth, &specifiedDepth);
}else //otherwise use the default
PsychCopyDepthStruct(&useDepth, ¤tDepth);
//find the color. We do this here because the validity of this argument depends on the depth.
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color); //get from user
if(!isArgThere)
PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromDepthStruct(&useDepth)); //or use the default
mode=PsychGetColorModeFromDepthStruct(&useDepth);
PsychCoerceColorMode(mode, &color); //transparent if mode match, error exit if invalid conversion.
//find the rect.
PsychGetScreenRect(screenNumber, rect); //get the rect describing the screen bounds. This is the default Rect.
if(!kPsychAllWindowsFull)
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect );
//find the number of specified buffers.
//OS X: The number of backbuffers is not a property of the display mode but an attribute of the pixel format.
// Therefore the value is held by a window record and not a screen record.
numWindowBuffers=2;
PsychCopyInIntegerArg(5,FALSE,&numWindowBuffers);
if(numWindowBuffers < 1 || numWindowBuffers > kPsychMaxNumberWindowBuffers)
PsychErrorExit(PsychError_invalidNumberBuffersArg);
// MK: Check for optional spec of stereoscopic display: 0 (the default) = monoscopic viewing.
// 1 == Stereo output via OpenGL built-in stereo facilities: This will drive any kind of
// stereo display hardware that is directly supported by MacOS-X.
// 2/3 == Stereo output via compressed frame output: Only one backbuffer is used for both
// views: The left view image is put into the top-half of the screen, the right view image
// is put into the bottom half of the screen. External hardware demangles this combi-image
// again into two separate images. CrystalEyes seems to be able to do this. One looses half
// of the vertical resolution, but potentially gains refresh rate...
// Future PTB version may include different stereo algorithms with an id > 1, e.g.,
// anaglyph stereo, interlaced stereo, ...
stereomode=0;
PsychCopyInIntegerArg(6,FALSE,&stereomode);
if(stereomode < 0 || stereomode > 1) PsychErrorExitMsg(PsychError_user, "Invalid stereomode provided (Valid between 0 and 9).");
//set the video mode to change the pixel size. TO DO: Set the rect and the default color
PsychGetScreenSettings(screenNumber, &screenSettings);
PsychInitDepthStruct(&(screenSettings.depth));
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
//Here is where all the work goes on
//if the screen is not already captured then to that
if(~PsychIsScreenCaptured(screenNumber)){
PsychCaptureScreen(screenNumber);
settingsMade=PsychSetScreenSettings(screenNumber, &screenSettings);
//Capturing the screen and setting its settings always occur in conjunction.
//There should be a check above to see if the display is captured and openWindow is attempting to change
//the bit depth.
}
didWindowOpen=PsychOpenOnscreenWindow(&screenSettings, &windowRecord, numWindowBuffers, stereomode);
if(!didWindowOpen){
PsychReleaseScreen(screenNumber);
// We use this dirty hack to exit with an error, but without printing
// an error message. The specific error message has been printed in
// PsychOpenOnscreenWindow() already...
PsychErrMsgTxt("");
}
//create the shadow texture for this window
PsychCreateTextureForWindow(windowRecord);
//set the alpha blending rule
PsychSetGLContext(windowRecord);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// sFactor dFactor
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
PsychCopyOutRectArg(2, FALSE, rect);
return(PsychError_none);
}
PsychError SCREENOpenOffscreenWindow(void)
{
int screenNumber, depth, targetScreenNumber;
PsychRectType rect;
PsychColorType color;
PsychWindowRecordType *exampleWindowRecord, *windowRecord, *targetWindow;
psych_bool wasColorSupplied;
char* texturePointer;
size_t xSize, ySize, nbytes;
psych_bool bigendian;
GLubyte *rpb;
int ix;
GLenum fboInternalFormat;
psych_bool needzbuffer;
psych_bool overridedepth = FALSE;
int usefloatformat = 0;
int specialFlags = 0;
int multiSample = 0;
// Detect endianity (byte-order) of machine:
ix=255;
rpb=(GLubyte*) &ix;
bigendian = ( *rpb == 255 ) ? FALSE : TRUE;
ix = 0; rpb = NULL;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the number of inputs
PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//1-User supplies a window ptr 2-User supplies a screen number 3-User supplies rect and pixel size
if(PsychIsWindowIndexArg(1)){
PsychAllocInWindowRecordArg(1, TRUE, &exampleWindowRecord);
// Assign normalized copy of example windows rect -- Top-Left corner is always (0,0)
PsychNormalizeRect(exampleWindowRecord->clientrect, rect);
// We copy depth only from exampleWindow if it is a offscreen window (=texture). Copying from
// onscreen windows doesn't make sense, e.g. depth=16 for onscreen means RGBA8 window, but it
// would map onto a LUMINANCE+ALPHA texture for the offscreen window! We always use 32 bit RGBA8
// in such a case.
depth=(PsychIsOffscreenWindow(exampleWindowRecord)) ? exampleWindowRecord->depth : 32;
// unless it is a FBO backed onscreen window in imaging mode: Then we can use the depth from it.
if (exampleWindowRecord->imagingMode & kPsychNeedFastBackingStore || exampleWindowRecord->imagingMode & kPsychNeedFastOffscreenWindows) depth = exampleWindowRecord->depth;
targetScreenNumber=exampleWindowRecord->screenNumber;
targetWindow=exampleWindowRecord;
} else if(PsychIsScreenNumberArg(1)){
PsychCopyInScreenNumberArg(1, TRUE, &screenNumber);
PsychGetScreenRect(screenNumber, rect);
depth=32; // Always use RGBA8 in this case! See above...
targetScreenNumber=screenNumber;
targetWindow=NULL;
} else if(PsychIsUnaffiliatedScreenNumberArg(1)){ //that means -1 or maybe also NaN if we add that option.
// Default to a depth of 32 bpp:
depth = 32;
targetWindow = NULL;
// Get first open onscreen window as target window:
PsychFindScreenWindowFromScreenNumber(kPsychUnaffiliatedWindow, &targetWindow);
if (targetWindow == NULL) PsychErrorExitMsg(PsychError_user, "Could not find any open onscreen window to act as parent for this offscreen window. Open an onscreen window first!");
targetScreenNumber = targetWindow->screenNumber;
PsychGetScreenRect(targetScreenNumber, rect);
} else {
targetScreenNumber = 0; // Make compiler happy.
PsychErrorExit(PsychError_invalidNumdex);
}
if (targetWindow==NULL) {
// Get target window of screen:
PsychFindScreenWindowFromScreenNumber(targetScreenNumber, &targetWindow);
if (targetWindow == NULL) PsychErrorExitMsg(PsychError_user, "Could not find any open onscreen window to act as parent for this offscreen window. Open an onscreen window first!");
targetScreenNumber = targetWindow->screenNumber;
}
//Depth and rect argument supplied as arguments override those inherited from reference screen or window.
//Note that PsychCopyIn* prefix means that value will not be overwritten if the arguments are not present.
PsychCopyInRectArg(3,FALSE, rect);
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "Invalid rect value provided: Empty rects are not allowed.");
// Copy in optional depth: This gets overriden in many ways if imaging pipeline is on:
if (PsychCopyInIntegerArg(4,FALSE, &depth)) overridedepth = TRUE;
// If any of the no longer supported values 0, 1, 2 or 4 is provided, we
// silently switch to 32 bits per pixel, which is the safest and fastest setting:
if (depth==0 || depth==1 || depth==2 || depth==4) depth=32;
// Final sanity check:
if (!(targetWindow->imagingMode & kPsychNeedFastOffscreenWindows) && !(targetWindow->imagingMode & kPsychNeedFastBackingStore) && (depth==64 || depth==128)) {
PsychErrorExitMsg(PsychError_user, "Invalid depth value provided. Must be 8 bpp, 16 bpp, 24 bpp or 32 bpp, unless you enable the imaging pipeline, which provides you with more options!");
}
if (depth!=8 && depth!=16 && depth!=24 && depth!=32 && depth!=64 && depth!=128) {
PsychErrorExitMsg(PsychError_user, "Invalid depth value provided. Must be 8 bpp, 16 bpp, 24 bpp, 32 bpp, or if imagingmode is enabled also 64 bpp or 128 bpp!");
}
// If the imaging pipeline is enabled for the associated onscreen window and fast backing store, aka FBO's
// is requested, then we only accept depths of at least 32 bit, i.e. RGBA windows. We override any lower
// precision spec. This is because some common hardware only supports rendering to RGBA textures, not to
// RGB, LA or Luminance textures.
if ((targetWindow->imagingMode & kPsychNeedFastBackingStore || targetWindow->imagingMode & kPsychNeedFastOffscreenWindows) && (depth < 32)) depth = 32;
// Find the color for the window background.
wasColorSupplied=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color);
// If none provided, use a proper white-value for this window:
if(!wasColorSupplied) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(targetWindow));
// Get the optional specialmode flag:
PsychCopyInIntegerArg(5, FALSE, &specialFlags);
// OpenGL-ES only supports GL_TEXTURE_2D targets, so enforce these via flags setting 1:
if (PsychIsGLES(targetWindow)) specialFlags |= 1;
// This command converts whatever color we got into RGBA format:
PsychCoerceColorMode(&color);
// printf("R=%i G=%i B=%i A=%i I=%i", color.value.rgba.r, color.value.rgba.g,color.value.rgba.b,color.value.rgba.a,color.value.index);
// First allocate the offscreen window record to store stuff into. If we exit with an error PsychErrorExit() should
// call PsychPurgeInvalidWindows which will clean up the window record.
PsychCreateWindowRecord(&windowRecord); // This also fills the window index field.
// This offscreen window is implemented as a Psychtoolbox texture:
windowRecord->windowType=kPsychTexture;
// We need to assign the screen number of the onscreen-window, so PsychCreateTexture()
// can query the size of the screen/onscreen-window...
windowRecord->screenNumber = targetScreenNumber;
// Assign the computed depth:
windowRecord->depth=depth;
// Default number of channels:
windowRecord->nrchannels=depth / 8;
// Assign the computed rect, but normalize it to start with top-left at (0,0):
PsychNormalizeRect(rect, windowRecord->rect);
// Client rect of an offscreen window is always == rect of it:
PsychCopyRect(windowRecord->clientrect, windowRecord->rect);
// Until here no OpenGL commands executed. Now we need a valid context: Set targetWindow
// as drawing target. This will perform neccessary context-switch and all backbuffer
// backup/restore/whatever operations to make sure we can do what we want without
// possibly screwing any offscreen windows and bindings:
if (PsychIsOnscreenWindow(targetWindow) || PsychIsOffscreenWindow(targetWindow)) {
// This is a possible on-/offscreen drawingtarget:
PsychSetDrawingTarget(targetWindow);
}
else {
// This must be a proxy-window object: Can't transition to it!
// But we can safe-reset the current drawingtarget...
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
// ...and then switch to the OpenGL context of the 'targetWindow' proxy object:
PsychSetGLContext(targetWindow);
// Ok, framebuffer and bindings are safe and disabled, context is set. We
// should be safe to continue with the proxy...
}
// From here on we have a defined context and state. We can detach the drawing target whenever
// we want, as everything is backed up somewhere for later reinit.
// Create offscreen window either new style as FBO, or old style as texture:
if ((targetWindow->imagingMode & kPsychNeedFastBackingStore) || (targetWindow->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Imaging mode for this window enabled: Use new way of creating the offscreen window:
// We safely unbind any FBO bindings and drawingtargets:
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
// Overriden for imagingmode: There we always have 4 channels...
windowRecord->nrchannels=4;
// Start off with standard 8 bpc fixed point:
fboInternalFormat = GL_RGBA8; windowRecord->depth=32; usefloatformat = 0;
// Need 16 bpc fixed point precision?
if (targetWindow->imagingMode & kPsychNeed16BPCFixed) {
fboInternalFormat = (targetWindow->gfxcaps & kPsychGfxCapSNTex16) ? GL_RGBA16_SNORM : GL_RGBA16;
windowRecord->depth=64;
usefloatformat = 0;
}
// Need 16 bpc floating point precision?
if (targetWindow->imagingMode & kPsychNeed16BPCFloat) { fboInternalFormat = GL_RGBA_FLOAT16_APPLE; windowRecord->depth=64; usefloatformat = 1; }
// Need 32 bpc floating point precision?
if (targetWindow->imagingMode & kPsychNeed32BPCFloat) { fboInternalFormat = GL_RGBA_FLOAT32_APPLE; windowRecord->depth=128; usefloatformat = 2; }
// Override depth value provided?
if (overridedepth) {
// Manual depth specified: Override with that depth:
switch(depth) {
case 32:
fboInternalFormat = GL_RGBA8; windowRecord->depth=32; usefloatformat = 0;
break;
case 64:
fboInternalFormat = GL_RGBA_FLOAT16_APPLE; windowRecord->depth=64; usefloatformat = 1;
// Need fallback for lack of float 16 support?
if (!(targetWindow->gfxcaps & kPsychGfxCapFPTex16) && !PsychIsGLES(targetWindow)) {
// Yes. Try 16 bit signed normalized texture instead:
if (PsychPrefStateGet_Verbosity() > 4)
printf("PTB-INFO:OpenOffscreenWindow: Code requested 16 bpc float precision, but this is unsupported. Trying to use 15 bit snorm precision instead.\n");
fboInternalFormat = GL_RGBA16_SNORM; windowRecord->depth=64; usefloatformat = 0;
if (!(targetWindow->gfxcaps & kPsychGfxCapSNTex16)) {
printf("PTB-ERROR:OpenOffscreenWindow: Code requested 16 bpc float precision, but this is unsupported by this graphics card.\n");
printf("PTB-ERROR:OpenOffscreenWindow: Tried to use 16 bit snorm format instead, but failed as this is unsupported as well.\n");
}
}
break;
case 128:
fboInternalFormat = GL_RGBA_FLOAT32_APPLE; windowRecord->depth=128; usefloatformat = 2;
break;
default:
fboInternalFormat = GL_RGBA8; windowRecord->depth=32; usefloatformat = 0;
}
}
// Floating point framebuffer on OpenGL-ES requested?
if (PsychIsGLES(targetWindow) && (usefloatformat > 0)) {
// Yes. We only support 32 bpc float framebuffers with alpha-blending. On less supportive hardware we fail:
if (!(targetWindow->gfxcaps & kPsychGfxCapFPTex32) || !(targetWindow->gfxcaps & kPsychGfxCapFPFBO32)) {
PsychErrorExitMsg(PsychError_user, "Sorry, the requested offscreen window color resolution of 32 bpc floating point is not supported by your graphics card. Game over.");
}
// Supported. Upgrade requested format to 32 bpc float, whatever it was before:
fboInternalFormat = GL_RGBA_FLOAT32_APPLE; windowRecord->depth=128; usefloatformat = 2;
}
// Do we need additional depth buffer attachments?
needzbuffer = (PsychPrefStateGet_3DGfx()>0) ? TRUE : FALSE;
// Copy in optional multiSample argument: It defaults to zero, aka multisampling disabled.
PsychCopyInIntegerArg(6, FALSE, &multiSample);
if (multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid negative multiSample level provided!");
// Multisampled anti-aliasing requested?
if (multiSample > 0) {
// Yep. Supported by GPU?
if (!(targetWindow->gfxcaps & kPsychGfxCapFBOMultisample)) {
// No. We fall back to non-multisampled mode:
multiSample = 0;
// Tell user if warnings enabled:
if (PsychPrefStateGet_Verbosity() > 1) {
printf("PTB-WARNING: You requested stimulus anti-aliasing via multisampling by setting the multiSample parameter of Screen('OpenOffscreenWindow', ...) to a non-zero value.\n");
printf("PTB-WARNING: You also requested use of the imaging pipeline. Unfortunately, your combination of operating system, graphics hardware and driver does not\n");
printf("PTB-WARNING: support simultaneous use of the imaging pipeline and multisampled anti-aliasing.\n");
printf("PTB-WARNING: Will therefore continue without anti-aliasing...\n\n");
printf("PTB-WARNING: A driver upgrade may resolve this issue. Users of MacOS-X need at least OS/X 10.5.2 Leopard for support on recent ATI hardware.\n\n");
}
}
}
// Allocate framebuffer object for this Offscreen window:
if (!PsychCreateFBO(&(windowRecord->fboTable[0]), fboInternalFormat, needzbuffer, (int) PsychGetWidthFromRect(rect), (int) PsychGetHeightFromRect(rect), multiSample, specialFlags)) {
// Failed!
PsychErrorExitMsg(PsychError_user, "Creation of Offscreen window in imagingmode failed for some reason :(");
}
// Assign this FBO as drawBuffer for mono channel of our Offscreen window:
windowRecord->drawBufferFBO[0] = 0;
windowRecord->fboCount = 1;
// Assign it as texture as well:
windowRecord->textureNumber = windowRecord->fboTable[0]->coltexid;
windowRecord->textureMemorySizeBytes = 0;
windowRecord->textureMemory = NULL;
windowRecord->texturetarget = (specialFlags & 0x1) ? GL_TEXTURE_2D : GL_TEXTURE_RECTANGLE_EXT;
windowRecord->surfaceSizeBytes = (size_t) (PsychGetWidthFromRect(rect) * PsychGetHeightFromRect(rect) * (windowRecord->depth / 8));
// Set bpc for FBO backed offscreen window:
windowRecord->bpc = (int) (windowRecord->depth / 4);
// Initial setup done, continues below after some shared code...
}
else {
// Traditional texture creation code:
// Special case for alpha-channel: DBL_MAX signals maximum alpha
// value requested. In our own code we need to manually map this to
// the maximum uint8 alpha value of 255:
if (color.value.rgba.a == DBL_MAX) color.value.rgba.a = 255;
// Allocate the texture memory:
// We only allocate the amount really needed for given format, aka numMatrixPlanes - Bytes per pixel.
xSize = (size_t) PsychGetWidthFromRect(rect);
ySize = (size_t) PsychGetHeightFromRect(rect);
windowRecord->textureMemorySizeBytes = ((size_t) (depth/8)) * xSize * ySize;
windowRecord->textureMemory = malloc(windowRecord->textureMemorySizeBytes);
texturePointer=(char*) windowRecord->textureMemory;
// printf("depth=%i xsize=%i ysize=%i mem=%i ptr=%p", depth, xSize, ySize, windowRecord->textureMemorySizeBytes, texturePointer);
// Fill with requested background color:
nbytes=0;
switch (depth) {
case 8: // Pure LUMINANCE texture:
memset((void*) texturePointer, (int) color.value.rgba.r, windowRecord->textureMemorySizeBytes);
break;
case 16: // LUMINANCE + ALPHA
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.a;
nbytes+=2;
}
break;
case 24: // RGB:
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.g;
*(texturePointer++) = (psych_uint8) color.value.rgba.b;
nbytes+=3;
}
break;
case 32: // RGBA
if (bigendian) {
// Code for big-endian machines, e.g., PowerPC:
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.a;
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.g;
*(texturePointer++) = (psych_uint8) color.value.rgba.b;
nbytes+=4;
}
}
else {
// Code for little-endian machines, e.g., IntelPC, IntelMAC, aka Pentium.
while (nbytes < windowRecord->textureMemorySizeBytes) {
*(texturePointer++) = (psych_uint8) color.value.rgba.b;
*(texturePointer++) = (psych_uint8) color.value.rgba.g;
*(texturePointer++) = (psych_uint8) color.value.rgba.r;
*(texturePointer++) = (psych_uint8) color.value.rgba.a;
nbytes+=4;
}
}
break;
}
}
// Shared setup code for FBO vs. non-FBO Offscreen windows:
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(windowRecord, targetWindow);
// Texture orientation is type 2 aka upright, non-transposed aka Offscreen window:
windowRecord->textureOrientation = 2;
if ((windowRecord->imagingMode & kPsychNeedFastBackingStore) || (windowRecord->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Last step for FBO backed Offscreen window: Clear it to its background color:
PsychSetDrawingTarget(windowRecord);
// Set default draw shader:
PsychSetShader(windowRecord, -1);
// Set background fill color:
PsychSetGLColor(&color, windowRecord);
// Setup alpha-blending:
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
// Fullscreen fill of a non-onscreen window:
PsychGLRect(windowRecord->rect);
// Multisampling requested? If so, we need to enable it:
if (multiSample > 0) {
glEnable(GL_MULTISAMPLE);
while (glGetError() != GL_NO_ERROR);
}
// Ready. Unbind it.
PsychSetDrawingTarget(NULL);
}
else {
// Old-style setup for non-FBO Offscreen windows:
// Special texture format?
if (specialFlags & 0x1) windowRecord->texturetarget = GL_TEXTURE_2D;
// Let's create and bind a new texture object and fill it with our new texture data.
PsychCreateTexture(windowRecord);
}
// Assign GLSL filter-/lookup-shaders if needed:
PsychAssignHighPrecisionTextureShaders(windowRecord, targetWindow, usefloatformat, (specialFlags & 2) ? 1 : 0);
// specialFlags setting 8? Disable auto-mipmap generation:
if (specialFlags & 0x8) windowRecord->specialflags |= kPsychDontAutoGenMipMaps;
// A specialFlags setting of 32? Protect texture against deletion via Screen('Close') without providing a explicit handle:
if (specialFlags & 32) windowRecord->specialflags |= kPsychDontDeleteOnClose;
// Window ready. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(windowRecord);
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
PsychCopyOutRectArg(2, FALSE, rect);
// Ready.
return(PsychError_none);
}
/*
PsychOSOpenOnscreenWindow()
Creates the pixel format and the context objects and then instantiates the context onto the screen.
-The pixel format and the context are stored in the target specific field of the window recored. Close
should clean up by destroying both the pixel format and the context.
-We mantain the context because it must be be made the current context by drawing functions to draw into
the specified window.
-We maintain the pixel format object because there seems to be now way to retrieve that from the context.
-To tell the caller to clean up PsychOSOpenOnscreenWindow returns FALSE if we fail to open the window. It
would be better to just issue an PsychErrorExit() and have that clean up everything allocated outside of
PsychOpenOnscreenWindow().
*/
boolean PsychOSOpenOnscreenWindow(PsychScreenSettingsType *screenSettings, PsychWindowRecordType *windowRecord, int numBuffers, int stereomode, int conserveVRAM)
{
RECT winRec;
PsychRectType screenrect;
CGDirectDisplayID cgDisplayID;
int pf;
unsigned int nNumFormats;
HDC hDC;
HWND hWnd;
WNDCLASS wc;
PIXELFORMATDESCRIPTOR pfd;
int attribs[48];
int attribcount;
float fattribs[2]={0,0};
int x, y, width, height, i, bpc;
GLenum glerr;
DWORD flags;
boolean fullscreen = FALSE;
DWORD windowStyle = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
// The WS_EX_NOACTIVATE flag prevents the window from grabbing keyboard focus. That way,
// the new Java-GetChar can do its job.
DWORD windowExtendedStyle = WS_EX_APPWINDOW | 0x08000000; // const int WS_EX_NOACTIVATE = 0x08000000;
// Init to safe default:
windowRecord->targetSpecific.glusercontextObject = NULL;
// Map the logical screen number to a device handle for the corresponding
// physical display device: CGDirectDisplayID is currently typedef'd to a
// HDC windows hardware device context handle.
PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, screenSettings->screenNumber);
// Check if this should be a fullscreen window:
PsychGetScreenRect(screenSettings->screenNumber, screenrect);
if (PsychMatchRect(screenrect, windowRecord->rect)) {
// This is supposed to be a fullscreen window with the dimensions of
// the current display/desktop:
// Switch system to fullscreen-mode without changing any settings:
fullscreen = ChangeScreenResolution(screenSettings->screenNumber, 0, 0, 0, 0);
}
else {
// Window size different from current screen size:
// A regular desktop window with borders and control icons is requested, e.g., for debugging:
fullscreen = FALSE;
}
// Special case for explicit multi-display setup under Windows when opening a window on
// screen zero. We enforce the fullscreen - flag, aka a borderless top level window. This way,
// if anything of our automatic full-desktop window emulation code goes wrong on exotic setups,
// the user can still enforce a suitably positioned and sized borderless toplevel window.
if (PsychGetNumDisplays()>2 && screenSettings->screenNumber == 0) fullscreen = TRUE;
if (fullscreen) {
windowStyle = WS_POPUP; // Set The WindowStyle To WS_POPUP (Popup Window without borders)
windowExtendedStyle |= WS_EX_TOPMOST; // Set The Extended Window Style To WS_EX_TOPMOST
}
else {
windowStyle |= WS_OVERLAPPEDWINDOW;
windowExtendedStyle |= WS_EX_TOPMOST; // Set The Extended Window Style To WS_EX_TOPMOST
}
// Define final position and size of window:
x=windowRecord->rect[kPsychLeft];
y=windowRecord->rect[kPsychTop];
width=PsychGetWidthFromRect(windowRecord->rect);
height=PsychGetHeightFromRect(windowRecord->rect);
// Register our own window class for Psychtoolbox onscreen windows:
// Only register the window class once - use hInstance as a flag.
if (!hInstance) {
hInstance = GetModuleHandle(NULL);
wc.style = CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = "PTB-OpenGL";
if (!RegisterClass(&wc)) {
hInstance = 0;
printf("\nPTB-ERROR[Register Windowclass failed]: Unknown error, Win32 specific.\n\n");
return(FALSE);
}
}
//if (PSYCH_DEBUG == PSYCH_ON) printf("Creating Window...\n");
// Adjust window bounds to account for the window borders if we are in non-fullscreen mode:
if (!fullscreen) {
winRec.left=x; winRec.top=y; winRec.right=x+width; winRec.bottom=y+height;
AdjustWindowRectEx(&winRec, windowStyle, 0, windowExtendedStyle);
x=winRec.left; y=winRec.top; width=winRec.right - winRec.left; height=winRec.bottom - winRec.top;
}
// Window class registered: Create a window of this class with some specific properties:
hWnd = CreateWindowEx(windowExtendedStyle,
"PTB-OpenGL",
"PTB Onscreen window",
windowStyle,
x, y, width, height, NULL, NULL, hInstance, NULL);
if (hWnd == NULL) {
printf("\nPTB-ERROR[CreateWindow() failed]: Unknown error, Win32 specific.\n\n");
return(FALSE);
}
// Retrieve device context for the window:
hDC = GetDC(hWnd);
// Setup optional flags for pixelformat:
flags = 0;
// Init pfd to zero:
memset(&pfd, 0, sizeof(pfd));
attribcount = 0;
attribs[attribcount++]=0x2001; // WGL_DRAW_TO_WINDOW_ARB
attribs[attribcount++]=GL_TRUE;
attribs[attribcount++]=0x2010; // WGL_SUPPORT_OPENGL_ARB
attribs[attribcount++]=GL_TRUE;
attribs[attribcount++]=0x2007; // WGL_SWAP_METHOD_ARB
attribs[attribcount++]=0x2028; // WGL_SWAP_EXCHANGE_ARB
attribs[attribcount++]=0x2013; // WGL_PIXEL_TYPE_ARB
// Select either floating point or fixed point framebuffer:
if (windowRecord->depth == 64 || windowRecord->depth == 128) {
// Request a floating point drawable instead of a fixed-point one:
attribs[attribcount++]=WGL_TYPE_RGBA_FLOAT_ARB;
}
else {
// Request standard fixed point drawable:
attribs[attribcount++]=0x202B; // WGL_TYPE_RGBA_ARB
}
// Select requested depth per color component 'bpc' for each channel:
bpc = 8; // We default to 8 bpc == RGBA8
if (windowRecord->depth == 30) { bpc = 10; printf("PTB-INFO: Trying to enable at least 10 bpc fixed point framebuffer.\n"); }
if (windowRecord->depth == 64) { bpc = 16; printf("PTB-INFO: Trying to enable 16 bpc floating point framebuffer.\n"); }
if (windowRecord->depth == 128) { bpc = 32; printf("PTB-INFO: Trying to enable 32 bpc floating point framebuffer.\n"); }
// Set up color depth for each channel:
attribs[attribcount++]=WGL_RED_BITS_ARB;
attribs[attribcount++]=bpc;
attribs[attribcount++]=WGL_GREEN_BITS_ARB;
attribs[attribcount++]=bpc;
attribs[attribcount++]=WGL_BLUE_BITS_ARB;
attribs[attribcount++]=bpc;
attribs[attribcount++]=WGL_ALPHA_BITS_ARB;
// Alpha channel has only 2 bpc in the fixed point bpc=10 case, i.e. RGBA=8882.
attribs[attribcount++]=(bpc == 10) ? 2 : bpc;
// Stereo display support: If stereo display output is requested with OpenGL native stereo,
// we request a stereo-enabled rendering context.
if(stereomode==kPsychOpenGLStereo) {
flags = flags | PFD_STEREO;
attribs[attribcount++]=0x2012; // WGL_STEREO_ARB
attribs[attribcount++]=GL_TRUE;
}
// Double buffering requested?
if(numBuffers>=2) {
// Enable double-buffering:
flags = flags | PFD_DOUBLEBUFFER;
attribs[attribcount++]=0x2011; // WGL_DOUBLE_BUFFER_ARB
attribs[attribcount++]=GL_TRUE;
// AUX buffers for Flip-Operations needed?
if ((conserveVRAM & kPsychDisableAUXBuffers) == 0) {
// Allocate one or two (mono vs. stereo) AUX buffers for new "don't clear" mode of Screen('Flip'):
// Not clearing the framebuffer after "Flip" is implemented by storing a backup-copy of
// the backbuffer to AUXs before flip and restoring the content from AUXs after flip.
pfd.cAuxBuffers=(stereomode==kPsychOpenGLStereo || stereomode==kPsychCompressedTLBRStereo || stereomode==kPsychCompressedTRBLStereo) ? 2 : 1;
attribs[attribcount++]=0x2024; // WGL_AUX_BUFFERS_ARB
attribs[attribcount++]=pfd.cAuxBuffers;
}
}
//if (PSYCH_DEBUG == PSYCH_ON) printf("Device context is %p\n", hDC);
// Build pixelformat descriptor:
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_SWAP_EXCHANGE |flags; // Want OpenGL capable window with bufferswap via page-flipping...
pfd.iPixelType = PFD_TYPE_RGBA; // Want a RGBA pixel format.
pfd.cColorBits = 32; // 32 bpp at least...
pfd.cAlphaBits = 8; // Want a 8 bit alpha-buffer.
// Support for OpenGL 3D rendering requested?
if (PsychPrefStateGet_3DGfx()) {
// Yes. Allocate and attach a 24bit depth buffer and 8 bit stencil buffer:
pfd.cDepthBits = 24;
pfd.cStencilBits = 8;
attribs[attribcount++]=0x2022; // WGL_DEPTH_BITS_ARB
attribs[attribcount++]=24;
attribs[attribcount++]=0x2023; // WGL_STENCIL_BITS_ARB
attribs[attribcount++]=8;
}
// Multisampled Anti-Aliasing requested?
if (windowRecord->multiSample > 0) {
// Request a multisample buffer:
attribs[attribcount++]= 0x2041; // WGL_SAMPLE_BUFFERS_ARB
attribs[attribcount++]= 1;
// Request at least multiSample samples per pixel:
attribs[attribcount++]= 0x2042; // WGL_SAMPLES_ARB
attribs[attribcount++]= windowRecord->multiSample;
}
// Finalize attribs-array:
attribs[attribcount++]= 0;
//if (PSYCH_DEBUG == PSYCH_ON) printf("Choosing pixelformat\n");
// Create pixelformat:
// This is typical Microsoft brain-damage: We first need to create a window the
// conventional old way just to be able to get a handle to the new wglChoosePixelFormat
// method, which will us - after destroying and recreating the new window - allow to
// select the pixelformat we actually want!
// Step 1: Choose pixelformat old-style:
pf = ChoosePixelFormat(hDC, &pfd);
// Do we have a valid pixelformat?
if (pf == 0) {
// Nope. We give up!
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR[ChoosePixelFormat() failed]: Unknown error, Win32 specific.\n\n");
return(FALSE);
}
// Yes. Set it:
if (SetPixelFormat(hDC, pf, &pfd) == FALSE) {
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR[SetPixelFormat() failed]: Unknown error, Win32 specific.\n\n");
return(FALSE);
}
// Ok, create and attach the rendering context.
windowRecord->targetSpecific.contextObject = wglCreateContext(hDC);
if (windowRecord->targetSpecific.contextObject == NULL) {
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR:[Context creation failed] Unknown, Win32 specific.\n\n");
return(FALSE);
}
// Store the handles...
windowRecord->targetSpecific.windowHandle = hWnd;
windowRecord->targetSpecific.deviceContext = hDC;
// Activate the rendering context:
PsychOSSetGLContext(windowRecord);
// Ok, the OpenGL rendering context is up and running. Auto-detect and bind all
// available OpenGL extensions via GLEW:
glerr = glewInit();
if (GLEW_OK != glerr)
{
/* Problem: glewInit failed, something is seriously wrong. */
printf("\nPTB-ERROR[GLEW init failed: %s]: Please report this to the forum. Will try to continue, but may crash soon!\n\n", glewGetErrorString(glerr));
fflush(NULL);
}
else {
if (PsychPrefStateGet_Verbosity()>4) printf("PTB-INFO: Using GLEW version %s for automatic detection of OpenGL extensions...\n", glewGetString(GLEW_VERSION));
}
DescribePixelFormat(hDC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if ((stereomode==kPsychOpenGLStereo) && ((pfd.dwFlags & PFD_STEREO)==0)) {
// Ooops. Couldn't get the requested stereo-context from hardware :(
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("PTB-ERROR: OpenGL native stereo mode unavailable. Your hardware may not support it,\n"
"PTB-ERROR: or at least not on a flat-panel? Expect abortion of your script soon...");
return(FALSE);
}
// Special debug override for faulty drivers with non-working extension:
if (conserveVRAM & kPsychOverrideWglChoosePixelformat) wglChoosePixelFormatARB = NULL;
// Step 2: Ok, we have an OpenGL rendering context with all known extensions bound:
// Do we have (or want) support for wglChoosePixelFormatARB?
// We skip use of it if we can do without it, i.e., when we don't need unusual framebuffer
// configs (like non 8bpc fixed) and we don't need multisampling. This is a work-around
// for hardware that has trouble (=driver bugs) with wglChoosePixelformat() in some modes, e.g., the NVidia
// Quadro gfx card, which fails to enable quad-buffered stereo when using wglChoosePixelformat(),
// but does so perfectly well when using the old-style ChoosePixelFormat().
if ((wglChoosePixelFormatARB == NULL) || ((bpc==8) && (windowRecord->multiSample <= 0))) {
// Failed (==NULL) or disabled via override.
if ((wglChoosePixelFormatARB == NULL) && (PsychPrefStateGet_Verbosity() > 1)) printf("PTB-WARNING: Could not bind wglChoosePixelFormat - Extension. Some features will be unavailable, e.g., Anti-Aliasing and high precision framebuffers.\n");
}
else {
// Supported. We destroy the rendering context and window, then recreate it with
// the wglChoosePixelFormat - method...
wglMakeCurrent(NULL, NULL);
// Delete rendering context:
wglDeleteContext(windowRecord->targetSpecific.contextObject);
windowRecord->targetSpecific.contextObject=NULL;
// Release device context:
ReleaseDC(windowRecord->targetSpecific.deviceContext, windowRecord->targetSpecific.windowHandle);
windowRecord->targetSpecific.deviceContext=NULL;
// Close & Destroy the window:
DestroyWindow(windowRecord->targetSpecific.windowHandle);
windowRecord->targetSpecific.windowHandle=NULL;
// Ok, old window and stuff is dead. Create new window:
hWnd = CreateWindowEx(windowExtendedStyle, "PTB-OpenGL", "PTB Onscreen window", windowStyle,
x, y, width, height, NULL, NULL, hInstance, NULL);
if (hWnd == NULL) {
printf("\nPTB-ERROR[CreateWindow() - II failed]: Unknown error, Win32 specific.\n\n");
return(FALSE);
}
// Retrieve device context for the window:
hDC = GetDC(hWnd);
pf = 0;
nNumFormats=0;
wglChoosePixelFormatARB(hDC, &attribs[0], NULL, 1, &pf, &nNumFormats);
if (nNumFormats==0 && windowRecord->multiSample > 0) {
// Failed. Probably due to too demanding multisample requirements: Lets lower them...
for (i=0; i<attribcount && attribs[i]!=0x2042; i++);
// Reduce requested number of samples/pixel and retry until we get one:
while (nNumFormats==0 && windowRecord->multiSample > 0) {
// printf("Failed for multisampling level %i nNum=%i\n", windowRecord->multiSample, nNumFormats);
attribs[i+1]--;
windowRecord->multiSample--;
wglChoosePixelFormatARB(hDC, &attribs[0], NULL, 1, &pf, &nNumFormats);
}
// If we still do not get one with 0 samples per pixel, we can try to disable
// multisampling completely:
if (windowRecord->multiSample == 0 && nNumFormats==0) {
// printf("Failed for multisampling level %i nNum=%i --> Disabling multisampling...\n", windowRecord->multiSample, nNumFormats);
// We 0-Out all entries related to multi-sampling, including the
// GL_SAMPLES_ARB and GL_SAMPLE_BUFFERS_ARB enums themselves:
for (i=0; i<attribcount && attribs[i]!=0x2042; i++);
attribs[i]=0;
for (i=0; i<attribcount && attribs[i]!=0x2041; i++);
attribs[i]=0;
attribs[i+1]=0;
wglChoosePixelFormatARB(hDC, &attribs[0], NULL, 1, &pf, &nNumFormats);
}
}
if (nNumFormats==0 && numBuffers>=2) {
// We still don't have a valid pixelformat, but double-buffering is enabled.
// Let's try if we get one if we do not request any AUX-Buffers:
for (i=0; i<attribcount && attribs[i]!=0x2024; i++);
attribs[i+1] = 0; // Zero AUX-Buffers requested.
wglChoosePixelFormatARB(hDC, &attribs[0], NULL, 1, &pf, &nNumFormats);
}
if (nNumFormats==0 && numBuffers>=2) {
// We still don't have a valid pixelformat, but double-buffering is enabled.
// Let's try if we get one if we do not request SWAP_EXCHANGED double buffering anymore:
for (i=0; i<attribcount && attribs[i]!=0x2028; i++);
attribs[i] = 0x202A; // WGL_SWAP_UNDEFINED_ARB
wglChoosePixelFormatARB(hDC, &attribs[0], NULL, 1, &pf, &nNumFormats);
}
// Either we have a multisampled or non-multisampled format, or none. If we failed,
// then we can not do anything anymore about it.
// Do we have a valid pixelformat?
if (nNumFormats == 0) {
// Nope. We give up!
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR[wglChoosePixelFormat() failed]: Unknown error, Win32 specific. Code: %i.\n\n", GetLastError());
return(FALSE);
}
// Yes. Set it:
if (SetPixelFormat(hDC, pf, &pfd) == FALSE) {
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR[SetPixelFormat() - II failed]: Unknown error, Win32 specific.\n\n");
return(FALSE);
}
// Ok, create and attach the rendering context.
windowRecord->targetSpecific.contextObject = wglCreateContext(hDC);
if (windowRecord->targetSpecific.contextObject == NULL) {
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR:[Context creation II failed] Unknown, Win32 specific.\n\n");
return(FALSE);
}
// Store the handles...
windowRecord->targetSpecific.windowHandle = hWnd;
windowRecord->targetSpecific.deviceContext = hDC;
// Activate the rendering context:
PsychOSSetGLContext(windowRecord);
DescribePixelFormat(hDC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if ((stereomode==kPsychOpenGLStereo) && ((pfd.dwFlags & PFD_STEREO)==0)) {
// Ooops. Couldn't get the requested stereo-context from hardware :(
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("PTB-ERROR: OpenGL native stereo mode unavailable. Your hardware may not support it,\n"
"PTB-ERROR: or at least not on a flat-panel? Expect abortion of your script soon...");
return(FALSE);
}
// Done with final window and OpenGL context setup. We've got our final context enabled.
}
// Enable multisampling if this was requested:
if (windowRecord->multiSample > 0) glEnable(0x809D); // 0x809D == GL_MULTISAMPLE_ARB
// Throw away any error-state this could have created on old hardware...
glGetError();
// External 3D graphics support enabled? Or OpenGL quad-buffered stereo enabled?
// For the former, we need this code for OpenGL state isolation. For the latter we
// need this code as workaround for Windows brain-damage. For some reason it helps
// to properly shutdown stereo contexts on Windows...
if (PsychPrefStateGet_3DGfx() || stereomode == kPsychOpenGLStereo) {
// Yes. We need to create an extra OpenGL rendering context for the external
// OpenGL code to provide optimal state-isolation. The context shares all
// heavyweight ressources likes textures, FBOs, VBOs, PBOs, display lists and
// starts off as an identical copy of PTB's context as of here.
windowRecord->targetSpecific.glusercontextObject = wglCreateContext(hDC);
if (windowRecord->targetSpecific.glusercontextObject == NULL) {
ReleaseDC(hDC, hWnd);
DestroyWindow(hWnd);
printf("\nPTB-ERROR[UserContextCreation failed]: Creating a private OpenGL context for Matlab OpenGL failed for unknown reasons.\n\n");
return(FALSE);
}
wglMakeCurrent(windowRecord->targetSpecific.deviceContext, windowRecord->targetSpecific.glusercontextObject);
wglMakeCurrent(windowRecord->targetSpecific.deviceContext, windowRecord->targetSpecific.contextObject);
// Copy full state from our main context:
if(!wglCopyContext(windowRecord->targetSpecific.contextObject, windowRecord->targetSpecific.glusercontextObject, GL_ALL_ATTRIB_BITS)) {
// This is ugly, but not fatal...
if (PsychPrefStateGet_Verbosity()>1) {
printf("\nPTB-WARNING[wglCopyContext for user context failed]: Copying state to private OpenGL context for Matlab OpenGL failed for unknown reasons.\n\n");
}
}
// Enable ressource sharing with master context for this window:
if (!wglShareLists(windowRecord->targetSpecific.contextObject, windowRecord->targetSpecific.glusercontextObject)) {
// This is ugly, but not fatal...
if (PsychPrefStateGet_Verbosity()>1) {
printf("\nPTB-WARNING[wglShareLists for user context failed]: Ressource sharing with private OpenGL context for Matlab OpenGL failed for unknown reasons.\n\n");
}
}
}
// Finally, show our new window:
ShowWindow(hWnd, SW_SHOW);
// Give it higher priority than other applications windows:
// Disabled: Interferes with JAVA-GetChar: SetForegroundWindow(hWnd);
// Set the focus on it:
// Disabled: Interferes with JAVA-GetChar: SetFocus(hWnd);
// Capture the window if it is a fullscreen one: This window will receive all
// mouse move and mouse button press events. Important for GetMouse() to work
// properly...
if (fullscreen) SetCapture(hWnd);
// Increase our own open window counter:
win32_windowcount++;
// Some info for the user regarding non-fullscreen and ATI hw:
if (!fullscreen && (strstr(glGetString(GL_VENDOR), "ATI"))) {
printf("PTB-INFO: Some ATI graphics cards may not support proper syncing to vertical retrace when\n");
printf("PTB-INFO: running in windowed mode (non-fullscreen). If PTB aborts with 'Synchronization failure'\n");
printf("PTB-INFO: you can disable the sync test via call to Screen('Preference', 'SkipSyncTests', 1); .\n");
printf("PTB-INFO: You won't get proper stimulus onset timestamps though, so windowed mode may be of limited use.\n");
}
// Dynamically bind the VSYNC extension:
//if (strstr(glGetString(GL_EXTENSIONS), "WGL_EXT_swap_control")) {
// Bind it:
// wglSwapIntervalEXT=(PFNWGLEXTSWAPCONTROLPROC) wglGetProcAddress("wglSwapIntervalEXT");
//}
//else {
if (wglSwapIntervalEXT == NULL) {
wglSwapIntervalEXT = NULL;
printf("PTB-WARNING: Your graphics driver doesn't allow me to control syncing wrt. vertical retrace!\n");
printf("PTB-WARNING: Please update your display graphics driver as soon as possible to fix this.\n");
printf("PTB-WARNING: Until then, you can manually enable syncing to VBL somewhere in the display settings\n");
printf("PTB-WARNING: tab of your machine.\n");
}
// Ok, we should be ready for OS independent setup...
//printf("\nPTB-INFO: Low-level (Windoze) setup of onscreen window finished!\n");
//fflush(NULL);
// Well Done!
return(TRUE);
}
/*
PsychOSOpenOnscreenWindow()
Creates the CGL pixel format and the CGL context objects and then instantiates the context onto the screen.
-The pixel format and the context are stored in the target specific field of the window recored. Close
should clean up by destroying both the pixel format and the context.
-We mantain the context because it must be be made the current context by drawing functions to draw into
the specified window.
-We maintain the pixel format object because there seems to be now way to retrieve that from the context.
-To tell the caller to clean up PsychOSOpenOnscreenWindow returns FALSE if we fail to open the window. It
would be better to just issue an PsychErrorExit() and have that clean up everything allocated outside of
PsychOpenOnscreenWindow().
MK: The new option 'stereomode' allows selection of stereo display instead of mono display:
0 (default) == Old behaviour -> Monoscopic rendering context.
>0 == Stereo display, where the number defines the type of stereo algorithm to use.
=1 == Use OpenGL built-in stereo by creating a context/window with left- and right backbuffer. This is
the only mode of interest here, as it requires use of a stereo capable OpenGL pixelformat. All other
stereo modes are implemented by PTB itself in a platform independent manner on top of a standard mono
context.
*/
psych_bool PsychOSOpenOnscreenWindow(PsychScreenSettingsType *screenSettings, PsychWindowRecordType *windowRecord, int numBuffers, int stereomode, int conserveVRAM)
{
CGOpenGLDisplayMask displayMask;
CGLError error;
CGDirectDisplayID cgDisplayID;
CGLPixelFormatAttribute attribs[40];
int attribcount;
GLint numVirtualScreens;
GLenum glerr;
PsychRectType screenrect;
int i;
int windowLevel;
long scw, sch;
void* cocoaWindow = NULL;
// Map screen number to physical display handle cgDisplayID:
PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, screenSettings->screenNumber);
displayMask = CGDisplayIDToOpenGLDisplayMask(cgDisplayID);
// NULL-out Cocoa window handle, so this is well-defined in case of error:
windowRecord->targetSpecific.windowHandle = NULL;
// Retrieve windowLevel, an indicator of where non-CGL / non-fullscreen windows should
// be located wrt. to other windows. -2 = Allow regular window manager control of stacking
// order, visibility etc., -1 = Invisible/hidden, 0 = Behind everything else, occluded by
// everything else. 1 - 999 = At layer 'windowLevel' -> Occludes stuff on layers "below" it.
// 1000 - 1999 = At highest level, but partially translucent / alpha channel allows to make
// regions transparent. Range 1000 - 1499 = transparent for mouse and keyboard, alpha 0-99.99%,
// 1500-1599 = opaque for mouse and keyboard, alpha 0-99.99%, 2000 or higher: Above everything,
// fully opaque, occludes everything, a typical fullscreen onscreen window. 2000 is the default.
windowLevel = PsychPrefStateGet_WindowShieldingLevel();
// Window rect provided which has same size as screen?
// We do not use windowed mode if the provided window rectangle either
// matches the target screens rectangle (and therefore its exact size)
// or its screens global rectangle. In such cases we use CGL for better
// low level control and to exclude the desktop compositor from interfering:
PsychGetScreenRect(screenSettings->screenNumber, screenrect);
if (PsychMatchRect(screenrect, windowRecord->rect)) windowRecord->specialflags |= kPsychIsFullscreenWindow;
PsychGetGlobalScreenRect(screenSettings->screenNumber, screenrect);
if (PsychMatchRect(screenrect, windowRecord->rect)) windowRecord->specialflags |= kPsychIsFullscreenWindow;
if ((windowRecord->specialflags & kPsychIsFullscreenWindow) && (PsychPrefStateGet_Verbosity() > 3)) {
printf("PTB-INFO: Always using Cocoa for fullscreen windows to work around graphics driver bugs in OSX.\n");
printf("PTB-INFO: Presentation timing precision is not yet known for this configuration on most machines. Check your results.\n");
}
// Display for fullscreen window not captured? Timing precision is unclear in this mode. In theory the compositor should disable
// itself for fullscreen windows on modern OSX versions. If it really does that, who knows?
if ((windowRecord->specialflags & kPsychIsFullscreenWindow) && (PsychPrefStateGet_ConserveVRAM() & kPsychUseAGLCompositorForFullscreenWindows)) {
// Force a window rectangle that matches the global screen rectangle for that windows screen:
PsychCopyRect(windowRecord->rect, screenrect);
// Warn user about what's going on:
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-INFO: No display capture / compositor lockout for fullscreen window. Timing precision is unknown.\n");
}
if ((windowRecord->specialflags & kPsychGUIWindow) && (PsychPrefStateGet_Verbosity() > 3)) {
printf("PTB-INFO: Onscreen window is configured as regular GUI window.\n");
}
// Create onscreen Cocoa window of requested position and size:
if (PsychCocoaCreateWindow(windowRecord, windowLevel, &cocoaWindow)) {
printf("\nPTB-ERROR[CreateNewWindow failed]: Failed to open Cocoa onscreen window\n\n");
return(FALSE);
}
// Transparent window requested?
if ((windowLevel >= 1000) && (windowLevel < 2000)) {
// Setup of global window alpha value for transparency. This is premultiplied to
// the individual per-pixel alpha values if transparency is enabled by Cocoa code.
//
// Levels 1000 - 1499 and 1500 to 1999 map to a master opacity level of 0.0 - 1.0:
PsychCocoaSetWindowAlpha(cocoaWindow, ((float) (windowLevel % 500)) / 499.0);
}
// Show it! Unless a windowLevel of -1 requests hiding the window:
if (windowLevel != -1) PsychCocoaShowWindow(cocoaWindow);
// If usercode wants a black startup screen then we add a pause of 0.5 seconds here
// before proceeding. This will avoid a white flash at window open time, which might
// be something the user wanted to avoid. Why does this help or is needed at all?
// Nobody knows, but this is Apples ridiculous toy OS, so why even ask such questions?
if (PsychPrefStateGet_VisualDebugLevel() < 4)
PsychYieldIntervalSeconds(0.5);
// Level zero means: Place behind all other windows:
if (windowLevel == 0) PsychCocoaSendBehind(cocoaWindow);
// Levels 1 to 999 define window levels for the group of the window.
// A level of -2 would leave this to the system:
if (windowLevel > 0 && windowLevel < 1000) PsychCocoaSetWindowLevel(cocoaWindow, windowLevel);
// Is the target display captured for a fullscreen window?
if (PsychIsScreenCaptured(screenSettings->screenNumber)) {
// Yes. Make sure our window is above the shielding window level:
PsychCocoaSetWindowLevel(cocoaWindow, (int) CGShieldingWindowLevel());
}
// Store window handle in windowRecord:
windowRecord->targetSpecific.windowHandle = cocoaWindow;
// Store vblank startline aka true height of physical display screen in pixels:
PsychGetScreenPixelSize(screenSettings->screenNumber, &scw, &sch);
windowRecord->VBL_Startline = (int) sch;
// Define pixelformat attributes for OpenGL contexts:
// No pixelformat attribs to start with:
attribcount = 0;
attribs[attribcount++]=kCGLPFADisplayMask;
attribs[attribcount++]=displayMask;
// 10 bit per component integer framebuffer requested (10-10-10-2)?
if (windowRecord->depth == 30) {
// Request a 10 bit per color component framebuffer with 2 bit alpha channel:
printf("PTB-INFO: Trying to enable 10 bpc, 30 bit integer framebuffer...\n");
attribs[attribcount++]=kCGLPFANoRecovery;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=10*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=2;
}
// 11 bit per component integer framebuffer requested (11-11-10-0)?
if (windowRecord->depth == 33) {
// Request a ~ 11 bit per color component framebuffer without alpha channel:
printf("PTB-INFO: Trying to enable 11 bpc, 32 bit integer framebuffer...\n");
attribs[attribcount++]=kCGLPFANoRecovery;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=32;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=0;
}
// 16 bit per component integer framebuffer requested (16-16-16-16)?
if (windowRecord->depth == 48) {
// Request a 16 bit per color component framebuffer:
printf("PTB-INFO: Trying to enable 16 bpc, 64 bit integer framebuffer...\n");
attribs[attribcount++]=kCGLPFANoRecovery;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=16*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=16;
}
// 16 bit per component, 64 bit framebuffer requested (16-16-16-16)?
if (windowRecord->depth == 64) {
// Request a floating point framebuffer in 16-bit half-float format, i.e., RGBA = 16 bits per component.
printf("PTB-INFO: Trying to enable 16 bpc float framebuffer...\n");
attribs[attribcount++]=kCGLPFAColorFloat;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=16*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=16;
}
// 32 bit per component, 128 bit framebuffer requested (32-32-32-32)?
if (windowRecord->depth == 128) {
// Request a floating point framebuffer in 32-bit float format, i.e., RGBA = 32 bits per component.
printf("PTB-INFO: Trying to enable 32 bpc float framebuffer...\n");
attribs[attribcount++]=kCGLPFAColorFloat;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=32*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=32;
}
// Possible to request use of the Apple floating point software renderer:
if (conserveVRAM & kPsychUseSoftwareRenderer) {
#ifndef kCGLRendererGenericFloatID
#define kCGLRendererGenericFloatID 0x00020400
#endif
attribs[attribcount++]=AGL_RENDERER_ID;
attribs[attribcount++]=kCGLRendererGenericFloatID;
}
// Support for 3D rendering requested?
if (PsychPrefStateGet_3DGfx()) {
// Yes. Allocate a 24-Bit depth and 8-Bit stencilbuffer for this purpose:
attribs[attribcount++]=kCGLPFADepthSize;
attribs[attribcount++]=24;
attribs[attribcount++]=kCGLPFAStencilSize;
attribs[attribcount++]=8;
// Alloc an accumulation buffer as well?
if (PsychPrefStateGet_3DGfx() & 2) {
// Yes: Alloc accum buffer, request 64 bpp, aka 16 bits integer per color component if possible:
attribs[attribcount++]=kCGLPFAAccumSize;
attribs[attribcount++]=64;
}
}
if(numBuffers>=2){
// Enable double-buffering:
attribs[attribcount++]=kCGLPFADoubleBuffer;
if ((conserveVRAM & kPsychDisableAUXBuffers) == 0) {
// Allocate one or two (for mono vs. stereo display) AUX buffers for "don't clear" mode of Screen('Flip'):
// Not clearing the framebuffer after "Flip" is implemented by storing a backup-copy of
// the backbuffer to AUXs before flip and restoring the content from AUXs after flip.
// Unless the imaging pipeline is active, which doesn't need AUX buffers due to internal
// storage of fb content in its drawbufferFBO's:
attribs[attribcount++]=kCGLPFAAuxBuffers;
attribs[attribcount++]=(stereomode==kPsychOpenGLStereo || stereomode==kPsychCompressedTLBRStereo || stereomode==kPsychCompressedTRBLStereo) ? 2 : 1;
}
}
// If stereo display output is requested with OpenGL native stereo, request a stereo-enabled rendering context.
// This is deprecated since 10.11 El Capitan, and in fact does no longer work - OpenGL quad buffered stereo is
// dead on 10.11 on all tested GPU's from Intel, NVidia, AMD.
if(stereomode==kPsychOpenGLStereo) {
attribs[attribcount++] = kCGLPFAStereo;
}
// Multisampled Anti-Aliasing requested?
if (windowRecord->multiSample > 0) {
// Request a multisample buffer:
attribs[attribcount++]= kCGLPFASampleBuffers;
attribs[attribcount++]= 1;
// Request at least multiSample samples per pixel:
attribs[attribcount++]= kCGLPFASamples;
attribs[attribcount++]= windowRecord->multiSample;
}
// Finalize attribute array with NULL.
attribs[attribcount++]=(CGLPixelFormatAttribute)NULL;
// Init to zero:
windowRecord->targetSpecific.pixelFormatObject = NULL;
windowRecord->targetSpecific.glusercontextObject = NULL;
windowRecord->targetSpecific.glswapcontextObject = NULL;
// Try to find matching pixelformat:
error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
// No valid pixelformat found and stereo format requested?
if ((error || (windowRecord->targetSpecific.pixelFormatObject == NULL)) && (stereomode == kPsychOpenGLStereo)) {
// Yep: Stereo may be the culprit. Remove the stereo attribute by overwriting it with something
// that is essentially a no-op, specifically kCGLPFAAccelerated which is supported by all real
// renderers that might end up in this code-path:
for (i = 0; i < attribcount && attribs[i] != kCGLPFAStereo; i++);
attribs[i] = kCGLPFAAccelerated;
// Retry query of pixelformat without request for native OpenGL quad-buffered stereo. If we succeed, we're
// sort of ok, as the higher-level code will fallback to stereomode kPsychFrameSequentialStereo - our own
// homegrown frame-sequential stereo support, which may be good enough.
error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
if (error || (windowRecord->targetSpecific.pixelFormatObject == NULL)) {
windowRecord->targetSpecific.pixelFormatObject = NULL;
printf("\nPTB-ERROR[ChoosePixelFormat failed: %s]: Disabling OpenGL native quad-buffered stereo did not help. Moving on...\n\n", CGLErrorString(error));
}
}
// Now try if choosing a matching format for a lower multisample mode helps to get unstuck:
if (windowRecord->multiSample > 0) {
if (windowRecord->targetSpecific.pixelFormatObject==NULL && windowRecord->multiSample > 0) {
// Failed. Probably due to too demanding multisample requirements: Lets lower them...
for (i = 0; i < attribcount && attribs[i] != kCGLPFASamples; i++);
while (windowRecord->targetSpecific.pixelFormatObject == NULL && windowRecord->multiSample > 0) {
attribs[i+1]--;
windowRecord->multiSample--;
error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
}
if (windowRecord->multiSample == 0 && windowRecord->targetSpecific.pixelFormatObject == NULL) {
// Ok, multisampling is now at zero and we still don't succeed. Disable multisampling completely:
for (i=0; i<attribcount && attribs[i]!=kCGLPFASampleBuffers; i++);
attribs[i+1] = 0;
printf("\nPTB-ERROR[ChoosePixelFormat failed: %s]: Disabling multisample anti-aliasing did not help. Moving on...\n\n", CGLErrorString(error));
}
}
}
// Try choosing a matching display configuration again and create the window and rendering context:
// If one of these two fails, then the installed gfx hardware is not good enough to satisfy our
// requirements, or we have massive ressource shortage in the system. -> Screwed up anyway, so we abort.
if (windowRecord->targetSpecific.pixelFormatObject == NULL) error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
if (error) {
printf("\nPTB-ERROR[ChoosePixelFormat failed: %s]: Reason unknown. There could be insufficient video memory or a driver malfunction. Giving up.\n\n", CGLErrorString(error));
return(FALSE);
}
// Create an OpenGL rendering context with the selected pixelformat: Share its ressources with 'slaveWindow's context, if slaveWindow is non-NULL.
// If slaveWindow is non-NULL here, then slaveWindow is typically another onscreen window. Therefore this establishes OpenGL resource sharing across
// different onscreen windows in a session, e.g., for multi-display operation:
error=CGLCreateContext(windowRecord->targetSpecific.pixelFormatObject, ((windowRecord->slaveWindow) ? windowRecord->slaveWindow->targetSpecific.contextObject : NULL),
&(windowRecord->targetSpecific.contextObject));
if (error) {
printf("\nPTB-ERROR[ContextCreation failed: %s]: Could not create master OpenGL context for new onscreen window. Insufficient video memory?\n\n", CGLErrorString(error));
return(FALSE);
}
// Enable the OpenGL rendering context associated with our window:
error=CGLSetCurrentContext(windowRecord->targetSpecific.contextObject);
if (error) {
printf("\nPTB-ERROR[SetCurrentContext failed: %s]: Insufficient video memory\n\n", CGLErrorString(error));
return(FALSE);
}
// NULL-out the AGL context field, just for safety...
windowRecord->targetSpecific.deviceContext = NULL;
// Ok, the master OpenGL rendering context for this new onscreen window is up and running.
// Auto-detect and bind all available OpenGL extensions via GLEW:
glerr = glewInit();
if (GLEW_OK != glerr)
{
/* Problem: glewInit failed, something is seriously wrong. */
printf("\nPTB-ERROR[GLEW init failed: %s]: Please report this to the forum. Will try to continue, but may crash soon!\n\n", glewGetErrorString(glerr));
fflush(NULL);
}
else {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Using GLEW version %s for automatic detection of OpenGL extensions...\n", glewGetString(GLEW_VERSION));
}
// Enable multisampling if it was requested:
if (windowRecord->multiSample > 0) glEnable(GL_MULTISAMPLE);
// External 3D graphics support enabled?
if (PsychPrefStateGet_3DGfx()) {
// Yes. We need to create an extra OpenGL rendering context for the external
// OpenGL code to provide optimal state-isolation. The context shares all
// heavyweight ressources likes textures, FBOs, VBOs, PBOs, shader, display lists and
// starts off as an identical copy of PTB's context as of here.
error=CGLCreateContext(windowRecord->targetSpecific.pixelFormatObject, windowRecord->targetSpecific.contextObject, &(windowRecord->targetSpecific.glusercontextObject));
if (error) {
printf("\nPTB-ERROR[UserContextCreation failed: %s]: Creating a private OpenGL context for userspace OpenGL failed.\n\n", CGLErrorString(error));
return(FALSE);
}
}
// Create glswapcontextObject - An OpenGL context for exclusive use by parallel background threads,
// e.g., our thread for async flip operations and self-made frame-sequential stereo:
error=CGLCreateContext(windowRecord->targetSpecific.pixelFormatObject, windowRecord->targetSpecific.contextObject, &(windowRecord->targetSpecific.glswapcontextObject));
if (error) {
printf("\nPTB-ERROR[SwapContextCreation failed: %s]: Creating a private OpenGL context for async-bufferswaps failed.\n\n", CGLErrorString(error));
CGLSetCurrentContext(NULL);
return(FALSE);
}
// Store Cocoa onscreen window handle:
windowRecord->targetSpecific.windowHandle = cocoaWindow;
// Objective-C setup path, using Cocoa + NSOpenGLContext wrapped around already
// existing and setup CGLContext:
if (PsychCocoaSetupAndAssignOpenGLContextsFromCGLContexts(cocoaWindow, windowRecord)) {
printf("\nPTB-ERROR[Cocoa OpenGL setup failed]: Setup failed for unknown reasons.\n\n");
PsychCocoaDisposeWindow(windowRecord);
return(FALSE);
}
// Check for output display rotation enabled. Will impair timing/timestamping because
// it uses the desktop compositor for a rotated copy blit, instead of via rotated crtc
// scanout, as most crtc's don't support this in hardware:
if ((((int) CGDisplayRotation(cgDisplayID)) != 0) && (PsychPrefStateGet_Verbosity() > 1)) {
printf("PTB-WARNING: Your onscreen windows output display has rotation enabled. It is not displaying in upright orientation.\n");
printf("PTB-WARNING: On most graphics cards this will cause unreliable stimulus presentation timing and timestamping.\n");
printf("PTB-WARNING: If you want non-upright stimulus presentation, look at 'help PsychImaging' on how to achieve this in\n");
printf("PTB-WARNING: a way that doesn't impair timing. The subfunctions 'FlipHorizontal' and 'FlipVertical' are what you probably need.\n");
}
// First reference to this screen by a window?
if (screenRefCount[screenSettings->screenNumber] == 0) {
// High precision timestamping enabled? If so, we need to setup the fallback
// timestamping methods in case beamposition timestamping doesn't work:
if (PsychPrefStateGet_VBLTimestampingMode() > 0) {
// Use of CoreVideo is needed on 10.7 and later due to brokeness of the old method (thanks Apple!):
if (PsychPrefStateGet_Verbosity() > 2) {
printf("PTB-INFO: Will use fragile CoreVideo timestamping as fallback if beamposition timestamping doesn't work.\n");
// Recommend use of kernel driver if it isn't installed already for all but Intel GPU's:
if (!PsychOSIsKernelDriverAvailable(screenSettings->screenNumber) && !strstr((char*) glGetString(GL_VENDOR), "Intel")) {
printf("PTB-INFO: Installation of the PsychtoolboxKernelDriver is strongly recommended if you care about precise visual\n");
printf("PTB-INFO: onset timestamping or timing. See 'help PsychtoolboxKernelDriver' for installation instructions.\n");
}
}
if (NULL == cvDisplayLink[screenSettings->screenNumber]) {
// CoreVideo timestamping:
//
// Create and start a CVDisplayLink for this screen.
if (kCVReturnSuccess != CVDisplayLinkCreateWithCGDisplay(cgDisplayID, &cvDisplayLink[screenSettings->screenNumber])) {
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to create CVDisplayLink for screenId %i. This may impair VBL timestamping.\n", screenSettings->screenNumber);
} else {
// Assign dummy output callback, as this is mandatory to get the link up and running:
CVDisplayLinkSetOutputCallback(cvDisplayLink[screenSettings->screenNumber], &PsychCVDisplayLinkOutputCallback, (void*) (long int) screenSettings->screenNumber);
// Setup shared data structure and mutex:
memset(&cvDisplayLinkData[screenSettings->screenNumber], 0, sizeof(cvDisplayLinkData[screenSettings->screenNumber]));
PsychInitMutex(&(cvDisplayLinkData[screenSettings->screenNumber].mutex));
// Start the link:
if (kCVReturnSuccess != CVDisplayLinkStart(cvDisplayLink[screenSettings->screenNumber])) {
// Failed to start: Release it again and report error:
CVDisplayLinkRelease(cvDisplayLink[screenSettings->screenNumber]);
cvDisplayLink[screenSettings->screenNumber] = NULL;
// Teardown shared data structure and mutex:
PsychDestroyMutex(&(cvDisplayLinkData[screenSettings->screenNumber].mutex));
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to start CVDisplayLink for screenId %i. This may impair VBL timestamping.\n", screenSettings->screenNumber);
}
else {
// Display link started: Report some stuff for the fun of it...
if (PsychPrefStateGet_Verbosity() > 3) {
// Wait for 50 msecs before query of video refresh from display link to give it a chance to start up:
PsychWaitIntervalSeconds(0.050);
printf("PTB-INFO: CVDisplayLink for screen %i created to work around the brokenness of Apple Mac OS/X 10.7 and later:\n", screenSettings->screenNumber);
printf("PTB-INFO: Video refresh interval as measured by CoreVideo display link: %f msecs.\n", (float) CVDisplayLinkGetActualOutputVideoRefreshPeriod(cvDisplayLink[screenSettings->screenNumber]) * 1000.0);
CVTime outLatency = CVDisplayLinkGetOutputVideoLatency(cvDisplayLink[screenSettings->screenNumber]);
printf("PTB-INFO: Video display output delay as reported by CoreVideo display link: %f msecs.\n", screenSettings->screenNumber, (float) (((double) outLatency.timeValue / (double) outLatency.timeScale) * 1000.0));
}
}
}
}
}
else {
// VBLtimestampingmode 0 or -1 -- No CoreVideo fallback for timestamping if beamposition timestamping is unavailable:
// This is the new default as of Psychtoolbox 3.0.12 to avoid the buggy, crashy, unreliably CoreVideo fallback.
// Recommend use of kernel driver if it isn't installed already for all but Intel GPU's:
if (!PsychOSIsKernelDriverAvailable(screenSettings->screenNumber) && !strstr((char*) glGetString(GL_VENDOR), "Intel")) {
printf("PTB-INFO: Installation of the PsychtoolboxKernelDriver is strongly recommended if you care about precise visual\n");
printf("PTB-INFO: onset timestamping or timing. See 'help PsychtoolboxKernelDriver' for installation instructions.\n");
}
}
}
// Retain reference of this window to its screen:
screenRefCount[screenSettings->screenNumber]++;
// Done.
return(TRUE);
}
PsychError SCREENOpenWindow(void)
{
int screenNumber, numWindowBuffers, stereomode, multiSample, imagingmode, specialflags;
PsychRectType rect, screenrect;
PsychColorType color;
psych_bool isArgThere, didWindowOpen, useAGL;
PsychScreenSettingsType screenSettings;
PsychWindowRecordType *windowRecord;
PsychDepthType specifiedDepth, possibleDepths, currentDepth, useDepth;
int dummy1;
double dummy2, dummy3, dummy4;
psych_bool EmulateOldPTB = PsychPrefStateGet_EmulateOldPTB();
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the number of inputs
PsychErrorExit(PsychCapNumInputArgs(9)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the screen number from the windowPtrOrScreenNumber. This also checks to make sure that the specified screen exists.
PsychCopyInScreenNumberArg(kPsychUseDefaultArgPosition, TRUE, &screenNumber);
if(screenNumber==-1)
PsychErrorExitMsg(PsychError_user, "The specified onscreen window has no ancestral screen.");
/*
The depth checking is ugly because of this stupid depth structure stuff.
Instead get a descriptor of the current video settings, change the depth field,
and pass it to a validate function wich searches a list of valid video modes for the display.
There seems to be no point in checking the depths alone because the legality of a particular
depth depends on the other settings specified below. Its probably best to wait until we have
digested all settings and then test the full mode, declarin an invalid
mode and not an invalid pixel size. We could notice when the depth alone is specified
and in that case issue an invalid depth value.
*/
//find the PixelSize first because the color specifier depends on the screen depth.
PsychInitDepthStruct(¤tDepth); //get the current depth
PsychGetScreenDepth(screenNumber, ¤tDepth);
PsychInitDepthStruct(&possibleDepths); //get the possible depths
PsychGetScreenDepths(screenNumber, &possibleDepths);
#if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_WINDOWS
// MK Experimental Hack: Add the special depth values 64 and 128 to the depth struct. This should
// allows for 16 bpc, 32 bpc floating point color buffers on the latest ATI and NVidia hardware.
// "Should" means: It doesn't really work with any current driver, but we leave the testcode in
// in the hope for future OS and driver releases ;-)
// Unfortunately at this point of the init sequence, we are not able
// to check if these formats are supported by the hardware. Ugly ugly ugly...
PsychAddValueToDepthStruct(64, &possibleDepths);
PsychAddValueToDepthStruct(128, &possibleDepths);
#endif
// #if PSYCH_SYSTEM == PSYCH_OSX || PSYCH_SYSTEM == PSYCH_LINUX
// On MacOS/X and Linux with ATI Radeon X1000/HD2000/HD3000 hardware and the special
// kernel support driver installed, we should be able to configure the hardwares
// framebuffers into ABGR2101010 mode, ie. 2 bits alpha, 10 bpc for red, green, blue.
// This needs support from the imaging pipeline, or manually converted stimuli, as
// the GPU doesn't format pixel data properly, only the CRTC scans out in that format.
// Anyway, allow this setting on OS/X and Linux:
// Update: Some FireGL cards (2008 and later) claim to support this on MS-Windows. Enable
// this option on Windows as well, so it is at least testable:
PsychAddValueToDepthStruct(30, &possibleDepths);
// #endif
PsychInitDepthStruct(&specifiedDepth); //get the requested depth and validate it.
isArgThere = PsychCopyInSingleDepthArg(4, FALSE, &specifiedDepth);
PsychInitDepthStruct(&useDepth);
if(isArgThere){ //if the argument is there check that the screen supports it...
if(!PsychIsMemberDepthStruct(&specifiedDepth, &possibleDepths))
PsychErrorExit(PsychError_invalidDepthArg);
else
PsychCopyDepthStruct(&useDepth, &specifiedDepth);
}else //otherwise use the default
PsychCopyDepthStruct(&useDepth, ¤tDepth);
// Initialize the rect argument to the screen rectangle:
PsychGetGlobalScreenRect(screenNumber, rect); //get the rect describing the screen bounds. This is the default Rect.
// Override it with a user supplied rect, if one was supplied:
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect );
if (IsPsychRectEmpty(rect)) PsychErrorExitMsg(PsychError_user, "OpenWindow called with invalid (empty) rect argument.");
if (PSYCH_SYSTEM == PSYCH_OSX) {
// OS/X system: Need to decide if we use a Carbon window + AGL
// or a fullscreen context with CGL:
// Default to AGL, switch to CGL if below constraints are met:
useAGL = TRUE;
// Window rect provided which has a different size than screen?
// We do not use windowed mode if the provided window rectangle either
// matches the target screens rectangle (and therefore its exact size)
// or its screens global rectangle.
PsychGetScreenRect(screenNumber, screenrect);
if (PsychMatchRect(screenrect, rect)) useAGL=FALSE;
PsychGetGlobalScreenRect(screenNumber, screenrect);
if (PsychMatchRect(screenrect, rect)) useAGL=FALSE;
// Override for use on f$%#$Fd OS/X 10.5.3 - 10.5.6 with NVidia GF 8800 GPU's:
if (PsychPrefStateGet_ConserveVRAM() & kPsychUseAGLCompositorForFullscreenWindows) useAGL = TRUE;
}
else {
// Non OS/X system: Do not use AGL ;-)
useAGL = FALSE;
}
//find the number of specified buffers.
//OS X: The number of backbuffers is not a property of the display mode but an attribute of the pixel format.
// Therefore the value is held by a window record and not a screen record.
numWindowBuffers=2;
PsychCopyInIntegerArg(5,FALSE,&numWindowBuffers);
if(numWindowBuffers < 1 || numWindowBuffers > kPsychMaxNumberWindowBuffers) PsychErrorExit(PsychError_invalidNumberBuffersArg);
stereomode=0;
PsychCopyInIntegerArg(6,FALSE,&stereomode);
if(stereomode < 0 || stereomode > 11) PsychErrorExitMsg(PsychError_user, "Invalid stereomode provided (Valid between 0 and 11).");
if (stereomode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, stereo display functions are not supported in OS-9 PTB emulation mode.");
multiSample=0;
PsychCopyInIntegerArg(7,FALSE,&multiSample);
if(multiSample < 0) PsychErrorExitMsg(PsychError_user, "Invalid multisample value provided (Valid are positive numbers >= 0).");
if (multiSample!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, anti-aliasing functions are not supported in OS-9 PTB emulation mode.");
imagingmode=0;
PsychCopyInIntegerArg(8,FALSE,&imagingmode);
if(imagingmode < 0) PsychErrorExitMsg(PsychError_user, "Invalid imaging mode provided (See 'help PsychImagingMode' for usage info).");
if (imagingmode!=0 && EmulateOldPTB) PsychErrorExitMsg(PsychError_user, "Sorry, imaging pipeline functions are not supported in OS-9 PTB emulation mode.");
specialflags=0;
PsychCopyInIntegerArg(9,FALSE,&specialflags);
if (specialflags < 0 || (specialflags > 0 && specialflags!=kPsychGUIWindow)) PsychErrorExitMsg(PsychError_user, "Invalid 'specialflags' provided.");
// We require use of the imaging pipeline if stereomode for dualwindow display is requested.
// This makes heavy use of FBO's and blit operations, so imaging pipeline is needed.
if ((stereomode==kPsychDualWindowStereo) || (imagingmode & kPsychNeedDualWindowOutput)) {
// Dual window stereo requested, but imaging pipeline not enabled. Enable it:
imagingmode|= kPsychNeedFastBackingStore;
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Trying to enable imaging pipeline for dual-window stereo display mode or dual-window output mode...\n");
}
//set the video mode to change the pixel size. TO DO: Set the rect and the default color
PsychGetScreenSettings(screenNumber, &screenSettings);
PsychInitDepthStruct(&(screenSettings.depth));
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Here is where all the work goes on:
// If the screen is not already captured then to that:
if(!PsychIsScreenCaptured(screenNumber) && !useAGL) {
PsychCaptureScreen(screenNumber);
}
#if PSYCH_SYSTEM == PSYCH_WINDOWS
// On M$-Windows we currently only support - and therefore require >= 30 bpp color depth.
if (PsychGetScreenDepthValue(screenNumber) < 30) {
// Display running at less than 30 bpp. OpenWindow will fail on M$-Windows anyway, so let's abort
// now.
// Output warning text:
printf("PTB-ERROR: Your display screen %i is not running at the required color depth of at least 30 bit.\n", screenNumber);
printf("PTB-ERROR: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-ERROR: This will not work on Microsoft Windows operating systems.\n");
printf("PTB-ERROR: Please use the 'Display settings' control panel of Windows to change the color depth to\n");
printf("PTB-ERROR: 32 bits per pixel ('True color' or 'Highest' setting) and then retry. It may be neccessary\n");
printf("PTB-ERROR: to restart Matlab after applying the change...\n");
fflush(NULL);
// Release the captured screen:
PsychRestoreScreenSettings(screenNumber);
PsychReleaseScreen(screenNumber);
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// Abort with Matlab error:
PsychErrorExitMsg(PsychError_user, "Insufficient color depth setting for display device (smaller than 30 bpp).");
}
#endif
//if (PSYCH_DEBUG == PSYCH_ON) printf("Entering PsychOpenOnscreenWindow\n");
PsychCopyDepthStruct(&(screenSettings.depth), &useDepth);
// Create the onscreen window and perform initialization of everything except
// imaging pipeline and a few other special quirks. If sharedContextWindow is non-NULL,
// the new window will share its OpenGL context ressources with sharedContextWindow.
// This is typically used for dual-window stereo mode. Btw. If imaging pipeline is really
// active, we force multiSample to zero: This way the system backbuffer / pixelformat
// is enabled without multisampling support, as we do all the multisampling stuff ourselves
// within the imaging pipeline with multisampled drawbuffer FBO's...
didWindowOpen=PsychOpenOnscreenWindow(&screenSettings, &windowRecord, numWindowBuffers, stereomode, rect, ((imagingmode==0 || imagingmode==kPsychNeedFastOffscreenWindows) ? multiSample : 0), sharedContextWindow, specialflags);
if (!didWindowOpen) {
if (!useAGL) {
PsychRestoreScreenSettings(screenNumber);
PsychReleaseScreen(screenNumber);
}
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// We use this dirty hack to exit with an error, but without printing
// an error message. The specific error message has been printed in
// PsychOpenOnscreenWindow() already..
PsychErrMsgTxt("");
}
// Sufficient display depth for full alpha-blending and such?
if (PsychGetScreenDepthValue(screenNumber) < 24) {
// Nope. Output a little warning.
printf("PTB-WARNING: Your display screen %i is not running at 24 bit color depth or higher.\n", screenNumber);
printf("PTB-WARNING: The current setting is %i bit color depth..\n", PsychGetScreenDepthValue(screenNumber));
printf("PTB-WARNING: This could cause failure to work correctly or visual artifacts in stimuli\n");
printf("PTB-WARNING: that involve Alpha-Blending. It can also cause drastically reduced color resolution\n");
printf("PTB-WARNING: for your stimuli! Please try to switch your display to 'True Color' (Windows)\n");
printf("PTB-WARNING: our 'Millions of Colors' (MacOS-X) to get rid of this warning and the visual artifacts.\n");
fflush(NULL);
}
// Define clear color: This depends on the color range of our onscreen window...
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color); //get from user
if(!isArgThere) PsychLoadColorStruct(&color, kPsychIndexColor, PsychGetWhiteValueFromWindow(windowRecord)); //or use the default
PsychCoerceColorMode(&color);
// The imaging pipeline and graphics drivers had over 5 years of time to mature. As of 2012, imaging pipeline based
// support for fast offscreen windows and for stereoscopic display modes is far superior in performance,
// robustness, flexibility and convenience to the legacy method which was used in ptb by default so far.
// Now it is 2012+ and we switch the defaults: If the GPU+driver combo supports it, and usercode doesn't
// actively opt-out of it, we auto-enable use of FBO backed fast offscreen windows. We don't auto-enable
// the full pipeline for stereoscopic display modes, but we print some recommendations to the user to
// consider enabling the full pipeline for stereo display:
if ((windowRecord->gfxcaps & kPsychGfxCapFBO) && !(PsychPrefStateGet_ConserveVRAM() & kPsychDontAutoEnableImagingPipeline)) {
// Support for basic use of the PTB imaging pipeline and/or for fast offscreen windows
// is available - a GPU + driver combo with support for OpenGL framebuffer objects with
// at least RGBA8 format and rectangle rendertargets.
// Usercode doesn't disallow automatic use of imaging pipeline or fast offscreen windows,
// ie. it didn't set the kPsychDontAutoEnableImagingPipeline conserveVRAM flag.
// Good!
// We will therefore auto-enable use of fast offscreen windows:
imagingmode |= kPsychNeedFastOffscreenWindows;
// Is a stereomode requested which would benefit from enabling the full imaging pipeline?
if (stereomode > 0) {
if (((stereomode == kPsychOpenGLStereo) && !(windowRecord->gfxcaps & kPsychGfxCapNativeStereo)) || (stereomode == kPsychFrameSequentialStereo)) {
// Native OpenGL quad-buffered frame-sequential stereo requested, but unsupported by gpu & driver.
// Or use of our own method requested. We have FBO and framebuffer blit support, so we can roll our
// own framesequential stereo by use of the imaging pipeline. Enable basic imaging pipeline:
imagingmode |= kPsychNeedFastBackingStore;
// Override stereomode to our own homegrown implementation:
stereomode = kPsychFrameSequentialStereo;
windowRecord->stereomode = stereomode;
if (PsychPrefStateGet_Verbosity() > 2) {
printf("\n");
printf("PTB-INFO: Your script requests use of frame-sequential stereo, but your graphics card\n");
printf("PTB-INFO: and driver doesn't support this. I will now fully enable the imaging pipeline\n");
printf("PTB-INFO: and use my own home-grown frame-sequential stereo implementation. Note that this\n");
printf("PTB-INFO: may not be as robust and high-performance as using a graphics card with native\n");
printf("PTB-INFO: frame-sequential stereo support. But let's see what i can do for you...\n\n");
}
}
else {
// Yes: Provide the user with recommendations to enable the pipeline.
if (!(imagingmode & kPsychNeedFastBackingStore) && (PsychPrefStateGet_Verbosity() > 2)) {
printf("\n");
printf("PTB-INFO: Your script requests use of a stereoscopic display mode (stereomode = %i).\n", stereomode);
printf("PTB-INFO: Stereoscopic stimulus display is usually more flexible, convenient and robust if\n");
printf("PTB-INFO: the Psychtoolbox imaging pipeline is enabled. Your graphics card is capable\n");
printf("PTB-INFO: of using the pipeline but your script doesn't enable use of the pipeline.\n");
printf("PTB-INFO: I recommend you enable use of the pipeline for enhanced stereo stimulus display.\n");
printf("PTB-INFO: Have a look at the demoscript ImagingStereoDemo.m on how to do this.\n\n");
}
}
}
}
// Query if OpenGL stereo is natively supported or if our own emulation mode will work:
if ((((stereomode == kPsychOpenGLStereo) && !(windowRecord->gfxcaps & kPsychGfxCapNativeStereo)) || (stereomode == kPsychFrameSequentialStereo)) &&
(!(imagingmode & kPsychNeedFastBackingStore) || (windowRecord->stereomode != kPsychFrameSequentialStereo) || !(windowRecord->gfxcaps & kPsychGfxCapFBO))) {
// OpenGL native stereo was requested, but is obviously not supported and we can't roll our own implementation either :-(
printf("\nPTB-ERROR: Asked for OpenGL native stereo (frame-sequential mode) but this doesn't seem to be supported by your graphics hardware or driver.\n");
printf("PTB-ERROR: Unfortunately using my own implementation via imaging pipeline did not work either, due to lack of hardware support, or because\n");
printf("PTB-ERROR: did not allow me to auto-enable the pipeline and use this method. This means game over!\n");
if (PSYCH_SYSTEM == PSYCH_OSX) {
printf("PTB-ERROR: Frame-sequential stereo should be supported on all recent ATI/AMD and NVidia cards on OS/X, except for the Intel onboard chips,\n");
printf("PTB-ERROR: at least in fullscreen mode with OS/X 10.5, and also mostly on OS/X 10.4. If it doesn't work, check for OS updates etc.\n\n");
}
else {
printf("PTB-ERROR: Frame-sequential native stereo on Windows or Linux is usually only supported with the professional line of graphics cards\n");
printf("PTB-ERROR: from NVidia and ATI/AMD, e.g., NVidia Quadro series or ATI Fire series. If you happen to have such a card, check\n");
printf("PTB-ERROR: your driver settings and/or update your graphics driver.\n\n");
}
PsychErrMsgTxt("Frame-Sequential stereo display mode requested, but unsupported. Emulation unsupported as well. Game over!");
}
// Special setup code for dual window stereomode or output mode:
if (stereomode == kPsychDualWindowStereo || (imagingmode & kPsychNeedDualWindowOutput)) {
if (sharedContextWindow) {
// This is creation & setup of the slave onscreen window, ie. the one
// representing the right-eye or channel 1 view. This window doesn't do much. It
// is not used or referenced in the users experiment script. It receives
// its final image content during Screen('Flip') operation of the master
// onscreen window, then gets flipped in sync with the master window.
// Ok, we already have the slave window open and it shares its OpenGL context
// with the master window. Reset its internal reference to the master:
windowRecord->slaveWindow = NULL;
// Reset imagingmode for this window prior to imaging pipeline setup. This
// window is totally passive so it doesn't need the imaging pipeline.
imagingmode = 0;
// Assign this window to the master window as a slave:
sharedContextWindow->slaveWindow = windowRecord;
// Try to optionally enable framelock / swaplock extensions for the window-pair
// if this is supported by the given system configuration. If supported, this
// should guarantee perfect synchronization of bufferswaps across the window-pair:
PsychOSSetupFrameLock(sharedContextWindow, windowRecord);
// Reset master assignment to prepare possible further dual-window config operations:
sharedContextWindow = NULL;
// Activate the IdentitiyBlitChain for the slave window and add a single identity blit
// operation to it: This is needed in PsychPreFlipOperations() for final copy of stimulus
// image into this slave window:
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "IdentityBlitChain", "Builtin:IdentityBlit", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "IdentityBlitChain");
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Created master-slave window relationship for dual-window stereo/output display mode...\n");
// Special config finished. The master-slave combo should work from now on...
}
else {
// This is initial setup & creation of the master onscreen window, ie. the one
// representing the left-eye or channel 0 view and doing all the heavy work, acting as a
// proxy for both windows.
// Not much to do here. Just store its windowRecord as a reference for creation
// of the slave window. We'll need it for that purpose...
sharedContextWindow = windowRecord;
}
}
// Set special half-width flag for window if we are either in a dual-display/dual-view stereo mode or if
// if is requested as part of the imagingMode flag. This will cause PTB 2D drawing routines and window size
// query routines etc. to return an effective window width or window rect only half the real width.
if (windowRecord->stereomode==kPsychFreeFusionStereo || windowRecord->stereomode==kPsychFreeCrossFusionStereo || (imagingmode & kPsychHalfWidthWindow)) {
windowRecord->specialflags = windowRecord->specialflags | kPsychHalfWidthWindow;
imagingmode = imagingmode & (~kPsychHalfWidthWindow);
}
// Similar handling for twice-width windows: Used for certain packed-pixels (2 stimulus pixels in one fb pixel) formats:
if (imagingmode & kPsychTwiceWidthWindow) {
windowRecord->specialflags = windowRecord->specialflags | kPsychTwiceWidthWindow;
imagingmode = imagingmode & (~kPsychTwiceWidthWindow);
}
// Similar handling for windows of half the real height, except that none of our built-in stereo modes requires these,
// so this is only done on request from external code via the imagingmode flag kPsychHalfHeightWindow.
// One use of this is when using interleaved line stereo mode (PsychImaging(...'InterleavedLineStereo')) where windows
// only have a useable net height of half their physical height:
if (imagingmode & kPsychHalfHeightWindow) {
windowRecord->specialflags = windowRecord->specialflags | kPsychHalfHeightWindow;
imagingmode = imagingmode & (~kPsychHalfHeightWindow);
}
// Define windows clientrect. It is a copy of windows rect, but stretched or compressed
// to twice or half the width or height of the windows rect, depending on the special size
// flags. clientrect is used as reference for all size query functions Screen('Rect'), Screen('WindowSize')
// and for all Screen 2D drawing functions:
PsychSetupClientRect(windowRecord);
// Initialize internal image processing pipeline if requested:
if (numWindowBuffers > 0) PsychInitializeImagingPipeline(windowRecord, imagingmode, multiSample);
// On OS-X, if we are in quad-buffered frame sequential stereo mode, we automatically generate
// blue-line-sync style sync lines for use with stereo shutter glasses. We don't do this
// by default on Windows or Linux: These systems either don't have stereo capable hardware,
// or they have some and its drivers already take care of sync signal generation.
if (((PSYCH_SYSTEM == PSYCH_OSX) && (windowRecord->stereomode == kPsychOpenGLStereo)) || (windowRecord->stereomode == kPsychFrameSequentialStereo)) {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Enabling internal blue line sync renderer for quad-buffered stereo...\n");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "LeftFinalizerBlitChain", "Builtin:RenderStereoSyncLine", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "LeftFinalizerBlitChain");
PsychPipelineAddBuiltinFunctionToHook(windowRecord, "RightFinalizerBlitChain", "Builtin:RenderStereoSyncLine", INT_MAX, "");
PsychPipelineEnableHook(windowRecord, "RightFinalizerBlitChain");
}
// Activate new onscreen window for userspace drawing: If imaging pipeline is active, this
// will bind the correct rendertargets for the first time. We soft-reset first to get
// into a defined state:
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
PsychSetDrawingTarget(windowRecord);
// Set the clear color and perform a backbuffer-clear:
PsychConvertColorToDoubleVector(&color, windowRecord, windowRecord->clearColor);
PsychGLClear(windowRecord);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// Make sure no OpenGL errors happened up to this point:
PsychTestForGLErrors();
// If we are in logo-startup mode (former blue-screen mode) and double-buffering
// is enabled, then do an initial bufferswap & clear, so the display starts in
// the user selected background color instead of staying at the blue screen or
// logo display until the Matlab script first calls 'Flip'.
if (((PsychPrefStateGet_VisualDebugLevel()>=4) || (windowRecord->stereomode > 0)) && numWindowBuffers>=2) {
// Do three immediate bufferswaps by an internal call to Screen('Flip'). This will also
// take care of clearing the backbuffer in preparation of first userspace drawing
// commands and such. We need up-to 3 calls to clear triple-buffered setups from framebuffer junk.
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
PsychFlipWindowBuffers(windowRecord, 0, 0, 0, 0, &dummy1, &dummy2, &dummy3, &dummy4);
// Display now shows background color, so user knows that PTB's 'OpenWindow'
// procedure is successfully finished.
}
PsychTestForGLErrors();
// Reset flipcounter to zero:
windowRecord->flipCount = 0;
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, windowRecord->windowIndex);
// Optionally return the windows clientrect:
PsychCopyOutRectArg(2, FALSE, windowRecord->clientrect);
return(PsychError_none);
}
