void testApp::generateScreenSpaceFrameBuffers() { #ifdef DEBUG cout << "Creating First Framebuffer" <<endl; #endif glGenFramebuffersEXT(1, &fboId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthTextureId, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colourTextureId, 0); #ifdef DEBUG printFramebufferInfo(); #endif bool status = checkFramebufferStatus(); if(!status) fboUsed = false; #ifdef DEBUG cout << "Creating Second Framebuffer" <<endl; #endif glGenFramebuffersEXT(1, &fboIdFinal); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboIdFinal); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, finalTextureId, 0); glGenRenderbuffersEXT(1, &rboIdFinal); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rboIdFinal); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, ofGetWidth(), ofGetHeight()); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboIdFinal); #ifdef DEBUG printFramebufferInfo(); #endif status = checkFramebufferStatus(); if(!status) fboUsed = false; glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
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 LuaRBOs::CreateRBO(lua_State* L) { RBO rbo; rbo.Init(); rbo.xsize = (GLsizei)luaL_checknumber(L, 1); rbo.ysize = (GLsizei)luaL_checknumber(L, 2); rbo.target = GL_RENDERBUFFER_EXT; rbo.format = GL_RGBA; const int table = 3; if (lua_istable(L, table)) { lua_getfield(L, table, "target"); if (lua_isnumber(L, -1)) { rbo.target = (GLenum)lua_tonumber(L, -1); } lua_pop(L, 1); lua_getfield(L, table, "format"); if (lua_isnumber(L, -1)) { rbo.format = (GLenum)lua_tonumber(L, -1); } lua_pop(L, 1); } glGenRenderbuffersEXT(1, &rbo.id); glBindRenderbufferEXT(rbo.target, rbo.id); // allocate the memory glRenderbufferStorageEXT(rbo.target, rbo.format, rbo.xsize, rbo.ysize); glBindRenderbufferEXT(rbo.target, 0); RBO* rboPtr = static_cast<RBO*>(lua_newuserdata(L, sizeof(RBO))); *rboPtr = rbo; luaL_getmetatable(L, "RBO"); lua_setmetatable(L, -2); if (rboPtr->id != 0) { CLuaHandle::GetActiveRBOs(L).rbos.insert(rboPtr); } return 1; }
FrameBufferObject::FrameBufferObject(int width, int height, bool useDepthBuffer) { if(!glewIsSupported("GL_EXT_framebuffer_object")) systemError("fbo not supported"); this->width=width; this->height=height; glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); depthbuffer=0; if(useDepthBuffer) { glGenRenderbuffersEXT(1, &depthbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer); /*GLuint depthTex; glGenTextures(1, &depthTex); glBindTexture(GL_TEXTURE_2D, depthTex); 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_DEPTH24_STENCIL8_EXT, width, height, 0, GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D, depthTex, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_STENCIL_ATTACHMENT_EXT,GL_TEXTURE_2D, depthTex, 0); */ } glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //necessary on nvidia! glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //necessary on nvidia! glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texture, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(GL_FRAMEBUFFER_COMPLETE_EXT!=status) systemError("framebuffer object not complete"); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0); }
void LLRenderTarget::allocateDepth() { if (mStencil) { //use render buffers where stencil buffers are in play glGenRenderbuffersEXT(1, (GLuint *) &mDepth); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, mResX, mResY); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); } else { LLImageGL::generateTextures(1, &mDepth); gGL.getTexUnit(0)->bindManual(mUsage, mDepth); U32 internal_type = LLTexUnit::getInternalType(mUsage); gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT); LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT32_ARB, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); } }
void FrameBufferObject::create(unsigned int _width, unsigned int _height, bool _withRenderBuffer) { clear(); glGenFramebuffersEXT(1, &frameBufferId_); assert(frameBufferId_ != 0); if(_withRenderBuffer) { glGenRenderbuffersEXT(1, &renderBufferId_); assert(renderBufferId_ != 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderBufferId_); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT32, _width, _height); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBufferId_); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderBufferId_); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } }
OpenGLRTTexture::OpenGLRTTexture(unsigned int _texture) : mTextureID(_texture), mWidth(0), mHeight(0), mFBOID(0), mRBOID(0) { int miplevel = 0; glBindTexture(GL_TEXTURE_2D, mTextureID); glGetTexLevelParameteriv(GL_TEXTURE_2D, miplevel, GL_TEXTURE_WIDTH, &mWidth); glGetTexLevelParameteriv(GL_TEXTURE_2D, miplevel, GL_TEXTURE_HEIGHT, &mHeight); glBindTexture(GL_TEXTURE_2D, 0); mRenderTargetInfo.maximumDepth = 1.0f; mRenderTargetInfo.hOffset = 0; mRenderTargetInfo.vOffset = 0; mRenderTargetInfo.aspectCoef = float(mHeight) / float(mWidth); mRenderTargetInfo.pixScaleX = 1.0f / float(mWidth); mRenderTargetInfo.pixScaleY = 1.0f / float(mHeight); // create a framebuffer object, you need to delete them when program exits. glGenFramebuffersEXT(1, &mFBOID); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBOID); // 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, &mRBOID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mRBOID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, mWidth, mHeight); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); // attach a texture to FBO color attachement point glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, mTextureID, 0); // attach a renderbuffer to depth attachment point glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mRBOID); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
void widgetEnableGLImpl(widget *self) { GLenum status; // Check if GL is already enabled if (self->openGLEnabled) { return; } // Generate an FBO id glGenFramebuffersEXT(1, &self->fboId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, self->fboId); // Generate a renderbuffer to server as a depth buffer glGenRenderbuffersEXT(1, &self->depthbufferId); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, self->depthbufferId); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, self->size.x, self->size.y); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); // Bind our drawing texture and initialise it glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self->textureId); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, self->size.x, self->size.y, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); // Attach the texture to the FBO glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, self->textureId, 0); // Attach the depthbuffer to the FBO glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, self->depthbufferId); // Ensure that the FBO was created successfully status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT); // Un-bind the FBO glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Rendering GL content to the widget is now enabled self->openGLEnabled = true; }
void initFramebuffer(void) { //renderbuffer object の生成 glGenRenderbuffersEXT( 1, &rbName ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, rbName ); //Z glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, TEX_WIDTH, TEX_HEIGHT ); //framebuffer object の生成 glGenFramebuffersEXT( 1, &fbName ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fbName ); //textureをframebuffer objectに結びつける glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texName, 0 ); //renderbufferをframebuffer objectに結びつける glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rbName ); //framebuffer object の無効化 glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); }
void cgtk::reset_fbo() { if(renderbuffer) glDeleteRenderbuffersEXT(1, &renderbuffer); if(final_image) glDeleteTexturesEXT(1, &final_image); if(backface_buffer) glDeleteTexturesEXT(1, &backface_buffer); if(framebuffer) glDeleteFramebuffersEXT(1, &framebuffer); // Create the to FBO's one for the backside of the volumecube and one for the finalimage rendering glGenFramebuffersEXT(1, &framebuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer); glGenTextures(1, &backface_buffer); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, backface_buffer); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,GL_RGBA16F_ARB, WINDOW_SIZE_W, WINDOW_SIZE_H, 0, GL_RGBA, GL_FLOAT, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, backface_buffer, 0); glGenTextures(1, &final_image); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, final_image); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,GL_RGBA16F_ARB, WINDOW_SIZE_W, WINDOW_SIZE_H, 0, GL_RGBA, GL_FLOAT, NULL); glGenRenderbuffersEXT(1, &renderbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_SIZE_W, WINDOW_SIZE_H); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderbuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
/* ================ R_CreateFBOColorBuffer Framebuffer must be bound ================ */ void R_CreateFBOColorBuffer( FBO_t *fbo, int format, int index ) { qboolean absent; if ( index < 0 || index >= glConfig2.maxColorAttachments ) { ri.Printf( PRINT_WARNING, "R_CreateFBOColorBuffer: invalid attachment index %i\n", index ); return; } #if 0 if ( format != GL_RGB && format != GL_RGBA && format != GL_RGB16F && format != GL_RGBA16F && format != GL_RGB32F_ARB && format != GL_RGBA32F_ARB ) { ri.Printf( PRINT_WARNING, "R_CreateFBOColorBuffer: format %i is not color-renderable\n", format ); //return; } #endif fbo->colorFormat = format; absent = fbo->colorBuffers[ index ] == 0; if ( absent ) { glGenRenderbuffersEXT( 1, &fbo->colorBuffers[ index ] ); } glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, fbo->colorBuffers[ index ] ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, format, fbo->width, fbo->height ); if ( absent ) { glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + index, GL_RENDERBUFFER_EXT, fbo->colorBuffers[ index ] ); } GL_CheckErrors(); }
bool RenderImageImplFBO::Create(unsigned int width, unsigned int height, unsigned int textureId, bool depthBuffer) { // Create the framebuffer object GLuint frameBuffer = 0; GLCheck(glGenFramebuffersEXT(1, &frameBuffer)); myFrameBuffer = static_cast<unsigned int>(frameBuffer); if (!myFrameBuffer) { Err() << "Impossible to create render image (failed to create the frame buffer object)" << std::endl; return false; } GLCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, myFrameBuffer)); // Create the depth buffer if requested if (depthBuffer) { GLuint depth = 0; GLCheck(glGenRenderbuffersEXT(1, &depth)); myDepthBuffer = static_cast<unsigned int>(depth); if (!myDepthBuffer) { Err() << "Impossible to create render image (failed to create the attached depth buffer)" << std::endl; return false; } GLCheck(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, myDepthBuffer)); GLCheck(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height)); GLCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, myDepthBuffer)); } // Link the image 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 image (failed to link the target image to the frame buffer)" << std::endl; return false; } return true; }
void piglit_init(int argc, char **argv) { GLint max_samples; GLuint rb, fb; GLenum status; bool pass = true; piglit_require_extension("GL_EXT_framebuffer_multisample"); glGetIntegerv(GL_MAX_SAMPLES, &max_samples); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER, fb); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER, rb); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, max_samples, GL_RGBA, 1, 1); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rb); glDrawBuffer(GL_COLOR_ATTACHMENT0); glReadBuffer(GL_COLOR_ATTACHMENT0); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "FBO incomplete\n"); piglit_report_result(PIGLIT_FAIL); } /* Finally, the actual test! */ glCopyPixels(0, 0, 1, 1, GL_COLOR); if (!piglit_check_gl_error(GL_INVALID_OPERATION)) piglit_report_result(PIGLIT_FAIL); glDeleteRenderbuffersEXT(1, &rb); glDeleteFramebuffersEXT(1, &fb); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
/** * Tests for support of the EXT_framebuffer_object * extension, and generates a framebuffer if supported */ FBO::FBO(int requires, int w, int h) { this->requires = requires; frameBuffer = 0; if (!GLEW_EXT_framebuffer_object) return; assert(glGenFramebuffersEXT != 0); glGenFramebuffersEXT(1,&frameBuffer); select(); // Is a depth renderbuffer needed? if ((requires & FBO_NEED_DEPTH) && !(requires & FBO_NEED_DEPTH_TEXTURE)) { glGenRenderbuffersEXT(1, &depthRenderBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthRenderBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, w, h); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthRenderBuffer); } deselect(); }
void LLMultisampleBuffer::addColorAttachment(U32 color_fmt) { if (color_fmt == 0) { return; } U32 offset = mTex.size(); if (offset >= 4 || (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))) { llerrs << "Too many color attachments!" << llendl; } U32 tex; glGenRenderbuffersEXT(1, &tex); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, tex); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, color_fmt, mResX, mResY); stop_glerror(); if (mFBO) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+offset, GL_RENDERBUFFER_EXT, tex); stop_glerror(); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch (status) { case GL_FRAMEBUFFER_COMPLETE_EXT: break; default: llerrs << "WTF? " << std::hex << status << llendl; break; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } mTex.push_back(tex); }
void piglit_init(int argc, char **argv) { GLint max_samples, samples, prev_rb_samples = 0; GLuint rb; bool pass = true; piglit_require_extension("GL_EXT_framebuffer_multisample"); glGetIntegerv(GL_MAX_SAMPLES, &max_samples); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER, rb); printf("%10s %10s\n", "requested", "result"); for (samples = 0; samples <= max_samples; samples++) { GLint rb_samples; glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, samples, GL_RGBA, 1, 1); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &rb_samples); if ((rb_samples < prev_rb_samples) || (samples == 0 && rb_samples != 0) || (samples > 0 && rb_samples < samples)) { fprintf(stderr, "%10d %10d (ERROR)\n", samples, rb_samples); pass = false; } else { printf("%10d %10d\n", samples, rb_samples); } prev_rb_samples = rb_samples; } glDeleteRenderbuffersEXT(1, &rb); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
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); }
char GLSLBase::initializeFBO(std::string& log) { 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, frameBufferWidth(), frameBufferHeight()); // Now setup the first texture to render to glGenTextures(1, &img); glBindTexture(GL_TEXTURE_2D, img); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, frameBufferWidth(), frameBufferHeight(), 0, GL_RGBA, GL_FLOAT, 0); 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); // 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) { log += "cannot create frame buffer object"; fHasFBO = 0; return 0; } // Unbind the FBO for now glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); fHasFBO = 1; fPixels = new float[frameBufferWidth() * frameBufferHeight() * 4]; return 1; }
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 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, &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) { glGenFramebuffers(1, &enigma::msaa_fbo); } glBindFramebuffer(GL_FRAMEBUFFER, enigma::msaa_fbo); // Now make a multi-sample color buffer glGenRenderbuffers(1, &ColorBufferID); glBindRenderbuffer(GL_RENDERBUFFER, ColorBufferID); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, 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, DepthBufferID); glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, GL_DEPTH_COMPONENT24, window_get_region_width_scaled(), window_get_region_height_scaled()); // Attach the render buffers to the multi-sampler fbo glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, ColorBufferID); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, DepthBufferID); }
static void initialize_backg_texture(void) { if (settings.static_settings->use_fbo) { glGenFramebuffersEXT(1, &fbo_id); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id); glGenRenderbuffersEXT(1, &depth_rb_id); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb_id); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, backg_texture_size(), backg_texture_size()); } glGenTextures(1, &backg_texture_id); glBindTexture(GL_TEXTURE_2D, backg_texture_id); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, backg_texture_size(), backg_texture_size(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); if (settings.static_settings->use_fbo) { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, backg_texture_id, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb_id); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } }
glue_static Framebuffer *glueCubemap(int res) { Framebuffer *fbo; int x; fbo=malloc(sizeof(Framebuffer)); fbo->xres=res; fbo->yres=res; glGenFramebuffersEXT(1, &fbo->num); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo->num); // depth glGenRenderbuffersEXT(1, &fbo->depthbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fbo->depthbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, res, res); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->depthbuffer); // colortexture glGenTextures(1, &fbo->texnum); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, fbo->texnum); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST); for (x=0; x<6; x++) { glTexImage2D(cubesides[x], 0, GL_RGBA, res, res, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, cubesides[x], fbo->texnum, 0); } checkfbostatus(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); fbo->texnum2=0; glueLoading(); return fbo; }
bool FBO::createDepthOnly(int width, int height) { glGenFramebuffersEXT(1, &fbo_id); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id); glGenRenderbuffersEXT(1, &renderbuffer_color); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer_color); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, renderbuffer_color); depth_texture = new Texture(width, height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth_texture->texture_id, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { std::cout << "Error: Framebuffer object is not completed" << std::endl; return false; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return true; }
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; }
/* ================ R_CreateFBOPackedDepthStencilBuffer ================ */ void R_CreateFBOPackedDepthStencilBuffer( FBO_t *fbo, int format ) { #if defined( USE_D3D10 ) // TODO #else qboolean absent; if ( format != GL_DEPTH_STENCIL_EXT && format != GL_DEPTH24_STENCIL8_EXT ) { ri.Printf( PRINT_WARNING, "R_CreateFBOPackedDepthStencilBuffer: format %i is not depth-stencil-renderable\n", format ); return; } fbo->packedDepthStencilFormat = format; absent = fbo->packedDepthStencilBuffer == 0; if ( absent ) { glGenRenderbuffersEXT( 1, &fbo->packedDepthStencilBuffer ); } glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, fbo->packedDepthStencilBuffer ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, fbo->packedDepthStencilFormat, fbo->width, fbo->height ); GL_CheckErrors(); if ( absent ) { glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->packedDepthStencilBuffer ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->packedDepthStencilBuffer ); } GL_CheckErrors(); #endif }
bool RenderToTexture::create(int width, int height, bool generate_mipmaps) { this->width = width; this->height = height; this->generate_mipmaps = generate_mipmaps; glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); glGenRenderbuffersEXT(1, &depthbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer); glGenTextures(1, &texture_id); glBindTexture(GL_TEXTURE_2D, texture_id); 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); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ( generate_mipmaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR) ); if (generate_mipmaps) glGenerateMipmapEXT(GL_TEXTURE_2D); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texture_id, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { std::cout << "Error: Framebuffer object is not completed" << std::endl; return false; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return true; }
/** Try a certain packed depth/stencil format, and return the status. @returns true if this combo is supported false if this combo is not supported */ bool GLFBOManager::_tryPackedFormat(GLenum packedFormat) { GLuint packedRB = 0; bool failed = false; // flag on GL errors /// Generate renderbuffer glGenRenderbuffersEXT(1, &packedRB); /// Bind it to FBO glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, packedRB); /// Allocate storage for buffer glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, packedFormat, PROBE_SIZE, PROBE_SIZE); glGetError(); // NV hack /// Attach depth glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, packedRB); if(glGetError() != GL_NO_ERROR) // NV hack failed = true; /// Attach stencil glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, packedRB); if(glGetError() != GL_NO_ERROR) // NV hack failed = true; GLuint status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); /// Detach and destroy glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); glDeleteRenderbuffersEXT(1, &packedRB); return status == GL_FRAMEBUFFER_COMPLETE_EXT && !failed; }
void initgl (unsigned char * dataSet, int imageWidth, int imageHeight, int imageDepth){ glEnable(GL_CULL_FACE); glClearColor(ClearColor[1],ClearColor[2],ClearColor[3], 0); Load3DTextures(intensityTexture3D); // CreateColorTable(LUTIndex, TransferTexture); // Load the vertex and fragment raycasting programs glslprogram = initShaderWithFile("rc.vert", "rc.frag"); // Create the to FBO's one for the backside of the volumecube and one for the finalimage rendering glGenFramebuffersEXT(1, &frameBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,frameBuffer); glGenTextures(1, &backFaceBuffer); glBindTexture(GL_TEXTURE_2D, backFaceBuffer); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA16F_ARB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, backFaceBuffer, 0); glGenTextures(1, &finalImage); glBindTexture(GL_TEXTURE_2D, finalImage); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA16F_ARB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL); glGenRenderbuffersEXT(1, &renderBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_WIDTH, WINDOW_HEIGHT); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
//the initial version will not support depth buffers. bool RenderTargetGL::create(const GraphicsDevice* gdev, u32 createFlags, u32 width, u32 height, const SamplerState& initSamplerState) { m_width = width; m_height = height; //create the color texture m_texture->createRGBA(gdev, width, height, NULL, initSamplerState); //create the frame buffer object glGenFramebuffersEXT(1, &m_glID); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_glID); //attach 2D texture to this FBO glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture->m_glID, 0); //create the depth buffer if requested if (createFlags & RT_CREATE_DEPTH) { //create the depth buffer (render buffer, not texture) glGenRenderbuffersEXT(1, &m_glDepthID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_glDepthID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); //attach depth buffer to FBO glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_glDepthID); } //Does the GPU support current FBO configuration? GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { LOG( LOG_ERROR, "RenderTargetGL create failed! Status = %x", status ); return false; } return true; }