Add render resouce

openVulkanoCpp/Base/Render/RenderResource.hpp

@@ -0,0 +1,143 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include <concepts>
+#include <utility>
+#include <type_traits>
+
+namespace OpenVulkano
+{
+	class RenderResource;
+
+	class IRenderResourceHelper
+	{
+		friend class RenderResource;
+
+	protected:
+		void UpdateRenderResource(RenderResource& resource);
+
+		void ResetRenderResource(RenderResource& resource);
+
+		virtual void Release() = 0;
+	};
+
+	template <class T>
+	concept Renderable = std::is_convertible_v<T, RenderResource&>;
+
+	class RenderResource final
+	{
+		friend class IRenderResourceHelper;
+
+		IRenderResourceHelper* renderObject = nullptr;
+
+	public:
+		RenderResource() = default;
+		RenderResource(const RenderResource& ignored) { /* Do not copy, copy will be created by renderer */ }
+		RenderResource(RenderResource&& move) : renderObject(move.renderObject) { move.renderObject = nullptr; }
+
+		~RenderResource()
+		{
+			Release();
+		}
+
+		void Release()
+		{
+			if (!renderObject) return;
+			renderObject->Release();
+			renderObject = nullptr;
+		}
+
+		template<class T>
+		T* As() { return static_cast<T*>(renderObject); }
+
+		template<class T>
+		operator T() { return static_cast<T>(renderObject); }
+
+		operator bool() const { return renderObject; }
+	};
+
+	inline void IRenderResourceHelper::UpdateRenderResource(RenderResource& resource)
+	{
+		resource.renderObject = this;
+	}
+
+	inline void IRenderResourceHelper::ResetRenderResource(RenderResource& resource)
+	{
+		resource.renderObject = nullptr;
+	}
+
+	template<Renderable API_INDEPENDENT_CLASS>
+	class IRenderResource : public IRenderResourceHelper
+	{
+		API_INDEPENDENT_CLASS* m_owner;
+
+	protected:
+		IRenderResource(API_INDEPENDENT_CLASS* owner) : m_owner(owner)
+		{
+			if (m_owner) UpdateRenderResource(GetOwnerResource());
+		}
+
+		IRenderResource(const IRenderResource<API_INDEPENDENT_CLASS>& copy) = delete;
+
+		IRenderResource(IRenderResource<API_INDEPENDENT_CLASS>&& move)
+			: m_owner(move.m_owner)
+		{
+			if (m_owner) UpdateRenderResource(GetOwnerResource());
+			move.m_owner = nullptr;
+		}
+
+		RenderResource& GetOwnerResource() { return static_cast<RenderResource&>(*m_owner); }
+
+	public:
+		virtual ~IRenderResource()
+		{
+			if (m_owner) ResetRenderResource(GetOwnerResource());
+		}
+
+		void UpdateAddress(API_INDEPENDENT_CLASS* owner)
+		{
+			m_owner = owner;
+		}
+
+		operator API_INDEPENDENT_CLASS*() const { return m_owner; }
+
+		API_INDEPENDENT_CLASS* GetOwner() const { return m_owner; }
+	};
+
+	/**
+	 * This is a convenience class to create a Renderable class.
+	 * You can also just create a RenderResource instance a conversion operator inside your own class to make it Renderable; and you probably want to delete your move constructor in that case.
+	 */
+	template <class T>
+	class RenderResourceHolder
+	{
+		RenderResource renderResource;
+
+	protected:
+		RenderResourceHolder() = default;
+		RenderResourceHolder(const RenderResourceHolder& ignored) {}
+		RenderResourceHolder(RenderResourceHolder&& move)
+				: renderResource(std::move(move.renderResource))
+		{
+			if (IRenderResource<T>* renderRes = renderResource)
+				renderRes->UpdateAddress(static_cast<T*>(this));
+		}
+
+		~RenderResourceHolder() = default;
+
+	public:
+		operator RenderResource&() { return renderResource; }
+
+		RenderResource& GetRenderResource() { return renderResource; }
+
+		template<Renderable RT>
+		operator RT() const { return renderResource; }
+
+		bool HasRenderResource() const { return renderResource; }
+	};
+}