test/framebuffer.cpp

Go to the documentation of this file.

/*
 * framebuffer.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Test for the glut::Framebuffer object
 */

// includes --------------------------------------------------------------------
#include "glut-demo/glut-demo.h"
#include "opengl-effects/framebuffer.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 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);

                        // create framebuffer
                        m_framebuffer =
                            glut::Framebuffer::create(m_width, m_height);
                        ASSERT(m_framebuffer, "failed to create framebuffer");
                }

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

                        static float s_rotate = 0.0;
                        s_rotate += 0.67;

                        // render offscreen
                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        {
                                glut::FramebufferContext fc(m_framebuffer, m_texId, rc);

                                glut::Viewer view2;
                                view2.setPosition(point3d_t(0, 0, -5));
                                glut::setOpenGLViewer(view2);
                                glRotatef(s_rotate, 0, 1, 0);
                                
                                // 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);
                        }
                        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 -------------------------------------------------
        smart_ptr<glut::Framebuffer>    m_framebuffer;
        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;
}