144 lines
3.5 KiB
C++
144 lines
3.5 KiB
C++
/*
|
|
* 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; }
|
|
};
|
|
}
|