fsITexture.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsITexture.h
*
*       Purpose:        Container for textures that are uploaded to graphics
*                               hardware. Accessible through the fsCTextureManager.
*
*********************************************************************/
 
#ifndef fsITexturehdr
#define fsITexturehdr
 
#include <memory>
#include <vector>
 
#include <fsCore/fsSColour.h>
#include <fsCore/fsBaseTypes.h>
#include <fsCore/src/fsCResourceName.h>
 
class fsIImage;
struct fsPoint;
class fsCBrush;
class fsAffineMtx2d;
 
class fsITexture
{
        friend class fsCBrushManager;
        friend class fsCParticleData;
        friend class fsCParticleCloud;
        friend class fsIParticleCloud;
        friend class fsCSequenceParticleCloud;
        friend class gfCMazeSolution;
 
public:
        
        enum class fsFilterMode
        {
                eNEAREST,
                eNEAREST_MIPMAP_NEAREST,
                eNEAREST_MIPMAP_LINEAR,
                eLINEAR,
                eLINEAR_MIPMAP_LINEAR,
                eLINEAR_MIPMAP_NEAREST,
                eDONT_CARE,
        };
 
        enum class fsWrapMode
        {
                eREPEAT,
                eMIRROR_REPEAT,
                eCLAMP_TO_EDGE,
                eDONT_CARE
        };
        
        struct fsSOptions
        {
                fsSOptions(fsCResourceName const& pImageFilename,
                           fsBool pCreateHitMap,
                           fsBool pDeferedUpload = false,
                           fsBool pUVAnimation = false):
                        mImageFilename(pImageFilename),
                        mCreateHitMap(pCreateHitMap),
                        mDeferedUpload(pDeferedUpload),
                        mUVAnimation(pUVAnimation)
                {
                }
 
                fsCResourceName mImageFilename;
                fsBool mCreateHitMap;
                fsBool mDeferedUpload = false;
                fsBool mUVAnimation = false;
                fsBool mMultiMask = false;
        };
 
        void filterModeSet(fsFilterMode pNewMode);
        void wrapModeSet(fsWrapMode pNewMode);
        
        std::shared_ptr<fsITexture> cloneSubSection(fsCBrush const* pBlend, fsPoint const& pOffset);
        void blend(fsCBrush const* pBlend, fsPoint const& pOffset);
        void finalise();
 
        fsSColour4B pixelGet(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow);
        void pixelSet(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow, fsSColour4B const& pPixel);
        void textureCopyThroughStencil(std::shared_ptr<fsITexture> pSrc, std::shared_ptr<fsITexture> pStencil,
                                       fsS32 pU, fsS32 pV, fsS32 pX, fsS32 pY, fsS32 pAlphaHitMaskThreshold);
        void textureCopyInto(std::shared_ptr<fsITexture> pSrc, fsS32 pU, fsS32 pV, fsS32 pX, fsS32 pY);
 
        virtual fsS32 imageWidthGet() const = 0;
        virtual fsS32 imageHeightGet() const = 0;
        virtual fsS32 textureWidthGet() const = 0;
        virtual fsS32 textureHeightGet() const = 0;
 
        fsBool hasHitMapGet() const;
        fsBool hitTest(fsPoint const& pLocalPoint) const;
 
        virtual fsU8 alphaGet(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow) const { return 0; };
        virtual fsBool hasAlphaChannelGet() const { return false; };
 
        virtual ~fsITexture();
 
protected:
 
        static std::shared_ptr<fsITexture> createFromImageFile(fsSOptions const& pOptions);
        static std::shared_ptr<fsITexture> createAlpha8FromTextureWithHitmap(
                std::shared_ptr<fsITexture> pTextureWithHitmap, fsS32 pU, fsS32 pV, fsS32 pW, fsS32 pH);
        static std::shared_ptr<fsITexture> createWithEmptyImage(fsS32 pWidth, fsS32 pHeight);
 
        virtual void createFromAlpha8Data(std::vector<fsU8>& pAlphaData, fsS32 pImgW, fsS32 pImgH,
                                  fsPoint const& pPOTDimenions) {};
 
        virtual void createFromImage(fsIImage const* pImage) = 0;
 
        virtual void filterModeSetDo(fsFilterMode pNewMode) = 0;
        virtual void wrapModeSetDo(fsWrapMode pNewMode) = 0;
        virtual fsU8 alphaValueGet(fsS32 pImgX, fsS32 pImgY) { return 0; };
 
        virtual std::shared_ptr<fsITexture> doCloneSubSection(fsCBrush const* pBlend, fsPoint const& pOffset) const = 0;
        virtual void doBlend(fsCBrush const* pBlend, fsPoint const& pOffset) = 0;
 
        virtual fsSColour4B pixelGetDo(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow) { return fsSColour4B(); };
 
        virtual void doPixelSet(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow, fsSColour4B const& pPixel) {};
 
        virtual void doTextureCopyThroughStencil(std::shared_ptr<fsITexture> pDest, std::shared_ptr<fsITexture> pStencil,
                                                 fsS32 pU, fsS32 pV, fsS32 pX, fsS32 pY, fsS32 pAlphaHitMaskThreshold) {};
 
        virtual void doTextureCopyInto(std::shared_ptr<fsITexture> pDest, fsS32 pU, fsS32 pV, fsS32 pX, fsS32 pY) {};
 
 
        fsITexture();
 
        void hitMapStore(fsU8 pAlphaThreshold = 0);
        void emptyImageCreate(fsS32 pWidth, fsS32 pHeight);;
        void imageLoad(fsCResourceName const& pImageFileName);
        void imageFileLoad(fsCResourceName const& pImageFileName, fsBool pUVAnimation);
        void maskFileLoad(fsCResourceName const& pImageFileName, fsBool pUVAnimation);
 
        std::unique_ptr<fsIImage> mImage;
        fsS32 mWidth;
        fsS32 mHeight;
 
private:
 
        void alpha8TexDataGet(std::shared_ptr<fsITexture> pTextureWithHitmap, std::vector<fsU8>& pAlphaData, fsS32 pU, fsS32 pV,
                              fsS32 pW, fsS32 pH, fsPoint const& pPotDimensions) const;
        static fsS32 roundToPow2(fsS32 pDimension);
        static fsS32 scaleDownToBits(fsS32 pVal);
 
        static const fsS32 mByteMask = 7;
 
        std::vector<fsU8> mHitMap;
};
 
#endif