void cFrameBufferFBO::BindRenderBuffer() { if ( mDepthBuffer ) { GLint curRB; glGetIntegerv( GL_RENDERBUFFER_BINDING, &curRB ); mLastRB = (Int32)curRB; glBindRenderbufferEXT( GL_RENDERBUFFER, mDepthBuffer ); } }
bool RenderTextureImplFBO::create(unsigned int width, unsigned int height, unsigned int textureId, bool depthBuffer) { // Create the context m_context = new Context; // Create the framebuffer object GLuint frameBuffer = 0; glCheck(glGenFramebuffersEXT(1, &frameBuffer)); m_frameBuffer = static_cast<unsigned int>(frameBuffer); if (!m_frameBuffer) { err() << "Impossible to create render texture (failed to create the frame buffer object)" << std::endl; return false; } glCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_frameBuffer)); // Create the depth buffer if requested if (depthBuffer || sfExt::StencilBufferEnabled) { GLuint depth = 0; glCheck(glGenRenderbuffersEXT(1, &depth)); m_depthBuffer = static_cast<unsigned int>(depth); if (!m_depthBuffer) { err() << "Impossible to create render texture (failed to create the attached depth buffer)" << std::endl; return false; } glCheck(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthBuffer)); if(sfExt::StencilBufferEnabled) { err() << "Creating FBO with stencil" << std::endl; glCheck(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, width, height)); glCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer)); glCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer)); } else { glCheck(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height)); glCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer)); } } // Link the texture to the frame buffer glCheck(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textureId, 0)); // A final check, just to be sure... if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { glCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0)); err() << "Impossible to create render texture (failed to link the target texture to the frame buffer)" << std::endl; return false; } return true; }
void HeadlessView::resize(const uint16_t width, const uint16_t height, const float pixelRatio) { dimensions = { width, height, pixelRatio }; clearBuffers(); const unsigned int w = dimensions.width * dimensions.pixelRatio; const unsigned int h = dimensions.height * dimensions.pixelRatio; // Create depth/stencil buffer MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil)); MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0)); MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboColor)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor)); MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0)); MBGL_CHECK_ERROR(glGenFramebuffersEXT(1, &fbo)); MBGL_CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo)); MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor)); MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil)); GLenum status = MBGL_CHECK_ERROR(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { std::stringstream error("Couldn't create framebuffer: "); switch (status) { case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: (error << "incomplete attachment.\n"); break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: error << "incomplete missing attachment.\n"; break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: error << "incomplete dimensions.\n"; break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: error << "incomplete formats.\n"; break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: error << "incomplete draw buffer.\n"; break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: error << "incomplete read buffer.\n"; break; case GL_FRAMEBUFFER_UNSUPPORTED: error << "unsupported.\n"; break; default: error << "other\n"; break; } throw std::runtime_error(error.str()); } }
void EJCanvasContextScreen::present() { glViewport(0, 0, viewportWidth, viewportHeight); #ifdef _WINDOWS glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0 ); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0 ); #else glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0 ); glBindRenderbufferOES(GL_RENDERBUFFER_OES, 0 ); #endif // [self flushBuffers]; EJCanvasContext::flushBuffers(); if( msaaEnabled ) { #ifdef _WINDOWS //Bind the MSAA and View frameBuffers and resolve glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, msaaFrameBuffer); glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, viewFrameBuffer); //glResolveMultisampleFramebufferAPPLE(); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, viewRenderBuffer); // [[EJApp instance].glContext presentRenderbuffer:GL_RENDERBUFFER]; // EJApp::instance()->glContext->presentRenderbuffer(GL_RENDERBUFFER_OES); // presentRenderbuffer(GL_RENDERBUFFER_OES); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, msaaFrameBuffer); #else //Bind the MSAA and View frameBuffers and resolve glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer); glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFrameBuffer); // glResolveMultisampleFramebufferAPPLE(); glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderBuffer); // [[EJApp instance].glContext presentRenderbuffer:GL_RENDERBUFFER]; // EJApp::instance()->glContext->presentRenderbuffer(GL_RENDERBUFFER_OES); // presentRenderbuffer(GL_RENDERBUFFER_OES); glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer); #endif } else { } }
void RE_InitFBOs() { GLenum DrawBuffers[1]; GLenum status; GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT }; glConfig.oculusFBL = 0; glConfig.oculusFBR = 0; glGenFramebuffersEXT(1, &glConfig.oculusFBL); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, glConfig.oculusFBL); // The depth buffer glGenRenderbuffers(1, &glConfig.oculusDepthRenderBufferLeft); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, glConfig.oculusDepthRenderBufferLeft); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, glConfig.vidWidth, glConfig.vidHeight); glGenTextures(1, &glConfig.oculusRenderTargetLeft); glBindTexture(GL_TEXTURE_2D, glConfig.oculusRenderTargetLeft); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Empty Image glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glGenerateMipmapEXT(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, glConfig.oculusRenderTargetLeft, 0); glGenTextures(1, &glConfig.oculusRenderTargetRight); glBindTexture(GL_TEXTURE_2D, glConfig.oculusRenderTargetRight); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Empty Image glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glGenerateMipmapEXT(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, glConfig.oculusRenderTargetRight, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, glConfig.oculusDepthRenderBufferLeft); //glDrawBuffers(2, (GLenum*)buffers); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) exit(1); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind the FBO for now }
void say_rbo_make_current(GLuint rbo) { say_context *context = say_context_current(); if (context != say_rbo_last_context || rbo != say_current_rbo) { say_current_rbo = rbo; say_rbo_last_context = context; glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo); } }
void R_BindNullFBO(void) { Ren_LogComment("--- R_BindNullFBO ---\n"); if (glState.currentFBO && glConfig2.framebufferObjectAvailable) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glState.currentFBO = NULL; } }
bool InitResourceOpenGL(void) { if ( glGenFramebuffersEXT==NULL ) { printf("Could not create frame buffer object\n"); return false; } // 投影矩陣 g_projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFOV, 1.0f, 0.1f, 100.0f); // 設定視角轉換矩陣 glMatrixMode(GL_PROJECTION); glLoadMatrixf( (float *) &g_projection_matrix); glMatrixMode(GL_MODELVIEW); glEnable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); // 開啟一個framebuffer object glGenFramebuffersEXT(1, &g_framebuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_framebuffer); // 配罝一塊貼圖空間給framebuffer object繪圖使用 { glGenTextures(1, &g_texture); glBindTexture(GL_TEXTURE_2D, g_texture); // 設定filter glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 宣告貼圖大小及格式 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); // framebuffer的RGBA繪圖 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, g_texture, 0); } // 配置zbuffer給framebuffer object使用 { glGenRenderbuffersEXT(1, &g_depthbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_depthbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, 512, 512); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, g_depthbuffer); } // 檢查framebuffer object有沒有配置成功 GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if ( status!=GL_FRAMEBUFFER_COMPLETE_EXT ) { return false; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return true; }
void CRenderTarget::addDepthRenderBuffer(void) { /** Attachement d'un render buffer pour la profondeur */ m_bDepthRenderBuffer = true; glGenRenderbuffersEXT( 1, &m_uiDepthRenderBuffer ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_uiFrameBuffer ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_uiDepthRenderBuffer ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_uiWidth, m_uiHeight ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_uiDepthRenderBuffer ); bindDefaultTarget(); }
void EJCanvasContext::create() { #ifdef _WINDOWS if( msaaEnabled ) { glGenFramebuffersEXT(1, &msaaFrameBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, msaaFrameBuffer); glGenRenderbuffersEXT(1, &msaaRenderBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, msaaRenderBuffer); //glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER, msaaSamples, GL_RGBA8, bufferWidth, bufferHeight); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, msaaRenderBuffer); } glGenFramebuffersEXT(1, &viewFrameBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, viewFrameBuffer); glGenRenderbuffersEXT(1, &viewRenderBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, viewRenderBuffer); #else if( msaaEnabled ) { glGenFramebuffersOES(1, &msaaFrameBuffer); glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer); glGenRenderbuffersOES(1, &msaaRenderBuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, msaaRenderBuffer); //glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER_OES, msaaSamples, GL_RGBA8_OES, bufferWidth, bufferHeight); glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, msaaRenderBuffer); } glGenFramebuffersOES(1, &viewFrameBuffer); glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFrameBuffer); glGenRenderbuffersOES(1, &viewRenderBuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderBuffer); #endif }
void display_reset(int samples, bool vsync) { int interval = vsync ? 1 : 0; if (enigma::is_ext_swapcontrol_supported()) { wglSwapIntervalEXT(interval); } GLint fbo; glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fbo); GLuint ColorBufferID, DepthBufferID; // Cleanup the multi-sampler fbo if turning off multi-sampling if (samples == 0) { if (enigma::msaa_fbo != 0) { glDeleteFramebuffers(1, &enigma::msaa_fbo); enigma::msaa_fbo = 0; } return; } //TODO: Change the code below to fix this to size properly to views // If we don't already have a multi-sample fbo then create one if (enigma::msaa_fbo == 0) { glGenFramebuffersEXT(1, &enigma::msaa_fbo); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, enigma::msaa_fbo); // Now make a multi-sample color buffer glGenRenderbuffersEXT(1, &ColorBufferID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, ColorBufferID); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_RGBA8, window_get_region_width_scaled(), window_get_region_height_scaled()); // We also need a depth buffer glGenRenderbuffersEXT(1, &DepthBufferID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DepthBufferID); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_DEPTH_COMPONENT24, window_get_region_width_scaled(), window_get_region_height_scaled()); // Attach the render buffers to the multi-sampler fbo glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, ColorBufferID); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, DepthBufferID); }
void InitFBO() { glGenTextures(1, &fb_tex); glBindTexture(GL_TEXTURE_2D, fb_tex); 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_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); printf("\tframebuffer size: %dx%d\n", g_Width, g_Height); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fb_tex, 0); glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); GLenum status; status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); break; default: printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); exit(1); break; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); }
void HeadlessView::resizeFramebuffer() { const unsigned int w = dimensions[0] * pixelRatio; const unsigned int h = dimensions[1] * pixelRatio; // Create depth/stencil buffer MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil)); MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0)); MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboColor)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor)); MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h)); MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0)); MBGL_CHECK_ERROR(glGenFramebuffersEXT(1, &fbo)); MBGL_CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo)); MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor)); MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil)); GLenum status = MBGL_CHECK_ERROR(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { std::string error("Couldn't create framebuffer: "); switch (status) { case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: (error += "incomplete attachment"); break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: error += "incomplete missing attachment"; break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: error += "incomplete dimensions"; break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: error += "incomplete formats"; break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: error += "incomplete draw buffer"; break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: error += "incomplete read buffer"; break; case GL_FRAMEBUFFER_UNSUPPORTED: error += "unsupported"; break; default: error += "other"; break; } throw std::runtime_error(error); } MBGL_CHECK_ERROR(glViewport(0, 0, w, h)); }
void RenderBuffer::init(const QSize& size, uint internal_format, int numSamp) { if (m_obj != -1) destroy(); glGenRenderbuffersEXT(1, &m_obj); Q_ASSERT(!glIsRenderbufferEXT(m_obj)); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_obj); Q_ASSERT(glIsRenderbufferEXT(m_obj)); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, numSamp, internal_format, size.width(), size.height()); mglCheckErrors("renderBuf"); }
void LLMultisampleBuffer::allocateDepth() { glGenRenderbuffersEXT(1, (GLuint* ) &mDepth); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth); if (mStencil) { glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH24_STENCIL8_EXT, mResX, mResY); } else { glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH_COMPONENT16_ARB, mResX, mResY); } }
void GL_RenderBuffer::createRenderBuffer( RenderBufferType bufferComponents ) { // Render buffers are just objects which are used to support // offscreen rendering, often for sections of the framebuffer which // don’t have a texture format associated with them. if( !checkSize() ) return; GLuint renderBuffer; glGenRenderbuffersEXT(1, &renderBuffer); CheckLastErrorGL( "Could not generate renderbuffer object" ); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderBuffer); CheckLastErrorGL( "Could not bind renderbuffer object" ); bind(); if( BitwiseAnd(bufferComponents, RenderBufferType::Depth) ) { createRenderBufferStorage(renderBuffer, GL_DEPTH_COMPONENT, GL_DEPTH_ATTACHMENT_EXT); } if( BitwiseAnd(bufferComponents, RenderBufferType::Color) ) { createRenderBufferStorage(renderBuffer, GL_RGBA, GL_COLOR_ATTACHMENT0_EXT); colorAttach = true; } if( BitwiseAnd(bufferComponents, RenderBufferType::Stencil) ) { createRenderBufferStorage(renderBuffer, GL_STENCIL_INDEX, GL_STENCIL_ATTACHMENT_EXT); colorAttach = true; } glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); unbind(); }
void FrameBufferObject::initDepthBuffer() { if(depthTexture) { glBindTexture(GL_TEXTURE_2D, depthTextureID); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); glTexImage2D(GL_TEXTURE_2D, 0, _fboParams.depthInternalformat , width, height, 0,GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glBindTexture(GL_TEXTURE_2D, 0); } else { glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthTextureID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); } }
void initfbo(GLvoid) { // Setup our FBO glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); // Create the render buffer for depth glGenRenderbuffersEXT(1, &depthBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); // 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); glGenTextures(1, &img2); glBindTexture(GL_TEXTURE_2D, img2); 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); // The following 3 lines enable mipmap filtering and generate the mipmap data so rendering works // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // glGenerateMipmapEXT(GL_TEXTURE_2D); // 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); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, img2, 0); // Attach the depth render buffer to the FBO as it's depth attachment glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) exit(1); GLenum buffers[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT}; glDrawBuffers(2, buffers); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind the FBO for now }
void create() { w = width; h = height; r = (float)w / (float)h; //RGBA8 2D texture, 24 bit depth texture, 256x256 std::cout << "gen tex" << std::endl; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); // in order to set parameters 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_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //NULL means reserve texture memory, but texels are undefined glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); // allocate data //------------------------- std::cout << "gen fbo" << std::endl; glGenFramebuffersEXT(1, &fb); std::cout << "fbo = " << fb << std::endl; glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); //Attach 2D texture to this FBO std::cout << "attach tex to fbo" << std::endl; glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); //------------------------- std::cout << "gen rbo" << std::endl; glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, w, h); //------------------------- //Attach depth buffer to FBO std::cout << "attach depth buffer to fbo" << std::endl; glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); //------------------------- //Does the GPU support current FBO configuration? GLenum status; status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: std::cout << "good" << std::endl; break; default: //HANDLE_THE_ERROR; std::cout << "error" << std::endl; abort(); } }
void intro_do( long time ) { //--- update parameters ----------------------------------------- const float t = 0.001f*(float)time; // camera position fparams[ 0] = 2.0f; fparams[ 1] = 0.0f; fparams[ 2] = 2.0f; // camera target fparams[ 4] = 0.0f; fparams[ 5] = 0.0f; fparams[ 6] = 0.0f; // sphere fparams[ 8] = 0.0f; fparams[ 9] = 0.0f; fparams[10] = 0.0f; fparams[11] = 1.0f; /* // Gen renderbuffer glGenRenderbuffersEXT(1, &frontb); // Bind renderbuffer glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, frontb); // Init as a depth buffer glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, XRES, YRES); // Attach to the FBO for depth glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, frontb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);*/ //--- render ----------------------------------------- static float reso[4]; reso[0] = XRES; reso[1] = YRES; reso[2] = XRES; reso[3] = YRES; oglUseProgram( pid ); glUniform1fARB( oglGetUniformLocation( pid, "iGlobalTime" ), t ); oglUniform4fv( oglGetUniformLocation( pid, "iResolution" ), 1, reso ); oglUniform4fv( oglGetUniformLocation( pid, "fpar" ), 4, fparams ); glRects( -1, -1, 1, 1 ); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); }
/* ============ R_BindNullFBO ============ */ void R_BindNullFBO( void ) { if ( r_logFile->integer ) { GLimp_LogComment( "--- R_BindNullFBO ---\n" ); } if ( glState.currentFBO ) { glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 ); glState.currentFBO = NULL; } }
int FrameBuffer::_new(lua_State *l) { int width = luaL_checkinteger(l, -2); int height = luaL_checkinteger(l, -1); FrameBuffer *self = newuserdata(FrameBuffer); cout << "creating framebuffer " << $(width) << $(height) << endl; self->width = width; self->height = height; self->tex = Image::from_bytes(NULL, width, height); glGenFramebuffersEXT(1, &self->fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, self->fbo); // attach texture to fbo glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, self->tex.texid, 0); // create depth buffer glGenRenderbuffersEXT(1, &self->depth); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, self->depth); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); // attach depth to fbo glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, self->depth); // see if it worked GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { cout << "Failed to setup framebuffer" << endl; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); if (luaL_newmetatable(l, "FrameBuffer")) { lua_newtable(l); // the index table setfunction("bind", FrameBuffer::_bind); setfunction("release", FrameBuffer::_release); setfunction("render", FrameBuffer::_render); setfunction("bindTex", FrameBuffer::_bindTex); setfunction("draw", FrameBuffer::_draw); lua_setfield(l, -2, "__index"); } lua_setmetatable(l, -2); return 1; }
bool RfxRenderTarget::Setup(int pass) { if (!GLEW_EXT_framebuffer_object) { qWarning("FBO not supported!"); return false; } if (initOk) return true; glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); // if "use viewport dimensions" at this point we have a gl context if (vportdim) { GLfloat dims[4]; glGetFloatv(GL_VIEWPORT, dims); width = (int)dims[2]; height = (int)dims[3]; } // depth buffer glGenRenderbuffersEXT(1, &depTex); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depTex); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depTex); // color buffer glGenTextures(1, &colTex); glBindTexture(GL_TEXTURE_2D, colTex); 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, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colTex, 0); // set texture state based on the first uniform that will use RT QList<int> k = passStates.keys(); for (int i = 0; i < k.size(); ++i) { if (k.at(i) > pass) { foreach (RfxState *s, passStates.value(i)) s->SetEnvironment(GL_TEXTURE_2D); } } initOk = (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return initOk; }
void initFramebuffer( void ) { //renderbuffer glGenRenderbuffersEXT( 1, &rbName ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, rbName ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, TEX_WIDTH, TEX_HEIGHT ); //framebuffer glGenFramebuffersEXT( 1, &fbName ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fbName ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rbName ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); }
static void Reshape( int width, int height ) { float ar = (float) width / (float) height; glViewport( 0, 0, width, height ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glFrustum( -ar, ar, -1.0, 1.0, 5.0, 25.0 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef( 0.0, 0.0, -15.0 ); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, ColorRb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, width, height); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DepthRb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); Width = width; Height = height; }
void EJCanvasContext::createStencilBufferOnce() { if( stencilBuffer ) { return; } #ifdef _WINDOWS glGenRenderbuffersEXT(1, &stencilBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, stencilBuffer); if( msaaEnabled ) { glRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaaSamples, GL_DEPTH24_STENCIL8, bufferWidth, bufferHeight); } else { glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, bufferWidth, bufferHeight); } glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, stencilBuffer); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, stencilBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, msaaEnabled ? msaaRenderBuffer : viewRenderBuffer ); #else glGenRenderbuffersOES(1, &stencilBuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, stencilBuffer); if( msaaEnabled ) { //glRenderbufferStorageMultisampleAPPLE(GL_RENDERBUFFER, msaaSamples, GL_DEPTH24_STENCIL8_OES, bufferWidth, bufferHeight); } else { glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH24_STENCIL8_OES, bufferWidth, bufferHeight); } glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilBuffer); glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilBuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, msaaEnabled ? msaaRenderBuffer : viewRenderBuffer ); #endif glClear(GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }
virtual GLenum createFBO(GLuint& framebuffer, GLuint& depth_stencil, GLuint& img, int width, int height) { GLint current_fbo; glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, ¤t_fbo); // create framebuffer glGenFramebuffersEXT(1, &framebuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer); // create stencil buffer glGenRenderbuffersEXT(1, &depth_stencil); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_stencil); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_stencil); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_stencil); // generate texture save target glGenTextures(1, &img); bindTexture(img); 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_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); bindTexture(0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img, 0); // check status GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); // unbind framebuffer glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (GLuint)current_fbo); return status; }
PIGLIT_GL_TEST_CONFIG_END void piglit_init(int argc, char **argv) { glGetIntegerv(GL_MAX_SAMPLES_EXT, &numSamples); glGenFramebuffersEXT(1, &framebuffer); glGenRenderbuffersEXT(1, &renderbuffer); glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer); glBindRenderbufferEXT(GL_RENDERBUFFER, renderbuffer); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, numSamples, GL_RGBA, WIDTH, HEIGHT); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer); glEnable (GL_MULTISAMPLE); }
framebufferobject::framebufferobject(class texture& attachedtex, bool withdepthbuffer) : id(0), depthbuf_id(0), mytex(attachedtex), bound(false) { if (!supported()) throw std::runtime_error("frame buffer objects are not supported!"); // create and bind depth buffer if requested if (withdepthbuffer) { glGenRenderbuffersEXT(1, &depthbuf_id); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuf_id); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, mytex.get_gl_width(), mytex.get_gl_height()); } // create and bind FBO glGenFramebuffersEXT(1, &id); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, mytex.get_opengl_name(), 0); // attach depth buffer if requested if (withdepthbuffer) { glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuf_id); } GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) { destroy(); log_warning( "FBO initialization check failed: " << init_failure_reason( status ) ); throw std::runtime_error("FBO initialization check failed"); } // unbind for now glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); }
void intiFB(int w, int h) { ////////framebuffer init if(glIsTexture(tex)) { glDeleteRenderbuffers(1, &depth_rb); glDeleteTextures(1,&tex); glDeleteFramebuffers(1, &fb); } glEnable(GL_DEPTH_TEST); glClearColor(0.0, 0.0, 0.0, 1.0); glGenFramebuffers(1, &fb); glGenTextures(1, &tex); glGenRenderbuffers(1, &depth_rb); glBindFramebuffer(GL_FRAMEBUFFER, fb); // init texture glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texWidth, texHeight, 0, GL_RGBA, GL_FLOAT, NULL); GET_GLERROR(NULL); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0); GET_GLERROR(0); // initialize depth renderbuffer glBindRenderbufferEXT(GL_RENDERBUFFER, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, texWidth, texHeight); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_rb); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0); GET_GLERROR(0); CheckFramebufferStatus(); glBindFramebufferEXT(GL_FRAMEBUFFER, 0); }