bool RenderPass::setup(PixelFormat pixelFormat, int frameW, int frameH, Texture *pTarget, bool bDepthBuffer) { ASSERT(!m_bGenMipmaps); // Not implemented completely. Need to check if the mipmap filters have to // be set before checking for framebuffer completeness or rendering, and if so, to add interface // functionality to do so free(); ASSERT(frameW > 0); ASSERT(frameH > 0); // setup a texture format int texFormat = GL_RGBA8; switch (pixelFormat) { case PIXEL_RGBA8: texFormat = GL_RGBA8; break; case PIXEL_RGBA16F: texFormat = GL_RGBA16F_ARB; break; case PIXEL_RGBA32F: texFormat = GL_RGBA32F_ARB; break; default: ASSERT(0); } if (pTarget) { // set an external texture as a render target ASSERT(frameW == pTarget->getWidth()); ASSERT(frameH == pTarget->getHeight()); m_pFrameTexture = pTarget; m_bOwnsTexture = false; } else { // Create a texture for the given pixel format m_pFrameTexture = new Texture(); m_pFrameTexture->create(frameW, frameH, texFormat); m_bOwnsTexture = true; } m_format = pixelFormat; m_width = frameW; m_height = frameH; m_bUsePBuffer = false; if (m_bUsePBuffer) { // Create the pbuffer if (!m_pbuffer.create(frameW, frameH, texFormat)) { MessageBox(0, TEXT("Failed to create pbuffer"), TEXT("Error"), MB_OK); exit(-1); } // create a texture for the depth buffer if (bDepthBuffer) { m_pDepthTex = new Texture(); m_pDepthTex->create(frameW, frameH, texFormat); } } else { // Use Frame Buffer Objects // if (m_bGenMipmaps) { // m_pFrameTexture->set(); // glGenerateMipmapEXT(GL_TEXTURE_2D); // } // create an FBO for rendering //glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)wglGetProcAddress("glGenFramebuffersEXT"); glGenFramebuffersEXT(1, &m_FBO); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FBO); if (bDepthBuffer) { glGenRenderbuffersEXT(1, &m_FBODepthBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_FBODepthBuffer); // assign some storage for the depth buffer glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, frameW, frameH); // attach the depth buffer to the FBO glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_FBODepthBuffer); } // attach a texture to the FBO for rendering glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_pFrameTexture->getGLTex(), 0); // check if the frame buffer is complete GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { // some error occured // TODO: report the error and try to recover // TODO: fallback to a p-buffer // TEMP: report error return false; } } return true; }
void blit_block_item_sheet() { GLuint block_item_64_texture = 0; { unsigned int color_tex, fb, depth_rb; const int xres = 1024; const int yres = 1024; const float scale = 64.0f; //RGBA8 2D texture, 24 bit depth texture, 256x256 glGenTextures(1, &color_tex); glBindTexture(GL_TEXTURE_2D, color_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); //NULL means reserve texture memory, but texels are undefined glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, xres,yres, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); //------------------------- glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); //Attach 2D texture to this FBO glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, color_tex, 0); //------------------------- glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, xres,yres); //------------------------- //Attach depth buffer to FBO 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: //printf("FBO works\n"); break; default: printf("blit_block_item_sheet: FBO error\n"); break; } //------------------------- //and now you can render to GL_TEXTURE_2D glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //------------------------- glViewport(0, 0, xres, yres); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0f, (float) xres, 0.0f, (float) yres, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //------------------------- //glDisable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D); GL_ASSERT(GL_BLEND, false); glDisable(GL_DEPTH_TEST); glBindTexture(GL_TEXTURE_2D, t_map::block_textures_normal); glBegin(GL_QUADS); for (int i=0; i<16; i++) for (int j=0; j<16; j++) { /* const int T = 0; const int B = 1; const int N = 2; const int S = 3; const int W = 4; const int E = 5; */ int index = 16*j+i; // the NULL_CUBE is reserved at 255 (so that it fits in a packet) // must skip it if (!isValid((CubeType)index)) continue; int s1 = get_cube_side_texture((CubeType)index, 0); //T int s2 = get_cube_side_texture((CubeType)index, 2); //N int s3 = get_cube_side_texture((CubeType)index, 4); //W draw_iso_cube(i*scale, j*scale, scale, s1,s2,s3); } glEnd(); block_item_64_surface = create_surface_from_nothing(xres, yres); SDL_LockSurface(block_item_64_surface); GLenum format = get_texture_format(block_item_64_surface); //glReadPixels(0, 0, xres, yres, GL_RGBA, GL_UNSIGNED_BYTE, (void*) block_item_64_surface->pixels); glReadPixels(0, 0, xres, yres, format, GL_UNSIGNED_BYTE, (void*) block_item_64_surface->pixels); SDL_UnlockSurface(block_item_64_surface); save_surface_to_png(block_item_64_surface, SCREENSHOT_PATH "fbo_test_64.png"); //Delete resources glDeleteTextures(1, &color_tex); glDeleteRenderbuffersEXT(1, &depth_rb); //Bind 0, which means render to back buffer, as a result, fb is unbound glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glDeleteFramebuffersEXT(1, &fb); //http://stackoverflow.com/questions/5102277/resizing-an-image-using-opengl // setup another framebuffer here // bind the 64 pixel texture // draw to a 256x256 framebuffer // save surface to png again create_texture_from_surface(block_item_64_surface, &block_item_64_texture, GL_NEAREST); //create_texture_from_surface(block_item_64_surface, &block_item_64_texture, GL_LINEAR); GS_ASSERT_ABORT(block_item_64_texture != 0); SDL_FreeSurface(block_item_64_surface); } { unsigned int color_tex, fb, depth_rb; const int xres = 256; const int yres = 256; //const float scale = 16.0; //RGBA8 2D texture, 24 bit depth texture, 256x256 glGenTextures(1, &color_tex); glBindTexture(GL_TEXTURE_2D, color_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); //NULL means reserve texture memory, but texels are undefined glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, xres,yres, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); //------------------------- glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); //Attach 2D texture to this FBO glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, color_tex, 0); //------------------------- glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, xres,yres); //------------------------- //Attach depth buffer to FBO 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: //printf("FBO works\n"); break; default: printf("blit_block_item_sheet: FBO error\n"); break; } //------------------------- //and now you can render to GL_TEXTURE_2D glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //------------------------- glViewport(0, 0, xres, yres); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0f, (float) xres, 0.0f, (float) yres, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //------------------------- //glDisable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D); GL_ASSERT(GL_BLEND, false); glDisable(GL_DEPTH_TEST); //glBindTexture(GL_TEXTURE_2D, t_map::block_textures_normal); //glBegin(GL_QUADS); //for (int i=0; i<16; i++) //for (int j=0; j<16; j++) //{ ///* //const int T = 0; //const int B = 1; //const int N = 2; //const int S = 3; //const int W = 4; //const int E = 5; //*/ //int index = 16*j+i; //int s1 = get_cube_side_texture(index, 0); //T //int s2 = get_cube_side_texture(index, 2); //N //int s3 = get_cube_side_texture(index, 4); //W //draw_iso_cube(i*scale, j*scale, scale, s1,s2,s3); //} //glEnd(); //glBegin(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, block_item_64_texture); draw_bound_texture(0.0f, 0.0f, xres, yres); //glDisable(GL_TEXTURE_2D); block_item_16_surface = create_surface_from_nothing(xres, yres); SDL_LockSurface(block_item_16_surface); GLenum format = get_texture_format(block_item_16_surface); //glReadPixels(0, 0, xres, yres, GL_RGBA, GL_UNSIGNED_BYTE, (void*) block_item_16_surface->pixels); glReadPixels(0, 0, xres, yres, format, GL_UNSIGNED_BYTE, (void*) block_item_16_surface->pixels); SDL_UnlockSurface(block_item_16_surface); save_surface_to_png(block_item_16_surface, SCREENSHOT_PATH "fbo_test_16.png"); //Delete resources glDeleteTextures(1, &color_tex); glDeleteRenderbuffersEXT(1, &depth_rb); //Bind 0, which means render to back buffer, as a result, fb is unbound glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glDeleteFramebuffersEXT(1, &fb); SDL_FreeSurface(block_item_16_surface); } glBindFramebufferEXT(GL_FRAMEBUFFER, 0); glBindTexture(GL_TEXTURE_2D, 0); glViewport (0, 0, _xres, _yres); }
PIGLIT_GL_TEST_CONFIG_END static GLboolean test_with_format(GLenum internal_format, GLenum format, float results_x, float results_y) { GLuint tex, fb; GLenum status; GLboolean pass = GL_TRUE; int subrect_w = BUF_WIDTH / 5; int subrect_h = BUF_HEIGHT / 5; int x, y; int rbits, gbits, bbits, abits; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, internal_format, BUF_WIDTH, BUF_HEIGHT, 0, format, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &rbits); glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_SIZE, &gbits); glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_SIZE, &bbits); glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &abits); printf("testing with format 0x%04x, 0x%04x " "(%d,%d,%d,%d rgba)\n", internal_format, format, rbits, gbits, bbits, abits); 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, "texture for internalformat 0x%04x. " "format 0x%04x is framebuffer " "incomplete (status = 0x%04x)\n", internal_format, format, status); goto done; } /* Set matrices */ glViewport(0, 0, BUF_WIDTH, BUF_HEIGHT); piglit_ortho_projection(BUF_WIDTH, BUF_HEIGHT, GL_FALSE); /* clear background to purple */ glClearColor(1.0, 0.0, 1.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); /* lower-left square: red */ glColor4f(1.0, 0.0, 0.0, 0.0); piglit_draw_rect(subrect_w * 1, subrect_h * 1, subrect_w, subrect_h); /* lower-right square: green */ glColor4f(0.0, 1.0, 0.0, 0.0); piglit_draw_rect(subrect_w * 3, subrect_h * 1, subrect_w, subrect_h); /* upper-left square: blue */ glColor4f(0.0, 0.0, 1.0, 0.0); piglit_draw_rect(subrect_w * 1, subrect_h * 3, subrect_w, subrect_h); /* upper-right square: black */ glColor4f(0.0, 0.0, 0.0, 1.0); piglit_draw_rect(subrect_w * 3, subrect_h * 3, subrect_w, subrect_h); for (y = 0; y < BUF_HEIGHT; y++) { for (x = 0; x < BUF_WIDTH; x++) { float expected[4]; if (x >= subrect_w * 1 && x < subrect_w * 2 && y >= subrect_h * 1 && y < subrect_h * 2) { expected[0] = 1.0; expected[1] = 0.0; expected[2] = 0.0; expected[3] = 0.0; } else if (x >= subrect_w * 3 && x < subrect_w * 4 && y >= subrect_h * 1 && y < subrect_h * 2) { expected[0] = 0.0; expected[1] = 1.0; expected[2] = 0.0; expected[3] = 0.0; } else if (x >= subrect_w * 1 && x < subrect_w * 2 && y >= subrect_h * 3 && y < subrect_h * 4) { expected[0] = 0.0; expected[1] = 0.0; expected[2] = 1.0; expected[3] = 0.0; } else if (x >= subrect_w * 3 && x < subrect_w * 4 && y >= subrect_h * 3 && y < subrect_h * 4) { expected[0] = 0.0; expected[1] = 0.0; expected[2] = 0.0; expected[3] = 1.0; } else { expected[0] = 1.0; expected[1] = 0.0; expected[2] = 1.0; expected[3] = 0.0; } pass &= piglit_probe_pixel_rgb(x, y, expected); } } /* display the texture by drawing a quad */ glViewport(0, 0, piglit_width, piglit_height); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); piglit_draw_rect_tex(results_x, results_y, BUF_WIDTH, BUF_HEIGHT, 0, 0, 1, 1); glDisable(GL_TEXTURE_2D); done: glDeleteFramebuffersEXT(1, &fb); glDeleteTextures(1, &tex); return pass; }
void ofxFBOTexture::allocate(int w, int h, int internalGlDataType, int numSamples) { _isActive = false; //OpenGL supported technologies checking. if(!bSupportsFBO){ ofLog(OF_LOG_ERROR, "ofxFBOTexture: GL_EXT_framebuffer_object not supported by current OpenGL renderer. " " For Apple machines, more info at http://developer.apple.com/graphicsimaging/opengl/capabilities"); return; } if(!bSupportsMulti && numSamples){ ofLog(OF_LOG_WARNING, "ofxFBOTexture: GL_EXT_framebuffer_multisample not supported by current OpenGL renderer." " Falling back to non-multisampled mode. To disable this message, specify 0 samples." " Apple machines, more info at http://developer.apple.com/graphicsimaging/opengl/capabilities"); numSamples = 0; } if(!bSupportsBlit && numSamples){ //if there's no blit, then it's not worth using multi ofLog(OF_LOG_WARNING, "ofxFBOTexture: GL_EXT_framebuffer_blit not supported by current OpenGL renderer." " Falling back to non-multisampled mode. To disable this message, specify 0 samples." " Apple machines, more info at http://developer.apple.com/graphicsimaging/opengl/capabilities"); numSamples = 0; } if(maxSamples < numSamples){ ofLog(OF_LOG_WARNING, "ofxFBOTexture: requested samples too high. Using GL_SAMPLES instead."); numSamples = maxSamples; } //validate requested dimensions to see that they are within limits. if(maxTextureSize < w || maxRenderBufferSize < w){ ofLog(OF_LOG_WARNING, "ofxFBOTexture: requested width was too large. Using largest allowed value instead."); if(maxTextureSize < w) w = maxTextureSize; if(maxRenderBufferSize < w) w = maxRenderBufferSize; } if( maxTextureSize < h || maxRenderBufferSize < h){ ofLog(OF_LOG_WARNING, "ofxFBOTexture: requested height was too large. Using largest allowed value instead."); if(maxTextureSize < h) h = maxTextureSize; if(maxRenderBufferSize < h) h = maxRenderBufferSize; } /** validates arg3 for legacy function calling style i dont check for 1 because 1 is a valid internal color format so we're not sure if the person is passing a boolean or a color format so we can't accuse them of doing the legacy boolean thing. Even if that stops the FBO, the other color format error will help them out. */ if(internalGlDataType==0){ ofLog(OF_LOG_WARNING, "ofxFBOTexture::allocate( _ , _ , HERE , _ ) " "The calling statement passed a boolean value like an older version of FBO object. " "This argument has changed to be a color format " "like GL_RGB, GL_RGBA, GL_RGBA16F_ARB, and GL_RGBA32F_ARB. " "Defaulting to GL_RGBA."); internalGlDataType = GL_RGBA; } // attempt to free the previous bound texture, if we can: clean(); texData.width = w; texData.height = h; this->numSamples = numSamples; /* *GLEE_ARB_texture_rectangle thows errors in the latest from github (post 0062?) so i commented this out */ //#ifndef TARGET_OPENGLES // if (GLEE_ARB_texture_rectangle){ // texData.tex_w = w; // texData.tex_h = h; // texData.textureTarget = GL_TEXTURE_RECTANGLE_ARB; // } else //#endif // { texData.tex_w = ofNextPow2(w); texData.tex_h = ofNextPow2(h); // } //#ifndef TARGET_OPENGLES // if (GLEE_ARB_texture_rectangle){ // texData.tex_t = w; // texData.tex_u = h; // } else //#endif // { texData.tex_t = w/texData.tex_w; texData.tex_u = h/texData.tex_h; //} texData.width = w; texData.height = h; texData.bFlipTexture = true; texData.glTypeInternal = internalGlDataType; #ifndef TARGET_OPENGLES switch(texData.glTypeInternal) { case GL_RGBA32F_ARB: case GL_RGBA16F_ARB: texData.glType = GL_RGBA; texData.pixelType = GL_FLOAT; pixels = new float[w * h * 4]; break; default: texData.glType = texData.glTypeInternal; texData.pixelType = GL_UNSIGNED_BYTE; pixels = new float[w * h * 4]; break; } #else texData.glType = GL_RGBA; texData.pixelType = GL_UNSIGNED_BYTE; pixels = new unsigned char[w * h * 4]; #endif // create & setup texture glGenTextures(1, (GLuint *)&texData.textureID); // could be more then one, but for now, just one glBindTexture(texData.textureTarget, (GLuint)texData.textureID); glTexParameterf(texData.textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(texData.textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameterf(texData.textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(texData.textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(texData.textureTarget, 0, texData.glTypeInternal, texData.tex_w, texData.tex_h, 0, texData.glType, texData.pixelType, 0); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); #ifndef TARGET_OPENGLES glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, (GLint *) &oldFramebuffer); if(numSamples ){ // MULTISAMPLE // //THEO Create the render buffer for depth glGenRenderbuffersEXT(1, &depthBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, numSamples, GL_DEPTH_COMPONENT, texData.tex_w, texData.tex_h); //THEO multi sampled color buffer glGenRenderbuffersEXT(1, &colorBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, colorBuffer); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, numSamples, texData.glTypeInternal, texData.tex_w, texData.tex_h); //THEO create fbo for multi sampled content and attach depth and color buffers to it glGenFramebuffersEXT(1, &mfbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mfbo); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, colorBuffer); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer); }else{ //THEO Create the render buffer for depth glGenRenderbuffersEXT(1, &depthBuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, texData.tex_w, texData.tex_h); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer); } // create & setup FBO glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); // attach it to the FBO so we can render to it glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, texData.textureTarget, (GLuint)texData.textureID, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) { //validate arg3 after the fact because it's worth letting them try that format. if(internalGlDataType != GL_RGBA && internalGlDataType != GL_RGB && internalGlDataType != GL_RGBA16F_ARB && internalGlDataType != GL_RGBA32F_ARB){ ofLog(OF_LOG_ERROR, "ofxFBOTexture: Failed to initialize. " "I noticed that the calling statement did not passed an expected color format " "like GL_RGB, GL_RGBA, GL_RGBA16F_ARB, and GL_RGBA32F_ARB. You might try one of those. " "ofxFBOTexture::allocate( _ , _ , HERE , _ ) "); }else{ ofLog(OF_LOG_ERROR, "ofxFBOTexture: Failed to initialize."); } std::exit(1); } clear(0, 0, 0, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, oldFramebuffer); #else if(numSamples ){ ofLog(OF_LOG_WARNING, "Multi-sampling not supported on OpenGL ES"); }else{ } glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, (GLint *) &oldFramebuffer); // create & setup FBO glGenFramebuffersOES(1, &fbo); glBindFramebufferOES(GL_FRAMEBUFFER_OES, fbo); // attach it to the FBO so we can render to it glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, texData.textureTarget, (GLuint)texData.textureID, 0); glBindFramebufferOES(GL_FRAMEBUFFER_OES, oldFramebuffer); #endif texData.bAllocated = true; }
ShadowMapCube::ShadowMapCube(RebGDC * rgdc) { ird = rgdc->rd; shadowProgram.AddShaderFile(rgdc->rfs->Search("vshadow.rvs", "Shaders")); shadowProgram.AddShaderFile(rgdc->rfs->Search("fshadow.rfs", "Shaders")); shadowProgram.AddShaderFile(rgdc->rfs->Search("gshadow.rgs", "Shaders")); shadowProgram.Link(); w = 512; h = 512; glGenFramebuffersEXT(1, &sfbo); // Bind the FBO so that the next operations will be bound to it glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfbo); // Bind the depth buffer //glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, srbo); //glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, w, h); //glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, srbo); // Generate and bind the OGL texture for diffuse glGenTextures(1, &st); glBindTexture(GL_TEXTURE_CUBE_MAP, st); // fixes seam-artifacts due to numerical precision limitations glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL); //glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY); GLint internal_format = GL_DEPTH_COMPONENT32F; GLenum data_type = GL_FLOAT; // float z-buffer (if more precision is needed) // GLint internal_format = GL_DEPTH_COMPONENT32F; // GLenum data_type = GL_FLOAT; GLenum format = GL_DEPTH_COMPONENT; for (GLint face = 0; face < 6; face++) { glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, internal_format, w, h, 0, format, data_type, NULL //content need not be specified ); } //glTexImage2D(GL_TEXTURE_2D, //0, //internal_format, //w, h, 0, //format, //data_type, //NULL); //content need not be specified glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, st, 0); glDrawBuffer(GL_NONE); // Check if all worked fine and unbind the FBO GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) throw new std::exception("Can't initialize an FBO render texture. FBO initialization failed."); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
ArgoLightBuffer::ArgoLightBuffer(int width, int height) { this->width=width; this->height=height; std::string log; dLightProg = new GLSLProgram("Data/Shaders/v_light.glsl","Data/Shaders/f_dlight.glsl"); if (!dLightProg->vertex_->isCompiled()){ dLightProg->vertex_->getShaderLog(log); } if (!dLightProg->fragment_->isCompiled()){ dLightProg->fragment_->getShaderLog(log); while(true) { printf(log.c_str()); } assert (false); } pLightProg = new GLSLProgram("Data/Shaders/v_light.glsl","Data/Shaders/f_plight.glsl"); if (!pLightProg->vertex_->isCompiled()){ pLightProg->vertex_->getShaderLog(log); } if (!pLightProg->fragment_->isCompiled()){ pLightProg->fragment_->getShaderLog(log); } glEnable(GL_TEXTURE_2D); glGenFramebuffersEXT(1,&buffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, buffer); glGenTextures(1, &lightTex); glBindTexture(GL_TEXTURE_2D, lightTex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_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); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_FLOAT, 0); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, lightTex, 0); glGenTextures(1, &specTex); glBindTexture(GL_TEXTURE_2D, specTex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_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); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_FLOAT, 0); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, specTex, 0); // check FbO status GLenum FBOstatus = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(FBOstatus != GL_FRAMEBUFFER_COMPLETE_EXT) printf("GL_FRAMEBUFFER_COMPLETE failed, CANNOT use FBO. %i\n",FBOstatus); else printf("Light Buffer Done\n"); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); }
void RendererGL15::CreateFrameBufferObject(RenderTarget& rt) { GLint oldFBO; glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &oldFBO); //GLint oldFBO_DEPTH; //glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &oldFBO_DEPTH); glGenTextures(1, (GLuint*)&rt.mTargetTexture->mHardwareID); glBindTexture(GL_TEXTURE_2D, rt.mTargetTexture->mHardwareID); glTexImage2D(GL_TEXTURE_2D, 0, (GLuint)rt.mTargetTexture->mPixelFormat, rt.mTargetTexture->mWidth, rt.mTargetTexture->mHeight, 0, (GLuint)rt.mTargetTexture->mPixelFormat, GL_UNSIGNED_BYTE, rt.mTargetTexture->mPixelData); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( 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 ); //Setup Texture Framebuffer glGenFramebuffersEXT(1, (GLuint*)&rt.mFBOID); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, rt.mFBOID); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, rt.mTargetTexture->mHardwareID, 0); GLint backingWidth, backingHeight; glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_WIDTH_EXT, &backingWidth); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_HEIGHT_EXT, &backingHeight); glGenRenderbuffersEXT(1, (GLuint*)&rt.mFBO_DEPTHID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rt.mFBO_DEPTHID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16, rt.mTargetTexture->mWidth, rt.mTargetTexture->mHeight); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rt.mFBO_DEPTHID); //Clear the texture bind //glBindTexture(GL_TEXTURE_2D,0); // 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; } //status = glCheckFramebufferStatusOES(GL_RENDERBUFFER_OES); //if (status != GL_FRAMEBUFFER_COMPLETE_OES) //{ // printf("RENDER BUFFER(DEPTH PART) OBJECT ISN'T SETUP CORRECTLY\n"); //} //glBindFramebufferOES(GL_FRAMEBUFFER_OES, oldFBO); //glBindRenderbufferOES(GL_RENDERBUFFER_OES, oldFBO_DEPTH); //glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_WIDTH_OES, &backingWidth); //glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_HEIGHT_OES, &backingHeight); //glGenRenderbuffersOES(1, &texDepthbuffer); //glBindRenderbufferOES(GL_RENDERBUFFER_OES, texDepthbuffer); //glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, 128, 128); //glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, texDepthbuffer); //if(glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES) != GL_FRAMEBUFFER_COMPLETE_OES) { // NSLog(@"failed to make complete framebuffer object %x", glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES)); // return NO; //} }
RenderTarget::RenderTarget(const RenderTargetDesc &d) : Graphics::RenderTarget(d) , m_active(false) { glGenFramebuffersEXT(1, &m_fbo); }
void FrameBufferObject::init(unsigned int width, unsigned int height, const unsigned int* colorBufferInternalFormat, const unsigned int* colorBufferSWRAP, const unsigned int* colorBufferTWRAP, const unsigned int* colorBufferMinFiltering, const unsigned int* colorBufferMagFiltering, FBO_DepthBufferType depthBufferType, const unsigned int depthBufferMinFiltering, const unsigned int depthBufferMagFiltering, const unsigned int depthBufferSWRAP, const unsigned int depthBufferTWRAP, bool depthTextureCompareToR) { /////////////////INITIALIZATION///////////////// this->width = width; this->height = height; //color render buffer if(this->nbColorAttachement>0) { colorTextures = new GLuint[nbColorAttachement]; colorMinificationFiltering = new GLuint[nbColorAttachement]; for(int i=0; i<this->nbColorAttachement; i++) { glGenTextures(1, &colorTextures[i]); glBindTexture(GL_TEXTURE_2D, colorTextures[i]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, colorBufferMinFiltering[i]); this->colorMinificationFiltering[i] = colorBufferMinFiltering[i]; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, colorBufferMagFiltering[i]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, colorBufferSWRAP[i]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, colorBufferTWRAP[i]); glTexImage2D(GL_TEXTURE_2D, 0, colorBufferInternalFormat[i], width, height, 0, GL_RGBA, GL_FLOAT, NULL); if(this->colorMinificationFiltering[i]==GL_NEAREST_MIPMAP_NEAREST || this->colorMinificationFiltering[i]==GL_LINEAR_MIPMAP_NEAREST ||this->colorMinificationFiltering[i]==GL_NEAREST_MIPMAP_LINEAR || this->colorMinificationFiltering[i]==GL_LINEAR_MIPMAP_LINEAR) { glGenerateMipmapEXT(GL_TEXTURE_2D); } } } //depth render buffer this->depthType = depthBufferType; if(this->depthType!=FBO_DepthBufferType_NONE) { switch(this->depthType) { case FBO_DepthBufferType_TEXTURE: glGenTextures(1, &this->depthID); glBindTexture(GL_TEXTURE_2D, this->depthID); this->depthMinificationFiltering = depthBufferMinFiltering; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, depthBufferMinFiltering); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, depthBufferMagFiltering); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, depthBufferSWRAP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, depthBufferTWRAP); if(depthTextureCompareToR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24_ARB, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); if(this->depthMinificationFiltering==GL_NEAREST_MIPMAP_NEAREST || this->depthMinificationFiltering==GL_LINEAR_MIPMAP_NEAREST ||this->depthMinificationFiltering==GL_NEAREST_MIPMAP_LINEAR || this->depthMinificationFiltering==GL_LINEAR_MIPMAP_LINEAR) { glGenerateMipmapEXT(GL_TEXTURE_2D); } break; case FBO_DepthBufferType_RENDERTARGET: default: glGenRenderbuffersEXT(1, &this->depthID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, this->depthID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24_ARB, width, height); break; } } /////////////////ATTACHEMENT///////////////// glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); //color render buffer attachement if(nbColorAttachement>0) { for(int i=0; i<this->nbColorAttachement; i++) { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i, GL_TEXTURE_2D, this->colorTextures[i], 0 ); } glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); } else { glReadBuffer(GL_NONE); glDrawBuffer(GL_NONE); } //depth render buffer attachement if(this->depthType!=FBO_DepthBufferType_NONE) { switch(this->depthType) { case FBO_DepthBufferType_TEXTURE: glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, this->depthID, 0); break; case FBO_DepthBufferType_RENDERTARGET: default: glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, this->depthID); break; } } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); CheckFramebufferStatus(this->fbo); }
void OffscreenRenderer::prepareRendering(int w, int h) { if((!pbuffer && !glWidget) || width < w || height < h) { bool usePBuffer = true; if(pbuffer) { delete pbuffer; pbuffer = 0; } if(glWidget) { delete glWidget; glWidget = 0; usePBuffer = false; } if(framebuffer) { glDeleteFramebuffersEXT(1, &framebuffer); framebuffer = 0; } if(renderbuffer) { glDeleteRenderbuffersEXT(1, &renderbuffer); renderbuffer = 0; } if(flippingBuffer) { delete[] flippingBuffer; flippingBuffer = 0; } QGLFormat format; format.setStencil(false); //format.setDoubleBuffer(false); format.setSwapInterval(0); if(usePBuffer) { #ifdef _WIN32 pbuffer = new QGLPixelBuffer(QSize(w, h), format); #else pbuffer = 0; #endif } if(!pbuffer || !pbuffer->isValid()) { if(pbuffer) { delete pbuffer; pbuffer = 0; } // maybe fall back to "onscreen rendering" if(!glWidget) { glWidget = new QGLWidget(format, 0, 0, Qt::WindowStaysOnTopHint); glWidget->setFixedSize(w, h); glWidget->makeCurrent(); width = w; height = h; graphicsManager->initContext(false); } // QGLFramebufferObject didn't work properly... but well, the framebuffer object extension is platform independend anyway if(GLEW_EXT_framebuffer_object) { GLenum status; glGenFramebuffersEXT(1, &framebuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer); glGenRenderbuffersEXT(1, &renderbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, renderbuffer); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) { if(framebuffer) { glDeleteFramebuffersEXT(1, &framebuffer); framebuffer = 0; } if(renderbuffer) { glDeleteRenderbuffersEXT(1, &renderbuffer); renderbuffer = 0; } } } if(framebuffer) { TRACE("OffscreenRenderer: using framebuffer object renderer"); } else { TRACE("OffscreenRenderer: using window renderer"); } determineImagePositionInBuffer(w, h); } else { TRACE("OffscreenRenderer: yeah, using pixel buffer renderer"); pbuffer->makeCurrent(); const QSize& size(pbuffer->size()); width = size.width(); height = size.height(); ASSERT(width >= w && height >= h); graphicsManager->initContext(false); determineImagePositionInBuffer(w, h); } } VERIFY(makeCurrent()); }
enum piglit_result piglit_display(void) { bool warn = false, pass = true; GLuint rb, fbo; int i, j; float times[ARRAY_LENGTH(gl_formats)][ARRAY_LENGTH(gl_types)]; glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA, texture_size, texture_size); pass &= piglit_check_gl_error(GL_NO_ERROR); glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, rb); pass &= piglit_check_gl_error(GL_NO_ERROR); /* Set up basic GL stuff */ glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); warn = !test_exact(); for (i = 0; i < ARRAY_LENGTH(gl_formats); ++i) { for (j = 0; j < ARRAY_LENGTH(gl_types); ++j) { if (!valid_combination(gl_formats[i], gl_types[j])) continue; pass &= run_test(gl_formats[i], gl_types[j], ×[i][j]); } } glDisable(GL_TEXTURE_2D); glDeleteFramebuffers(1, &fbo); glDeleteRenderbuffers(1, &rb); if (benchmark) { fprintf(stdout, "internalFormat, format, type, time (us/call)\n"); for (i = 0; i < ARRAY_LENGTH(gl_formats); ++i) { for (j = 0; j < ARRAY_LENGTH(gl_types); ++j) { if (!valid_combination(gl_formats[i], gl_types[j])) continue; fprintf(stdout, "%s, %s, %s, %.3f\n", piglit_get_gl_enum_name(format->internal_format), piglit_get_gl_enum_name(gl_formats[i]), piglit_get_gl_enum_name(gl_types[j]), times[i][j]); } } } if (pass) { return warn ? PIGLIT_WARN : PIGLIT_PASS; } else { return PIGLIT_FAIL; } }
void CGLRenderTexture::create(U32 width, U32 height, bool mipmaps, bool anisotropic, U32 Rbits, U32 Gbits, U32 Bbits, U32 Abits, U32 Dbits, U32 Sbits) { if(!GLEW_EXT_framebuffer_object) return; mWidth = width; mHeight = height; mRedBits = Rbits; mGreenBits = Gbits; mBlueBits = Bbits; mAlphaBits = Abits; mDepthBits = Dbits; mStencilBits = Sbits; mHasMipmaps = mipmaps && GLEW_SGIS_generate_mipmap; mHasAnisotropic = anisotropic && GLEW_EXT_texture_filter_anisotropic; if(!(isPowerOfTwo(mWidth) && isPowerOfTwo(mHeight))){ mGLType = GL_TEXTURE_RECTANGLE_EXT; } glGenTextures(1, &texNum); checkGLError(); activate(); checkGLError(); glTexParameteri(mGLType, GL_TEXTURE_WRAP_S, GL_CLAMP); checkGLError(); glTexParameteri(mGLType, GL_TEXTURE_WRAP_T, GL_CLAMP); checkGLError(); if(mGLType != GL_TEXTURE_RECTANGLE_EXT){ if(mRedBits > 8){ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); checkGLError(); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); checkGLError(); } if (mHasMipmaps){ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); checkGLError(); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); checkGLError(); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); checkGLError(); } if (mHasAnisotropic){ F32 maxAnisotropy; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy); checkGLError(); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy); checkGLError(); } } S32 size; GLuint type; if(mRedBits > 8){ size = 8; type = GL_RGB16F_ARB; } else { size = 4; type = GL_RGBA; } char *data = (char *)malloc(width * height * size); memset(data, 0, width * height * size); glCopyTexImage2D(mGLType, 0, type, 0, 0, width, height, 0);checkGLError(); setMemoryUsage(width * height * size); free(data); glGenFramebuffersEXT(1, &mFBO);checkGLError(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);checkGLError(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, mGLType, texNum, 0);checkGLError(); mDepthRenderBuffer = 0; if(mDepthBits > 0 && mStencilBits == 0){ glGenRenderbuffersEXT(1, &mDepthRenderBuffer);checkGLError(); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepthRenderBuffer);checkGLError(); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, mWidth, mHeight); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepthRenderBuffer);checkGLError(); } else { if(mStencilBits > 0){ glGenRenderbuffersEXT(1, &mStencilRenderBuffer);checkGLError(); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mStencilRenderBuffer);checkGLError(); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, mWidth, mHeight);checkGLError(); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_EXT, GL_RENDERBUFFER_EXT, mStencilRenderBuffer);checkGLError(); } else { glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);checkGLError(); } } #if 0 if(mStencilBits > 0){ glGenRenderbuffersEXT(1, &mStencilRenderBuffer);checkGLError(); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mStencilRenderBuffer);checkGLError(); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX, mWidth, mHeight);checkGLError(); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mStencilRenderBuffer);checkGLError(); } #endif GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); switch(status) { case GL_FRAMEBUFFER_COMPLETE_EXT: break; case GL_FRAMEBUFFER_UNSUPPORTED_EXT: /* choose different formats */ gcon.printf("Framebuffer not complete\n"); break; default: /* programming error; will fail on all hardware */ assert(0); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);checkGLError(); mCreated = true; glBindTexture(mGLType, 0); checkGLError(); // Reinitialize the usage because activate() here marks as // used mLastFrameUsed = -10; }
void InitializeGlut(int *argc, char *argv[]) { int i,j; glutInit(argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(screenwidth, screenheight); glutCreateWindow(argv[0]); glutDisplayFunc(Display); glutKeyboardFunc(Keyboard); // Support mapped pinned allocations cudaSetDeviceFlags(cudaDeviceMapHost); cudaGLSetGLDevice(0); cublasCreate_v2(&cublasHd); glewInit(); GLint max_texture_size; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size); if(max_texture_size < screenwidth || screenwidth < screenheight) { printf("Max size of texttur(%d) is less than screensize(%d, %d)\n", max_texture_size, screenwidth, screenheight); exit(0); } //Create the textures glActiveTextureARB(GL_TEXTURE0_ARB); // 처리용 텍스쳐 2장 // Q. 왜 2장일까? glGenTextures(2, Processed_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Processed_Texture[0]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Processed_Texture[1]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // Site용 텍스쳐 // Q. 처리용과 별개인 이유는? glGenTextures(1, &Site_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Site_Texture); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // Registers the texture or renderbuffer object specified by image for access by CUDA. // A handle to the registered object is returned as resource cutilSafeCall(cudaGraphicsGLRegisterImage(&grSite, Site_Texture, GL_TEXTURE_RECTANGLE_NV, cudaGraphicsMapFlagsReadOnly)); // 에너지용 텍스쳐 // 처리용과 동일한 2장 // Q. 왜?? glGenTextures(2, Energy_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Energy_Texture[0]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Energy_Texture[1]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // 인덱스용 텍스쳐 // 인덱스를 컬러로 표현 glGenTextures(1, &IndexColor_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, IndexColor_Texture); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA, screenwidth, screenheight, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // Render Buffer Object glGenFramebuffersEXT(1, &RB_object); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, RB_object); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA32F_ARB, screenwidth+2, screenheight+2); // Frame(?) Buffer Object glGenFramebuffersEXT(1, &FB_objects); // ???? // NVIDIA 확인이라는 점만 확인 // http://developer.download.nvidia.com/opengl/specs/nvOpenGLspecs.pdf glGetQueryiv(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, &oq_bitsSupported); glGenQueriesARB(1, &occlusion_query); InitCg(); // 미리 컴파일된 화면 픽셀 목록 ScreenPointsList = glGenLists(1); glNewList(ScreenPointsList, GL_COMPILE); glBegin(GL_POINTS); for (i=0; i<screenwidth; i++) for (j=0; j<screenheight; j++) glVertex2f(i+1.5, j+1.5); glEnd(); glEndList(); }
static void GenFramebuffersEXT(GLsizei n, GLuint *framebuffers) { glGenFramebuffersEXT(n, framebuffers); }
void gen_frame_buffers(GLsizei n, GLuint *framebuffers) { glGenFramebuffersEXT(n, framebuffers); CHECK_GL_ERROR(); }
enum piglit_result piglit_display(void) { enum piglit_result res; GLuint fb, rb; GLenum status; glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT); /* Create the FBO. */ glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, f.iformat, BUF_SIZE, BUF_SIZE); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, rb); glViewport(0, 0, BUF_SIZE, BUF_SIZE); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { printf("FBO incomplete status 0x%X\n", status); piglit_report_result(PIGLIT_SKIP); } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1); switch (test) { case CLEAR: puts("Testing glClear(depth)."); res = test_clear(); break; case READPIXELS: puts("Testing glReadPixels(depth)."); res = test_readpixels(); break; case DRAWPIXELS: puts("Testing glDrawPixels(depth)."); res = test_drawpixels(); break; case COPYPIXELS: case BLIT: puts(test == BLIT ? "Testing glBlitFramebuffer(depth)." : "Testing glCopyPixels(depth)."); res = test_copy(); break; default: assert(0); res = PIGLIT_SKIP; } /* Cleanup. */ glBindFramebufferEXT(GL_FRAMEBUFFER, piglit_winsys_fbo); glDeleteFramebuffersEXT(1, &fb); glDeleteRenderbuffersEXT(1, &rb); piglit_present_results(); assert(glGetError() == 0); return res; }
/* Do piglit_rgbw_texture() image but using glClear */ static bool do_rgba_clear(GLenum format, GLuint tex, int level, int size) { float red[4] = {1.0, 0.0, 0.0, 0.0}; float green[4] = {0.0, 1.0, 0.0, 0.25}; float blue[4] = {0.0, 0.0, 1.0, 0.5}; float white[4] = {1.0, 1.0, 1.0, 1.0}; float black[4] = {0.0, 0.0, 0.0, 0.0}; float *color; GLuint fb; GLenum status; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, level); status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { glDeleteFramebuffersEXT(1, &fb); return false; } /* Handle the small sizes of compressed mipmap blocks */ switch (format) { case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: case GL_COMPRESSED_RGB_FXT1_3DFX: case GL_COMPRESSED_RGBA_FXT1_3DFX: if (size == 4) color = red; else if (size == 2) color = green; else if (size == 1) color = blue; else { assert(0); color = black; } glClearColor(color[0], color[1], color[2], color[3]); glClear(GL_COLOR_BUFFER_BIT); return true; } glEnable(GL_SCISSOR_TEST); glScissor(0, 0, size / 2, size / 2); glClearColor(red[0], red[1], red[2], red[3]); glClear(GL_COLOR_BUFFER_BIT); glScissor(size / 2, 0, size / 2, size / 2); glClearColor(green[0], green[1], green[2], green[3]); glClear(GL_COLOR_BUFFER_BIT); glScissor(0, size / 2, size / 2, size / 2); glClearColor(blue[0], blue[1], blue[2], blue[3]); glClear(GL_COLOR_BUFFER_BIT); glScissor(size / 2, size / 2, size / 2, size / 2); glClearColor(white[0], white[1], white[2], white[3]); glClear(GL_COLOR_BUFFER_BIT); glDisable(GL_SCISSOR_TEST); glDeleteFramebuffersEXT(1, &fb); return true; }
enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; GLuint tex0, tex1, fb; GLenum status; const GLenum attachments[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, }; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); tex0 = attach_texture(0); tex1 = attach_texture(1); glDrawBuffersARB(2, attachments); status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status); piglit_report_result(PIGLIT_SKIP); } /* Clear render targets (textures) to red */ glClearColor(1.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glMultiTexCoord4fv(GL_TEXTURE0, result0); glMultiTexCoord4fv(GL_TEXTURE1, result1); glEnable(GL_FRAGMENT_PROGRAM_ARB); piglit_draw_rect(0, 0, piglit_width, piglit_height); glDisable(GL_FRAGMENT_PROGRAM_ARB); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); /* Draw the two green textures to halves of the window. */ glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glBindTexture(GL_TEXTURE_2D, tex0); piglit_draw_rect_tex(0, 0, piglit_width / 2, piglit_height, 0, 0, 1, 1); glBindTexture(GL_TEXTURE_2D, tex1); piglit_draw_rect_tex(piglit_width / 2, 0, piglit_width / 2, piglit_height, 0, 0, 1, 1); glDisable(GL_TEXTURE_2D); glDeleteTextures(1, &tex0); glDeleteTextures(1, &tex1); glDeleteFramebuffersEXT(1, &fb); pass = pass && piglit_probe_rect_rgba(0, 0, piglit_width / 2, piglit_height, result0); pass = pass && piglit_probe_rect_rgba(piglit_width / 2, 0, piglit_width / 2, piglit_height, result1); glutSwapBuffers(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
bool HCoreCreateRenderTargetOpenGL(int w, int h, GLuint *pFrameBuffer, GLuint color_fmt, GLuint *pFrameTexture, int num_mrts, GLuint depth_fmt, GLuint *pDepthTexture) { GLuint framebuffer = 0; GLuint frametexture = 0; GLuint depthtexture = 0; glGenFramebuffersEXT(1, &framebuffer); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer); if ( pFrameTexture ) { for ( int i=0; i<num_mrts; i++ ) { glGenTextures(1, &frametexture); glBindTexture(GL_TEXTURE_2D, frametexture); //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); if ( color_fmt==GL_RGBA32F_ARB || color_fmt==GL_RGBA16F_ARB ) { glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } else { 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, color_fmt, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i, GL_TEXTURE_2D, frametexture, 0); pFrameTexture[i] = frametexture; } } else { glDrawBuffer(FALSE); glReadBuffer(FALSE); } if ( pDepthTexture ) { glGenTextures(1, &depthtexture); glBindTexture(GL_TEXTURE_2D, depthtexture); 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); glTexImage2D(GL_TEXTURE_2D, 0, depth_fmt, w, h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthtexture, 0); *pDepthTexture = depthtexture; } GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if ( status!=GL_FRAMEBUFFER_COMPLETE_EXT ) { return false; } *pFrameBuffer = framebuffer; return true; }
bool FrameBufferObject::initialize(Texture &texture, GLuint sharedStencilBufferID, GLuint sharedDepthBufferID, bool depthOnly) { if(frameBufferID){ std::cerr<<"FrameBufferObject already initialized!"<<std::endl ; return false ; } if(texture.getWidth() <= 0 || texture.getHeight() <= 0){ std::cerr<<"Width and Height of FBO must be positive, non-zero"<<std::endl; return false ; } if(texture.getTarget() != GL_TEXTURE_2D && texture.getTarget() != GL_TEXTURE_CUBE_MAP_ARB && texture.getTarget() != GL_TEXTURE_RECTANGLE_ARB){ std::cerr<<"Current FBO implementation only supports 2D/RECT/CUBE textures"<<std::endl; return false ; } if(!texture.getID()){ std::cerr<<"FBO need a valid Texture ID"<<std::endl ; return false ; } sharedStencilBuffer = (sharedStencilBufferID!= 0); sharedDepthBuffer = (sharedDepthBufferID != 0); height = texture.getHeight(); width = texture.getWidth(); glGenFramebuffersEXT(1, &frameBufferID); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBufferID); if(!sharedDepthBufferID && !depthOnly) { glGenRenderbuffersEXT(1, &depthBufferID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBufferID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBufferID); } if(sharedDepthBufferID) glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, sharedDepthBufferID); if(!sharedStencilBufferID) { glGenRenderbuffersEXT(1, &stencilBufferID); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, stencilBufferID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, stencilBufferID); } else glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, sharedStencilBufferID); if((texture.getTarget() == GL_TEXTURE_RECTANGLE_ARB) || (texture.getTarget() == GL_TEXTURE_2D)) { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, depthOnly ? GL_DEPTH_ATTACHMENT_EXT : GL_COLOR_ATTACHMENT0_EXT, texture.getTarget(), texture.getID(), 0); if(depthOnly) { glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); } } else { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X, texture.getID(), 0); } bool result = FrameBufferObject::checkStatus(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return result; }
/** Detect which internal formats are allowed as RTT Also detect what combinations of stencil and depth are allowed with this internal format. */ void GLFBOManager::detectFBOFormats() { // Try all formats, and report which ones work as target GLuint fb = 0, tid = 0; GLint old_drawbuffer = 0, old_readbuffer = 0; GLenum target = GL_TEXTURE_2D; glGetIntegerv (GL_DRAW_BUFFER, &old_drawbuffer); glGetIntegerv (GL_READ_BUFFER, &old_readbuffer); for(size_t x=0; x<PF_COUNT; ++x) { mProps[x].valid = false; // Fetch GL format token GLenum fmt = GLPixelUtil::getGLInternalFormat((PixelFormat)x); if(fmt == GL_NONE && x!=0) continue; // No test for compressed formats if(PixelUtil::isCompressed((PixelFormat)x)) continue; // Buggy ATI cards *crash* on non-RGB(A) formats int depths[4]; PixelUtil::getBitDepths((PixelFormat)x, depths); if(fmt!=GL_NONE && mATIMode && (!depths[0] || !depths[1] || !depths[2])) continue; // Create and attach framebuffer glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); if (fmt!=GL_NONE) { // Create and attach texture glGenTextures(1, &tid); glBindTexture(target, tid); // Set some default parameters so it won't fail on NVidia cards if (GLEW_VERSION_1_2) glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(target, 0, fmt, PROBE_SIZE, PROBE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, tid, 0); } else { // Draw to nowhere -- stencil/depth only glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); } // Check status GLuint status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); // Ignore status in case of fmt==GL_NONE, because no implementation will accept // a buffer without *any* attachment. Buffers with only stencil and depth attachment // might still be supported, so we must continue probing. if(fmt == GL_NONE || status == GL_FRAMEBUFFER_COMPLETE_EXT) { mProps[x].valid = true; StringUtil::StrStreamType str; str << "FBO " << PixelUtil::getFormatName((PixelFormat)x) << " depth/stencil support: "; // For each depth/stencil formats for (size_t depth = 0; depth < DEPTHFORMAT_COUNT; ++depth) { if (depthFormats[depth] != GL_DEPTH24_STENCIL8_EXT) { // General depth/stencil combination for (size_t stencil = 0; stencil < STENCILFORMAT_COUNT; ++stencil) { //StringUtil::StrStreamType l; //l << "Trying " << PixelUtil::getFormatName((PixelFormat)x) // << " D" << depthBits[depth] // << "S" << stencilBits[stencil]; //LogManager::getSingleton().logMessage(l.str()); if (_tryFormat(depthFormats[depth], stencilFormats[stencil])) { /// Add mode to allowed modes str << "D" << depthBits[depth] << "S" << stencilBits[stencil] << " "; FormatProperties::Mode mode; mode.depth = depth; mode.stencil = stencil; mProps[x].modes.push_back(mode); } } } else { // Packed depth/stencil format // #if OGRE_PLATFORM == OGRE_PLATFORM_LINUX // It now seems as if this workaround now *breaks* nvidia cards on Linux with the 169.12 drivers on Linux #if 0 // Only query packed depth/stencil formats for 32-bit // non-floating point formats (ie not R32!) // Linux nVidia driver segfaults if you query others if (PixelUtil::getNumElemBits((PixelFormat)x) != 32 || PixelUtil::isFloatingPoint((PixelFormat)x)) { continue; } #endif if (_tryPackedFormat(depthFormats[depth])) { /// Add mode to allowed modes str << "Packed-D" << depthBits[depth] << "S" << 8 << " "; FormatProperties::Mode mode; mode.depth = depth; mode.stencil = 0; // unuse mProps[x].modes.push_back(mode); } } } LogManager::getSingleton().logMessage(str.str()); } // Delete texture and framebuffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glDeleteFramebuffersEXT(1, &fb); // Workaround for NVIDIA / Linux 169.21 driver problem // see http://www.ogre3d.org/phpBB2/viewtopic.php?t=38037&start=25 glFinish(); if (fmt!=GL_NONE) glDeleteTextures(1, &tid); } // It seems a bug in nVidia driver: glBindFramebufferEXT should restore // draw and read buffers, but in some unclear circumstances it won't. glDrawBuffer(old_drawbuffer); glReadBuffer(old_readbuffer); String fmtstring = ""; for(size_t x=0; x<PF_COUNT; ++x) { if(mProps[x].valid) fmtstring += PixelUtil::getFormatName((PixelFormat)x)+" "; } LogManager::getSingleton().logMessage("[GL] : Valid FBO targets " + fmtstring); }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; int x, y; GLuint tex, fb; float blue[] = {1, 0, 0, 0}; float green[] = {0, 1, 0, 0}; bool draw_green; float *draw_colors[] = {blue, green}; float w_screen = 2.0f * TEX_WIDTH / piglit_width; float h_screen = 2.0f * TEX_HEIGHT / piglit_height; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); assert(glGetError() == 0); assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT); draw_green = true; for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) { float y_screen = -1.0 + 2.0 * ((float)y / piglit_height); for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) { float x_screen = -1.0 + 2.0 * ((float)x / piglit_width); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glDisable(GL_TEXTURE_2D); glColor4fv(draw_colors[draw_green]); piglit_draw_rect(-1, -1, 2, 2); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glEnable(GL_TEXTURE_2D); piglit_draw_rect_tex(x_screen, y_screen, w_screen, h_screen, 0, 0, 1, 1); draw_green = !draw_green; } /* Make it a checkerboard. */ draw_green = !draw_green; } glDeleteFramebuffersEXT(1, &fb); glDeleteTextures(1, &tex); draw_green = true; for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) { for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) { float *expected = draw_colors[draw_green]; pass = pass && piglit_probe_rect_rgb(x, y, TEX_WIDTH, TEX_HEIGHT, expected); draw_green = !draw_green; } draw_green = !draw_green; } piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
static void init(int argc, char *argv[]) { static GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0}; static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0}; static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0}; static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0}; GLint i; glLightfv(GL_LIGHT0, GL_POSITION, pos); #if 0 glEnable(GL_CULL_FACE); #endif glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); /* make the gears */ Gear1 = glGenLists(1); glNewList(Gear1, GL_COMPILE); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red); gear(1.0, 4.0, 1.0, 20, 0.7); glEndList(); Gear2 = glGenLists(1); glNewList(Gear2, GL_COMPILE); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green); gear(0.5, 2.0, 2.0, 10, 0.7); glEndList(); Gear3 = glGenLists(1); glNewList(Gear3, GL_COMPILE); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue); gear(1.3, 2.0, 0.5, 10, 0.7); glEndList(); cubeList = glGenLists(1); glNewList(cubeList, GL_COMPILE); genCube(); glEndList(); glEnable(GL_NORMALIZE); /* xxx make size dynamic */ TexWidth = 256; TexHeight = 256; glBindTexture(GL_TEXTURE_2D, TexObj); glTexImage2D(GL_TEXTURE_2D, 0, IntFormat, TexWidth, TexHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glGenFramebuffersEXT(1, &GearsFbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GearsFbo); glGenRenderbuffersEXT(1, &GearsDepthRB); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, GearsDepthRB); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, TexWidth, TexHeight); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, GearsDepthRB); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, TexObj, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) { printf("!!! FB not complete\n"); exit(1); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); for ( i=1; i<argc; i++ ) { if (strcmp(argv[i], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } } }
void ShivaVGWindowSurfacePrivate::ensureContext(QWidget *widget) { #if defined(Q_WS_X11) Window win = widget->winId(); if (win != drawable) { if (context) glXDestroyContext(X11->display, context); drawable = win; } if (context == 0) { const QX11Info *xinfo = qt_x11Info(widget); int spec[64]; int i = 0; spec[i++] = GLX_DOUBLEBUFFER; spec[i++] = GLX_DEPTH_SIZE; spec[i++] = 1; spec[i++] = GLX_STENCIL_SIZE; spec[i++] = 1; spec[i++] = GLX_RGBA; spec[i++] = GLX_RED_SIZE; spec[i++] = 1; spec[i++] = GLX_GREEN_SIZE; spec[i++] = 1; spec[i++] = GLX_BLUE_SIZE; spec[i++] = 1; spec[i++] = GLX_SAMPLE_BUFFERS_ARB; spec[i++] = 1; spec[i++] = GLX_SAMPLES_ARB; spec[i++] = 4; spec[i] = XNone; XVisualInfo *visual = glXChooseVisual (xinfo->display(), xinfo->screen(), spec); context = glXCreateContext(X11->display, visual, 0, True); if (!context) qWarning("glXCreateContext: could not create GL context for VG rendering"); } #else Q_UNUSED(widget); #endif #if defined(QVG_USE_FBO) if (needsResize && fbo) { #if defined(Q_WS_X11) glXMakeCurrent(X11->display, drawable, context); #endif glDeleteTextures(1, &texture); glDeleteFramebuffersEXT(1, &fbo); #if defined(Q_WS_X11) glXMakeCurrent(X11->display, 0, 0); #endif fbo = 0; texture = 0; } if (!fbo) { #if defined(Q_WS_X11) glXMakeCurrent(X11->display, drawable, context); #endif glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size.width(), size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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); glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texture, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); #if defined(Q_WS_X11) glXMakeCurrent(X11->display, 0, 0); #endif } #endif needsResize = false; }
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); glEnable(GL_NORMALIZE); glEnable(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); 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_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); CGutModel::SetTexturePath("../../textures/"); g_Model_OpenGL.ConvertToOpenGLModel(&g_Model); return true; }
void slop::Framebuffer::create( unsigned int width, unsigned int height, unsigned char flags, std::string shader ) { if ( m_width == width && m_height == height && m_flags == flags ) { return; } delete m_shader; m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) ); if ( GLEW_VERSION_3_0 ) { glDeleteFramebuffers( 1, &m_frame ); if ( m_flags & color ) { glDeleteTextures( 1, &m_texture ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glDeleteRenderbuffers( 1, &m_depth ); } if ( m_flags & stencil ) { glDeleteRenderbuffers( 1, &m_stencil ); } } else if ( GLEW_EXT_framebuffer_object ) { glDeleteFramebuffersEXT( 1, &m_frame ); if ( m_flags & color ) { glDeleteTextures( 1, &m_texture ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glDeleteRenderbuffersEXT( 1, &m_depth ); } if ( m_flags & stencil ) { glDeleteRenderbuffersEXT( 1, &m_stencil ); } } m_flags = flags; m_width = width; m_height = height; if ( GLEW_VERSION_3_0 ) { glGenFramebuffers( 1, &m_frame ); glBindFramebuffer( GL_FRAMEBUFFER, m_frame ); if ( m_flags & color ) { glGenTextures( 1, &m_texture ); glBindTexture( GL_TEXTURE_2D, m_texture ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glGenRenderbuffers( 1, &m_depth ); glBindRenderbuffer( GL_RENDERBUFFER, m_depth ); glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_width, m_height ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth ); } //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points. if ( m_flags & stencil ) { glGenRenderbuffers( 1, &m_stencil ); glBindRenderbuffer( GL_RENDERBUFFER, m_stencil ); glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_width, m_height ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_stencil ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil ); } //Make sure we unbind when we're done. glBindFramebuffer( GL_FRAMEBUFFER, 0 ); } else if ( GLEW_EXT_framebuffer_object ) { glGenFramebuffersEXT( 1, &m_frame ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame ); if ( m_flags & color ) { glGenTextures( 1, &m_texture ); glBindTexture( GL_TEXTURE_2D, m_texture ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glGenRenderbuffersEXT( 1, &m_depth ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depth ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_width, m_height ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depth ); } //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points. if ( m_flags & stencil ) { glGenRenderbuffersEXT( 1, &m_stencil ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_stencil ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, m_width, m_height ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil ); } //Make sure we unbind when we're done. glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); } }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglGenFramebuffersEXT__IJ(JNIEnv *__env, jclass clazz, jint n, jlong framebuffersAddress) { glGenFramebuffersEXTPROC glGenFramebuffersEXT = (glGenFramebuffersEXTPROC)tlsGetFunction(1707); intptr_t framebuffers = (intptr_t)framebuffersAddress; UNUSED_PARAM(clazz) glGenFramebuffersEXT(n, framebuffers); }
slop::Framebuffer::Framebuffer( unsigned int width, unsigned int height, unsigned char flags, std::string shader ) { m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) ); generatedBuffers = false; m_width = width; m_height = height; m_flags = flags; if ( m_flags & stencil && m_flags & depth ) { fprintf( stderr, "Most hardware doesn't support using a FBO with a depth and stencil attached! Condensing them to one render buffer..." ); } if ( GLEW_VERSION_3_0 ) { glGenFramebuffers( 1, &m_frame ); glBindFramebuffer( GL_FRAMEBUFFER, m_frame ); if ( m_flags & color ) { glGenTextures( 1, &m_texture ); glBindTexture( GL_TEXTURE_2D, m_texture ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glGenRenderbuffers( 1, &m_depth ); glBindRenderbuffer( GL_RENDERBUFFER, m_depth ); glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_width, m_height ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth ); } //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points. if ( m_flags & stencil ) { glGenRenderbuffers( 1, &m_stencil ); glBindRenderbuffer( GL_RENDERBUFFER, m_stencil ); glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_width, m_height ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_stencil ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil ); } check(); //Make sure we unbind when we're done. glBindFramebuffer( GL_FRAMEBUFFER, 0 ); } else if ( GLEW_EXT_framebuffer_object ) { glGenFramebuffersEXT( 1, &m_frame ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame ); if ( m_flags & color ) { glGenTextures( 1, &m_texture ); glBindTexture( GL_TEXTURE_2D, m_texture ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glGenRenderbuffersEXT( 1, &m_depth ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depth ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_width, m_height ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depth ); } //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points. if ( m_flags & stencil ) { glGenRenderbuffersEXT( 1, &m_stencil ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_stencil ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, m_width, m_height ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil ); } check(); //Make sure we unbind when we're done. glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); } else { throw std::runtime_error( "Error: Failed to create framebuffer! You need OpenGL 3.0 or the GL_EXT_framebuffer_object extension!" ); } }
void GlFramebufferObject::createObject() { deleteObject(); glGenFramebuffersEXT(1, &_handle); }
static void draw_opengl(void) { double secs = al_get_time(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); /* Let's create a texture. It will only be visible if we cannot draw over * it with the framebuffer extension. */ if (!tex) { unsigned char *pixels = malloc(256 * 256 * 4); int x, y; for (y = 0; y < 256; y++) { for (x = 0; x < 256; x++) { unsigned char r = x, g = y, b = 0, a = 255; pixels[y * 256 * 4 + x * 4 + 0] = r; pixels[y * 256 * 4 + x * 4 + 1] = g; pixels[y * 256 * 4 + x * 4 + 2] = b; pixels[y * 256 * 4 + x * 4 + 3] = a; } } glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 256, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); free(pixels); } /* Let's create a framebuffer object. */ if (!fbo && !no_fbo) { /* Did Allegro discover the OpenGL extension for us? */ if (al_get_opengl_extension_list()->ALLEGRO_GL_EXT_framebuffer_object) { /* If yes, then it also filled in the function pointer. How nice. */ glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); /* Attach the framebuffer object to our texture. */ glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { no_fbo = true; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } else { /* We are screwed, the extension is not available. */ no_fbo = true; } } /* Draw a yellow triangle on red background to the framebuffer object. */ if (fbo && !no_fbo) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); glPushAttrib(GL_VIEWPORT_BIT | GL_TRANSFORM_BIT); glViewport(0, 0, 256, 256); glClearColor(1, 0, 0, 1); glClear(GL_COLOR_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, 256, 256, 0, -1, 1); glDisable(GL_TEXTURE_2D); glColor3f(1, 1, 0); glTranslatef(128, 128 + sin(secs * ALLEGRO_PI * 2 * 2) * 20, 0); glBegin(GL_TRIANGLES); glVertex2f(0, -100); glVertex2f(100, 0); glVertex2f(-100, 0); glEnd(); glPopMatrix(); glPopAttrib(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } /* Draw a quad with our texture. */ glClearColor(0, 0, 1, 1); glClear(GL_COLOR_BUFFER_BIT); glLoadIdentity(); glTranslatef(320, 240, 0); glRotatef(secs * 360 / 4, 0, 0, 1); glColor3f(1, 1, 1); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, tex); glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex2f(-100, -100); glTexCoord2f(1, 0); glVertex2f(+100, -100); glTexCoord2f(1, 1); glVertex2f(+100, +100); glTexCoord2f(0, 1); glVertex2f(-100, +100); glEnd(); }