void PottsLabeling3_Relaxed::copyBuffersFrom(PottsLabeling3_Relaxed& src) { setupNormalizedProjection(); _uBufA->activate(); src._uBufA->enableTexture(GL_TEXTURE0); enableTrivialTexture2DShader(); renderNormalizedQuad(); src._uBufA->disableTexture(GL_TEXTURE0); #if defined(GPU_POTTS_LABELING_USE_PACKED_P) _pBufA->activate(); src._pBufA->enableTexture(GL_TEXTURE0); renderNormalizedQuad(); src._pBufA->disableTexture(GL_TEXTURE0); #else GLenum const buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT }; _pFboA->activate(); glDrawBuffersARB(1, buffers+1); src._pFboA->getColorTexture(0).enable(GL_TEXTURE0); renderNormalizedQuad(); src._pFboA->getColorTexture(0).disable(GL_TEXTURE0); glDrawBuffersARB(1, buffers+0); src._pFboA->getColorTexture(0).enable(GL_TEXTURE0); renderNormalizedQuad(); src._pFboA->getColorTexture(0).disable(GL_TEXTURE0); #endif disableTrivialTexture2DShader(); } // end PottsLabeling3_Relaxed::copyLabels()
void PottsLabeling4_LevelFun::copyBuffersFrom(PottsLabeling4_LevelFun& src) { setupNormalizedProjection(); _uBufA->activate(); src._uBufA->enableTexture(GL_TEXTURE0); enableTrivialTexture2DShader(); renderNormalizedQuad(); src._uBufA->disableTexture(GL_TEXTURE0); GLenum const buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT }; _pFboA->activate(); glDrawBuffersARB(1, buffers+2); src._pFboA->getColorTexture(0).enable(GL_TEXTURE0); renderNormalizedQuad(); src._pFboA->getColorTexture(0).disable(GL_TEXTURE0); glDrawBuffersARB(1, buffers+1); src._pFboA->getColorTexture(0).enable(GL_TEXTURE0); renderNormalizedQuad(); src._pFboA->getColorTexture(0).disable(GL_TEXTURE0); glDrawBuffersARB(1, buffers+0); src._pFboA->getColorTexture(0).enable(GL_TEXTURE0); renderNormalizedQuad(); src._pFboA->getColorTexture(0).disable(GL_TEXTURE0); disableTrivialTexture2DShader(); } // end PottsLabeling4_LevelFun::copyLabels()
void GPU::FrameBuffer::Bind() const { glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_Id ); if( !m_EnabledBuffers.empty() ) glDrawBuffersARB( m_EnabledBuffers.size(), &m_EnabledBuffers.front() ); else glDrawBuffersARB( 0, NULL ); glViewport( 0, 0, m_Width, m_Height ); }
bool SSAO::setup() { if (!GLEW_EXT_framebuffer_object) { qWarning("FBO not supported!"); return false; } if (_initOk) return true; //genero i 2 framebuffer object che mi servono. glGenFramebuffersEXT(1, &_fbo); glGenFramebuffersEXT(1, &_fbo2); //attacco il primo...adesso le modifiche andranno a modificare solo _fbo glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo); //Generates first color texture this->genColorTextureEXT(this->_color1, GL_COLOR_ATTACHMENT0_EXT); this->genDepthMapTexture24(this->_depthMap, false); GLenum drawBuffers[] = {GL_COLOR_ATTACHMENT0}; glDrawBuffersARB(0, drawBuffers); int err = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); _initOk = (err == GL_FRAMEBUFFER_COMPLETE_EXT); if(!this->_initOk) return this->_initOk; //attacco il secondo fbo...adesso le modifiche andranno a modificare solo _fbo2 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo2); //Generates first color texture this->genColorTextureEXT(this->_color2, GL_COLOR_ATTACHMENT0_EXT); //Generates render buffer for depth attachment this->genDepthRenderBufferEXT(this->_depth); GLenum drawBuffers2[] = {GL_COLOR_ATTACHMENT0}; glDrawBuffersARB(0, drawBuffers2); this->loadNoiseTxt(); err = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); _initOk = (err == GL_FRAMEBUFFER_COMPLETE_EXT); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return _initOk; }
void LLRenderTarget::bindTarget() { if (mFBO) { stop_glerror(); glBindFramebuffer(GL_FRAMEBUFFER, mFBO); stop_glerror(); if (gGLManager.mHasDrawBuffers) { //setup multiple render targets GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3}; glDrawBuffersARB(mTex.size(), drawbuffers); } if (mTex.empty()) { //no color buffer to draw to glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); } check_framebuffer_status(); stop_glerror(); } glViewport(0, 0, mResX, mResY); sBoundTarget = this; }
bool ShadowMapping::setup() { if (!GLEW_EXT_framebuffer_object) { qWarning("FBO not supported!"); return false; } if (_initOk) return true; glGenFramebuffersEXT(1, &_fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo); this->genDepthMapTexture24(this->_shadowMap, true); //we don't need a color attachment GLenum drawBuffers[] = {GL_NONE}; glDrawBuffersARB(1, drawBuffers); glReadBuffer(GL_NONE); //checks for fbo creation errors int err = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); _initOk = (err == GL_FRAMEBUFFER_COMPLETE_EXT); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return _initOk; }
/** * @brief * Sets a color render target */ void SurfaceTextureBuffer::SetColorRenderTarget(uint8 nColorIndex, PLRenderer::TextureBuffer *pTextureBuffer) { // Check color index if (nColorIndex < m_nMaxColorTargets) { // Set color render target while (!m_lstTextureBufferHandler[nColorIndex]) { PLRenderer::ResourceHandler *pTextureBufferHandler = new PLRenderer::ResourceHandler(); m_lstTextureBufferHandler.Add(pTextureBufferHandler); } PLRenderer::ResourceHandler *pTextureBufferHandler = m_lstTextureBufferHandler[nColorIndex]; pTextureBufferHandler->SetResource(pTextureBuffer); // Check FBO if (m_pFrameBufferObject && pTextureBuffer) { m_pFrameBufferObject->Bind(); m_pFrameBufferObject->SwitchTarget(*pTextureBuffer, nColorIndex); // "GL_ARB_draw_buffers" & "GL_NV_fbo_color_attachments" extensions available? const Extensions &cExtensions = static_cast<Renderer&>(GetRenderer()).GetContext().GetExtensions(); if (cExtensions.IsGL_ARB_draw_buffers() && cExtensions.IsGL_NV_fbo_color_attachments()) { // Set draw buffers static const GLenum db[16] = { GL_COLOR_ATTACHMENT0_NV, GL_COLOR_ATTACHMENT1_NV, GL_COLOR_ATTACHMENT2_NV, GL_COLOR_ATTACHMENT3_NV, GL_COLOR_ATTACHMENT4_NV, GL_COLOR_ATTACHMENT5_NV, GL_COLOR_ATTACHMENT6_NV, GL_COLOR_ATTACHMENT7_NV, GL_COLOR_ATTACHMENT8_NV, GL_COLOR_ATTACHMENT9_NV, GL_COLOR_ATTACHMENT10_NV, GL_COLOR_ATTACHMENT11_NV, GL_COLOR_ATTACHMENT12_NV, GL_COLOR_ATTACHMENT13_NV, GL_COLOR_ATTACHMENT14_NV, GL_COLOR_ATTACHMENT15_NV}; glDrawBuffersARB(m_nMaxColorTargets, db); } } } }
void PottsLabeling4_LevelFun::setZero() { glClearColor(0, 0, 0, 0); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); _uBufA->activate(); glClear(GL_COLOR_BUFFER_BIT); GLenum const buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT }; _pFboA->activate(); glDrawBuffersARB(1, buffers+2); glClear(GL_COLOR_BUFFER_BIT); glDrawBuffersARB(1, buffers+1); glClear(GL_COLOR_BUFFER_BIT); glDrawBuffersARB(1, buffers+0); glClear(GL_COLOR_BUFFER_BIT); } // PottsLabeling4_LevelFun::setZero()
/** * @brief * Sets a color render target */ void SurfaceTextureBuffer::SetColorRenderTarget(uint8 nColorIndex, PLRenderer::TextureBuffer *pTextureBuffer) { // Check color index if (nColorIndex < m_nMaxColorTargets) { // Set color render target while (!m_lstTextureBufferHandler[nColorIndex]) { PLRenderer::ResourceHandler *pTextureBufferHandler = new PLRenderer::ResourceHandler(); m_lstTextureBufferHandler.Add(pTextureBufferHandler); } PLRenderer::ResourceHandler *pTextureBufferHandler = m_lstTextureBufferHandler[nColorIndex]; pTextureBufferHandler->SetResource(pTextureBuffer); // Check FBO if (m_pFrameBufferObject && pTextureBuffer) { m_pFrameBufferObject->Bind(); m_pFrameBufferObject->SwitchTarget(*pTextureBuffer, nColorIndex); // Get extensions instance const Extensions &cExtensions = static_cast<Renderer&>(GetRenderer()).GetContext().GetExtensions(); // Set draw buffers static const GLuint db[16] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT, GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT, GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT, GL_COLOR_ATTACHMENT8_EXT, GL_COLOR_ATTACHMENT9_EXT, GL_COLOR_ATTACHMENT10_EXT, GL_COLOR_ATTACHMENT11_EXT, GL_COLOR_ATTACHMENT12_EXT, GL_COLOR_ATTACHMENT13_EXT, GL_COLOR_ATTACHMENT14_EXT, GL_COLOR_ATTACHMENT15_EXT}; if (cExtensions.IsGL_ARB_draw_buffers()) glDrawBuffersARB(m_nMaxColorTargets, db); else if (cExtensions.IsGL_ATI_draw_buffers()) glDrawBuffersATI(m_nMaxColorTargets, db); } } }
bool SurfaceTextureBuffer::MakeCurrent(uint8 nFace) { // Check whether the data is valid and whether there's a texture buffer if (m_cTextureBufferHandler.GetResource() && GetTextureBuffer()) { // Set target face if (GetTextureBuffer()->GetType() == PLRenderer::Resource::TypeTextureBufferCube) m_nFace = nFace; else m_nFace = 0; // Cleanup texture buffer handlers for (uint32 i=0; i<m_lstTextureBufferHandler.GetNumOfElements(); i++) delete m_lstTextureBufferHandler[i]; m_lstTextureBufferHandler.Clear(); // Add primary texture buffer handler PLRenderer::ResourceHandler *pTextureBufferHandler = new PLRenderer::ResourceHandler(); pTextureBufferHandler->SetResource(m_cTextureBufferHandler.GetResource()); m_lstTextureBufferHandler.Add(pTextureBufferHandler); // Frame buffer object used? if (m_pFrameBufferObject && m_cTextureBufferHandler.GetResource()) { m_pFrameBufferObject->SwitchTarget(static_cast<PLRenderer::TextureBuffer&>(*m_cTextureBufferHandler.GetResource()), 0, nFace); m_pFrameBufferObject->Bind(); // Need rendering to depth only PLRenderer::TextureBuffer::EPixelFormat nFormat = GetTextureBuffer()->GetFormat(); if (nFormat == PLRenderer::TextureBuffer::D16 || nFormat == PLRenderer::TextureBuffer::D24 || nFormat == PLRenderer::TextureBuffer::D32) { glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); } else { // Get extensions instance const Extensions &cExtensions = static_cast<Renderer&>(GetRenderer()).GetContext().GetExtensions(); // Set draw buffers static const GLuint db[16] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT, GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT, GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT, GL_COLOR_ATTACHMENT8_EXT, GL_COLOR_ATTACHMENT9_EXT, GL_COLOR_ATTACHMENT10_EXT, GL_COLOR_ATTACHMENT11_EXT, GL_COLOR_ATTACHMENT12_EXT, GL_COLOR_ATTACHMENT13_EXT, GL_COLOR_ATTACHMENT14_EXT, GL_COLOR_ATTACHMENT15_EXT}; if (cExtensions.IsGL_ARB_draw_buffers()) glDrawBuffersARB(m_nMaxColorTargets, db); else if (cExtensions.IsGL_ATI_draw_buffers()) glDrawBuffersATI(m_nMaxColorTargets, db); } // Else... } // ... If there's no frame buffer, we can still 'render to texture' by only using glCopyTexSubImage2D() to // copy the drawn stuff into a texture buffer. But this way, the current framebuffer content is 'overdrawn' and // the texture buffer size we can render in is limited to the screen size. // Enable/disable multisample - "shouldn't" have an effect when render to texture, but safe is safe :D GetRenderer().SetRenderState(PLRenderer::RenderState::MultisampleEnable, !(GetFlags() & NoMultisampleAntialiasing)); // Done return true; } // Error! return false; }
void PottsLabeling3_Relaxed::setZero() { glClearColor(0, 0, 0, 0); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); _uBufA->activate(); glClear(GL_COLOR_BUFFER_BIT); #if defined(GPU_POTTS_LABELING_USE_PACKED_P) _pBufA->activate(); glClear(GL_COLOR_BUFFER_BIT); #else GLenum const buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT }; _pFboA->activate(); glDrawBuffersARB(1, buffers+1); glClear(GL_COLOR_BUFFER_BIT); glDrawBuffersARB(1, buffers+0); glClear(GL_COLOR_BUFFER_BIT); #endif } // PottsLabeling3_Relaxed::setZero()
bool SurfaceTextureBuffer::MakeCurrent(uint8 nFace) { // Check whether the data is valid and whether there's a texture buffer if (m_cTextureBufferHandler.GetResource() && GetTextureBuffer()) { // Set target face if (GetTextureBuffer()->GetType() == PLRenderer::Resource::TypeTextureBufferCube) m_nFace = nFace; else m_nFace = 0; // Cleanup texture buffer handlers for (uint32 i=0; i<m_lstTextureBufferHandler.GetNumOfElements(); i++) delete m_lstTextureBufferHandler[i]; m_lstTextureBufferHandler.Clear(); // Add primary texture buffer handler PLRenderer::ResourceHandler *pTextureBufferHandler = new PLRenderer::ResourceHandler(); pTextureBufferHandler->SetResource(m_cTextureBufferHandler.GetResource()); m_lstTextureBufferHandler.Add(pTextureBufferHandler); // Frame buffer object used? if (m_pFrameBufferObject && m_cTextureBufferHandler.GetResource()) { m_pFrameBufferObject->SwitchTarget(static_cast<PLRenderer::TextureBuffer&>(*m_cTextureBufferHandler.GetResource()), 0, nFace); m_pFrameBufferObject->Bind(); // Need rendering to depth only PLRenderer::TextureBuffer::EPixelFormat nFormat = GetTextureBuffer()->GetFormat(); const Extensions &cExtensions = static_cast<Renderer&>(GetRenderer()).GetContext().GetExtensions(); if (nFormat == PLRenderer::TextureBuffer::D16 || nFormat == PLRenderer::TextureBuffer::D24 || nFormat == PLRenderer::TextureBuffer::D32) { // "GL_NV_read_buffer"-extension available? if (cExtensions.IsGL_NV_read_buffer()) glReadBufferNV(GL_NONE); } else { // "GL_ARB_draw_buffers" & "GL_NV_fbo_color_attachments" extensions available? if (cExtensions.IsGL_ARB_draw_buffers() && cExtensions.IsGL_NV_fbo_color_attachments()) { // Set draw buffers static const GLenum db[16] = { GL_COLOR_ATTACHMENT0_NV, GL_COLOR_ATTACHMENT1_NV, GL_COLOR_ATTACHMENT2_NV, GL_COLOR_ATTACHMENT3_NV, GL_COLOR_ATTACHMENT4_NV, GL_COLOR_ATTACHMENT5_NV, GL_COLOR_ATTACHMENT6_NV, GL_COLOR_ATTACHMENT7_NV, GL_COLOR_ATTACHMENT8_NV, GL_COLOR_ATTACHMENT9_NV, GL_COLOR_ATTACHMENT10_NV, GL_COLOR_ATTACHMENT11_NV, GL_COLOR_ATTACHMENT12_NV, GL_COLOR_ATTACHMENT13_NV, GL_COLOR_ATTACHMENT14_NV, GL_COLOR_ATTACHMENT15_NV}; glDrawBuffersARB(m_nMaxColorTargets, db); } } } // Enable/disable multisample - "shouldn't" have an effect when render to texture, but safe is safe :D GetRenderer().SetRenderState(PLRenderer::RenderState::MultisampleEnable, !(GetFlags() & NoMultisampleAntialiasing)); // Done return true; } // Error! return false; }
void GodRays::begin() { // start frame buffer glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId); // prenastavit viewport glViewport(0,0,g_WinWidth, g_WinHeight); glClearColor(0.f, 0.f, 0.f, 1.f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GLenum buffers[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT}; glDrawBuffersARB(2, buffers); // now render scene... }
void piglit_init(int argc, char **argv) { GLint max_dual_source; GLenum buffers[32]; int i; piglit_require_gl_version(30); piglit_require_extension("GL_ARB_blend_func_extended"); piglit_require_extension("GL_ARB_draw_buffers_blend"); /* This test needs some number of draw buffers, so make sure the * implementation isn't broken. This enables the test to generate a * useful failure message. */ glGetIntegerv(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, &max_dual_source); if (max_dual_source < 1) { fprintf(stderr, "ARB_blend_func_extended requires GL_MAX_DUAL_SOURCE_DRAW_BUFFERS >= 1. " "Only got %d!\n", max_dual_source); piglit_report_result(PIGLIT_FAIL); } max_buffers = max_dual_source + 1; create_fbo(); for (i = 0; i < max_buffers; i++) buffers[i] = GL_COLOR_ATTACHMENT0_EXT + i; glDrawBuffersARB(max_buffers, buffers); for (i = 0; i < max_buffers; i++) { if (i >= max_dual_source) glBlendFunciARB(i, GL_SRC1_ALPHA, GL_ONE_MINUS_SRC1_ALPHA); else glBlendFunciARB(i, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnableIndexedEXT(GL_BLEND, i); } glBegin(GL_QUADS); if (!piglit_check_gl_error(GL_INVALID_OPERATION)) piglit_report_result(PIGLIT_FAIL); else piglit_report_result(PIGLIT_PASS); }
void LLMultisampleBuffer::bindTarget(LLRenderTarget* ref) { if (!ref) { ref = this; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO); if (gGLManager.mHasDrawBuffers) { //setup multiple render targets GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT}; glDrawBuffersARB(ref->mTex.size(), drawbuffers); } check_framebuffer_status(); glViewport(0, 0, mResX, mResY); sBoundTarget = this; }
static void generate_and_display_drawbuffers(int count) { GLuint tex[MAX_TARGETS], fb, fs, vs, prog; GLenum attachments[MAX_TARGETS], status; char *fs_count_source; int i; int colors_uniform; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); for (i = 0; i < count; i++) { tex[i] = attach_texture(i); attachments[i] = GL_COLOR_ATTACHMENT0 + i; } 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); } glDrawBuffersARB(count, attachments); /* Clear all to red so we see if the shader rendering happens. */ glClearColor(1.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); /* Build the shader that writes different color to each buffer. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); fs_count_source = malloc(strlen(fs_source) + 5); sprintf(fs_count_source, fs_source, count); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_count_source); free(fs_count_source); prog = piglit_link_simple_program(vs, fs); glUseProgram(prog); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); colors_uniform = glGetUniformLocation(prog, "colors"); glUniform4fv(colors_uniform, MAX_TARGETS, (GLfloat *) colors); /* Now render to all the color buffers. */ piglit_draw_rect(-1, -1, 2, 2); /* OK, now draw each of these textures to the winsys framebuffer. */ glUseProgram(0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); /* draw row of boxes, each with the color from texture/target[i] */ for (i = 0; i < count; i++) { glBindTexture(GL_TEXTURE_2D, tex[i]); piglit_draw_rect_tex(16 * i, 16 * (count - 1), 16, 16, 0, 0, 1, 1); } glDisable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glDeleteTextures(1, &tex[i]); } glDeleteFramebuffersEXT(1, &fb); }
void PottsLabeling3_Relaxed::iterate(unsigned int costTexId, int nIterations) { static Cg_FragmentProgram * uShader = 0; static Cg_FragmentProgram * pShader = 0; if (uShader == 0) { uShader = new Cg_FragmentProgram("PottsLabeling3_Relaxed::uShader"); uShader->setProgramFromFile("potts_3labeling_update_u.cg"); #if defined(GPU_POTTS_LABELING_USE_PACKED_P) char const * args[] = { "-DUSE_PACKED_P=1", 0 }; uShader->compile(args); #else uShader->compile(); #endif checkGLErrorsHere0(); } if (pShader == 0) { pShader = new Cg_FragmentProgram("PottsLabeling3_Relaxed::pShader"); pShader->setProgramFromFile("potts_3labeling_update_p.cg"); #if defined(GPU_POTTS_LABELING_USE_PACKED_P) char const * args[] = { "-DUSE_PACKED_P=1", 0 }; pShader->compile(args); #else pShader->compile(); #endif checkGLErrorsHere0(); } float const ds = 1.0f/_width; float const dt = 1.0f/_height; setupNormalizedProjection(); uShader->parameter("theta", _theta); pShader->parameter("timestep_over_theta", _timestep/_theta); pShader->parameter("epsilon", _epsilon); for (int iter = 0; iter < nIterations; ++iter) { #if defined(GPU_POTTS_LABELING_USE_PACKED_P) _uBufB->activate(); //uShader->parameter("theta", theta); _uBufA->enableTexture(GL_TEXTURE0); _pBufA->enableTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, costTexId); glEnable(GL_TEXTURE_2D); uShader->enable(); renderNormalizedQuad(GPU_SAMPLE_NEIGHBORS, ds, dt); uShader->disable(); _uBufA->disableTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE2); glDisable(GL_TEXTURE_2D); std::swap(_uBufA, _uBufB); _pBufB->activate(); //pShader->parameter("timestep_over_theta", tau/theta); _uBufA->enableTexture(GL_TEXTURE0); pShader->enable(); renderNormalizedQuad(GPU_SAMPLE_NEIGHBORS, ds, dt); pShader->disable(); _uBufA->disableTexture(GL_TEXTURE0); _pBufA->disableTexture(GL_TEXTURE1); std::swap(_pBufA, _pBufB); #else _uBufB->activate(); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); //checkGLErrorsHere0(); //uShader->parameter("theta", theta); _uBufA->enableTexture(GL_TEXTURE0); _pFboA->getColorTexture(0).enable(GL_TEXTURE1); _pFboA->getColorTexture(1).enable(GL_TEXTURE2); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, costTexId); glEnable(GL_TEXTURE_2D); uShader->enable(); renderNormalizedQuad(GPU_SAMPLE_NEIGHBORS, ds, dt); uShader->disable(); _uBufA->disableTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE3); glDisable(GL_TEXTURE_2D); // _pBufA->getColorTexture(0).disable(GL_TEXTURE1); // _pBufA->getColorTexture(1).disable(GL_TEXTURE2); std::swap(_uBufA, _uBufB); //pShader->parameter("timestep_over_theta", tau/theta); _pFboB->activate(); GLenum const buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT }; glDrawBuffersARB(2, buffers); //checkGLErrorsHere0(); _uBufA->enableTexture(GL_TEXTURE0); // _pBufA->getColorTexture(0).enable(GL_TEXTURE1); // _pBufA->getColorTexture(1).enable(GL_TEXTURE2); pShader->enable(); renderNormalizedQuad(GPU_SAMPLE_NEIGHBORS, ds, dt); pShader->disable(); _uBufA->disableTexture(GL_TEXTURE0); _pFboA->getColorTexture(0).disable(GL_TEXTURE1); _pFboA->getColorTexture(1).disable(GL_TEXTURE2); std::swap(_pFboA, _pFboB); #endif } // end for (iter) } // end PottsLabeling3_Relaxed::iterate()
enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; GLuint tex0, tex1, fb; GLenum status; float green[] = {0, 1, 0, 0}; float blue[] = {0, 0, 1, 0}; 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 to blue. The first buffer will have no blending and * get overwritten green, and the second will be blended ZERO, * ONE leaving the blue in place. */ glClearColor(0.0, 0.0, 1.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glBlendFunc(GL_ZERO, GL_ONE); glDisableIndexedEXT(GL_BLEND, 0); glEnableIndexedEXT(GL_BLEND, 1); glColor4fv(green); piglit_draw_rect(0, 0, piglit_width, piglit_height); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glDisable(GL_BLEND); /* Draw the two 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, piglit_height, 0, 0, 1, 1); glDisable(GL_TEXTURE_2D); glDeleteTextures(1, &tex0); glDeleteTextures(1, &tex1); glDeleteFramebuffersEXT(1, &fb); pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/2, piglit_height, green); pass = pass && piglit_probe_rect_rgb(piglit_width/2, 0, piglit_width/2, piglit_height, blue); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void PottsLabeling4_LevelFun::iterate(unsigned int costTexId, int nIterations) { static Cg_FragmentProgram * uShader = 0; static Cg_FragmentProgram * pqShader = 0; if (uShader == 0) { uShader = new Cg_FragmentProgram("PottsLabeling4_LevelFun::uShader"); uShader->setProgramFromFile("potts_4labeling_levelfun_update_u.cg"); uShader->compile(); checkGLErrorsHere0(); } if (pqShader == 0) { pqShader = new Cg_FragmentProgram("PottsLabeling4_LevelFun::pqShader"); pqShader->setProgramFromFile("potts_4labeling_levelfun_update_pq.cg"); pqShader->compile(); checkGLErrorsHere0(); } float const ds = 1.0f/_width; float const dt = 1.0f/_height; setupNormalizedProjection(); uShader->parameter("tau", _tau_primal); pqShader->parameter("tau", _tau_dual); for (int iter = 0; iter < nIterations; ++iter) { _uBufB->activate(); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); _uBufA->enableTexture(GL_TEXTURE0); _pFboA->getColorTexture(0).enable(GL_TEXTURE1); _pFboA->getColorTexture(1).enable(GL_TEXTURE2); _pFboA->getColorTexture(2).enable(GL_TEXTURE3); uShader->enable(); renderNormalizedQuad(GPU_SAMPLE_NEIGHBORS, ds, dt); uShader->disable(); _uBufA->disableTexture(GL_TEXTURE0); std::swap(_uBufA, _uBufB); _pFboB->activate(); GLenum const buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT }; glDrawBuffersARB(3, buffers); _uBufA->enableTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, costTexId); glEnable(GL_TEXTURE_2D); pqShader->enable(); renderNormalizedQuad(GPU_SAMPLE_NEIGHBORS, ds, dt); pqShader->disable(); _uBufA->disableTexture(GL_TEXTURE0); _pFboA->getColorTexture(0).disable(GL_TEXTURE1); _pFboA->getColorTexture(1).disable(GL_TEXTURE2); _pFboA->getColorTexture(2).disable(GL_TEXTURE3); glActiveTexture(GL_TEXTURE4); glDisable(GL_TEXTURE_2D); std::swap(_pFboA, _pFboB); } // end for (iter) } // end PottsLabeling4_LevelFun::iterate()
enum piglit_result piglit_display(void) { static GLenum buffers[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT}; static const float red[] = {1.0f, 0.0f, 0.0f}; static const float green[] = {0.0f, 1.0f, 0.0f}; static const float blue[] = {0.0f, 0.0f, 1.0f}; static const struct { GLsizei buffer_count; const float *clear_color; const float *expected_0; const float *expected_1; } tests[] = { {2, red, red, red}, {1, green, green, red}, {2, blue, blue, blue}, }; int w = piglit_width; int h = piglit_height; GLuint fbo, tex[2]; unsigned i; glGenTextures(2, tex); glBindTexture(GL_TEXTURE_2D, tex[0]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); glBindTexture(GL_TEXTURE_2D, tex[1]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); glGenFramebuffersEXT(1, &fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex[0], 0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, tex[1], 0); check_fbo_status(); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); for (i = 0; i < sizeof(tests) / sizeof(*tests); ++i) { GLint buffer, expected_buffer; glDrawBuffersARB(tests[i].buffer_count, buffers); check_fbo_status(); glGetIntegerv(GL_DRAW_BUFFER1_ARB, &buffer); expected_buffer = tests[i].buffer_count < 2 ? GL_NONE : GL_COLOR_ATTACHMENT1_EXT; if (buffer != expected_buffer) { printf("Unexpected buffer %#x for DRAW_BUFFER1_ARB in test %u, expected %#x.\n", buffer, i, expected_buffer); piglit_report_result(PIGLIT_FAIL); } glClearColor(tests[i].clear_color[0], tests[i].clear_color[1], tests[i].clear_color[2], 1.0f); glClear(GL_COLOR_BUFFER_BIT); glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); if (!piglit_probe_pixel_rgb(w / 2, h / 2, tests[i].expected_0)) { printf("Probe failed for test %u, attachment 0.\n", i); piglit_report_result(PIGLIT_FAIL); } glReadBuffer(GL_COLOR_ATTACHMENT1_EXT); if (!piglit_probe_pixel_rgb(w / 2, h / 2, tests[i].expected_1)) { printf("Probe failed for test %u, attachment 1.\n", i); piglit_report_result(PIGLIT_FAIL); } } if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); return PIGLIT_PASS; }
enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; GLuint tex0, tex1, fb; GLenum status; float white[] = {1, 1, 1, 1}; float green[] = {0, 1, 0, 0}; float blue[] = {0, 0, 1, 0}; 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 to black */ glClearColor(0.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); /* Mask only green in RT 0, blue in RT 1, then try to draw in white */ glColorMaskIndexedEXT(0, GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE); glColorMaskIndexedEXT(1, GL_FALSE, GL_FALSE, GL_TRUE, GL_FALSE); if (test_clear) { glClearColor(1.0, 1.0, 1.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); } else { glColor4fv(white); piglit_draw_rect(0, 0, piglit_width, piglit_height); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); /* Draw the two 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, piglit_height, 0, 0, 1, 1); glDisable(GL_TEXTURE_2D); glDeleteTextures(1, &tex0); glDeleteTextures(1, &tex1); glDeleteFramebuffersEXT(1, &fb); pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/2, piglit_height, green); pass = pass && piglit_probe_rect_rgb(piglit_width/2, 0, piglit_width/2, piglit_height, blue); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
static void Display(void) { GLubyte *buffer = malloc(Width * Height * 4); static const GLenum buffers[2] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT }; glUseProgram(Program); glEnable(GL_DEPTH_TEST); /* draw to user framebuffer */ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FBobject); /* Clear color buffer 0 (blue) */ glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); glClear(GL_COLOR_BUFFER_BIT); /* Clear color buffer 1 (1 - blue) */ glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT); glClear(GL_COLOR_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT); /* draw to two buffers w/ fragment shader */ glDrawBuffersARB(2, buffers); /* different color masks for each buffer */ if (1) { glColorMaskIndexedEXT(0, GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE); glColorMaskIndexedEXT(1, GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE); } glPushMatrix(); glRotatef(Xrot, 1, 0, 0); glRotatef(Yrot, 0, 1, 0); glPushMatrix(); glTranslatef(1, 0, 0); glutSolidTorus(1.0, 2.0, 10, 20); glPopMatrix(); glPushMatrix(); glTranslatef(-1, 0, 0); glRotatef(90, 1, 0, 0); glutSolidTorus(1.0, 2.0, 10, 20); glPopMatrix(); glPopMatrix(); /* restore default color masks */ glColorMaskIndexedEXT(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glColorMaskIndexedEXT(1, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); /* read from user framebuffer */ /* left half = colorbuffer 0 */ glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); glPixelStorei(GL_PACK_ROW_LENGTH, Width); glPixelStorei(GL_PACK_SKIP_PIXELS, 0); glReadPixels(0, 0, Width / 2, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); /* right half = colorbuffer 1 */ glReadBuffer(GL_COLOR_ATTACHMENT1_EXT); glPixelStorei(GL_PACK_SKIP_PIXELS, Width / 2); glReadPixels(Width / 2, 0, Width - Width / 2, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); /* draw to window */ glUseProgram(0); glDisable(GL_DEPTH_TEST); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glWindowPos2iARB(0, 0); glDrawPixels(Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); free(buffer); glutSwapBuffers(); CheckError(__LINE__); }
static void generate_and_display_drawbuffers(int count) { GLuint tex[16], fb, fs, vs, prog; GLenum attachments[16], status, error; char *fs_count_source; int i; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); for (i = 0; i < count; i++) { tex[i] = attach_texture(i); attachments[i] = GL_COLOR_ATTACHMENT0 + i; } 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); } glDrawBuffersARB(count, attachments); /* Clear all to red so we see if the shader rendering happens. */ glClearColor(1.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); /* Build the shader that spams green to all outputs. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); fs_count_source = malloc(strlen(fs_source) + 5); sprintf(fs_count_source, fs_source, count); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_count_source); free(fs_count_source); prog = piglit_link_simple_program(vs, fs); glUseProgram(prog); error = glGetError(); if (error) { fprintf(stderr, "glUseProgram error: 0x%x\n", error); piglit_report_result(PIGLIT_FAIL); } /* Now render to all the color buffers. */ piglit_draw_rect(-1, -1, 2, 2); /* OK, now draw each of these textures to the winsys framebuffer. */ glUseProgram(0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glBindTexture(GL_TEXTURE_2D, tex[i]); piglit_draw_rect_tex(16 * i, 16 * (count - 1), 16, 16, 0, 0, 1, 1); } glDisable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glDeleteTextures(1, &tex[i]); } glDeleteFramebuffersEXT(1, &fb); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBDrawBuffers_nglDrawBuffersARB(JNIEnv *env, jclass clazz, jint size, jobject buffers, jint buffers_position, jlong function_pointer) { const GLenum *buffers_address = ((const GLenum *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position; glDrawBuffersARBPROC glDrawBuffersARB = (glDrawBuffersARBPROC)((intptr_t)function_pointer); glDrawBuffersARB(size, buffers_address); }
static void generate_and_display_drawbuffers(int count) { GLuint tex[16], fb, fs, vs, prog; GLenum attachments[16], status; int i; char fs_output_line[256]; char fs_full_source[1024]; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); for (i = 0; i < count; i++) { tex[i] = attach_texture(i); attachments[i] = GL_COLOR_ATTACHMENT0 + i; } 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); } glDrawBuffersARB(count, attachments); /* Clear all to 0.25 so we see if the shader rendering happens. */ glClearColor(clear_value, clear_value, clear_value, clear_value); glClear(GL_COLOR_BUFFER_BIT); /* Build the shader that spams green to all outputs. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); strcpy(fs_full_source, fs_source_start); for (i = 0; i < count; i++) { sprintf(fs_output_line, fs_source_output, i, output_values[i * 4], output_values[(i * 4) + 1], output_values[(i * 4) + 2], output_values[(i * 4) + 3]); strcat(fs_full_source, fs_output_line); } strcat(fs_full_source, fs_source_end); assert(strlen(fs_full_source) + 1 < sizeof(fs_full_source) / sizeof(fs_full_source[0])); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_full_source); prog = piglit_link_simple_program(vs, fs); glUseProgram(prog); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); /* Now render to all the color buffers. */ piglit_draw_rect(-1, -1, 2, 2); glDisable(GL_BLEND); /* OK, now draw each of these textures to the winsys framebuffer. */ glUseProgram(0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glBindTexture(GL_TEXTURE_2D, tex[i]); piglit_draw_rect_tex(16 * i, 16 * (count - 1), 16, 16, 0, 0, 1, 1); } glDisable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glDeleteTextures(1, &tex[i]); } glDeleteFramebuffersEXT(1, &fb); }
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; }
static enum piglit_result test(void) { GLenum buffers[32]; static const GLfloat dest_color[4] = { 0.75, 0.25, 0.25, 0.5 }; static const GLfloat test_color[4] = { 1.0, 0.25, 0.75, 0.25 }; GLfloat expected[32][4]; int i; create_fbo(); for (i = 0; i < maxBuffers; i++) { buffers[i] = GL_COLOR_ATTACHMENT0_EXT + i; } glDrawBuffersARB(maxBuffers, buffers); /* Setup blend modes and compute expected result color. * We only test two simple blending modes. A more elaborate * test would exercise a much wider variety of modes. */ for (i = 0; i < maxBuffers; i++) { if (i % 2 == 0) { float a; glBlendFunciARB(i, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); a = test_color[3]; expected[i][0] = test_color[0] * a + dest_color[0] * (1.0 - a); expected[i][1] = test_color[1] * a + dest_color[1] * (1.0 - a); expected[i][2] = test_color[2] * a + dest_color[2] * (1.0 - a); expected[i][3] = test_color[3] * a + dest_color[3] * (1.0 - a); } else { glBlendFunciARB(i, GL_ONE, GL_ONE); glBlendEquationiARB(i, GL_FUNC_SUBTRACT); expected[i][0] = test_color[0] - dest_color[0]; expected[i][1] = test_color[1] - dest_color[1]; expected[i][2] = test_color[2] - dest_color[2]; expected[i][3] = test_color[3] - dest_color[3]; } expected[i][0] = CLAMP(expected[i][0], 0.0, 1.0); expected[i][1] = CLAMP(expected[i][1], 0.0, 1.0); expected[i][2] = CLAMP(expected[i][2], 0.0, 1.0); expected[i][3] = CLAMP(expected[i][3], 0.0, 1.0); glEnableIndexedEXT(GL_BLEND, i); } /* query blend modes */ for (i = 0; i < maxBuffers; i++) { GLint p0, p1, p2, p3; glGetIntegerIndexedvEXT(GL_BLEND_SRC, i, &p0); glGetIntegerIndexedvEXT(GL_BLEND_DST, i, &p1); glGetIntegerIndexedvEXT(GL_BLEND_EQUATION, i, &p2); glGetIntegerIndexedvEXT(GL_BLEND, i, &p3); if (i % 2 == 0) { MY_ASSERT(p0 == GL_SRC_ALPHA); MY_ASSERT(p1 == GL_ONE_MINUS_SRC_ALPHA); MY_ASSERT(p2 == GL_FUNC_ADD); } else { MY_ASSERT(p0 == GL_ONE); MY_ASSERT(p1 == GL_ONE); MY_ASSERT(p2 == GL_FUNC_SUBTRACT); } MY_ASSERT(p3 == GL_TRUE); } /* test drawing */ glClearColor(dest_color[0], dest_color[1], dest_color[2], dest_color[3]); glClear(GL_COLOR_BUFFER_BIT); glColor4fv(test_color); piglit_draw_rect(0, 0, piglit_width, piglit_height); for (i = 0; i < maxBuffers; i++) { glReadBuffer(GL_COLOR_ATTACHMENT0_EXT + i); check_error(__LINE__); if (!piglit_probe_pixel_rgba(5, 5, expected[i])) { printf("For color buffer %d\n", i); return PIGLIT_FAIL; } } return PIGLIT_PASS; }