framebuffer.cpp

Go to the documentation of this file.

/*
 * framebuffer.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of simple framebuffer object for offscreen drawing.
 */

// includes --------------------------------------------------------------------
#include "framebuffer.h"                // always include our own header first!

#include "perf/perf.h"


namespace glut {


// interface destructors
Framebuffer::~Framebuffer(void) throw() { }


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



////////////////////////////////////////////////////////////////////////////////
//
//      FBuffer -- class that implements the glut::Framebuffer interface
//
////////////////////////////////////////////////////////////////////////////////

class FBuffer : public Framebuffer {
public:
        FBuffer(void) throw();
        ~FBuffer(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN int width, IN int height);

        // glut::Framebuffer class interface methods ---------------------------
        int getWidth(void) const throw() { return m_width; }
        int getHeight(void) const throw() { return m_height; }
        void setupForRendering(IN int textureId,
                                IN const render_context_t& rc);
        void endRendering(void) throw();

private:
        // private member data -------------------------------------------------
        int             m_width;
        int             m_height;
        GLuint          m_fbufId;       // framebuffer ID
        GLuint          m_rbufId;       // renderbuffer ID
};



FBuffer::FBuffer
(
void
)
throw()
{
        m_width = m_height = 0;
        m_fbufId = 0;
        m_rbufId = 0;
}



FBuffer::~FBuffer
(
void
)
throw()
{
        if (m_rbufId) {
                glDeleteRenderbuffersEXT(1, &m_rbufId);
        }
        if (m_fbufId) {
                glDeleteFramebuffersEXT(1, &m_fbufId);
        }
}



void
FBuffer::initialize
(
IN int width,
IN int height
)
{
        ASSERT(width > 1, "bad width: %d", width);
        ASSERT(height > 1, "bad height: %d", height);

        // save width and height
        m_width = width;
        m_height = height;

        // create raw OpenGL framebuffer
        ASSERT(!m_fbufId, "already have framebuffer?");
        glGenFramebuffersEXT(1, &m_fbufId);
        ASSERT(m_fbufId, "failed to create OpenGL framebuffer");
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbufId);

        // create renderbuffer for depth buffer, attach to framebuffer
        ASSERT(!m_rbufId, "already have a renderbuffer?");
        glGenRenderbuffersEXT(1, &m_rbufId);
        ASSERT(m_rbufId, "failed to create OpenGL renderbuffer");
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_rbufId);
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
            m_width, m_height);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
            GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_rbufId);

        // now that we have finished construction, unbind framebuffer
        const int nullFramebuffer = 0;
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, nullFramebuffer);
}



void
FBuffer::setupForRendering
(
IN int textureId,
IN const render_context_t& rc
)
{
        ASSERT(textureId, "null");

        // bind and validate incoming texture
        // NOTE: I've heard these glGet() calls can be expensive (can interrupt
        //      GPU processing).  But I'm not sure if I want to require another
        //      struct besides the texture ID.
        glBindTexture(GL_TEXTURE_2D, textureId);
        const int levelOfDetail = 0;
        int width, height;
        glGetTexLevelParameteriv(GL_TEXTURE_2D, levelOfDetail, GL_TEXTURE_WIDTH,
            &width);
        glGetTexLevelParameteriv(GL_TEXTURE_2D, levelOfDetail, GL_TEXTURE_HEIGHT,
            &height);

        ASSERT_THROW(width == m_width && height == m_height,
            "Incoming texture size does not match framebuffer.  Texture size: "
            << width << " x " << height << ", framebuffer size: " << m_width
            << " x " << m_height);

        // okay, bind our framebuffer in preparation for drawing
        ASSERT(m_fbufId, "should have valid framebuffer");
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbufId);

        // bind texture to framebuffer
        const int mipmapLevel = 0;
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
            GL_TEXTURE_2D, textureId, mipmapLevel);

        // framebuffer should be complete now
        GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
        ASSERT_THROW(GL_FRAMEBUFFER_COMPLETE_EXT == status,
            "Framebuffer is not complete, status = " << status);

        // save current opengl state
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glPushAttrib(GL_VIEWPORT_BIT);

        // set up new projection + modelview matrices
        camera_t camera = rc.camera;
        camera.setAspect(m_width, m_height);
        setOpenGLProjection(camera);
        glViewport(0, 0, m_width, m_height);
}



void
FBuffer::endRendering
(
void
)
throw()
{
        // unbind framebuffer
        const int nullFramebuffer = 0;
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, nullFramebuffer);

        // unbind texture to framebuffer
        const int mipmapLevel = 0;
        const int nullTexture = 0;
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
            GL_TEXTURE_2D, nullTexture, mipmapLevel);

        // restore original transformation matrices
        glPopAttrib();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Framebuffer>
Framebuffer::create
(
IN int width,
IN int height
)
{
        ASSERT(width > 1, "Bad width: %d", width);
        ASSERT(height > 1, "Bad height: %d", height);

        smart_ptr<FBuffer> local = new FBuffer;
        ASSERT(local, "out of memory");

        local->initialize(width, height);

        return local;
}



};      // glut namespace