RE/RE_OGLTexture.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_OGLTexture.h ( RE Library, C++)
 *
 * COMMENTS:
 *      Base class for various OpenGL texture types: 1D, 2D, 3D, Cube,
 *      2D rectangles, 1D arrays and 2D arrays.
 *      
 */
#ifndef RE_OGLTexture_h
#define RE_OGLTexture_h

#include "RE_API.h"
#include "RE_Types.h"
#include "RE_TextureTypes.h"

class RE_Render;


class RE_API RE_OGLTexture
{
public:
             RE_OGLTexture();
    virtual ~RE_OGLTexture();
    
    virtual const char *className() const;
    
    // Texture type (dimensions)
    virtual RE_TextureDimension getTextureType() const = 0;

    // Returns true if this texture type is supported.
    virtual bool        hasTextureSupport(RE_Render *r);

    // True if this texture type supports mipmapping (all but tex rectangles)
    virtual bool        hasMipMapSupport(RE_Render *);

    // Returns the maximum size of a texture edge of the given texture type
    virtual int         getMaxTextureSize(RE_Render *r) = 0;

    // Returns the maximum index that can be used for arrays and cube maps
    virtual int         getMaxTextureIndex(RE_Render *r);

    // True if GL can compress textures itself.
    bool                hasAutoCompression(RE_Render *r);

    // true if this has a valid texture created for it.
    virtual bool        isValid() const;

    // Texture identifier - opaque handle.
    RE_TextureID        getID() const;

    // Releases the texture on the GPU; this object becomes invalid.
    virtual void        free(RE_Render *r);

    // Assign this texture to the specified texture unit, with an optional
    // texturing mode (UNKNOWN leaves the unit's mode alone)
    void                assignToUnit(RE_Render *r,
                                     int texunit,
                                     RE_TextureMode mode = RE_TEXTURE_UNKNOWN);

    // -----------------------------------------------------------------
    // Basic Texture data (modifying will invalidate texture,
    //                     requiring a setTexture() call)

    // The data type is the CPU-side data format, vectorsize can be 1-4.
    // To use leaner GPU-side data formats, set a texture compression.
    void                setFormat(RE_GPUType data, int vectorsize);
    RE_GPUType          getFormatType() const;
    int                 getFormatSize() const;

    // Compress the texture on the GPU, default is to use the same format as
    // the CPU format (RE_COMPRESS_NONE). If auto_compress is false, it is
    // assumed that the data passed to this texture object is already
    // compressed.
    void                setCompression(RE_TextureCompress comp,
                                       bool auto_compress);
    RE_TextureCompress  getCompression() const;
    bool                getAutoCompression() const;

    // Texture Resolution
    // Height/depth may not be required, depending on texture dimension.
    void                setResolution(int w, int h = 1, int depth = 1);
    int                 getWidth() const;
    int                 getHeight() const;
    int                 getDepth() const;
    
    // GL may differ from getWidth/Height/Depth if GPU requires pow2 textures
    // These sizes will never be smaller than the above sizes.
    int                 getGLWidth() const;
    int                 getGLHeight() const;
    int                 getGLDepth() const;

    // Enables mipmapping and auto-generation of mipmaps. Not all texture data
    // formats can be mipmapped (specifically floating point). This also sets
    // the minify filter to RE_FILT_LINEAR_MIPMAP_LINEAR if not set to a MIPMAP
    // filter and it is enabled, or back to RE_FILT_LINEAR if disabled.
    void                setMipMap(bool m, bool autogen = true);
    bool                getMipMap() const;
    bool                getMipMapAutoGenerate() const;

    
    // ---------------------------------------------------------------------
    // Texture transfer methods (CPU/GPU).
    
    // set/getTexture() writes or reads the entire texture.
    // It is assumed that data points to a chunk of memory large enough for the
    // texture. A set method must be called afterwards to reinitialize the
    // texture if the above parameters are changed.
    // If a texture compression scheme is used, this class handles the
    // compression and decompression for you if compress is true; otherwise
    // it is assumed the compressed data is passed in.

    // 'level' is the texture mipmap level. Must be 0 if mipmapping is disabled.
    // 'index' varies by texture type; face for cube maps and index for arrays.
    virtual void        setTexture(RE_Render *r, const void *data,
                                   int level=0, int index=-1) = 0;
    
    // How large a block is required to initialize or fetch this texture.
    int64               getSizeBytes() const;

    // The size of one scanline in the image
    int64               getScanBytes() const;

    // Write to or read from a portion of the texture. Not all dimensions may
    // be used. See derived classes for the meaning of 'z'. These can only be
    // used after setTexture(), though it can be called with data=NULL to set
    // up the texture for setSubTexture(). 
    virtual void        setSubTexture(RE_Render *r,
                                      void *data,    int level,
                                      int xoffset,   int xsize,
                                      int yoffset=0, int ysize=1,
                                      int zoffset=0, int zsize=1) = 0;

    // Reads the entire texture at 'level' back into 'data'. 'data' must point
    // to a block of at least 'getSizeBytes()' in size.
    virtual void        getTexture(RE_Render *r, void *data,
                                   int level=0, int index=-1);
    
    // ---------------------------------------------------------------------
    // Texture Parameters (changing will modify, does not require setTexture)
    
    // Filter to use when displaying the texture at less than 100% zoom
    void                setMinFilter( RE_Render *r, RE_TexFiltType t );
    RE_TexFiltType      getMinFilter()  const;

    // Filter to use when displaying the texture at greater than 100% zoom
    void                setMagFilter( RE_Render *r, RE_TexFiltType t );
    RE_TexFiltType      getMagFilter()  const;

    // Texture wrapping - clamp or repeat. Not all dimension may be used.
    void                setTextureWrap(RE_Render *r,
                                       bool clamp_x,
                                       bool clamp_y = true,
                                       bool clamp_z = true);
    bool                getWrapX() const;
    bool                getWrapY() const;
    bool                getWrapZ() const;
                                       

protected:
    void                deleteObject(RE_Render *r);
    void                adjustPow2(int &w, int &h, int &d);
    void                setupTextureParameters(RE_Render *r);
    void                validate();
    
    virtual int         getGLType() const = 0;
    virtual int         getGLTypeBinding() const = 0;

    // These methods must be called from within a locked context
    virtual void        buildMipMaps(const void *data) = 0;
    void                pushPixelAlignment(bool write, int &pixel);
    void                popPixelAlignment(bool write, int pixel);
    bool                createTextureID();
    
    // returns a malloc'ed image with the compressed data, which must be freed.
    // If no compression is necessary, this will return NULL.
    void *              compressTexData(const void *src, int w, int h);
    void                determineCompressionInternal();
    
    // OpenGL data
    RE_TextureID        myID;
    int                 myGLType;
    int                 myGLFormat;
    int                 myGLInternal;
    int                 myGLWidth;
    int                 myGLHeight;
    int                 myGLDepth;
    
private:
    
    // RE data
    RE_GPUType          myDataType;
    int                 myVectorSize;
    int                 myWidth;
    int                 myHeight;
    int                 myDepth;
    RE_TexFiltType      myMinFilter;
    RE_TexFiltType      myMagFilter;
    RE_TextureCompress  myCompression;
    bool                myMipMapFlag;
    bool                myMipMapAutoGenFlag;
    bool                myWrap[3];
    bool                myAutoCompressFlag;
    bool                myCompressFlag;
    bool                myValidFlag;
};



inline bool
RE_OGLTexture::isValid() const
{
    return myID != 0 && myValidFlag;
}

inline RE_TextureID
RE_OGLTexture::getID() const
{
    return myID;
}

inline RE_GPUType
RE_OGLTexture::getFormatType() const
{
    return myDataType;
}

inline int
RE_OGLTexture::getFormatSize() const
{
    return myVectorSize;
}

inline int
RE_OGLTexture::getWidth() const
{
    return myWidth;
}

inline int
RE_OGLTexture::getHeight() const
{
    return myHeight;
}

inline int
RE_OGLTexture::getDepth() const
{
    return myDepth;
}

inline int
RE_OGLTexture::getGLWidth() const
{
    return myGLWidth;
}

inline int
RE_OGLTexture::getGLHeight() const
{
    return myGLHeight;
}

inline int
RE_OGLTexture::getGLDepth() const
{
    return myGLDepth;
}

inline RE_TextureCompress
RE_OGLTexture::getCompression() const
{
    return myCompression;
}

inline bool
RE_OGLTexture::getAutoCompression() const
{
    return myAutoCompressFlag;
}

inline bool
RE_OGLTexture::hasMipMapSupport(RE_Render *)
{
    return true;
}

inline bool
RE_OGLTexture::getMipMap() const
{
    return myMipMapFlag;
}

inline bool
RE_OGLTexture::getMipMapAutoGenerate() const
{
    return myMipMapAutoGenFlag;
}

inline RE_TexFiltType
RE_OGLTexture::getMinFilter() const
{
    return myMinFilter;
}

inline RE_TexFiltType
RE_OGLTexture::getMagFilter() const
{
    return myMagFilter;
}

inline bool
RE_OGLTexture::getWrapX() const
{
    return myWrap[0];
}

inline bool
RE_OGLTexture::getWrapY() const
{
    return myWrap[1];
}

inline bool
RE_OGLTexture::getWrapZ() const
{
    return myWrap[2];
}

inline const char *
RE_OGLTexture::className() const
{
    return  "RE_OGLTexture";
}

inline bool
RE_OGLTexture::hasTextureSupport(RE_Render *r)
{
    return true;
}

inline void
RE_OGLTexture::validate()
{
    myValidFlag = true;
}

inline int
RE_OGLTexture::getMaxTextureIndex(RE_Render *) 
{
    return 1;
}


#endif

---