/** * Deattaches an attachment from the framebuffer */ void FBO::Unattach(const GLenum attachment) { GLuint target; glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, (GLint*)&target); if (target==GL_RENDERBUFFER_EXT) { //! check if the RBO was created via FBO::CreateRenderBuffer() GLuint id; glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, (GLint*)&id); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, 0); for (std::vector<GLuint>::iterator ri=myRBOs.begin(); ri!=myRBOs.end(); ++ri) { if (*ri == id) { glDeleteRenderbuffersEXT(1, &(*ri)); myRBOs.erase(ri); break; } } } else { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachment, GL_TEXTURE_2D, 0, 0); } }
void FrameBuffer::attachRBufDepth() { glGenRenderbuffersEXT(1, (GLuint*)&m_shadowRBuf); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_shadowRBuf); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_sizeX, m_sizeY); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_shadowRBuf); }
/* Test binding and return error code */ static GLenum test_binding(GLboolean bindRenderbuffer) { GLuint fb, rb; GLenum err; glGenFramebuffersEXT(1, &fb); glGenRenderbuffersEXT(1, &rb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); err = glGetError(); if (err != GL_NO_ERROR) return PIGLIT_FAIL; /* enabling this should prevent the GL error */ if (bindRenderbuffer) glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, rb); err = glGetError(); return err; }
void fbo_destroy(FBO *fbo) { if (fbo->native_fbo) { delete fbo; return; } if (gl_extensions.ARB_framebuffer_object || gl_extensions.IsGLES) { glBindFramebuffer(GL_FRAMEBUFFER, fbo->handle); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); glDeleteFramebuffers(1, &fbo->handle); glDeleteRenderbuffers(1, &fbo->z_stencil_buffer); glDeleteRenderbuffers(1, &fbo->z_buffer); glDeleteRenderbuffers(1, &fbo->stencil_buffer); } else if (gl_extensions.EXT_framebuffer_object) { #ifndef USING_GLES2 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo->handle); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glDeleteFramebuffersEXT(1, &fbo->handle); glDeleteRenderbuffersEXT(1, &fbo->z_stencil_buffer); #endif } currentDrawHandle_ = 0; currentReadHandle_ = 0; glDeleteTextures(1, &fbo->color_texture); delete fbo; }
void initFBO(GLuint& fbo, GLuint& depthBuffer, GLuint& img) { // Setup our FBO width = gw; height = gh; glGenFramebuffersEXT(1, &fbo); // bind for set up glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); // Now setup a texture to render to glGenTextures(1, &img); glBindTexture(GL_TEXTURE_2D, img); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // And attach it to the FBO so we can render to it glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img, 0); // Create the render buffer for depth glGenRenderbuffersEXT(1, &depthBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_DEPTH_COMPONENT, width, height); // Attach the depth render buffer to FBO as it's depth attachment glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer); // Checking GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) exit(1); // Unbind the FBO for now glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
void GL_GenerateFBO(GLuint texId, GLuint *fboId, int w, int h) { GLuint cRboId; Console_Printf(" Generate FBO %dx%d. ", w, h); glGenFramebuffersEXT(1, fboId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, *fboId); if(vid_multisample.integer && gl_ext_framebuffer_multisample.integer) { Console_Printf("(MSAA) "); glGenRenderbuffersEXT(1, &cRboId); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cRboId); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, vid_multisample.integer, GL_RGBA, w, h); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, cRboId); } glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texId, 0); //glDrawBuffer(GL_FRONT); //glReadBuffer(GL_FRONT); GL_CheckFBOStatus(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
void testApp::initFrameBuffer() { initFrameBufferDepthBuffer(); // Initialize our frame buffer depth buffer initFrameBufferTexture(); // Initialize our frame buffer texture glGenFramebuffersEXT(1, &mFBOID); // Generate one frame buffer and store the ID in fbo glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBOID); // Bind our frame buffer glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, mTextureID, 0); // Attach the texture mFBOID to the color buffer in our frame buffer glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepthID); // Attach the depth buffer mDepthID to our frame buffer GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); // Check that status of our generated frame buffer if (status != GL_FRAMEBUFFER_COMPLETE_EXT) // If the frame buffer does not report back as complete { std::cout << "Couldn't create frame buffer" << std::endl; // Output an error to the console //exit(0); // Exit the application } else { cout << "BITCHIN " <<endl; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind our frame buffer #ifdef SYPHON thisWillNeverWork.bAllocated = true; thisWillNeverWork.textureID = mTextureID; thisWillNeverWork.width = 640; thisWillNeverWork.height = 480; thisWillNeverWork.bFlipTexture = true; thisWillNeverWork.textureTarget = GL_TEXTURE_2D; #endif }
/* ================ R_CreateFBODepthBuffer ================ */ void R_CreateFBODepthBuffer( FBO_t *fbo, int format ) { qboolean absent; if ( format != GL_DEPTH_COMPONENT && format != GL_DEPTH_COMPONENT16 && format != GL_DEPTH_COMPONENT24 && format != GL_DEPTH_COMPONENT32_ARB ) { ri.Printf( PRINT_WARNING, "R_CreateFBODepthBuffer: format %i is not depth-renderable\n", format ); return; } fbo->depthFormat = format; absent = fbo->depthBuffer == 0; if ( absent ) { glGenRenderbuffersEXT( 1, &fbo->depthBuffer ); } glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, fbo->depthBuffer ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, fbo->depthFormat, fbo->width, fbo->height ); if ( absent ) { glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->depthBuffer ); } GL_CheckErrors(); }
GLuint* OpenGL::RayCaster::CreateRenderBuffer(const int WINDOW_SIZE_X, const int WINDOW_SIZE_Y) { INFO("Creating the rendering buffer"); GLuint* renderBuffer_ID = MEM_ALLOC_1D_GENERIC(GLuint, 1); // Generate the render buffer ID glGenRenderbuffersEXT(1, renderBuffer_ID); // Bnd the render buffer glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, *renderBuffer_ID); // Setup the parameters of the render buffer glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_SIZE_X, WINDOW_SIZE_Y); // Attche the render buffer to the frame buffer glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, *renderBuffer_ID); // Unbind the render buffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); INFO("1") return renderBuffer_ID; }
void testApp::generateFrameBuffers(){ // create a framebuffer object, you need to delete them when program exits. glGenFramebuffersEXT(1, &fboId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId); // create a renderbuffer object to store depth info // NOTE: A depth renderable image should be attached the FBO for depth test. // If we don't attach a depth renderable image to the FBO, then // the rendering output will be corrupted because of missing depth test. // If you also need stencil test for your rendering, then you must // attach additional image to the stencil attachement point, too. glGenRenderbuffersEXT(1, &rboId); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rboId); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, ofGetWidth(), ofGetHeight()); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); // attach a texture to FBO color attachement point glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colourTextureId, 0); // attach a renderbuffer to depth attachment point glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboId); //@ disable color buffer if you don't attach any color buffer image, //@ for example, rendering depth buffer only to a texture. //@ Otherwise, glCheckFramebufferStatusEXT will not be complete. //glDrawBuffer(GL_NONE); //glReadBuffer(GL_NONE); // check FBO status printFramebufferInfo(); bool status = checkFramebufferStatus(); if(!status) fboUsed = false; }
/* ================ R_CreateFBOStencilBuffer ================ */ void R_CreateFBOStencilBuffer(FBO_t * fbo, int format) { #if defined(USE_D3D10) // TODO #else qboolean absent; if(format != GL_STENCIL_INDEX && //format != GL_STENCIL_INDEX_EXT && format != GL_STENCIL_INDEX1_EXT && format != GL_STENCIL_INDEX4_EXT && format != GL_STENCIL_INDEX8_EXT && format != GL_STENCIL_INDEX16_EXT) { ri.Printf(PRINT_WARNING, "R_CreateFBOStencilBuffer: format %i is not stencil-renderable\n", format); return; } fbo->stencilFormat = format; absent = fbo->stencilBuffer == 0; if(absent) glGenRenderbuffersEXT(1, &fbo->stencilBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fbo->stencilBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, fbo->stencilFormat, fbo->width, fbo->height); GL_CheckErrors(); if(absent) glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->stencilBuffer); GL_CheckErrors(); #endif }
static void Init(void) { fprintf(stderr, "GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); fprintf(stderr, "GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); fprintf(stderr, "GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); fflush(stderr); if (!glutExtensionSupported("GL_EXT_framebuffer_object")) { printf("GL_EXT_framebuffer_object not found!\n"); exit(0); } glGenFramebuffersEXT(1, &MyFB); glGenRenderbuffersEXT(1, &MyRB); { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, MyRB); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_RENDERBUFFER_EXT, MyRB); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, Width, Height); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } glClearColor(0.0, 0.0, 1.0, 0.0); }
void fbo::initDepthBuffer(void){ glGenRenderbuffersEXT(1, &depth_id); // Generate one render buffer and store the ID in fbo_depth glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_id); // Bind the fbo_depth render buffer glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); // Set the render buffer storage to be a depth component, with a width and height of the window glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_id); // Set the render buffer of this buffer to the depth buffer glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); // Unbind the render buffer }
GLuint RenderTarget::initRenderToTexture() { #ifdef USE_FBO if (this->useFBO==1) { this->renderToTexture=1; GLuint fb2, depth_rb2; glGenFramebuffersEXT(1, &fb2); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fb2 ); glGenRenderbuffersEXT(1, &depth_rb2); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, depth_rb2 ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, this->texsize,this->texsize ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb2 ); this->fbuffer[1] = fb2; this->depthb[1]= depth_rb2; glGenTextures(1, &this->textureID[2]); glBindTexture(GL_TEXTURE_2D, this->textureID[2]); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, this->textureID[2], 0 ); return this->textureID[2]; } #endif return -1; }
void StimulusDisplay::allocateBufferStorage(int contextIndex) { if (!(glewIsSupported("GL_EXT_framebuffer_object") && glewIsSupported("GL_EXT_framebuffer_blit"))) { throw SimpleException("renderer does not support required OpenGL framebuffer extensions"); } glGenFramebuffersEXT(1, &framebuffers[contextIndex]); glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, framebuffers[contextIndex]); glGenRenderbuffersEXT(1, &renderbuffers[contextIndex]); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffers[contextIndex]); getCurrentViewportSize(bufferWidths[contextIndex], bufferHeights[contextIndex]); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, bufferWidths[contextIndex], bufferHeights[contextIndex]); glFramebufferRenderbufferEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, renderbuffers[contextIndex]); GLenum status = glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT); if (GL_FRAMEBUFFER_COMPLETE_EXT != status) { throw SimpleException("OpenGL framebuffer setup failed"); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); }
static void create_fbo(void) { GLuint rb[32]; int i; glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); glGenRenderbuffersEXT(max_ds_buffers, rb); check_error(__LINE__); for (i = 0; i < max_ds_buffers; i++) { glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb[i]); check_error(__LINE__); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0 + i, GL_RENDERBUFFER_EXT, rb[i]); check_error(__LINE__); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA, piglit_width, piglit_height); check_error(__LINE__); } }
void PCSSShadowMap::reInit(DrawEnv *pEnv) { #ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP Int32 width = _shadowVP->getPixelWidth(); Int32 height = _shadowVP->getPixelHeight(); Window *win = pEnv->getWindow(); win->validateGLObject(_colorMap->getGLId(), pEnv); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, win->getGLObjectId(_colorMap->getGLId()), 0); win->validateGLObject(_shadowFactorMap->getGLId(), pEnv); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, win->getGLObjectId(_shadowFactorMap->getGLId()), 0); //Initialize Depth Renderbuffer glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _rb_depth); if(_useNPOTTextures) glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24_ARB, _shadowVP->getPixelWidth(), _shadowVP->getPixelHeight()); else glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24_ARB, _widthHeightPOT, _widthHeightPOT); //Attach Renderbuffer to Framebuffer depth Buffer glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT , _rb_depth); #endif }
void LLRenderTarget::release() { if (mDepth) { if (mStencil) { glDeleteRenderbuffersEXT(1, (GLuint*) &mDepth); stop_glerror(); } else { LLImageGL::deleteTextures(1, &mDepth); stop_glerror(); } mDepth = 0; } else if (mUseDepth && mFBO) { //detach shared depth buffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO); if (mStencil) { //attached as a renderbuffer glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); mStencil = false; } else { //attached as a texture glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), 0, 0); } mUseDepth = false; } if (mFBO) { glDeleteFramebuffersEXT(1, (GLuint *) &mFBO); mFBO = 0; } if (mTex.size() > 0) { LLImageGL::deleteTextures(mTex.size(), &mTex[0]); mTex.clear(); } mSampleBuffer = NULL; sBoundTarget = NULL; }
void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage, bool use_fbo) { stop_glerror(); mResX = resx; mResY = resy; mStencil = stencil; mUsage = usage; mUseDepth = depth; release(); if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject) { if (depth) { stop_glerror(); allocateDepth(); stop_glerror(); } glGenFramebuffersEXT(1, (GLuint *) &mFBO); if (mDepth) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO); if (mStencil) { glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth); stop_glerror(); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth); stop_glerror(); } else { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0); stop_glerror(); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } stop_glerror(); } addColorAttachment(color_fmt); }
void framebuffer_obj_t::detach_renderbuffer(GLenum attachment_point) { glFramebufferRenderbufferEXT( GL_FRAMEBUFFER, attachment_point, GL_RENDERBUFFER, 0); check_error(); }
void FBO::generateColorOnly(bool tex16f) { destroy(); //Generate the texture glGenTextures(1, &m_iTexId); glBindTexture(m_eTextureType, m_iTexId); glTexParameteri (m_eTextureType, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri (m_eTextureType, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(m_eTextureType, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(m_eTextureType, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(m_eTextureType, GL_GENERATE_MIPMAP, GL_TRUE); ///We need six Face for cube, or one for 2D if (m_eTextureType == GL_TEXTURE_CUBE_MAP) { glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X , 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Y , 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Z , 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_X , 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Y , 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Z , 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); } else{ if(!tex16f) glTexImage2D(m_eTextureType, 0, GL_RGBA8, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); else glTexImage2D(m_eTextureType, 0, GL_RGB16F_ARB, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); } glBindTexture(m_eTextureType, 0); //Generate renderbuffer glGenRenderbuffersEXT(1, &m_iRenderId); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_iRenderId); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_iWidth, m_iHeight); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); //Generating ID glGenFramebuffersEXT(1, &m_iId); activate(); // attach a texture to FBO color attachement point glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, m_eTextureType, m_iTexId, 0); // attach a renderbuffer to depth attachment point glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_iRenderId); desactivate(); //Check FBO status if(!checkFramebufferStatus()) std::cerr<<"ERROR : FBO creation Fail "<<std::endl; //Color Only m_iType = 0; }
void initDisplay() { for(int i=0;i<10;i++) { flag_dessin[i] = false; } flag_dessin[0] = true; instantPrec = glutGet(GLUT_ELAPSED_TIME); sepiaColor[0] = 0.2; sepiaColor[1] = 0.1; sepiaColor[2] = 0; /// INITIALISATION DES TEXTURES ... initTexture(); /// INITIALISATION DES SHADERS ... if(!RTShaders::areShadersSupported(true)) { std::cerr<<"[In initDisplay] : Shaders are not supported..."<<std::endl; exit(5); } testShader = RTShaders::loadShader("./shaders/tstshader.vert","./shaders/tstshader.frag",true); /// INITIALISATION DES FBOS ... if (USE_FBO) { if(initFBO()==false){ cerr<<"FBO not supported ! Exiting"<<endl; exit(5); } glGenFramebuffersEXT(1, &fbo_handler); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fbo_handler); GLuint depth_rb; glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_DEPTH_COMPONENT,image_base->tailu,image_base->tailv); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, image_base->indbind , 0); checkFramebufferStatus(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0); } /// INITIALISATION CLASSIQUE OPENGL ... glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glShadeModel( GL_SMOOTH ); glEnable(GL_TEXTURE_2D); glDisable(GL_BLEND); glDisable(GL_FOG); CHECK_GL; glUseProgramObjectARB(0); }
static enum piglit_result test(void) { GLuint fbo, rb; int i; GLboolean pass = GL_TRUE; GLenum err; glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); check_error(__LINE__); glGenRenderbuffersEXT(1, &rb); check_error(__LINE__); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, rb); check_error(__LINE__); /* clear out any errors */ while (glGetError()) ; /* test formats that should be accepted */ for (i = 0; i < ARRAY_SIZE(Formats); i++) { if (!HaveExtension[Formats[i].extension]) continue; glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, Formats[i].format, piglit_width, piglit_height); err = glGetError(); if (err) { printf("%s: glRenderbufferStorage failed for format 0x%x\n", TestName, Formats[i].format); pass = GL_FALSE; } printf("0x%04X: %s\n", Formats[i].format, glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT ? "complete" : "incomplete"); } /* test formats that should fail */ for (i = 0; i < ARRAY_SIZE(InvalidFormats); i++) { glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, InvalidFormats[i], piglit_width, piglit_height); err = glGetError(); if (err != GL_INVALID_ENUM) { printf("%s: glRenderbufferStorage erroneously accepted format 0x%x\n", TestName, InvalidFormats[i]); pass = GL_FALSE; } } return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void framebuffer_obj_t::attach_renderbuffer( const renderbuffer_obj_t& obj, GLenum attachment_point) { glFramebufferRenderbufferEXT( GL_FRAMEBUFFER, attachment_point, GL_RENDERBUFFER, obj.id()); check_error(); }
/*------------------------------------------------------------------------- -------------------------------------------------------------------------*/ bool FilterBox::Initialize(int w, int h) { bufw = w; bufh = h; // // FBO // glGenFramebuffersEXT(2, fb); glGenTextures(2, textureID); glGenRenderbuffersEXT(1, &depth_rb); initRT(0, w, h); initRT(1, w, h); // // initialize depth renderbuffer // glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, w, h); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); CheckFramebufferStatus(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // // CGFX things // cgContext = cgCreateContext(); cgGLRegisterStates(cgContext); std::string resolved_path; cgEffect = cgCreateEffectFromFile(cgContext, "data/shaders/FilterBox.cgfx", NULL); if(!cgEffect) { exit(0); const char * pszErrors = NULL; fprintf(stderr, "CgFx Parse error : %s", pszErrors); const char *listing = cgGetLastListing(cgContext); bValid = false; return false; } cgTechnique = cgGetNamedTechnique(cgEffect, "Filter"); cgPassFilterH = cgGetNamedPass(cgTechnique, "verticalPass"); cgPassFilterV = cgGetNamedPass(cgTechnique, "horizontalPass"); cgPassBlend = cgGetNamedPass(cgTechnique, "drawFinal"); cgBlendFactor = cgGetNamedEffectParameter(cgEffect, "blendFactor"); cgGlowFactor = cgGetNamedEffectParameter(cgEffect, "glowFactor"); srcSampler = cgGetNamedEffectParameter(cgEffect, "srcSampler"); tempSampler = cgGetNamedEffectParameter(cgEffect, "tempSampler"); finalSampler = cgGetNamedEffectParameter(cgEffect, "finalSampler"); verticalDir = cgGetNamedEffectParameter(cgEffect, "verticalDir"); horizontalDir = cgGetNamedEffectParameter(cgEffect, "horizontalDir"); cgGLSetParameter2f(verticalDir, 0,1.0f/(float)h); cgGLSetParameter2f(horizontalDir, 1.0f/(float)w, 0); bValid = true; return true; }
/** * Creates and attaches a RBO */ void FBO::CreateRenderBuffer(const GLenum attachment, const GLenum format, const GLsizei width, const GLsizei height) { GLuint rbo; glGenRenderbuffersEXT(1, &rbo); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, format, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, rbo); myRBOs.push_back(rbo); }
void Canvas::Impl::setup(int w, int h) { if (width != 0 || height != 0 || w <= 0 || h <= 0) return; width = w; height = h; // Setup texture glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); if (GLEW_ARB_framebuffer_object) { // Setup renderBuffer glGenRenderbuffers(1, &renderBuffer); glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, width, height); // Setup frameBuffer glGenFramebuffers(1, &frameBuffer); glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, renderBuffer); glBindFramebuffer(GL_FRAMEBUFFER, 0); } else { // Setup renderBuffer glGenRenderbuffersEXT(1, &renderBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, width, height); // Setup frameBuffer glGenFramebuffersEXT(1, &frameBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texture, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderBuffer); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } }
int FrameBufferObject::CreateImageObject(unsigned int width, unsigned int height, int depthbuffer_enabled, int stencilbuffer_enabled) { //Create the Image object ImageObject new_object; new_object.width = width; new_object.height = height; new_object.texture_type = NULL; new_object.texture_id = NULL; new_object.depth_id = NULL; new_object.stencil_id = NULL; //First determine if the requested dimensions are power of two if (ispoweroftwo(width) && ispoweroftwo(height)) { new_object.texture_type = GL_TEXTURE_2D; //Power of two enum LogSystem()->ReportMessage("Using GL_TEXTURE_2D"); } else { new_object.texture_type = 0x84F5; //Non power of two enum } glGenTextures(1, &new_object.texture_id); new_object.texture_id; glBindTexture(GL_TEXTURE_RECTANGLE_ARB, new_object.texture_id); new_object.texture_type = GL_TEXTURE_RECTANGLE_ARB; glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);//GL_CLAMP glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);//GL_CLAMP glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); //Create the depth RenderBuffer if requested if (depthbuffer_enabled != 0) { glGenRenderbuffersEXT(1, &new_object.depth_id); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, new_object.depth_id); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, new_object.width, new_object.height); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer_id); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, new_object.depth_id); } //glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0); //Push this new image object onto the list image_objects.push_back(new_object); //Return the 'index' for the id of this texture return (int)image_objects.size() - 1; }
//////////////////////////////////////////////////////// // renderGL // ///////////////////////////////////////////////////////// void gemcubeframebuffer :: render(GemState *state) { gem::GLStack*stacks=NULL; if(state) { state->get(GemState::_GL_STACKS, stacks); } if(!m_width || !m_height) { error("width and height must be present!"); } glActiveTexture(GL_TEXTURE0_ARB + m_texunit); if (m_wantinit) { initFBO(); } // store the window viewport dimensions so we can reset them, // and set the viewport to the dimensions of our texture glGetIntegerv(GL_VIEWPORT, m_vp); glGetFloatv( GL_COLOR_CLEAR_VALUE, m_color ); glBindTexture( m_texTarget, 0 ); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_frameBufferIndex); // Bind the texture to the frame buffer. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, /*m_texTarget*/ GL_TEXTURE_CUBE_MAP_POSITIVE_X + m_face, m_offScreenID, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBufferIndex); // debug yellow color // glClearColor( 1,1,0,0); glClearColor( m_FBOcolor[0], m_FBOcolor[1], m_FBOcolor[2], m_FBOcolor[3] ); // Clear the buffers and reset the model view matrix. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // We need a one-to-one mapping of pixels to texels in order to // ensure every element of our texture is processed. By setting our // viewport to the dimensions of our destination texture and drawing // a screen-sized quad (see below), we ensure that every pixel of our // texel is generated and processed in the fragment program. glViewport(0,0, m_width, m_height); if(stacks) { stacks->push(gem::GLStack::PROJECTION); } glLoadIdentity(); glFrustum( m_perspect[0], m_perspect[1], m_perspect[2], m_perspect[3], m_perspect[4], m_perspect[5]); if(stacks) { stacks->push(gem::GLStack::MODELVIEW); } glLoadIdentity(); }
Map::Map() { mMutex = CreateMutex(NULL, FALSE, "LeftMapMutex"); mCollidableMutex = CreateMutex(NULL, FALSE, "LeftMapCollidableMutex"); mSpot = new GLParticle(1280, 1280, 1.0f, 1.0f, 1.0f, 1.0f, glpLight); mMinimap.clear(); mMinimapZoom = 20.0f; mMinimapParticle = new GLParticle(5, 5, 0.0f, 1.0f, 0.0f, 1.0f, glpSolid); mMinimapMask.resize(1); genCirclePolygon(GLvector2f(0.0f, 0.0f), 2000.0f, mMinimapMask[0], false, 64); mGaussShader = new GLGaussShader(); assert(mGaussShader->initialized()); glGenTextures(1, &mFramebufferTexture); glBindTexture(GL_TEXTURE_2D, mFramebufferTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, GL_SCREEN_IWIDTH, GL_SCREEN_IHEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenFramebuffersEXT(1, &mFramebuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFramebuffer); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, mFramebufferTexture, 0); glGenRenderbuffersEXT(1, &mRenderbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mRenderbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, GL_SCREEN_IWIDTH, GL_SCREEN_IHEIGHT); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mRenderbuffer); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); assert(status == GL_FRAMEBUFFER_COMPLETE_EXT); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindTexture(GL_TEXTURE_2D, 0); mFramebufferList = glGenLists(1); glNewList(mFramebufferList, GL_COMPILE); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glBindTexture(GL_TEXTURE_2D, mFramebufferTexture); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex3f(0.0f, 0.0f, 0.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(GL_SCREEN_FWIDTH, 0.0f, 0.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(GL_SCREEN_FWIDTH, GL_SCREEN_FHEIGHT, 0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(0.0f, GL_SCREEN_FHEIGHT, 0.0f); glEnd(); glBindTexture(GL_TEXTURE_2D, 0); glEndList(); mCallback = 0; mUpdate = true; generate(); }