GxResTexture.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
#include "jpeglib.h"
 
//===========================================================================
//===========================================================================
class GxResTexture : public GxResBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_NAME_ICON(GxResTexture, GxResBase, "テクスチャリソース", GxRtti::ICON_TYPE::IMAGE)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTexture)
 
    
    struct GxCreateCallbackArgument
    {
        u32 _attribute;     
    };
protected:
    // リソースバージョン
    static const u32 RESOURCE_VERSION;
 
    static constexpr u32 TEXTURE_BITCOUNT_8 = GxMath::VALUE_8;
    static constexpr u32 TEXTURE_BITCOUNT_16 = GxMath::VALUE_16;
    static constexpr u32 TEXTURE_BITCOUNT_24 = 24;
    static constexpr u32 TEXTURE_BITCOUNT_32 = GxMath::VALUE_32;
public:
    struct GxTextureInformation : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_STRUCT(GxResTexture::GxTextureInformation)
 
        
        static constexpr u32 ARRAY_LEVEL_2D = GxMath::VALUE_1;
        static constexpr u32 ARRAY_LEVEL_3D = GxMath::VALUE_1;
        static constexpr u32 ARRAY_LEVEL_CUBE = 6;
        static constexpr u32 MIPMAP_LEVEL_MIN = GxMath::VALUE_1;
        static constexpr u32 MIPMAP_LEVEL_MAX = GxMath::VALUE_16;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxTextureInformation(void)
            : _width(0)
            , _height(0)
            , _attribute(0)
            , _textureType(RENDER_TEXTURE_TYPE::UNKNOWN)
            , _depthOrArrayCount(ARRAY_LEVEL_2D)
            , _mipmapLevel(0)
            , _pixelFormat(RENDER_FORMAT::UNKNOWN)
            , _originalMipmapLevel(0)
            , _isNoResFinalized(0)
            , _reserved(0)
        {}
        ~GxTextureInformation(void){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        constexpr u32 getWidth(void) const { return _width; }
        constexpr u32 getHeight(void) const { return _height; }
        constexpr u32 getDepth(void) const { return _textureType == RENDER_TEXTURE_TYPE::_3D ? _depthOrArrayCount : 1; }
        constexpr RENDER_TEXTURE_TYPE getTextureType(void) const { return _textureType; }
        constexpr u32 getArrayLevel(void) const { return _textureType == RENDER_TEXTURE_TYPE::_3D ? 1 : _depthOrArrayCount; }
        constexpr u32 getMipmapLevel(void) const { return _mipmapLevel; }
        constexpr u32 getOriginalMipmapLevel(void) const { return _originalMipmapLevel; }
        constexpr RENDER_ATTRIBUTE getAttribute(void) const { return static_cast<RENDER_ATTRIBUTE>(_attribute); }
        constexpr RENDER_FORMAT getPixelFormat(void) const { return _pixelFormat; }
        constexpr u32 getOriginalWidth(void) const { return _width << (_originalMipmapLevel - _mipmapLevel); }
        constexpr u32 getOriginalHeight(void) const { return _height << (_originalMipmapLevel - _mipmapLevel); }
 
        constexpr void getWidthProperty(void* const pValue) const { *static_cast<u32*>(pValue) = getWidth(); }
        constexpr void getHeightProperty(void* const pValue) const { *static_cast<u32*>(pValue) = getHeight(); }
        constexpr void getMipmapLevelProperty(void* const pValue) const { *static_cast<u32*>(pValue) = getMipmapLevel(); }
        constexpr void getOriginalWidthProperty(void* const pValue) const { *static_cast<u32*>(pValue) = getOriginalWidth(); }
        constexpr void getOriginalHeightProperty(void* const pValue) const { *static_cast<u32*>(pValue) = getOriginalHeight(); }
        constexpr void getOriginalMipmapLevelProperty(void* const pValue) const { *static_cast<u32*>(pValue) = getOriginalMipmapLevel(); }
        void getPixelFormatProperty(void* const pValue) const;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32         _width : 16;                
        u32         _height : 16;               
        u32         _attribute : 32;            
        RENDER_TEXTURE_TYPE _textureType : 4;   
        u32         _depthOrArrayCount : 4;     
        u32         _mipmapLevel : 4;           
        RENDER_FORMAT _pixelFormat : 8;         
        u32         _originalMipmapLevel : 4;   
        u32         _isNoResFinalized : 1;      
        u32         _reserved : 7;              
 
    };
 
#if GX_DEVELOP
    struct GxImportSetting : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_STRUCT(GxResTexture::GxImportSetting)
 
        
        enum class COMPRESS
        {
            NONE,   
            DXT1,   
            DXT3,   
            DXT5,   
            R8,     
            MAX,    
        };
#if GX_DEVELOP
        GX_ENUM_TABLE_MAX(COMPRESS)
#endif //GX_DEVELOP
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxImportSetting(void) : _compressFormat(COMPRESS::NONE), _isSRGB(false){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        COMPRESS    _compressFormat;    
        b32         _isSRGB;            
 
    };
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxResTexture(void) : _pTexture(nullptr), _pBuffer(nullptr){}
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 dataSize);
#if GX_DEVELOP
    b32 save(GxStream& stream);
    void resizeBuffer(const GxSize& size);
    void writeBuffer(void* pBuffer, const GxRect& rect);
    GxRtti* getUnitRtti( void ) override;
#endif  // GX_DEVELOP
 
    b32 setTexture(GxRenderTexture* pRenderTexture);
    b32 uploadTextureToVideoMemory(void);
    void deleteTextureFromVideoMemory(void);
 
    static b32 saveAsBmp(GX_CSTR fileName, u32* pImage, s32 width, s32 height, u32 bytePerPixel);
    static b32 saveAsPng(GX_CSTR fileName, u32* pImage, s32 width, s32 height, u32 bytePerPixel);
#if GX_USE_DX11 || GX_USE_DX12
    static void nativeToRGBA32(u32* pMemory, u32 width, u32 height);
    static void addChromaRGBA32(u32* pMemory, u32 width, u32 height, GxColor chromaKeyColor);
#endif //GX_USE_DX11 || GX_USE_DX12
 
    static b32 writeAsPng(GxStreamWriter& writer, u32* pImage, s32 pitch, s32 width, s32 height, u32 bytePerPixel);
    static GxResTexture* loadFromFile(const GxRttiResource& resRtti, GX_CSTR fileName);
 
#if GX_EDITOR
    void getToolRtti(GxArray& arrayTool) const override;
#endif // GX_EDITOR
 
protected:
    b32 createTexture(void);
    b32 loadTexture(GxStreamReader& reader);
    b32 loadTextureMainMemory(GxStream& stream, u32 dataSize);
#if GX_DEVELOP
    b32 saveTexture(GxStreamWriter& writer);
#endif  // GX_DEVELOP
    void createCallback(void* pUser);
 
private:
    virtual b32 loadHeader(GxStreamReader& reader);
    virtual b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel);
#if GX_DEVELOP
    virtual b32 saveHeader(GxStreamWriter& writer);
    virtual b32 saveTextureMappingData(GxStreamWriter& writer, u32 arrayIndex, u32 mipmapLevel);
    void saveImportSetting(void);
    f32 convertToSRGB(f32 value);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GxRenderTexture* getTexture(void) const { return _pTexture; }
    GX_FORCE_INLINE const GxTextureInformation& getInformation(void)    const   { return _textureInformation; }
    GX_FORCE_INLINE void* getBuffer(void) const { return _pBuffer; }
 
    GX_FORCE_INLINE void setIsNoResFinalized(b32 state)                         { _textureInformation._isNoResFinalized = static_cast<u32>(state); }
    GX_FORCE_INLINE b32 isNoResFinalized(void)                          const   { return static_cast<b32>(_textureInformation._isNoResFinalized); }
private:
#if GX_DEVELOP
    static void getImportSettingPath(GxString& path, GX_CSTR resourcePath);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxRenderTexture*            _pTexture;                  
    GxTextureInformation        _textureInformation;        
    void*                       _pBuffer;                   
#if GX_DEVELOP
    GxImportSetting             _importSetting;             
#endif //GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxResTextureBmp : public GxResTexture
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_NAME(GxResTextureBmp, GxResTexture, "BMPテクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTextureBmp)
 
private:
    enum class BMP_FORMAT
    {
        TRUE_COLOR_24 = 24,     
        TRUE_COLOR_32 = 32      
    };
 
    static constexpr u32 BMP_MIPMAP_LEVEL = GxMath::VALUE_1;
 
    struct BmpFileHeader
    {
        u8          _type[2];               
        u32         _size;                  
        u16         _reserved[2];           
        u32         _imageOffset;           
    };
 
    struct BmpInformationHeader
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        RENDER_FORMAT getBmpTextureFormat(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        u32         _headerSize;            
        s32         _width;                 
        s32         _height;                
        u16         _planes;                
        u16         _bitPerPixel;           
        u32         _compression;           
        u32         _imageSize;             
        s32         _pixelPerMeterX;        
        s32         _pixelPerMeterY;        
        u32         _colorUsed;             
        u32         _colorImportant;        
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTextureBmp(void)
    {
        GX_MEMSET(&_fileHeader, 0, sizeof(BmpFileHeader));
        GX_MEMSET(&_informationHeader, 0, sizeof(BmpInformationHeader));
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
    b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    BmpFileHeader               _fileHeader;            
    BmpInformationHeader        _informationHeader;     
 
};
 
//===========================================================================
//===========================================================================
class GxResTextureDds : public GxResTexture
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_RESOURCE_NAME(GxResTextureDds, GxResTexture, "DDSテクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTextureDds)
 
private:
    enum DDSD
    {
        DDSD_CAPS           = 0x00000001,               
        DDSD_HEIGHT         = 0x00000002,               
        DDSD_WIDTH          = 0x00000004,               
        DDSD_PITCH          = 0x00000008,               
        DDSD_PIXELFORMAT    = 0x00001000,               
        DDSD_MIPMAPCOUNT    = 0x00020000,               
        DDSD_LINEARSIZE     = 0x00080000,               
        DDSD_DEPTH          = 0x00800000                
    };
    enum DDPF
    {
        DDPF_ALPHAPIXELS        = 0x00000001,               
        DDPF_ALPHA              = 0x00000002,               
        DDPF_FOURCC             = 0x00000004,               
        DDPF_PALETTEINDEXED4    = 0x00000008,               
        DDPF_PALETTEINDEXED8    = 0x00000020,               
        DDPF_RGB                = 0x00000040,               
        DDPF_LUMINANCE          = 0x00020000,               
        DDPF_BUMPDUDV           = 0x00080000                
    };
    enum DDSCAPS1
    {
        DDSCAPS1_ALPHA          = 0x00000002,               
        DDSCAPS1_COMPLEX        = 0x00000008,               
        DDSCAPS1_TEXTURE        = 0x00001000,               
        DDSCAPS1_MIPMAP         = 0x00040000                
    };
    enum DDSCAPS2
    {
        DDSCAPS2_CUBEMAP            = 0x00000200,           
        DDSCAPS2_CUBEMAP_POSITIVEX  = 0x00000400,           
        DDSCAPS2_CUBEMAP_NEGATIVEX  = 0x00000800,           
        DDSCAPS2_CUBEMAP_POSITIVEY  = 0x00001000,           
        DDSCAPS2_CUBEMAP_NEGATIVEY  = 0x00002000,           
        DDSCAPS2_CUBEMAP_POSITIVEZ  = 0x00004000,           
        DDSCAPS2_CUBEMAP_NEGATIVEZ  = 0x00008000,           
        DDSCAPS2_VOLUME             = 0x00200000            
    };
    enum class DDSFORMAT
    {
        R16F            = 111,                      
        G16R16F         = 112,                      
        A16B16G16R16F   = 113,                      
        R32F            = 114,                      
        G32R32F         = 115,                      
        A32B32G32R32F   = 116,                      
    };
    enum class DXT10FORMAT
    {
        R32G32B32A32_FLOAT      = 2,    
        R16G16B16A16_FLOAT      = 10,   
        R10G10B10A2_UNORM       = 24,   
        R11G11B10_FLOAT         = 26,   
        R8G8B8A8_UNORM          = 28,   
        R8G8B8A8_UNORM_SRGB     = 29,   
        R16G16_FLOAT            = 34,   
        D32_FLOAT               = 40,   
        R32_FLOAT               = 41,   
        D16_UNORM               = 55,   
        R16_UNORM               = 56,   
        R8_UNORM                = 61,   
        BC1_UNORM               = 71,   
        BC1_UNORM_SRGB          = 72,   
        BC2_UNORM               = 74,   
        BC2_UNORM_SRGB          = 75,   
        BC3_UNORM               = 77,   
        BC3_UNORM_SRGB          = 78,   
        BC4_UNORM               = 80,   
        BC4_SNORM               = 81,   
        BC5_UNORM               = 83,   
        BC5_SNORM               = 84,   
        BC6H_UF16               = 95,   
        BC6H_SF16               = 96,   
        BC7_UNORM               = 98,   
        BC7_UNORM_SRGB          = 99,   
    };
    struct DdsFileHeader
    {
        u32                 _magic;                         
    };
    
    struct DdsPixelFormat
    {
        u32                 _size;                          
        u32                 _flags;                         
        u32                 _fourcc;                        
        u32                 _rgbBitCount;                   
        u32                 _redBitMask;                    
        u32                 _greenBitMask;                  
        u32                 _blueBitMask;                   
        u32                 _alphaBitMask;                  
    };
    struct DdsCaps
    {
        u32                 _caps1;                         
        u32                 _caps2;                         
        u32                 _reserved[2];                   
    };
    struct DdsFormatHeader
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        static constexpr u32 RESERVED1_SIZE = 11;               
        static constexpr u32 RESERVED2_SIZE = GxMath::VALUE_1;              
 
        struct DdsFormatHeaderDXT10
        {
            //-----------------------------------------------------------
            //-----------------------------------------------------------
 
            RENDER_FORMAT       getDdsTextureFormat(void);
 
            //-----------------------------------------------------------
            //-----------------------------------------------------------
 
            u32                 _dxgiFormat;            
            u32                 _resourceDimension;     
            u32                 _miscFlag;              
            u32                 _arraySize;             
            u32                 _miscFlags2;            
 
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        RENDER_FORMAT       getDdsTextureFormat(void);
        RENDER_TEXTURE_TYPE getDdsTextureType(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        u32                 _headerSize;                    
        u32                 _flags;                         
        u32                 _height;                        
        u32                 _width;                         
        u32                 _pitchOrLinearSize;             
        u32                 _depth;                         
        u32                 _mipmapCount;                   
        u32                 _reserved1[RESERVED1_SIZE];     
        DdsPixelFormat      _pixelFormat;                   
        DdsCaps             _caps;                          
        u32                 _reserved2[RESERVED2_SIZE];     
        DdsFormatHeaderDXT10    _dxt10Format;               
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTextureDds(void){ GX_MEMSET(&_fileHeader, 0, sizeof(DdsFileHeader)); GX_MEMSET(&_formatHeader, 0, sizeof(DdsFormatHeader)); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
    b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    DdsFileHeader               _fileHeader;            
    DdsFormatHeader             _formatHeader;          
 
};
 
//===========================================================================
//===========================================================================
class GxResTextureSdds : public GxResTextureDds
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_NAME(GxResTextureSdds, GxResTextureDds, "DDS(SRGB)テクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTextureSdds)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTextureSdds(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
 
};
 
//===========================================================================
//===========================================================================
class GxResTexturePng : public GxResTexture
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_RESOURCE_NAME(GxResTexturePng, GxResTexture, "PNGテクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTexturePng)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTexturePng(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
 
    b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    void* _pRead;               // png_structp
    void* _pReadInformation;    // png_infop
    void* _pEnd;                // png_infop
 
};
 
//===========================================================================
//===========================================================================
class GxResTextureJpeg : public GxResTexture
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_RESOURCE_NAME(GxResTextureJpeg, GxResTexture, "JPEGテクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTextureJpeg)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTextureJpeg(void) : _pRawBuffer(nullptr){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
    b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    jpeg_decompress_struct  _jpegInformation;   
    jpeg_error_mgr          _jpegError;         
    u8*                     _pRawBuffer;        
 
};
 
//===========================================================================
//===========================================================================
class GxResTexturePvr : public GxResTexture
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_NAME(GxResTexturePvr, GxResTexture, "PVRテクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTexturePvr)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTexturePvr(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
 
    b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel) override;
 
};
 
//===========================================================================
//===========================================================================
class GxResTextureTga : public GxResTexture
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_NAME(GxResTextureTga, GxResTexture, "TGAテクスチャリソース")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResTextureTga)
 
private:
    enum class TGA_FORMAT
    {
        TRUE_COLOR_24 = 24,     
        TRUE_COLOR_32 = 32      
    };
 
    static constexpr u32 TGA_MIPMAP_LEVEL = GxMath::VALUE_1;
 
    struct TgaInformationHeader
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        RENDER_FORMAT       getTgaTextureFormat(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        s32         _width;                 
        s32         _height;                
        u16         _bitPerPixel;           
        b32         _isRLE;                 
        b32         _isFlip;                
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResTextureTga(void){ }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 loadHeader(GxStreamReader& reader) override;
    b32 loadTextureMappingData(GxStreamReader& reader, u32 arrayIndex, u32 mipmapLevel) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    TgaInformationHeader        _informationHeader;     
 
};
 
GX_CORE_NAMESPACE_END()