Texture.h

#pragma once
 
#include "Types.h"
#include "gfx/Texture.h"
 
using namespace System::Runtime::InteropServices;
 
namespace SharpKmyGfx{
 
    ref class GameView;
 
    public ref class Texture {
 
        bool managedResourceAttached = false;
 
    public:
        kmyGfx::Texture* obj;
        bool deleteAsCreator = false;
        System::String^ loadpath;
        Texture()
        {
            obj = NULL;
            deleteAsCreator = true;
        }
 
        Texture(System::String^ path, System::Guid guid, int type, bool srgb, bool genmipmap, TEXTUREUSAGE usage, bool compress, PREMULTIPLIEDTYPE premultiplied);
 
        Texture(kmyGfx::Texture* t)
        {
            obj = t;
            deleteAsCreator = false;
            if(t)t->addExRef();
        }
 
        Texture^ makeNewReference()
        {
            return gcnew Texture(obj);
        }
 
        ~Texture()
        {
            Release();
        }
 
        void managedResourceAttach()
        {
            if (managedResourceAttached) {
                DBGPRINTF("[warn] texture attached to multiple managed resource. (%s)", obj ? obj->getFileName() : "nullobj");
            }
            managedResourceAttached = true;
        }
 
        void managedResourceDetach()
        {
            if (!managedResourceAttached) {
                DBGPRINTF("[warn] unattached texture was detached. (%s)", obj ? obj->getFileName() : "nullobj");
            }
            managedResourceAttached = false;
        }
 
        bool isEqual(SharpKmyGfx::Texture^ t)
        {
            if (!t)return false;
            return t->obj == obj;
        }
 
        void Release()
        {
            if (obj) {
                obj->removeExRef();
                if (deleteAsCreator) {
                    obj->removeRef();
                }
                obj = nullptr;
            }
        }
 
        void Delete()
        {
            if (obj) {
                obj->removeExRef();
                if (deleteAsCreator) {
                    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 setPremultiplied(PREMULTIPLIEDTYPE premultiplied)
        {
            if (obj)obj->setPremultiplied((kmyGfx::PremultipliedType)premultiplied);
        }
 
        bool isReloadRequired() { return obj ? obj->m_reloadRequired : false; }
 
        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();
        static void textureStoreJobWaitQueuedJobFinished();
 
        static void forceReloadFileTextures() {
            kmyGfx::Texture::forceReloadFileTextures();
        }
 
        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(); }
 
        TEXTUREFFORMAT getTextureFormat()
        {
            if (obj)
            {
                auto format = obj->getFormat();
                return static_cast<TEXTUREFFORMAT>(format);
            }
        //  return static_cast<TEXTUREFFORMAT>(kmyGfx::kTEXTUREFORMAT_INVALID);
            return TEXTUREFFORMAT::kINVALID;
        }
    };
}