New object management architecture for OpenGL subsystem (more platforms to come)

include/boo/BooObject.hpp

@@ -0,0 +1,47 @@
+#ifndef BOOOBJECT_HPP
+#define BOOOBJECT_HPP
+
+#include <atomic>
+
+namespace boo
+{
+
+class IObj
+{
+    std::atomic_int m_refCount = {0};
+public:
+    virtual ~IObj() = default;
+    void increment() { m_refCount++; }
+    void decrement()
+    {
+        if (m_refCount.fetch_sub(1) == 1)
+            delete this;
+    }
+};
+
+template<class SubCls>
+class ObjToken
+{
+    SubCls* m_obj = nullptr;
+public:
+    ObjToken() = default;
+    ObjToken(SubCls* obj) : m_obj(obj) { m_obj->increment(); }
+    ObjToken(const ObjToken& other) : m_obj(other.m_obj) { m_obj->increment(); }
+    ObjToken(ObjToken&& other) : m_obj(other.m_obj) { other.m_obj = nullptr; }
+    ObjToken& operator=(SubCls* obj)
+    { if (m_obj) m_obj->decrement(); m_obj = obj; m_obj->increment(); return *this; }
+    ObjToken& operator=(const ObjToken& other)
+    { if (m_obj) m_obj->decrement(); m_obj = other.m_obj; m_obj->increment(); return *this; }
+    ObjToken& operator=(ObjToken&& other)
+    { if (m_obj) m_obj->decrement(); m_obj = other.m_obj; other.m_obj = nullptr; return *this; }
+    ~ObjToken() { if (m_obj) m_obj->decrement(); }
+    SubCls* get() const { return m_obj; }
+    SubCls* operator->() const { return m_obj; }
+    SubCls& operator*() const { return *m_obj; }
+    template<class T> T* cast() const { return static_cast<T*>(m_obj); }
+    operator bool() const { return m_obj != nullptr; }
+};
+
+}
+
+#endif // BOOOBJECT_HPP

include/boo/graphicsdev/GL.hpp

@@ -8,6 +8,7 @@
 
 namespace boo
 {
+class BaseGraphicsData;
 
 class GLDataFactory : public IGraphicsDataFactory
 {
@@ -16,40 +17,44 @@ public:
     {
         friend class GLDataFactoryImpl;
         GLDataFactory& m_parent;
-        Context(GLDataFactory& parent) : m_parent(parent) {}
+        ObjToken<BaseGraphicsData> m_data;
+        Context(GLDataFactory& parent);
+        ~Context();
     public:
-        Platform platform() const {return Platform::OpenGL;}
-        const SystemChar* platformName() const {return _S("OpenGL");}
+        Platform platform() const { return Platform::OpenGL; }
+        const SystemChar* platformName() const { return _S("OpenGL"); }
 
-        IGraphicsBufferS* newStaticBuffer(BufferUse use, const void* data, size_t stride, size_t count);
-        IGraphicsBufferD* newDynamicBuffer(BufferUse use, size_t stride, size_t count);
+        ObjToken<IGraphicsBufferS> newStaticBuffer(BufferUse use, const void* data, size_t stride, size_t count);
+        ObjToken<IGraphicsBufferD> newDynamicBuffer(BufferUse use, size_t stride, size_t count);
 
-        ITextureS* newStaticTexture(size_t width, size_t height, size_t mips, TextureFormat fmt,
-                                    TextureClampMode clampMode, const void* data, size_t sz);
-        ITextureSA* newStaticArrayTexture(size_t width, size_t height, size_t layers, size_t mips,
-                                          TextureFormat fmt, TextureClampMode clampMode, const void* data, size_t sz);
-        ITextureD* newDynamicTexture(size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode);
-        ITextureR* newRenderTexture(size_t width, size_t height, TextureClampMode clampMode,
-                                    size_t colorBindingCount, size_t depthBindingCount);
+        ObjToken<ITextureS> newStaticTexture(size_t width, size_t height, size_t mips, TextureFormat fmt,
+                                             TextureClampMode clampMode, const void* data, size_t sz);
+        ObjToken<ITextureSA> newStaticArrayTexture(size_t width, size_t height, size_t layers, size_t mips,
+                                                   TextureFormat fmt, TextureClampMode clampMode, const void* data, size_t sz);
+        ObjToken<ITextureD> newDynamicTexture(size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode);
+        ObjToken<ITextureR> newRenderTexture(size_t width, size_t height, TextureClampMode clampMode,
+                                             size_t colorBindingCount, size_t depthBindingCount);
 
-        bool bindingNeedsVertexFormat() const {return true;}
-        IVertexFormat* newVertexFormat(size_t elementCount, const VertexElementDescriptor* elements,
-                                       size_t baseVert = 0, size_t baseInst = 0);
+        bool bindingNeedsVertexFormat() const { return true; }
+        ObjToken<IVertexFormat> newVertexFormat(size_t elementCount, const VertexElementDescriptor* elements,
+                                                size_t baseVert = 0, size_t baseInst = 0);
 
-        IShaderPipeline* newShaderPipeline(const char* vertSource, const char* fragSource,
-                                           size_t texCount, const char** texNames,
-                                           size_t uniformBlockCount, const char** uniformBlockNames,
-                                           BlendFactor srcFac, BlendFactor dstFac, Primitive prim,
-                                           ZTest depthTest, bool depthWrite, bool colorWrite,
-                                           bool alphaWrite, CullMode culling);
+        ObjToken<IShaderPipeline> newShaderPipeline(const char* vertSource, const char* fragSource,
+                                                    size_t texCount, const char** texNames,
+                                                    size_t uniformBlockCount, const char** uniformBlockNames,
+                                                    BlendFactor srcFac, BlendFactor dstFac, Primitive prim,
+                                                    ZTest depthTest, bool depthWrite, bool colorWrite,
+                                                    bool alphaWrite, CullMode culling);
 
-        IShaderDataBinding*
-        newShaderDataBinding(IShaderPipeline* pipeline,
-                             IVertexFormat* vtxFormat,
-                             IGraphicsBuffer* vbo, IGraphicsBuffer* instVbo, IGraphicsBuffer* ibo,
-                             size_t ubufCount, IGraphicsBuffer** ubufs, const PipelineStage* ubufStages,
+        ObjToken<IShaderDataBinding>
+        newShaderDataBinding(const ObjToken<IShaderPipeline>& pipeline,
+                             const ObjToken<IVertexFormat>& vtxFormat,
+                             const ObjToken<IGraphicsBuffer>& vbo,
+                             const ObjToken<IGraphicsBuffer>& instVbo,
+                             const ObjToken<IGraphicsBuffer>& ibo,
+                             size_t ubufCount, const ObjToken<IGraphicsBuffer>* ubufs, const PipelineStage* ubufStages,
                              const size_t* ubufOffs, const size_t* ubufSizes,
-                             size_t texCount, ITexture** texs,
+                             size_t texCount, const ObjToken<ITexture>* texs,
                              const int* texBindIdx, const bool* depthBind,
                              size_t baseVert = 0, size_t baseInst = 0);
     };

include/boo/graphicsdev/IGraphicsCommandQueue.hpp

@@ -16,12 +16,12 @@ struct IGraphicsCommandQueue
     virtual Platform platform() const=0;
     virtual const SystemChar* platformName() const=0;
 
-    virtual void setShaderDataBinding(IShaderDataBinding* binding)=0;
-    virtual void setRenderTarget(ITextureR* target)=0;
+    virtual void setShaderDataBinding(const ObjToken<IShaderDataBinding>& binding)=0;
+    virtual void setRenderTarget(const ObjToken<ITextureR>& target)=0;
     virtual void setViewport(const SWindowRect& rect, float znear=0.f, float zfar=1.f)=0;
     virtual void setScissor(const SWindowRect& rect)=0;
 
-    virtual void resizeRenderTexture(ITextureR* tex, size_t width, size_t height)=0;
+    virtual void resizeRenderTexture(const ObjToken<ITextureR>& tex, size_t width, size_t height)=0;
     virtual void schedulePostFrameHandler(std::function<void(void)>&& func)=0;
 
     virtual void setClearColor(const float rgba[4])=0;
@@ -32,9 +32,9 @@ struct IGraphicsCommandQueue
     virtual void drawInstances(size_t start, size_t count, size_t instCount)=0;
     virtual void drawInstancesIndexed(size_t start, size_t count, size_t instCount)=0;
 
-    virtual void resolveBindTexture(ITextureR* texture, const SWindowRect& rect,
+    virtual void resolveBindTexture(const ObjToken<ITextureR>& texture, const SWindowRect& rect,
                                     bool tlOrigin, int bindIdx, bool color, bool depth)=0;
-    virtual void resolveDisplay(ITextureR* source)=0;
+    virtual void resolveDisplay(const ObjToken<ITextureR>& source)=0;
     virtual void execute()=0;
 
     virtual void stopRenderer()=0;

include/boo/graphicsdev/IGraphicsDataFactory.hpp

@@ -6,47 +6,12 @@
 #include <stdint.h>
 #include "boo/System.hpp"
 #include "boo/ThreadLocalPtr.hpp"
+#include "boo/BooObject.hpp"
 
 namespace boo
 {
 struct IGraphicsCommandQueue;
 
-/** Opaque object for maintaining ownership of factory-created resources */
-struct IGraphicsData { virtual ~IGraphicsData() = default; };
-class GraphicsDataToken;
-
-/** Opaque object for maintaining ownership of factory-created pool buffers */
-struct IGraphicsBufferPool {};
-class GraphicsBufferPoolToken;
-
-struct IGraphicsBuffer
-{
-    bool dynamic() const {return m_dynamic;}
-    IGraphicsData* m_parentData;
-protected:
-    bool m_dynamic;
-    IGraphicsBuffer(IGraphicsData* parent, bool dynamic)
-    : m_parentData(parent), m_dynamic(dynamic) {}
-    virtual ~IGraphicsBuffer() = default;
-};
-
-/** Static resource buffer for verts, indices, uniform constants */
-struct IGraphicsBufferS : IGraphicsBuffer
-{
-protected:
-    IGraphicsBufferS(IGraphicsData* parent) : IGraphicsBuffer(parent, false) {}
-};
-
-/** Dynamic resource buffer for verts, indices, uniform constants */
-struct IGraphicsBufferD : IGraphicsBuffer
-{
-    virtual void load(const void* data, size_t sz)=0;
-    virtual void* map(size_t sz)=0;
-    virtual void unmap()=0;
-protected:
-    IGraphicsBufferD(IGraphicsData* parent) : IGraphicsBuffer(parent, true) {}
-};
-
 /** Supported buffer uses */
 enum class BufferUse
 {
@@ -56,6 +21,33 @@ enum class BufferUse
     Uniform
 };
 
+/** Typeless graphics buffer */
+struct IGraphicsBuffer : IObj
+{
+    bool dynamic() const { return m_dynamic; }
+protected:
+    bool m_dynamic;
+    explicit IGraphicsBuffer(bool dynamic) : m_dynamic(dynamic) {}
+};
+
+/** Static resource buffer for verts, indices, uniform constants */
+struct IGraphicsBufferS : IGraphicsBuffer
+{
+protected:
+    IGraphicsBufferS() : IGraphicsBuffer(false) {}
+};
+
+/** Dynamic resource buffer for verts, indices, uniform constants */
+struct IGraphicsBufferD : IGraphicsBuffer
+{
+    virtual void load(const void* data, size_t sz)=0;
+    virtual void* map(size_t sz)=0;
+    virtual void unmap()=0;
+protected:
+    IGraphicsBufferD() : IGraphicsBuffer(true) {}
+};
+
+/** Texture access types */
 enum class TextureType
 {
     Static,
@@ -64,48 +56,6 @@ enum class TextureType
     Render
 };
 
-struct ITexture
-{
-    TextureType type() const {return m_type;}
-    IGraphicsData* m_parentData;
-protected:
-    TextureType m_type;
-    ITexture(IGraphicsData* parent, TextureType type)
-    : m_parentData(parent), m_type(type) {}
-    virtual ~ITexture() {}
-};
-
-/** Static resource buffer for textures */
-struct ITextureS : ITexture
-{
-protected:
-    ITextureS(IGraphicsData* parent) : ITexture(parent, TextureType::Static) {}
-};
-
-/** Static-array resource buffer for array textures */
-struct ITextureSA : ITexture
-{
-protected:
-    ITextureSA(IGraphicsData* parent) : ITexture(parent, TextureType::StaticArray) {}
-};
-
-/** Dynamic resource buffer for textures */
-struct ITextureD : ITexture
-{
-    virtual void load(const void* data, size_t sz)=0;
-    virtual void* map(size_t sz)=0;
-    virtual void unmap()=0;
-protected:
-    ITextureD(IGraphicsData* parent) : ITexture(parent, TextureType::Dynamic) {}
-};
-
-/** Resource buffer for render-target textures */
-struct ITextureR : ITexture
-{
-protected:
-    ITextureR(IGraphicsData* parent) : ITexture(parent, TextureType::Render) {}
-};
-
 /** Supported texture formats */
 enum class TextureFormat
 {
@@ -115,21 +65,57 @@ enum class TextureFormat
     PVRTC4
 };
 
+/** Supported texture clamp modes */
 enum class TextureClampMode
 {
     Repeat,
     ClampToWhite
 };
 
+/** Typeless texture */
+struct ITexture : IObj
+{
+    TextureType type() const { return m_type; }
+protected:
+    TextureType m_type;
+    explicit ITexture(TextureType type) : m_type(type) {}
+};
+
+/** Static resource buffer for textures */
+struct ITextureS : ITexture
+{
+protected:
+    ITextureS() : ITexture(TextureType::Static) {}
+};
+
+/** Static-array resource buffer for array textures */
+struct ITextureSA : ITexture
+{
+protected:
+    ITextureSA() : ITexture(TextureType::StaticArray) {}
+};
+
+/** Dynamic resource buffer for textures */
+struct ITextureD : ITexture
+{
+    virtual void load(const void* data, size_t sz)=0;
+    virtual void* map(size_t sz)=0;
+    virtual void unmap()=0;
+protected:
+    ITextureD() : ITexture(TextureType::Dynamic) {}
+};
+
+/** Resource buffer for render-target textures */
+struct ITextureR : ITexture
+{
+protected:
+    ITextureR() : ITexture(TextureType::Render) {}
+};
+
 /** Opaque token for representing the data layout of a vertex
  *  in a VBO. Also able to reference buffers for platforms like
  *  OpenGL that cache object refs */
-struct IVertexFormat
-{
-    IGraphicsData* m_parentData;
-protected:
-    IVertexFormat(IGraphicsData* parent) : m_parentData(parent) {}
-};
+struct IVertexFormat : IObj {};
 
 /** Types of vertex attributes */
 enum class VertexSemantic
@@ -164,17 +150,12 @@ struct VertexElementDescriptor
 
 /** Opaque token for referencing a complete graphics pipeline state necessary
  *  to rasterize geometry (shaders and blending modes mainly) */
-struct IShaderPipeline
-{
-    IGraphicsData* m_parentData;
-protected:
-    IShaderPipeline(IGraphicsData* parent) : m_parentData(parent) {}
-};
+struct IShaderPipeline : IObj {};
 
 /** Opaque token serving as indirection table for shader resources
  *  and IShaderPipeline reference. Each renderable surface-material holds one
  *  as a reference */
-struct IShaderDataBinding {};
+struct IShaderDataBinding : IObj {};
 
 /** Used wherever distinction of pipeline stages is needed */
 enum class PipelineStage
@@ -252,44 +233,48 @@ struct IGraphicsDataFactory
         virtual Platform platform() const=0;
         virtual const SystemChar* platformName() const=0;
 
-        virtual IGraphicsBufferS*
+        virtual ObjToken<IGraphicsBufferS>
         newStaticBuffer(BufferUse use, const void* data, size_t stride, size_t count)=0;
-        virtual IGraphicsBufferD*
+        virtual ObjToken<IGraphicsBufferD>
         newDynamicBuffer(BufferUse use, size_t stride, size_t count)=0;
 
-        virtual ITextureS*
+        virtual ObjToken<ITextureS>
         newStaticTexture(size_t width, size_t height, size_t mips, TextureFormat fmt,
                          TextureClampMode clampMode, const void* data, size_t sz)=0;
-        virtual ITextureSA*
+        virtual ObjToken<ITextureSA>
         newStaticArrayTexture(size_t width, size_t height, size_t layers, size_t mips,
                               TextureFormat fmt, TextureClampMode clampMode, const void* data, size_t sz)=0;
-        virtual ITextureD*
+        virtual ObjToken<ITextureD>
         newDynamicTexture(size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode)=0;
-        virtual ITextureR*
+        virtual ObjToken<ITextureR>
         newRenderTexture(size_t width, size_t height, TextureClampMode clampMode,
                          size_t colorBindingCount, size_t depthBindingCount)=0;
 
         virtual bool bindingNeedsVertexFormat() const=0;
-        virtual IVertexFormat*
+        virtual ObjToken<IVertexFormat>
         newVertexFormat(size_t elementCount, const VertexElementDescriptor* elements,
                         size_t baseVert = 0, size_t baseInst = 0)=0;
 
-        virtual IShaderDataBinding*
-        newShaderDataBinding(IShaderPipeline* pipeline,
-                             IVertexFormat* vtxFormat,
-                             IGraphicsBuffer* vbo, IGraphicsBuffer* instVbo, IGraphicsBuffer* ibo,
-                             size_t ubufCount, IGraphicsBuffer** ubufs, const PipelineStage* ubufStages,
+        virtual ObjToken<IShaderDataBinding>
+        newShaderDataBinding(const ObjToken<IShaderPipeline>& pipeline,
+                             const ObjToken<IVertexFormat>& vtxFormat,
+                             const ObjToken<IGraphicsBuffer>& vbo,
+                             const ObjToken<IGraphicsBuffer>& instVbo,
+                             const ObjToken<IGraphicsBuffer>& ibo,
+                             size_t ubufCount, const ObjToken<IGraphicsBuffer>* ubufs, const PipelineStage* ubufStages,
                              const size_t* ubufOffs, const size_t* ubufSizes,
-                             size_t texCount, ITexture** texs,
+                             size_t texCount, const ObjToken<ITexture>* texs,
                              const int* texBindIdx, const bool* depthBind,
                              size_t baseVert = 0, size_t baseInst = 0)=0;
 
-        IShaderDataBinding*
-        newShaderDataBinding(IShaderPipeline* pipeline,
-                             IVertexFormat* vtxFormat,
-                             IGraphicsBuffer* vbo, IGraphicsBuffer* instVbo, IGraphicsBuffer* ibo,
-                             size_t ubufCount, IGraphicsBuffer** ubufs, const PipelineStage* ubufStages,
-                             size_t texCount, ITexture** texs,
+        ObjToken<IShaderDataBinding>
+        newShaderDataBinding(const ObjToken<IShaderPipeline>& pipeline,
+                             const ObjToken<IVertexFormat>& vtxFormat,
+                             const ObjToken<IGraphicsBuffer>& vbo,
+                             const ObjToken<IGraphicsBuffer>& instVbo,
+                             const ObjToken<IGraphicsBuffer>& ibo,
+                             size_t ubufCount, const ObjToken<IGraphicsBuffer>* ubufs, const PipelineStage* ubufStages,
+                             size_t texCount, const ObjToken<ITexture>* texs,
                              const int* texBindIdx, const bool* depthBind,
                              size_t baseVert = 0, size_t baseInst = 0)
         {
@@ -300,130 +285,13 @@ struct IGraphicsDataFactory
         }
     };
 
-    virtual GraphicsDataToken commitTransaction(const std::function<bool(Context& ctx)>&)=0;
-    virtual GraphicsBufferPoolToken newBufferPool()=0;
+    virtual void commitTransaction(const std::function<bool(Context& ctx)>&)=0;
 
-    virtual void destroyAllData()=0;
-private:
-    friend class GraphicsDataToken;
-    virtual void destroyData(IGraphicsData*)=0;
-
-    friend class GraphicsBufferPoolToken;
-    virtual void destroyPool(IGraphicsBufferPool*)=0;
-    virtual IGraphicsBufferD* newPoolBuffer(IGraphicsBufferPool* pool, BufferUse use,
-                                            size_t stride, size_t count)=0;
-    virtual void deletePoolBuffer(IGraphicsBufferPool* p, IGraphicsBufferD* buf)=0;
+    virtual ObjToken<IGraphicsBufferD> newPoolBuffer(BufferUse use, size_t stride, size_t count)=0;
 };
 
-using FactoryCommitFunc = std::function<bool(IGraphicsDataFactory::Context& ctx)>;
-
-/** Ownership token for maintaining lifetime of factory-created resources.
- *  Deletion of this token triggers mass-deallocation of the factory's
- *  IGraphicsData (please don't delete and draw contained resources in the same frame). */
-class GraphicsDataToken
-{
-    friend class GLDataFactoryImpl;
-    friend class D3D12DataFactory;
-    friend class D3D11DataFactory;
-    friend class MetalDataFactoryImpl;
-    friend class VulkanDataFactoryImpl;
-    IGraphicsDataFactory* m_factory = nullptr;
-    IGraphicsData* m_data = nullptr;
-    GraphicsDataToken(IGraphicsDataFactory* factory, IGraphicsData* data)
-    : m_factory(factory), m_data(data) {}
-public:
-    void doDestroy()
-    {
-        if (m_factory && m_data)
-        {
-            m_factory->destroyData(m_data);
-            m_factory = nullptr;
-            m_data = nullptr;
-        }
-    }
-    GraphicsDataToken() = default;
-    GraphicsDataToken(const GraphicsDataToken& other) = delete;
-    GraphicsDataToken(GraphicsDataToken&& other)
-    {
-        m_factory = other.m_factory;
-        other.m_factory = nullptr;
-        m_data = other.m_data;
-        other.m_data = nullptr;
-    }
-    GraphicsDataToken& operator=(const GraphicsDataToken& other) = delete;
-    GraphicsDataToken& operator=(GraphicsDataToken&& other)
-    {
-        doDestroy();
-        m_factory = other.m_factory;
-        other.m_factory = nullptr;
-        m_data = other.m_data;
-        other.m_data = nullptr;
-        return *this;
-    }
-    ~GraphicsDataToken() {doDestroy();}
-    operator bool() const {return m_factory && m_data;}
-};
-
-/** Ownership token for maintaining lifetimes of an appendable list of dynamic buffers.
- *  Deletion of this token triggers mass-deallocation of the IGraphicsBufferPool
- *  (please don't delete and draw contained resources in the same frame). */
-class GraphicsBufferPoolToken
-{
-    friend class GLDataFactoryImpl;
-    friend class D3D12DataFactory;
-    friend class D3D11DataFactory;
-    friend class MetalDataFactoryImpl;
-    friend class VulkanDataFactoryImpl;
-    IGraphicsDataFactory* m_factory = nullptr;
-    IGraphicsBufferPool* m_pool = nullptr;
-    GraphicsBufferPoolToken(IGraphicsDataFactory* factory, IGraphicsBufferPool* pool)
-    : m_factory(factory), m_pool(pool) {}
-public:
-    void doDestroy()
-    {
-        if (m_factory && m_pool)
-        {
-            m_factory->destroyPool(m_pool);
-            m_factory = nullptr;
-            m_pool = nullptr;
-        }
-    }
-    GraphicsBufferPoolToken() = default;
-    GraphicsBufferPoolToken(const GraphicsBufferPoolToken& other) = delete;
-    GraphicsBufferPoolToken(GraphicsBufferPoolToken&& other)
-    {
-        m_factory = other.m_factory;
-        other.m_factory = nullptr;
-        m_pool = other.m_pool;
-        other.m_pool = nullptr;
-    }
-    GraphicsBufferPoolToken& operator=(const GraphicsBufferPoolToken& other) = delete;
-    GraphicsBufferPoolToken& operator=(GraphicsBufferPoolToken&& other)
-    {
-        doDestroy();
-        m_factory = other.m_factory;
-        other.m_factory = nullptr;
-        m_pool = other.m_pool;
-        other.m_pool = nullptr;
-        return *this;
-    }
-    ~GraphicsBufferPoolToken() {doDestroy();}
-    operator bool() const {return m_factory && m_pool;}
-
-    IGraphicsBufferD* newPoolBuffer(BufferUse use,
-                                    size_t stride, size_t count)
-    {
-        if (m_factory)
-            return m_factory->newPoolBuffer(m_pool, use, stride, count);
-        return nullptr;
-    }
-
-    void deletePoolBuffer(IGraphicsBufferD* buf)
-    {
-        if (m_factory)
-            m_factory->deletePoolBuffer(m_pool, buf);
-    }
-};
+using GraphicsDataFactoryContext = IGraphicsDataFactory::Context;
+using FactoryCommitFunc = std::function<bool(GraphicsDataFactoryContext& ctx)>;
 
 }
 

include/boo/graphicsdev/Metal.hpp

@@ -19,37 +19,41 @@ public:
         MetalDataFactory& m_parent;
         Context(MetalDataFactory& parent) : m_parent(parent) {}
     public:
-        Platform platform() const {return Platform::Metal;}
-        const char* platformName() const {return "Metal";}
+        Platform platform() const { return Platform::Metal; }
+        const SystemChar* platformName() const { return _S("Metal"); }
 
-        IGraphicsBufferS* newStaticBuffer(BufferUse use, const void* data, size_t stride, size_t count);
-        IGraphicsBufferD* newDynamicBuffer(BufferUse use, size_t stride, size_t count);
+        ObjToken<IGraphicsBufferS> newStaticBuffer(BufferUse use, const void* data, size_t stride, size_t count);
+        ObjToken<IGraphicsBufferD> newDynamicBuffer(BufferUse use, size_t stride, size_t count);
 
-        ITextureS* newStaticTexture(size_t width, size_t height, size_t mips, TextureFormat fmt,
-                                    TextureClampMode clampMode, const void* data, size_t sz);
-        ITextureSA* newStaticArrayTexture(size_t width, size_t height, size_t layers, size_t mips,
-                                          TextureFormat fmt, TextureClampMode clampMode, const void* data, size_t sz);
-        ITextureD* newDynamicTexture(size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode);
-        ITextureR* newRenderTexture(size_t width, size_t height, TextureClampMode clampMode,
-                                    size_t colorBindCount, size_t depthBindCount);
+        ObjToken<ITextureS> newStaticTexture(size_t width, size_t height, size_t mips, TextureFormat fmt,
+                                             TextureClampMode clampMode, const void* data, size_t sz);
+        ObjToken<ITextureSA> newStaticArrayTexture(size_t width, size_t height, size_t layers, size_t mips,
+                                                   TextureFormat fmt, TextureClampMode clampMode, const void* data,
+                                                   size_t sz);
+        ObjToken<ITextureD> newDynamicTexture(size_t width, size_t height, TextureFormat fmt,
+                                              TextureClampMode clampMode);
+        ObjToken<ITextureR> newRenderTexture(size_t width, size_t height, TextureClampMode clampMode,
+                                             size_t colorBindCount, size_t depthBindCount);
 
-        bool bindingNeedsVertexFormat() const {return false;}
-        IVertexFormat* newVertexFormat(size_t elementCount, const VertexElementDescriptor* elements,
-                                       size_t baseVert = 0, size_t baseInst = 0);
+        bool bindingNeedsVertexFormat() const { return false; }
+        ObjToken<IVertexFormat> newVertexFormat(size_t elementCount, const VertexElementDescriptor* elements,
+                                                size_t baseVert = 0, size_t baseInst = 0);
 
-        IShaderPipeline* newShaderPipeline(const char* vertSource, const char* fragSource,
-                                           IVertexFormat* vtxFmt, unsigned targetSamples,
-                                           BlendFactor srcFac, BlendFactor dstFac, Primitive prim,
-                                           ZTest depthTest, bool depthWrite, bool colorWrite,
-                                           bool alphaWrite, CullMode culling);
+        ObjToken<IShaderPipeline> newShaderPipeline(const char* vertSource, const char* fragSource,
+                                                    IVertexFormat* vtxFmt, unsigned targetSamples,
+                                                    BlendFactor srcFac, BlendFactor dstFac, Primitive prim,
+                                                    ZTest depthTest, bool depthWrite, bool colorWrite,
+                                                    bool alphaWrite, CullMode culling);
 
-        IShaderDataBinding*
-        newShaderDataBinding(IShaderPipeline* pipeline,
-                             IVertexFormat* vtxFormat,
-                             IGraphicsBuffer* vbo, IGraphicsBuffer* instVbo, IGraphicsBuffer* ibo,
-                             size_t ubufCount, IGraphicsBuffer** ubufs, const PipelineStage* ubufStages,
+        ObjToken<IShaderDataBinding>
+        newShaderDataBinding(const ObjToken<IShaderPipeline>& pipeline,
+                             const ObjToken<IVertexFormat>& vtxFormat,
+                             const ObjToken<IGraphicsBuffer>& vbo,
+                             const ObjToken<IGraphicsBuffer>& instVbo,
+                             const ObjToken<IGraphicsBuffer>& ibo,
+                             size_t ubufCount, const ObjToken<IGraphicsBuffer>* ubufs, const PipelineStage* ubufStages,
                              const size_t* ubufOffs, const size_t* ubufSizes,
-                             size_t texCount, ITexture** texs,
+                             size_t texCount, const ObjToken<ITexture>* texs,
                              const int* texBindIdxs, const bool* depthBind,
                              size_t baseVert = 0, size_t baseInst = 0);
     };