GraphicsTools: Added resource registry (close #452)

Author: MikhailGorobets

Graphics/GraphicsTools/CMakeLists.txt

@@ -12,6 +12,7 @@ set(INTERFACE
     interface/DurationQueryHelper.hpp
     interface/GraphicsUtilities.h
     interface/MapHelper.hpp
+    interface/ResourceRegistry.hpp
     interface/ScopedDebugGroup.hpp
     interface/GPUCompletionAwaitQueue.hpp
     interface/ScopedQueryHelper.hpp

Graphics/GraphicsTools/interface/GraphicsUtilities.h

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -154,6 +154,58 @@ void DILIGENT_GLOBAL_FUNCTION(CreateSparseTextureMtl)(IRenderDevice*        pDev
                                                       IDeviceMemory*        pMemory,
                                                       ITexture**            ppTexture);
 
+#if DILIGENT_CPP_INTERFACE
+
+/// Returns default shader resource view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetDefaultSRV)(ITexture* pTexture);
+
+/// Returns default render target view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetDefaultRTV)(ITexture* pTexture);
+
+/// Returns default depth-stencil view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetDefaultDSV)(ITexture* pTexture);
+
+/// Returns default unordered access view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetDefaultUAV)(ITexture* pTexture);
+
+/// Returns default shader resource view of a buffer.
+/// If the buffer is null, returns null.
+IBufferView* DILIGENT_GLOBAL_FUNCTION(GetDefaultSRV)(IBuffer* pBuffer);
+
+/// Returns default unordered access view of a buffer.
+/// If the buffer is null, returns null.
+IBufferView* DILIGENT_GLOBAL_FUNCTION(GetDefaultUAV)(IBuffer* pBuffer);
+
+#endif
+
+/// Returns default shader resource view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetTextureDefaultSRV)(IObject* pTexture);
+
+/// Returns default render target view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetTextureDefaultRTV)(IObject* pTexture);
+
+/// Returns default depth-stencil view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetTextureDefaultDSV)(IObject* pTexture);
+
+/// Returns default unordered access view of a texture.
+/// If the texture is null, returns null.
+ITextureView* DILIGENT_GLOBAL_FUNCTION(GetTextureDefaultUAV)(IObject* pTexture);
+
+/// Returns default shader resource view of a buffer.
+/// If the buffer is null, returns null.
+IBufferView* DILIGENT_GLOBAL_FUNCTION(GetBufferDefaultSRV)(IObject* pBuffer);
+
+/// Returns default unordered access view of a buffer.
+/// If the buffer is null, returns null.
+IBufferView* DILIGENT_GLOBAL_FUNCTION(GetBufferDefaultUAV)(IObject* pBuffer);
+
 #include "../../../Primitives/interface/UndefRefMacro.h"
 
 DILIGENT_END_NAMESPACE // namespace Diligent

Graphics/GraphicsTools/interface/ResourceRegistry.hpp

@@ -0,0 +1,123 @@
+/*
+ *  Copyright 2024 Diligent Graphics LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include "../../../Common/interface/RefCntAutoPtr.hpp"
+#include "../../GraphicsEngine/interface/Buffer.h"
+#include "../../GraphicsEngine/interface/Texture.h"
+#include "GraphicsUtilities.h"
+
+namespace Diligent
+{
+
+/// Helper class that facilitates resource management.
+class ResourceRegistry
+{
+public:
+    using ResourceIdType = Uint32;
+
+    ResourceRegistry()  = default;
+    ~ResourceRegistry() = default;
+
+    explicit ResourceRegistry(size_t ResourceCount) :
+        m_Resources(ResourceCount)
+    {}
+
+    void SetSize(size_t ResourceCount)
+    {
+        m_Resources.resize(ResourceCount);
+    }
+
+    void Insert(ResourceIdType Id, IDeviceObject* pObject)
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        m_Resources[Id] = pObject;
+    }
+
+    bool IsInitialized(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return m_Resources[Id] != nullptr;
+    }
+
+    ITexture* GetTexture(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        DEV_CHECK_ERR(RefCntAutoPtr<ITexture>(m_Resources[Id], IID_Texture), "Resource is not a texture");
+        return StaticCast<ITexture*>(m_Resources[Id]);
+    }
+
+    IBuffer* GetBuffer(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        DEV_CHECK_ERR(RefCntAutoPtr<IBuffer>(m_Resources[Id], IID_Buffer), "Resource is not a buffer");
+        return StaticCast<IBuffer*>(m_Resources[Id]);
+    }
+
+    ITextureView* GetTextureSRV(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return GetTextureDefaultSRV(m_Resources[Id]);
+    }
+
+    ITextureView* GetTextureRTV(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return GetTextureDefaultRTV(m_Resources[Id]);
+    }
+
+    ITextureView* GetTextureDSV(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return GetTextureDefaultDSV(m_Resources[Id]);
+    }
+
+    ITextureView* GetTextureUAV(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return GetTextureDefaultUAV(m_Resources[Id]);
+    }
+
+    IBufferView* GetBufferSRV(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return GetBufferDefaultSRV(m_Resources[Id]);
+    }
+
+    IBufferView* GetBufferUAV(ResourceIdType Id) const
+    {
+        DEV_CHECK_ERR(Id < m_Resources.size(), "Resource index is out of range");
+        return GetBufferDefaultUAV(m_Resources[Id]);
+    }
+
+private:
+    std::vector<RefCntAutoPtr<IDeviceObject>> m_Resources;
+};
+
+} // namespace Diligent

Graphics/GraphicsTools/src/GraphicsUtilities.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -33,6 +33,7 @@
 #include "DebugUtilities.hpp"
 #include "GraphicsAccessories.hpp"
 #include "ColorConversion.h"
+#include "RefCntAutoPtr.hpp"
 
 #define PI_F 3.1415926f
 
@@ -463,6 +464,82 @@ void CreateSparseTextureMtl(IRenderDevice*     pDevice,
 }
 #endif
 
+inline ITextureView* ExtractTextureView(ITexture* pTexture, TEXTURE_VIEW_TYPE ViewType)
+{
+    return pTexture != nullptr ? pTexture->GetDefaultView(ViewType) : nullptr;
+}
+
+inline IBufferView* ExtractBufferView(IBuffer* pBuffer, BUFFER_VIEW_TYPE ViewType)
+{
+    return pBuffer != nullptr ? pBuffer->GetDefaultView(ViewType) : nullptr;
+}
+
+ITextureView* GetDefaultSRV(ITexture* pTexture)
+{
+    return ExtractTextureView(pTexture, TEXTURE_VIEW_SHADER_RESOURCE);
+}
+
+ITextureView* GetDefaultRTV(ITexture* pTexture)
+{
+    return ExtractTextureView(pTexture, TEXTURE_VIEW_RENDER_TARGET);
+}
+
+ITextureView* GetDefaultDSV(ITexture* pTexture)
+{
+    return ExtractTextureView(pTexture, TEXTURE_VIEW_DEPTH_STENCIL);
+}
+
+ITextureView* GetDefaultUAV(ITexture* pTexture)
+{
+    return ExtractTextureView(pTexture, TEXTURE_VIEW_UNORDERED_ACCESS);
+}
+
+IBufferView* GetDefaultSRV(IBuffer* pBuffer)
+{
+    return ExtractBufferView(pBuffer, BUFFER_VIEW_SHADER_RESOURCE);
+}
+
+IBufferView* GetDefaultUAV(IBuffer* pBuffer)
+{
+    return ExtractBufferView(pBuffer, BUFFER_VIEW_UNORDERED_ACCESS);
+}
+
+ITextureView* GetTextureDefaultSRV(IObject* pTexture)
+{
+    DEV_CHECK_ERR(pTexture == nullptr || RefCntAutoPtr<ITexture>(pTexture, IID_Texture), "Resource is not a texture");
+    return GetDefaultSRV(static_cast<ITexture*>(pTexture));
+}
+
+ITextureView* GetTextureDefaultRTV(IObject* pTexture)
+{
+    DEV_CHECK_ERR(pTexture == nullptr || RefCntAutoPtr<ITexture>(pTexture, IID_Texture), "Resource is not a texture");
+    return GetDefaultRTV(static_cast<ITexture*>(pTexture));
+}
+
+ITextureView* GetTextureDefaultDSV(IObject* pTexture)
+{
+    DEV_CHECK_ERR(pTexture == nullptr || RefCntAutoPtr<ITexture>(pTexture, IID_Texture), "Resource is not a texture");
+    return GetDefaultDSV(static_cast<ITexture*>(pTexture));
+}
+
+ITextureView* GetTextureDefaultUAV(IObject* pTexture)
+{
+    DEV_CHECK_ERR(pTexture == nullptr || RefCntAutoPtr<ITexture>(pTexture, IID_Texture), "Resource is not a texture");
+    return GetDefaultUAV(static_cast<ITexture*>(pTexture));
+}
+
+IBufferView* GetBufferDefaultSRV(IObject* pBuffer)
+{
+    DEV_CHECK_ERR(pBuffer == nullptr || RefCntAutoPtr<IBuffer>(pBuffer, IID_Buffer), "Resource is not a buffer");
+    return GetDefaultSRV(static_cast<IBuffer*>(pBuffer));
+}
+
+IBufferView* GetBufferDefaultUAV(IObject* pBuffer)
+{
+    DEV_CHECK_ERR(pBuffer == nullptr || RefCntAutoPtr<IBuffer>(pBuffer, IID_Buffer), "Resource is not a buffer");
+    return GetDefaultUAV(static_cast<IBuffer*>(pBuffer));
+}
+
 } // namespace Diligent
 
 
@@ -503,4 +580,35 @@ extern "C"
     {
         Diligent::CreateSparseTextureMtl(pDevice, TexDesc, pMemory, ppTexture);
     }
+
+
+    Diligent::ITextureView* Diligent_GetTextureDefaultSRV(Diligent::IObject* pTexture)
+    {
+        return Diligent::GetTextureDefaultSRV(pTexture);
+    }
+
+    Diligent::ITextureView* Diligent_GetTextureDefaultRTV(Diligent::IObject* pTexture)
+    {
+        return Diligent::GetTextureDefaultRTV(pTexture);
+    }
+
+    Diligent::ITextureView* Diligent_GetTextureDefaultDSV(Diligent::IObject* pTexture)
+    {
+        return Diligent::GetTextureDefaultDSV(pTexture);
+    }
+
+    Diligent::ITextureView* Diligent_GetTextureDefaultUAV(Diligent::IObject* pTexture)
+    {
+        return Diligent::GetTextureDefaultUAV(pTexture);
+    }
+
+    Diligent::IBufferView* Diligent_GetBufferDefaultSRV(Diligent::IObject* pBuffer)
+    {
+        return Diligent::GetBufferDefaultSRV(pBuffer);
+    }
+
+    Diligent::IBufferView* Diligent_GetBufferDefaultRTV(Diligent::IObject* pBuffer)
+    {
+        return Diligent::GetBufferDefaultUAV(pBuffer);
+    }
 }

Tests/IncludeTest/GraphicsTools/ResourceRegistryH_test.cpp

@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2024 Diligent Graphics LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#include "DiligentCore/Graphics/GraphicsTools/interface/ResourceRegistry.hpp"