PsychError SCREENConstrainCursor(void)
{
static char useString[] = "Screen('ConstrainCursor', windowIndex, addConstraint [, rect]);";
// 1 2 3
static char synopsisString[] =
"Confine mouse cursor position to a specified area inside onscreen window 'windowIndex'.\n\n"
"If you set 'addConstraint' to 1, then a region constraint is added: 'rect' specifies the "
"rectangle (in window local coordinates) to which the mouse cursor should be confined. If "
"you omit 'rect', then the cursor is confined to the region of the window, ie. can't leave "
"the window. On MS-Windows you can only define one single rectangular region at all, regardless "
"of the number of onscreen windows. On Linux/X11 you can define up to a total of (currently) 1024 "
"confinement regions, e.g., for multiple separate windows, or multiple regions per window.\n"
"Additionally on Linux/X11 you can define empty 'rect's which define a horizontal or vertical line. "
"This adds a horizontal or vertical border line which can not be crossed by the mouse cursor, so you "
"could, e.g., build a complex maze, in which the cursor has to navigate. Please note that this "
"ability will not be present on a future version of Psychtoolbox for Linux with the Wayland display "
"server. While the Wayland implementation will provide the ability to define multiple regions, its "
"semantic will very likely be different, so if you use this special Linux/X11 only feature, your code "
"will not only be non-portable to MS-Windows, but also to future Linux versions which use Wayland instead "
"of the X11 graphics system!\n\n"
"If you set 'addConstraint' to 0 and specify a 'rect', then the specified 'rect' confinement region "
"for the given onscreen window is removed on Linux/X11. If you omit 'rect' on Linux, then all confinement "
"regions for the given onscreen window are removed. On MS-Windows the single globally available confinement "
"region is removed if it was set for the given onscreen window, regardless if you specify 'rect' or not, "
"as there is no ambiguity or choice with only one global rect anyway.\n\n"
"Closing an onscreen window with active cursor constraints will automatically remove all associated "
"cursor confinement regions. This is true for proper close via Screen('Close', windowIndex), Screen('Closeall') or sca, "
"or during a controlled error abort with proper error handling. On Linux, quitting/killing or crashing Octave/Matlab "
"will also release pointer confinement. On MS-Windows, pressing ALT+TAB will release the confinement.\n\n"
"The 'ConstrainCursor' function is not currently supported or supportable on Apple macOS due to macOS "
"operating system limitations. See 'help SetMouse' sections referring to the 'detachFromMouse' parameter for "
"a hint on how you may be able to work around this macOS limitation for some applications.\n\n";
static char seeAlsoString[] = "HideCursorHelper";
PsychWindowRecordType *windowRecord;
int addConstraint;
PsychRectType rect;
// All subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if (PsychIsGiveHelp()) { PsychGiveHelp(); return(PsychError_none); };
PsychErrorExit(PsychCapNumInputArgs(3)); // The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
// Get windowRecord:
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
if (!PsychIsOnscreenWindow(windowRecord))
PsychErrorExitMsg(PsychError_user, "Specified window is not an onscreen window, as required.");
// Get flag:
PsychCopyInIntegerArg(2, kPsychArgRequired, &addConstraint);
if (addConstraint) {
// If optional rect is omitted, use full window rect:
if (!PsychCopyInRectArg(3, kPsychArgOptional, rect))
PsychCopyRect(rect, windowRecord->rect);
if (!ValidatePsychRect(rect) || rect[kPsychLeft] < 0 || rect[kPsychTop] < 0 ||
rect[kPsychRight] > PsychGetWidthFromRect(windowRecord->rect) ||
rect[kPsychBottom] > PsychGetHeightFromRect(windowRecord->rect)) {
PsychErrorExitMsg(PsychError_user, "Invalid 'rect' provided. Invalid, or reaches outside the onscreen windows borders.");
}
// Add a new cursor constraint for this window, defined by rect:
if (!PsychOSConstrainPointer(windowRecord, TRUE, rect))
PsychErrorExitMsg(PsychError_user, "Failed to add cursor constraint for onscreen window.");
}
else {
if (PsychCopyInRectArg(3, kPsychArgOptional, rect)) {
// Remove cursor constraint for this window, as defined by rect:
if (!PsychOSConstrainPointer(windowRecord, FALSE, rect))
PsychErrorExitMsg(PsychError_user, "Failed to remove cursor constraint for onscreen window.");
} else {
// Remove all cursor constraints for this window:
if (!PsychOSConstrainPointer(windowRecord, FALSE, NULL))
PsychErrorExitMsg(PsychError_user, "Failed to remove all cursor constraints for onscreen window.");
}
}
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 SCREENDontCopyWindow(void)
{
PsychRectType sourceRect, targetRect, targetRectInverted;
PsychWindowRecordType *sourceWin, *targetWin;
GLdouble sourceVertex[2], targetVertex[2];
double t1,t2;
double sourceRectWidth, sourceRectHeight;
//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);
PsychCopyInRectArg(3, FALSE, sourceRect);
//get paramters for the target window:
PsychAllocInWindowRecordArg(2, TRUE, &targetWin);
PsychCopyRect(targetRect, targetWin->rect);
PsychCopyInRectArg(4, FALSE, targetRect);
//Check that the windows agree in depth. They don't have to agree in format because we convert to the correct format for the target when we
//create the texture.
if(sourceWin->depth != targetWin->depth)
PsychErrorExitMsg(PsychError_user, "Source and target windows must have the same bit depth");
//We need to unbind the source window texture from any previous target contexts if it is bound. There can be only one binding at a time.
//We could augment the Psychtoolbox to support shared contexts and multiple bindings.
PsychRetargetWindowToWindow(sourceWin, targetWin);
//each of these next three commands makes changes only when neccessary, they can be called generously
//when there is a possibility that any are necessary.
//PsychGetPrecisionTimerSeconds(&t1);
PsychAllocateTexture(sourceWin);
PsychBindTexture(sourceWin);
PsychUpdateTexture(sourceWin);
//PsychGetPrecisionTimerSeconds(&t2);
//mexPrintf("texture checking copywindow took %f seconds\n", t2-t1);
//PsychGetPrecisionTimerSeconds(&t1);
PsychGetPrecisionTimerSeconds(&t1);
PsychSetGLContext(targetWin);
glBindTexture(GL_TEXTURE_RECTANGLE_EXT, sourceWin->glTexture);
sourceRectWidth= PsychGetWidthFromRect(sourceWin->rect);
sourceRectHeight= PsychGetHeightFromRect(sourceWin->rect);
glTexSubImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, (GLsizei)sourceRectWidth, (GLsizei)sourceRectHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, sourceWin->textureMemory);
PsychInvertRectY(targetRectInverted, targetRect, targetWin->rect);
//PsychGetPrecisionTimerSeconds(&t1);
targetVertex[0]=0;
targetVertex[1]=0;
glBegin(GL_QUADS);
glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 0, sourceVertex));
glVertex2dv(targetVertex);
glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 1, sourceVertex));
glVertex2dv(targetVertex);
glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 2, sourceVertex));
glVertex2dv(targetVertex);
glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 3, sourceVertex));
glVertex2dv(targetVertex);
glEnd();
glFinish();
//PsychGetPrecisionTimerSeconds(&t2);
//mexPrintf("copywindow took %f seconds\n", t2-t1);
return(PsychError_none);
}
PsychError SCREENFillOval(void)
{
PsychRectType rect;
double numSlices, radius, xScale, yScale, xTranslate, yTranslate, rectY, rectX;
PsychWindowRecordType *windowRecord;
psych_bool isArgThere;
double *xy, *colors;
unsigned char *bytecolors;
int numRects, i, nc, mc, nrsize;
GLUquadricObj *diskQuadric;
double perfectUpToMaxDiameter;
static double perfectUpToMaxDiameterOld = 0;
//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(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
perfectUpToMaxDiameter = PsychGetWidthFromRect(windowRecord->clientrect);
if (PsychGetHeightFromRect(windowRecord->clientrect) < perfectUpToMaxDiameter) perfectUpToMaxDiameter = PsychGetHeightFromRect(windowRecord->clientrect);
PsychCopyInDoubleArg(4, kPsychArgOptional, &perfectUpToMaxDiameter);
if ((perfectUpToMaxDiameter != perfectUpToMaxDiameterOld) || (windowRecord->fillOvalDisplayList == 0)) {
perfectUpToMaxDiameterOld = perfectUpToMaxDiameter;
// Compute number of subdivisions (slices) to provide a perfect oval, i.e., one subdivision for each
// distance unit on the circumference of the oval.
numSlices=3.14159265358979323846 * perfectUpToMaxDiameter;
// Destroy old display list so it gets rebuilt with the new numSlices setting:
if (windowRecord->fillOvalDisplayList != 0) {
glDeleteLists(windowRecord->fillOvalDisplayList, 1);
windowRecord->fillOvalDisplayList = 0;
}
}
// Already cached display list for filled ovals for this windowRecord available?
if (windowRecord->fillOvalDisplayList == 0) {
// Nope. Create our prototypical filled oval:
// Generate a filled disk of that radius and subdivision and store it in a display list:
diskQuadric=gluNewQuadric();
windowRecord->fillOvalDisplayList = glGenLists(1);
glNewList(windowRecord->fillOvalDisplayList, GL_COMPILE);
gluDisk(diskQuadric, 0, 1, (int) numSlices, 1);
glEndList();
gluDeleteQuadric(diskQuadric);
// Display list ready for use in this and all future drawing calls for this windowRecord.
}
// Query, allocate and copy in all vectors...
numRects = 4;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
mc = nc = 0;
// The negative position -3 means: xy coords are expected at position 3, but they are optional.
// NULL means - don't want a size's vector.
PsychPrepareRenderBatch(windowRecord, -3, &numRects, &xy, 2, &nc, &mc, &colors, &bytecolors, 0, &nrsize, NULL);
// Only up to one rect provided?
if (numRects <= 1) {
// Get the oval and draw it:
PsychCopyRect(rect, windowRecord->clientrect);
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect);
if (isArgThere && IsPsychRectEmpty(rect)) return(PsychError_none);
numRects = 1;
}
else {
// Multiple ovals provided. Set up the first one:
PsychCopyRect(rect, &xy[0]);
}
// Draw all ovals (one or multiple):
for (i=0; i<numRects;) {
// Per oval color provided? If so then set it up. If only one common color
// was provided then PsychPrepareRenderBatch() has already set it up.
if (nc>1) {
// Yes. Set color for this specific item:
PsychSetArrayColor(windowRecord, i, mc, colors, bytecolors);
}
// Compute drawing parameters for ellipse:
if (!IsPsychRectEmpty(rect)) {
//The glu disk object location and size with a center point and a radius,
//whereas FillOval accepts a bounding rect. Converting from one set of parameters
//to the other we should careful what we do for rects size of even number of pixels in length.
PsychGetCenterFromRectAbsolute(rect, &xTranslate, &yTranslate);
rectY=PsychGetHeightFromRect(rect);
rectX=PsychGetWidthFromRect(rect);
if(rectX == rectY){
xScale=1;
yScale=1;
radius=rectX/2;
}else if(rectX > rectY){
xScale=1;
yScale=rectY/rectX;
radius=rectX/2;
}else if(rectY > rectX){
yScale=1;
xScale=rectX/rectY;
radius=rectY/2;
}
// Draw: Set up position, scale and size via matrix transform:
glPushMatrix();
glTranslated(xTranslate,yTranslate,0);
glScaled(xScale * radius, yScale * radius, 1);
// Draw cached disk object (stored in display list):
glCallList(windowRecord->fillOvalDisplayList);
// Done.
glPopMatrix();
}
// Done with this one. Set up the next one, if any...
i++;
if (i < numRects) PsychCopyRect(rect, &xy[i*4]);
// Next oval.
}
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
return(PsychError_none);
}
PsychError SCREENGetCapturedImage(void)
{
PsychWindowRecordType *windowRecord;
PsychWindowRecordType *textureRecord;
PsychRectType rect;
double summed_intensity;
int capturehandle = -1;
int waitForImage = TRUE;
int specialmode = 0;
double timeout, tnow;
double presentation_timestamp = 0;
int rc=-1;
double targetmemptr = 0;
double* tsummed = NULL;
psych_uint8 *targetmatrixptr = NULL;
static rawcapimgdata rawCaptureBuffer = {0, 0, 0, NULL};
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(6)); // Max. 6 input args.
PsychErrorExit(PsychRequireNumInputArgs(2)); // Min. 2 input args required.
PsychErrorExit(PsychCapNumOutputArgs(4)); // Max. 4 output args.
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Only onscreen windows allowed:
if(!PsychIsOnscreenWindow(windowRecord) && !PsychIsOffscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "GetCapturedImage called on something else than an onscreen window or offscreen window.");
}
// Get the handle:
PsychCopyInIntegerArg(2, TRUE, &capturehandle);
if (capturehandle==-1) {
PsychErrorExitMsg(PsychError_user, "GetCapturedImage called without valid handle to a capture object.");
}
// Get the 'waitForImage' flag: If waitForImage == true == 1, we'll do a blocking wait for
// arrival of a new image. Otherwise we will return with a 0-Handle if there
// isn't any new image available.
PsychCopyInIntegerArg(3, FALSE, &waitForImage);
// Special case waitForImage == 4? This would ask to call into the capture driver, but
// not wait for any image to arrive and not return any information. This is only useful
// on OS/X and Windows when using the capture engine for video recording to harddisk. In
// that case we are not interested at all in the captured live video, we just want it to
// get written to harddisk in the background. To keep the video encoder going, we need to
// call its SGIdle() routine and waitForImage==4 does just that, call SGIdle().
if (waitForImage == 4) {
// Perform the null-call to the capture engine, ie a SGIdle() on OS/X and Windows:
PsychGetTextureFromCapture(windowRecord, capturehandle, 4, 0.0, NULL, NULL, NULL, NULL);
// Done. Nothing to return...
return(PsychError_none);
}
// Get the optional textureRecord for the optional texture handle. If the calling script
// provides the texture handle of an existing Psychtoolbox texture that has a matching
// format, then that texture is recycled by overwriting its previous content with the
// image data from the new captured image. This can save some overhead for texture destruction
// and recreation. While this is probably not noticeable on mid- to high-end gfx cards with
// rectangle texture support, it can provide a significant speedup on low-end gfx cards with
// only power-of-two texture support.
textureRecord = NULL;
if ((PsychGetNumInputArgs()>=4) && PsychIsWindowIndexArg(4)) PsychAllocInWindowRecordArg(4, FALSE, &textureRecord);
// Get the optional specialmode flag:
PsychCopyInIntegerArg(5, FALSE, &specialmode);
// Set a 10 second maximum timeout for waiting for new frames:
PsychGetAdjustedPrecisionTimerSeconds(&timeout);
timeout+=10;
while (rc==-1) {
// We pass a checkForImage value of 2 if waitForImage>0. This way we can signal if we are in polling or blocking mode.
// With the libdc1394 engine this allows to do a real blocking wait in the driver -- much more efficient than the spin-waiting approach!
rc = PsychGetTextureFromCapture(windowRecord, capturehandle, ((waitForImage>0 && waitForImage<3) ? 2 : 1), 0.0, NULL, &presentation_timestamp, NULL, &rawCaptureBuffer);
PsychGetAdjustedPrecisionTimerSeconds(&tnow);
if (rc==-2 || (tnow > timeout)) {
// No image available and there won't be any in the future, because capture has been stopped or there is a timeout:
if (tnow > timeout) printf("PTB-WARNING: In Screen('GetCapturedImage') timed out waiting for a new frame. No video data in over 10 seconds!\n");
// No new texture available: Return a negative handle:
PsychCopyOutDoubleArg(1, TRUE, -1);
// ...and an invalid timestamp:
PsychCopyOutDoubleArg(2, FALSE, -1);
PsychCopyOutDoubleArg(3, FALSE, 0);
PsychCopyOutDoubleArg(4, FALSE, 0);
// Ready!
return(PsychError_none);
}
else if (rc==-1 && (waitForImage == 0 || waitForImage == 3)) {
// We should just poll once and no new texture available: Return a null-handle:
PsychCopyOutDoubleArg(1, TRUE, 0);
// ...and the current timestamp:
PsychCopyOutDoubleArg(2, FALSE, presentation_timestamp);
PsychCopyOutDoubleArg(3, FALSE, 0);
PsychCopyOutDoubleArg(4, FALSE, 0);
// Ready!
return(PsychError_none);
}
else if (rc==-1 && waitForImage != 0) {
// No new texture available yet. Just sleep a bit and then retry...
PsychYieldIntervalSeconds(0.002);
}
}
// rc == 0 --> New image available: Go ahead...
if (waitForImage!=2 && waitForImage!=3) {
// Ok, we need a texture for the image. Did script provide an old one for recycling?
if (textureRecord) {
// Old texture provided for reuse? Some basic sanity check: Everything else is
// up to the lower level PsychGetTextureFromCapture() routine.
if(!PsychIsOffscreenWindow(textureRecord)) {
PsychErrorExitMsg(PsychError_user, "GetCapturedImage provided with something else than a texture as fourth call parameter.");
}
}
else {
// No old texture provided: Create a new texture record:
PsychCreateWindowRecord(&textureRecord);
// Set mode to 'Texture':
textureRecord->windowType=kPsychTexture;
// We need to assign the screen number of the onscreen-window.
textureRecord->screenNumber=windowRecord->screenNumber;
// It defaults to a 32 bit texture for captured images. On Linux, this will be overriden,
// if optimized formats exist for our purpose:
textureRecord->depth=32;
textureRecord->nrchannels = 4;
// Create default rectangle which describes the dimensions of the image. Will be overwritten
// later on.
PsychMakeRect(rect, 0, 0, 10, 10);
PsychCopyRect(textureRecord->rect, rect);
// Other setup stuff:
textureRecord->textureMemorySizeBytes= 0;
textureRecord->textureMemory=NULL;
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Set textureNumber to zero, which means "Not cached, do not recycle"
// Todo: Texture recycling like in PsychMovieSupport for higher efficiency!
textureRecord->textureNumber = 0;
}
// Power-of-two texture requested?
if (specialmode & 0x01) {
// Yes. Spec it:
textureRecord->texturetarget = GL_TEXTURE_2D;
}
}
else {
// Just want to return summed_intensity and timestamp, not real texture...
textureRecord = NULL;
}
// Default to no calculation of summed image intensity:
tsummed = NULL;
if ((PsychGetNumOutputArgs() > 3) && !(specialmode & 0x2)) {
// Return sum of pixel intensities for all channels of this image: Need to
// assign the output pointer for this to happen:
tsummed = &summed_intensity;
}
// Try to fetch an image from the capture object and return it as texture:
targetmatrixptr = NULL;
// Shall we return a Matlab matrix?
if ((PsychGetNumOutputArgs() > 3) && (specialmode & 0x2)) {
// We shall return a matrix with raw image data. Allocate a uint8 matrix
// of sufficient size:
PsychAllocOutUnsignedByteMatArg(4, TRUE, rawCaptureBuffer.depth, rawCaptureBuffer.w, rawCaptureBuffer.h, &targetmatrixptr);
tsummed = NULL;
}
// Shall we return data into preallocated memory buffer?
if (specialmode & 0x4) {
// Copy in memory address (which itself is encoded in a double value):
PsychCopyInDoubleArg(6, TRUE, &targetmemptr);
targetmatrixptr = (psych_uint8*) PsychDoubleToPtr(targetmemptr);
}
if (targetmatrixptr == NULL) {
// Standard fetch of a texture and its timestamp:
rc = PsychGetTextureFromCapture(windowRecord, capturehandle, 0, 0.0, textureRecord, &presentation_timestamp, tsummed, NULL);
}
else {
// Fetch of a memory raw image buffer + timestamp + possibly a texture:
rawCaptureBuffer.data = (void*) targetmatrixptr;
rc = PsychGetTextureFromCapture(windowRecord, capturehandle, 0, 0.0, textureRecord, &presentation_timestamp, tsummed, &rawCaptureBuffer);
}
if (tsummed) {
// Return sum of pixel intensities for all channels of this image:
PsychCopyOutDoubleArg(4, FALSE, summed_intensity);
}
// Real texture requested?
if (textureRecord) {
// Texture ready for consumption.
// Assign GLSL filter-/lookup-shaders if needed: usefloatformat is always == 0 as
// our current capture engine implementations only return 8 bpc fixed textures.
// The 'userRequest' flag is set if specialmode flag is set to 8.
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, 0, (specialmode & 8) ? 1 : 0);
// specialmode setting 16? Disable auto-mipmap generation:
if (specialmode & 16) textureRecord->specialflags |= kPsychDontAutoGenMipMaps;
// Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, TRUE, textureRecord->windowIndex);
}
else {
PsychCopyOutDoubleArg(1, TRUE, 0);
}
// Return presentation timestamp for this image:
PsychCopyOutDoubleArg(2, FALSE, presentation_timestamp);
// Return count of pending frames in buffers or of dropped frames:
PsychCopyOutDoubleArg(3, FALSE, (double) rc);
// Ready!
return(PsychError_none);
}
PsychError SCREENDrawTexture(void)
{
static char synopsisString[] =
"Draw the texture specified via 'texturePointer' into the target window specified via 'windowPointer'. "
"In the the OS X Psychtoolbox textures replace offscreen windows for fast drawing of images during animation."
"'sourceRect' specifies a rectangular subpart of the texture to be drawn (Defaults to full texture). "
"'destinationRect' defines the rectangular subpart of the window where the texture should be drawn. This defaults"
"to centered on the screen. "
"'rotationAngle' Specifies a rotation angle in degree for rotated drawing of the texture (Defaults to 0 deg. = upright). "
"'filterMode' How to compute the pixel color values when the texture is drawn magnified, minified or drawn shifted, e.g., "
"if sourceRect and destinationRect do not have the same size or if sourceRect specifies fractional pixel values. 0 = Nearest "
"neighbour filtering, 1 = Bilinear filtering - this is the default. 'globalAlpha' A global alpha transparency value to apply "
"to the whole texture for blending. Range is 0 = fully transparent to 1 = fully opaque, defaults to one. If both, an alpha-channel "
"and globalAlpha are provided, then the final alpha is the product of both values. 'modulateColor', if provided, overrides the "
"'globalAlpha' value. If 'modulateColor' is specified, the 'globalAlpha' value will be ignored. 'modulateColor' will be a global "
"color that gets applied to the texture as a whole, i.e., it modulates each color channel. E.g., modulateColor = [128 255 0] would "
"leave the green- and alpha-channel untouched, but it would multiply the blue channel with 0 - set it to zero blue intensity, and "
"it would multiply each texel in the red channel by 128/255 - reduce its intensity to 50%. The most interesting application of "
"'modulateColor' is drawing of arbitrary complex shapes of selectable color: Simply generate an all-white luminance texture of "
"arbitrary shape, possibly with alpha channel, then draw it with 'modulateColor' set to the wanted color and global alpha value.\n"
"'textureShader' (optional): If you provide a valid handle of a GLSL shader, this shader will be applied to the texture during "
"drawing. If the texture already has a shader assigned (via Screen('MakeTexture') or automatically by PTB for some reason), then "
"the shader provided here as 'textureShader' will silently override the shader assigned earlier. Application of shaders this way "
"is mostly useful for application of simple single-pass image processing operations to a texture, e.g., a simple blur or a "
"deinterlacing operation for a video texture. If you intend to use this texture multiple times or if you need more complex image "
"processing, e.g., multi-pass operations, better use the Screen('TransformTexture') command. It allows for complex operations to "
"be applied and is more flexible.\n"
"'specialFlags' optional argument: Allows to pass a couple of special flags to influence the drawing. The flags can be combined "
"by mor() ing them together. A value of kPsychUseTextureMatrixForRotation will use a different mode of operation for drawing of "
"rotated textures, where the drawn 'dstRect' texture rectangle is always upright, but texels are retrieved at rotated positions, "
"as if the 'srcRect' rectangle would be rotated. If you set a value of kPsychDontDoRotation then the rotation angle will not be "
"used to rotate the texture. Instead it will be passed to a bount texture shader (if any), which is free to interpret the "
"'rotationAngle' parameters is it wants - e.g., to implement custom texture rotation."
"\n\n"
"'auxParameters' optional argument: If this is set as a vector with at least 4 components, and a multiple of four components, "
"then these values are passed to a shader (if any is bound) as 'auxParameter0....n'. The current implementation supports at "
"most 32 values per draw call. This is mostly useful when drawing procedural textures if one needs to pass more additional "
"parameters to define the texture than can fit into other parameter fields. See 'help ProceduralShadingAPI' for more info. "
"\n\n"
"If you want to draw many textures to the same onscreen- or offscreen window, use the function Screen('DrawTextures'). "
"It accepts the same arguments as this function, but is optimized to draw many textures in one call.";
// If you change useString then also change the corresponding synopsis string in ScreenSynopsis.c
static char useString[] = "Screen('DrawTexture', windowPointer, texturePointer [,sourceRect] [,destinationRect] [,rotationAngle] [, filterMode] [, globalAlpha] [, modulateColor] [, textureShader] [, specialFlags] [, auxParameters]);";
// 1 2 3 4 5 6 7 8 9 10 11
PsychWindowRecordType *source, *target;
PsychRectType sourceRect, targetRect, tempRect;
double rotationAngle = 0; // Default rotation angle is zero deg. = upright.
int filterMode = 1; // Default filter mode is bilinear filtering.
double globalAlpha = 1.0; // Default global alpha is 1 == no effect.
PsychColorType color;
int textureShader, backupShader;
double* auxParameters;
int numAuxParams, numAuxComponents, m, n, p;
int specialFlags = 0;
//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(11));
PsychErrorExit(PsychRequireNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(0));
//Read in arguments
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &target);
PsychAllocInWindowRecordArg(2, kPsychArgRequired, &source);
if(source->windowType!=kPsychTexture) {
PsychErrorExitMsg(PsychError_user, "The first argument supplied was a window pointer, not a texture pointer");
}
PsychCopyRect(sourceRect,source->clientrect);
PsychCopyInRectArg(3, kPsychArgOptional, sourceRect);
if (IsPsychRectEmpty(sourceRect)) return(PsychError_none);
PsychCopyRect(tempRect, target->clientrect);
PsychCenterRectInRect(sourceRect, tempRect, targetRect);
PsychCopyInRectArg(4, kPsychArgOptional, targetRect);
if (IsPsychRectEmpty(targetRect)) return(PsychError_none);
PsychCopyInDoubleArg(5, kPsychArgOptional, &rotationAngle);
PsychCopyInIntegerArg(6, kPsychArgOptional, &filterMode);
if (filterMode<0 || filterMode>3) {
PsychErrorExitMsg(PsychError_user, "filterMode needs to be 0 for nearest neighbour filter, or 1 for bilinear filter, or 2 for mipmapped filter or 3 for mipmapped-linear filter.");
}
// Copy in optional 'globalAlpha': We don't put restrictions on its valid range
// anymore - That made sense for pure fixed function LDR rendering, but no longer
// for HDR rendering or procedural shading.
PsychCopyInDoubleArg(7, kPsychArgOptional, &globalAlpha);
PsychSetDrawingTarget(target);
PsychUpdateAlphaBlendingFactorLazily(target);
if(PsychCopyInColorArg(8, kPsychArgOptional, &color)) {
// set globalAlpha to DBL_MAX to signal that PsychBlitTexture() shouldn't
// use this parameter and not set any modulate color, cause we do it.
globalAlpha = DBL_MAX;
// Setup global vertex color as modulate color for texture drawing:
PsychCoerceColorMode(&color);
// This call stores unclamped color in target->currentColor, as needed
// if color is to be processed by some bound shader (procedural or filtershader)
// inside PsychBlitTextureToDisplay():
PsychConvertColorToDoubleVector(&color, target, (GLdouble*) &(target->currentColor));
// Submit the same color to fixed function pipe attribute as well, in case no
// shader is bound, or shader pulls from standard color attribute (we can't know yet):
glColor4dv(target->currentColor);
}
// Assign optional override texture shader, if any provided:
textureShader = -1;
PsychCopyInIntegerArg(9, kPsychArgOptional, &textureShader);
// Assign any other optional special flags:
PsychCopyInIntegerArg(10, kPsychArgOptional, &specialFlags);
// Set rotation mode flag for texture matrix rotation if secialFlags is set accordingly:
if (specialFlags & kPsychUseTextureMatrixForRotation) source->specialflags|=kPsychUseTextureMatrixForRotation;
// Set rotation mode flag for no fixed function pipeline rotation if secialFlags is set accordingly:
if (specialFlags & kPsychDontDoRotation) source->specialflags|=kPsychDontDoRotation;
// Optional auxParameters:
auxParameters = NULL;
m=n=p=0;
if (PsychAllocInDoubleMatArg(11, kPsychArgOptional, &m, &n, &p, &auxParameters)) {
if ((p!=1) || (m * n < 4) || (((m*n) % 4)!=0)) PsychErrorExitMsg(PsychError_user, "The 11th argument must be a vector of 'auxParameter' values with a multiple of 4 components.");
}
numAuxParams = m*n;
target->auxShaderParamsCount = numAuxParams;
// Pass auxParameters for current primitive in the auxShaderParams field.
if (numAuxParams > 0) {
target->auxShaderParams = auxParameters;
}
else {
target->auxShaderParams = NULL;
}
if (textureShader > -1) {
backupShader = source->textureFilterShader;
source->textureFilterShader = -1 * textureShader;
PsychBlitTextureToDisplay(source, target, sourceRect, targetRect, rotationAngle, filterMode, globalAlpha);
source->textureFilterShader = backupShader;
}
else {
PsychBlitTextureToDisplay(source, target, sourceRect, targetRect, rotationAngle, filterMode, globalAlpha);
}
// Reset rotation mode flag:
source->specialflags &= ~(kPsychUseTextureMatrixForRotation | kPsychDontDoRotation);
target->auxShaderParams = NULL;
target->auxShaderParamsCount = 0;
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(target);
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 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 SCREENMakeTexture(void)
{
int ix;
PsychWindowRecordType *textureRecord;
PsychWindowRecordType *windowRecord;
PsychRectType rect;
Boolean isImageMatrixBytes, isImageMatrixDoubles;
int numMatrixPlanes, xSize, ySize;
unsigned char *byteMatrix;
double *doubleMatrix;
GLuint *texturePointer;
GLubyte *texturePointer_b;
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(2));
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 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.
PsychMakeRect(rect, 0, 0, xSize, ySize);
//Create a texture record. Really just a window recored 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.
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=valloc(textureRecord->textureMemorySizeBytes);
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #3
StoreNowTime();
texturePointer=textureRecord->textureMemory;
// Original implementation: Takes 80 ms on a 800x800 texture...
/* if(isImageMatrixDoubles && numMatrixPlanes==1){
for(ix=0;ix<xSize;ix++){
for(iy=0;iy<ySize;iy++){
textureIndex=xSize*iy+ix;
matrixIndex=iy + ySize * ix;
textureRecord->textureMemory[textureIndex]= ((((((GLuint)255 << 8) |
(GLuint)(doubleMatrix[matrixIndex])) << 8 ) |
(GLuint)(doubleMatrix[matrixIndex]) ) << 8) |
(GLuint)(doubleMatrix[matrixIndex]);
}
}
}
*/
// Improved implementation: Takes 13 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==1){
texturePointer_b=(GLubyte*) texturePointer;
int iters=xSize*ySize;
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(doubleMatrix++);
}
textureRecord->depth=8;
}
// Original implementation: Takes 30 ms on a 800x800 texture...
/* if(isImageMatrixBytes && numMatrixPlanes==1){
for(ix=0;ix<xSize;ix++){
for(iy=0;iy<ySize;iy++){
textureIndex=xSize*iy+ix;
matrixIndex=iy + ySize * ix;
textureRecord->textureMemory[textureIndex]= ((((((GLuint)255 << 8) |
(GLuint)(byteMatrix[matrixIndex])) << 8 ) |
(GLuint)(byteMatrix[matrixIndex]) ) << 8) |
(GLuint)(byteMatrix[matrixIndex]);
}
}
}
*/
// 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;
int iters=xSize*ySize;
double *rp, *ap;
rp=(double*) ((unsigned long long) doubleMatrix);
ap=(double*) ((unsigned long long) doubleMatrix + (unsigned long long) 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;
int iters=xSize*ySize;
GLubyte *rp, *ap;
rp=(GLubyte*) ((unsigned long long) byteMatrix);
ap=(GLubyte*) ((unsigned long long) byteMatrix + (unsigned long long) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rp++);
*(texturePointer_b++)= *(ap++);
}
textureRecord->depth=16;
}
// Original version: Takes 160 ms on a 800x800 texture...
/* if(isImageMatrixDoubles && numMatrixPlanes==3){
for(ix=0;ix<xSize;ix++){
for(iy=0;iy<ySize;iy++){
textureIndex=xSize*iy+ix;
redIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 0);
greenIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 1);
blueIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 2);
red=(GLuint)doubleMatrix[redIndex];
green=(GLuint)doubleMatrix[greenIndex];
blue=(GLuint)doubleMatrix[blueIndex];
alpha=(GLuint)255;
textureRecord->textureMemory[textureIndex]= (((((alpha << 8) | red) << 8 ) | green ) << 8) | blue;
}
}
textureRecord->depth=24;
}
*/
// Improved version: Takes 43 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
int iters=xSize*ySize;
double *rp, *gp, *bp;
rp=(double*) ((unsigned long long) doubleMatrix);
gp=(double*) ((unsigned long long) doubleMatrix + (unsigned long long) iters*sizeof(double));
bp=(double*) ((unsigned long long) gp + (unsigned long long) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
textureRecord->depth=24;
}
/* // Original version: Takes 94 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==3){
for(ix=0;ix<xSize;ix++){
for(iy=0;iy<ySize;iy++){
textureIndex=xSize*iy+ix;
redIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 0);
greenIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 1);
blueIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 2);
red=(GLuint)byteMatrix[redIndex];
green=(GLuint)byteMatrix[greenIndex];
blue=(GLuint)byteMatrix[blueIndex];
alpha=(GLuint)255;
textureRecord->textureMemory[textureIndex]= (((((alpha << 8) | red) << 8 ) | green ) << 8) | blue;
}
}
}
*/
// Improved version: Takes 25 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==3){
texturePointer_b=(GLubyte*) texturePointer;
int iters=xSize*ySize;
GLubyte *rp, *gp, *bp;
rp=(GLubyte*) ((unsigned long long) byteMatrix);
gp=(GLubyte*) ((unsigned long long) byteMatrix + (unsigned long long) iters);
bp=(GLubyte*) ((unsigned long long) gp + (unsigned long long) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(rp++);
*(texturePointer_b++)= *(gp++);
*(texturePointer_b++)= *(bp++);
}
textureRecord->depth=24;
}
// Original version: 190 ms on a 800x800 texture...
/* if(isImageMatrixDoubles && numMatrixPlanes==4){
for(ix=0;ix<xSize;ix++){
for(iy=0;iy<ySize;iy++){
textureIndex=xSize*iy+ix;
redIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 0);
greenIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 1);
blueIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 2);
alphaIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 3);
red=(GLuint)doubleMatrix[redIndex];
green=(GLuint)doubleMatrix[greenIndex];
blue=(GLuint)doubleMatrix[blueIndex];
alpha=(GLuint)doubleMatrix[alphaIndex];
textureRecord->textureMemory[textureIndex]= (((((alpha << 8) | red) << 8 ) | green ) << 8) | blue;
}
}
}
*/
// Improved version: Takes 55 ms on a 800x800 texture...
if(isImageMatrixDoubles && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
int iters=xSize*ySize;
double *rp, *gp, *bp, *ap;
rp=(double*) ((unsigned long long) doubleMatrix);
gp=(double*) ((unsigned long long) doubleMatrix + (unsigned long long) iters*sizeof(double));
bp=(double*) ((unsigned long long) gp + (unsigned long long) iters*sizeof(double));
ap=(double*) ((unsigned long long) bp + (unsigned long long) iters*sizeof(double));
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= (GLubyte) *(ap++);
*(texturePointer_b++)= (GLubyte) *(rp++);
*(texturePointer_b++)= (GLubyte) *(gp++);
*(texturePointer_b++)= (GLubyte) *(bp++);
}
textureRecord->depth=32;
}
// Original version: Takes 125 ms on a 800x800 texture...
/* if(isImageMatrixBytes && numMatrixPlanes==4){
for(ix=0;ix<xSize;ix++){
for(iy=0;iy<ySize;iy++){
textureIndex=xSize*iy+ix;
redIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 0);
greenIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 1);
blueIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 2);
alphaIndex=PsychIndexElementFrom3DArray(ySize, xSize, 3, iy, ix, 3);
red=(GLuint)byteMatrix[redIndex];
green=(GLuint)byteMatrix[greenIndex];
blue=(GLuint)byteMatrix[blueIndex];
alpha=(GLuint)byteMatrix[alphaIndex];
textureRecord->textureMemory[textureIndex]= (((((alpha << 8) | red) << 8 ) | green ) << 8) | blue;
}
}
}
*/
// Improved version: Takes 33 ms on a 800x800 texture...
if(isImageMatrixBytes && numMatrixPlanes==4){
texturePointer_b=(GLubyte*) texturePointer;
int iters=xSize*ySize;
GLubyte *rp, *gp, *bp, *ap;
rp=(GLubyte*) ((unsigned long long) byteMatrix);
gp=(GLubyte*) ((unsigned long long) byteMatrix + (unsigned long long) iters);
bp=(GLubyte*) ((unsigned long long) gp + (unsigned long long) iters);
ap=(GLubyte*) ((unsigned long long) bp + (unsigned long long) iters);
for(ix=0;ix<iters;ix++){
*(texturePointer_b++)= *(ap++);
*(texturePointer_b++)= *(rp++);
*(texturePointer_b++)= *(gp++);
*(texturePointer_b++)= *(bp++);
}
textureRecord->depth=32;
}
// The memory buffer now contains our texture data in a format ready to submit to OpenGL.
// Assign proper OpenGL-Renderingcontext to texture:
// MK: Is this the proper way to do it???
textureRecord->targetSpecific.contextObject = windowRecord->targetSpecific.contextObject;
// Let's create and bind a new texture object and fill it with our new texture data.
PsychCreateTexture(textureRecord);
// Texture ready. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, FALSE, textureRecord->windowIndex);
if(PsychPrefStateGet_DebugMakeTexture()) //MARK #4
StoreNowTime();
return(PsychError_none);
}
PsychError SCREENFrameRect(void)
{
PsychColorType color;
PsychRectType rect;
PsychWindowRecordType *windowRecord;
int whiteValue;
psych_bool isArgThere;
double penSize, lf, fudge;
GLdouble dVals[4];
double *xy, *colors, *penSizes;
unsigned char *bytecolors;
int numRects, i, j, nc, mc, nrsize;
//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 tweakable correction factor for framerect:
lf = PsychPrefStateGet_FrameRectCorrection();
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Query, allocate and copy in all vectors...
numRects = 4;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
penSizes = NULL;
// The negative position -3 means: xy coords are expected at position 3, but they are optional.
// NULL means - don't want a size's vector.
PsychPrepareRenderBatch(windowRecord, -3, &numRects, &xy, 2, &nc, &mc, &colors, &bytecolors, 4, &nrsize, &penSizes);
// Default rect is fullscreen:
PsychCopyRect(rect, windowRecord->rect);
// Only up to one rect provided?
if (numRects <= 1) {
// Get the rect and draw it
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect);
if (isArgThere && IsPsychRectEmpty(rect)) return(PsychError_none);
numRects = 1;
}
// Pen size starts as "undefined", just to make sure it gets initially set:
penSize = -DBL_MAX;
// Framed rect drawing loop:
for (i=0; i<numRects; i++) {
// Multiple rects to draw or single iteration to draw provided rect?
if (numRects > 1) {
// Multi-Rect drawing: Assign next rect from array and setup corresponding
// color and penSize...
// Assign rect:
rect[kPsychLeft] = xy[i*4 + 0];
rect[kPsychTop] = xy[i*4 + 1];
rect[kPsychRight] = xy[i*4 + 2];
rect[kPsychBottom] = xy[i*4 + 3];
// Per rect color provided?
if (nc>1) {
// Yes. Set color for this specific rect:
PsychSetArrayColor(windowRecord, i, mc, colors, bytecolors);
}
}
else {
// Only one single rect to draw in this single loop iteration.
// The rect is already set up in 'rect', and the drawing color has
// been set as well by PsychPrepareRenderBatch(). penSize has been
// set by that routine as well in penSizes[0], so we don't have
// anything to do here...
// NO OP.
}
j = (nrsize > 1) ? i : 0;
if (penSizes[j] != penSize) {
penSize = penSizes[j];
if (lf != -1) glLineWidth((GLfloat) penSize);
}
if (IsPsychRectEmpty(rect)) continue;
if (lf == -1) {
// New style rendering: More robust against variations in GPU implementations:
fudge = penSize;
glRectd(rect[kPsychLeft], rect[kPsychTop], rect[kPsychRight], rect[kPsychTop] + fudge);
glRectd(rect[kPsychLeft], rect[kPsychBottom], rect[kPsychRight], rect[kPsychBottom] - fudge);
glRectd(rect[kPsychLeft], rect[kPsychTop]+fudge, rect[kPsychLeft]+fudge, rect[kPsychBottom]-fudge);
glRectd(rect[kPsychRight]-fudge, rect[kPsychTop]+fudge, rect[kPsychRight], rect[kPsychBottom]-fudge);
}
else {
// Old style: Has a couple of problems in corner cases. Left for now as reference...
if (penSize > 1) {
// Width > 1
fudge = (penSize > 1) ? lf * penSize/2 : 0.0;
glBegin(GL_LINES);
// Draw 4 separate segments, extend the left and right
// vertical segments by half a penWidth.
glVertex2d(rect[kPsychLeft], rect[kPsychTop] - fudge);
glVertex2d(rect[kPsychLeft], rect[kPsychBottom] + fudge);
glVertex2d(rect[kPsychRight], rect[kPsychTop]);
glVertex2d(rect[kPsychLeft], rect[kPsychTop]);
glVertex2d(rect[kPsychRight], rect[kPsychBottom] + fudge);
glVertex2d(rect[kPsychRight], rect[kPsychTop] - fudge);
glVertex2d(rect[kPsychRight], rect[kPsychBottom]);
glVertex2d(rect[kPsychLeft], rect[kPsychBottom]);
glEnd();
}
else {
// Width <= 1: Simple case...
glBegin(GL_LINE_LOOP);
glVertex2d(rect[kPsychLeft], rect[kPsychBottom]);
glVertex2d(rect[kPsychLeft], rect[kPsychTop]);
glVertex2d(rect[kPsychRight], rect[kPsychTop]);
glVertex2d(rect[kPsychRight], rect[kPsychBottom]);
glEnd();
}
}
// Next rect...
}
// Need to reset line width?
if (penSize!=1 && lf!=-1) glLineWidth(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
return(PsychError_none);
}
PsychError SCREENGetMovieImage(void)
{
PsychWindowRecordType *windowRecord;
PsychWindowRecordType *textureRecord;
PsychRectType rect;
double deadline, tnow;
int moviehandle = -1;
int waitForImage = TRUE;
double requestedTimeIndex = -1;
double presentation_timestamp = 0;
int rc=0;
int specialFlags = 0;
int specialFlags2 = 0;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()) {PsychGiveHelp(); return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(6)); // Max. 6 input args.
PsychErrorExit(PsychRequireNumInputArgs(2)); // Min. 2 input args required.
PsychErrorExit(PsychCapNumOutputArgs(2)); // Max. 2 output args.
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Only onscreen windows allowed:
if(!PsychIsOnscreenWindow(windowRecord)) {
PsychErrorExitMsg(PsychError_user, "GetMovieImage called on something else than an onscreen window.");
}
// Get the movie handle:
PsychCopyInIntegerArg(2, TRUE, &moviehandle);
if (moviehandle==-1) {
PsychErrorExitMsg(PsychError_user, "GetMovieImage called without valid handle to a movie object.");
}
// Get the 'waitForImage' flag: If waitForImage == true == 1, we'll do a blocking wait for
// arrival of a new image for playback. Otherwise we will return with a 0-Handle if there
// isn't any new image available.
PsychCopyInIntegerArg(3, FALSE, &waitForImage);
// Get the requested timeindex for the frame. The default is -1, which means: Get the next image,
// according to current movie playback time.
PsychCopyInDoubleArg(4, FALSE, &requestedTimeIndex);
// Get the optional specialFlags flag:
PsychCopyInIntegerArg(5, FALSE, &specialFlags);
// Get the optional specialFlags2 flag:
PsychCopyInIntegerArg(6, FALSE, &specialFlags2);
PsychGetAdjustedPrecisionTimerSeconds(&deadline);
deadline += 5;
while (rc==0) {
rc = PsychGetTextureFromMovie(windowRecord, moviehandle, TRUE, requestedTimeIndex, NULL, NULL);
PsychGetAdjustedPrecisionTimerSeconds(&tnow);
if (rc<0 || (tnow > deadline)) {
// No image available and there won't be any in the future, because the movie has reached
// its end and we are not in looped playback mode:
if (tnow > deadline) printf("PTB-ERROR: In Screen('GetMovieImage') for movie %i: Timed out while waiting for new frame after 5 seconds!\n", moviehandle);
// No new texture available: Return a negative handle:
PsychCopyOutDoubleArg(1, TRUE, -1);
// ...and an invalid timestamp:
PsychCopyOutDoubleArg(2, FALSE, -1);
// Ready!
return(PsychError_none);
}
else if (rc==0 && waitForImage == 0) {
// We should just poll once and no new texture available: Return a null-handle:
PsychCopyOutDoubleArg(1, TRUE, 0);
// ...and an invalid timestamp:
PsychCopyOutDoubleArg(2, FALSE, -1);
// Ready!
return(PsychError_none);
}
else if (rc==0 && waitForImage != 0) {
// No new texture available yet. Just sleep a bit and then retry...
PsychWaitIntervalSeconds(0.005);
}
}
// New image available: Go ahead...
// Create a texture record. Really just a window record adapted for textures.
PsychCreateWindowRecord(&textureRecord); // This also fills the window index field.
// Set mode to 'Texture':
textureRecord->windowType=kPsychTexture;
// We need to assign the screen number of the onscreen-window.
textureRecord->screenNumber=windowRecord->screenNumber;
// It is always a 32 bit texture for movie textures:
textureRecord->depth=32;
textureRecord->nrchannels = 4;
// Create default rectangle which describes the dimensions of the image. Will be overwritten
// later on.
PsychMakeRect(rect, 0, 0, 10, 10);
PsychCopyRect(textureRecord->rect, rect);
// Other setup stuff:
textureRecord->textureMemorySizeBytes= 0;
textureRecord->textureMemory=NULL;
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Try to fetch an image from the movie object and return it as texture:
PsychGetTextureFromMovie(windowRecord, moviehandle, FALSE, requestedTimeIndex, textureRecord, ((specialFlags2 & 1) ? NULL : &presentation_timestamp));
// Assign GLSL filter-/lookup-shaders if needed: usefloatformat is always == 0 as
// our current movie engine implementations only return 8 bpc fixed textures.
// The 'userRequest' flag is set if specialmode flag is set to 8.
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, 0, (specialFlags & 2) ? 1 : 0);
// Texture ready for consumption. Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
PsychCopyOutDoubleArg(1, TRUE, textureRecord->windowIndex);
// Return presentation timestamp for this image:
PsychCopyOutDoubleArg(2, FALSE, presentation_timestamp);
// Ready!
return(PsychError_none);
}
/*
PsychOSOpenOnscreenWindow()
Creates the CGL pixel format and the CGL context objects and then instantiates the context onto the screen.
-The pixel format and the context are stored in the target specific field of the window recored. Close
should clean up by destroying both the pixel format and the context.
-We mantain the context because it must be be made the current context by drawing functions to draw into
the specified window.
-We maintain the pixel format object because there seems to be now way to retrieve that from the context.
-To tell the caller to clean up PsychOSOpenOnscreenWindow returns FALSE if we fail to open the window. It
would be better to just issue an PsychErrorExit() and have that clean up everything allocated outside of
PsychOpenOnscreenWindow().
MK: The new option 'stereomode' allows selection of stereo display instead of mono display:
0 (default) == Old behaviour -> Monoscopic rendering context.
>0 == Stereo display, where the number defines the type of stereo algorithm to use.
=1 == Use OpenGL built-in stereo by creating a context/window with left- and right backbuffer. This is
the only mode of interest here, as it requires use of a stereo capable OpenGL pixelformat. All other
stereo modes are implemented by PTB itself in a platform independent manner on top of a standard mono
context.
*/
psych_bool PsychOSOpenOnscreenWindow(PsychScreenSettingsType *screenSettings, PsychWindowRecordType *windowRecord, int numBuffers, int stereomode, int conserveVRAM)
{
CGOpenGLDisplayMask displayMask;
CGLError error;
CGDirectDisplayID cgDisplayID;
CGLPixelFormatAttribute attribs[40];
int attribcount;
GLint numVirtualScreens;
GLenum glerr;
PsychRectType screenrect;
int i;
int windowLevel;
long scw, sch;
void* cocoaWindow = NULL;
// Map screen number to physical display handle cgDisplayID:
PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, screenSettings->screenNumber);
displayMask = CGDisplayIDToOpenGLDisplayMask(cgDisplayID);
// NULL-out Cocoa window handle, so this is well-defined in case of error:
windowRecord->targetSpecific.windowHandle = NULL;
// Retrieve windowLevel, an indicator of where non-CGL / non-fullscreen windows should
// be located wrt. to other windows. -2 = Allow regular window manager control of stacking
// order, visibility etc., -1 = Invisible/hidden, 0 = Behind everything else, occluded by
// everything else. 1 - 999 = At layer 'windowLevel' -> Occludes stuff on layers "below" it.
// 1000 - 1999 = At highest level, but partially translucent / alpha channel allows to make
// regions transparent. Range 1000 - 1499 = transparent for mouse and keyboard, alpha 0-99.99%,
// 1500-1599 = opaque for mouse and keyboard, alpha 0-99.99%, 2000 or higher: Above everything,
// fully opaque, occludes everything, a typical fullscreen onscreen window. 2000 is the default.
windowLevel = PsychPrefStateGet_WindowShieldingLevel();
// Window rect provided which has same size as screen?
// We do not use windowed mode if the provided window rectangle either
// matches the target screens rectangle (and therefore its exact size)
// or its screens global rectangle. In such cases we use CGL for better
// low level control and to exclude the desktop compositor from interfering:
PsychGetScreenRect(screenSettings->screenNumber, screenrect);
if (PsychMatchRect(screenrect, windowRecord->rect)) windowRecord->specialflags |= kPsychIsFullscreenWindow;
PsychGetGlobalScreenRect(screenSettings->screenNumber, screenrect);
if (PsychMatchRect(screenrect, windowRecord->rect)) windowRecord->specialflags |= kPsychIsFullscreenWindow;
if ((windowRecord->specialflags & kPsychIsFullscreenWindow) && (PsychPrefStateGet_Verbosity() > 3)) {
printf("PTB-INFO: Always using Cocoa for fullscreen windows to work around graphics driver bugs in OSX.\n");
printf("PTB-INFO: Presentation timing precision is not yet known for this configuration on most machines. Check your results.\n");
}
// Display for fullscreen window not captured? Timing precision is unclear in this mode. In theory the compositor should disable
// itself for fullscreen windows on modern OSX versions. If it really does that, who knows?
if ((windowRecord->specialflags & kPsychIsFullscreenWindow) && (PsychPrefStateGet_ConserveVRAM() & kPsychUseAGLCompositorForFullscreenWindows)) {
// Force a window rectangle that matches the global screen rectangle for that windows screen:
PsychCopyRect(windowRecord->rect, screenrect);
// Warn user about what's going on:
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-INFO: No display capture / compositor lockout for fullscreen window. Timing precision is unknown.\n");
}
if ((windowRecord->specialflags & kPsychGUIWindow) && (PsychPrefStateGet_Verbosity() > 3)) {
printf("PTB-INFO: Onscreen window is configured as regular GUI window.\n");
}
// Create onscreen Cocoa window of requested position and size:
if (PsychCocoaCreateWindow(windowRecord, windowLevel, &cocoaWindow)) {
printf("\nPTB-ERROR[CreateNewWindow failed]: Failed to open Cocoa onscreen window\n\n");
return(FALSE);
}
// Transparent window requested?
if ((windowLevel >= 1000) && (windowLevel < 2000)) {
// Setup of global window alpha value for transparency. This is premultiplied to
// the individual per-pixel alpha values if transparency is enabled by Cocoa code.
//
// Levels 1000 - 1499 and 1500 to 1999 map to a master opacity level of 0.0 - 1.0:
PsychCocoaSetWindowAlpha(cocoaWindow, ((float) (windowLevel % 500)) / 499.0);
}
// Show it! Unless a windowLevel of -1 requests hiding the window:
if (windowLevel != -1) PsychCocoaShowWindow(cocoaWindow);
// If usercode wants a black startup screen then we add a pause of 0.5 seconds here
// before proceeding. This will avoid a white flash at window open time, which might
// be something the user wanted to avoid. Why does this help or is needed at all?
// Nobody knows, but this is Apples ridiculous toy OS, so why even ask such questions?
if (PsychPrefStateGet_VisualDebugLevel() < 4)
PsychYieldIntervalSeconds(0.5);
// Level zero means: Place behind all other windows:
if (windowLevel == 0) PsychCocoaSendBehind(cocoaWindow);
// Levels 1 to 999 define window levels for the group of the window.
// A level of -2 would leave this to the system:
if (windowLevel > 0 && windowLevel < 1000) PsychCocoaSetWindowLevel(cocoaWindow, windowLevel);
// Is the target display captured for a fullscreen window?
if (PsychIsScreenCaptured(screenSettings->screenNumber)) {
// Yes. Make sure our window is above the shielding window level:
PsychCocoaSetWindowLevel(cocoaWindow, (int) CGShieldingWindowLevel());
}
// Store window handle in windowRecord:
windowRecord->targetSpecific.windowHandle = cocoaWindow;
// Store vblank startline aka true height of physical display screen in pixels:
PsychGetScreenPixelSize(screenSettings->screenNumber, &scw, &sch);
windowRecord->VBL_Startline = (int) sch;
// Define pixelformat attributes for OpenGL contexts:
// No pixelformat attribs to start with:
attribcount = 0;
attribs[attribcount++]=kCGLPFADisplayMask;
attribs[attribcount++]=displayMask;
// 10 bit per component integer framebuffer requested (10-10-10-2)?
if (windowRecord->depth == 30) {
// Request a 10 bit per color component framebuffer with 2 bit alpha channel:
printf("PTB-INFO: Trying to enable 10 bpc, 30 bit integer framebuffer...\n");
attribs[attribcount++]=kCGLPFANoRecovery;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=10*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=2;
}
// 11 bit per component integer framebuffer requested (11-11-10-0)?
if (windowRecord->depth == 33) {
// Request a ~ 11 bit per color component framebuffer without alpha channel:
printf("PTB-INFO: Trying to enable 11 bpc, 32 bit integer framebuffer...\n");
attribs[attribcount++]=kCGLPFANoRecovery;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=32;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=0;
}
// 16 bit per component integer framebuffer requested (16-16-16-16)?
if (windowRecord->depth == 48) {
// Request a 16 bit per color component framebuffer:
printf("PTB-INFO: Trying to enable 16 bpc, 64 bit integer framebuffer...\n");
attribs[attribcount++]=kCGLPFANoRecovery;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=16*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=16;
}
// 16 bit per component, 64 bit framebuffer requested (16-16-16-16)?
if (windowRecord->depth == 64) {
// Request a floating point framebuffer in 16-bit half-float format, i.e., RGBA = 16 bits per component.
printf("PTB-INFO: Trying to enable 16 bpc float framebuffer...\n");
attribs[attribcount++]=kCGLPFAColorFloat;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=16*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=16;
}
// 32 bit per component, 128 bit framebuffer requested (32-32-32-32)?
if (windowRecord->depth == 128) {
// Request a floating point framebuffer in 32-bit float format, i.e., RGBA = 32 bits per component.
printf("PTB-INFO: Trying to enable 32 bpc float framebuffer...\n");
attribs[attribcount++]=kCGLPFAColorFloat;
attribs[attribcount++]=kCGLPFAMinimumPolicy;
attribs[attribcount++]=kCGLPFAColorSize;
attribs[attribcount++]=32*3;
attribs[attribcount++]=kCGLPFAAlphaSize;
attribs[attribcount++]=32;
}
// Possible to request use of the Apple floating point software renderer:
if (conserveVRAM & kPsychUseSoftwareRenderer) {
#ifndef kCGLRendererGenericFloatID
#define kCGLRendererGenericFloatID 0x00020400
#endif
attribs[attribcount++]=AGL_RENDERER_ID;
attribs[attribcount++]=kCGLRendererGenericFloatID;
}
// Support for 3D rendering requested?
if (PsychPrefStateGet_3DGfx()) {
// Yes. Allocate a 24-Bit depth and 8-Bit stencilbuffer for this purpose:
attribs[attribcount++]=kCGLPFADepthSize;
attribs[attribcount++]=24;
attribs[attribcount++]=kCGLPFAStencilSize;
attribs[attribcount++]=8;
// Alloc an accumulation buffer as well?
if (PsychPrefStateGet_3DGfx() & 2) {
// Yes: Alloc accum buffer, request 64 bpp, aka 16 bits integer per color component if possible:
attribs[attribcount++]=kCGLPFAAccumSize;
attribs[attribcount++]=64;
}
}
if(numBuffers>=2){
// Enable double-buffering:
attribs[attribcount++]=kCGLPFADoubleBuffer;
if ((conserveVRAM & kPsychDisableAUXBuffers) == 0) {
// Allocate one or two (for mono vs. stereo display) AUX buffers for "don't clear" mode of Screen('Flip'):
// Not clearing the framebuffer after "Flip" is implemented by storing a backup-copy of
// the backbuffer to AUXs before flip and restoring the content from AUXs after flip.
// Unless the imaging pipeline is active, which doesn't need AUX buffers due to internal
// storage of fb content in its drawbufferFBO's:
attribs[attribcount++]=kCGLPFAAuxBuffers;
attribs[attribcount++]=(stereomode==kPsychOpenGLStereo || stereomode==kPsychCompressedTLBRStereo || stereomode==kPsychCompressedTRBLStereo) ? 2 : 1;
}
}
// If stereo display output is requested with OpenGL native stereo, request a stereo-enabled rendering context.
// This is deprecated since 10.11 El Capitan, and in fact does no longer work - OpenGL quad buffered stereo is
// dead on 10.11 on all tested GPU's from Intel, NVidia, AMD.
if(stereomode==kPsychOpenGLStereo) {
attribs[attribcount++] = kCGLPFAStereo;
}
// Multisampled Anti-Aliasing requested?
if (windowRecord->multiSample > 0) {
// Request a multisample buffer:
attribs[attribcount++]= kCGLPFASampleBuffers;
attribs[attribcount++]= 1;
// Request at least multiSample samples per pixel:
attribs[attribcount++]= kCGLPFASamples;
attribs[attribcount++]= windowRecord->multiSample;
}
// Finalize attribute array with NULL.
attribs[attribcount++]=(CGLPixelFormatAttribute)NULL;
// Init to zero:
windowRecord->targetSpecific.pixelFormatObject = NULL;
windowRecord->targetSpecific.glusercontextObject = NULL;
windowRecord->targetSpecific.glswapcontextObject = NULL;
// Try to find matching pixelformat:
error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
// No valid pixelformat found and stereo format requested?
if ((error || (windowRecord->targetSpecific.pixelFormatObject == NULL)) && (stereomode == kPsychOpenGLStereo)) {
// Yep: Stereo may be the culprit. Remove the stereo attribute by overwriting it with something
// that is essentially a no-op, specifically kCGLPFAAccelerated which is supported by all real
// renderers that might end up in this code-path:
for (i = 0; i < attribcount && attribs[i] != kCGLPFAStereo; i++);
attribs[i] = kCGLPFAAccelerated;
// Retry query of pixelformat without request for native OpenGL quad-buffered stereo. If we succeed, we're
// sort of ok, as the higher-level code will fallback to stereomode kPsychFrameSequentialStereo - our own
// homegrown frame-sequential stereo support, which may be good enough.
error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
if (error || (windowRecord->targetSpecific.pixelFormatObject == NULL)) {
windowRecord->targetSpecific.pixelFormatObject = NULL;
printf("\nPTB-ERROR[ChoosePixelFormat failed: %s]: Disabling OpenGL native quad-buffered stereo did not help. Moving on...\n\n", CGLErrorString(error));
}
}
// Now try if choosing a matching format for a lower multisample mode helps to get unstuck:
if (windowRecord->multiSample > 0) {
if (windowRecord->targetSpecific.pixelFormatObject==NULL && windowRecord->multiSample > 0) {
// Failed. Probably due to too demanding multisample requirements: Lets lower them...
for (i = 0; i < attribcount && attribs[i] != kCGLPFASamples; i++);
while (windowRecord->targetSpecific.pixelFormatObject == NULL && windowRecord->multiSample > 0) {
attribs[i+1]--;
windowRecord->multiSample--;
error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
}
if (windowRecord->multiSample == 0 && windowRecord->targetSpecific.pixelFormatObject == NULL) {
// Ok, multisampling is now at zero and we still don't succeed. Disable multisampling completely:
for (i=0; i<attribcount && attribs[i]!=kCGLPFASampleBuffers; i++);
attribs[i+1] = 0;
printf("\nPTB-ERROR[ChoosePixelFormat failed: %s]: Disabling multisample anti-aliasing did not help. Moving on...\n\n", CGLErrorString(error));
}
}
}
// Try choosing a matching display configuration again and create the window and rendering context:
// If one of these two fails, then the installed gfx hardware is not good enough to satisfy our
// requirements, or we have massive ressource shortage in the system. -> Screwed up anyway, so we abort.
if (windowRecord->targetSpecific.pixelFormatObject == NULL) error = CGLChoosePixelFormat(attribs, &(windowRecord->targetSpecific.pixelFormatObject), &numVirtualScreens);
if (error) {
printf("\nPTB-ERROR[ChoosePixelFormat failed: %s]: Reason unknown. There could be insufficient video memory or a driver malfunction. Giving up.\n\n", CGLErrorString(error));
return(FALSE);
}
// Create an OpenGL rendering context with the selected pixelformat: Share its ressources with 'slaveWindow's context, if slaveWindow is non-NULL.
// If slaveWindow is non-NULL here, then slaveWindow is typically another onscreen window. Therefore this establishes OpenGL resource sharing across
// different onscreen windows in a session, e.g., for multi-display operation:
error=CGLCreateContext(windowRecord->targetSpecific.pixelFormatObject, ((windowRecord->slaveWindow) ? windowRecord->slaveWindow->targetSpecific.contextObject : NULL),
&(windowRecord->targetSpecific.contextObject));
if (error) {
printf("\nPTB-ERROR[ContextCreation failed: %s]: Could not create master OpenGL context for new onscreen window. Insufficient video memory?\n\n", CGLErrorString(error));
return(FALSE);
}
// Enable the OpenGL rendering context associated with our window:
error=CGLSetCurrentContext(windowRecord->targetSpecific.contextObject);
if (error) {
printf("\nPTB-ERROR[SetCurrentContext failed: %s]: Insufficient video memory\n\n", CGLErrorString(error));
return(FALSE);
}
// NULL-out the AGL context field, just for safety...
windowRecord->targetSpecific.deviceContext = NULL;
// Ok, the master OpenGL rendering context for this new onscreen window is up and running.
// Auto-detect and bind all available OpenGL extensions via GLEW:
glerr = glewInit();
if (GLEW_OK != glerr)
{
/* Problem: glewInit failed, something is seriously wrong. */
printf("\nPTB-ERROR[GLEW init failed: %s]: Please report this to the forum. Will try to continue, but may crash soon!\n\n", glewGetErrorString(glerr));
fflush(NULL);
}
else {
if (PsychPrefStateGet_Verbosity()>3) printf("PTB-INFO: Using GLEW version %s for automatic detection of OpenGL extensions...\n", glewGetString(GLEW_VERSION));
}
// Enable multisampling if it was requested:
if (windowRecord->multiSample > 0) glEnable(GL_MULTISAMPLE);
// External 3D graphics support enabled?
if (PsychPrefStateGet_3DGfx()) {
// Yes. We need to create an extra OpenGL rendering context for the external
// OpenGL code to provide optimal state-isolation. The context shares all
// heavyweight ressources likes textures, FBOs, VBOs, PBOs, shader, display lists and
// starts off as an identical copy of PTB's context as of here.
error=CGLCreateContext(windowRecord->targetSpecific.pixelFormatObject, windowRecord->targetSpecific.contextObject, &(windowRecord->targetSpecific.glusercontextObject));
if (error) {
printf("\nPTB-ERROR[UserContextCreation failed: %s]: Creating a private OpenGL context for userspace OpenGL failed.\n\n", CGLErrorString(error));
return(FALSE);
}
}
// Create glswapcontextObject - An OpenGL context for exclusive use by parallel background threads,
// e.g., our thread for async flip operations and self-made frame-sequential stereo:
error=CGLCreateContext(windowRecord->targetSpecific.pixelFormatObject, windowRecord->targetSpecific.contextObject, &(windowRecord->targetSpecific.glswapcontextObject));
if (error) {
printf("\nPTB-ERROR[SwapContextCreation failed: %s]: Creating a private OpenGL context for async-bufferswaps failed.\n\n", CGLErrorString(error));
CGLSetCurrentContext(NULL);
return(FALSE);
}
// Store Cocoa onscreen window handle:
windowRecord->targetSpecific.windowHandle = cocoaWindow;
// Objective-C setup path, using Cocoa + NSOpenGLContext wrapped around already
// existing and setup CGLContext:
if (PsychCocoaSetupAndAssignOpenGLContextsFromCGLContexts(cocoaWindow, windowRecord)) {
printf("\nPTB-ERROR[Cocoa OpenGL setup failed]: Setup failed for unknown reasons.\n\n");
PsychCocoaDisposeWindow(windowRecord);
return(FALSE);
}
// Check for output display rotation enabled. Will impair timing/timestamping because
// it uses the desktop compositor for a rotated copy blit, instead of via rotated crtc
// scanout, as most crtc's don't support this in hardware:
if ((((int) CGDisplayRotation(cgDisplayID)) != 0) && (PsychPrefStateGet_Verbosity() > 1)) {
printf("PTB-WARNING: Your onscreen windows output display has rotation enabled. It is not displaying in upright orientation.\n");
printf("PTB-WARNING: On most graphics cards this will cause unreliable stimulus presentation timing and timestamping.\n");
printf("PTB-WARNING: If you want non-upright stimulus presentation, look at 'help PsychImaging' on how to achieve this in\n");
printf("PTB-WARNING: a way that doesn't impair timing. The subfunctions 'FlipHorizontal' and 'FlipVertical' are what you probably need.\n");
}
// First reference to this screen by a window?
if (screenRefCount[screenSettings->screenNumber] == 0) {
// High precision timestamping enabled? If so, we need to setup the fallback
// timestamping methods in case beamposition timestamping doesn't work:
if (PsychPrefStateGet_VBLTimestampingMode() > 0) {
// Use of CoreVideo is needed on 10.7 and later due to brokeness of the old method (thanks Apple!):
if (PsychPrefStateGet_Verbosity() > 2) {
printf("PTB-INFO: Will use fragile CoreVideo timestamping as fallback if beamposition timestamping doesn't work.\n");
// Recommend use of kernel driver if it isn't installed already for all but Intel GPU's:
if (!PsychOSIsKernelDriverAvailable(screenSettings->screenNumber) && !strstr((char*) glGetString(GL_VENDOR), "Intel")) {
printf("PTB-INFO: Installation of the PsychtoolboxKernelDriver is strongly recommended if you care about precise visual\n");
printf("PTB-INFO: onset timestamping or timing. See 'help PsychtoolboxKernelDriver' for installation instructions.\n");
}
}
if (NULL == cvDisplayLink[screenSettings->screenNumber]) {
// CoreVideo timestamping:
//
// Create and start a CVDisplayLink for this screen.
if (kCVReturnSuccess != CVDisplayLinkCreateWithCGDisplay(cgDisplayID, &cvDisplayLink[screenSettings->screenNumber])) {
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to create CVDisplayLink for screenId %i. This may impair VBL timestamping.\n", screenSettings->screenNumber);
} else {
// Assign dummy output callback, as this is mandatory to get the link up and running:
CVDisplayLinkSetOutputCallback(cvDisplayLink[screenSettings->screenNumber], &PsychCVDisplayLinkOutputCallback, (void*) (long int) screenSettings->screenNumber);
// Setup shared data structure and mutex:
memset(&cvDisplayLinkData[screenSettings->screenNumber], 0, sizeof(cvDisplayLinkData[screenSettings->screenNumber]));
PsychInitMutex(&(cvDisplayLinkData[screenSettings->screenNumber].mutex));
// Start the link:
if (kCVReturnSuccess != CVDisplayLinkStart(cvDisplayLink[screenSettings->screenNumber])) {
// Failed to start: Release it again and report error:
CVDisplayLinkRelease(cvDisplayLink[screenSettings->screenNumber]);
cvDisplayLink[screenSettings->screenNumber] = NULL;
// Teardown shared data structure and mutex:
PsychDestroyMutex(&(cvDisplayLinkData[screenSettings->screenNumber].mutex));
if (PsychPrefStateGet_Verbosity()>1) printf("PTB-WARNING: Failed to start CVDisplayLink for screenId %i. This may impair VBL timestamping.\n", screenSettings->screenNumber);
}
else {
// Display link started: Report some stuff for the fun of it...
if (PsychPrefStateGet_Verbosity() > 3) {
// Wait for 50 msecs before query of video refresh from display link to give it a chance to start up:
PsychWaitIntervalSeconds(0.050);
printf("PTB-INFO: CVDisplayLink for screen %i created to work around the brokenness of Apple Mac OS/X 10.7 and later:\n", screenSettings->screenNumber);
printf("PTB-INFO: Video refresh interval as measured by CoreVideo display link: %f msecs.\n", (float) CVDisplayLinkGetActualOutputVideoRefreshPeriod(cvDisplayLink[screenSettings->screenNumber]) * 1000.0);
CVTime outLatency = CVDisplayLinkGetOutputVideoLatency(cvDisplayLink[screenSettings->screenNumber]);
printf("PTB-INFO: Video display output delay as reported by CoreVideo display link: %f msecs.\n", screenSettings->screenNumber, (float) (((double) outLatency.timeValue / (double) outLatency.timeScale) * 1000.0));
}
}
}
}
}
else {
// VBLtimestampingmode 0 or -1 -- No CoreVideo fallback for timestamping if beamposition timestamping is unavailable:
// This is the new default as of Psychtoolbox 3.0.12 to avoid the buggy, crashy, unreliably CoreVideo fallback.
// Recommend use of kernel driver if it isn't installed already for all but Intel GPU's:
if (!PsychOSIsKernelDriverAvailable(screenSettings->screenNumber) && !strstr((char*) glGetString(GL_VENDOR), "Intel")) {
printf("PTB-INFO: Installation of the PsychtoolboxKernelDriver is strongly recommended if you care about precise visual\n");
printf("PTB-INFO: onset timestamping or timing. See 'help PsychtoolboxKernelDriver' for installation instructions.\n");
}
}
}
// Retain reference of this window to its screen:
screenRefCount[screenSettings->screenNumber]++;
// Done.
return(TRUE);
}
PsychError 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);
}
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 SCREENSetOpenGLTexture(void)
{
PsychWindowRecordType *windowRecord, *textureRecord;
int texid, w, h, d, testarg, textureShader, usefloatformat = 0;
int specialFlags = 0;
GLenum target = 0;
texid=w=h=d=-1;
//all subfunctions should have these two lines.
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumInputArgs(9)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(4)); //The required 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(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
// Get the texture record from the texture record argument.
// Check if either none ( [] or '' ) or the special value zero was
// provided as Psychtoolbox textureHandle. In that case, we create a new
// empty texture record instead of reusing an existing one.
testarg=0;
PsychCopyInIntegerArg(2, FALSE, &testarg);
if (testarg==0) {
// No valid textureHandle provided. Create a new empty textureRecord.
PsychCreateWindowRecord(&textureRecord);
textureRecord->windowType=kPsychTexture;
textureRecord->screenNumber = windowRecord->screenNumber;
// Assign parent window and copy its inheritable properties:
PsychAssignParentWindow(textureRecord, windowRecord);
// Mark it valid and return handle to userspace:
PsychSetWindowRecordValid(textureRecord);
}
else {
// None of the special values provided. We assume its a handle to a valid
// and existing PTB texture and try to retrieve the textureRecord:
PsychAllocInWindowRecordArg(2, TRUE, &textureRecord);
}
// Is it a textureRecord?
if (!PsychIsTexture(textureRecord)) {
PsychErrorExitMsg(PsychError_user, "You tried to set texture information on something else than a texture!");
}
// Query OpenGL texid:
PsychCopyInIntegerArg(3, TRUE, &texid);
// Query OpenGL texture target:
PsychCopyInIntegerArg(4, TRUE, (int*) &target);
// Query optional override width:
PsychCopyInIntegerArg(5, FALSE, &w);
// Query optional override height:
PsychCopyInIntegerArg(6, FALSE, &h);
// Query optional override depth:
PsychCopyInIntegerArg(7, FALSE, &d);
// Get optional texture shader handle:
textureShader = 0;
PsychCopyInIntegerArg(8, FALSE, &textureShader);
// Get optional specialFlags:
PsychCopyInIntegerArg(9, FALSE, &specialFlags);
// Activate OpenGL rendering context of windowRecord:
PsychSetGLContext(windowRecord);
// Bind the provided external OpenGL texture object:
PsychTestForGLErrors();
glBindTexture(target, texid);
PsychTestForGLErrors();
// Binding worked. Query its size and format unless override values are given:
if (w==-1) glGetTexLevelParameteriv(target, 0, GL_TEXTURE_WIDTH, (GLint*) &w);
if (h==-1) glGetTexLevelParameteriv(target, 0, GL_TEXTURE_HEIGHT, (GLint*) &h);
if (d==-1) glGetTexLevelParameteriv(target, 0, GL_TEXTURE_DEPTH, (GLint*) &d);
if (w<=0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (negative) texture width.");
}
if (h<=0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (negative) texture height.");
}
if (d<=0) {
PsychErrorExitMsg(PsychError_user, "You tried to set invalid (negative) texture depth.");
}
// Ok, setup texture record for texture:
PsychInitWindowRecordTextureFields(textureRecord);
textureRecord->depth = d;
// Assume this texture has four channels. FIXME: Is this problematic?
textureRecord->nrchannels = 4;
PsychMakeRect(textureRecord->rect, 0, 0, w, h);
// Client rect of a texture is always == rect of it:
PsychCopyRect(textureRecord->clientrect, textureRecord->rect);
textureRecord->texturetarget = target;
// Orientation is set to 2 - like an upright Offscreen window texture:
textureRecord->textureOrientation = 2;
textureRecord->textureNumber = texid;
// Assign GLSL filter-/lookup-shaders if needed: usefloatformat is determined
// by query, whereas the 'userRequest' flag is set to zero for now.
glGetTexLevelParameteriv(target, 0, GL_TEXTURE_RED_SIZE, (GLint*) &d);
if (d <= 0) glGetTexLevelParameteriv(target, 0, GL_TEXTURE_LUMINANCE_SIZE, (GLint*) &d);
if (d < 16) usefloatformat = 0;
if (d >= 16) usefloatformat = 1;
if (d >= 32) usefloatformat = 2;
// Assign bpc value:
textureRecord->bpc = (int) d;
PsychAssignHighPrecisionTextureShaders(textureRecord, windowRecord, usefloatformat, (specialFlags & 2) ? 1 : 0);
// specialFlags setting 8? Disable auto-mipmap generation:
if (specialFlags & 0x8) textureRecord->specialflags |= kPsychDontAutoGenMipMaps;
// A specialFlags setting of 32? Protect texture against deletion via Screen('Close') without providing a explicit handle:
if (specialFlags & 32) textureRecord->specialflags |= kPsychDontDeleteOnClose;
// 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;
}
// Unbind texture:
glBindTexture(target, 0);
// printf("id %i target: %i w %i h %i", texid, target, w, h);
// Return new (or old) PTB textureHandle for this texture:
PsychCopyOutDoubleArg(1, FALSE, textureRecord->windowIndex);
PsychCopyOutRectArg(2, FALSE, textureRecord->rect);
// Done.
return(PsychError_none);
}
PsychError SCREENFrameOval(void)
{
PsychRectType rect;
double numSlices, outerRadius, xScale, yScale, xTranslate, yTranslate, rectY, rectX, penWidth, penHeight, penSize, innerRadius;
PsychWindowRecordType *windowRecord;
psych_bool isArgThere, isclassic;
double *xy, *colors;
unsigned char *bytecolors;
double* penSizes;
int numRects, i, nc, mc, nrsize;
GLUquadricObj *diskQuadric;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);}
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(6)); //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);
// Query, allocate and copy in all vectors...
numRects = 4;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
mc = nc = 0;
// The negative position -3 means: xy coords are expected at position 3, but they are optional.
// NULL means - don't want a size's vector.
PsychPrepareRenderBatch(windowRecord, -3, &numRects, &xy, 2, &nc, &mc, &colors, &bytecolors, 4, &nrsize, &penSizes, FALSE);
isclassic = PsychIsGLClassic(windowRecord);
// Only up to one rect provided?
if (numRects <= 1) {
// Get the oval and draw it:
PsychCopyRect(rect, windowRecord->clientrect);
isArgThere=PsychCopyInRectArg(kPsychUseDefaultArgPosition, FALSE, rect);
if (isArgThere && IsPsychRectEmpty(rect)) return(PsychError_none);
numRects = 1;
// Get the pen width and height arguments
penWidth=1;
penHeight=1;
PsychCopyInDoubleArg(4, FALSE, &penWidth);
PsychCopyInDoubleArg(5, FALSE, &penHeight);
penSize = (penWidth > penHeight) ? penWidth : penHeight;
}
else {
// Multiple ovals provided. Set up the first one:
PsychCopyRect(rect, &xy[0]);
penSize = penSizes[0];
}
// Create quadric object:
if (isclassic) diskQuadric = gluNewQuadric();
// Draw all ovals (one or multiple):
for (i=0; i < numRects;) {
// Per oval color provided? If so then set it up. If only one common color
// was provided then PsychPrepareRenderBatch() has already set it up.
if (nc>1) {
// Yes. Set color for this specific item:
PsychSetArrayColor(windowRecord, i, mc, colors, bytecolors);
}
// Per oval penSize provided? If so, set it up. Otherwise keep at default size
// common for all ovals, set by code outside loop:
if (nrsize > 1) penSize = penSizes[i];
// Compute drawing parameters for ellipse:
if (!IsPsychRectEmpty(rect)) {
//The glu disk object location and size with a center point and a radius,
//whereas FrameOval accepts a bounding rect. Converting from one set of parameters
//to the other we should careful what we do for rects size of even number of pixels in length.
PsychGetCenterFromRectAbsolute(rect, &xTranslate, &yTranslate);
rectY=PsychGetHeightFromRect(rect);
rectX=PsychGetWidthFromRect(rect);
if(rectX == rectY){
xScale=1;
yScale=1;
outerRadius=rectX/2;
}else if(rectX > rectY){
xScale=1;
yScale=rectY/rectX;
outerRadius=rectX/2;
}else {
yScale=1;
xScale=rectX/rectY;
outerRadius=rectY/2;
}
numSlices = 3.14159265358979323846 * 2 * outerRadius;
innerRadius = outerRadius - penSize;
innerRadius = (innerRadius < 0) ? 0 : innerRadius;
if (isclassic) {
// Draw: Set up position, scale and size via matrix transform:
glPushMatrix();
glTranslated(xTranslate, yTranslate, 0);
glScaled(xScale, yScale, 1);
// Compute disk quadric for given params: This is awfully slow and would
// benefit a lot from shader magic on modern GPUs:
gluDisk(diskQuadric, innerRadius, outerRadius, (int) numSlices, 1);
glPopMatrix();
}
else {
PsychDrawDisc(windowRecord, (float) xTranslate, (float) yTranslate, (float) innerRadius, (float) outerRadius, (int) numSlices, (float) xScale, (float) yScale, 0, 360);
}
}
// Done with this one. Set up the next one, if any...
i++;
if (i < numRects) {
PsychCopyRect(rect, &xy[i*4]);
}
// Next oval.
}
// Release quadric object:
if (isclassic) gluDeleteQuadric(diskQuadric);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
// All Psychfunctions require this.
return(PsychError_none);
}
// Batch-drawing version of DrawTexture:
PsychError SCREENDrawTextures(void)
{
// If you change useString then also change the corresponding synopsis string in ScreenSynopsis.c 1 2 3 4 5 6 7 8
static char useString[] = "Screen('DrawTextures', windowPointer, texturePointer(s) [, sourceRect(s)] [, destinationRect(s)] [, rotationAngle(s)] [, filterMode(s)] [, globalAlpha(s)] [, modulateColor(s)] [, textureShader] [, specialFlags] [, auxParameters]);";
// 1 2 3 4 5 6 7 8 9 10 11
static char synopsisString[] = "Draw many textures at once, either one texture to many locations or many textures.\n"
"This function accepts the same parameters as Screen('DrawTexture'), but it is optimized for drawing many textures. "
"You can leave out each argument, a default setting will be used in that case, provide it once to apply it to all "
"drawn items, or provide a vector or matrix with a individual setting for each drawn item. If you provide multiple "
"settings per argument, then the number must match between all arguments.\n\n"
"Examples:\n"
"a) One texture drawn to different locations at different orientations: Provide one texture handle for the texturePointer, "
"a 4 row by n columns matrix for 'destinationRect' to provide target rectangles for n locations, provide a n component "
"vector of 'rotationAngles' for the n different orientations of the n drawn texture patches.\n"
"b) n textures drawn to n different locations: Same as a) but provide a n component vector of 'texturePointers' one for "
"each texture to be drawn to one of n locations at n angles.\n";
PsychWindowRecordType *source, *target;
PsychRectType sourceRect, targetRect, tempRect;
PsychColorType color;
GLdouble dVals[4];
double *dstRects, *srcRects, *colors, *penSizes, *globalAlphas, *filterModes, *rotationAngles;
unsigned char *bytecolors;
int numTexs, numdstRects, numsrcRects, i, j, nc, mc, nrsize, m, n, p, numAngles, numFilterModes, numAlphas, numRef;
double* texids;
double rotationAngle, globalAlpha, filterMode;
double* auxParameters;
int numAuxParams, numAuxComponents;
int textureShader, backupShader;
int specialFlags = 0;
//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 onscreen GL context which we will need in the
//final step when we copy the texture from system RAM onto the screen.
PsychErrorExit(PsychCapNumInputArgs(11));
PsychErrorExit(PsychRequireNumInputArgs(2));
PsychErrorExit(PsychCapNumOutputArgs(0));
// The target window is a fixed parameter:
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &target);
// First get all source texture handles:
PsychAllocInDoubleMatArg(2, kPsychArgRequired, &m, &n, &p, &texids);
if ((p!=1) || (m>1 && n!=1) || (n>1 && m!=1)) PsychErrorExitMsg(PsychError_user, "The second argument must be either a row- or columnvector of valid texture handles.");
// This is the number of texture handles:
numTexs = m * n;
// Only one texture?
if (numTexs == 1) {
// Yes. Allocate it in the conventional way:
PsychAllocInWindowRecordArg(2, kPsychArgRequired, &source);
if(source->windowType!=kPsychTexture) {
PsychErrorExitMsg(PsychError_user, "The second argument supplied was not a texture handle!");
}
}
// Query, allocate and copy in all vectors...
numdstRects = 4;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
penSizes = NULL;
// The negative position -4 means: dstRects coords are expected at position 4, but they are optional.
// NULL means - don't want a size's vector.
PsychPrepareRenderBatch(target, -4, &numdstRects, &dstRects, 8, &nc, &mc, &colors, &bytecolors, 5, &nrsize, &penSizes);
// At this point, target is set up as target window, i.e. its GL-Context is active, it is set as drawing target,
// alpha blending is set up according to Screen('BlendFunction'), and the drawing color is set if it is a singular one.
if (nc <= 1) {
// Only one - or no - color provided. One or none?
if(PsychCopyInColorArg(8, kPsychArgOptional, &color)) {
// One global modulate color provided:
// Setup global vertex color as modulate color for texture drawing:
PsychCoerceColorMode(&color);
PsychSetGLColor(&color, target);
}
else {
// No modulateColor provided: Don't use this parameter:
nc = 0;
}
}
// Try to get source rects:
m=n=p=0;
if (PsychAllocInDoubleMatArg(3, kPsychArgOptional, &m, &n, &p, &srcRects)) {
if ((p!=1) || (m!=1 && m!=4)) PsychErrorExitMsg(PsychError_user, "The third argument must be either empty, or a single srcRect 4 component row vector, or a 4 row by n column matrix with srcRects for all objects to draw, not a 3D matrix!");
// Ok, its a one row or four row matrix:
if (m==4) {
// Potentially multiple source rects provided:
numsrcRects = n;
}
else {
// Its a one row vector: This is either a single srcRect for all textures, or something invalid:
if (n!=4) PsychErrorExitMsg(PsychError_user, "The third argument must be either empty, or a single srcRect 4 component row vector, or a 4 row by n column matrix with srcRects for all objects to draw!");
// Single srcRect provided:
numsrcRects = 1;
}
}
else {
// No srcRects provided:
numsrcRects = 0;
}
// Optional rotation angles:
m=n=p=0;
if (PsychAllocInDoubleMatArg(5, kPsychArgOptional, &m, &n, &p, &rotationAngles)) {
if ((p!=1) || (m>1 && n!=1) || (n>1 && m!=1)) PsychErrorExitMsg(PsychError_user, "The fifth argument must be either a row- or columnvector of rotation angles.");
}
numAngles = m * n;
// Default to 0 degree rotation -- upright drawing:
rotationAngle = (numAngles == 1) ? rotationAngles[0] : 0.0;
// Optional filter modes:
m=n=p=0;
if (PsychAllocInDoubleMatArg(6, kPsychArgOptional, &m, &n, &p, &filterModes)) {
if ((p!=1) || (m>1 && n!=1) || (n>1 && m!=1)) PsychErrorExitMsg(PsychError_user, "The sixth argument must be either a row- or columnvector of filterModes.");
}
numFilterModes = m * n;
// Default to bilinear filtering:
filterMode = (numFilterModes == 1) ? filterModes[0] : 1;
// Optional globalAlphas:
m=n=p=0;
if (PsychAllocInDoubleMatArg(7, kPsychArgOptional, &m, &n, &p, &globalAlphas)) {
if ((p!=1) || (m>1 && n!=1) || (n>1 && m!=1)) PsychErrorExitMsg(PsychError_user, "The seventh argument must be either a row- or columnvector of globalAlpha values.");
}
numAlphas = m * n;
globalAlpha = (numAlphas == 1) ? globalAlphas[0] : 1.0;
// Optional auxParameters:
auxParameters = NULL;
m=n=p=0;
if (PsychAllocInDoubleMatArg(11, kPsychArgOptional, &m, &n, &p, &auxParameters)) {
if ((p!=1) || (m < 4) || ((m % 4) !=0)|| (n < 1)) PsychErrorExitMsg(PsychError_user, "The 11th argument must be a column vector or matrix of 'auxParameter' values with at least 4 components and component count a multiple of four.");
}
numAuxParams = n;
numAuxComponents = m;
// Check for consistency: Each parameter must be either not present, present once,
// or present as many times as all other multi-parameters:
numRef = (numsrcRects > numdstRects) ? numsrcRects : numdstRects;
numRef = (numRef > numTexs) ? numRef : numTexs;
numRef = (numRef > nc) ? numRef : nc;
numRef = (numRef > numAlphas) ? numRef : numAlphas;
numRef = (numRef > numFilterModes) ? numRef : numFilterModes;
numRef = (numRef > numAngles) ? numRef : numAngles;
numRef = (numRef > numAuxParams) ? numRef : numAuxParams;
if (numTexs > 1 && numTexs != numRef) {
printf("PTB-ERROR: Number of provided texture handles %i doesn't match number of other primitives %i!\n", numTexs, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (numsrcRects > 1 && numsrcRects != numRef) {
printf("PTB-ERROR: Number of provided source rectangles %i doesn't match number of other primitives %i!\n", numsrcRects, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (numdstRects > 1 && numdstRects != numRef) {
printf("PTB-ERROR: Number of provided destination rectangles %i doesn't match number of other primitives %i!\n", numdstRects, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (numAngles > 1 && numAngles != numRef) {
printf("PTB-ERROR: Number of provided rotation angles %i doesn't match number of other primitives %i!\n", numAngles, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (numAlphas > 1 && numAlphas != numRef) {
printf("PTB-ERROR: Number of provided global alpha values %i doesn't match number of other primitives %i!\n", numAlphas, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (numFilterModes > 1 && numFilterModes != numRef) {
printf("PTB-ERROR: Number of provided filtermode values %i doesn't match number of other primitives %i!\n", numFilterModes, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (nc > 1 && nc != numRef) {
printf("PTB-ERROR: Number of provided modulateColors %i doesn't match number of other primitives %i!\n", nc, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
if (numAuxParams > 1 && numAuxParams != numRef) {
printf("PTB-ERROR: Number of provided 'auxParameter' column vectors %i doesn't match number of other primitives %i!\n", numAuxParams, numRef);
PsychErrorExitMsg(PsychError_user, "Inconsistent number of arguments provided to Screen('DrawTextures').");
}
// Assign optional override texture shader, if any provided:
textureShader = -1;
PsychCopyInIntegerArg(9, kPsychArgOptional, &textureShader);
// Assign any other optional special flags:
PsychCopyInIntegerArg(10, kPsychArgOptional, &specialFlags);
// Ok, everything consistent so far.
// Texture blitting loop:
for (i=0; i < numRef; i++) {
// Draw i'th texture:
// Check if more than one texture provided. If not then the one single texture has been
// setup already above:
if (numTexs > 1) {
// More than one texture handle provided: Need to allocate i'th one in:
if(!IsWindowIndex((PsychWindowIndexType) texids[i])) {
printf("PTB-ERROR: %i th entry in texture handle vector is not a valid handle!\n");
PsychErrorExitMsg(PsychError_user, "Invalid texture handle provided to Screen('DrawTextures').");
}
// Get it:
FindWindowRecord((PsychWindowIndexType) texids[i], &source);
if(source->windowType!=kPsychTexture) {
printf("PTB-ERROR: %i th entry in texture handle vector is not a valid handle!\n");
PsychErrorExitMsg(PsychError_user, "The second argument supplied was not a texture handle!");
}
// Ok, we have our texture record in source:
}
// Source rectangle provided?
if (numsrcRects > 1) {
// Get i'th source rectangle:
PsychCopyRect(sourceRect, &(srcRects[i*4]));
} else if (numsrcRects == 1) {
// Single source rect provided - get it:
PsychCopyRect(sourceRect, &(srcRects[0]));
} else {
// No source rect provided: Take rectangle of current texture as srcRect:
PsychCopyRect(sourceRect,source->clientrect);
}
// Skip this texture if sourceRect is an empty rect:
if (IsPsychRectEmpty(sourceRect)) continue;
// Destination rectangle provided?
if (numdstRects > 1) {
// Get i'th destination rectangle:
PsychCopyRect(targetRect, &(dstRects[i*4]));
} else if (numdstRects == 1) {
// Single destination rect provided - get it:
PsychCopyRect(targetRect, &(dstRects[0]));
} else {
// No destination rect provided: Center the current sourceRect in the current
// target window and use that as destination:
PsychCopyRect(tempRect, target->clientrect);
PsychCenterRectInRect(sourceRect, tempRect, targetRect);
}
// Skip this texture if targetRect is an empty rect:
if (IsPsychRectEmpty(targetRect)) continue;
if (numAngles > 1) rotationAngle = rotationAngles[i];
if (numFilterModes > 1) filterMode = filterModes[i];
if (numAlphas > 1) globalAlpha = globalAlphas[i];
// Disable alpha if modulateColor active:
if (nc > 0) globalAlpha = DBL_MAX;
// Pass auxParameters for current primitive in the auxShaderParams field.
target->auxShaderParamsCount = numAuxComponents;
if (numAuxParams > 0) {
if (numAuxParams == 1) {
target->auxShaderParams = auxParameters;
}
else {
target->auxShaderParams = &(auxParameters[i * numAuxComponents]);
}
}
else {
target->auxShaderParams = NULL;
}
// Multiple modulateColors provided?
if (nc > 1) {
// Yes. Set it up as current vertex color: We submit to internal currentColor for
// shader based color processing and via glColorXXX() for fixed pipe processing:
if (mc==3) {
if (colors) {
// RGB double:
glColor3dv(&(colors[i*3]));
target->currentColor[0]=colors[i*3 + 0];
target->currentColor[1]=colors[i*3 + 1];
target->currentColor[2]=colors[i*3 + 2];
target->currentColor[3]=1.0;
}
else {
// RGB uint8:
glColor3ubv(&(bytecolors[i*3]));
target->currentColor[0]=((double) bytecolors[i*3 + 0] / 255.0);
target->currentColor[1]=((double) bytecolors[i*3 + 1] / 255.0);
target->currentColor[2]=((double) bytecolors[i*3 + 2] / 255.0);
target->currentColor[3]=1.0;
}
}
else {
if (colors) {
// RGBA double:
glColor4dv(&(colors[i*4]));
target->currentColor[0]=colors[i*4 + 0];
target->currentColor[1]=colors[i*4 + 1];
target->currentColor[2]=colors[i*4 + 2];
target->currentColor[3]=colors[i*4 + 3];
}
else {
// RGBA uint8:
glColor4ubv(&(bytecolors[i*4]));
target->currentColor[0]=((double) bytecolors[i*4 + 0] / 255.0);
target->currentColor[1]=((double) bytecolors[i*4 + 1] / 255.0);
target->currentColor[2]=((double) bytecolors[i*4 + 2] / 255.0);
target->currentColor[3]=((double) bytecolors[i*4 + 3] / 255.0);
}
}
}
// Ok, everything assigned. Check parameters:
if (filterMode<0 || filterMode>3) {
PsychErrorExitMsg(PsychError_user, "filterMode needs to be 0 for nearest neighbour filter, or 1 for bilinear filter, or 2 for mipmapped filter or 3 for mipmapped-linear filter.");
}
// Set rotation mode flag for texture matrix rotation if secialFlags is set accordingly:
if (specialFlags & kPsychUseTextureMatrixForRotation) source->specialflags|=kPsychUseTextureMatrixForRotation;
if (specialFlags & kPsychDontDoRotation) source->specialflags|=kPsychDontDoRotation;
// Perform blit operation for i'th texture, either with or without an override texture shader applied:
if (textureShader > -1) {
backupShader = source->textureFilterShader;
source->textureFilterShader = -1 * textureShader;
PsychBlitTextureToDisplay(source, target, sourceRect, targetRect, rotationAngle, filterMode, globalAlpha);
source->textureFilterShader = backupShader;
}
else {
PsychBlitTextureToDisplay(source, target, sourceRect, targetRect, rotationAngle, filterMode, globalAlpha);
}
// Reset rotation mode flag:
source->specialflags &= ~(kPsychUseTextureMatrixForRotation | kPsychDontDoRotation);
// Next one...
}
target->auxShaderParams = NULL;
target->auxShaderParamsCount = 0;
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(target);
return(PsychError_none);
}