int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
{
GLsizei n;
GLboolean retval;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLboolean answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
n = *(GLsizei *)(pc + 0);
__GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
retval =
glAreTexturesResident(
*(GLsizei *)(pc + 0),
(GLuint *)(pc + 4),
(GLboolean *) answer
);
__GLX_PUT_RETVAL(retval);
__GLX_BEGIN_REPLY(n);
__GLX_SEND_HEADER();
__GLX_SEND_BYTE_ARRAY(n);
return Success;
}
int IsTextureResident(GLuint handle)
{
GLboolean b;
if (glAreTexturesResident(1, &handle, &b))
return 1;
return 0;
}
PsychError SCREENPreloadTextures(void)
{
PsychWindowRecordType *windowRecord, *texwin;
psych_bool isArgThere;
int *texhandles;
PsychWindowRecordType **windowRecordArray;
int i, n, numWindows, myhandle;
double *success;
psych_bool* residency;
GLuint* texids;
GLboolean* texresident;
psych_bool failed = false;
GLclampf maxprio = 1.0f;
GLenum target;
//all sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
//check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs
PsychErrorExit(PsychRequireNumInputArgs(1)); //The minimum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(2)); //The maximum number of outputs
//get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Get optional texids vector:
isArgThere = PsychIsArgPresent(PsychArgIn, 2);
PsychAllocInIntegerListArg(2, FALSE, &n, &texhandles);
if (n < 1) isArgThere=FALSE;
// Enable this windowRecords framebuffer as current drawingtarget:
PsychSetDrawingTarget(windowRecord);
// Disable shader:
PsychSetShader(windowRecord, 0);
glDisable(GL_TEXTURE_2D);
// Fetch global texturing mode:
target=PsychGetTextureTarget(windowRecord);
glEnable(target);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(0, 0, 0, 0);
// Setup identity modelview matrix:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
PsychCreateVolatileWindowRecordPointerList(&numWindows, &windowRecordArray);
// Process vector of all texids for all requested textures:
if (!isArgThere) {
// No handles provided: In this case, we preload all textures:
n=0;
for(i=0; i<numWindows; i++) {
if (windowRecordArray[i]->windowType==kPsychTexture) {
n++;
// Prioritize this texture:
glPrioritizeTextures(1, (GLuint*) &(windowRecordArray[i]->textureNumber), &maxprio);
// Bind this texture:
glBindTexture(target, windowRecordArray[i]->textureNumber);
// Render a single textured point, thereby enforcing a texture upload:
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2i(10,10);
glTexCoord2f(0,1); glVertex2i(10,11);
glTexCoord2f(1,1); glVertex2i(11,11);
glTexCoord2f(1,0); glVertex2i(11,10);
glEnd();
}
}
texids = (GLuint*) PsychMallocTemp(sizeof(GLuint) * n);
texresident = (GLboolean*) PsychMallocTemp(sizeof(GLboolean) * n);
n=0;
for(i=0; i<numWindows; i++) {
if (windowRecordArray[i]->windowType==kPsychTexture) {
texids[n] = (GLuint) windowRecordArray[i]->textureNumber;
n++;
}
}
}
else {
// Vector with texture handles provided: Just preload them.
texids = (GLuint*) PsychMallocTemp(sizeof(GLuint) * n);
texresident = (GLboolean*) PsychMallocTemp(sizeof(GLboolean) * n);
myhandle=0;
for (i=0; i<n; i++) {
myhandle = texhandles[i];
texwin = NULL;
if (IsWindowIndex(myhandle)) FindWindowRecord(myhandle, &texwin);
if (texwin && texwin->windowType==kPsychTexture) {
// Prioritize this texture:
glPrioritizeTextures(1, (GLuint*) &(texwin->textureNumber), &maxprio);
// Bind this texture:
glBindTexture(target, texwin->textureNumber);
// Render a single textured point, thereby enforcing a texture upload:
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2i(10,10);
glTexCoord2f(0,1); glVertex2i(10,11);
glTexCoord2f(1,1); glVertex2i(11,11);
glTexCoord2f(1,0); glVertex2i(11,10);
glEnd();
texids[i] = (GLuint) texwin->textureNumber;
}
else {
// This handle is invalid or at least no texture handle:
printf("PTB-ERROR! Screen('PreloadTextures'): Entry %i of texture handle vector (handle %i) is not a texture handle!\n",
i, myhandle);
failed = true;
}
}
}
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// Disable texture engine:
glDisable(GL_TEXTURE_2D);
glDisable(target);
// Wait for prefetch completion:
glFinish();
// We don't need these anymore:
PsychDestroyVolatileWindowRecordPointerList(windowRecordArray);
if (failed) {
PsychErrorExitMsg(PsychError_user, "At least one texture handle in texids-vector was invalid! Aborted.");
}
// Query residency state of all preloaded textures:
success = NULL;
PsychAllocOutDoubleArg(1, FALSE, &success);
*success = (double) glAreTexturesResident(n, texids, texresident);
// Sync pipe again, just to be safe...
glFinish();
// Count them and copy them into output vector:
PsychAllocOutBooleanMatArg(2, FALSE, n, 1, 1, &residency);
for (i=0; i<n; i++) {
residency[i] = (psych_bool) ((*success) ? TRUE : texresident[i]);
}
PsychTestForGLErrors();
// Done. Our PsychMallocTemp'ed arrays will be auto-released...
return(PsychError_none);
}
static void Display( void )
{
GLfloat spacing = WinWidth / Columns;
GLfloat size = spacing * 0.4;
GLint i;
/* test residency */
if (0)
{
GLboolean b;
GLint i, resident;
b = glAreTexturesResident(NumTextures, TextureID, TextureResidency);
if (b) {
printf("all resident\n");
}
else {
resident = 0;
for (i = 0; i < NumTextures; i++) {
if (TextureResidency[i]) {
resident++;
}
}
printf("%d of %d texture resident\n", resident, NumTextures);
}
}
/* render the textured quads */
glClear( GL_COLOR_BUFFER_BIT );
for (i = 0; i < NumTextures; i++) {
GLint row = i / Columns;
GLint col = i % Columns;
GLfloat x = col * spacing + spacing * 0.5;
GLfloat y = row * spacing + spacing * 0.5;
GLfloat maxDim = (TextureWidth[i] > TextureHeight[i])
? TextureWidth[i] : TextureHeight[i];
GLfloat w = TextureWidth[i] / maxDim;
GLfloat h = TextureHeight[i] / maxDim;
glPushMatrix();
glTranslatef(x, y, 0.0);
glRotatef(Zrot, 0, 0, 1);
glScalef(size, size, 1);
glBindTexture(GL_TEXTURE_2D, TextureID[i]);
glBegin(GL_POLYGON);
#if 0
glTexCoord2f(0, 0); glVertex2f(-1, -1);
glTexCoord2f(1, 0); glVertex2f( 1, -1);
glTexCoord2f(1, 1); glVertex2f( 1, 1);
glTexCoord2f(0, 1); glVertex2f(-1, 1);
#else
glTexCoord2f(0, 0); glVertex2f(-w, -h);
glTexCoord2f(1, 0); glVertex2f( w, -h);
glTexCoord2f(1, 1); glVertex2f( w, h);
glTexCoord2f(0, 1); glVertex2f(-w, h);
#endif
glEnd();
glPopMatrix();
}
glutSwapBuffers();
}
GLboolean glAreTexturesResidentEXT(GLsizei n, const GLuint *textures,
GLboolean *residences)
{
return glAreTexturesResident(n, textures, residences);
}
//===========================================================================
void cTexture2D::render()
{
if (m_image.initialized() == 0) return;
// Only check residency in memory if we weren't going to
// update the texture anyway...
if (m_updateTextureFlag == 0)
{
GLboolean texture_is_resident;
glAreTexturesResident(1, &m_textureID, &texture_is_resident);
if (texture_is_resident == false)
{
m_updateTextureFlag = true;
}
}
// is texture being rendered for the first time?
if (m_updateTextureFlag)
{
update();
m_updateTextureFlag = false;
}
// enable texturing
glEnable(GL_TEXTURE_2D);
// enable or disable spherical mapping
if (m_useSphericalMapping)
{
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
}
else
{
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
// Sets the wrap parameter for texture coordinate s to either
// GL_CLAMP or GL_REPEAT.
glTexParameteri(GL_TEXTURE_2D ,GL_TEXTURE_WRAP_S, m_wrapSmode);
glTexParameteri(GL_TEXTURE_2D ,GL_TEXTURE_WRAP_T, m_wrapTmode);
// Set the texture magnification function to either GL_NEAREST or GL_LINEAR.
glTexParameteri(GL_TEXTURE_2D ,GL_TEXTURE_MAG_FILTER, m_magnificationFunction);
// Set the texture minifying function to either GL_NEAREST or GL_LINEAR.
glTexParameteri(GL_TEXTURE_2D ,GL_TEXTURE_MIN_FILTER, m_minifyingFunction);
// set the environment mode (GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, m_environmentMode);
// make this the current texture
glBindTexture(GL_TEXTURE_2D, m_textureID);
// set the environmental color
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &m_color.pColor()[0]);
}
M(jboolean, glAreTexturesResident, jint n, jobject textures, jobject residences) {
return glAreTexturesResident(n, BUFF(GLuint, textures), BUFF(GLboolean, residences));
}
bool RGL::texIsResident(unsigned int id)
{
unsigned char res=false;
glAreTexturesResident( 1, &id, &res );
return (res!=0);
}
void
CvrTextureObject::activateTexture(const SoGLRenderAction * action) const
{
const GLuint texid = this->getGLTexture(action);
const unsigned short nrtexdims = this->getNrOfTextureDimensions();
const GLenum gltextypeenum = (nrtexdims == 2) ? GL_TEXTURE_2D : GL_TEXTURE_3D;
glEnable(gltextypeenum);
glBindTexture(gltextypeenum, texid);
#if CVR_DEBUG
if (cvr_debug_textureuse()) {
SoDebugError::postInfo("CvrTextureObject::activeTexture",
"glBindTexture(%s, %u) in GL context %u",
(gltextypeenum == GL_TEXTURE_2D) ? "GL_TEXTURE_2D" : "GL_TEXTURE_3D",
texid, action->getCacheContext());
}
#endif // debug
const GLenum interp = CvrGLInterpolationElement::get(action->getState());
glTexParameteri(gltextypeenum, GL_TEXTURE_MAG_FILTER, interp);
glTexParameteri(gltextypeenum, GL_TEXTURE_MIN_FILTER, interp);
assert(glGetError() == GL_NO_ERROR);
#if CVR_DEBUG && 0 // debug
// FIXME: glAreTexturesResident() is OpenGL 1.1 only. 20021119 mortene.
GLboolean residences[1];
GLboolean resident = glAreTexturesResident(1, &texid, residences);
if (!resident) {
SoDebugError::postWarning("Cvr2DTexSubPage::activateTexture",
"texture %d not resident", texid);
Cvr2DTexSubPage::detectedtextureswapping = TRUE;
}
// For reference, here's some information from Thomas Roell of Xi
// Graphics on glAreTexturesResident() from c.g.a.opengl:
//
// [...]
//
// With regards to glAreTexturesResident(), this is kind of
// tricky. This function returns which textures are currently
// resident is HW accessable memory (AGP, FB, TB). It does not
// return whether a set of textures could be made resident at a
// future point of time. A lot of OpenGL implementations (APPLE &
// XiGraphics for example) do cache a texture upon first use with
// 3D primitive. Hence unless you had used a texture before it
// will not be resident. N.b that usually operations like
// glBindTexture, glTex*Image and so on will not make a texture
// resident for such caching implementations.
//
// [...]
//
// Additional information from Ian D Romanick (IBM engineer doing
// Linux OpenGL work):
//
// [...]
//
// AreTexturesResident is basically worthless, IMO. All OpenGL
// rendering happens in a VERY high latency pipeline. When an
// application calls AreTexturesResident, the textures may all be
// resident at that time. However, there may already be
// primitives in the pipeline that will cause those textures to be
// removed from texturable memory before more primitives can be
// put in the pipe.
//
// [...]
//
// 20021201 mortene.
#endif // debug
}