PsychError SCREENglPoint(void)
{
PsychColorType color;
double *xPosition, *yPosition, dotSize;
PsychWindowRecordType *windowRecord;
int whiteValue;
psych_bool isArgThere;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
//Get the color argument or use the default, then coerce to the form determened by the window depth.
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color);
if(!isArgThere){
whiteValue=PsychGetWhiteValueFromWindow(windowRecord);
PsychLoadColorStruct(&color, kPsychIndexColor, whiteValue ); //index mode will coerce to any other.
}
PsychCoerceColorMode( &color);
//get the x and y position values.
PsychAllocInDoubleArg(3, TRUE, &xPosition);
PsychAllocInDoubleArg(4, TRUE, &yPosition);
dotSize=1; //set the default
PsychCopyInDoubleArg(5, FALSE, &dotSize);
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Set default draw shader:
PsychSetShader(windowRecord, -1);
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
PsychSetGLColor(&color, windowRecord);
glEnable(GL_POINT_SMOOTH);
glPointSize((float)dotSize);
glBegin(GL_POINTS);
glVertex2d( (GLdouble)*xPosition, *yPosition);
glEnd();
glDisable(GL_POINT_SMOOTH);
glPointSize(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
return(PsychError_none);
}
/* PsychGLClear()
*
* Helper around glClearColor() and glClear() - takes special issues
* caused by HDR framebuffer support into account.
*/
void PsychGLClear(PsychWindowRecordType *windowRecord)
{
int oldShader, nowShader;
// Unclamped/High-precision color mode enabled via GLSL shaders?
if ((windowRecord->defaultDrawShader != 0) && (windowRecord->defaultDrawShader == windowRecord->unclampedDrawShader)) {
// Yes. Can't use standard clear, but need to clear via drawing a full-window rect with
// clear color:
// Query currently bound shader:
oldShader = PsychGetCurrentShader(windowRecord);
// Assign hdr draw shader:
nowShader = PsychSetShader(windowRecord, -1);
// Assign HDR clear color for window:
HDRglColor4dv(windowRecord->clearColor);
// Draw a fullscreen rect in the clear color, make sure
// no alpha blending is active:
if (glIsEnabled(GL_BLEND)) {
glDisable(GL_BLEND);
PsychGLRect(windowRecord->rect);
glEnable(GL_BLEND);
}
else {
PsychGLRect(windowRecord->rect);
}
// Revert to old shader binding:
if (nowShader != oldShader) PsychSetShader(windowRecord, oldShader);
}
else {
// Standard clear path: Can use OpenGL's fast color buffer clear:
glClearColor((GLclampf) windowRecord->clearColor[0], (GLclampf) windowRecord->clearColor[1], (GLclampf) windowRecord->clearColor[2], (GLclampf) windowRecord->clearColor[3]);
glClear(GL_COLOR_BUFFER_BIT);
}
return;
}
PsychError SCREENFillPoly(void)
{
PsychColorType color;
PsychWindowRecordType *windowRecord;
double whiteValue;
int i, mSize, nSize, pSize;
psych_bool isArgThere;
double *pointList;
double isConvex;
int j,k;
int flag;
double z;
combinerCacheSlot = 0;
combinerCacheSize = 0;
combinerCache = NULL;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(4)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
//Get the color argument or use the default, then coerce to the form determened by the window depth.
isArgThere=PsychCopyInColorArg(2, FALSE, &color);
if(!isArgThere){
whiteValue=PsychGetWhiteValueFromWindow(windowRecord);
PsychLoadColorStruct(&color, kPsychIndexColor, whiteValue ); //index mode will coerce to any other.
}
PsychCoerceColorMode( &color);
//get the list of pairs and validate.
PsychAllocInDoubleMatArg(3, kPsychArgRequired, &mSize, &nSize, &pSize, &pointList);
if(nSize!=2) PsychErrorExitMsg(PsychError_user, "Width of pointList must be 2");
if(mSize<3) PsychErrorExitMsg(PsychError_user, "Polygons must consist of at least 3 points; M dimension of pointList was < 3!");
if(pSize>1) PsychErrorExitMsg(PsychError_user, "pointList must be a 2D matrix, not a 3D matrix!");
isConvex = -1;
PsychCopyInDoubleArg(4, kPsychArgOptional, &isConvex);
// On non-OpenGL1/2 we always force isConvex to zero, so the GLU tesselator is
// always used. This because the tesselator only emits GL_TRIANGLES and GL_TRIANGLE_STRIP
// and GL_TRIANGLE_FANS primitives which are supported on all current OpenGL API's, whereas
// or "classic" fast-path needs GL_POLYGONS, which are only supported on classic OpenGL1/2:
if (!PsychIsGLClassic(windowRecord)) isConvex = 0;
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Set default drawshader:
PsychSetShader(windowRecord, -1);
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
PsychSetGLColor(&color, windowRecord);
///////// Test for convexity ////////
// This algorithm checks, if the polygon is definitely convex, or not.
// We take the slow-path, if polygon is non-convex or if we can't prove
// that it is convex.
//
// Algorithm adapted from: http://astronomy.swin.edu.au/~pbourke/geometry/clockwise/
// Which was written by Paul Bourke, 1998.
//
// -> This webpage explains the mathematical principle behind the test and provides
// a C-Source file which has been adapted for use here.
//
if (isConvex == -1) {
flag = 0;
for (i=0; i < mSize; i++) {
j = (i + 1) % mSize;
k = (i + 2) % mSize;
z = (pointList[j] - pointList[i]) * (pointList[k+mSize] - pointList[j+mSize]);
z -= (pointList[j+mSize] - pointList[i+mSize]) * (pointList[k] - pointList[j]);
if (z < 0) {
flag |= 1;
}
else if (z > 0) {
flag |= 2;
}
if (flag == 3) {
// This is definitely a CONCAVE polygon --> not Convex --> Take slow but safe path.
break;
}
}
if (flag!=0 && flag!=3) {
// This is a convex polygon --> Take fast path.
isConvex = 1;
}
else {
// This is a complex polygon --> can't determine if it is convex or not --> Take slow but safe path.
isConvex = 0;
}
}
////// Switch between fast path and slow path, depending on convexity of polygon:
if (isConvex > 0) {
// Convex, non-self-intersecting polygon - Take the fast-path:
glBegin(GL_POLYGON);
for(i=0;i<mSize;i++) glVertex2d((GLdouble)pointList[i], (GLdouble)pointList[i+mSize]);
glEnd();
}
else {
// Possibly concave and/or self-intersecting polygon - At least we couldn't prove it is convex.
// Take the slow, but safe, path using GLU-Tesselators to break it up into a couple of convex, simple
// polygons:
// Create and initialize a new GLU-Tesselator object, if needed:
if (NULL == tess) {
// Create tesselator:
tess = gluNewTess();
if (NULL == tess) PsychErrorExitMsg(PsychError_outofMemory, "Out of memory condition in Screen('FillPoly')! Not enough space.");
// Assign our callback-functions:
gluTessCallback(tess, GLU_TESS_BEGIN, GLUTESSCBCASTER PsychtcbBegin);
gluTessCallback(tess, GLU_TESS_VERTEX, GLUTESSCBCASTER PsychtcbVertex);
gluTessCallback(tess, GLU_TESS_END, GLUTESSCBCASTER PsychtcbEnd);
gluTessCallback(tess, GLU_TESS_COMBINE, GLUTESSCBCASTER PsychtcbCombine);
// Define all tesselated polygons to lie in the x-y plane:
gluTessNormal(tess, 0, 0, 1);
}
// We need to hold the values in a temporary array:
if (tempvsize < mSize) {
tempvsize = ((mSize / 1000) + 1) * 1000;
tempv = (double*) realloc((void*) tempv, sizeof(double) * 3 * tempvsize);
if (NULL == tempv) PsychErrorExitMsg(PsychError_outofMemory, "Out of memory condition in Screen('FillPoly')! Not enough space.");
}
// Now submit our Polygon for tesselation:
gluTessBeginPolygon(tess, NULL);
gluTessBeginContour(tess);
for(i=0; i < mSize; i++) {
tempv[i*3]=(GLdouble) pointList[i];
tempv[i*3+1]=(GLdouble) pointList[i+mSize];
tempv[i*3+2]=0;
gluTessVertex(tess, (GLdouble*) &(tempv[i*3]), (void*) &(tempv[i*3]));
}
// Process, finalize and render it by calling our callback-functions:
gluTessEndContour(tess);
gluTessEndPolygon (tess);
// Done with drawing the filled polygon. (Slow-Path)
}
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// printf("CombinerCalls %i out of %i allocated.\n", combinerCacheSlot, combinerCacheSize);
return(PsychError_none);
}
PsychError SCREENGetImage(void)
{
PsychRectType windowRect,sampleRect;
int nrchannels, ix, iy, sampleRectWidth, sampleRectHeight, invertedY, redReturnIndex, greenReturnIndex, blueReturnIndex, alphaReturnIndex, planeSize;
int viewid;
ubyte *returnArrayBase, *redPlane, *greenPlane, *bluePlane, *alphaPlane;
float *dredPlane, *dgreenPlane, *dbluePlane, *dalphaPlane;
double *returnArrayBaseDouble;
PsychWindowRecordType *windowRecord;
GLboolean isDoubleBuffer, isStereo;
char* buffername = NULL;
boolean floatprecision = FALSE;
GLenum whichBuffer = 0;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the numbers of inputs and outputs
PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Get windowRecord for this window:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Set window as drawingtarget: Even important if this binding is changed later on!
// We need to make sure all needed transitions are done - esp. in non-imaging mode,
// so backbuffer is in a useable state:
PsychSetDrawingTarget(windowRecord);
// Disable shaders:
PsychSetShader(windowRecord, 0);
// Soft-Reset drawingtarget. This is important to make sure no FBO's are bound,
// otherwise the following glGets for GL_DOUBLEBUFFER and GL_STEREO will retrieve
// wrong results, leading to totally wrong read buffer assignments down the road!!
PsychSetDrawingTarget(0x1);
glGetBooleanv(GL_DOUBLEBUFFER, &isDoubleBuffer);
glGetBooleanv(GL_STEREO, &isStereo);
// Retrieve optional read rectangle:
PsychGetRectFromWindowRecord(windowRect, windowRecord);
if(!PsychCopyInRectArg(2, FALSE, sampleRect)) memcpy(sampleRect, windowRect, sizeof(PsychRectType));
if (IsPsychRectEmpty(sampleRect)) return(PsychError_none);
// Assign read buffer:
if(PsychIsOnscreenWindow(windowRecord)) {
// Onscreen window: We read from the front- or front-left buffer by default.
// This works on single-buffered and double buffered contexts in a consistent fashion:
// Copy in optional override buffer name:
PsychAllocInCharArg(3, FALSE, &buffername);
// Override buffer name provided?
if (buffername) {
// Which one is it?
// "frontBuffer" is always a valid choice:
if (PsychMatch(buffername, "frontBuffer")) whichBuffer = GL_FRONT;
// Allow selection of left- or right front stereo buffer in stereo mode:
if (PsychMatch(buffername, "frontLeftBuffer") && isStereo) whichBuffer = GL_FRONT_LEFT;
if (PsychMatch(buffername, "frontRightBuffer") && isStereo) whichBuffer = GL_FRONT_RIGHT;
// Allow selection of backbuffer in double-buffered mode:
if (PsychMatch(buffername, "backBuffer") && isDoubleBuffer) whichBuffer = GL_BACK;
// Allow selection of left- or right back stereo buffer in stereo mode:
if (PsychMatch(buffername, "backLeftBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_LEFT;
if (PsychMatch(buffername, "backRightBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_RIGHT;
// Allow AUX buffer access for debug purposes:
if (PsychMatch(buffername, "aux0Buffer")) whichBuffer = GL_AUX0;
if (PsychMatch(buffername, "aux1Buffer")) whichBuffer = GL_AUX1;
if (PsychMatch(buffername, "aux2Buffer")) whichBuffer = GL_AUX2;
if (PsychMatch(buffername, "aux3Buffer")) whichBuffer = GL_AUX3;
}
else {
// Default is frontbuffer:
whichBuffer=GL_FRONT;
}
}
else {
// Offscreen window or texture: They only have one buffer, which is the
// backbuffer in double-buffered mode and the frontbuffer in single buffered mode:
whichBuffer=(isDoubleBuffer) ? GL_BACK : GL_FRONT;
}
// Enable this windowRecords framebuffer as current drawingtarget. This should
// also allow us to "GetImage" from Offscreen windows:
if ((windowRecord->imagingMode & kPsychNeedFastBackingStore) || (windowRecord->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Special case: Imaging pipeline active - We need to activate system framebuffer
// so we really read the content of the framebuffer and not of some FBO:
if (PsychIsOnscreenWindow(windowRecord)) {
// It's an onscreen window:
if (buffername && (PsychMatch(buffername, "drawBuffer")) && (windowRecord->imagingMode & kPsychNeedFastBackingStore)) {
// Activate drawBufferFBO:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// Is the drawBufferFBO multisampled?
viewid = (((windowRecord->stereomode > 0) && (windowRecord->stereodrawbuffer == 1)) ? 1 : 0);
if (windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->multisample > 0) {
// It is! We can't read from a multisampled FBO. Need to perform a multisample resolve operation and read
// from the resolved unisample buffer instead. This is only safe if the unisample buffer is either a dedicated
// FBO, or - in case its the final system backbuffer etc. - if preflip operations haven't been performed yet.
// If non dedicated buffer (aka finalizedFBO) and preflip ops have already happened, then the backbuffer contains
// final content for an upcoming Screen('Flip') and we can't use (and therefore taint) that buffer.
if ((windowRecord->inputBufferFBO[viewid] == windowRecord->finalizedFBO[viewid]) && (windowRecord->backBufferBackupDone)) {
// Target for resolve is finalized FBO (probably system backbuffer) and preflip ops have run already. We
// can't do the resolve op, as this would screw up the backbuffer with the final stimulus:
printf("PTB-ERROR: Tried to 'GetImage' from a multisampled 'drawBuffer', but can't perform anti-aliasing pass due to\n");
printf("PTB-ERROR: lack of a dedicated resolve buffer.\n");
printf("PTB-ERROR: You can get what you wanted by either one of two options:\n");
printf("PTB-ERROR: Either enable a processing stage in the imaging pipeline, even if you don't need it, e.g., by setting\n");
printf("PTB-ERROR: the imagingmode argument in the 'OpenWindow' call to kPsychNeedImageProcessing, this will create a\n");
printf("PTB-ERROR: suitable resolve buffer. Or place the 'GetImage' call before any Screen('DrawingFinished') call, then\n");
printf("PTB-ERROR: i can (ab-)use the system backbuffer as a temporary resolve buffer.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled 'drawBuffer'. Unsupported operation under given conditions.");
}
else {
// Ok, the inputBufferFBO is a suitable temporary resolve buffer. Perform a multisample resolve blit to it:
// A simple glBlitFramebufferEXT() call will do the copy & downsample operation:
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->fboid);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
glBlitFramebufferEXT(0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
// Bind inputBuffer as framebuffer:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
viewid = -1;
}
}
}
else {
// Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
}
else {
// Offscreen window or texture: Select drawing target as usual,
// but set color attachment as read buffer:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// We do not support multisampled readout:
if (windowRecord->fboTable[windowRecord->drawBufferFBO[0]]->multisample > 0) {
printf("PTB-ERROR: You tried to Screen('GetImage', ...); from an offscreen window or texture which has multisample anti-aliasing enabled.\n");
printf("PTB-ERROR: This operation is not supported. You must first use Screen('CopyWindow') to create a non-multisampled copy of the\n");
printf("PTB-ERROR: texture or offscreen window, then use 'GetImage' on that copy. The copy will be anti-aliased, so you'll get what you\n");
printf("PTB-ERROR: wanted with a bit more effort. Sorry for the inconvenience, but this is mostly a hardware limitation.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled texture or offscreen window. Unsupported operation.");
}
}
}
else {
// Normal case: No FBO based imaging - Select drawing target as usual:
PsychSetDrawingTarget(windowRecord);
}
// Select requested read buffer, after some double-check:
if (whichBuffer == 0) PsychErrorExitMsg(PsychError_user, "Invalid or unknown 'bufferName' argument provided.");
glReadBuffer(whichBuffer);
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In Screen('GetImage'): GL-Readbuffer whichBuffer = %i\n", whichBuffer);
// Get optional floatprecision flag: We return data with float-precision if
// this flag is set. By default we return uint8 data:
PsychCopyInFlagArg(4, FALSE, &floatprecision);
// Get the optional number of channels flag: By default we return 3 channels,
// the Red, Green, and blue color channel:
nrchannels = 3;
PsychCopyInIntegerArg(5, FALSE, &nrchannels);
if (nrchannels < 1 || nrchannels > 4) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' must be between 1 and 4!");
sampleRectWidth=PsychGetWidthFromRect(sampleRect);
sampleRectHeight=PsychGetHeightFromRect(sampleRect);
if (!floatprecision) {
// Readback of standard 8bpc uint8 pixels:
PsychAllocOutUnsignedByteMatArg(1, TRUE, sampleRectHeight, sampleRectWidth, nrchannels, &returnArrayBase);
redPlane= PsychMallocTemp(nrchannels * sizeof(GL_UNSIGNED_BYTE) * sampleRectWidth * sampleRectHeight);
planeSize=sampleRectWidth * sampleRectHeight;
greenPlane= redPlane + planeSize;
bluePlane= redPlane + 2 * planeSize;
alphaPlane= redPlane + 3 * planeSize;
glPixelStorei(GL_PACK_ALIGNMENT,1);
invertedY=windowRect[kPsychBottom]-sampleRect[kPsychBottom];
glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RED, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels>1) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_GREEN, GL_UNSIGNED_BYTE, greenPlane);
if (nrchannels>2) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_BLUE, GL_UNSIGNED_BYTE, bluePlane);
if (nrchannels>3) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_ALPHA, GL_UNSIGNED_BYTE, alphaPlane);
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0;ix<sampleRectWidth;ix++){
for(iy=0;iy<sampleRectHeight;iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBase[redReturnIndex]=redPlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
// Other channels on demand:
if (nrchannels>1) returnArrayBase[greenReturnIndex]=greenPlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
if (nrchannels>2) returnArrayBase[blueReturnIndex]=bluePlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
if (nrchannels>3) returnArrayBase[alphaReturnIndex]=alphaPlane[ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth];
}
}
}
else {
// Readback of standard 32bpc float pixels into a double matrix:
PsychAllocOutDoubleMatArg(1, TRUE, sampleRectHeight, sampleRectWidth, nrchannels, &returnArrayBaseDouble);
dredPlane= PsychMallocTemp(nrchannels * sizeof(GL_FLOAT) * sampleRectWidth * sampleRectHeight);
planeSize=sampleRectWidth * sampleRectHeight * sizeof(GL_FLOAT);
dgreenPlane= redPlane + planeSize;
dbluePlane= redPlane + 2 * planeSize;
dalphaPlane= redPlane + 3 * planeSize;
glPixelStorei(GL_PACK_ALIGNMENT, 1);
invertedY=windowRect[kPsychBottom]-sampleRect[kPsychBottom];
if (nrchannels==1) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RED, GL_FLOAT, dredPlane);
if (nrchannels==2) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_LUMINANCE_ALPHA, GL_FLOAT, dredPlane);
if (nrchannels==3) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RGB, GL_FLOAT, dredPlane);
if (nrchannels==4) glReadPixels(sampleRect[kPsychLeft],invertedY, sampleRectWidth, sampleRectHeight, GL_RGBA, GL_FLOAT, dredPlane);
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0;ix<sampleRectWidth;ix++){
for(iy=0;iy<sampleRectHeight;iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBaseDouble[redReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 0];
// Other channels on demand:
if (nrchannels>1) returnArrayBaseDouble[greenReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 1];
if (nrchannels>2) returnArrayBaseDouble[blueReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 2];
if (nrchannels>3) returnArrayBaseDouble[alphaReturnIndex]=dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * nrchannels + 3];
}
}
}
if (viewid == -1) {
// Need to reset framebuffer binding to get rid of the inputBufferFBO which is bound due to
// multisample resolve ops --> Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
return(PsychError_none);
}
PsychError SCREENMakeTexture(void)
{
int ix;
PsychWindowRecordType *textureRecord;
PsychWindowRecordType *windowRecord;
PsychRectType rect;
Boolean isImageMatrixBytes, isImageMatrixDoubles;
int numMatrixPlanes, xSize, ySize, iters;
unsigned char *byteMatrix;
double *doubleMatrix;
GLuint *texturePointer;
GLubyte *texturePointer_b;
GLfloat *texturePointer_f;
double *rp, *gp, *bp, *ap;
GLubyte *rpb, *gpb, *bpb, *apb;
int usepoweroftwo, usefloatformat, assume_texorientation, textureShader;
double optimized_orientation;
Boolean bigendian;
// Detect endianity (byte-order) of machine:
ix=255;
rpb=(GLubyte*) &ix;
bigendian = ( *rpb == 255 ) ? FALSE : TRUE;
ix = 0; rpb = NULL;
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #1
StoreNowTime();
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//Get the window structure for the onscreen window. It holds the onscreein GL context which we will need in the
//final step when we copy the texture from system RAM onto the screen.
PsychErrorExit(PsychCapNumInputArgs(7));
PsychErrorExit(PsychRequireNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(1));
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if((windowRecord->windowType!=kPsychDoubleBufferOnscreen) && (windowRecord->windowType!=kPsychSingleBufferOnscreen))
PsychErrorExitMsg(PsychError_user, "MakeTexture called on something else than a onscreen window");
// Get optional texture orientation flag:
assume_texorientation = 0;
PsychCopyInIntegerArg(6, FALSE, &assume_texorientation);
// Get optional texture shader handle:
textureShader = 0;
PsychCopyInIntegerArg(7, FALSE, &textureShader);
//get the argument and sanity check it.
isImageMatrixBytes=PsychAllocInUnsignedByteMatArg(2, kPsychArgAnything, &ySize, &xSize, &numMatrixPlanes, &byteMatrix);
isImageMatrixDoubles=PsychAllocInDoubleMatArg(2, kPsychArgAnything, &ySize, &xSize, &numMatrixPlanes, &doubleMatrix);
if(numMatrixPlanes > 4)
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Specified image matrix exceeds maximum depth of 4 layers");
if(ySize<1 || xSize <1)
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Specified image matrix must be at least 1 x 1 pixels in size");
if(! (isImageMatrixBytes || isImageMatrixDoubles))
PsychErrorExitMsg(PsychError_user, "Illegal argument type"); //not likely.
// Is this a special image matrix which is already pre-transposed to fit our optimal format?
if (assume_texorientation == 2) {
// Yes. Swap xSize and ySize to take this into account:
ix = xSize;
xSize = ySize;
ySize = ix;
ix = 0;
}
// Build defining rect for this texture:
PsychMakeRect(rect, 0, 0, xSize, ySize);
// Copy in texture preferred draw orientation hint. We default to zero degrees, if
// not provided.
// This parameter is not yet used. It is silently ignorerd for now...
optimized_orientation = 0;
PsychCopyInDoubleArg(3, FALSE, &optimized_orientation);
// Copy in special creation mode flag: It defaults to zero. If set to 1 then we
// always create a power-of-two GL_TEXTURE_2D texture. This is useful if one wants
// to create and use drifting gratings with no effort - texture wrapping is only available
// for GL_TEXTURE_2D, not for non-pot types. It is also useful if the texture is to be
// exported to external OpenGL code to simplify tex coords assignments.
usepoweroftwo=0;
PsychCopyInIntegerArg(4, FALSE, &usepoweroftwo);
// Check if size constraints are fullfilled for power-of-two mode:
if (usepoweroftwo & 1) {
for(ix = 1; ix < xSize; ix*=2);
if (ix!=xSize) {
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Power-of-two texture requested but width of imageMatrix is not a power of two!");
}
for(ix = 1; ix < ySize; ix*=2);
if (ix!=ySize) {
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Power-of-two texture requested but height of imageMatrix is not a power of two!");
}
}
// Check if creation of a floating point texture is requested? We default to non-floating point,
// standard 8 bpc textures if this parameter is not provided.
usefloatformat = 0;
PsychCopyInIntegerArg(5, FALSE, &usefloatformat);
if (usefloatformat<0 || usefloatformat>2) PsychErrorExitMsg(PsychError_user, "Invalid value for 'floatprecision' parameter provided! Valid values are 0 for 8bpc int, 1 for 16bpc float or 2 for 32bpc float.");
if (usefloatformat && !isImageMatrixDoubles) {
// Floating point texture requested. We only support this if our input is a double matrix, not
// for uint8 matrices - converting them to float precision would be just a waste of ressources
// without any benefit for precision.
PsychErrorExitMsg(PsychError_user, "Creation of a floating point precision texture requested, but uint8 matrix provided! Only double matrices are acceptable for this mode.");
}
//Create a texture record. Really just a window record adapted for textures.
PsychCreateWindowRecord(&textureRecord); //this also fills the window index field.
textureRecord->windowType=kPsychTexture;
// MK: We need to assign the screen number of the onscreen-window, so PsychCreateTexture()
// can query the size of the screen/onscreen-window...
textureRecord->screenNumber=windowRecord->screenNumber;
textureRecord->depth=32;
PsychCopyRect(textureRecord->rect, rect);
//Allocate the texture memory and copy the MATLAB matrix into the texture memory.
// MK: We only allocate the amount really needed for given format, aka numMatrixPlanes - Bytes per pixel.
if (usefloatformat) {
// Allocate a double for each color component and pixel:
textureRecord->textureMemorySizeBytes= sizeof(double) * numMatrixPlanes * xSize * ySize;
}
else {
// Allocate one byte per color component and pixel:
textureRecord->textureMemorySizeBytes= numMatrixPlanes * xSize * ySize;
}
// MK: Allocate memory page-aligned... -> Helps Apple texture range extensions et al.
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #2
StoreNowTime();
textureRecord->textureMemory=malloc(textureRecord->textureMemorySizeBytes);
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #3
StoreNowTime();
texturePointer=textureRecord->textureMemory;
// Does script explicitely request usage of a GL_TEXTURE_2D power-of-two texture?
if (usepoweroftwo & 1) {
// Enforce creation as a power-of-two texture:
textureRecord->texturetarget=GL_TEXTURE_2D;
}
// Now the conversion routines that convert Matlab/Octave matrices into memory
// buffers suitable for OpenGL:
if (usefloatformat) {
// Conversion routines for HDR 16 bpc or 32 bpc textures -- Slow path.
// Our input is always double matrices...
iters = xSize * ySize;
// Our input buffer is always of GL_FLOAT precision:
textureRecord->textureexternaltype = GL_FLOAT;
texturePointer_f=(GLfloat*) texturePointer;
if(numMatrixPlanes==1) {
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(doubleMatrix++);
}
textureRecord->depth=(usefloatformat==1) ? 16 : 32;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_LUMINANCE_FLOAT16_APPLE : GL_LUMINANCE_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_LUMINANCE;
}
if(numMatrixPlanes==2) {
rp=(double*) ((psych_uint64) doubleMatrix);
ap=(double*) ((psych_uint64) doubleMatrix + (psych_uint64) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(ap++);
}
textureRecord->depth=(usefloatformat==1) ? 32 : 64;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_LUMINANCE_ALPHA_FLOAT16_APPLE : GL_LUMINANCE_ALPHA_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_LUMINANCE_ALPHA;
}
if(numMatrixPlanes==3) {
rp=(double*) ((psych_uint64) doubleMatrix);
gp=(double*) ((psych_uint64) doubleMatrix + (psych_uint64) iters*sizeof(double));
bp=(double*) ((psych_uint64) gp + (psych_uint64) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(gp++);
*(texturePointer_f++)= (GLfloat) *(bp++);
}
textureRecord->depth=(usefloatformat==1) ? 48 : 96;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_RGB_FLOAT16_APPLE : GL_RGB_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_RGB;
}
if(numMatrixPlanes==4) {
rp=(double*) ((psych_uint64) doubleMatrix);
gp=(double*) ((psych_uint64) doubleMatrix + (psych_uint64) iters*sizeof(double));
bp=(double*) ((psych_uint64) gp + (psych_uint64) iters*sizeof(double));
ap=(double*) ((psych_uint64) bp + (psych_uint64) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(gp++);
*(texturePointer_f++)= (GLfloat) *(bp++);
*(texturePointer_f++)= (GLfloat) *(ap++);
}
textureRecord->depth=(usefloatformat==1) ? 64 : 128;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_RGBA_FLOAT16_APPLE : GL_RGBA_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_RGBA;
}
// This is a special workaround for bugs in FLOAT16 texture creation on Mac OS/X 10.4.x and 10.5.x.
// The OpenGL fails to properly flush very small values (< 1e-9) to zero when creating a FLOAT16
// type texture. Instead it seems to initialize with trash data, corrupting the texture.
// Therefore, if FLOAT16 texture creation is requested, we loop over the whole input buffer and
// set all values with magnitude smaller than 1e-9 to zero. Better safe than sorry...
if(usefloatformat==1) {
texturePointer_f=(GLfloat*) texturePointer;
iters = iters * numMatrixPlanes;
for(ix=0; ix<iters; ix++, texturePointer_f++) if(fabs((double) *texturePointer_f) < 1e-9) { *texturePointer_f = 0.0; }
}
// End of HDR conversion code...
}
else {
// Standard LDR texture 8 bpc conversion routines -- Fast path.
// Improved implementation: Takes 13 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==1){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(doubleMatrix++);
}
textureRecord->depth=8;
}
// Improved version: Takes 3 ms on a 800x800 texture...
// NB: Implementing memcpy manually by a for-loop takes 10 ms! This is a huge difference.
// -> That's because memcpy on MacOS-X is implemented with hand-coded, highly tuned Assembler code for PowerPC.
// -> It's always wise to use system-routines if available, instead of coding it by yourself!
if(isImageMatrixBytes && numMatrixPlanes==1){
memcpy((void*) texturePointer, (void*) byteMatrix, xSize*ySize);
textureRecord->depth=8;
}
// New version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==2){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
rp=(double*) ((psych_uint64) doubleMatrix);
ap=(double*) ((psych_uint64) doubleMatrix + (psych_uint64) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(ap++);
}
textureRecord->depth=16;
}
// New version: Takes 20 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==2){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
rpb=(GLubyte*) ((psych_uint64) byteMatrix);
apb=(GLubyte*) ((psych_uint64) byteMatrix + (psych_uint64) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(apb++);
}
textureRecord->depth=16;
}
// Improved version: Takes 43 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
rp=(double*) ((psych_uint64) doubleMatrix);
gp=(double*) ((psych_uint64) doubleMatrix + (psych_uint64) iters*sizeof(double));
bp=(double*) ((psych_uint64) gp + (psych_uint64) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
textureRecord->depth=24;
}
// Improved version: Takes 25 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
rpb=(GLubyte*) ((psych_uint64) byteMatrix);
gpb=(GLubyte*) ((psych_uint64) byteMatrix + (psych_uint64) iters);
bpb=(GLubyte*) ((psych_uint64) gpb + (psych_uint64) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(bpb++);
}
textureRecord->depth=24;
}
// Improved version: Takes 55 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
rp=(double*) ((psych_uint64) doubleMatrix);
gp=(double*) ((psych_uint64) doubleMatrix + (psych_uint64) iters*sizeof(double));
bp=(double*) ((psych_uint64) gp + (psych_uint64) iters*sizeof(double));
ap=(double*) ((psych_uint64) bp + (psych_uint64) iters*sizeof(double));
if (bigendian) {
// Code for big-endian machines like PowerPC:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(ap++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
}
else {
// Code for little-endian machines like Intel Pentium:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(bp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(ap++);
}
}
textureRecord->depth=32;
}
// Improved version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
iters=xSize*ySize;
rpb=(GLubyte*) ((psych_uint64) byteMatrix);
gpb=(GLubyte*) ((psych_uint64) byteMatrix + (psych_uint64) iters);
bpb=(GLubyte*) ((psych_uint64) gpb + (psych_uint64) iters);
apb=(GLubyte*) ((psych_uint64) bpb + (psych_uint64) iters);
if (bigendian) {
// Code for big-endian machines like PowerPC:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(apb++);
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(bpb++);
}
}
else {
// Code for little-endian machines like Intel Pentium:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(bpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(apb++);
}
}
textureRecord->depth=32;
}
} // End of 8 bpc texture conversion code (fast-path for LDR textures)
// The memory buffer now contains our texture data in a format ready to submit to OpenGL.
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Texture orientation is zero aka transposed aka non-renderswapped.
textureRecord->textureOrientation = ((assume_texorientation != 2) && (assume_texorientation != 3)) ? 0 : 2;
// This is our best guess about the number of image channels:
textureRecord->nrchannels = numMatrixPlanes;
// Let's create and bind a new texture object and fill it with our new texture data.
PsychCreateTexture(textureRecord);
// Assign GLSL filter-/lookup-shaders if needed:
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, usefloatformat, (usepoweroftwo & 2) ? 1 : 0);
// User specified override shader for this texture provided? This is useful for
// basic image processing and procedural texture shading:
if (textureShader!=0) {
// Assign provided shader as filtershader to this texture: We negate it so
// that the texture blitter routines know this is a custom shader, not our
// built in filter shader:
textureRecord->textureFilterShader = -1 * textureShader;
}
// Texture ready. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, FALSE, textureRecord->windowIndex);
// Swapping the texture to upright orientation requested?
if (assume_texorientation == 1) {
// Transform sourceRecord source texture into a normalized, upright texture if it isn't already in
// that format. We require this standard orientation for simplified shader design.
PsychSetShader(windowRecord, 0);
PsychNormalizeTextureOrientation(textureRecord);
}
// Shall the texture be finally declared "normally oriented"?
// This is either due to explicit renderswapping if assume_textureorientation == 1,
// or because it was already pretransposed in Matlab/Octave if assume_textureorientation == 2,
// or because user space tells us the texture is isotropic if assume_textureorientation == 3.
if (assume_texorientation > 0) {
// Yes. Label it as such:
textureRecord->textureOrientation = 2;
}
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #4
StoreNowTime();
return(PsychError_none);
}
PsychError SCREENBeginOpenGL(void)
{
static char useString[] = "Screen('BeginOpenGL', windowPtr [, sharecontext=0]);";
static char synopsisString[] = "Prepare window 'windowPtr' for OpenGL rendering by external OpenGL code. "
"This allows to use OpenGL drawing routines other than the ones implemented "
"in Screen() to draw to a Psychtoolbox onscreen- or offscreen window via execution of "
"OpenGL commands. Typical clients of this function are mogl (Richard F. Murrays OpenGL for Matlab wrapper), "
"the new Eyelink-Toolbox and third party Matlab Mex-Files which contain OpenGL rendering routines. "
"You *have to* call this command once before using any of those external drawing commands for the window. "
"After drawing, you *must* switch back to PTB's rendering via the Screen('EndOpenGL', windowPtr); command. "
"Normally, you won't provide the optional flag 'sharecontext', so PTB will automatically isolate the OpenGL "
"state of your code from its internal state. However, if you provide sharecontext=1, then PTB will allow "
"your code to use and affect PTBs internal context. Only do this if you really know what you're doing! "
"If you provide sharecontext=2 then PTB will give you your own private context, but it will synchronize "
"the state of that context with its internal state - Seldomly needed, but here for your convenience. "
"The context state isolation is as strict as possible without seriously affecting performance and functionality: "
"All OpenGL context state is separated, with two exceptions: The framebuffer binding (if any) is always synchronized "
"with PTB (and reset to zero when calling 'EndOpenGL' or another Screen command) to allow external code to transparently "
"render into PTBs internal framebuffers - Needed for the imaging pipeline to work. Ressources like textures, display lists, "
"FBOs, VBOs, PBOs and GLSL shaders are shared between PTB and your code as well for efficiency reasons. Both types of "
"ressource sharing shouldn't be a problem, because either you are a beginner or advanced OpenGL programmer and won't use "
"those facilities anyway, or you are an expert user - in which case you'll know how to prevent any conflicts easily.";
static char seeAlsoString[] = "EndOpenGL SetOpenGLTexture GetOpenGLTexture moglcore";
PsychWindowRecordType *windowRecord;
GLint fboid, coltexid, ztexid, stexid;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(2)); // The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); // Number of required inputs.
PsychErrorExit(PsychCapNumOutputArgs(0)); // The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Already in userspace mode?
if (PsychIsUserspaceRendering()) PsychErrorExitMsg(PsychError_user, "Tried to call Screen('BeginOpenGL'), but userspace rendering is already active! Missing or mismatched Screen('EndOpenGL')? Check your code.");
// (Optional) context sharing flag provided?
sharecontext = 0;
PsychCopyInIntegerArg(2, FALSE, &sharecontext);
if (sharecontext<0 || sharecontext>2) PsychErrorExitMsg(PsychError_user, "Invalid value for 'sharecontext' provided. Not in range 0 to 2.");
// Master override: If context isolation is disabled then we use the PTB internal context...
if (PsychPrefStateGet_ConserveVRAM() & kPsychDisableContextIsolation) sharecontext = 1;
// Set it as drawing target: This will set up the proper FBO bindings as well:
PsychSetDrawingTarget(windowRecord);
// Store it as a reference for later 'EndOpenGL' call:
preswitchWindowRecord = windowRecord;
// Userspace wants its own private rendering context, optionally updated to match PTBs internal state?
if (sharecontext == 0 || sharecontext == 2) {
// Yes. This is the normal case for 3D rendering. MOGLs and PTBs contexts are separated to
// increase robustness, only ressources like textures, display lists, PBO's, VBO's, FBO's
// and GLSL shaders are shared, but not the current renderstate.
// Make sure 3D rendering is globally enabled, otherwise this is considered a userspace bug:
if (PsychPrefStateGet_3DGfx()==0) PsychErrorExitMsg(PsychError_user, "Tried to call 'BeginOpenGL' for external rendering, but 3D rendering not globally enabled! Call 'InitializeMatlabOpenGL' at the beginning of your script!!");
// Query current FBO binding. We need to manually transfer this to the userspace context, so
// it can render into our window:
if (glBindFramebufferEXT) {
fboid = 0;
glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboid);
if (fboid>0) {
// Query attachments of FBO:
glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &coltexid);
glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &ztexid);
glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &stexid);
}
}
// Flush our context before context switch:
glFlush();
// Unbind possible FBOs, so system FB is active in our context:
if (glBindFramebufferEXT && (fboid > 0)) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glFlush();
}
// Switch to userspace context for this window, optionally sync state with PTBs context:
PsychOSSetUserGLContext(windowRecord, (sharecontext==2) ? TRUE : FALSE);
// All following ops apply to the usercontext, not our internal context:
// Manually establish proper FBO binding for userspace. This will get reset automaticaly on back-transition
// inside PsychSetGLContext on its first invocation. If we are in non-imaging mode then there's nothing to do.
if (glBindFramebufferEXT && (fboid > 0)) {
if (!glIsFramebufferEXT(fboid)) {
// Special case: Need to bind a special FBO and the underlying OpenGL driver is faulty,
// i.e. it doesn't share FBO names accross our OpenGL contexts as it should according to
// spec.: We manually create a clone of our internal FBO - Create an FBO in the userspace
// context with the same FBO handle, then manually reattach the proper attachments...
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Faulty graphics driver - FBO sharing doesn't work properly, trying work-around. Update your drivers as soon as possible!\n");
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_EXT, coltexid, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_EXT, ztexid, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_EXT, stexid, 0);
if (GL_FRAMEBUFFER_COMPLETE_EXT != glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)) {
// Game over :(
PsychErrorExitMsg(PsychError_internal, "Graphics driver malfunction: Failed to clone PTBs internal FBO for userspace GLContext inside SCREENBeginOpenGL as part of workaround code! Upgrade your gfx-drivers!!");
}
// If we reach this point, then the workaround for the worst OS in existence has worked.
}
else {
// Need to bind a special FBO and the system works correctly - no workaround needed. Just bind it in new context:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid);
}
}
// Is this the first time that the userspace rendering context of this
// onscreen window is selected for real userspace rendering?
if (windowRecord->needsViewportSetup && PsychIsOnscreenWindow(windowRecord)) {
// Yes. Need to perform one-time setup actions for this context:
windowRecord->needsViewportSetup = FALSE;
// Need to setup glViewPort, scissor rectangle, projection and modelview
// matrices to values that match the windows client rectangle. We need to
// do this here because some imaging pipeline display modes, e.g, stereomodes
// for top-bottom stereo or dualview stereo may have altered the useable client
// rendering area after the context was initially created. OpenGL spec states that
// at least the viewport and scissor rectangles are set to the full client window
// area at first bind of a context to its drawable, so we emulate this here on first
// 'BeginOpenGL' to avoid unpleasant surprises for unsuspecting users:
PsychSetupView(windowRecord, FALSE);
}
// Running without imaging pipeline and a stereo mode is active?
if ((windowRecord->stereomode) > 0 && !(windowRecord->imagingMode & kPsychNeedFastBackingStore)) {
// Perform setup work for stereo drawbuffers in fixed function mode:
PsychSwitchFixedFunctionStereoDrawbuffer(windowRecord);
}
}
else {
// Userspace shares context with PTB. Let's disable possibly bound GLSL shaders:
PsychSetShader(windowRecord, 0);
}
// Check for GL errors:
PsychTestForGLErrors();
// Set the userspace flag:
PsychSetUserspaceGLFlag(TRUE);
// Ready for userspace rendering:
return(PsychError_none);
}
PsychError SCREENMakeTexture(void)
{
size_t ix, iters;
PsychWindowRecordType *textureRecord;
PsychWindowRecordType *windowRecord;
PsychRectType rect;
psych_bool isImageMatrixBytes, isImageMatrixDoubles;
int numMatrixPlanes, xSize, ySize;
unsigned char *byteMatrix;
double *doubleMatrix;
GLuint *texturePointer;
GLubyte *texturePointer_b;
GLfloat *texturePointer_f;
double *rp, *gp, *bp, *ap;
GLubyte *rpb, *gpb, *bpb, *apb;
int usepoweroftwo, usefloatformat, assume_texorientation, textureShader;
double optimized_orientation;
psych_bool bigendian;
psych_bool planar_storage = FALSE;
// Detect endianity (byte-order) of machine:
ix=255;
rpb=(GLubyte*) &ix;
bigendian = ( *rpb == 255 ) ? FALSE : TRUE;
ix = 0; rpb = NULL;
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #1
StoreNowTime();
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//Get the window structure for the onscreen window. It holds the onscreein GL context which we will need in the
//final step when we copy the texture from system RAM onto the screen.
PsychErrorExit(PsychCapNumInputArgs(7));
PsychErrorExit(PsychRequireNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(1));
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if((windowRecord->windowType!=kPsychDoubleBufferOnscreen) && (windowRecord->windowType!=kPsychSingleBufferOnscreen))
PsychErrorExitMsg(PsychError_user, "MakeTexture called on something else than a onscreen window");
// Get optional texture orientation flag:
assume_texorientation = 0;
PsychCopyInIntegerArg(6, FALSE, &assume_texorientation);
// Get optional texture shader handle:
textureShader = 0;
PsychCopyInIntegerArg(7, FALSE, &textureShader);
//get the argument and sanity check it.
isImageMatrixBytes=PsychAllocInUnsignedByteMatArg(2, kPsychArgAnything, &ySize, &xSize, &numMatrixPlanes, &byteMatrix);
isImageMatrixDoubles=PsychAllocInDoubleMatArg(2, kPsychArgAnything, &ySize, &xSize, &numMatrixPlanes, &doubleMatrix);
if(numMatrixPlanes > 4)
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Specified image matrix exceeds maximum depth of 4 layers");
if(ySize<1 || xSize <1)
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Specified image matrix must be at least 1 x 1 pixels in size");
if(! (isImageMatrixBytes || isImageMatrixDoubles))
PsychErrorExitMsg(PsychError_user, "Illegal argument type"); //not likely.
// Is this a special image matrix which is already pre-transposed to fit our optimal format?
if (assume_texorientation == 2) {
// Yes. Swap xSize and ySize to take this into account:
ix = (size_t) xSize;
xSize = ySize;
ySize = (int) ix;
ix = 0;
}
// Build defining rect for this texture:
PsychMakeRect(rect, 0, 0, xSize, ySize);
// Copy in texture preferred draw orientation hint. We default to zero degrees, if
// not provided.
// This parameter is not yet used. It is silently ignorerd for now...
optimized_orientation = 0;
PsychCopyInDoubleArg(3, FALSE, &optimized_orientation);
// Copy in special creation mode flag: It defaults to zero. If set to 1 then we
// always create a power-of-two GL_TEXTURE_2D texture. This is useful if one wants
// to create and use drifting gratings with no effort - texture wrapping is only available
// for GL_TEXTURE_2D, not for non-pot types. It is also useful if the texture is to be
// exported to external OpenGL code to simplify tex coords assignments.
usepoweroftwo=0;
PsychCopyInIntegerArg(4, FALSE, &usepoweroftwo);
// Check if size constraints are fullfilled for power-of-two mode:
if (usepoweroftwo & 1) {
for(ix = 1; ix < (size_t) xSize; ix*=2);
if (ix != (size_t) xSize) {
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Power-of-two texture requested but width of imageMatrix is not a power of two!");
}
for(ix = 1; ix < (size_t) ySize; ix*=2);
if (ix != (size_t) ySize) {
PsychErrorExitMsg(PsychError_inputMatrixIllegalDimensionSize, "Power-of-two texture requested but height of imageMatrix is not a power of two!");
}
}
// Check if creation of a floating point texture is requested? We default to non-floating point,
// standard 8 bpc textures if this parameter is not provided.
usefloatformat = 0;
PsychCopyInIntegerArg(5, FALSE, &usefloatformat);
if (usefloatformat<0 || usefloatformat>2) PsychErrorExitMsg(PsychError_user, "Invalid value for 'floatprecision' parameter provided! Valid values are 0 for 8bpc int, 1 for 16bpc float or 2 for 32bpc float.");
if (usefloatformat && !isImageMatrixDoubles) {
// Floating point texture requested. We only support this if our input is a double matrix, not
// for uint8 matrices - converting them to float precision would be just a waste of ressources
// without any benefit for precision.
PsychErrorExitMsg(PsychError_user, "Creation of a floating point precision texture requested, but uint8 matrix provided! Only double matrices are acceptable for this mode.");
}
//Create a texture record. Really just a window record adapted for textures.
PsychCreateWindowRecord(&textureRecord); //this also fills the window index field.
textureRecord->windowType=kPsychTexture;
// MK: We need to assign the screen number of the onscreen-window, so PsychCreateTexture()
// can query the size of the screen/onscreen-window...
textureRecord->screenNumber=windowRecord->screenNumber;
textureRecord->depth=32;
PsychCopyRect(textureRecord->rect, rect);
// Is texture storage in planar format explicitely requested by usercode? Do the gpu and its size
// constraints on textures support planar storage for this image?
// Can a proper planar -> interleaved remapping GLSL shader be generated and assigned for this texture?
if ((usepoweroftwo == 4) && (numMatrixPlanes > 1) && (windowRecord->gfxcaps & kPsychGfxCapFBO) && !(PsychPrefStateGet_ConserveVRAM() & kPsychDontCacheTextures) &&
(ySize * numMatrixPlanes <= windowRecord->maxTextureSize) && PsychAssignPlanarTextureShaders(textureRecord, windowRecord, numMatrixPlanes)) {
// Yes: Use the planar texture storage fast-path.
planar_storage = TRUE;
if (PsychPrefStateGet_Verbosity() > 6) printf("PTB-DEBUG: Using planar storage for %i layer texture of size %i x %i texels.\n", numMatrixPlanes, xSize, ySize);
}
else {
planar_storage = FALSE;
if (PsychPrefStateGet_Verbosity() > 7) printf("PTB-DEBUG: Using standard storage for %i layer texture of size %i x %i texels.\n", numMatrixPlanes, xSize, ySize);
}
//Allocate the texture memory and copy the MATLAB matrix into the texture memory.
if (usefloatformat || (planar_storage && !isImageMatrixBytes)) {
// Allocate a double for each color component and pixel:
textureRecord->textureMemorySizeBytes = sizeof(double) * (size_t) numMatrixPlanes * (size_t) xSize * (size_t) ySize;
}
else {
// Allocate one byte per color component and pixel:
textureRecord->textureMemorySizeBytes = (size_t) numMatrixPlanes * (size_t) xSize * (size_t) ySize;
}
// We allocate our own intermediate conversion buffer unless this is
// creation of a single-layer luminance8 integer texture from a single
// layer uint8 input matrix and client storage is disabled. In that case, we can use a zero-copy path:
if ((isImageMatrixBytes && (numMatrixPlanes == 1) && (!usefloatformat) && !(PsychPrefStateGet_ConserveVRAM() & kPsychDontCacheTextures)) ||
(isImageMatrixBytes && planar_storage)) {
// Zero copy path:
texturePointer = NULL;
}
else {
// Allocate memory:
if(PsychPrefStateGet_DebugMakeTexture()) StoreNowTime();
textureRecord->textureMemory = malloc(textureRecord->textureMemorySizeBytes);
if(PsychPrefStateGet_DebugMakeTexture()) StoreNowTime();
texturePointer = textureRecord->textureMemory;
}
// Does script explicitely request usage of a GL_TEXTURE_2D power-of-two texture?
if (usepoweroftwo & 1) {
// Enforce creation as a power-of-two texture:
textureRecord->texturetarget=GL_TEXTURE_2D;
}
// Now the conversion routines that convert Matlab/Octave matrices into memory
// buffers suitable for OpenGL:
if (planar_storage) {
// Planar texture storage, backed by a LUMINANCE texture container:
// Zero-Copy possible? Only for uint8 input -> uint8 output:
if (texturePointer == NULL) {
texturePointer = (GLuint*) byteMatrix;
textureRecord->textureMemory = texturePointer;
// Set size to zero, so PsychCreateTexture() does not free() our
// input buffer:
textureRecord->textureMemorySizeBytes = 0;
// This is always a LUMINANCE8 texture, backing our planar uint8 texture:
textureRecord->depth = 8 * numMatrixPlanes;
textureRecord->textureexternaltype = GL_UNSIGNED_BYTE;
textureRecord->textureexternalformat = GL_LUMINANCE;
textureRecord->textureinternalformat = GL_LUMINANCE8;
}
else {
// Some cast operation needed from double input format.
// We always cast from double to float, potentially with
// normalization and/or checking of value range.
textureRecord->textureexternalformat = GL_LUMINANCE;
if (usefloatformat) {
// Floating point or other high precision format:
textureRecord->depth = ((usefloatformat == 1) ? 16 : 32) * numMatrixPlanes;
textureRecord->textureexternaltype = GL_FLOAT;
textureRecord->textureinternalformat = (usefloatformat == 1) ? GL_LUMINANCE_FLOAT16_APPLE : GL_LUMINANCE_FLOAT32_APPLE;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat == 1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_LUMINANCE16_SNORM;
// Perform copy with double -> float cast:
iters = (size_t) xSize * (size_t) ySize * (size_t) numMatrixPlanes;
texturePointer_f = (GLfloat*) texturePointer;
for(ix = 0; ix < iters; ix++) {
*(texturePointer_f++) = (GLfloat) *(doubleMatrix++);
}
iters = (size_t) xSize * (size_t) ySize;
}
else {
// 8 Bit format, but from double input matrix -> cast to uint8:
textureRecord->depth = 8 * numMatrixPlanes;
textureRecord->textureexternaltype = GL_UNSIGNED_BYTE;
textureRecord->textureinternalformat = GL_LUMINANCE8;
iters = (size_t) xSize * (size_t) ySize * (size_t) numMatrixPlanes;
texturePointer_b = (GLubyte*) texturePointer;
for(ix = 0; ix < iters; ix++) {
*(texturePointer_b++) = (GLubyte) *(doubleMatrix++);
}
iters = (size_t) xSize * (size_t) ySize;
}
}
}
else if (usefloatformat) {
// Conversion routines for HDR 16 bpc or 32 bpc textures -- Slow path.
// Our input is always double matrices...
iters = (size_t) xSize * (size_t) ySize;
// Our input buffer is always of GL_FLOAT precision:
textureRecord->textureexternaltype = GL_FLOAT;
texturePointer_f=(GLfloat*) texturePointer;
if(numMatrixPlanes==1) {
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(doubleMatrix++);
}
textureRecord->depth=(usefloatformat==1) ? 16 : 32;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_LUMINANCE_FLOAT16_APPLE : GL_LUMINANCE_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_LUMINANCE;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_LUMINANCE16_SNORM;
}
if(numMatrixPlanes==2) {
rp=(double*) ((size_t) doubleMatrix);
ap=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(ap++);
}
textureRecord->depth=(usefloatformat==1) ? 32 : 64;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_LUMINANCE_ALPHA_FLOAT16_APPLE : GL_LUMINANCE_ALPHA_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_LUMINANCE_ALPHA;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_LUMINANCE16_ALPHA16_SNORM;
}
if(numMatrixPlanes==3) {
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(gp++);
*(texturePointer_f++)= (GLfloat) *(bp++);
}
textureRecord->depth=(usefloatformat==1) ? 48 : 96;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_RGB_FLOAT16_APPLE : GL_RGB_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_RGB;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_RGB16_SNORM;
}
if(numMatrixPlanes==4) {
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
ap=(double*) ((size_t) bp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_f++)= (GLfloat) *(rp++);
*(texturePointer_f++)= (GLfloat) *(gp++);
*(texturePointer_f++)= (GLfloat) *(bp++);
*(texturePointer_f++)= (GLfloat) *(ap++);
}
textureRecord->depth=(usefloatformat==1) ? 64 : 128;
textureRecord->textureinternalformat = (usefloatformat==1) ? GL_RGBA_FLOAT16_APPLE : GL_RGBA_FLOAT32_APPLE;
textureRecord->textureexternalformat = GL_RGBA;
// Override for missing floating point texture support: Try to use 16 bit fixed point signed normalized textures [-1.0 ; 1.0] resolved at 15 bits:
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) textureRecord->textureinternalformat = GL_RGBA16_SNORM;
}
// End of HDR conversion code...
}
else {
// Standard LDR texture 8 bpc conversion routines -- Fast path.
iters = (size_t) xSize * (size_t) ySize;
// Improved implementation: Takes 13 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==1){
texturePointer_b=(GLubyte*) texturePointer;
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(doubleMatrix++);
}
textureRecord->depth=8;
}
// Improved version: Takes 3 ms on a 800x800 texture...
// NB: Implementing memcpy manually by a for-loop takes 10 ms! This is a huge difference.
// -> That's because memcpy on MacOS-X is implemented with hand-coded, highly tuned Assembler code for PowerPC.
// -> It's always wise to use system-routines if available, instead of coding it by yourself!
if(isImageMatrixBytes && numMatrixPlanes==1) {
if (texturePointer) {
// Need to do a copy. Use optimized memcpy():
memcpy((void*) texturePointer, (void*) byteMatrix, iters);
//texturePointer_b=(GLubyte*) texturePointer;
//for(ix=0;ix<iters;ix++){
// *(texturePointer_b++) = *(byteMatrix++);
//}
}
else {
// Zero-Copy path. Just pass a pointer to our input matrix:
texturePointer = (GLuint*) byteMatrix;
textureRecord->textureMemory = texturePointer;
// Set size to zero, so PsychCreateTexture() does not free() our
// input buffer:
textureRecord->textureMemorySizeBytes = 0;
}
textureRecord->depth=8;
}
// New version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==2){
texturePointer_b=(GLubyte*) texturePointer;
rp=(double*) ((size_t) doubleMatrix);
ap=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(ap++);
}
textureRecord->depth=16;
}
// New version: Takes 20 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==2){
texturePointer_b=(GLubyte*) texturePointer;
rpb=(GLubyte*) ((size_t) byteMatrix);
apb=(GLubyte*) ((size_t) rpb + (size_t) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(apb++);
}
textureRecord->depth=16;
}
// Improved version: Takes 43 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
textureRecord->depth=24;
}
// Improved version: Takes 25 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
rpb=(GLubyte*) ((size_t) byteMatrix);
gpb=(GLubyte*) ((size_t) rpb + (size_t) iters);
bpb=(GLubyte*) ((size_t) gpb + (size_t) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(bpb++);
}
textureRecord->depth=24;
}
// Improved version: Takes 55 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
rp=(double*) ((size_t) doubleMatrix);
gp=(double*) ((size_t) rp + (size_t) iters * sizeof(double));
bp=(double*) ((size_t) gp + (size_t) iters * sizeof(double));
ap=(double*) ((size_t) bp + (size_t) iters * sizeof(double));
if (bigendian) {
// Code for big-endian machines like PowerPC:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(ap++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
}
else {
// Code for little-endian machines like Intel Pentium:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(bp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(ap++);
}
}
textureRecord->depth=32;
}
// Improved version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
rpb=(GLubyte*) ((size_t) byteMatrix);
gpb=(GLubyte*) ((size_t) rpb + (size_t) iters);
bpb=(GLubyte*) ((size_t) gpb + (size_t) iters);
apb=(GLubyte*) ((size_t) bpb + (size_t) iters);
if (bigendian) {
// Code for big-endian machines like PowerPC:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(apb++);
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(bpb++);
}
}
else {
// Code for little-endian machines like Intel Pentium:
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(bpb++);
*(texturePointer_b++)= *(gpb++);
*(texturePointer_b++)= *(rpb++);
*(texturePointer_b++)= *(apb++);
}
}
textureRecord->depth=32;
}
} // End of 8 bpc texture conversion code (fast-path for LDR textures)
// Override for missing floating point texture support?
if ((usefloatformat==1) && !(windowRecord->gfxcaps & kPsychGfxCapFPTex16)) {
// Override enabled. Instead of a 16bpc float texture with 11 bit linear precision in the
// range [-1.0 ; 1.0], we use a 16 bit signed normalized texture with a normalized value
// range of [-1.0; 1.0], encoded with 1 bit sign and 15 bit magnitude. These textures have
// an effective linear precision of 15 bits - better than 16 bpc float - but they are restricted
// to a value range of [-1.0 ; 1.0], as opposed to 16 bpc float textures. Tell user about this
// replacement at high verbosity levels:
if (PsychPrefStateGet_Verbosity() > 4)
printf("PTB-INFO:MakeTexture: Code requested 16 bpc float texture, but this is unsupported. Trying to use 16 bit snorm texture instead.\n");
// Signed normalized textures supported? Otherwise we bail...
if (!(windowRecord->gfxcaps & kPsychGfxCapSNTex16)) {
printf("PTB-ERROR:MakeTexture: Code requested 16 bpc floating point texture, but this is unsupported by this graphics card.\n");
printf("PTB-ERROR:MakeTexture: Tried to use 16 bit snorm texture instead, but failed as this is unsupported as well.\n");
PsychErrorExitMsg(PsychError_user, "Creation of 15 bit linear precision signed normalized texture failed. Not supported by your graphics hardware!");
}
// Check value range of pixels. This will not work for out of [-1; 1] range values.
texturePointer_f=(GLfloat*) texturePointer;
iters = iters * (size_t) numMatrixPlanes;
for (ix=0; ix<iters; ix++, texturePointer_f++) {
if(fabs((double) *texturePointer_f) > 1.0) {
// Game over!
printf("PTB-ERROR:MakeTexture: Code requested 16 bpc floating point texture, but this is unsupported by this graphics card.\n");
printf("PTB-ERROR:MakeTexture: Tried to use 16 bit snorm texture instead, but failed because some pixels are outside the\n");
printf("PTB-ERROR:MakeTexture: representable range -1.0 to 1.0 for this texture type. Change your code or update your graphics hardware.\n");
PsychErrorExitMsg(PsychError_user, "Creation of 15 bit linear precision signed normalized texture failed due to out of [-1 ; +1] range pixel values!");
}
}
}
// This is a special workaround for bugs in FLOAT16 texture creation on Mac OS/X 10.4.x and 10.5.x.
// The OpenGL fails to properly flush very small values (< 1e-9) to zero when creating a FLOAT16
// type texture. Instead it seems to initialize with trash data, corrupting the texture.
// Therefore, if FLOAT16 texture creation is requested, we loop over the whole input buffer and
// set all values with magnitude smaller than 1e-9 to zero. Better safe than sorry...
if ((usefloatformat==1) && (windowRecord->gfxcaps & kPsychGfxCapFPTex16)) {
texturePointer_f=(GLfloat*) texturePointer;
iters = iters * (size_t) numMatrixPlanes;
for(ix=0; ix<iters; ix++, texturePointer_f++) if(fabs((double) *texturePointer_f) < 1e-9) { *texturePointer_f = 0.0; }
}
// The memory buffer now contains our texture data in a format ready to submit to OpenGL.
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Texture orientation is zero aka transposed aka non-renderswapped.
textureRecord->textureOrientation = ((assume_texorientation != 2) && (assume_texorientation != 3)) ? 0 : 2;
// This is our best guess about the number of image channels:
textureRecord->nrchannels = numMatrixPlanes;
if (planar_storage) {
// Setup special rect to fake PsychCreateTexture() into creating a luminance
// texture numMatrixPlanes times the height (in rows) of the texture, to store the
// numMatrixPlanes layers concatenated to each other.
if (textureRecord->textureOrientation == 0) {
// Normal case: Transposed storage.
PsychMakeRect(&(textureRecord->rect[0]), 0, 0, xSize * numMatrixPlanes, ySize);
}
else {
// Special case: Non-transposed or isotropic storage:
PsychMakeRect(&(textureRecord->rect[0]), 0, 0, xSize, ySize * numMatrixPlanes);
}
// Create planar texture:
PsychCreateTexture(textureRecord);
// Restore rect and clientrect of texture to effective size:
PsychMakeRect(&(textureRecord->rect[0]), 0, 0, xSize, ySize);
PsychCopyRect(textureRecord->clientrect, textureRecord->rect);
textureRecord->specialflags = kPsychPlanarTexture;
}
else {
// Let's create and bind a new texture object and fill it with our new texture data.
PsychCreateTexture(textureRecord);
// Assign GLSL filter-/lookup-shaders if needed:
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, usefloatformat, (usepoweroftwo & 2) ? 1 : 0);
}
// User specified override shader for this texture provided? This is useful for
// basic image processing and procedural texture shading:
if (textureShader!=0) {
// Assign provided shader as filtershader to this texture: We negate it so
// that the texture blitter routines know this is a custom shader, not our
// built in filter shader:
textureRecord->textureFilterShader = -1 * textureShader;
}
// Texture ready. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, FALSE, textureRecord->windowIndex);
// Swapping the texture to upright orientation requested?
if (assume_texorientation == 1) {
// Transform sourceRecord source texture into a normalized, upright texture if it isn't already in
// that format. We require this standard orientation for simplified shader design.
PsychSetShader(windowRecord, 0);
PsychNormalizeTextureOrientation(textureRecord);
}
// Shall the texture be finally declared "normally oriented"?
// This is either due to explicit renderswapping if assume_textureorientation == 1,
// or because it was already pretransposed in Matlab/Octave if assume_textureorientation == 2,
// or because user space tells us the texture is isotropic if assume_textureorientation == 3.
if (assume_texorientation > 0) {
// Yes. Label it as such:
textureRecord->textureOrientation = 2;
}
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #4
StoreNowTime();
return(PsychError_none);
}
PsychError SCREENDrawDots(void)
{
PsychWindowRecordType *windowRecord, *parentWindowRecord;
int m,n,p,mc,nc,idot_type;
int i, nrpoints, nrsize;
psych_bool isArgThere, usecolorvector, isdoublecolors, isuint8colors;
double *xy, *size, *center, *dot_type, *colors;
float *sizef;
unsigned char *bytecolors;
GLfloat pointsizerange[2];
psych_bool lenient = FALSE;
psych_bool usePointSizeArray = FALSE;
static psych_bool nocando = FALSE;
int oldverbosity;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
// Check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(7)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(4)); //The maximum number of outputs
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Get dot_type argument, if any, as it is already needed for a pure point size range query below:
isArgThere = PsychIsArgPresent(PsychArgIn, 6);
if(!isArgThere){
idot_type = 0;
} else {
PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type);
if(p != 1 || n != 1 || m != 1 || (dot_type[0] < 0 || dot_type[0] > 4))
PsychErrorExitMsg(PsychError_user, "dot_type must be 0, 1, 2, 3 or 4");
idot_type = (int) dot_type[0];
}
// Query for supported point size range?
if (PsychGetNumOutputArgs() > 0) {
PsychSetDrawingTarget(windowRecord);
// Always query and return aliased range:
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
PsychCopyOutDoubleArg(3, FALSE, (double) pointsizerange[0]);
PsychCopyOutDoubleArg(4, FALSE, (double) pointsizerange[1]);
// If driver supports smooth points and usercode doesn't specify a dot type (idot_type 0)
// or does not request shader + point-sprite based drawing then return smooth point
// size range as "smooth point size range" - query and assign it. Otherwise, ie., code
// explicitely wants to use a shader (idot_type >= 3) or has to use one, we will use
// point-sprites and that means the GL_ALIASED_POINT_SIZE_RANGE limits apply also to
// our shader based smooth dots, so return those:
if ((windowRecord->gfxcaps & kPsychGfxCapSmoothPrimitives) && (idot_type < 3))
glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
// Whatever the final choice for smooth dots is, return its limits:
PsychCopyOutDoubleArg(1, FALSE, (double) pointsizerange[0]);
PsychCopyOutDoubleArg(2, FALSE, (double) pointsizerange[1]);
// If this was only a query then we are done:
if (PsychGetNumInputArgs() < 2)
return(PsychError_none);
}
// Query, allocate and copy in all vectors...
nrpoints = 2;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
PsychPrepareRenderBatch(windowRecord, 2, &nrpoints, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size, (GL_FLOAT == PsychGLFloatType(windowRecord)));
isdoublecolors = (colors) ? TRUE:FALSE;
isuint8colors = (bytecolors) ? TRUE:FALSE;
usecolorvector = (nc>1) ? TRUE:FALSE;
// Assign sizef as float-type array of sizes, if float mode active, NULL otherwise:
sizef = (GL_FLOAT == PsychGLFloatType(windowRecord)) ? (float*) size : NULL;
// Get center argument
isArgThere = PsychIsArgPresent(PsychArgIn, 5);
if(!isArgThere){
center = (double *) PsychMallocTemp(2 * sizeof(double));
center[0] = 0;
center[1] = 0;
} else {
PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er);
if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector");
}
// Turn on antialiasing to draw circles? Or idot_type 4 for shader based square dots?
if (idot_type) {
// Smooth point rendering supported by gfx-driver and hardware? And user does not request our own stuff?
if ((idot_type == 3) || (idot_type == 4) || !(windowRecord->gfxcaps & kPsychGfxCapSmoothPrimitives)) {
// No. Need to roll our own shader + point sprite solution.
if (!windowRecord->smoothPointShader && !nocando) {
parentWindowRecord = PsychGetParentWindow(windowRecord);
if (!parentWindowRecord->smoothPointShader) {
// Build and assign shader to parent window, but allow this to silently fail:
oldverbosity = PsychPrefStateGet_Verbosity();
PsychPrefStateSet_Verbosity(0);
parentWindowRecord->smoothPointShader = PsychCreateGLSLProgram(PointSmoothFragmentShaderSrc, PointSmoothVertexShaderSrc, NULL);
PsychPrefStateSet_Verbosity(oldverbosity);
}
if (parentWindowRecord->smoothPointShader) {
// Got one compiled - assign it for use:
windowRecord->smoothPointShader = parentWindowRecord->smoothPointShader;
}
else {
// Failed. Record this failure so we can avoid retrying at next DrawDots invocation:
nocando = TRUE;
}
}
if (windowRecord->smoothPointShader) {
// Activate point smooth shader, and point sprite operation on texunit 1 for coordinates on set 1:
PsychSetShader(windowRecord, windowRecord->smoothPointShader);
glActiveTexture(GL_TEXTURE1);
glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
glActiveTexture(GL_TEXTURE0);
glEnable(GL_POINT_SPRITE);
// Tell shader from where to get its color information: Unclamped high precision colors from texture coordinate set 0, or regular colors from vertex color attribute?
glUniform1i(glGetUniformLocation(windowRecord->smoothPointShader, "useUnclampedFragColor"), (windowRecord->defaultDrawShader) ? 1 : 0);
// Tell shader if it should shade smooth round dots, or square dots:
glUniform1i(glGetUniformLocation(windowRecord->smoothPointShader, "drawRoundDots"), (idot_type != 4) ? 1 : 0);
// Tell shader about current point size in pointSize uniform:
glEnable(GL_PROGRAM_POINT_SIZE);
usePointSizeArray = TRUE;
}
else if (idot_type != 4) {
// Game over for round dot drawing:
PsychErrorExitMsg(PsychError_user, "Point smoothing unsupported on your system and our shader based implementation failed as well in Screen('DrawDots').");
}
else {
// Type 4 requested but unsupported. Fallback to type 0, which is the same, just slower:
idot_type = 0;
}
// Request square dots, without anti-aliasing: Better compatibility with
// shader + point sprite operation, and needed for idot_type 0 fallback.
glDisable(GL_POINT_SMOOTH);
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
}
else {
// User wants hw anti-aliased round smooth dots (idot_type = 1 or 2) and
// hardware + driver support this. Request smooth points from hardware:
glEnable(GL_POINT_SMOOTH);
glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
// A dot type of 2 requests highest quality point smoothing:
glHint(GL_POINT_SMOOTH_HINT, (idot_type > 1) ? GL_NICEST : GL_DONT_CARE);
}
}
else {
glDisable(GL_POINT_SMOOTH);
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
}
// Does ES-GPU only support a fixed point diameter of 1 pixel?
if ((pointsizerange[1] <= 1) && PsychIsGLES(windowRecord)) {
// Yes. Not much point bailing on this, as it should be easily visible
// during testing of a studies code on a OpenGL-ES device.
lenient = TRUE;
}
// Accept optional 'lenient' flag, if provided:
PsychCopyInFlagArg(7, FALSE, &lenient);
// Set size of a single dot:
if (!lenient && ((sizef && (sizef[0] > pointsizerange[1] || sizef[0] < pointsizerange[0])) ||
(!sizef && (size[0] > pointsizerange[1] || size[0] < pointsizerange[0])))) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
(sizef) ? sizef[0] : size[0], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup initial common point size for all points:
if (!usePointSizeArray) glPointSize((sizef) ? sizef[0] : (float) size[0]);
if (usePointSizeArray) glMultiTexCoord1f(GL_TEXTURE2, (sizef) ? sizef[0] : (float) size[0]);
// Setup modelview matrix to perform translation by 'center':
glMatrixMode(GL_MODELVIEW);
// Make a backup copy of the matrix:
glPushMatrix();
// Apply a global translation of (center(x,y)) pixels to all following points:
glTranslatef((float) center[0], (float) center[1], 0);
// Render the array of 2D-Points - Efficient version:
// This command sequence allows fast processing of whole arrays
// of vertices (or points, in this case). It saves the call overhead
// associated with the original implementation below and is potentially
// optimized in specific OpenGL implementations.
// Pass a pointer to the start of the point-coordinate array:
glVertexPointer(2, PSYCHGLFLOAT, 0, &xy[0]);
// Enable fast rendering of arrays:
glEnableClientState(GL_VERTEX_ARRAY);
if (usecolorvector) {
PsychSetupVertexColorArrays(windowRecord, TRUE, mc, colors, bytecolors);
}
// Render all n points, starting at point 0, render them as POINTS:
if ((nrsize == 1) || usePointSizeArray) {
// Only one common size provided, or efficient shader based
// path in use. We can use the fast path of only submitting
// one glDrawArrays call to draw all GL_POINTS. For a single
// common size, no further setup is needed.
if (nrsize > 1) {
// Individual size for each dot provided. Setup texture unit 2
// with a 1D texcoord array that stores per point size info in
// texture coordinate set 2. But first validate point sizes:
for (i = 0; i < nrpoints; i++) {
if (!lenient && ((sizef && (sizef[i] > pointsizerange[1] || sizef[i] < pointsizerange[0])) ||
(!sizef && (size[i] > pointsizerange[1] || size[i] < pointsizerange[0])))) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
(sizef) ? sizef[i] : size[i], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
}
// Sizes are fine, setup texunit 2:
glClientActiveTexture(GL_TEXTURE2);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(1, (sizef) ? GL_FLOAT : GL_DOUBLE, 0, (sizef) ? (const GLvoid*) sizef : (const GLvoid*) size);
}
// Draw all points:
glDrawArrays(GL_POINTS, 0, nrpoints);
if (nrsize > 1) {
// Individual size for each dot provided. Reset texture unit 2:
glTexCoordPointer(1, (sizef) ? GL_FLOAT : GL_DOUBLE, 0, (const GLvoid*) NULL);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// Back to default texunit 0:
glClientActiveTexture(GL_TEXTURE0);
}
}
else {
// Different size for each dot provided and we can't use our shader based implementation:
// We have to do One GL - call per dot:
for (i=0; i<nrpoints; i++) {
if (!lenient && ((sizef && (sizef[i] > pointsizerange[1] || sizef[i] < pointsizerange[0])) ||
(!sizef && (size[i] > pointsizerange[1] || size[i] < pointsizerange[0])))) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
(sizef) ? sizef[i] : size[i], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup point size for this point:
if (!usePointSizeArray) glPointSize((sizef) ? sizef[i] : (float) size[i]);
// Render point:
glDrawArrays(GL_POINTS, i, 1);
}
}
// Disable fast rendering of arrays:
glDisableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, PSYCHGLFLOAT, 0, NULL);
if (usecolorvector) PsychSetupVertexColorArrays(windowRecord, FALSE, 0, NULL, NULL);
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// turn off antialiasing again
if (idot_type) {
glDisable(GL_POINT_SMOOTH);
if (windowRecord->smoothPointShader) {
// Deactivate point smooth shader and point sprite operation on texunit 1:
PsychSetShader(windowRecord, 0);
glActiveTexture(GL_TEXTURE1);
glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_POINT_SPRITE);
glDisable(GL_PROGRAM_POINT_SIZE);
}
}
// Reset pointsize to 1.0
glPointSize(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
return(PsychError_none);
}
PsychError SCREENDrawLine(void)
{
PsychColorType color;
PsychWindowRecordType *windowRecord;
double whiteValue;
psych_bool isArgThere;
double sX, sY, dX, dY, penSize;
float linesizerange[2];
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(7)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
//Get the color argument or use the default, then coerce to the form determened by the window depth.
isArgThere=PsychCopyInColorArg(2, FALSE, &color);
if(!isArgThere){
whiteValue=PsychGetWhiteValueFromWindow(windowRecord);
PsychLoadColorStruct(&color, kPsychIndexColor, whiteValue ); //index mode will coerce to any other.
}
PsychCoerceColorMode( &color);
//get source and destination X and Y values
PsychCopyInDoubleArg(3, kPsychArgRequired, &sX);
PsychCopyInDoubleArg(4, kPsychArgRequired, &sY);
PsychCopyInDoubleArg(5, kPsychArgRequired, &dX);
PsychCopyInDoubleArg(6, kPsychArgRequired, &dY);
//get and set the pen size
penSize=1;
PsychCopyInDoubleArg(7, kPsychArgOptional, &penSize);
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Set default draw shader:
PsychSetShader(windowRecord, -1);
glGetFloatv(GL_LINE_WIDTH_RANGE, (GLfloat*) &linesizerange);
if (penSize < linesizerange[0] || penSize > linesizerange[1]) {
printf("PTB-ERROR: You requested a line width of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
penSize, linesizerange[0], linesizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported line width requested.");
}
glLineWidth((GLfloat)penSize);
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
PsychSetGLColor(&color, windowRecord);
glBegin(GL_LINES);
glVertex2d((GLdouble)sX, (GLdouble)sY);
glVertex2d((GLdouble)dX, (GLdouble)dY);
glEnd();
glLineWidth((GLfloat) 1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
return(PsychError_none);
}
PsychError SCREENTransformTexture(void)
{
PsychWindowRecordType *sourceRecord, *targetRecord, *proxyRecord, *sourceRecord2;
int testarg, specialFlags, usefloatformat, d;
// All subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if (PsychIsGiveHelp()) { PsychGiveHelp(); return(PsychError_none); };
PsychErrorExit(PsychCapNumInputArgs(5));
PsychErrorExit(PsychRequireNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(1));
// OpenGL FBO's supported? Otherwise this is a no-go...
if (glBindFramebufferEXT == NULL || glUseProgram == NULL) {
// Game over!
printf("PTB-ERROR: Sorry, your graphics driver & hardware does not support the required OpenGL framebuffer object extension or\n");
printf("PTB-ERROR: the OpenGL shading language for hardware accelerated fragment processing. This function is therefore disabled.\n");
printf("PTB-ERROR: You will need at least a NVidia GeforceFX-5200, a ATI Radeon 9600 or a Intel GMA-950 graphics card for this\n");
printf("PTB-ERROR: to work. If you have such a card (or a more recent one) then you'll need to update your graphics drivers.\n\n");
PsychErrorExitMsg(PsychError_user, "Screen('TransformTexture') command unsupported on your combination of graphics hardware & driver.");
}
// Get the window structure for the source texture.
PsychAllocInWindowRecordArg(1, TRUE, &sourceRecord);
if (!PsychIsTexture(sourceRecord))
PsychErrorExitMsg(PsychError_user, "'sourceTexture' argument must be a handle to a texture or offscreen window.");
// Get the window structure for the proxy object.
PsychAllocInWindowRecordArg(2, TRUE, &proxyRecord);
if (proxyRecord->windowType != kPsychProxyWindow)
PsychErrorExitMsg(PsychError_user, "'transformProxyPtr' argument must be a handle to a proxy object.");
// Test if optional specialFlags are provided:
specialFlags = 0;
PsychCopyInIntegerArg(5, FALSE, &specialFlags);
// Activate rendering context of the proxy object and soft-reset the drawing engine,
// so we're in a well defined state. The value 1 means: Reset safely, ie. do any
// framebuffer backups that might be needed before NULL-ing the binding:
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
PsychSetGLContext(proxyRecord);
// Save all state:
glPushAttrib(GL_ALL_ATTRIB_BITS);
// Disable alpha-blending:
glDisable(GL_BLEND);
// Reset color write mask to "all enabled"
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
// Disable any shaders:
PsychSetShader(proxyRecord, 0);
// Transform sourceRecord source texture into a normalized, upright texture if it isn't already in
// that format. We require this standard orientation for simplified shader design.
if (!(specialFlags & 1))
PsychNormalizeTextureOrientation(sourceRecord);
// Test if optional 2nd source texture is provided:
testarg = 0;
PsychCopyInIntegerArg(3, FALSE, &testarg);
if (testarg != 0) {
// Tes. Get the window structure for the 2nd source texture.
PsychAllocInWindowRecordArg(3, TRUE, &sourceRecord2);
if (!PsychIsTexture(sourceRecord2))
PsychErrorExitMsg(PsychError_user, "'sourceTexture2' argument must be a handle to a texture or offscreen window.");
// Transform sourceRecord2 source texture into a normalized, upright texture if it isn't already in
// that format. We require this standard orientation for simplified shader design.
if (!(specialFlags & 1))
PsychNormalizeTextureOrientation(sourceRecord2);
}
else {
// No secondary source texture:
sourceRecord2 = NULL;
}
// Restore proper rendering context:
PsychSetGLContext(proxyRecord);
// Test if optional target texture is provided:
testarg = 0;
PsychCopyInIntegerArg(4, FALSE, &testarg);
// Do we need to create a new one from scratch?
if (testarg == 0) {
// No valid textureHandle provided. Create a new empty textureRecord which clones some
// of the properties of the sourceRecord
targetRecord = NULL;
PsychCreateWindowRecord(&targetRecord);
PsychInitWindowRecordTextureFields(targetRecord);
targetRecord->windowType=kPsychTexture;
targetRecord->screenNumber = sourceRecord->screenNumber;
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(targetRecord, sourceRecord);
targetRecord->depth = sourceRecord->depth;
// Assume this texture has four channels.
targetRecord->nrchannels = 4;
PsychCopyRect(targetRecord->rect, sourceRecord->rect);
PsychCopyRect(targetRecord->clientrect, targetRecord->rect);
targetRecord->texturetarget = sourceRecord->texturetarget;
// Orientation is set to 2 - like an upright Offscreen window texture:
targetRecord->textureOrientation = 2;
// Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(targetRecord);
}
else {
// Get the window structure for the target texture.
PsychAllocInWindowRecordArg(4, TRUE, &targetRecord);
if (!PsychIsTexture(targetRecord))
PsychErrorExitMsg(PsychError_user, "'targetTexture' argument must be a handle to a texture or offscreen window.");
}
// Make sure our source textures have at least a pseudo FBO for read-access:
PsychCreateShadowFBOForTexture(sourceRecord, FALSE, -1);
if (sourceRecord2)
PsychCreateShadowFBOForTexture(sourceRecord2, FALSE, -1);
// Make sure the target texture is upright/normalized:
if (!(specialFlags & 1))
PsychNormalizeTextureOrientation(targetRecord);
// Make sure our target texture has a full-blown FBO attached as a rendertarget.
// As our proxy object defines the image processing ops, it also defines the
// required imagingMode properties for the target texture:
PsychCreateShadowFBOForTexture(targetRecord, TRUE, proxyRecord->imagingMode);
// Assign GLSL filter-/lookup-shaders if needed: usefloatformat is queried.
// The 'userRequest' flag is set depending on specialFlags setting & 2.
glBindTexture(targetRecord->texturetarget, targetRecord->textureNumber);
glGetTexLevelParameteriv(targetRecord->texturetarget, 0, GL_TEXTURE_RED_SIZE, (GLint*) &d);
if (d <= 0)
glGetTexLevelParameteriv(targetRecord->texturetarget, 0, GL_TEXTURE_LUMINANCE_SIZE, (GLint*) &d);
glBindTexture(targetRecord->texturetarget, 0);
usefloatformat = 0;
if (d == 16) usefloatformat = 1;
if (d >= 32) usefloatformat = 2;
PsychAssignHighPrecisionTextureShaders(targetRecord, sourceRecord, usefloatformat, (specialFlags & 2) ? 1 : 0);
// Make sure our proxy has suitable bounce buffers if we need any:
if (proxyRecord->imagingMode & (kPsychNeedDualPass | kPsychNeedMultiPass)) {
// Needs multi-pass processing. Create bounce buffer if neccessary:
PsychCopyRect(proxyRecord->rect, targetRecord->rect);
PsychCopyRect(proxyRecord->clientrect, targetRecord->rect);
// Build FBO for bounce-buffering. This will always be upright/normalized,
// so no need to normalize "texture orientation" for proxyRecord bounce buffers:
PsychCreateShadowFBOForTexture(proxyRecord, TRUE, proxyRecord->imagingMode);
}
// Make sure we don't have VRAM memory feedback loops:
if ((sourceRecord->textureNumber == targetRecord->textureNumber) ||
(sourceRecord2 && (sourceRecord2->textureNumber == targetRecord->textureNumber)))
PsychErrorExitMsg(PsychError_user, "Source texture and target texture must be different!");
// Apply image processing operation: Use ressources and OpenGL context of proxyRecord, run user defined blit chain,
// Don't supply user specific data (NULL), don't supply override blitter (NULL), source is read-only (TRUE), no
// swizzle allowed (FALSE), sourceRecord is source, targetRecord is destination, bounce buffers provided by proxyRecord,
// no secondary FBO available (NULL).
PsychPipelineExecuteHook(proxyRecord, kPsychUserDefinedBlit, NULL, NULL, TRUE, FALSE,
&(sourceRecord->fboTable[sourceRecord->drawBufferFBO[0]]), (sourceRecord2) ? &(sourceRecord2->fboTable[sourceRecord2->drawBufferFBO[0]]) : NULL,
&(targetRecord->fboTable[targetRecord->drawBufferFBO[0]]), (proxyRecord->drawBufferFBO[0]!=-1) ? &(proxyRecord->fboTable[proxyRecord->drawBufferFBO[0]]) : NULL);
// Restore previous settings:
glPopAttrib();
// Set "dirty" flag on texture: (Ab)used to trigger regeneration of mip-maps during texture drawing of mip-mapped textures.
targetRecord->needsViewportSetup = TRUE;
//Return the window index and the rect argument.
PsychCopyOutDoubleArg(1, FALSE, targetRecord->windowIndex);
// Done.
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);
}
// This also works as 'AddFrameToMovie', as almost all code is shared with 'GetImage'.
// Only difference is where the fetched pixeldata is sent: To the movie encoder or to
// a matlab/octave matrix.
PsychError SCREENGetImage(void)
{
PsychRectType windowRect, sampleRect;
int nrchannels, invertedY, stride;
size_t ix, iy, sampleRectWidth, sampleRectHeight, redReturnIndex, greenReturnIndex, blueReturnIndex, alphaReturnIndex, planeSize;
int viewid = 0;
psych_uint8 *returnArrayBase, *redPlane;
float *dredPlane;
double *returnArrayBaseDouble;
PsychWindowRecordType *windowRecord;
GLboolean isDoubleBuffer, isStereo;
char* buffername = NULL;
psych_bool floatprecision = FALSE;
GLenum whichBuffer = 0;
int frameduration = 1;
int moviehandle = 0;
unsigned int twidth, theight, numChannels, bitdepth;
unsigned char* framepixels;
psych_bool isOES;
// Called as 2nd personality "AddFrameToMovie" ?
psych_bool isAddMovieFrame = PsychMatch(PsychGetFunctionName(), "AddFrameToMovie");
// All sub functions should have these two lines
if (isAddMovieFrame) {
PsychPushHelp(useString2, synopsisString2, seeAlsoString);
}
else {
PsychPushHelp(useString, synopsisString, seeAlsoString);
}
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//cap the numbers of inputs and outputs
PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Get windowRecord for this window:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Embedded subset has very limited support for readback formats :
isOES = PsychIsGLES(windowRecord);
// Make sure we don't execute on an onscreen window with pending async flip, as this would interfere
// by touching the system backbuffer -> Impaired timing of the flip thread and undefined readback
// of image data due to racing with the ops of the flipperthread on the same drawable.
//
// Note: It would be possible to allow drawBuffer readback if the drawBuffer is not multi-sampled
// or if we can safely multisample-resolve without touching the backbuffer, but checking for all
// special cases adds ugly complexity and is not really worth the effort, so we don't allow this.
//
// If this passes then PsychSetDrawingTarget() below will trigger additional validations to check
// if execution of 'GetImage' is allowed under the current conditions for offscreen windows and
// textures:
if (PsychIsOnscreenWindow(windowRecord) && (windowRecord->flipInfo->asyncstate > 0)) {
PsychErrorExitMsg(PsychError_user, "Calling this function on an onscreen window with a pending asynchronous flip is not allowed!");
}
// Set window as drawingtarget: Even important if this binding is changed later on!
// We need to make sure all needed transitions are done - esp. in non-imaging mode,
// so backbuffer is in a useable state:
PsychSetDrawingTarget(windowRecord);
// Disable shaders:
PsychSetShader(windowRecord, 0);
// Soft-Reset drawingtarget. This is important to make sure no FBO's are bound,
// otherwise the following glGets for GL_DOUBLEBUFFER and GL_STEREO will retrieve
// wrong results, leading to totally wrong read buffer assignments down the road!!
PsychSetDrawingTarget((PsychWindowRecordType*) 0x1);
// Queries only available on desktop OpenGL:
if (!isOES) {
glGetBooleanv(GL_DOUBLEBUFFER, &isDoubleBuffer);
glGetBooleanv(GL_STEREO, &isStereo);
}
else {
// Make something reasonable up:
isStereo = FALSE;
isDoubleBuffer = TRUE;
}
// Force "quad-buffered" stereo mode if our own homegrown implementation is active:
if (windowRecord->stereomode == kPsychFrameSequentialStereo) isStereo = TRUE;
// Assign read buffer:
if(PsychIsOnscreenWindow(windowRecord)) {
// Onscreen window: We read from the front- or front-left buffer by default.
// This works on single-buffered and double buffered contexts in a consistent fashion:
// Copy in optional override buffer name:
PsychAllocInCharArg(3, FALSE, &buffername);
// Override buffer name provided?
if (buffername) {
// Which one is it?
// "frontBuffer" is always a valid choice:
if (PsychMatch(buffername, "frontBuffer")) whichBuffer = GL_FRONT;
// Allow selection of left- or right front stereo buffer in stereo mode:
if (PsychMatch(buffername, "frontLeftBuffer") && isStereo) whichBuffer = GL_FRONT_LEFT;
if (PsychMatch(buffername, "frontRightBuffer") && isStereo) whichBuffer = GL_FRONT_RIGHT;
// Allow selection of backbuffer in double-buffered mode:
if (PsychMatch(buffername, "backBuffer") && isDoubleBuffer) whichBuffer = GL_BACK;
// Allow selection of left- or right back stereo buffer in stereo mode:
if (PsychMatch(buffername, "backLeftBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_LEFT;
if (PsychMatch(buffername, "backRightBuffer") && isStereo && isDoubleBuffer) whichBuffer = GL_BACK_RIGHT;
// Allow AUX buffer access for debug purposes:
if (PsychMatch(buffername, "aux0Buffer")) whichBuffer = GL_AUX0;
if (PsychMatch(buffername, "aux1Buffer")) whichBuffer = GL_AUX1;
if (PsychMatch(buffername, "aux2Buffer")) whichBuffer = GL_AUX2;
if (PsychMatch(buffername, "aux3Buffer")) whichBuffer = GL_AUX3;
// If 'drawBuffer' is requested, but imaging pipeline inactive, ie., there is no real 'drawBuffer', then we
// map this to the backbuffer, as on a non-imaging configuration, the backbuffer is pretty much exactly the
// equivalent of the 'drawBuffer':
if (PsychMatch(buffername, "drawBuffer") && !(windowRecord->imagingMode & kPsychNeedFastBackingStore)) whichBuffer = GL_BACK;
}
else {
// Default is frontbuffer:
whichBuffer = GL_FRONT;
}
}
else {
// Offscreen window or texture: They only have one buffer, which is the
// backbuffer in double-buffered mode and the frontbuffer in single buffered mode:
whichBuffer=(isDoubleBuffer) ? GL_BACK : GL_FRONT;
}
// Enable this windowRecords framebuffer as current drawingtarget. This should
// also allow us to "GetImage" from Offscreen windows:
if ((windowRecord->imagingMode & kPsychNeedFastBackingStore) || (windowRecord->imagingMode & kPsychNeedFastOffscreenWindows)) {
// Special case: Imaging pipeline active - We need to activate system framebuffer
// so we really read the content of the framebuffer and not of some FBO:
if (PsychIsOnscreenWindow(windowRecord)) {
// It's an onscreen window:
// Homegrown frame-sequential stereo active? Need to remap some stuff:
if (windowRecord->stereomode == kPsychFrameSequentialStereo) {
// Back/Front buffers map to backleft/frontleft buffers:
if (whichBuffer == GL_BACK) whichBuffer = GL_BACK_LEFT;
if (whichBuffer == GL_FRONT) whichBuffer = GL_FRONT_LEFT;
// Special case: Want to read from stereo front buffer?
if ((whichBuffer == GL_FRONT_LEFT) || (whichBuffer == GL_FRONT_RIGHT)) {
// These don't really exist in our homegrown implementation. Their equivalents are the
// regular system front/backbuffers. Due to the bufferswaps happening every video
// refresh cycle and the complex logic on when and how to blit finalizedFBOs into
// the system buffers and the asynchronous execution of the parallel flipper thread,
// we don't know which buffer (GL_BACK or GL_FRONT) corresponds to the leftFront or
// rightFront buffer. Let's be stupid and just return the current front buffer for
// FRONT_LEFT and the current back buffer for FRONT_RIGHT, but warn user about the
// ambiguity:
whichBuffer = (whichBuffer == GL_FRONT_LEFT) ? GL_FRONT : GL_BACK;
if (PsychPrefStateGet_Verbosity() > 2) {
printf("PTB-WARNING: In Screen('GetImage'): You selected retrieval of one of the stereo front buffers, while our homegrown frame-sequential\n");
printf("PTB-WARNING: In Screen('GetImage'): stereo display mode is active. This will impair presentation timing and may cause flicker. The\n");
printf("PTB-WARNING: In Screen('GetImage'): mapping of 'frontLeftBuffer' and 'frontRightBuffer' to actual stimulus content is very ambiguous\n");
printf("PTB-WARNING: In Screen('GetImage'): in this mode. You may therefore end up with the content of the wrong buffer returned! Check results\n");
printf("PTB-WARNING: In Screen('GetImage'): carefully! Better read from 'backLeftBuffer' or 'backRightBuffer' for well defined results.\n\n");
}
}
}
// Homegrown frame-sequential stereo active and backleft or backright buffer requested?
if (((whichBuffer == GL_BACK_LEFT) || (whichBuffer == GL_BACK_RIGHT)) && (windowRecord->stereomode == kPsychFrameSequentialStereo)) {
// We can get the equivalent of the backLeft/RightBuffer from the finalizedFBO's in this mode. Get their content:
viewid = (whichBuffer == GL_BACK_RIGHT) ? 1 : 0;
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// Bind finalizedFBO as framebuffer to read from:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->finalizedFBO[viewid]]->fboid);
// Make sure binding gets released at end of routine:
viewid = -1;
} // No frame-sequential stereo: Full imaging pipeline active and one of the drawBuffer's requested?
else if (buffername && (PsychMatch(buffername, "drawBuffer")) && (windowRecord->imagingMode & kPsychNeedFastBackingStore)) {
// Activate drawBufferFBO:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// Is the drawBufferFBO multisampled?
viewid = (((windowRecord->stereomode > 0) && (windowRecord->stereodrawbuffer == 1)) ? 1 : 0);
if (windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->multisample > 0) {
// It is! We can't read from a multisampled FBO. Need to perform a multisample resolve operation and read
// from the resolved unisample buffer instead. This is only safe if the unisample buffer is either a dedicated
// FBO, or - in case its the final system backbuffer etc. - if preflip operations haven't been performed yet.
// If non dedicated buffer (aka finalizedFBO) and preflip ops have already happened, then the backbuffer contains
// final content for an upcoming Screen('Flip') and we can't use (and therefore taint) that buffer.
if ((windowRecord->inputBufferFBO[viewid] == windowRecord->finalizedFBO[viewid]) && (windowRecord->backBufferBackupDone)) {
// Target for resolve is finalized FBO (probably system backbuffer) and preflip ops have run already. We
// can't do the resolve op, as this would screw up the backbuffer with the final stimulus:
printf("PTB-ERROR: Tried to 'GetImage' from a multisampled 'drawBuffer', but can't perform anti-aliasing pass due to\n");
printf("PTB-ERROR: lack of a dedicated resolve buffer.\n");
printf("PTB-ERROR: You can get what you wanted by either one of two options:\n");
printf("PTB-ERROR: Either enable a processing stage in the imaging pipeline, even if you don't need it, e.g., by setting\n");
printf("PTB-ERROR: the imagingmode argument in the 'OpenWindow' call to kPsychNeedImageProcessing. This will create a\n");
printf("PTB-ERROR: suitable resolve buffer. Or place the 'GetImage' call before any Screen('DrawingFinished') call, then\n");
printf("PTB-ERROR: i can (ab-)use the system backbuffer as a temporary resolve buffer.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled 'drawBuffer'. Unsupported operation under given conditions.");
}
else {
// Ok, the inputBufferFBO is a suitable temporary resolve buffer. Perform a multisample resolve blit to it:
// A simple glBlitFramebufferEXT() call will do the copy & downsample operation:
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->drawBufferFBO[viewid]]->fboid);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
glBlitFramebufferEXT(0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
0, 0, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->width, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
// Bind inputBuffer as framebuffer:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, windowRecord->fboTable[windowRecord->inputBufferFBO[viewid]]->fboid);
viewid = -1;
}
}
}
else {
// No: Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
}
else {
// Offscreen window or texture: Select drawing target as usual,
// but set color attachment as read buffer:
PsychSetDrawingTarget(windowRecord);
whichBuffer = GL_COLOR_ATTACHMENT0_EXT;
// We do not support multisampled readout:
if (windowRecord->fboTable[windowRecord->drawBufferFBO[0]]->multisample > 0) {
printf("PTB-ERROR: You tried to Screen('GetImage', ...); from an offscreen window or texture which has multisample anti-aliasing enabled.\n");
printf("PTB-ERROR: This operation is not supported. You must first use Screen('CopyWindow') to create a non-multisampled copy of the\n");
printf("PTB-ERROR: texture or offscreen window, then use 'GetImage' on that copy. The copy will be anti-aliased, so you'll get what you\n");
printf("PTB-ERROR: wanted with a bit more effort. Sorry for the inconvenience, but this is mostly a hardware limitation.\n\n");
PsychErrorExitMsg(PsychError_user, "Tried to 'GetImage' from a multi-sampled texture or offscreen window. Unsupported operation.");
}
}
}
else {
// Normal case: No FBO based imaging - Select drawing target as usual:
PsychSetDrawingTarget(windowRecord);
}
if (!isOES) {
// Select requested read buffer, after some double-check:
if (whichBuffer == 0) PsychErrorExitMsg(PsychError_user, "Invalid or unknown 'bufferName' argument provided.");
glReadBuffer(whichBuffer);
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: In Screen('GetImage'): GL-Readbuffer whichBuffer = %i\n", whichBuffer);
}
else {
// OES: No way to select readbuffer, it is "hard-coded" by system spec, depending
// on framebuffer. For bound FBO, always color attachment zero, for system framebuffer,
// always front buffer on single-buffered setup, back buffer on double-buffered setup:
if (buffername && PsychIsOnscreenWindow(windowRecord) && (whichBuffer != GL_COLOR_ATTACHMENT0_EXT)) {
// Some part of the real system framebuffer of an onscreen window explicitely requested.
if ((windowRecord->windowType == kPsychSingleBufferOnscreen) && (whichBuffer != GL_FRONT) && (PsychPrefStateGet_Verbosity() > 1)) {
printf("PTB-WARNING: Tried to Screen('GetImage') single-buffered framebuffer '%s', but only 'frontBuffer' supported on OpenGL-ES. Returning that instead.\n", buffername);
}
if ((windowRecord->windowType == kPsychDoubleBufferOnscreen) && (whichBuffer != GL_BACK) && (PsychPrefStateGet_Verbosity() > 1)) {
printf("PTB-WARNING: Tried to Screen('GetImage') double-buffered framebuffer '%s', but only 'backBuffer' supported on OpenGL-ES. Returning that instead.\n", buffername);
}
}
}
if (whichBuffer == GL_COLOR_ATTACHMENT0_EXT) {
// FBO of texture / offscreen window / onscreen drawBuffer/inputBuffer
// has size of clientrect -- potentially larger or smaller than backbuffer:
PsychCopyRect(windowRect, windowRecord->clientrect);
}
else {
// Non-FBO backed texture / offscreen window / onscreen window has size
// of raw rect (==clientrect for non-onscreen, == backbuffer size for onscreen):
PsychCopyRect(windowRect, windowRecord->rect);
}
// Retrieve optional read rectangle:
if(!PsychCopyInRectArg(2, FALSE, sampleRect)) PsychCopyRect(sampleRect, windowRect);
if (IsPsychRectEmpty(sampleRect)) return(PsychError_none);
// Compute sampling rectangle:
if ((PsychGetWidthFromRect(sampleRect) >= INT_MAX) || (PsychGetHeightFromRect(sampleRect) >= INT_MAX)) {
PsychErrorExitMsg(PsychError_user, "Too big 'rect' argument provided. Both width and height of the rect must not exceed 2^31 pixels!");
}
sampleRectWidth = (size_t) PsychGetWidthFromRect(sampleRect);
sampleRectHeight= (size_t) PsychGetHeightFromRect(sampleRect);
// Regular image fetch to runtime, or adding to a movie?
if (!isAddMovieFrame) {
// Regular fetch:
// Get optional floatprecision flag: We return data with float-precision if
// this flag is set. By default we return uint8 data:
PsychCopyInFlagArg(4, FALSE, &floatprecision);
// Get the optional number of channels flag: By default we return 3 channels,
// the Red, Green, and blue color channel:
nrchannels = 3;
PsychCopyInIntegerArg(5, FALSE, &nrchannels);
if (nrchannels < 1 || nrchannels > 4) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' must be between 1 and 4!");
if (!floatprecision) {
// Readback of standard 8bpc uint8 pixels:
// No Luminance + Alpha on OES:
if (isOES && (nrchannels == 2)) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' == 2 not supported on OpenGL-ES!");
PsychAllocOutUnsignedByteMatArg(1, TRUE, (int) sampleRectHeight, (int) sampleRectWidth, (int) nrchannels, &returnArrayBase);
if (isOES) {
// We only do RGBA reads on OES, then discard unwanted stuff ourselves:
redPlane = (psych_uint8*) PsychMallocTemp((size_t) 4 * sampleRectWidth * sampleRectHeight);
}
else {
redPlane = (psych_uint8*) PsychMallocTemp((size_t) nrchannels * sampleRectWidth * sampleRectHeight);
}
planeSize = sampleRectWidth * sampleRectHeight;
glPixelStorei(GL_PACK_ALIGNMENT,1);
invertedY = (int) (windowRect[kPsychBottom] - sampleRect[kPsychBottom]);
if (isOES) {
glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_UNSIGNED_BYTE, redPlane);
stride = 4;
}
else {
stride = nrchannels;
if (nrchannels==1) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RED, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels==2) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels==3) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGB, GL_UNSIGNED_BYTE, redPlane);
if (nrchannels==4) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_UNSIGNED_BYTE, redPlane);
}
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0; ix < sampleRectWidth; ix++){
for(iy=0; iy < sampleRectHeight; iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBase[redReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 0];
// Other channels on demand:
if (nrchannels>1) returnArrayBase[greenReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 1];
if (nrchannels>2) returnArrayBase[blueReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 2];
if (nrchannels>3) returnArrayBase[alphaReturnIndex] = redPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 3];
}
}
}
else {
// Readback of standard 32bpc float pixels into a double matrix:
// No Luminance + Alpha on OES:
if (isOES && (nrchannels == 2)) PsychErrorExitMsg(PsychError_user, "Number of requested channels 'nrchannels' == 2 not supported on OpenGL-ES!");
// Only float readback on floating point FBO's with EXT_color_buffer_float support:
if (isOES && ((whichBuffer != GL_COLOR_ATTACHMENT0_EXT) || (windowRecord->bpc < 16) || !glewIsSupported("GL_EXT_color_buffer_float"))) {
printf("PTB-ERROR: Tried to 'GetImage' pixels in floating point format from a non-floating point surface, or not supported by your hardware.\n");
PsychErrorExitMsg(PsychError_user, "'GetImage' of floating point values from given object not supported on OpenGL-ES!");
}
PsychAllocOutDoubleMatArg(1, TRUE, (int) sampleRectHeight, (int) sampleRectWidth, (int) nrchannels, &returnArrayBaseDouble);
if (isOES) {
dredPlane = (float*) PsychMallocTemp((size_t) 4 * sizeof(float) * sampleRectWidth * sampleRectHeight);
stride = 4;
}
else {
dredPlane = (float*) PsychMallocTemp((size_t) nrchannels * sizeof(float) * sampleRectWidth * sampleRectHeight);
stride = nrchannels;
}
planeSize = sampleRectWidth * sampleRectHeight * sizeof(float);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
invertedY = (int) (windowRect[kPsychBottom]-sampleRect[kPsychBottom]);
if (!isOES) {
if (nrchannels==1) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RED, GL_FLOAT, dredPlane);
if (nrchannels==2) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_LUMINANCE_ALPHA, GL_FLOAT, dredPlane);
if (nrchannels==3) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGB, GL_FLOAT, dredPlane);
if (nrchannels==4) glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_FLOAT, dredPlane);
}
else {
glReadPixels((int) sampleRect[kPsychLeft], invertedY, (int) sampleRectWidth, (int) sampleRectHeight, GL_RGBA, GL_FLOAT, dredPlane);
}
//in one pass transpose and flip what we read with glReadPixels before returning.
//-glReadPixels insists on filling up memory in sequence by reading the screen row-wise whearas Matlab reads up memory into columns.
//-the Psychtoolbox screen as setup by gluOrtho puts 0,0 at the top left of the window but glReadPixels always believes that it's at the bottom left.
for(ix=0; ix < sampleRectWidth; ix++){
for(iy=0; iy < sampleRectHeight; iy++){
// Compute write-indices for returned data:
redReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 0);
greenReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 1);
blueReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 2);
alphaReturnIndex=PsychIndexElementFrom3DArray(sampleRectHeight, sampleRectWidth, nrchannels, iy, ix, 3);
// Always return RED/LUMINANCE channel:
returnArrayBaseDouble[redReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 0];
// Other channels on demand:
if (nrchannels>1) returnArrayBaseDouble[greenReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 1];
if (nrchannels>2) returnArrayBaseDouble[blueReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 2];
if (nrchannels>3) returnArrayBaseDouble[alphaReturnIndex] = dredPlane[(ix + ((sampleRectHeight-1) - iy ) * sampleRectWidth) * (size_t) stride + 3];
}
}
}
}
if (isAddMovieFrame) {
// Adding of image to a movie requested:
// Get optional moviehandle:
moviehandle = 0;
PsychCopyInIntegerArg(4, FALSE, &moviehandle);
if (moviehandle < 0) PsychErrorExitMsg(PsychError_user, "Provided 'moviehandle' is negative. Must be greater or equal to zero!");
// Get optional frameduration:
frameduration = 1;
PsychCopyInIntegerArg(5, FALSE, &frameduration);
if (frameduration < 1) PsychErrorExitMsg(PsychError_user, "Number of requested framedurations 'frameduration' is negative. Must be greater than zero!");
framepixels = PsychGetVideoFrameForMoviePtr(moviehandle, &twidth, &theight, &numChannels, &bitdepth);
if (framepixels) {
glPixelStorei(GL_PACK_ALIGNMENT,1);
invertedY = (int) (windowRect[kPsychBottom] - sampleRect[kPsychBottom]);
if (isOES) {
if (bitdepth != 8) PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed due to wrong bpc value. Only 8 bpc supported on OpenGL-ES.");
if (numChannels == 4) {
// OES: BGRA supported?
if (glewIsSupported("GL_EXT_read_format_bgra")) {
// Yep: Readback in a compatible and acceptably fast format:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_BGRA, GL_UNSIGNED_BYTE, framepixels);
}
else {
// Suboptimal readback path. will also cause swapped colors in movie writing:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RGBA, GL_UNSIGNED_BYTE, framepixels);
}
}
else if (numChannels == 3) {
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RGB, GL_UNSIGNED_BYTE, framepixels);
}
else PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed due to wrong number of channels. Only 3 or 4 channels are supported on OpenGL-ES.");
}
else {
// Desktop-GL: Use optimal format and support 16 bpc bitdepth as well.
switch (numChannels) {
case 4:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_BGRA, (bitdepth <= 8) ? GL_UNSIGNED_INT_8_8_8_8 : GL_UNSIGNED_SHORT, framepixels);
break;
case 3:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RGB, (bitdepth <= 8) ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT, framepixels);
break;
case 1:
glReadPixels((int) sampleRect[kPsychLeft], invertedY, twidth, theight, GL_RED, (bitdepth <= 8) ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT, framepixels);
break;
default:
PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed due to wrong number of channels. Only 1, 3 or 4 channels are supported on OpenGL.");
break;
}
}
// Add frame to movie, mark it as "upside down", with invalid -1 timestamp and a duration of frameduration ticks:
if (PsychAddVideoFrameToMovie(moviehandle, frameduration, TRUE, -1) != 0) {
PsychErrorExitMsg(PsychError_user, "AddFrameToMovie failed with error above!");
}
}
else {
PsychErrorExitMsg(PsychError_user, "Invalid 'moviePtr' provided. Doesn't correspond to a movie open for recording!");
}
}
if (viewid == -1) {
// Need to reset framebuffer binding to get rid of the inputBufferFBO which is bound due to
// multisample resolve ops, or of other special FBO bindings --> Activate system framebuffer:
PsychSetDrawingTarget(NULL);
}
return(PsychError_none);
}
PsychError SCREENWaitBlanking(void)
{
PsychWindowRecordType *windowRecord;
int waitFrames, framesWaited;
double tvbl, ifi;
long screenwidth, screenheight;
int vbl_startline, beampos, lastline;
psych_uint64 vblCount, vblRefCount;
CGDirectDisplayID cgDisplayID;
GLint read_buffer, draw_buffer;
// All subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs
PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if(!PsychIsOnscreenWindow(windowRecord))
PsychErrorExitMsg(PsychError_user, "Tried to call 'WaitBlanking' on something else than an onscreen window!");
// Get the number of frames to wait:
waitFrames = 0;
PsychCopyInIntegerArg(2, FALSE, &waitFrames);
// We default to wait at least one interval if no argument supplied:
waitFrames = (waitFrames < 1) ? 1 : waitFrames;
// Enable this windowRecords framebuffer as current drawingtarget:
// This is needed to make sure that Offscreen windows work propely.
PsychSetDrawingTarget(windowRecord);
// Retrieve display handle for beamposition queries:
PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, windowRecord->screenNumber);
// Retrieve final vbl_startline, aka physical height of the display in pixels:
PsychGetScreenSize(windowRecord->screenNumber, &screenwidth, &screenheight);
vbl_startline = (int) screenheight;
// Query duration of a monitor refresh interval: We try to use the measured interval,
// but fallback of the nominal value reported by the operating system if necessary:
if ((ifi = windowRecord->VideoRefreshInterval)<=0) {
if (PsychGetNominalFramerate(windowRecord->screenNumber) > 0) {
// Valid nominal framerate returned by OS: Calculate nominal IFI from it.
ifi = 1.0 / ((double) PsychGetNominalFramerate(windowRecord->screenNumber));
}
else {
// No reasonable value available! We fallback to an assumed 60 Hz refresh...
ifi = 1.0 / 60.0;
}
}
// Query vblcount to test if this method works correctly:
PsychOSGetVBLTimeAndCount(windowRecord, &vblRefCount);
// Check if beamposition queries are supported by this OS and working properly:
if (-1 != PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber) && windowRecord->VBL_Endline >= 0) {
// Beamposition queries supported and fine. We can wait for VBL without bufferswap-tricks:
// This is the OS-X way of doing things. We query the rasterbeamposition and compare it
// to the known values for the VBL area. If we enter VBL, we take a timestamp and return -
// or wait for the next VBL if waitFrames>0
// Query current beamposition when entering WaitBlanking:
beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
// Are we in VBL when entering WaitBlanking? If so, we should wait for one additional frame,
// because by definition, WaitBlanking should always wait for at least one monitor refresh
// interval...
if ((beampos<=windowRecord->VBL_Endline) && (beampos>=vbl_startline)) waitFrames++;
while(waitFrames > 0) {
// Enough time for a sleep? If the beam is far away from VBL area, we try to sleep to
// yield some CPU time to other processes in the system -- we are nice citizens ;)
beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
while (( ((float)(vbl_startline - beampos)) / (float) windowRecord->VBL_Endline * ifi) > 0.003) {
// At least 3 milliseconds left until retrace. We sleep for 1 millisecond.
PsychWaitIntervalSeconds(0.001);
beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
}
// Less than 3 ms away from retrace. Busy-Wait for retrace...
lastline = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
beampos = lastline;
while ((beampos < vbl_startline) && (beampos >= lastline)) {
lastline = beampos;
beampos = (long) PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber);
}
// Retrace! Take system timestamp of VBL onset:
PsychGetAdjustedPrecisionTimerSeconds(&tvbl);
// If this wasn't the last frame to wait, we need to wait for end of retrace before
// repeating the loop, because otherwise we would detect the same VBL and skip frames.
// If it is the last frame, we skip it and return as quickly as possible to save the
// Matlab script some extra Millisecond for drawing...
if (waitFrames>1) {
beampos = vbl_startline;
while ((beampos<=windowRecord->VBL_Endline) && (beampos>=vbl_startline)) { beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); };
}
// Done with this refresh interval...
// Decrement remaining number of frames to wait:
waitFrames--;
}
}
else if (vblRefCount > 0) {
// Display beamposition queries unsupported, but vblank count queries seem to work. Try those.
// Should work on Linux and OS/X:
while(waitFrames > 0) {
vblCount = vblRefCount;
// Wait for next vblank counter increment - aka start of next frame (its vblank):
while (vblCount == vblRefCount) {
// Requery:
PsychOSGetVBLTimeAndCount(windowRecord, &vblCount);
// Yield at least 100 usecs. This is accurate as this code-path
// only executes on OS/X and Linux, never on Windows (as of 01/06/2011):
PsychYieldIntervalSeconds(0.000100);
}
vblRefCount = vblCount;
// Done with this refresh interval...
// Decrement remaining number of frames to wait:
waitFrames--;
}
}
else {
// Other methods unsupported. We use the doublebuffer swap method of waiting for retrace.
//
// Working principle: On each frame, we first copy the content of the (user visible) frontbuffer into the backbuffer.
// Then we ask the OS to perform a front-backbuffer swap on next vertical retrace and go to sleep via glFinish() et al.
// until the OS signals swap-completion. This way PTB's/Matlabs execution will stall until VBL, when swap happens and
// we get woken up. We repeat this procedure 'waitFrames' times, then we take a high precision timestamp and exit the
// Waitblanking loop. As backbuffer and frontbuffer are identical (due to the copy) at swap time, the visual display
// won't change at all for the subject.
// This method should work reliably, but it has one drawback: A random wakeup delay (scheduling jitter) is added after
// retrace has been entered, so Waitblanking returns only after the beam has left retrace state on older hardware.
// This means a bit less time (1 ms?) for stimulus drawing on Windows than on OS-X where Waitblanking returns faster.
// Child protection:
if (windowRecord->windowType != kPsychDoubleBufferOnscreen) {
PsychErrorExitMsg(PsychError_internal, "WaitBlanking tried to perform swap-waiting on a single buffered window!");
}
// Setup buffers for front->back copy op:
// Backup old read- writebuffer assignments:
glGetIntegerv(GL_READ_BUFFER, &read_buffer);
glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
// Set read- and writebuffer properly:
glReadBuffer(GL_FRONT);
glDrawBuffer(GL_BACK);
// Reset viewport to full-screen default:
glViewport(0, 0, screenwidth, screenheight);
glScissor(0, 0, screenwidth, screenheight);
// Reset color buffer writemask to "All enabled":
glColorMask(TRUE, TRUE, TRUE, TRUE);
glDisable(GL_BLEND);
glPixelZoom(1,1);
// Disable draw shader:
PsychSetShader(windowRecord, 0);
// Swap-Waiting loop for 'waitFrames' frames:
while(waitFrames > 0) {
// Copy current content of front buffer into backbuffer:
glRasterPos2i(0, screenheight);
glCopyPixels(0, 0, screenwidth, screenheight, GL_COLOR);
// Ok, front- and backbuffer are now identical, so a bufferswap
// will be a visual no-op.
// Enable beamsyncing of bufferswaps to VBL:
PsychOSSetVBLSyncLevel(windowRecord, 1);
// Trigger bufferswap in sync with retrace:
PsychOSFlipWindowBuffers(windowRecord);
// Wait for swap-completion, aka beginning of VBL:
PsychWaitPixelSyncToken(windowRecord);
// VBL happened - Take system timestamp:
PsychGetAdjustedPrecisionTimerSeconds(&tvbl);
// This code-chunk is an alternate way of syncing, only used for debugging:
if (false) {
// Disable beamsyncing of bufferswaps to VBL:
PsychOSSetVBLSyncLevel(windowRecord, 0);
// Swap buffers immediately without vsync:
PsychOSFlipWindowBuffers(windowRecord);
}
// Decrement remaining number of frames to wait:
waitFrames--;
} // Do it again...
// Enable beamsyncing of bufferswaps to VBL:
PsychOSSetVBLSyncLevel(windowRecord, 1);
// Restore assignment of read- writebuffers and such:
glEnable(GL_BLEND);
glReadBuffer(read_buffer);
glDrawBuffer(draw_buffer);
// Done with Windows waitblanking...
}
// Compute number of frames waited: It is timestamp of return of this waitblanking minus
// timestamp of return of last waitblanking, divided by duration of a monitor refresh
// interval, mathematically rounded to an integral number:
framesWaited = (int) (((tvbl - windowRecord->time_at_last_vbl) / ifi) + 0.5f);
// Update timestamp for next invocation of Waitblanking:
windowRecord->time_at_last_vbl = tvbl;
// Return optional number of frames waited:
PsychCopyOutDoubleArg(1, FALSE, (double) framesWaited);
// Done.
return(PsychError_none);
}
PsychError SCREENCopyWindow(void)
{
PsychRectType sourceRect, targetRect, targetRectInverted;
PsychWindowRecordType *sourceWin, *targetWin;
GLdouble sourceVertex[2], targetVertex[2];
double t1;
double sourceRectWidth, sourceRectHeight;
GLuint srcFBO, dstFBO;
GLenum glerr;
//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(5)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
//get parameters for the source window:
PsychAllocInWindowRecordArg(1, TRUE, &sourceWin);
PsychCopyRect(sourceRect, sourceWin->rect);
// Special case for stereo: Only half the real window width:
PsychMakeRect(&sourceRect, sourceWin->rect[kPsychLeft], sourceWin->rect[kPsychTop],
sourceWin->rect[kPsychLeft] + PsychGetWidthFromRect(sourceWin->rect)/((sourceWin->specialflags & kPsychHalfWidthWindow) ? 2 : 1),
sourceWin->rect[kPsychTop] + PsychGetHeightFromRect(sourceWin->rect)/((sourceWin->specialflags & kPsychHalfHeightWindow) ? 2 : 1));
PsychCopyInRectArg(3, FALSE, sourceRect);
if (IsPsychRectEmpty(sourceRect)) return(PsychError_none);
//get paramters for the target window:
PsychAllocInWindowRecordArg(2, TRUE, &targetWin);
// By default, the targetRect is equal to the sourceRect, but centered in
// the target window.
PsychCopyRect(targetRect, targetWin->rect);
// Special case for stereo: Only half the real window width:
PsychMakeRect(&targetRect, targetWin->rect[kPsychLeft], targetWin->rect[kPsychTop],
targetWin->rect[kPsychLeft] + PsychGetWidthFromRect(targetWin->rect)/((targetWin->specialflags & kPsychHalfWidthWindow) ? 2 : 1),
targetWin->rect[kPsychTop] + PsychGetHeightFromRect(targetWin->rect)/((targetWin->specialflags & kPsychHalfHeightWindow) ? 2 : 1));
PsychCopyInRectArg(4, FALSE, targetRect);
if (IsPsychRectEmpty(targetRect)) return(PsychError_none);
if (0) {
printf("SourceRect: %f %f %f %f ---> TargetRect: %f %f %f %f\n", sourceRect[0], sourceRect[1],
sourceRect[2], sourceRect[3], targetRect[0], targetRect[1],targetRect[2],targetRect[3]);
}
// Validate rectangles:
if (!ValidatePsychRect(sourceRect) || sourceRect[kPsychLeft]<sourceWin->rect[kPsychLeft] ||
sourceRect[kPsychTop]<sourceWin->rect[kPsychTop] || sourceRect[kPsychRight]>sourceWin->rect[kPsychRight] ||
sourceRect[kPsychBottom]>sourceWin->rect[kPsychBottom]) {
PsychErrorExitMsg(PsychError_user, "Invalid source rectangle specified - (Partially) outside of source window.");
}
if (!ValidatePsychRect(targetRect) || targetRect[kPsychLeft]<targetWin->rect[kPsychLeft] ||
targetRect[kPsychTop]<targetWin->rect[kPsychTop] || targetRect[kPsychRight]>targetWin->rect[kPsychRight] ||
targetRect[kPsychBottom]>targetWin->rect[kPsychBottom]) {
PsychErrorExitMsg(PsychError_user, "Invalid target rectangle specified - (Partially) outside of target window.");
}
if (!(PsychPrefStateGet_ConserveVRAM() & kPsychAvoidCPUGPUSync)) PsychTestForGLErrors();
// Does this GL implementation support the EXT_framebuffer_blit extension for fast blitting between
// framebuffers? And is the imaging pipeline active? And is the kPsychAvoidFramebufferBlitIfPossible not set?
if ((sourceWin->gfxcaps & kPsychGfxCapFBOBlit) && (targetWin->gfxcaps & kPsychGfxCapFBOBlit) &&
(sourceWin->imagingMode > 0) && (targetWin->imagingMode > 0) && !(PsychPrefStateGet_ConserveVRAM() & kPsychAvoidFramebufferBlitIfPossible)) {
// Yes :-) -- This simplifies the CopyWindow implementation to a simple framebuffer blit op,
// regardless what the source- or destination is:
// Set each windows framebuffer as a drawingtarget once: This is just to make sure all of them
// have proper FBO's attached:
PsychSetDrawingTarget(sourceWin);
PsychSetDrawingTarget(targetWin);
// Soft-Reset drawing target - Detach anything bound or setup:
PsychSetDrawingTarget(0x1);
// Find source framebuffer:
if (sourceWin->fboCount == 0) {
// No FBO's attached to sourceWin: Must be a system framebuffer, e.g., if imagingMode == kPsychNeedFastOffscreenWindows and
// this is the onscreen window system framebuffer. Assign system framebuffer handle:
srcFBO = 0;
}
else {
// FBO's attached: Want drawBufferFBO 0 or 1 - 1 for right eye view in stereomode, 0 for
// everything else: left eye view, monoscopic buffer, offscreen windows / textures:
if ((sourceWin->stereomode > 0) && (sourceWin->stereodrawbuffer == 1)) {
// We are in stereo mode and want to access the right-eye channel. Bind FBO-1
srcFBO = sourceWin->fboTable[sourceWin->drawBufferFBO[1]]->fboid;
}
else {
srcFBO = sourceWin->fboTable[sourceWin->drawBufferFBO[0]]->fboid;
}
}
// Find target framebuffer:
if (targetWin->fboCount == 0) {
// No FBO's attached to targetWin: Must be a system framebuffer, e.g., if imagingMode == kPsychNeedFastOffscreenWindows and
// this is the onscreen window system framebuffer. Assign system framebuffer handle:
dstFBO = 0;
}
else {
// FBO's attached: Want drawBufferFBO 0 or 1 - 1 for right eye view in stereomode, 0 for
// everything else: left eye view, monoscopic buffer, offscreen windows / textures:
if ((targetWin->stereomode > 0) && (targetWin->stereodrawbuffer == 1)) {
// We are in stereo mode and want to access the right-eye channel. Bind FBO-1
dstFBO = targetWin->fboTable[targetWin->drawBufferFBO[1]]->fboid;
}
else {
dstFBO = targetWin->fboTable[targetWin->drawBufferFBO[0]]->fboid;
}
}
// Bind read- / write- framebuffers:
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, srcFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, dstFBO);
// Perform blit-operation: If blitting from a multisampled FBO into a non-multisampled one, this will also perform the
// multisample resolve operation:
glBlitFramebufferEXT(sourceRect[kPsychLeft], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychBottom], sourceRect[kPsychRight], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychTop],
targetRect[kPsychLeft], PsychGetHeightFromRect(targetWin->rect) - targetRect[kPsychBottom], targetRect[kPsychRight], PsychGetHeightFromRect(targetWin->rect) - targetRect[kPsychTop],
GL_COLOR_BUFFER_BIT, GL_NEAREST);
if (PsychPrefStateGet_Verbosity() > 5) {
printf("FBB-SRC: X0 = %f Y0 = %f X1 = %f Y1 = %f \n", sourceRect[kPsychLeft], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychBottom], sourceRect[kPsychRight], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychTop]);
printf("FBB-DST: X0 = %f Y0 = %f X1 = %f Y1 = %f \n", targetRect[kPsychLeft], PsychGetHeightFromRect(targetWin->rect) - targetRect[kPsychBottom], targetRect[kPsychRight], PsychGetHeightFromRect(targetWin->rect) - targetRect[kPsychTop]);
}
if (!(PsychPrefStateGet_ConserveVRAM() & kPsychAvoidCPUGPUSync)) {
if ((glerr = glGetError())!=GL_NO_ERROR) {
// Reset framebuffer binding to something safe - The system framebuffer:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if((glerr == GL_INVALID_OPERATION) && (PsychGetWidthFromRect(sourceRect) != PsychGetWidthFromRect(targetRect) ||
PsychGetHeightFromRect(sourceRect) != PsychGetHeightFromRect(targetRect))) {
// Non-matching sizes. Make sure we do not operate on multisampled stuff
PsychErrorExitMsg(PsychError_user, "CopyWindow failed: Most likely cause: You tried to copy a multi-sampled window into a non-multisampled window, but there is a size mismatch of sourceRect and targetRect. Matching size is required for such copies.");
}
else {
if (glerr == GL_INVALID_OPERATION) {
PsychErrorExitMsg(PsychError_user, "CopyWindow failed: Most likely cause: You tried to copy from a multi-sampled window into another multisampled window, but there is a mismatch between the multiSample levels of both. Identical multiSample values are required for such copies.");
}
else {
printf("CopyWindow failed for unresolved reason: OpenGL says after call to glBlitFramebufferEXT(): %s\n", gluErrorString(glerr));
PsychErrorExitMsg(PsychError_user, "CopyWindow failed for unresolved reason.");
}
}
}
}
// Reset framebuffer binding to something safe - The system framebuffer:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
// Just to make sure we catch invalid values:
if (!(PsychPrefStateGet_ConserveVRAM() & kPsychAvoidCPUGPUSync)) PsychTestForGLErrors();
// Done.
return(PsychError_none);
}
// We have four possible combinations for copy ops:
// Onscreen -> Onscreen
// Onscreen -> Texture
// Texture -> Texture
// Texture -> Onscreen
// Texture -> something copy? (Offscreen to Offscreen or Offscreen to Onscreen)
// This should work for both, copies from a texture/offscreen window to a different texture/offscreen window/onscreen window,
// and for copies of a subregion of a texture/offscreen window into a non-overlapping subregion of the texture/offscreen window
// itself:
if (sourceWin->windowType == kPsychTexture) {
// Bind targetWin (texture or onscreen windows framebuffer) as
// drawing target and just blit texture into it. Binding is done implicitely
if ((sourceWin == targetWin) && (targetWin->imagingMode > 0)) {
// Copy of a subregion of an offscreen window into itself while imaging pipe active, ie. FBO storage: This is actually the same
// as on onscreen -> onscreen copy, just with the targetWin FBO bound.
// Set target windows framebuffer as drawing target:
PsychSetDrawingTarget(targetWin);
// Disable alpha-blending:
glDisable(GL_BLEND);
// Disable any shading during copy-op:
PsychSetShader(targetWin, 0);
// Start position for pixel write is:
glRasterPos2f(targetRect[kPsychLeft], targetRect[kPsychBottom]);
// Zoom factor if rectangle sizes don't match:
glPixelZoom(PsychGetWidthFromRect(targetRect) / PsychGetWidthFromRect(sourceRect), PsychGetHeightFromRect(targetRect) / PsychGetHeightFromRect(sourceRect));
// Perform pixel copy operation:
glCopyPixels(sourceRect[kPsychLeft], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychBottom], (int) PsychGetWidthFromRect(sourceRect), (int) PsychGetHeightFromRect(sourceRect), GL_COLOR);
// That's it.
glPixelZoom(1,1);
// Flush drawing commands and wait for render-completion in single-buffer mode:
PsychFlushGL(targetWin);
}
else {
// Sourcewin != Targetwin and/or imaging pipe (FBO storage) not used. We blit the
// backing texture into itself, aka into its representation inside the system
// backbuffer. The blit routine will setup proper bindings:
// Disable alpha-blending:
glDisable(GL_BLEND);
// We use filterMode == 1 aka Bilinear filtering, so we get nice texture copies
// if size of sourceRect and targetRect don't match and some scaling is needed.
// We maybe could map the copyMode argument into some filterMode settings, but
// i don't know the spec of copyMode, so ...
PsychBlitTextureToDisplay(sourceWin, targetWin, sourceRect, targetRect, 0, 1, 1);
// That's it.
// Flush drawing commands and wait for render-completion in single-buffer mode:
PsychFlushGL(targetWin);
}
}
// Onscreen to texture copy?
if (PsychIsOnscreenWindow(sourceWin) && PsychIsOffscreenWindow(targetWin)) {
// With the current implemenation we can't zoom if sizes of sourceRect and targetRect don't
// match: Only one-to-one copy possible...
if(PsychGetWidthFromRect(sourceRect) != PsychGetWidthFromRect(targetRect) ||
PsychGetHeightFromRect(sourceRect) != PsychGetHeightFromRect(targetRect)) {
// Non-matching sizes. We can't perform requested scaled copy :(
PsychErrorExitMsg(PsychError_user, "Size mismatch of sourceRect and targetRect. Matching size is required for Onscreen to Offscreen copies. Sorry.");
}
// Update selected textures content:
// Looks weird but we need the framebuffer of sourceWin:
PsychSetDrawingTarget(sourceWin);
// Disable alpha-blending:
glDisable(GL_BLEND);
// Disable any shading during copy-op:
PsychSetShader(sourceWin, 0);
// Texture objects are shared across contexts, so doesn't matter if targetWin's texture actually
// belongs to the bound context of sourceWin:
glBindTexture(PsychGetTextureTarget(targetWin), targetWin->textureNumber);
// Copy into texture:
glCopyTexSubImage2D(PsychGetTextureTarget(targetWin), 0, targetRect[kPsychLeft], PsychGetHeightFromRect(targetWin->rect) - targetRect[kPsychBottom], sourceRect[kPsychLeft], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychBottom],
(int) PsychGetWidthFromRect(sourceRect), (int) PsychGetHeightFromRect(sourceRect));
// Unbind texture object:
glBindTexture(PsychGetTextureTarget(targetWin), 0);
// That's it.
glPixelZoom(1,1);
}
// Onscreen to Onscreen copy?
if (PsychIsOnscreenWindow(sourceWin) && PsychIsOnscreenWindow(targetWin)) {
// Currently only works for copies of subregion -> subregion inside same onscreen window,
// not across different onscreen windows! TODO: Only possible with EXT_framebuffer_blit
if (sourceWin != targetWin) PsychErrorExitMsg(PsychError_user, "Sorry, the current implementation only supports copies within the same onscreen window, not accross onscreen windows.");
// Set target windows framebuffer as drawing target:
PsychSetDrawingTarget(targetWin);
// Disable alpha-blending:
glDisable(GL_BLEND);
// Disable any shading during copy-op:
PsychSetShader(targetWin, 0);
// Start position for pixel write is:
glRasterPos2f(targetRect[kPsychLeft], targetRect[kPsychBottom]);
// Zoom factor if rectangle sizes don't match:
glPixelZoom(PsychGetWidthFromRect(targetRect) / PsychGetWidthFromRect(sourceRect), PsychGetHeightFromRect(targetRect) / PsychGetHeightFromRect(sourceRect));
// Perform pixel copy operation:
glCopyPixels(sourceRect[kPsychLeft], PsychGetHeightFromRect(sourceWin->rect) - sourceRect[kPsychBottom], (int) PsychGetWidthFromRect(sourceRect), (int) PsychGetHeightFromRect(sourceRect), GL_COLOR);
// That's it.
glPixelZoom(1,1);
// Flush drawing commands and wait for render-completion in single-buffer mode:
PsychFlushGL(targetWin);
}
// Just to make sure we catch invalid values:
if (!(PsychPrefStateGet_ConserveVRAM() & kPsychAvoidCPUGPUSync)) PsychTestForGLErrors();
// Done.
return(PsychError_none);
}
/* PsychPrepareRenderBatch()
*
* Perform setup for a batch of render requests for a specific primitive. Some 2D Screen
* drawing commands allow to specify a list of primitives to draw instead of only a single
* one. E.g. 'DrawDots' allows to draw thousands of dots with one single DrawDots command.
* This helper routine is called by such batch-capable commands. It checks which input arguments
* are provided and if its a single one or multiple ones. It sets up the rendering pipe accordingly,
* performing required conversion steps. The actual drawing routine just needs to perform primitive
* specific code.
*/
void PsychPrepareRenderBatch(PsychWindowRecordType *windowRecord, int coords_pos, int* coords_count, double** xy, int colors_pos, int* colors_count, int* colorcomponent_count, double** colors, unsigned char** bytecolors, int sizes_pos, int* sizes_count, double** size)
{
PsychColorType color;
int m,n,p,mc,nc,pc;
int i, nrpoints, nrsize;
psych_bool isArgThere, isdoublecolors, isuint8colors, usecolorvector, needxy;
double *tmpcolors, *pcolors, *tcolors;
double convfactor, whiteValue;
needxy = (coords_pos > 0) ? TRUE: FALSE;
coords_pos = abs(coords_pos);
colors_pos = abs(colors_pos);
sizes_pos = abs(sizes_pos);
// Get mandatory or optional xy coordinates argument
isArgThere = PsychIsArgPresent(PsychArgIn, coords_pos);
if(!isArgThere && needxy) {
PsychErrorExitMsg(PsychError_user, "No position argument supplied");
}
if (isArgThere) {
PsychAllocInDoubleMatArg(coords_pos, TRUE, &m, &n, &p, xy);
if(p!=1 || (m!=*coords_count && (m*n)!=*coords_count)) {
printf("PTB-ERROR: Coordinates must be a %i tuple or a %i rows vector.\n", *coords_count, *coords_count);
PsychErrorExitMsg(PsychError_user, "Invalid format for coordinate specification.");
}
if (m!=1) {
nrpoints=n;
*coords_count = n;
}
else {
// Special case: 1 row vector provided for single argument.
nrpoints=1;
*coords_count = 1;
}
}
else {
nrpoints = 0;
*coords_count = 0;
}
if (size) {
// Get optional size argument
isArgThere = PsychIsArgPresent(PsychArgIn, sizes_pos);
if(!isArgThere){
// No size provided: Use a default size of 1.0:
*size = (double *) PsychMallocTemp(sizeof(double));
*size[0] = 1;
nrsize=1;
} else {
PsychAllocInDoubleMatArg(sizes_pos, TRUE, &m, &n, &p, size);
if(p!=1) PsychErrorExitMsg(PsychError_user, "Size must be a scalar or a vector with one column or row");
nrsize=m*n;
if (nrsize!=nrpoints && nrsize!=1 && *sizes_count!=1) PsychErrorExitMsg(PsychError_user, "Size vector must contain one size value per item.");
}
*sizes_count = nrsize;
}
// Check if color argument is provided:
isArgThere = PsychIsArgPresent(PsychArgIn, colors_pos);
if(!isArgThere) {
// No color argument provided - Use defaults:
whiteValue=PsychGetWhiteValueFromWindow(windowRecord);
PsychLoadColorStruct(&color, kPsychIndexColor, whiteValue ); //index mode will coerce to any other.
usecolorvector=false;
}
else {
// Some color argument provided. Check first, if it's a valid color vector:
isdoublecolors = PsychAllocInDoubleMatArg(colors_pos, kPsychArgAnything, &mc, &nc, &pc, colors);
isuint8colors = PsychAllocInUnsignedByteMatArg(colors_pos, kPsychArgAnything, &mc, &nc, &pc, bytecolors);
// Do we have a color vector, aka one element per vertex?
if((isdoublecolors || isuint8colors) && pc==1 && mc!=1 && nc==nrpoints && nrpoints>1) {
// Looks like we might have a color vector... ... Double-check it:
if (mc!=3 && mc!=4) PsychErrorExitMsg(PsychError_user, "Color vector must be a 3 or 4 row vector");
// Yes. colors is a valid pointer to it.
usecolorvector=true;
if (isdoublecolors) {
if (fabs(windowRecord->colorRange)!=1) {
// We have to loop through the vector and divide all values by windowRecord->colorRange, so the input values
// 0-colorRange get mapped to the range 0.0-1.0, as OpenGL expects values in range 0-1 when
// a color vector is passed in Double- or Float format.
// This is inefficient, as it burns some cpu-cycles, but necessary to keep color
// specifications consistent in the PTB - API.
convfactor = 1.0 / fabs(windowRecord->colorRange);
tmpcolors=PsychMallocTemp(sizeof(double) * nc * mc);
pcolors = *colors;
tcolors = tmpcolors;
for (i=0; i<(nc*mc); i++) {
*(tcolors++)=(*pcolors++) * convfactor;
}
}
else {
// colorRange is == 1 --> No remapping needed as colors are already in proper range!
// Just setup pointer to our unaltered input color vector:
tmpcolors=*colors;
}
*colors = tmpcolors;
}
else {
// Color vector in uint8 format. Nothing to do.
}
}
else {
// No color vector provided: Check for a single valid color triplet or quadruple:
usecolorvector=false;
isArgThere=PsychCopyInColorArg(colors_pos, TRUE, &color);
}
}
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Setup default drawshader:
PsychSetShader(windowRecord, -1);
// Setup alpha blending properly:
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
// Setup common color for all objects if no color vector has been provided:
if (!usecolorvector) {
PsychCoerceColorMode(&color);
PsychSetGLColor(&color, windowRecord);
*colors_count = 1;
}
else {
*colors_count = nc;
}
*colorcomponent_count = mc;
return;
}
PsychError SCREENPutImage(void)
{
PsychRectType windowRect, positionRect;
int ix, iy;
size_t matrixRedIndex, matrixGreenIndex, matrixBlueIndex, matrixAlphaIndex, matrixGrayIndex;
int inputM, inputN, inputP, positionRectWidth, positionRectHeight;
size_t pixelIndex = 0;
PsychWindowRecordType *windowRecord;
unsigned char *inputMatrixByte;
double *inputMatrixDouble;
GLfloat *pixelData;
GLfloat matrixGrayValue, matrixRedValue, matrixGreenValue, matrixBlueValue, matrixAlphaValue;
PsychArgFormatType inputMatrixType;
GLfloat xZoom = 1, yZoom = -1;
// 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(4)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
// Get the image matrix.
inputMatrixType = PsychGetArgType(2);
switch (inputMatrixType) {
case PsychArgType_none:
case PsychArgType_default:
PsychErrorExitMsg(PsychError_user, "imageArray argument required");
break;
case PsychArgType_uint8:
PsychAllocInUnsignedByteMatArg(2, TRUE, &inputM, &inputN, &inputP, &inputMatrixByte);
break;
case PsychArgType_double:
PsychAllocInDoubleMatArg(2, TRUE, &inputM, &inputN, &inputP, &inputMatrixDouble);
break;
default:
PsychErrorExitMsg(PsychError_user, "imageArray must be uint8 or double type");
break;
}
if (inputP != 1 && inputP != 3 && inputP != 4) {
PsychErrorExitMsg(PsychError_user, "Third dimension of image matrix must be 1, 3, or 4");
}
// Get the window and get the rect and stuff.
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// A no-go on OES:
if (PsychIsGLES(windowRecord)) {
PsychErrorExitMsg(PsychError_unimplemented, "Sorry, Screen('PutImage') is not supported on OpenGL-ES embedded graphics hardware. Use 'MakeTexture' and 'DrawTexture' instead.");
}
PsychGetRectFromWindowRecord(windowRect, windowRecord);
if (PsychCopyInRectArg(3, FALSE, positionRect)) {
if (IsPsychRectEmpty(positionRect)) {
return PsychError_none;
}
positionRectWidth = (int) PsychGetWidthFromRect(positionRect);
positionRectHeight = (int) PsychGetHeightFromRect(positionRect);
if (positionRectWidth != inputN || positionRectHeight != inputM) {
// Calculate the zoom factor.
xZoom = (GLfloat) positionRectWidth / (GLfloat) inputN;
yZoom = -((GLfloat) positionRectHeight / (GLfloat) inputM);
}
}
else {
positionRect[kPsychLeft] = 0;
positionRect[kPsychTop] = 0;
positionRect[kPsychRight] = inputN;
positionRect[kPsychBottom] = inputM;
PsychCenterRect(positionRect, windowRect, positionRect);
}
// Allocate memory to hold the pixel data that we'll later pass to OpenGL.
pixelData = (GLfloat*) PsychMallocTemp(sizeof(GLfloat) * (size_t) inputN * (size_t) inputM * 4);
// Loop through all rows and columns of the pixel data passed from Matlab, extract it,
// and stick it into 'pixelData'.
for (iy = 0; iy < inputM; iy++) {
for (ix = 0; ix < inputN; ix++) {
if (inputP == 1) { // Grayscale
// Extract the grayscale value.
matrixGrayIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 1, (size_t) iy, (size_t) ix, 0);
if (inputMatrixType == PsychArgType_uint8) {
// If the color range is > 255, then force it to 255 for 8-bit values.
matrixGrayValue = (GLfloat)inputMatrixByte[matrixGrayIndex];
if (windowRecord->colorRange > 255) {
matrixGrayValue /= (GLfloat)255;
}
else {
matrixGrayValue /= (GLfloat)windowRecord->colorRange;
}
}
else {
matrixGrayValue = (GLfloat)(inputMatrixDouble[matrixGrayIndex] / windowRecord->colorRange);
}
// RGB will all be the same for grayscale. We'll go ahead and fix alpha to the max value.
pixelData[pixelIndex++] = matrixGrayValue; // R
pixelData[pixelIndex++] = matrixGrayValue; // G
pixelData[pixelIndex++] = matrixGrayValue; // B
pixelData[pixelIndex++] = (GLfloat) 1.0; // A
}
else if (inputP == 3) { // RGB
matrixRedIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 3, (size_t) iy, (size_t) ix, 0);
matrixGreenIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 3, (size_t) iy, (size_t) ix, 1);
matrixBlueIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 3, (size_t) iy, (size_t) ix, 2);
if (inputMatrixType == PsychArgType_uint8) {
// If the color range is > 255, then force it to 255 for 8-bit values.
matrixRedValue = (GLfloat)inputMatrixByte[matrixRedIndex];
matrixGreenValue = (GLfloat)inputMatrixByte[matrixGreenIndex];
matrixBlueValue = (GLfloat)inputMatrixByte[matrixBlueIndex];
if (windowRecord->colorRange > 255) {
matrixRedValue /= (GLfloat)255;
matrixGreenValue /= (GLfloat)255;
matrixBlueValue /= (GLfloat)255;
}
else {
matrixRedValue /= (GLfloat)windowRecord->colorRange;
matrixGreenValue /= (GLfloat)windowRecord->colorRange;
matrixBlueValue /= (GLfloat)windowRecord->colorRange;
}
}
else {
matrixRedValue = (GLfloat)(inputMatrixDouble[matrixRedIndex] / windowRecord->colorRange);
matrixGreenValue = (GLfloat)(inputMatrixDouble[matrixGreenIndex] / windowRecord->colorRange);
matrixBlueValue = (GLfloat)(inputMatrixDouble[matrixBlueIndex] / windowRecord->colorRange);
}
pixelData[pixelIndex++] = matrixRedValue;
pixelData[pixelIndex++] = matrixGreenValue;
pixelData[pixelIndex++] = matrixBlueValue;
pixelData[pixelIndex++] = (GLfloat)1.0;
}
else if (inputP == 4) { // RGBA
matrixRedIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 4, (size_t) iy, (size_t) ix, 0);
matrixGreenIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 4, (size_t) iy, (size_t) ix, 1);
matrixBlueIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 4, (size_t) iy, (size_t) ix, 2);
matrixAlphaIndex = PSYCHINDEXELEMENTFROM3DARRAY((size_t) inputM, (size_t) inputN, 4, (size_t) iy, (size_t) ix, 3);
if (inputMatrixType == PsychArgType_uint8) {
// If the color range is > 255, then force it to 255 for 8-bit values.
matrixRedValue = (GLfloat)inputMatrixByte[matrixRedIndex];
matrixGreenValue = (GLfloat)inputMatrixByte[matrixGreenIndex];
matrixBlueValue = (GLfloat)inputMatrixByte[matrixBlueIndex];
matrixAlphaValue = (GLfloat)inputMatrixByte[matrixAlphaIndex];
if (windowRecord->colorRange > 255) {
matrixRedValue /= (GLfloat)255;
matrixGreenValue /= (GLfloat)255;
matrixBlueValue /= (GLfloat)255;
matrixAlphaValue /= (GLfloat)255;
}
else {
matrixRedValue /= (GLfloat)windowRecord->colorRange;
matrixGreenValue /= (GLfloat)windowRecord->colorRange;
matrixBlueValue /= (GLfloat)windowRecord->colorRange;
matrixAlphaValue /= (GLfloat)windowRecord->colorRange;
}
}
else {
matrixRedValue = (GLfloat)(inputMatrixDouble[matrixRedIndex] / windowRecord->colorRange);
matrixGreenValue = (GLfloat)(inputMatrixDouble[matrixGreenIndex] / (GLfloat)windowRecord->colorRange);
matrixBlueValue = (GLfloat)(inputMatrixDouble[matrixBlueIndex] / (GLfloat)windowRecord->colorRange);
matrixAlphaValue = (GLfloat)(inputMatrixDouble[matrixAlphaIndex] / (GLfloat)windowRecord->colorRange);
}
pixelData[pixelIndex++] = matrixRedValue;
pixelData[pixelIndex++] = matrixGreenValue;
pixelData[pixelIndex++] = matrixBlueValue;
pixelData[pixelIndex++] = matrixAlphaValue;
}
} // for (iy = 0; iy < inputM; iy++)
} // for (ix = 0; ix < inputN; ix++)
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Disable draw shader:
PsychSetShader(windowRecord, 0);
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
// Set the raster position so that we can draw starting at this location.
glRasterPos2f((GLfloat)(positionRect[kPsychLeft]), (GLfloat)(positionRect[kPsychTop]));
// Tell glDrawPixels to unpack the pixel array along GLfloat boundaries.
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint)sizeof(GLfloat));
// Dump the pixels onto the screen.
glPixelZoom(xZoom, yZoom);
glDrawPixels(inputN, inputM, GL_RGBA, GL_FLOAT, pixelData);
glPixelZoom(1,1);
PsychFlushGL(windowRecord); // This does nothing if we are multi buffered, otherwise it glFlushes
PsychTestForGLErrors();
return PsychError_none;
}
PsychError SCREENPreloadTextures(void)
{
PsychWindowRecordType *windowRecord, *texwin;
psych_bool isArgThere;
int *texhandles;
PsychWindowRecordType **windowRecordArray;
int i, n, numWindows, myhandle;
double *success;
psych_bool* residency;
GLuint* texids;
GLboolean* texresident;
psych_bool failed = false;
GLclampf maxprio = 1.0f;
GLenum target;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The minimum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Get optional texids vector:
isArgThere = PsychIsArgPresent(PsychArgIn, 2);
PsychAllocInIntegerListArg(2, FALSE, &n, &texhandles);
if (n < 1) isArgThere=FALSE;
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Disable shader:
PsychSetShader(windowRecord, 0);
glDisable(GL_TEXTURE_2D);
// Fetch global texturing mode:
target=PsychGetTextureTarget(windowRecord);
glEnable(target);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(0, 0, 0, 0);
// Setup identity modelview matrix:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
PsychCreateVolatileWindowRecordPointerList(&numWindows, &windowRecordArray);
// Process vector of all texids for all requested textures:
if (!isArgThere) {
// No handles provided: In this case, we preload all textures:
n=0;
for(i=0; i<numWindows; i++) {
if (windowRecordArray[i]->windowType==kPsychTexture) {
n++;
// Prioritize this texture:
glPrioritizeTextures(1, (GLuint*) &(windowRecordArray[i]->textureNumber), &maxprio);
// Bind this texture:
glBindTexture(target, windowRecordArray[i]->textureNumber);
// Render a single textured point, thereby enforcing a texture upload:
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2i(10,10);
glTexCoord2f(0,1); glVertex2i(10,11);
glTexCoord2f(1,1); glVertex2i(11,11);
glTexCoord2f(1,0); glVertex2i(11,10);
glEnd();
}
}
texids = (GLuint*) PsychMallocTemp(sizeof(GLuint) * n);
texresident = (GLboolean*) PsychMallocTemp(sizeof(GLboolean) * n);
n=0;
for(i=0; i<numWindows; i++) {
if (windowRecordArray[i]->windowType==kPsychTexture) {
texids[n] = (GLuint) windowRecordArray[i]->textureNumber;
n++;
}
}
}
else {
// Vector with texture handles provided: Just preload them.
texids = (GLuint*) PsychMallocTemp(sizeof(GLuint) * n);
texresident = (GLboolean*) PsychMallocTemp(sizeof(GLboolean) * n);
myhandle=0;
for (i=0; i<n; i++) {
myhandle = texhandles[i];
texwin = NULL;
if (IsWindowIndex(myhandle)) FindWindowRecord(myhandle, &texwin);
if (texwin && texwin->windowType==kPsychTexture) {
// Prioritize this texture:
glPrioritizeTextures(1, (GLuint*) &(texwin->textureNumber), &maxprio);
// Bind this texture:
glBindTexture(target, texwin->textureNumber);
// Render a single textured point, thereby enforcing a texture upload:
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2i(10,10);
glTexCoord2f(0,1); glVertex2i(10,11);
glTexCoord2f(1,1); glVertex2i(11,11);
glTexCoord2f(1,0); glVertex2i(11,10);
glEnd();
texids[i] = (GLuint) texwin->textureNumber;
}
else {
// This handle is invalid or at least no texture handle:
printf("PTB-ERROR! Screen('PreloadTextures'): Entry %i of texture handle vector (handle %i) is not a texture handle!\n",
i, myhandle);
failed = true;
}
}
}
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// Disable texture engine:
glDisable(GL_TEXTURE_2D);
glDisable(target);
// Wait for prefetch completion:
glFinish();
// We don't need these anymore:
PsychDestroyVolatileWindowRecordPointerList(windowRecordArray);
if (failed) {
PsychErrorExitMsg(PsychError_user, "At least one texture handle in texids-vector was invalid! Aborted.");
}
// Query residency state of all preloaded textures:
success = NULL;
PsychAllocOutDoubleArg(1, FALSE, &success);
*success = (double) glAreTexturesResident(n, texids, texresident);
// Sync pipe again, just to be safe...
glFinish();
// Count them and copy them into output vector:
PsychAllocOutBooleanMatArg(2, FALSE, n, 1, 1, &residency);
for (i=0; i<n; i++) {
residency[i] = (psych_bool) ((*success) ? TRUE : texresident[i]);
}
PsychTestForGLErrors();
// Done. Our PsychMallocTemp'ed arrays will be auto-released...
return(PsychError_none);
}
void PsychRenderArc(unsigned int mode)
{
PsychColorType color;
PsychRectType rect;
double *startAngle, *arcAngle, *penWidth, *penHeight;
PsychWindowRecordType *windowRecord;
int whiteValue;
double dotSize;
psych_bool isArgThere;
GLUquadric *diskQuadric = NULL;
double cx, cy, w, h;
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
//Get the color argument or use the default, then coerce to the form determened by the window depth.
isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color);
if(!isArgThere){
whiteValue=PsychGetWhiteValueFromWindow(windowRecord);
PsychLoadColorStruct(&color, kPsychIndexColor, whiteValue ); //index mode will coerce to any other.
}
PsychCoerceColorMode( &color);
// Get the rect to which the object should be inscribed: Default is "full screen"
PsychMakeRect(rect, 0, 0, PsychGetWidthFromRect(windowRecord->rect), PsychGetHeightFromRect(windowRecord->rect));
PsychCopyInRectArg(3, FALSE, rect);
if (IsPsychRectEmpty(rect)) return;
w=PsychGetWidthFromRect(rect);
h=PsychGetHeightFromRect(rect);
PsychGetCenterFromRectAbsolute(rect, &cx, &cy);
if (w==0 || h==0) PsychErrorExitMsg(PsychError_user, "Invalid rect (width or height equals zero) provided!");
// Get start angle:
PsychAllocInDoubleArg(4, TRUE, &startAngle);
PsychAllocInDoubleArg(5, TRUE, &arcAngle);
if (mode==2) {
// Get pen width and height:
penWidth=NULL;
penHeight=NULL;
PsychAllocInDoubleArg(6, FALSE, &penWidth);
PsychAllocInDoubleArg(7, FALSE, &penHeight);
// Check if penWidth and penHeight spec'd. If so, they
// need to be equal:
if (penWidth && penHeight && (*penWidth!=*penHeight)) {
PsychErrorExitMsg(PsychError_user, "penWidth and penHeight must be equal on OS-X if both are specified!");
}
dotSize=1;
if (penWidth) dotSize = *penWidth;
if (penHeight) dotSize = *penHeight;
}
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Set default drawshader:
PsychSetShader(windowRecord, -1);
PsychUpdateAlphaBlendingFactorLazily(windowRecord);
PsychSetGLColor(&color, windowRecord);
// Backup our modelview matrix:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
// Position disk at center of rect:
glTranslated(cx, cy, 0);
// Scale in order to fit to rect in case w!=h:
glScaled(1.0, -h/w, 1.0);
// Draw filled partial disk:
diskQuadric=gluNewQuadric();
switch (mode) {
case 1: // One pixel thin arc: InnerRadius = OuterRadius - 1
gluPartialDisk(diskQuadric, (w/2) - 1.0, w/2, w, 2, *startAngle, *arcAngle);
break;
case 2: // dotSize thick arc: InnerRadius = OuterRadius - dotsize
gluPartialDisk(diskQuadric, (dotSize < (w/2)) ? (w/2) - dotSize : 0, w/2, w, 2, *startAngle, *arcAngle);
break;
case 3: // Filled arc:
gluPartialDisk(diskQuadric, 0, w/2, w, 1, *startAngle, *arcAngle);
break;
}
gluDeleteQuadric(diskQuadric);
// Restore old matrix:
glPopMatrix();
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
return;
}
