RE/RE_RasterObject.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:
 *      Joe Drew
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_RasterObject.h (RE Library, C++)
 *
 * COMMENTS:
 *
 *      If you want to render offscreen, then (potentially) use the result as
 *      a texture, there are two choices: framebuffer objects and raster
 *      windows. Framebuffer objects are preferable, since they're faster, but
 *      they're not supported everywhere. Raster windows are supported more
 *      generally.
 *
 *      This class abstracts out choosing whether to use RE_FrameBuffer or
 *      RE_RasterWindow. Provide this class with a render callback, and when
 *      you're initializing, call build(). Later, when you are sure an OpenGL
 *      context has been pushed, call getTexture() to get the ID of a texture
 *      that contains what you have drawn offscreen.
 *
 */

#ifndef __RE_RasterObject__
#define __RE_RasterObject__

#include "RE_API.h"

#include <boost/function.hpp>
#include <SYS/SYS_Types.h>

class PXL_Raster;
class RE_FrameBuffer;
class RE_Render;
class RE_RasterWindow;

typedef boost::function<void (RE_Render *, int, int, int, int, void *)> 
                          // (     render,   x,   y,   w,   h,   data)
                                      RE_RenderCallback;

class RE_API RE_RasterObject
{
public:
    /// Provide this class with a callback, the width and height you want to
    /// render into, the height and width you want the texture to be (this
    /// should be a power of two), and some data to be passed to the callback.
    RE_RasterObject(RE_RenderCallback callback, int w, int h, int tw, int th,
                    void *data);

    /// Be very careful before calling this - do you have an OpenGL context
    /// pushed?
    ~RE_RasterObject();

    /// Frees the offscreen buffer associated with this object without
    /// clearing the other data (texture, raster).
    void            resetBuffer();

    // build() does not create the texture because a valid OGL Context may
    // not be present yet. It can safely render into a RasterWindow, as that
    // pushes a valid context. We can't render to a RasterWindow in the middle
    // of a redraw as that messes up stacks & contexts. So, the texture
    // creation is split into 2 parts - build() (called during init) and
    // getTexture() (called during redraw).

    /// Render offscreen, calling the render callback.
    bool        build(RE_Render *r);

    /// Generate and get the OpenGL ID of a texture that contains the contents
    /// of what was render when build() was called.
    uint        getTexture(RE_Render *r);

    /// If the color scheme changes, we need to re-render everything.
    void        rebuild(RE_Render *r);

    /// Whether build() has successfully been called.
    bool        isBuilt() const;

    /// The texture's width. Should be a power of two.
    int getTexWidth() const;

    /// The texture's height. Should be a power of two.
    int getTexHeight() const;

    /// The width of what you actually want to render.
    int getWidth() const;

    /// The height of what you actually want to render.
    int getHeight() const;
    
    /// Force PXL_Raster creation
    void        setForceRaster(bool on) { myForceRaster = on; }

    PXL_Raster* getRaster() { return myRaster; }

    /// Renders this object directly using the callback.
    void        renderDirect(RE_Render *r, int x, int y, int w, int h);

private: // methods
    void        render(RE_Render *r);
    bool        buildOffscreen(RE_Render *r);
    bool        buildFrameBuffer(RE_Render *r);

private:

    RE_RenderCallback    myCallback;
    void                *myVoidData;
    int                  myTexWidth;
    int                  myTexHeight;
    int                  myWidth;
    int                  myHeight;
    bool                 myBuiltFlag;
    uint                 myTextureID;
    PXL_Raster          *myRaster;
    bool                 myForceRaster;
    RE_RasterWindow     *myRasterWindow;
    RE_FrameBuffer      *myFrameBuffer;
    
    static int             theRenderToTexture;
    static bool            theRenderToBuffer;
};

#endif

---