Radient: expose GPU resource pool settings in engine create info

Author: TheMostDiligent

Radient/include/Assets/RadientAssetManagerImpl.hpp

@@ -70,9 +70,10 @@ class RadientAssetManagerImpl final : public ObjectBase<IRadientAssetManager>
 
     struct CreateInfo
     {
-        RadientAssetManagerCreateInfo Assets;
-        IThreadPool*                  pThreadPool = nullptr;
-        IRenderDevice*                pDevice     = nullptr;
+        RadientAssetManagerCreateInfo    Assets;
+        RadientResourceManagerCreateInfo Resources;
+        IThreadPool*                     pThreadPool = nullptr;
+        IRenderDevice*                   pDevice     = nullptr;
     };
 
     RadientAssetManagerImpl(IReferenceCounters* pRefCounters,

Radient/interface/RadientAssets.h

@@ -112,6 +112,46 @@ DILIGENT_TYPED_ENUM(RADIENT_INDEX_TYPE, Uint8)
 // clang-format on
 
 
+/// GPU resource pool creation attributes used by the engine's asset manager.
+/// These settings control resource capacity, not rendering feature availability.
+struct RadientResourceManagerCreateInfo
+{
+    /// Initial size and growth increment of each index buffer, in bytes.
+    /// Zero selects the engine default.
+    Uint32 IndexBufferSize DEFAULT_INITIALIZER(4u * 1024u * 1024u);
+
+    /// Maximum size of each index buffer, in bytes. Zero prevents growth beyond IndexBufferSize.
+    Uint64 MaxIndexBufferSize DEFAULT_INITIALIZER(256ull * 1024ull * 1024ull);
+
+    /// Initial size and growth increment of the morph-target buffer, in bytes.
+    /// Zero selects the engine default.
+    Uint32 MorphTargetBufferSize DEFAULT_INITIALIZER(1024u * 1024u);
+
+    /// Maximum morph-target buffer size, in bytes. Zero prevents growth beyond MorphTargetBufferSize.
+    Uint64 MaxMorphTargetBufferSize DEFAULT_INITIALIZER(256ull * 1024ull * 1024ull);
+
+    /// Vertex capacity of each new vertex pool. Zero selects the engine default.
+    /// Rounded up to a multiple of 1024 vertices.
+    Uint32 VertexPoolSize DEFAULT_INITIALIZER(64u * 1024u);
+
+    /// Starting width and height of each default texture atlas, in texels.
+    /// Zero selects the engine default.
+    Uint32 TextureAtlasSize DEFAULT_INITIALIZER(2048);
+
+    /// Maximum mip-level-0 size of one atlas slice, in bytes. Zero disables this limit.
+    /// Both dimensions are halved until the slice fits, without reducing either below 16.
+    /// The minimum dimensions take precedence when the limit is too small.
+    Uint64 TextureAtlasMipLevel0Size DEFAULT_INITIALIZER(16ull * 1024ull * 1024ull);
+
+    /// Initial number of slices in each texture atlas. Zero defers storage allocation.
+    Uint32 TextureAtlasSlices DEFAULT_INITIALIZER(1);
+
+    /// Maximum number of slices in each texture atlas. Zero selects the engine default.
+    Uint32 TextureAtlasMaxSlices DEFAULT_INITIALIZER(2048);
+};
+typedef struct RadientResourceManagerCreateInfo RadientResourceManagerCreateInfo;
+
+
 /// Asset manager description.
 struct RadientAssetManagerDesc
 {

Radient/interface/RadientEngine.h

@@ -56,6 +56,9 @@ struct RadientEngineCreateInfo
     /// Number of worker threads for the internal thread pool.
     /// Zero lets Radient choose a default based on the host system.
     Uint32 WorkerThreadCount DEFAULT_INITIALIZER(0);
+
+    /// GPU resource pool creation attributes. Used when the backend has a native device.
+    RadientResourceManagerCreateInfo Resources DEFAULT_INITIALIZER({});
 };
 typedef struct RadientEngineCreateInfo RadientEngineCreateInfo;
 

Radient/src/Assets/RadientAssetManagerImpl.cpp

@@ -55,16 +55,6 @@ namespace Diligent
 namespace
 {
 
-constexpr Uint64 RadientDefaultIndexBufferSize           = 16ull * 1024ull * 1024ull;
-constexpr Uint64 RadientDefaultMaxIndexBufferSize        = 256ull * 1024ull * 1024ull;
-constexpr Uint64 RadientDefaultMorphTargetBufferSize     = 1024ull * 1024ull;
-constexpr Uint64 RadientDefaultMaxMorphTargetBufferSize  = 256ull * 1024ull * 1024ull;
-constexpr Uint32 RadientDefaultVertexPoolSize            = 1024u * 1024u;
-constexpr Uint32 RadientDefaultTextureAtlasSize          = 2048u;
-constexpr Uint64 RadientDefaultTextureAtlasMipLevel0Size = 16ull * 1024ull * 1024ull;
-constexpr Uint32 RadientDefaultTextureAtlasSlices        = 1u;
-constexpr Uint32 RadientDefaultTextureAtlasMaxSlices     = 2048u;
-
 static constexpr INTERFACE_ID IID_SceneAssetImpl = {0xb59806f1, 0xa08a, 0x4dff, {0xb0, 0x37, 0x84, 0x75, 0xd6, 0xfd, 0x7f, 0x1b}};
 
 struct ImportedSceneStorage
@@ -196,52 +186,52 @@ struct ImportedSceneStorage
     mutable std::atomic<RADIENT_STATUS>      GPUResourceStatus{RADIENT_STATUS_OK};
 };
 
-GLTF::ResourceManager::CreateInfo CreateResourceManagerInfo()
+GLTF::ResourceManager::CreateInfo CreateResourceManagerInfo(const RadientResourceManagerCreateInfo& ResourceCI)
 {
     GLTF::ResourceManager::CreateInfo CreateInfo;
 
     CreateInfo.IndexAllocatorCI.Desc.Name      = "Radient index pool";
-    CreateInfo.IndexAllocatorCI.Desc.Size      = RadientDefaultIndexBufferSize;
+    CreateInfo.IndexAllocatorCI.Desc.Size      = ResourceCI.IndexBufferSize;
     CreateInfo.IndexAllocatorCI.Desc.Usage     = USAGE_DEFAULT;
     CreateInfo.IndexAllocatorCI.Desc.BindFlags = BIND_INDEX_BUFFER;
-    CreateInfo.IndexAllocatorCI.ExpansionSize  = static_cast<Uint32>(RadientDefaultIndexBufferSize);
-    CreateInfo.IndexAllocatorCI.MaxSize        = RadientDefaultMaxIndexBufferSize;
+    CreateInfo.IndexAllocatorCI.ExpansionSize  = ResourceCI.IndexBufferSize;
+    CreateInfo.IndexAllocatorCI.MaxSize        = ResourceCI.MaxIndexBufferSize;
 
     CreateInfo.MorphTargetAllocatorCI.Desc.Name              = "Radient morph target buffer";
-    CreateInfo.MorphTargetAllocatorCI.Desc.Size              = RadientDefaultMorphTargetBufferSize;
+    CreateInfo.MorphTargetAllocatorCI.Desc.Size              = ResourceCI.MorphTargetBufferSize;
     CreateInfo.MorphTargetAllocatorCI.Desc.Usage             = USAGE_DEFAULT;
     CreateInfo.MorphTargetAllocatorCI.Desc.BindFlags         = BIND_SHADER_RESOURCE;
     CreateInfo.MorphTargetAllocatorCI.Desc.Mode              = BUFFER_MODE_STRUCTURED;
     CreateInfo.MorphTargetAllocatorCI.Desc.ElementByteStride = sizeof(Float32);
-    CreateInfo.MorphTargetAllocatorCI.ExpansionSize          = static_cast<Uint32>(RadientDefaultMorphTargetBufferSize);
-    CreateInfo.MorphTargetAllocatorCI.MaxSize                = RadientDefaultMaxMorphTargetBufferSize;
+    CreateInfo.MorphTargetAllocatorCI.ExpansionSize          = ResourceCI.MorphTargetBufferSize;
+    CreateInfo.MorphTargetAllocatorCI.MaxSize                = ResourceCI.MaxMorphTargetBufferSize;
 
     CreateInfo.DefaultPoolDesc.Name        = "Radient vertex pool";
-    CreateInfo.DefaultPoolDesc.VertexCount = RadientDefaultVertexPoolSize;
+    CreateInfo.DefaultPoolDesc.VertexCount = ResourceCI.VertexPoolSize;
     CreateInfo.DefaultPoolDesc.Usage       = USAGE_DEFAULT;
     CreateInfo.DefaultPoolDesc.Mode        = BUFFER_MODE_UNDEFINED;
 
     CreateInfo.DefaultAtlasDesc.Desc.Name      = "Radient texture atlas";
     CreateInfo.DefaultAtlasDesc.Desc.Type      = RESOURCE_DIM_TEX_2D_ARRAY;
-    CreateInfo.DefaultAtlasDesc.Desc.Width     = RadientDefaultTextureAtlasSize;
-    CreateInfo.DefaultAtlasDesc.Desc.Height    = RadientDefaultTextureAtlasSize;
+    CreateInfo.DefaultAtlasDesc.Desc.Width     = ResourceCI.TextureAtlasSize;
+    CreateInfo.DefaultAtlasDesc.Desc.Height    = ResourceCI.TextureAtlasSize;
     CreateInfo.DefaultAtlasDesc.Desc.MipLevels = 0;
-    CreateInfo.DefaultAtlasDesc.Desc.ArraySize = RadientDefaultTextureAtlasSlices;
+    CreateInfo.DefaultAtlasDesc.Desc.ArraySize = ResourceCI.TextureAtlasSlices;
     CreateInfo.DefaultAtlasDesc.Desc.Format    = TEX_FORMAT_RGBA8_TYPELESS;
     CreateInfo.DefaultAtlasDesc.Desc.Usage     = USAGE_DEFAULT;
     CreateInfo.DefaultAtlasDesc.Desc.BindFlags = BIND_SHADER_RESOURCE;
-    CreateInfo.DefaultAtlasDesc.MaxSliceCount  = RadientDefaultTextureAtlasMaxSlices;
-    CreateInfo.DefaultAtlasMipLevel0Size       = RadientDefaultTextureAtlasMipLevel0Size;
+    CreateInfo.DefaultAtlasDesc.MaxSliceCount  = ResourceCI.TextureAtlasMaxSlices;
+    CreateInfo.DefaultAtlasMipLevel0Size       = ResourceCI.TextureAtlasMipLevel0Size;
 
     return CreateInfo;
 }
 
-RefCntAutoPtr<GLTF::ResourceManager> CreateRadientResourceManager(IRenderDevice* pDevice)
+RefCntAutoPtr<GLTF::ResourceManager> CreateRadientResourceManager(IRenderDevice* pDevice, const RadientResourceManagerCreateInfo& ResourceCI)
 {
     if (pDevice == nullptr)
         return {};
 
-    return GLTF::ResourceManager::Create(pDevice, CreateResourceManagerInfo());
+    return GLTF::ResourceManager::Create(pDevice, CreateResourceManagerInfo(ResourceCI));
 }
 
 RefCntAutoPtr<IGPUUploadManager> CreateRadientGPUUploadManager(IRenderDevice* pDevice)
@@ -404,7 +394,7 @@ RadientAssetManagerImpl::RadientAssetManagerImpl(IReferenceCounters* pRefCounter
     m_pThreadPool{CreateInfo.pThreadPool},
     m_pDevice{CreateInfo.pDevice},
     m_pAssetResolver{GetRadientAssetResolverOrDefault(CreateInfo.Assets.pAssetResolver)},
-    m_pResourceManager{CreateRadientResourceManager(CreateInfo.pDevice)},
+    m_pResourceManager{CreateRadientResourceManager(CreateInfo.pDevice, CreateInfo.Resources)},
     m_pUploadManager{CreateRadientGPUUploadManager(CreateInfo.pDevice)},
     m_pTextureManager{
         RadientTextureAssetManager::Create(

Radient/src/Core/RadientEngineImpl.cpp

@@ -29,11 +29,13 @@
 #include "Animation/RadientAnimationRegistryImpl.hpp"
 #include "Assets/RadientAssetManagerImpl.hpp"
 #include "Core/RadientBackendImpl.hpp"
+#include "Core/RadientValidation.hpp"
 #include "Render/RadientRendererImpl.hpp"
 #include "Scene/RadientSceneImpl.hpp"
 #include "Import/RadientSceneImporterImpl.hpp"
 #include "Scene/RadientSceneWriterImpl.hpp"
 
+#include "Align.hpp"
 #include "Errors.hpp"
 #include "ThreadPool.hpp"
 
@@ -53,6 +55,41 @@ size_t GetDefaultRadientWorkerThreadCount()
     return std::max(1u, HardwareThreads != 0 ? HardwareThreads - 1u : 1u);
 }
 
+bool NormalizeResourceManagerCreateInfo(RadientResourceManagerCreateInfo& ResourceCI)
+{
+    constexpr RadientResourceManagerCreateInfo Defaults{};
+    if (ResourceCI.IndexBufferSize == 0)
+        ResourceCI.IndexBufferSize = Defaults.IndexBufferSize;
+    if (ResourceCI.MorphTargetBufferSize == 0)
+        ResourceCI.MorphTargetBufferSize = Defaults.MorphTargetBufferSize;
+    if (ResourceCI.VertexPoolSize == 0)
+        ResourceCI.VertexPoolSize = Defaults.VertexPoolSize;
+    if (ResourceCI.TextureAtlasSize == 0)
+        ResourceCI.TextureAtlasSize = Defaults.TextureAtlasSize;
+    if (ResourceCI.TextureAtlasMaxSlices == 0)
+        ResourceCI.TextureAtlasMaxSlices = Defaults.TextureAtlasMaxSlices;
+
+    constexpr Uint32 VertexPoolAlignment = 1024;
+    if (!RadientValidation::IsSumRepresentable<Uint32>(ResourceCI.VertexPoolSize, VertexPoolAlignment - 1u))
+    {
+        LOG_ERROR_MESSAGE("Radient resource manager VertexPoolSize (", ResourceCI.VertexPoolSize,
+                          ") cannot be rounded up to a multiple of ", VertexPoolAlignment, " without overflowing Uint32.");
+        return false;
+    }
+    ResourceCI.VertexPoolSize = AlignUp(ResourceCI.VertexPoolSize, VertexPoolAlignment);
+
+    constexpr Uint64 AtlasMipLevel0SizeAlignment = 64ull * 1024ull;
+    if (!RadientValidation::IsSumRepresentable<Uint64>(ResourceCI.TextureAtlasMipLevel0Size, AtlasMipLevel0SizeAlignment - 1u))
+    {
+        LOG_ERROR_MESSAGE("Radient resource manager TextureAtlasMipLevel0Size (", ResourceCI.TextureAtlasMipLevel0Size,
+                          ") cannot be rounded up to a multiple of ", AtlasMipLevel0SizeAlignment, " bytes without overflowing Uint64.");
+        return false;
+    }
+    ResourceCI.TextureAtlasMipLevel0Size = AlignUp(ResourceCI.TextureAtlasMipLevel0Size, AtlasMipLevel0SizeAlignment);
+
+    return true;
+}
+
 } // namespace
 
 RadientEngineImpl::RadientEngineImpl(IReferenceCounters* pRefCounters, const RadientEngineCreateInfo& CreateInfo) :
@@ -76,6 +113,7 @@ RadientEngineImpl::RadientEngineImpl(IReferenceCounters* pRefCounters, const Rad
 
     RadientAssetManagerImpl::CreateInfo AssetManagerCI{};
     AssetManagerCI.Assets      = CreateInfo.Assets;
+    AssetManagerCI.Resources   = CreateInfo.Resources;
     AssetManagerCI.pThreadPool = m_pThreadPool;
     AssetManagerCI.pDevice     = m_pBackend != nullptr ? m_pBackend->GetNativeDevice() : nullptr;
     m_pAssetManager            = RadientAssetManagerImpl::Create(AssetManagerCI);
@@ -234,7 +272,11 @@ RADIENT_STATUS DILIGENT_GLOBAL_FUNCTION(CreateRadientEngine)(const RadientEngine
     DEV_CHECK_ERR(*ppEngine == nullptr, "Output engine pointer must be null. Overwriting a non-null output pointer may result in memory leaks.");
     *ppEngine = nullptr;
 
-    RefCntAutoPtr<IRadientEngine> pEngine = RadientEngineImpl::Create(EngineCI);
+    RadientEngineCreateInfo NormalizedCI = EngineCI;
+    if (NormalizedCI.Backend.pDevice != nullptr && !NormalizeResourceManagerCreateInfo(NormalizedCI.Resources))
+        return RADIENT_STATUS_INVALID_ARGUMENT;
+
+    RefCntAutoPtr<IRadientEngine> pEngine = RadientEngineImpl::Create(NormalizedCI);
     *ppEngine                             = pEngine.Detach();
     return RADIENT_STATUS_OK;
 }

Tests/IncludeTest/Radient/RadientEngineH_test.c

@@ -62,9 +62,18 @@ void RadientEngine_C_TestMacros(IRadientEngine* pEngine)
 
 void RadientEngine_C_TestCreateFunction(void)
 {
-    RadientEngineCreateInfo EngineCI = {0};
-    IRadientEngine*         pEngine  = 0;
-    RADIENT_STATUS          Status   = Diligent_CreateRadientEngine(&EngineCI, &pEngine);
+    RadientEngineCreateInfo EngineCI             = {0};
+    EngineCI.Resources.IndexBufferSize           = 4u * 1024u * 1024u;
+    EngineCI.Resources.MaxIndexBufferSize        = 256ull * 1024ull * 1024ull;
+    EngineCI.Resources.MorphTargetBufferSize     = 1024u * 1024u;
+    EngineCI.Resources.MaxMorphTargetBufferSize  = 256ull * 1024ull * 1024ull;
+    EngineCI.Resources.VertexPoolSize            = 64u * 1024u;
+    EngineCI.Resources.TextureAtlasSize          = 2048;
+    EngineCI.Resources.TextureAtlasMipLevel0Size = 16ull * 1024ull * 1024ull;
+    EngineCI.Resources.TextureAtlasSlices        = 1;
+    EngineCI.Resources.TextureAtlasMaxSlices     = 2048;
+    IRadientEngine* pEngine                      = 0;
+    RADIENT_STATUS  Status                       = Diligent_CreateRadientEngine(&EngineCI, &pEngine);
 
     (void)pEngine;
     (void)Status;

Tests/IncludeTest/Radient/RadientEngineH_test.cpp

@@ -26,6 +26,16 @@
 
 #include "Radient/interface/RadientEngine.h"
 
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.IndexBufferSize == 4u * 1024u * 1024u, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.MaxIndexBufferSize == 256ull * 1024ull * 1024ull, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.MorphTargetBufferSize == 1024u * 1024u, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.MaxMorphTargetBufferSize == 256ull * 1024ull * 1024ull, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.VertexPoolSize == 64u * 1024u, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.TextureAtlasSize == 2048, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.TextureAtlasMipLevel0Size == 16ull * 1024ull * 1024ull, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.TextureAtlasSlices == 1, "Resource default changed");
+static_assert(Diligent::RadientEngineCreateInfo{}.Resources.TextureAtlasMaxSlices == 2048, "Resource default changed");
+
 void RadientEngine_CPP_UseAnimationRegistry(Diligent::IRadientEngine* pEngine,
                                             Diligent::IRadientScene*  pScene)
 {