raw-framebuffer.cpp

Go to the documentation of this file.

/*
 * raw-framebuffer.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple test of OpenGL framebuffer rendering.  Uses raw OpenGL APIs directly
 * rather than the glut::Framebuffer object.
 */

// includes --------------------------------------------------------------------
#include "glut-demo/glut-demo.h"


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////


class TestHost : public glut::DemoHost {
public:
        ~TestHost(void) throw() { }

        // glut::DemoHost class interface methods ------------------------------
        void onInit(void) {
                        // framebuffer dimensions
                        m_width = 240;
                        m_height = m_width;

                        // create framebuffer
                        glGenFramebuffersEXT(1, (GLuint *) &m_fboId);
                        DPRINTF("Created framebuffer id=%d", m_fboId);
                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fboId);

                        // create renderbuffer for depth field
                        int dbId;
                        glGenRenderbuffersEXT(1, (GLuint *) &dbId);
                        DPRINTF("Created render buffer id=%d", dbId);
                        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, dbId);
                        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
                            GL_DEPTH_COMPONENT, m_width, m_height);
                        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
                            GL_RENDERBUFFER_EXT, dbId);

                        // create texture as a render target
                        glGenTextures(1, (GLuint *) &m_texId);
                        DPRINTF("Created texture id=%d", m_texId);
                        glBindTexture(GL_TEXTURE_2D, m_texId);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

                        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_width, m_height,
                            0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
                        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
                            GL_TEXTURE_2D, m_texId, 0);

                        // verify happy
                        GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
                        ASSERT_THROW(GL_FRAMEBUFFER_COMPLETE_EXT == status,
                            "OpenGL framebuffer not complete?  status=" << status);

                        // unbind for now
                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
                }

        void display3D(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq) {

                        static float s_rotate = 0.0;
                        s_rotate += 0.67;

                        // separate view context for texture
                        glut::render_context_t rc2;
                        rc2.viewer.setPosition(point3d_t(0, 0, -10.0));
                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        glMatrixMode(GL_PROJECTION);
                        glPushMatrix();
                        rc2.camera.setAspect(m_width, m_height);
                        glut::setOpenGLProjection(rc2.camera);
                        glut::setOpenGLViewer(rc2.viewer);
                        glRotatef(s_rotate, 0, 1, 0);

                        // bind to the framebuffer for rendering
                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fboId);
                        glPushAttrib(GL_VIEWPORT_BIT);
                        glViewport(0, 0, m_width, m_height);

                        // render to framebuffer
                        glEnable(GL_BLEND);
                        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
                        glClearColor(0.0, 0.0, 0.0, 0.0);
                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                        glColor4f(1.0, 0.0, 1.0, 0.8);
                        glEnable(GL_COLOR_MATERIAL);
                        glutSolidSphere(1.5, 12, 12);
                        glDisable(GL_COLOR_MATERIAL);
                        glDisable(GL_BLEND);

                        // clean up after framebuffer
                        glPopAttrib();
                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

                        // restore modelview matrix
                        glMatrixMode(GL_PROJECTION);
                        glPopMatrix();
                        glMatrixMode(GL_MODELVIEW);
                        glPopMatrix();

                        // add to render queue
                        glut::poly_request_t * pr = rq->grabRequestSlot();
                        if (!pr) {
                                DPRINTF("No available slots?");
                                return;
                        }

                        // get transform
                        matrix4_t T;
                        glut::getModelViewMatrix(T);

                        pr->nVertices = 4;
                        pr->textureId = m_texId;
                        pr->normal.set(0, 0, -1);

                        pr->u[0] = 0;
                        pr->v[0] = 0;
                        pr->vertex[0] = T * point3d_t(-1, -1, -1);

                        pr->u[1] = 0;
                        pr->v[1] = 1;
                        pr->vertex[1] = T * point3d_t(-1,  1, -1);

                        pr->u[2] = 1;
                        pr->v[2] = 1;
                        pr->vertex[2] = T * point3d_t( 1,  1, -1);

                        pr->u[3] = 1;
                        pr->v[3] = 0;
                        pr->vertex[3] = T * point3d_t( 1, -1, -1);
                }

private:
        // private member data -------------------------------------------------
        int             m_fboId;
        int             m_texId;
        int             m_width;
        int             m_height;
};



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        try {
                smart_ptr<glut::DemoHost> host = new TestHost;
                ASSERT(host, "out of memory");
                glut::startDemo(argc, argv, "Framebuffer Demo", host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                return 1;
        }

        // don't ever get here
        return 0;
}