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;
}
