TextureEntity.h

#pragma once
#include "AssetEntity.h"

namespace ParaEngine
{
    class ImageEntity;

    struct ImageExtendInfo
    {
        ImageExtendInfo()
            : FocalLength(0.0f)
        {
        }

        // lens focal length, unit is mm
        double FocalLength;
    };



    struct TextureEntity : public AssetEntity
    {
    private:
        friend class CTextureProcessor;
    public:
        static const std::string DEFAULT_STATIC_TEXTURE;

        static int g_nTextureLOD;

        static bool g_bEnable32bitsTexture;

        /* get image format by filename 
        * @return : -1 unknown, 24 dds, 13 png, 2 jpg, 17 tga
        */
        static int GetFormatByFileName(const std::string& filename);
    public:
        virtual AssetEntity::AssetType GetType(){ return AssetEntity::texture; };

        enum _SurfaceType
        {
            RenderTarget = 0,
            StaticTexture,
            TextureSequence,
            SysMemoryTexture,
            BlpTexture,
            TerrainHighResTexture,
            CubeTexture,
            FlashTexture,
            HTMLTexture,
            TextureSurface,
            DEPTHSTENCIL,
        } SurfaceType;

        struct TextureInfo
        {
            static const TextureInfo Empty;
            int m_width, m_height;
            
            enum TEXTURE_FORMAT{
                FMT_A8R8G8B8,
                FMT_ALPHA8,
                FMT_X8R8G8B8,
                FMT_UNKNOWN
            }m_format;
            
            enum SUB_TYPE{
                TYPE_SCREENSIZE,
                TYPE_UNKNOWN
            }m_subtype;
            
        public:
            TextureInfo(int width, int height, TEXTURE_FORMAT format, SUB_TYPE subtype)
                : m_width(width), m_height(height), m_format(format), m_subtype(subtype){};
            TextureInfo()
                : m_width(0), m_height(0), m_format(FMT_UNKNOWN), m_subtype(TYPE_UNKNOWN){};
            TextureInfo(const TextureInfo& t)
                : m_width(t.m_width), m_height(t.m_height), m_format(t.m_format), m_subtype(t.m_subtype){};
            virtual ~TextureInfo(){};
            
            TEXTURE_FORMAT GetFormat() const { return m_format; }
            int GetHeight() const { return m_height; }
            int GetWidth() const { return m_width; }
        };

        struct AnimatedTextureInfo : TextureInfo{
            float  m_fFPS;
            int m_nFrameCount;
            int m_nCurrentFrameIndex;
            bool m_bAutoAnimation;
        public:
            AnimatedTextureInfo() :m_fFPS(15.f), m_nFrameCount(0), m_nCurrentFrameIndex(0), m_bAutoAnimation(true){};
            virtual ~AnimatedTextureInfo(){};
        };

        union
        {
            TextureInfo* m_pTextureInfo;
            AnimatedTextureInfo* m_pAnimatedTextureInfo;
        };

        char* m_pRawData;
        int32 m_nRawDataSize;

        // this value will be increased by one every time GetTexture() or GetSurface() is called. 
        int32 m_nHitCount;
        // the color key(default to 0):  Color value to replace with transparent black, or 0 to disable the color key. This is always a 32-bit ARGB color, 
        // independent of the source image format. Alpha is significant and should usually be set to FF for opaque color keys. 
        // Thus, for opaque black, the value would be equal to 0xFF000000. COLOR_XRGB(0,0,0)
        Color m_dwColorKey;

        bool m_bAsyncLoad;

    public:
        TextureEntity(const AssetKey& key);
        TextureEntity();
        virtual ~TextureEntity();

        // TODO: remove this function from base class after refactoring. 
        // the caller needs to cast to implementation class to use this function. 
        virtual DeviceTexturePtr_type GetTexture() { return 0; };

        virtual HRESULT InitDeviceObjects();
        virtual HRESULT RestoreDeviceObjects();
        virtual HRESULT InvalidateDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();
        virtual HRESULT LoadFromMemory(const char* buffer, DWORD nFileSize, UINT nMipLevels, D3DFORMAT dwTextureFormat = D3DFMT_UNKNOWN, void** ppTexture = NULL) { return E_FAIL; };

        
        virtual bool LoadFromImage(ImageEntity * image, D3DFORMAT dwTextureFormat = D3DFMT_UNKNOWN, UINT nMipLevels = 0, void** ppTexture = NULL);


        virtual HRESULT CreateTextureFromFile_Async(void* pContext, RenderDevicePtr pDev = NULL, const char* sFileName = NULL, void** ppTexture = NULL, D3DFORMAT dwTextureFormat = D3DFMT_UNKNOWN, UINT nMipLevels = D3DX_DEFAULT, Color dwColorKey = 0);

        bool IsAsyncLoad() const;
        void SetAsyncLoad(bool val);

        // make this texture render target. 
        virtual bool SetRenderTarget(int nIndex = 0) { return false; };
        
        virtual void SetSamplerStateBlocky(bool bIsBlocky);
        virtual bool IsSamplerStateBlocky();

        // the color key(default to 0):  Color value to replace with transparent black, or 0 to disable the color key. This is always a 32-bit ARGB color, 
        // independent of the source image format. Alpha is significant and should usually be set to FF for opaque color keys. 
        // Thus, for opaque black, the value would be equal to 0xFF000000. COLOR_XRGB(0,0,0)
        void SetColorKey(Color colorKey);

        Color GetColorKey();

        virtual bool IsLoaded();

        bool IsPending();

        void SetRawData(char* pData, int nSize);
        char* GetRawData();
        int GetRawDataSize();
        bool GiveupRawDataOwnership();

        virtual void SetTextureInfo(const TextureInfo& tInfo);
        virtual const TextureInfo* GetTextureInfo();

        virtual int32 GetWidth();
        virtual int32 GetHeight();

        virtual bool IsFlipY();

        /* this value will be increased by one every time GetTexture() or GetSurface() is called.
        * normally we never needs to care about this. Except in some rare cases, such as the mini scene graph needs to know if its being used by others in the last frame. */
        int GetHitCount(){ return m_nHitCount; }

        /* this value will be increased by one every time GetTexture() or GetSurface() is called.
        * normally we never needs to care about this. Except in some rare cases, such as the mini scene graph needs to know if its being used by others in the last frame. */
        void SetHitCount(int nHitCount){ m_nHitCount = nHitCount; }

        void MakeInvalid();

        void Refresh(const char* sFilename = NULL, bool bLazyLoad = false);

        AnimatedTextureInfo* GetAnimatedTextureInfo();

        void SetTextureFPS(float FPS);
        void EnableTextureAutoAnimation(bool bEnable);
        void SetCurrentFrameNumber(int nFrame);
        int GetCurrentFrameNumber();

        int GetFrameCount();
        
        virtual bool SaveToFile(const char* filename, D3DFORMAT dwFormat, int width, int height, UINT MipLevels = 1, DWORD Filter = D3DX_DEFAULT, Color ColorKey = 0);;

        static void LoadImage(char *sBufMemFile, int sizeBuf, int &width, int &height, byte ** ppBuffer, bool bAlpha);
        static bool LoadImageOfFormat(const std::string& sTextureFileName, char *sBufMemFile, int sizeBuf, int &width, int &height, byte ** ppBuffer, int* pBytesPerPixel = NULL, int nFormat = -1);
        static bool LoadImageOfFormatEx(const std::string& sTextureFileName, char *sBufMemFile, int sizeBuf, int &width, int &height, byte ** ppBuffer, int* pBytesPerPixel = NULL, int nFormat = -1, ImageExtendInfo *info = nullptr);

        static TextureEntity* CreateTexture(const uint8 * pTexels, int width, int height, int rowLength, int bytesPerPixel, uint32 nMipLevels = 0, D3DPOOL dwCreatePool= D3DPOOL_MANAGED, DWORD nFormat = 0);
        static TextureEntity* CreateTexture(const char* pFileName, uint32 nMipLevels = 0, D3DPOOL dwCreatePool = D3DPOOL_MANAGED);
    };
}

// chose an implementation as Texture Manager
#ifdef USE_DIRECTX_RENDERER
#include "TextureEntityDirectX.h"
#elif defined(USE_OPENGL_RENDERER)
#include "TextureEntityOpenGL.h"
#else
namespace ParaEngine{
    typedef AssetManager<TextureEntity, TextureEntity> TextureAssetManager;
}
#endif