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 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 }
bool FBO::CheckFramebufferStatus() { GLenum status; status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: return true; break; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" << std::endl; return false; break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_UNSUPPORTED_EXT" << std::endl; return false; break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" << std::endl; return false; break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" << std::endl; return false; break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" << std::endl; return false; break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" << std::endl; return false; break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: std::cerr << "FrameBuffer Status Error : GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" << std::endl; return false; break; default: std::cerr << "FrameBuffer Status Error : unknown error" << std::endl; return false; } }
static enum piglit_result test_clear(void) { GLuint cb; GLenum status; float green[3] = {0, 1, 0}; enum piglit_result res; /* Add a colorbuffer. */ glGenRenderbuffersEXT(1, &cb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, BUF_SIZE, BUF_SIZE); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, cb); glDrawBuffer(GL_COLOR_ATTACHMENT0); glReadBuffer(GL_COLOR_ATTACHMENT0); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { printf("FBO incomplete status 0x%X\n", status); piglit_report_result(PIGLIT_FAIL); /* RGBA8 must succeed. */ } glClearDepth(0.75); glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glColor3fv(green); glDepthFunc(GL_LEQUAL); piglit_draw_rect_z(0.499, -1, -1, 1, 2); /* 0.75 converted to clip space is 0.5. */ glDepthFunc(GL_GEQUAL); piglit_draw_rect_z(0.501, 0, -1, 1, 2); glColor3f(1, 1, 1); glDisable(GL_DEPTH_TEST); res = piglit_probe_rect_rgb(0, 0, BUF_SIZE, BUF_SIZE, green) ? PIGLIT_PASS : PIGLIT_FAIL; /* Display the colorbuffer. */ if (!piglit_automatic) { glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, piglit_winsys_fbo); glBlitFramebufferEXT(0, 0, BUF_SIZE, BUF_SIZE, 0, 0, BUF_SIZE, BUF_SIZE, GL_COLOR_BUFFER_BIT, GL_NEAREST); } glDeleteRenderbuffersEXT(1, &cb); return res; }
static int create_fbo(void) { GLuint tex, fb; GLenum status; int i, dim; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) { glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA, dim, dim, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); } assert(glGetError() == 0); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); assert(glGetError() == 0); status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "FBO incomplete\n"); goto done; } glViewport(0, 0, TEX_WIDTH, TEX_HEIGHT); piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE); glColor4fv(red); piglit_draw_rect(0, 0, TEX_WIDTH / 2, TEX_HEIGHT / 2); glColor4fv(green); piglit_draw_rect(TEX_WIDTH / 2, 0, TEX_WIDTH, TEX_HEIGHT / 2); glColor4fv(blue); piglit_draw_rect(0, TEX_HEIGHT / 2, TEX_WIDTH/2, TEX_HEIGHT); glColor4fv(white); piglit_draw_rect(TEX_WIDTH / 2, TEX_HEIGHT / 2, TEX_WIDTH, TEX_HEIGHT); glGenerateMipmapEXT(GL_TEXTURE_2D); done: glDeleteFramebuffersEXT(1, &fb); return tex; }
int GPU_framebuffer_texture_attach(GPUFrameBuffer *fb, GPUTexture *tex, char err_out[256]) { GLenum status; GLenum attachment; GLenum error; if (tex->depth) attachment = GL_DEPTH_ATTACHMENT_EXT; else attachment = GL_COLOR_ATTACHMENT0_EXT; glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb->object); GG.currentfb = fb->object; glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachment, tex->target, tex->bindcode, 0); error = glGetError(); if (error == GL_INVALID_OPERATION) { GPU_framebuffer_restore(); GPU_print_framebuffer_error(error, err_out); return 0; } if (tex->depth) { glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); } else { glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); } status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { GPU_framebuffer_restore(); GPU_print_framebuffer_error(status, err_out); return 0; } if (tex->depth) fb->depthtex = tex; else fb->colortex = tex; tex->fb= fb; return 1; }
//Generate the FBO the depth shader will write to void RenderEngine::generateShadowFBO() { GLenum FBOstatus; // Try to use a texture depth component glGenTextures(1, &depthTextureId); glBindTexture(GL_TEXTURE_2D, depthTextureId); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Remove artefact on the edges of the shadowmap glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); // No need to force GL_DEPTH_COMPONENT24, drivers usually give you the max precision if available glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, kShadowMapWidth, kShadowMapHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); glGenTextures(1,&colorTextureId); glBindTexture(GL_TEXTURE_2D, colorTextureId); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // Remove artifact on the edges of the shadowmap 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_RGB16F_ARB, kShadowMapWidth, kShadowMapHeight, 0, GL_RGB, GL_FLOAT, 0); glGenerateMipmapEXT(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 0); // create a framebuffer object glGenFramebuffersEXT(1, &shadowFboId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, shadowFboId); // attach the texture to FBO depth attachment point glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT ,GL_TEXTURE_2D, depthTextureId, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D, colorTextureId, 0); // check FBO status FBOstatus = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(FBOstatus != GL_FRAMEBUFFER_COMPLETE_EXT) printf("GL_FRAMEBUFFER_COMPLETE_EXT failed for shadowmap FBO, CANNOT use FBO\n"); // switch back to window-system-provided framebuffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
t_bool jit_gl_hap_draw_begin(t_jit_gl_hap *x, GLuint texid, GLuint width, GLuint height) { GLenum status; if(x->fboid == 0) glGenFramebuffersEXT(1, &x->fboid); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, x->fboid); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, texid, 0); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); // moving this to after bindframebuffer seems to fix problems on windows // http://www.opengl.org/discussion_boards/showthread.php/165636-Invalid-Operation-glDrawBuffer-glPopAttrib glPushAttrib(GL_VIEWPORT_BIT|GL_COLOR_BUFFER_BIT); glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); if(status == GL_FRAMEBUFFER_COMPLETE_EXT) { glClearColor(0.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glViewport(0, 0, width, height); glMatrixMode(GL_TEXTURE); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0, width, 0.0, height, -1, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glColor4f(0.0, 0.0, 0.0, 1.0); // do not need blending if we use black border for alpha and replace env mode, saves a buffer wipe // we can do this since our image draws over the complete surface of the FBO, no pixel goes untouched. glDisable(GL_BLEND); glDisable(GL_LIGHTING); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameterf( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE ); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST); return 1; } return 0; }
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; }
static int create_array_fbo(void) { GLuint tex, fb; GLenum status; int layer; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, tex); assert(glGetError() == 0); /* allocate empty array texture */ glTexImage3D(GL_TEXTURE_2D_ARRAY_EXT, 0, GL_RGBA, BUF_WIDTH, BUF_HEIGHT, num_layers, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); assert(glGetError() == 0); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); /* draw something into each layer of the array texture */ for (layer = 0; layer < NUM_LAYERS; layer++) { glFramebufferTextureLayer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, tex, 0, layer); assert(glGetError() == 0); status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "FBO incomplete\n"); goto done; } glViewport(0, 0, BUF_WIDTH, BUF_HEIGHT); piglit_ortho_projection(BUF_WIDTH, BUF_HEIGHT, GL_FALSE); /* solid color quad */ glColor4fv(layer_color[layer]); piglit_draw_rect(-2, -2, BUF_WIDTH + 2, BUF_HEIGHT + 2); } done: glDeleteFramebuffersEXT(1, &fb); return tex; }
void generateShadowFBO() { int shadowMapWidth = RENDER_WIDTH * SHADOW_MAP_RATIO; int shadowMapHeight = RENDER_HEIGHT * SHADOW_MAP_RATIO; //GLfloat borderColor[4] = {0,0,0,0}; GLenum FBOstatus; // Try to use a texture depth component glGenTextures(1, &depthTextureID); glBindTexture(GL_TEXTURE_2D, depthTextureID); // GL_LINEAR does not make sense for depth texture. However, next tutorial shows usage of GL_LINEAR and PCF glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Remove artefact on the edges of the shadowmap glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); //glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor ); // No need to force GL_DEPTH_COMPONENT24, drivers usually give you the max precision if available glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadowMapWidth, shadowMapHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); // create a framebuffer object glGenFramebuffersEXT(1, &fboId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId); // Instruct openGL that we won't bind a color texture with the currently binded FBO glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); // attach the texture to FBO depth attachment point glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthTextureID, 0); // check FBO status FBOstatus = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(FBOstatus != GL_FRAMEBUFFER_COMPLETE_EXT) printf("GL_FRAMEBUFFER_COMPLETE_EXT failed, CANNOT use FBO\n"); // switch back to window-system-provided framebuffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
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; }
static void create_fbo(void) { GLenum depthIntFormat = GL_DEPTH_COMPONENT24; GLenum status; /* depth texture */ glGenTextures(1, &DepthTex); glBindTexture(TexTarget, DepthTex); glTexParameteri(TexTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(TexTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(TexTarget, 0, depthIntFormat, SIZE, SIZE, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); assert(glGetError() == 0); glGetTexLevelParameteriv(TexTarget, 0, GL_TEXTURE_DEPTH_SIZE, &Zbits); /* color texture */ glGenTextures(1, &ColorTex); glBindTexture(TexTarget, ColorTex); glTexParameteri(TexTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(TexTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(TexTarget, 0, GL_RGBA, SIZE, SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); assert(glGetError() == 0); /* Create FBO */ glGenFramebuffersEXT(1, &FBO); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FBO); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, TexTarget, ColorTex, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, TexTarget, DepthTex, 0); assert(glGetError() == 0); status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { piglit_report_result(PIGLIT_SKIP); } }
static void use_fbo_for_bitmap(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bitmap, ALLEGRO_FBO_INFO *info) { ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap = bitmap->extra; GLint e; if (info->fbo_state == FBO_INFO_UNUSED) info->fbo_state = FBO_INFO_TRANSIENT; info->owner = bitmap; info->last_use_time = al_get_time(); ogl_bitmap->fbo_info = info; /* Bind to the FBO. */ _al_ogl_bind_framebuffer(info->fbo); /* Attach the texture. */ if (ANDROID_PROGRAMMABLE_PIPELINE(al_get_current_display())) { glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ogl_bitmap->texture, 0); } else { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, ogl_bitmap->texture, 0); } e = glGetError(); if (e) { ALLEGRO_DEBUG("glFrameBufferTexture2DEXT failed! fbo=%d texture=%d (%s)", info->fbo, ogl_bitmap->texture, _al_gl_error_string(e)); } /* See comment about unimplemented functions on Android above */ if (UNLESS_ANDROID_OR_RPI( glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)) { /* For some reason, we cannot use the FBO with this * texture. So no reason to keep re-trying, output a log * message and switch to (extremely slow) software mode. */ ALLEGRO_ERROR("Could not use FBO for bitmap with format %s.\n", _al_pixel_format_name(al_get_bitmap_format(bitmap))); ALLEGRO_ERROR("*** SWITCHING TO SOFTWARE MODE ***\n"); _al_ogl_bind_framebuffer(0); glDeleteFramebuffersEXT(1, &info->fbo); _al_ogl_reset_fbo_info(info); ogl_bitmap->fbo_info = NULL; } else { display->ogl_extras->opengl_target = bitmap; } }
/** * Run a check and output any errors. */ bool SoXipFbo::checkFramebufferStatus() { bool isOk = false; GLenum status = (GLenum)glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: isOk = true; break; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT"); break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_UNSUPPORTED_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT"); SoDebugError::post("SoXipFbo", "The fbo will be incomplete without color attachments"); break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT"); if (!mFboOut.numColorAttachments) SoDebugError::post("SoXipFbo", "The fbo will be incomplete without color attachments"); SoDebugError::post("SoXipFbo", "One or more render targets have no attached buffer(s)"); break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT"); if (useDepthBuffer.getValue()) SoDebugError::post("SoXipFbo", "Try turning the depth buffer off or replace with 3D depth"); break; case GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT"); break; case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT: SoDebugError::post("SoXipFbo", "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT"); break; default: SoDebugError::post("SoXipFbo", "UNKNOWN frambuffer error %i", status); } return isOk; }
void startBVHPlayer( int* argcp, char** argv ) { atexit( finalize ); glutInit( argcp, argv ); glutInitWindowSize( win_width, win_height ); glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL ); glutCreateWindow( "Motion Viewer" ); glewInit(); // GLenum status = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ); switch( status ) { case GL_FRAMEBUFFER_COMPLETE_EXT: std::cout<<"GL_FRAMEBUFFER_COMPLETE_EXT!: SUCCESS\n"; break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: std::cout<<"GL_FRAMEBUFFER_UNSUPPORTED_EXT!: ERROR\n"; exit(0); break; default: exit(0); } if (glewIsSupported("GL_VERSION_2_0")) std::cout << "Ready for OpenGL 2.0\n"; else { std::cout << "OpenGL 2.0 not supported\n"; exit(0); } initialize(); // call-back initialization glutReshapeFunc( reshape ); glutDisplayFunc( display ); glutKeyboardFunc( keyboard ); glutSpecialFunc( special ); glutMouseFunc( mouse ); glutMotionFunc( motion ); glutTimerFunc( time_interval, timer, 1 ); glutIdleFunc( idle ); glutMainLoop(); }
static bool do_depth_clear(GLenum format, GLuint tex, int level, int size) { GLuint fb; GLenum status; GLint draw_buffer, read_buffer; int x; glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer); glGetIntegerv(GL_READ_BUFFER, &read_buffer); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, tex, level); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glDeleteFramebuffersEXT(1, &fb); return false; } glEnable(GL_SCISSOR_TEST); for (x = 0; x < size; x++) { float val = (x + 0.5) / (size); glScissor(x, 0, 1, size); glClearDepth(val); glClear(GL_DEPTH_BUFFER_BIT); } glDisable(GL_SCISSOR_TEST); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glDeleteFramebuffersEXT(1, &fb); glDrawBuffer(draw_buffer); glReadBuffer(read_buffer); return true; }
t_bool jit_gl_hap_draw_begin(t_jit_gl_hap *x, GLuint texid, GLuint width, GLuint height) { GLenum status; // save texture state, client state, etc. glPushAttrib(GL_ALL_ATTRIB_BITS); glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); // FBO generation/attachment to texture if(x->fboid == 0) glGenFramebuffersEXT(1, &x->fboid); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, x->fboid); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, texid, 0); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status == GL_FRAMEBUFFER_COMPLETE_EXT) { glClearColor(0.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glViewport(0, 0, width, height); glMatrixMode(GL_TEXTURE); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0, width, 0.0, height, -1, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glColor4f(0.0, 0.0, 0.0, 1.0); // do not need blending if we use black border for alpha and replace env mode, saves a buffer wipe // we can do this since our image draws over the complete surface of the FBO, no pixel goes untouched. glDisable(GL_BLEND); glDisable(GL_LIGHTING); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameterf( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE ); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST); return 1; } return 0; }
static enum piglit_result test_clear(void) { GLuint cb; GLenum status; float green[3] = {0, 1, 0}; enum piglit_result res; /* Add a colorbuffer. */ glGenRenderbuffersEXT(1, &cb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, BUF_SIZE, BUF_SIZE); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, cb); glDrawBuffer(GL_COLOR_ATTACHMENT0); glReadBuffer(GL_COLOR_ATTACHMENT0); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { printf("FBO incomplete status 0x%X\n", status); piglit_report_result(PIGLIT_FAIL); /* RGBA8 must succeed. */ } glClearStencil(0x3456); glClear(GL_STENCIL_BUFFER_BIT); glEnable(GL_STENCIL_TEST); glStencilFunc(GL_EQUAL, 0x3456 & mask, ~0); glColor3fv(green); piglit_draw_rect(-1, -1, 2, 2); glColor3f(1, 1, 1); glDisable(GL_STENCIL_TEST); res = piglit_probe_rect_rgb(0, 0, BUF_SIZE, BUF_SIZE, green) ? PIGLIT_PASS : PIGLIT_FAIL; /* Display the colorbuffer. */ if (!piglit_automatic) { glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0); glBlitFramebufferEXT(0, 0, BUF_SIZE, BUF_SIZE, 0, 0, BUF_SIZE, BUF_SIZE, GL_COLOR_BUFFER_BIT, GL_NEAREST); } glDeleteRenderbuffersEXT(1, &cb); return res; }
void RendererGL15::BindFrameBuffer(int buffID) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (GLint)buffID); // check if it worked (probably worth doing :) ) GLuint status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch (status) { case GL_FRAMEBUFFER_COMPLETE_EXT: /*printf("GL_FRAMEBUFFER_COMPLETE_EXT\n")*/;break; case 0x8CDB: printf("GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n");break; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: printf("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n");break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: printf("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n");break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: printf("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS\n");break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: printf("GL_FRAMEBUFFER_UNSUPPORTED\n");break; default: printf("Unknown issue (%x).\n",status);break; } }
void check_framebuffer_status() { if (gDebugGL) { GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch (status) { case GL_FRAMEBUFFER_COMPLETE_EXT: break; default: llerrs <<"check_framebuffer_status failed" << llendl; break; } } }
int fbo_check_framebuffer_status(FBO *fbo) { GLenum fbStatus; #ifndef USING_GLES2 if (!gl_extensions.ARB_framebuffer_object && gl_extensions.EXT_framebuffer_object) { fbStatus = glCheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER); } else if (gl_extensions.ARB_framebuffer_object) { fbStatus = glCheckFramebufferStatus(GL_READ_FRAMEBUFFER); } else { fbStatus = 0; } #else fbStatus = glCheckFramebufferStatus(GL_READ_FRAMEBUFFER); #endif return (int)fbStatus; }
/// Checks if FBO status is ok bool PCSSShadowMap::checkFrameBufferStatus(Window *win) { GLenum errCode, status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: FINFO(("%x: framebuffer complete!\n", status)); break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: FWARNING(("%x: framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT\n", status)); // choose different formats return false; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: FWARNING(("%x: framebuffer INCOMPLETE_ATTACHMENT\n", status)); break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: FWARNING(("%x: framebuffer FRAMEBUFFER_MISSING_ATTACHMENT\n", status)); break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: FWARNING(("%x: framebuffer FRAMEBUFFER_DIMENSIONS\n", status)); break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: FWARNING(("%x: framebuffer INCOMPLETE_FORMATS\n", status)); break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: FWARNING(("%x: framebuffer INCOMPLETE_DRAW_BUFFER\n", status)); break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: FWARNING(("%x: framebuffer INCOMPLETE_READ_BUFFER\n", status)); break; case GL_FRAMEBUFFER_BINDING_EXT: FWARNING(("%x: framebuffer BINDING_EXT\n", status)); break; default: return false; } if((errCode = glGetError()) != GL_NO_ERROR) { const GLubyte *errString = gluErrorString(errCode); FWARNING(("OpenGL Error: %s!\n", errString)); return false; } return true; }
static int create_1d_fbo(void) { GLuint tex, fb; GLenum status; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_1D, tex); glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, BUF_WIDTH, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); assert(glGetError() == 0); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_1D, tex, 0); assert(glGetError() == 0); status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "FBO incomplete\n"); goto done; } glViewport(0, 0, BUF_WIDTH, 1); piglit_ortho_projection(BUF_WIDTH, 1, GL_FALSE); /* left side: red */ glColor4f(1.0, 0.0, 0.0, 0.0); piglit_draw_rect(0, 0, BUF_WIDTH / 2, 1); /* right side: green */ glColor4f(0.0, 1.0, 0.0, 0.0); piglit_draw_rect(BUF_WIDTH / 2, 0, BUF_WIDTH, 1); done: glDeleteFramebuffersEXT(1, &fb); return tex; }
Spotlight::Spotlight() { // capture coloring info later for debug if interesting? /*glEnable(GL_TEXTURE_2D); glGenTextures(1, &textureId); glBindTexture(GL_TEXTURE_2D, textureId); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_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); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0);*/ glGetError(); // We want a temp depth buffer please. glGenTextures(1, &this->depthBuffer); if (int i = glGetError() != GL_NO_ERROR) { warning("Depth buffer fail: %x\n", i); } glBindTexture(GL_TEXTURE_2D, this->depthBuffer); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_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); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, 1024, 1024, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); // Via this. glGenFramebuffersEXT(1, &this->frameBuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, this->frameBuffer); // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textureId, 0); // Tell it we want no draw buffer glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, this->depthBuffer, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) fatal("::SpotLight glCheckFramebufferStatusEXT failed!"); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); this->lightMatrix = new GLfloat[16]; this->projMatrix = new GLfloat[16]; this->mviewMatrix = new GLfloat[16]; }
/** * Run a check and output any errors. */ bool SoXipFboAttachColor3D::checkFramebufferStatus() { bool isOk = false; int db[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; int tp[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; GLenum status = (GLenum)glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: isOk = true; break; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: SoDebugError::post("SoXipFboAttachColor3D", "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT"); break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: SoDebugError::post("SoXipFboAttachColor3D", "GL_FRAMEBUFFER_UNSUPPORTED_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: SoDebugError::post("SoXipFboAttachColor3D", "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: SoDebugError::post("SoXipFboAttachColor3D", "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: SoDebugError::post("SoXipFboAttachColor3D", "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT"); break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: // Extract buffer setup for (int i = 0; i < mMaxAttachments; i++) glGetIntegerv(GL_DRAW_BUFFER0 + i, db + i); // Extract type setup for (int i = 0; i < mMaxAttachments; i++) glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + i, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, tp + i); // Print SoDebugError::post("SoXipFboAttachColor3D", "Incomplete Draw Buffer: draw (%d %d %d %d) type (%d %d %d %d)", db[0], db[1], db[2], db[3], tp[0], tp[1], tp[2], tp[3]); break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: SoDebugError::post("SoXipFboAttachColor3D", "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT"); break; default: SoDebugError::post("SoXipFboAttachColor3D", "UNKNOWN frambuffer error %i", status); } return isOk; }
void CWater::CreateRenderTexture( CInt size, CInt channels, CInt type, CInt textureID) { glGenTextures(1, &m_waterTexture[textureID]); glBindTexture(GL_TEXTURE_2D, m_waterTexture[textureID]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); if ( g_render.UsingFBOs() && g_options.m_enableFBO ) { glGenerateMipmapEXT( GL_TEXTURE_2D ); glTexImage2D(GL_TEXTURE_2D, 0, channels, size, size, 0, type, GL_UNSIGNED_BYTE, NULL ); m_fboID[textureID] = g_render.GenerateFBO(); g_render.BindFBO( m_fboID[textureID] ); g_render.Attach2DTextureToFBOColor( m_waterTexture[textureID] ); m_rbID[textureID] = g_render.GenerateRenderBuffer(); g_render.BindRenderBuffer( m_rbID[textureID] ); g_render.RenderbufferStorage( size, size ); g_render.AttachDepthToFBO( m_rbID[textureID] ); g_render.BindFBO(0); g_render.BindRenderBuffer(0); GLenum status; status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: break; default: MessageBox( NULL, _T("An error occured while creating the FBO for water\n"), _T( "VandaEngine Error" ), MB_OK ); break; } } else { glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE ); glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST ); CUInt *pTexture = NULL; pTexture = CNewData( CUInt, size * size * channels ); memset(pTexture, 0, size * size * channels * sizeof(CUInt)); glTexImage2D(GL_TEXTURE_2D, 0, channels, size, size, 0, type, GL_UNSIGNED_BYTE, pTexture); CDeleteData( pTexture ); } glBindTexture(GL_TEXTURE_2D, 0); }
void PostProcess::CreateFBO(int w, int h) { assert(m_nFramebufferId == 0); glGenFramebuffersEXT(1, &m_nFramebufferId); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_nFramebufferId); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_pOutputTexture->GetHandle(), 0); GLenum fboStatus = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(fboStatus != GL_FRAMEBUFFER_COMPLETE_EXT) { std::cout << "GL_FRAMEBUFFER_COMPLETE_EXT failed, CANNOT use FBO\n"; PrintFBOStatus(fboStatus); } assert(fboStatus == GL_FRAMEBUFFER_COMPLETE_EXT); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
void mitk::GPGPU::Texture::ActivateAsDestination() { static GLenum buffers[5][4] = { { GL_NONE, GL_NONE, GL_NONE, GL_NONE }, { GL_COLOR_ATTACHMENT0, GL_NONE, GL_NONE, GL_NONE }, { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_NONE, GL_NONE }, { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_NONE }, { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 }, }; glBindFramebuffer( GL_FRAMEBUFFER, glFBOHandle ); glDrawBuffers(4, buffers[1]); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, glTarget,glTextureHandle,0); GPGPU_CHECKGLERR << "associating texture to framebufferobject"; int error = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(error) { case GL_FRAMEBUFFER_COMPLETE_EXT: break; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: GPGPU_ERROR << "Incomplete attachment\n";break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: GPGPU_ERROR << "Missing attachment\n";break; case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: GPGPU_ERROR << "Incomplete dimensions\n";break; case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: GPGPU_ERROR << "Incomplete formats\n";break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: GPGPU_ERROR << "Incomplete draw buffer\n";break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: GPGPU_ERROR << "Incomplete read buffer\n";break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: GPGPU_ERROR << "Framebufferobjects unsupported\n";break; default: GPGPU_ERROR << "unknown framebuffer status\n";break; } glViewport(0,0,myWidth,myHeight); GPGPU_CHECKGLERR << "setting viewport"; }
static void Display( void ) { GLubyte *buffer = malloc(Width * Height * 4); GLenum status; CheckError(__LINE__); /* draw to user framebuffer */ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { printf("fbotest3: Error: Framebuffer is incomplete!!!\n"); } CheckError(__LINE__); glClearColor(0.5, 0.5, 1.0, 0.0); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glPushMatrix(); glRotatef(30.0, 1, 0, 0); glRotatef(Rotation, 0, 1, 0); glutSolidTeapot(2.0); glPopMatrix(); /* read from user framebuffer */ glReadPixels(0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); /* draw to window */ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glDisable(GL_DEPTH_TEST); /* in case window has depth buffer */ glWindowPos2iARB(0, 0); glDrawPixels(Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); free(buffer); glutSwapBuffers(); CheckError(__LINE__); }