Texture.h

#pragma once
 
#include "Types.h"
#include "gfx/Texture.h"
 
using namespace System::Runtime::InteropServices;
 
namespace SharpKmyGfx{
 
    public enum class TEXTUREFILTER{
        kNEAREST,
        kBILINEAR,
    };
 
    public enum class WRAPTYPE{
        kREPEAT,
        kCLAMP,
        kMIRROR,
    };
 
    public enum class TEXTUREFFORMAT{
 
        kINVALID = -1,
        kRGBA,
        kRGB8,
        kR8,
        kR16,
        kR16F,
        kRGBA16F,
        kRGB32F,
        kRGBA32F,
        kDEPTH16,
        kDEPTH24_STENCIL8,
        kSHADOW16,
        kSRGBA8,
        kSRGB8,
        kRGB10_A2,
 
        kCOMPRESSED_RGB,
        kCOMPRESSED_SRGB,
        kCOMPRESSED_RGBA1,
        kCOMPRESSED_SRGBA1,
        kCOMPRESSED_RGBA8,
        kCOMPRESSED_SRGBA8,
 
        kCOMPRESSED_BC1,
        kCOMPRESSED_BC1S,
        kCOMPRESSED_BC3,
        kCOMPRESSED_BC3S,
        kCOMPRESSED_BC5,
        kCOMPRESSED_BC6,
 
        kCOUNT,
    };
 
    public enum class TEXTUREUSAGE
    {
        kDefault,
        kNormal,
        k2D,
    };
 
    public enum class TEXTURESHAPE
    {
        k2D,
        kCube,
        k3D
    };
 
    ref class GameView;
 
    public ref class Texture {
 
    public:
        kmyGfx::Texture* obj;
        bool ownImage;
        System::String^ loadpath;
        Texture()
        {
            obj = NULL;
            ownImage = false;
        }
 
        Texture(System::String^ path, System::Guid guid, int type);
 
        Texture(kmyGfx::Texture* t)
        {
            obj = t;
            ownImage = false;
        }
 
        void Release()
        {
            if (ownImage && obj)obj->removeRef();
            obj = nullptr;
        }
 
        void Delete()
        {
            if (ownImage && obj)obj->removeRef();
            obj = nullptr;
        }
 
        int getWidth()
        {
            if (!obj)return 0;
            return obj->getWidth();
        }
 
        int getHeight()
        {
            if (!obj)return 0;
            return obj->getHeight();
        }
 
        int getStoredWidth()
        {
            if (!obj)return 0;
            return obj->getStoredWidth();
        }
 
        int getStoredHeight()
        {
            if (!obj)return 0;
            return obj->getStoredHeight();
        }
 
        void setMagFilter(TEXTUREFILTER f)
        {
            if (!obj)return;
 
            if (f == TEXTUREFILTER::kBILINEAR)obj->setMagFilter(kmyGfx::Texture::kFILTER_BILINEAR);
            else obj->setMagFilter(kmyGfx::Texture::kFILTER_NEAREST);
        }
 
        void setMinFilter(TEXTUREFILTER f)
        {
            if (!obj)return;
 
            if (f == TEXTUREFILTER::kBILINEAR)obj->setMinFilter(kmyGfx::Texture::kFILTER_BILINEAR);
            else obj->setMinFilter(kmyGfx::Texture::kFILTER_NEAREST);
        }
 
        void setWrap(WRAPTYPE f)
        {
            if (!obj)return;
 
            obj->setUWrap(f == WRAPTYPE::kCLAMP ? kmyGfx::WRAPTYPE::kWRAPTYPE_CLAMP : kmyGfx::WRAPTYPE::kWRAPTYPE_REPEAT);
            obj->setVWrap(f == WRAPTYPE::kCLAMP ? kmyGfx::WRAPTYPE::kWRAPTYPE_CLAMP : kmyGfx::WRAPTYPE::kWRAPTYPE_REPEAT);
        }
 
        void setUWrap(WRAPTYPE f)
        {
            if (!obj)return;
 
            obj->setUWrap(f == WRAPTYPE::kCLAMP ? kmyGfx::WRAPTYPE::kWRAPTYPE_CLAMP : kmyGfx::WRAPTYPE::kWRAPTYPE_REPEAT);
        }
 
        void setVWrap(WRAPTYPE f)
        {
            if (!obj)return;
 
            obj->setVWrap(f == WRAPTYPE::kCLAMP ? kmyGfx::WRAPTYPE::kWRAPTYPE_CLAMP : kmyGfx::WRAPTYPE::kWRAPTYPE_REPEAT);
        }
 
        void setWWrap(WRAPTYPE f)
        {
            if (!obj)return;
 
            obj->setWWrap(f == WRAPTYPE::kCLAMP ? kmyGfx::WRAPTYPE::kWRAPTYPE_CLAMP : kmyGfx::WRAPTYPE::kWRAPTYPE_REPEAT);
        }
 
        void setAnisotropy(float v)
        {
            if (obj)obj->setAnisotropy(v);
        }
 
        void setType(int type)
        {
            if (obj)obj->setType((kmyGfx::TEXTURETYPE)type);
        }
 
        void setUsage(TEXTUREUSAGE usage)
        {
            if (obj)obj->setUsage((kmyGfx::TEXTUREUSAGE)usage);
        }
 
        void setCompress(bool flg)
        {
            if (obj)obj->setCompress(flg);
        }
 
        void renamePath(System::String^ path);
 
        void create(int width, int height, bool srgb, int miplevel);
        void create(int width, int height, TEXTUREFFORMAT format, int miplevel);
        void enableWrite() { if (obj)obj->enableWrite(); }
        void apply() { if (obj)obj->apply(); }
        void storeSubPixel2DDelay(int x, int y, int w, int h, array<UINT32>^ list, TEXTUREFFORMAT format, int sx, int sy, int swidth, int level);
        void copyTexture2DDelay(int dx, int dy, int dw, int dh, int dlevel, int sx, int sy, int slevel, Texture^ src);
        void storeSubPixel2D(int x, int y, int w, int h, array<UINT32>^ list, TEXTUREFFORMAT format, int sx, int sy, int swidth, int level);
        void storeSubPixel2D(int x, int y, int w, int h, u8 *list, TEXTUREFFORMAT format, int level);
        static void getColor(System::String^ name, [System::Runtime::InteropServices::Out] array<UINT32>^% list, int% width, int% height);
 
        static Texture^ load(System::String^ path, bool srgb, TEXTURESHAPE shape, TEXTUREUSAGE usage);
 
        static Texture^ load(System::IO::Stream^ stream, bool srgb, bool genmipmap, TEXTURESHAPE shape, TEXTUREUSAGE usage);
 
        static array<System::String^>^ getLoadableFileList(System::String^ path);
 
        static int getMaxTexture2DSize()
        {
            return kmyGfx::GfxDriver::getInstance()->getMaxTexture2DSize();
        }
 
        static void pushFindTextureBaseDirectory(String^ path);
        static void popFindTextureBaseDirectory();
 
        static int getTextureStoreJobSerial();
        static bool textureStoreJobFinished(int serial);
        static void textureStoreJobDispatchAll();
 
        void getColor([System::Runtime::InteropServices::Out] array<UINT32>^% list, int level);
 
        System::String^ getFileName();
        System::String^ getFilePath();
        System::Guid getGuid();
        void setGuid(System::Guid id);
        bool isSrgb() { return obj?obj->isSrgb():false; }
        void setSrgb(bool b) { if(obj)obj->setSrgb(b); }
        void setGenMipmap(bool flg) { if(obj)obj->setGenMipmap(flg); }
 
        void addRef() { if (obj)obj->addRef(); }
        void removeRef() { if (obj)obj->removeRef(); }
        void reloadIfLoaded() { if (obj)obj->reloadIfLoaded(); }
        int getRef() { return (obj == nullptr) ? -1000 : obj->getRefCount(); }
 
        void saveNativeTexture(System::String^ path);
        void setNativeTexturePath(System::String^ path);
 
    };
 
    public ref class Buffer
    {
    public:
        static int getBufferStoreJobSerial();
        static bool bufferStoreJobFinished(int serial);
        static void bufferStoreJobDispatchAll();
    };
 
 
 
 
}