void GraphicsContext3D::deleteFramebuffer(Platform3DObject framebuffer)
{
makeContextCurrent();
glDeleteFramebuffersEXT(1, &framebuffer);
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint fbo, tex, pbo;
uint32_t *addr;
make_fbo(&fbo, &tex);
glClear(GL_COLOR_BUFFER_BIT);
glGenBuffersARB(1, &pbo);
glBindBufferARB(GL_PIXEL_PACK_BUFFER, pbo);
glBufferDataARB(GL_PIXEL_PACK_BUFFER, 4 * 4, NULL, GL_STREAM_DRAW_ARB);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glViewport(0, 0, 2, 2);
piglit_ortho_projection(2, 2, GL_FALSE);
/* bottom: green. top: blue. */
glColor4f(0.0, 1.0, 0.0, 0.0);
piglit_draw_rect(0, 0, 2, 1);
glColor4f(0.0, 0.0, 1.0, 0.0);
piglit_draw_rect(0, 1, 2, 1);
/* Read the whole buffer. */
glReadPixels(0, 0, 2, 2,
GL_BGRA, GL_UNSIGNED_BYTE, (void *)(uintptr_t)0);
addr = glMapBufferARB(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY_ARB);
pass &= probe(0, 0, 0x0000ff00, addr[0]);
pass &= probe(1, 0, 0x0000ff00, addr[1]);
pass &= probe(0, 1, 0x000000ff, addr[2]);
pass &= probe(1, 1, 0x000000ff, addr[3]);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER);
/* Read with an offset. */
glReadPixels(1, 0, 1, 1,
GL_BGRA, GL_UNSIGNED_BYTE, (void *)(uintptr_t)4);
addr = glMapBufferARB(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY_ARB);
pass &= probe(1, 0, 0x0000ff00, addr[1]);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER);
/* Read with an offset. */
glReadPixels(1, 1, 1, 1,
GL_BGRA, GL_UNSIGNED_BYTE, (void *)(uintptr_t)4);
addr = glMapBufferARB(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY_ARB);
pass &= probe(1, 1, 0x000000ff, addr[1]);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER);
glDeleteBuffersARB(1, &pbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindTexture(GL_TEXTURE_2D, tex);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_draw_rect_tex(0, 0, piglit_width, piglit_height,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteFramebuffersEXT(1, &fbo);
glDeleteTextures(1, &tex);
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static void create_1d_fbo(GLuint *out_tex, GLuint *out_ds)
{
GLuint tex, ds, fb;
GLenum status;
/* Create the color buffer. */
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_1D, tex);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA,
BUF_WIDTH,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
assert(glGetError() == 0);
/* Create the depth-stencil buffer. */
glGenTextures(1, &ds);
glBindTexture(GL_TEXTURE_1D, ds);
glTexImage1D(GL_TEXTURE_1D, 0, f.iformat, BUF_WIDTH, 0, f.format, f.type, NULL);
assert(glGetError() == 0);
/* Create the FBO. */
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_1D,
tex,
0);
glFramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_TEXTURE_1D,
ds,
0);
if (f.format == GL_DEPTH_STENCIL) {
glFramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
GL_STENCIL_ATTACHMENT_EXT,
GL_TEXTURE_1D,
ds,
0);
}
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
piglit_report_result(PIGLIT_SKIP);
}
glViewport(0, 0, BUF_WIDTH, 1);
glClearDepth(1);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glDepthRange(0, 0);
glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
piglit_ortho_projection(BUF_WIDTH, 1, GL_FALSE);
/* green */
glColor4f(0.0, 1.0, 0.0, 0.0);
piglit_draw_rect(0, 0, BUF_WIDTH, 1);
glDeleteFramebuffersEXT(1, &fb);
*out_tex = tex;
*out_ds = ds;
}
/**
* Render the six faces of a cube map.
*/
static void
RenderCubeMap(void)
{
GLuint fbo, face, depthStencilRb;
GLint cubeSize;
CheckError(__LINE__);
cubeSize = ChooseCubeSize();
printf("Rendering %d x %d cube texture\n", cubeSize, cubeSize);
CubeTexture = CreateCubeTexture(cubeSize);
/*
* Make FBO.
*/
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
/*
* Make depth/stencil renderbuffer.
*/
glGenRenderbuffersEXT(1, &depthStencilRb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthStencilRb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL,
cubeSize, cubeSize);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, depthStencilRb);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
GL_STENCIL_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, depthStencilRb);
glClearColor(0.25, 0.25, 0.25, 1.0);
glViewport(0, 0, cubeSize, cubeSize);
/*
* Render into cube faces.
*/
for (face = 0; face < 6; face++) {
GLenum status;
/* Render color into face of cubemap */
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_CUBE_MAP_POSITIVE_X + face,
CubeTexture, 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
CheckError(__LINE__);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO not complete! status = 0x%04x\n", status);
assert(status == GL_FRAMEBUFFER_COMPLETE_EXT);
}
CheckError(__LINE__);
/* Render the depth image into cube face */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SetupCubeFaceView(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, SpherePos);
DrawScene();
}
glDeleteRenderbuffersEXT(1, &depthStencilRb);
glDeleteFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
CheckError(__LINE__);
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint tex, fb;
GLenum status;
float fbo_white[] = {0.0, 0.0, 0.0, 1.0};
float fbo_black[] = {0.0, 0.0, 0.0, 0.0};
float fbo_gray[] = {0.0, 0.0, 0.0, 0.5};
float white[] = {1.0, 1.0, 1.0, 1.0};
float black[] = {0.0, 0.0, 0.0, 0.0};
float gray[] = {0.5, 0.5, 0.5, 0.5};
int fbo_width = 64;
int fbo_height = 64;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glViewport(0, 0, fbo_width, fbo_height);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA,
fbo_width, fbo_height, 0,
GL_ALPHA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status);
piglit_report_result(PIGLIT_SKIP);
}
/* Clear to no alpha. */
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor4f(0.0, 0.0, 0.0, 0.0);
piglit_draw_rect(-1.0, -1.0, 0.5, 2.0);
glColor4f(0.0, 0.0, 0.0, 1.0);
piglit_draw_rect(-0.5, -1.0, 0.5, 2.0);
glColor4f(0.0, 0.0, 0.0, 0.5);
piglit_draw_rect(0.0, -1.0, 0.5, 2.0);
glEnable(GL_BLEND);
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
glColor4f(0.0, 0.0, 0.0, 1.0);
piglit_draw_rect(0.0, -1.0, 0.5, 2.0);
glDisable(GL_BLEND);
glColor4f(0.0, 0.0, 0.0, 0.5);
piglit_draw_rect(0.5, -1.0, 0.5, 2.0);
glEnable(GL_BLEND);
glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
glColor4f(0.0, 0.0, 0.0, 1.0);
piglit_draw_rect(0.5, -1.0, 0.5, 2.0);
glDisable(GL_BLEND);
printf("Testing FBO result.\n");
pass = piglit_probe_pixel_rgba(fbo_width * 1 / 8, 0, fbo_black) && pass;
pass = piglit_probe_pixel_rgba(fbo_width * 3 / 8, 0, fbo_white) && pass;
pass = piglit_probe_pixel_rgba(fbo_width * 5 / 8, 0, fbo_gray) && pass;
pass = piglit_probe_pixel_rgba(fbo_width * 7 / 8, 0, fbo_gray) && pass;
/* Draw the two textures to halves of the window. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glViewport(0, 0, piglit_width, piglit_height);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_ALPHA);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glBindTexture(GL_TEXTURE_2D, tex);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex);
glDeleteFramebuffersEXT(1, &fb);
printf("Testing window result.\n");
pass = piglit_probe_pixel_rgba(piglit_width * 1 / 8, 0, black) && pass;
pass = piglit_probe_pixel_rgba(piglit_width * 3 / 8, 0, white) && pass;
pass = piglit_probe_pixel_rgba(piglit_width * 5 / 8, 0, gray) && pass;
pass = piglit_probe_pixel_rgba(piglit_width * 7 / 8, 0, gray) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool _al_ogl_create_persistent_fbo(ALLEGRO_BITMAP *bitmap)
{
ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap;
ALLEGRO_FBO_INFO *info;
GLint old_fbo, e;
if (bitmap->parent)
bitmap = bitmap->parent;
ogl_bitmap = bitmap->extra;
/* Don't continue if the bitmap does not belong to the current display. */
if (_al_get_bitmap_display(bitmap)->ogl_extras->is_shared == false &&
_al_get_bitmap_display(bitmap) != al_get_current_display()) {
return false;
}
if (ogl_bitmap->is_backbuffer) {
return false;
}
ASSERT(!ogl_bitmap->fbo_info);
info = al_malloc(sizeof(ALLEGRO_FBO_INFO));
if (ANDROID_PROGRAMMABLE_PIPELINE(al_get_current_display())) {
glGenFramebuffers(1, &info->fbo);
}
else {
glGenFramebuffersEXT(1, &info->fbo);
}
if (info->fbo == 0) {
al_free(info);
return false;
}
old_fbo = _al_ogl_bind_framebuffer(info->fbo);
if (ANDROID_PROGRAMMABLE_PIPELINE(al_get_current_display())) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, ogl_bitmap->texture, 0);
}
else {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, ogl_bitmap->texture, 0);
}
e = glGetError();
if (e) {
ALLEGRO_DEBUG("glFrameBufferTexture2DEXT failed! fbo=%d texture=%d (%s)",
info->fbo, ogl_bitmap->texture, _al_gl_error_string(e));
}
/* You'll see this a couple times in this file: some ES 1.1 functions aren't
* implemented on Android. This is an ugly workaround.
*/
if (UNLESS_ANDROID_OR_RPI(
glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT))
{
ALLEGRO_ERROR("FBO incomplete.\n");
_al_ogl_bind_framebuffer(old_fbo);
glDeleteFramebuffersEXT(1, &info->fbo);
al_free(info);
return false;
}
_al_ogl_bind_framebuffer(old_fbo);
info->fbo_state = FBO_INFO_PERSISTENT;
info->owner = bitmap;
info->last_use_time = al_get_time();
ogl_bitmap->fbo_info = info;
ALLEGRO_DEBUG("Persistent FBO: %u\n", info->fbo);
return true;
}
void MGLContext::deleteFrameBuffer(unsigned int * frameBufferId){
glDeleteFramebuffersEXT(1, frameBufferId);
}
DiGLFrameBuffer::~DiGLFrameBuffer()
{
glDeleteFramebuffersEXT(1, &mFBOId);
}
static int
create_cube_fbo(void)
{
GLuint tex, fb;
GLenum status;
int face, dim;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
for (face = 0; face < 6; face++) {
int level = 0;
for (dim = BUF_WIDTH; dim > 0; dim /= 2) {
glTexImage2D(cube_face_targets[face], level, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
level++;
}
}
assert(glGetError() == 0);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (face = 0; face < 6; face++) {
int level = 0;
for (dim = BUF_WIDTH; dim > 0; dim /= 2) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
cube_face_targets[face],
tex,
level);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
goto done;
}
glViewport(0, 0, dim, dim);
piglit_ortho_projection(dim, dim, GL_FALSE);
glColor4fv(get_face_color(face, level));
/* Draw a little outside the bounds to make
* sure clipping's working.
*/
piglit_draw_rect(-2, -2, dim + 2, dim + 2);
level++;
}
}
done:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return tex;
}
DiGLFBOManager::~DiGLFBOManager()
{
glDeleteFramebuffersEXT(1, &mTempFBO);
}
void DiGLFBOManager::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 (uint32 x = 0; x < PIXEL_FORMAT_MAX; ++x)
{
mProps[x].valid = false;
GLenum fmt = DiGLTypeMappings::GLInternalFormatMapping[(DiPixelFormat)x];
if (fmt == GL_NONE && x != 0)
continue;
if (DiPixelBox::IsCompressedFormat((DiPixelFormat)x))
continue;
// Buggy ATI cards *crash* on non-RGB(A) formats
int depths[4];
DiPixelBox::GetBitDepths((DiPixelFormat)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;
// 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)
{
if (TryFormat(depthFormats[depth], stencilFormats[stencil]))
{
/// Add mode to allowed modes
FormatProperties::Mode mode;
mode.depth = depth;
mode.stencil = stencil;
mProps[x].modes.push_back(mode);
}
}
}
else
{
if (TryPackedFormat(depthFormats[depth]))
{
/// Add mode to allowed modes
FormatProperties::Mode mode;
mode.depth = depth;
mode.stencil = 0;
mProps[x].modes.push_back(mode);
}
}
}
}
// 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);
for (size_t x = 0; x < PIXEL_FORMAT_MAX; ++x)
{
if (mProps[x].valid)
{
DI_INFO("Valid format for FBO targets: %s", DiPixelBox::GetPixelTypeName((DiPixelFormat)x).c_str());
}
}
}
GLRenderTarget::~GLRenderTarget() {
glDeleteFramebuffersEXT(1, &fboId);
}
Raycaster::DataItem::~DataItem(void)
{
/* Destroy the depth texture and framebuffer: */
glDeleteFramebuffersEXT(1,&depthFramebufferID);
glDeleteTextures(1,&depthTextureID);
}
void GPU_offscreen_read_pixels(GPUOffScreen *ofs, int type, void *pixels)
{
const int w = GPU_texture_width(ofs->color);
const int h = GPU_texture_height(ofs->color);
if (GPU_texture_target(ofs->color) == GL_TEXTURE_2D_MULTISAMPLE) {
/* For a multi-sample texture,
* we need to create an intermediate buffer to blit to,
* before its copied using 'glReadPixels' */
/* not needed since 'ofs' needs to be bound to the framebuffer already */
// #define USE_FBO_CTX_SWITCH
GLuint fbo_blit = 0;
GLuint tex_blit = 0;
GLenum status;
/* create texture for new 'fbo_blit' */
glGenTextures(1, &tex_blit);
if (!tex_blit) {
goto finally;
}
glBindTexture(GL_TEXTURE_2D, tex_blit);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, type, 0);
#ifdef USE_FBO_CTX_SWITCH
/* read from multi-sample buffer */
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, ofs->color->fb->object);
glFramebufferTexture2DEXT(
GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + ofs->color->fb_attachment,
GL_TEXTURE_2D_MULTISAMPLE, ofs->color->bindcode, 0);
status = glCheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
goto finally;
}
#endif
/* write into new single-sample buffer */
glGenFramebuffersEXT(1, &fbo_blit);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo_blit);
glFramebufferTexture2DEXT(
GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, tex_blit, 0);
status = glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
goto finally;
}
/* perform the copy */
glBlitFramebufferEXT(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
/* read the results */
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo_blit);
glReadPixels(0, 0, w, h, GL_RGBA, type, pixels);
#ifdef USE_FBO_CTX_SWITCH
/* restore the original frame-bufer */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, ofs->color->fb->object);
#undef USE_FBO_CTX_SWITCH
#endif
finally:
/* cleanup */
if (tex_blit) {
glDeleteTextures(1, &tex_blit);
}
if (fbo_blit) {
glDeleteFramebuffersEXT(1, &fbo_blit);
}
GPU_ASSERT_NO_GL_ERRORS("Read Multi-Sample Pixels");
}
else {
glReadPixels(0, 0, w, h, GL_RGBA, type, pixels);
}
}
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);
}
/* Cleanup. */
glDeleteFramebuffersEXT(1, &fb);
glDeleteRenderbuffersEXT(1, &rb);
glutSwapBuffers();
assert(glGetError() == 0);
return res;
}
Framebuffer::~Framebuffer () {
if (framebufferID != 0) {
glDeleteFramebuffersEXT(1, &framebufferID);
framebufferID = 0;
}
}
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);
}
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);
}
FrameBuffer::~FrameBuffer()
{
glDeleteFramebuffersEXT(1, &frameBufferObject);
glDeleteRenderbuffersEXT( 1, &depthbuffer );
}
framebuffer_obj_t::~framebuffer_obj_t()
{
if( id_)
glDeleteFramebuffersEXT( 1, &id_);
}
FramebufferObject::~FramebufferObject()
{
glDeleteFramebuffersEXT(1, &id_);
}
bool spoutGLDXinterop::CreateInterop(HWND hWnd, char* sendername, unsigned int width, unsigned int height, DWORD dwFormat, bool bReceive)
{
bool bRet = true;
DWORD format;
D3DFORMAT DX9format = D3DFMT_A8R8G8B8; // fixed format for DX9 (21)
// Needs an openGL context to work
if(!wglGetCurrentContext()) {
// MessageBoxA(NULL, "CreateInterop - no GL context", "Warning", MB_OK);
return false;
}
if(bUseDX9) {
// printf("CreateInterop - DX9 mode - format D3DFMT_A8R8G8B8 (%d) \n", DX9format);
// DirectX 9
format = (DWORD)DX9format;
}
else {
// DirectX 11
// Is this a DX11 texture or a DX9 sender texture?
if(dwFormat > 0) {
// printf("CreateInterop - DX11 mode - format %d \n", dwFormat);
format = (DXGI_FORMAT)dwFormat;
}
else {
// printf("CreateInterop - DX11 mode - default compatible format %d \n", DX11format);
format = (DWORD)DX11format; // DXGI_FORMAT_B8G8R8A8_UNORM default compatible with DX9
}
}
// Formats
// DXGI_FORMAT_R8G8B8A8_UNORM; // default DX11 format - not compatible with DX9 (28)
// DXGI_FORMAT_B8G8R8A8_UNORM; // compatoble DX11 format - works with DX9 (87)
// Quit now if the receiver can't access the shared memory info of the sender
// Otherwise m_dxShareHandle is set by getSharedTextureInfo and is the
// shared texture handle of the Sender texture
if (bReceive && !getSharedTextureInfo(sendername)) {
// printf("CreateInterop error 1\n");
return false;
}
// Check the sender format for a DX9 receiver
// It can only be from a DX9 sender (format 0)
// or from a compatible DX11 sender (format 87)
if(bReceive && bUseDX9) {
if(!(m_TextureInfo.format == 0 || m_TextureInfo.format == 87)) {
// printf("CreateInterop - Incompatible format %d \n", m_TextureInfo.format);
return false;
}
}
// Make sure DirectX has been initialized
// Creates a global pointer to the DirectX device (DX11 g_pd3dDevice or DX9 m_pDevice)
if(!OpenDirectX(hWnd, bUseDX9)) {
return false;
}
// Allow for sender updates
// When a sender size changes, the new texture has to be re-registered
if(m_hInteropDevice != NULL && m_hInteropObject != NULL) {
// printf("CreateInterop - wglDXUnregisterObjectNV\n");
wglDXUnregisterObjectNV(m_hInteropDevice, m_hInteropObject);
m_hInteropObject = NULL;
}
// Create an fbo for copying textures
if(m_fbo) {
// Delete the fbo before the texture so that any texture attachment is released
// printf("CreateInterop - deleting fbo\n");
glDeleteFramebuffersEXT(1, &m_fbo);
m_fbo = 0;
}
glGenFramebuffersEXT(1, &m_fbo);
// Create a local opengl texture that will be linked to a shared DirectX texture
if(m_glTexture) {
// printf("CreateInterop - deleting texture\n");
glDeleteTextures(1, &m_glTexture);
m_glTexture = 0;
}
glGenTextures(1, &m_glTexture);
// Create textures and GLDX interop objects
if(bUseDX9) bRet = CreateDX9interop(width, height, format, bReceive);
else bRet = CreateDX11interop(width, height, format, bReceive);
if(!bRet) {
// printf("CreateInterop error 2\n");
return false;
}
// Now the global shared texture handle - m_dxShareHandle - has been set so a sender can be created
// this creates the sender shared memory map and registers the sender
if (!bReceive) {
// We are done with the format
// So for DirectX 9, set to zero to identify the sender as DirectX 9
if(bUseDX9) format = 0;
if(!senders.CreateSender(sendername, width, height, m_dxShareHandle, format))
return false;
}
// Set up local values for this instance
// Needed for texture read and write size checks
m_TextureInfo.width = (unsigned __int32)width;
m_TextureInfo.height = (unsigned __int32)height;
m_TextureInfo.shareHandle = (unsigned __int32)m_dxShareHandle;
m_TextureInfo.format = format;
// Initialize general texture transfer sync mutex - either sender or receiver can do this
spoutdx.CreateAccessMutex(sendername, m_hAccessMutex);
// Now it has initialized OK
m_bInitialized = true;
//
// Now we have globals for this instance
//
// m_TextureInfo.width - width of the texture
// m_TextureInfo.height - height of the texture
// m_TextureInfo.shareHandle - handle of the shared texture
// m_TextureInfo.format - format of the texture
// m_glTexture - a linked opengl texture
// m_dxTexture - a linked, shared DirectX texture created here
// m_hInteropDevice - handle to interop device created by wglDXOpenDeviceNV by init
// m_hInteropObject - handle to the connected texture created by wglDXRegisterObjectNV
// m_hAccessMutex - mutex for texture access lock
// m_bInitialized - whether it initialized OK
// true means the init was OK, not the connection
return true;
}
~Framebuffer(){
glDeleteFramebuffersEXT(1, &m_id);
glDeleteRenderbuffersEXT(1, &m_depth_rbo);
glDeleteTextures(1, &m_texture);
}
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, 0);
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;
}
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
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);
glDrawBuffersATI(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, piglit_winsys_fbo);
/* 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);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
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;
}
static int create_fbo(void)
{
GLuint tex, fb;
GLint maxsize;
GLenum status;
int x0, x1, y0, y1;
GLenum glerror;
maxsize = find_max_texture_size();
printf("max 2D texture size: %d x %d\n", maxsize, maxsize);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, maxsize, maxsize,
0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glerror = glGetError();
switch (glerror) {
case GL_NO_ERROR:
break;
case GL_OUT_OF_MEMORY:
puts("Got GL_OUT_OF_MEMORY.");
piglit_report_result(PIGLIT_PASS);
default:
printf("Unexpected error: %s\n",
piglit_get_gl_enum_name(glerror));
piglit_report_result(PIGLIT_FAIL);
}
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex, 0);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("FBO incomplete\n");
piglit_report_result(PIGLIT_SKIP);
}
glViewport(0, 0, maxsize, maxsize);
piglit_ortho_projection(maxsize, maxsize, GL_FALSE);
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
x0 = maxsize / 4;
x1 = maxsize * 3 / 4;
y0 = maxsize / 4;
y1 = maxsize * 3 / 4;
draw_color_sub_rect(x0, y0, maxsize);
draw_color_sub_rect(x1, y0, maxsize);
draw_color_sub_rect(x1, y1, maxsize);
draw_color_sub_rect(x0, y1, maxsize);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return tex;
}
//----------------------------------------------------------------------------
void OpenGL::DestroyFrameBuffer (GLuint& framebuffer)
{
glDeleteFramebuffersEXT(1, &framebuffer);
framebuffer = 0;
}
void ShutDown(GLvoid)
{
glDeleteFramebuffersEXT(1, &fbo);
glDeleteRenderbuffersEXT(1, &depthBuffer);
glDeleteTextures(1,&img);
}
void
piglit_init(int argc, char **argv)
{
GLint max_samples, sample_buffers, samples, rb_samples;
GLuint rb, fb;
GLenum status;
bool pass = true;
int i;
piglit_require_extension("GL_EXT_framebuffer_multisample");
glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER, fb);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glReadBuffer(GL_COLOR_ATTACHMENT0);
for (i = 0; i < max_samples; i++) {
glGenRenderbuffersEXT(1, &rb);
glBindRenderbufferEXT(GL_RENDERBUFFER, rb);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
max_samples,
GL_RGBA, 1, 1);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, rb);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetRenderbufferParameterivEXT(GL_RENDERBUFFER,
GL_RENDERBUFFER_SAMPLES,
&rb_samples);
glGetIntegerv(GL_SAMPLES, &samples);
if (rb_samples != samples) {
fprintf(stderr,
"FBO reported GL_SAMPLES %d for "
"rb samples %d\n",
samples, rb_samples);
pass = false;
}
glGetIntegerv(GL_SAMPLE_BUFFERS, &sample_buffers);
if ((rb_samples != 0) != (sample_buffers == 1)) {
fprintf(stderr,
"FBO reported GL_SAMPLE_BUFFERS %d for "
"rb samples %d\n",
sample_buffers, samples);
pass = false;
}
glDeleteRenderbuffersEXT(1, &rb);
}
glDeleteFramebuffersEXT(1, &fb);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}