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 }