RE/RE_FrameBuffer.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Alexander
 *      Side Effects
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_FrameBuffer.h ( RE Library, C++)
 *
 * COMMENTS:
 *
 *   This class uses the Framebuffer object extension to do offscreen
 *   rendering to render buffers & textures. Note that rendering to texture
 *   is not supported on all platforms, so please check that the framebuffer
 *   is valid before rendering (either isValid(), or the return value of
 *   begin).
 *
 *   You can attach many buffers, including GL_DEPTH_ATTACHMENT_EXT,
 *   GL_STENCIL_ATTACHMENT_EXT, and up to GL_MAX_COLOR_ATTACHMENTS color
 *   attachments (sequential from GL_COLOR_ATTACHMENT0_EXT). You must include
 *   a render buffer for depth or stencil if you intend to use depth or
 *   stencil tests.
 *
 *   For color, you can render to either a texture or a renderbuffer.
 *   Generally, textures are used for passes, and renderbuffers are used to
 *   pull images from the GPU.
 *
 *   Deleting the class will clean up the frame buffer object and any
 *   renderbuffers still attached, but textures will not be deleted.
 */
#ifndef RE_FrameBuffer_h
#define RE_FrameBuffer_h

#include "RE_Render.h"

#include <UT/UT_PtrArray.h>

class re_FrameBufferAttachment;

enum RE_BufferAttachment
{
    RE_COLOR_BUFFER,
    RE_DEPTH_BUFFER,
    RE_STENCIL_BUFFER
};

class RE_API RE_FrameBuffer
{
public:
             RE_FrameBuffer();
            ~RE_FrameBuffer();

    static bool  isFrameBufferSupported();
    static int   getNumColorAttachments();
    
    /// Attach a texture to the framebuffer. You are still responsible for
    /// deleting it.
    bool         attachTexture(RE_Render *r, GLuint textureid,
                               RE_GPUType type, int vectorsize,
                               int miplevel = 0,
                               RE_BufferAttachment buf = RE_COLOR_BUFFER,
                               int colorbufnum = 0);

    /// Create a texture and attach it to the framebuffer. You are still
    /// responsible for deleting it.  Specify rect = true to create a
    /// texture rectangle (check to see that this extension
    /// is supported before calling this method).
    GLuint       createTexture(RE_Render *r, int w, int h,
                               RE_GPUType type, int vectorsize,
                               int miplevel = 0,
                               RE_BufferAttachment buf = RE_COLOR_BUFFER,
                               int colorbufnum = 0,
                               bool rect = false);
                                   

    /// Create a renderbuffer and attach it to the framebuffer. This will
    /// be cleaned up when you delete the render buffer, or call
    /// clearAttachment() on it.
    GLuint       createRenderBuffer(RE_Render *r, int w, int h,
                                    RE_GPUType type, int vectorsize,
                                    RE_BufferAttachment buf = RE_COLOR_BUFFER,
                                    int colorbufnum = 0);

    /// You must call this if attaching textures (if you are creating textures,
    /// the resulotion of the textures you pass is used). 
    void         setResolution(int width, int height);
    int          getWidth() const { return myWidth; }
    int          getHeight() const { return myHeight; }


    /// Returns true if the framebuffer is ready to render.
    bool         isValid(RE_Render *r);

    /// do all rendering between the begin/end statements. Renders to the
    /// given attachment. Specify initview = true set the modelview matrix
    /// to an orthographic projection the size of the framebuffer, the
    /// viewport to the size of the framebuffer, and to push the current
    /// GL state (via RE_OGLRender::pushState(1)).
    bool         begin(RE_Render *r, RE_BufferAttachment buf = RE_COLOR_BUFFER,
                       int colorbufnum = 0, bool initview = true);
    void         end(RE_Render *r);

    void         drawToBuffer(RE_Render *r,
                              RE_BufferAttachment buf = RE_COLOR_BUFFER,
                              int colorbufnum = 0);

    // allows you to draw to multiple buffers at once.
    // The type RE_COLOR_BUFFER is assumed. There is a limit on the
    // number you can write to simultaneously, getMaxDrawBuffers().
    void         drawToBuffers(RE_Render *r, int num, int *bufferlist);
    static int   getMaxDrawBuffers(RE_Render *r);

    // This method allows you to begin an ascyncronous read from a series of
    // buffers. Note that it will only be asyncronous if the
    // RE_PIXEL_BUFFER_OBJECT extension is supported. 
    bool        readAsyncFromBuffers(RE_Render *r, int num, int *bufferlist);

    /// reads the data from the render buffer specified into 'buffer'.
    /// 'buffer' must be large enough to contain the full renderbuffer size.
    bool        readFromRenderBuffer(RE_Render *r, void *buffer,
                                     RE_BufferAttachment buf=RE_COLOR_BUFFER,
                                     int colorbufnum = 0);


    /// Removes the attachment, and frees the renderbuffer or texture if
    /// freeme is true.
    bool        detach(RE_Render *r, RE_BufferAttachment buf=RE_COLOR_BUFFER,
                       int colorbufnum = 0,
                       bool freeme = false);
                       
    bool        detachAndFree(RE_Render *r,
                              RE_BufferAttachment buf=RE_COLOR_BUFFER, 
                              int colorbufnum = 0)
                            { return detach( r, buf, colorbufnum ,true); }
    
private:
    bool        privateReadFromBuffer(RE_Render *r,
                                      re_FrameBufferAttachment *attach,
                                      int glattachment,
                                      void *image_data);

    enum RE_BufferBindMode 
    {
      RE_BIND_NONE = 0, // Cannot be used as a parameter to bindFrameBuffer()
      RE_BIND_READ = 1,
      RE_BIND_DRAW = 2,
    };

    bool        bindFrameBuffer(RE_Render *r, 
                                RE_BufferBindMode bindmode = RE_BIND_DRAW);
    void        unbindFrameBuffer(RE_Render *r);

    unsigned    getGLBuffer() const;
    
    GLuint      myFrameBuffer;
    int         myWidth;
    int         myHeight;
    RE_RenderBuf myPrevRenderBuffer;
    bool        myBegun;
    bool        myRestoreView;
    RE_BufferBindMode myOpenMode;
    UT_PtrArray <re_FrameBufferAttachment *> myAttachments;

    static int  theARBExtension;
};

#endif

---