Radient: move morph target streams to GPU-backed geometry data

- split transient morph sources from immutable layout metadata
- cache and upload morph streams as per-geometry data assets
- import glTF morph targets in each primitive's vertex domain
- expose morph buffer offsets to drawable geometry
- add source validation, caching, and GPU upload tests

Author: TheMostDiligent

Radient/CMakeLists.txt

@@ -18,6 +18,7 @@ set(SOURCE
     src/Assets/RadientMaterialAssetImplBase.hpp
     src/Assets/RadientMeshIndexSource.cpp
     src/Assets/RadientMeshAssetManager.cpp
+    src/Assets/RadientMorphTargetSource.cpp
     src/Assets/RadientMorphTargets.cpp
     src/Assets/RadientMeshPrimitives.cpp
     src/Assets/RadientMeshVertexSource.cpp
@@ -81,6 +82,7 @@ set(INCLUDE
     include/Assets/RadientMeshIndexSource.hpp
     include/Assets/RadientMeshAssetManager.hpp
     include/Assets/RadientMorphTargetData.hpp
+    include/Assets/RadientMorphTargetSource.hpp
     include/Assets/RadientMeshVertexSource.hpp
     include/Assets/RadientMeshViewSource.hpp
     include/Assets/RadientTextureAssetManager.hpp

Radient/include/Assets/RadientMeshAssetManager.hpp

@@ -26,7 +26,6 @@
 
 #pragma once
 
-#include "Assets/RadientMorphTargetData.hpp"
 #include "Render/RadientDrawableMesh.hpp"
 #include "RadientAssetCache.hpp"
 #include "RadientAssets.h"
@@ -48,8 +47,10 @@ class ResourceManager;
 
 class RadientMeshIndexSource;
 class RadientMeshVertexSource;
+class RadientMorphTargetSource;
 class MeshIndexDataPayloadImpl;
 class MeshVertexDataPayloadImpl;
+class MeshMorphTargetDataPayloadImpl;
 class MeshPayloadImpl;
 class RadientMeshAssetManager;
 struct RadientMeshViewCreateInfo;
@@ -68,11 +69,19 @@ class IRadientMeshVertexData : public IRadientAsset
 {
 };
 
+// Opaque handle to shared mesh morph-target data. The implementation details
+// are private to RadientMeshAssetManager.
+class IRadientMeshMorphTargetData : public IRadientAsset
+{
+};
+
 struct RadientMeshGeometryData
 {
-    /// Vertex and index data that together form one drawable geometry.
-    IRadientMeshVertexData* pVertexData = nullptr;
-    IRadientMeshIndexData*  pIndexData  = nullptr;
+    /// Vertex, index, and optional morph-target data that together form one
+    /// drawable geometry. Morph-target deltas use the vertex data's domain.
+    IRadientMeshVertexData*      pVertexData      = nullptr;
+    IRadientMeshIndexData*       pIndexData       = nullptr;
+    IRadientMeshMorphTargetData* pMorphTargetData = nullptr;
 };
 
 class RadientMeshAssetManager final : public std::enable_shared_from_this<RadientMeshAssetManager>
@@ -101,15 +110,18 @@ class RadientMeshAssetManager final : public std::enable_shared_from_this<Radien
                                         std::unique_ptr<RadientMeshVertexSource> pVertexSource,
                                         IRadientMeshVertexData**                 ppVertexData);
 
+    RADIENT_STATUS CreateMeshMorphTargetData(IThreadPool&                              ThreadPool,
+                                             std::unique_ptr<RadientMorphTargetSource> pMorphTargetSource,
+                                             IRadientMeshMorphTargetData**             ppMorphTargetData);
+
     // Creates a mesh handle and schedules mesh-view payload creation. When
     // vertex or index data is still loading, the view task depends on the
     // corresponding data tasks if they are still available.
-    RADIENT_STATUS CreateMeshView(IThreadPool&                            ThreadPool,
-                                  const RadientMeshGeometryData*          pGeometryData,
-                                  Uint32                                  GeometryCount,
-                                  const RadientMeshViewCreateInfo&        ViewCI,
-                                  IRadientMeshAsset**                     ppMesh,
-                                  std::unique_ptr<RadientMorphTargetData> pMorphTargetData = nullptr);
+    RADIENT_STATUS CreateMeshView(IThreadPool&                     ThreadPool,
+                                  const RadientMeshGeometryData*   pGeometryData,
+                                  Uint32                           GeometryCount,
+                                  const RadientMeshViewCreateInfo& ViewCI,
+                                  IRadientMeshAsset**              ppMesh);
 
     // Returns drawable mesh data when the mesh asset is ready. A pending status
     // means that any mesh dependency may still be unresolved: source/view
@@ -127,18 +139,19 @@ class RadientMeshAssetManager final : public std::enable_shared_from_this<Radien
     static RADIENT_STATUS GetLoadStatus(IRadientMeshIndexData* pMeshIndexData);
     // Reports CPU-side mesh data readiness for shared mesh vertex data handles.
     static RADIENT_STATUS GetLoadStatus(IRadientMeshVertexData* pMeshVertexData);
+    // Reports CPU-side mesh data readiness for shared morph-target data handles.
+    static RADIENT_STATUS GetLoadStatus(IRadientMeshMorphTargetData* pMorphTargetData);
 
     // Reports render-resource readiness. This follows GetLoadStatus(), then
     // checks geometry GPU resources and material/texture GPU resources.
-    static RADIENT_STATUS                   GetGPUResourceStatus(IRadientAsset* pMeshAsset);
-    static const MeshPayloadImpl*           GetMeshPayload(IRadientMeshAsset* pMeshAsset);
-    static Uint32                           GetMeshGeometryCount(IRadientMeshAsset* pMeshAsset);
-    static const MeshIndexDataPayloadImpl*  GetMeshIndexDataPayload(IRadientMeshAsset* pMeshAsset, Uint32 GeometryIndex);
-    static const MeshVertexDataPayloadImpl* GetMeshVertexDataPayload(IRadientMeshAsset* pMeshAsset, Uint32 GeometryIndex);
-    static const IRadientMeshIndexData*     GetMeshIndexData(IRadientMeshAsset* pMeshAsset);
-    static const IRadientMeshVertexData*    GetMeshVertexData(IRadientMeshAsset* pMeshAsset);
-    // Returns packed morph deltas for a ready mesh asset.
-    static const RadientMorphTargetData* GetMorphTargetData(IRadientMeshAsset* pMeshAsset);
+    static RADIENT_STATUS                        GetGPUResourceStatus(IRadientAsset* pMeshAsset);
+    static const MeshPayloadImpl*                GetMeshPayload(IRadientMeshAsset* pMeshAsset);
+    static Uint32                                GetMeshGeometryCount(IRadientMeshAsset* pMeshAsset);
+    static const MeshIndexDataPayloadImpl*       GetMeshIndexDataPayload(IRadientMeshAsset* pMeshAsset, Uint32 GeometryIndex);
+    static const MeshVertexDataPayloadImpl*      GetMeshVertexDataPayload(IRadientMeshAsset* pMeshAsset, Uint32 GeometryIndex);
+    static const MeshMorphTargetDataPayloadImpl* GetMeshMorphTargetDataPayload(IRadientMeshAsset* pMeshAsset, Uint32 GeometryIndex);
+    static const IRadientMeshIndexData*          GetMeshIndexData(IRadientMeshAsset* pMeshAsset);
+    static const IRadientMeshVertexData*         GetMeshVertexData(IRadientMeshAsset* pMeshAsset);
 
 private:
     explicit RadientMeshAssetManager(const CreateInfo& CI);
@@ -147,9 +160,10 @@ class RadientMeshAssetManager final : public std::enable_shared_from_this<Radien
     RefCntWeakPtr<GLTF::ResourceManager> m_WeakResourceManager;
     RefCntWeakPtr<IGPUUploadManager>     m_WeakUploadManager;
 
-    RadientAssetCache<MeshPayloadImpl>           m_MeshCache;
-    RadientAssetCache<MeshIndexDataPayloadImpl>  m_MeshIndexDataCache;
-    RadientAssetCache<MeshVertexDataPayloadImpl> m_MeshVertexDataCache;
+    RadientAssetCache<MeshPayloadImpl>                m_MeshCache;
+    RadientAssetCache<MeshIndexDataPayloadImpl>       m_MeshIndexDataCache;
+    RadientAssetCache<MeshVertexDataPayloadImpl>      m_MeshVertexDataCache;
+    RadientAssetCache<MeshMorphTargetDataPayloadImpl> m_MeshMorphTargetDataCache;
 };
 
 } // namespace Diligent

Radient/include/Assets/RadientMorphTargetData.hpp

@@ -34,13 +34,13 @@
 namespace Diligent
 {
 
-/// Packed immutable morph-target data copied from RadientMeshCreateInfo.
+class RadientMorphTargetSource;
+
+/// Packed immutable morph-target metadata stored in a mesh-data payload.
 class RadientMorphTargetData final
 {
 public:
-    RadientMorphTargetData(const RadientMorphTargetCreateInfo* pTargets,
-                           Uint32                              TargetCount,
-                           Uint32                              VertexCount);
+    explicit RadientMorphTargetData(const RadientMorphTargetSource& Source);
 
     RadientMorphTargetData(const RadientMorphTargetData&)            = delete;
     RadientMorphTargetData& operator=(const RadientMorphTargetData&) = delete;
@@ -50,21 +50,34 @@ class RadientMorphTargetData final
         return m_Desc;
     }
 
-    /// Returns the copied delta stream for one target attribute.
-    const Float32* GetDeltas(Uint32 TargetIndex, Uint32 AttributeIndex) const noexcept;
+    Uint32 GetVertexCount() const noexcept
+    {
+        return m_VertexCount;
+    }
+
+    Uint32 GetDataSize() const noexcept
+    {
+        return m_DataSize;
+    }
+
+    /// Returns the byte offset of one attribute stream in the GPU allocation.
+    Uint32 GetAttributeDataOffset(Uint32 TargetIndex, Uint32 AttributeIndex) const noexcept;
 
 private:
-    struct AttributeData
+    struct AttributeLayout
     {
-        const Float32* pDeltas = nullptr;
+        Uint32 DataOffset = 0;
     };
 
     using PackedMemory = std::unique_ptr<void, STDDeleterRawMem<void>>;
 
     PackedMemory                           m_Memory;
     RadientMeshAssetDesc                   m_Desc;
-    const RadientMorphTargetAttributeDesc* m_pAttributes    = nullptr;
-    const AttributeData*                   m_pAttributeData = nullptr;
+    const RadientMorphTargetAttributeDesc* m_pAttributes       = nullptr;
+    const AttributeLayout*                 m_pAttributeLayouts = nullptr;
+
+    Uint32 m_VertexCount = 0;
+    Uint32 m_DataSize    = 0;
 };
 
 RADIENT_STATUS CreateRadientMorphTargetWeights(IRadientMeshAsset*           pMesh,

Radient/include/Assets/RadientMorphTargetSource.hpp

@@ -0,0 +1,109 @@
+/*
+ *  Copyright 2026 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 "RadientMorphTargets.h"
+
+#include <string>
+#include <vector>
+
+namespace Diligent
+{
+
+/// Owns CPU-side morph-target source data that is packed into a GPU buffer.
+class RadientMorphTargetSource final
+{
+public:
+    struct Attribute
+    {
+        std::string Semantic;
+        Uint32      ComponentCount = 0;
+        Uint32      DataOffset     = 0;
+    };
+
+    struct Target
+    {
+        std::string            Name;
+        Float32                DefaultWeight = 0;
+        std::vector<Attribute> Attributes;
+    };
+
+    struct PackDestination
+    {
+        void*  pData    = nullptr;
+        Uint32 DataSize = 0;
+    };
+
+    RadientMorphTargetSource(const RadientMorphTargetCreateInfo* pTargets,
+                             Uint32                              TargetCount,
+                             Uint32                              VertexCount);
+
+    // clang-format off
+    RadientMorphTargetSource(const RadientMorphTargetSource&)            = delete;
+    RadientMorphTargetSource(RadientMorphTargetSource&&)                 = delete;
+    RadientMorphTargetSource& operator=(const RadientMorphTargetSource&) = delete;
+    RadientMorphTargetSource& operator=(RadientMorphTargetSource&&)      = delete;
+    // clang-format on
+
+    RADIENT_STATUS GetStatus() const noexcept
+    {
+        return m_Status;
+    }
+
+    Uint32 GetVertexCount() const noexcept
+    {
+        return m_VertexCount;
+    }
+
+    Uint32 GetTargetCount() const noexcept
+    {
+        return static_cast<Uint32>(m_Targets.size());
+    }
+
+    const Target& GetTarget(Uint32 TargetIndex) const noexcept
+    {
+        return m_Targets[TargetIndex];
+    }
+
+    Uint32 GetDataSize() const noexcept
+    {
+        return static_cast<Uint32>(m_Deltas.size() * sizeof(Float32));
+    }
+
+    /// Returns a key for the packed morph-target description and GPU data.
+    std::string MakeCacheKey() const;
+
+    RADIENT_STATUS PackData(PackDestination Destination) const noexcept;
+
+private:
+    RADIENT_STATUS       m_Status      = RADIENT_STATUS_INVALID_ARGUMENT;
+    Uint32               m_VertexCount = 0;
+    std::vector<Target>  m_Targets;
+    std::vector<Float32> m_Deltas;
+};
+
+} // namespace Diligent

Radient/include/Render/RadientDrawableMesh.hpp

@@ -35,6 +35,7 @@
 namespace Diligent
 {
 
+class RadientMorphTargetData;
 struct IRadientMaterialAsset;
 
 struct RadientDrawableMeshPrimitive
@@ -53,10 +54,18 @@ struct RadientDrawableMeshGeometry
 {
     IVertexPool* pVertexPool = nullptr;
 
+    /// Immutable layout of this geometry's morph-target streams, or null when
+    /// the geometry has no morph targets.
+    const RadientMorphTargetData* pMorphTargetData = nullptr;
+
     PBR_Renderer::PSO_FLAGS VertexAttribFlags = PBR_Renderer::PSO_FLAG_NONE;
 
     Uint32 FirstIndexLocation = 0;
     Uint32 BaseVertex         = 0;
+
+    /// Byte offset of the geometry's packed deltas in the shared morph-target
+    /// buffer. Valid when pMorphTargetData is non-null and contains GPU data.
+    Uint32 MorphTargetDataOffset = 0;
 };
 
 /// Resolved mesh data needed to expand one scene renderable into drawable primitive slots.

Radient/interface/RadientAssets.h

@@ -518,8 +518,9 @@ DILIGENT_END_INTERFACE
 /// Immutable mesh asset and its morph-target schema.
 DILIGENT_BEGIN_INTERFACE(IRadientMeshAsset, IRadientAsset)
 {
-    /// Returns the immutable mesh description. The returned reference and all
-    /// data it references remain valid while the mesh asset is retained.
+    /// Returns the immutable mesh description. The description is empty until
+    /// mesh loading completes successfully. The returned reference and all data
+    /// it references remain valid while the mesh asset is retained.
     VIRTUAL const RadientMeshAssetDesc REF METHOD(GetDesc)(THIS) CONST PURE;
 
     /// Creates mutable weights initialized to the mesh morph-target defaults.

Radient/interface/RadientMorphTargets.h

@@ -67,8 +67,9 @@ struct RadientMorphTargetAttributeCreateInfo
 {
     /// Tightly packed canonical floating-point deltas. The array contains
     /// RadientMeshCreateInfo::VertexCount times the corresponding attribute
-    /// description's ComponentCount values. Radient copies the data during
-    /// mesh creation.
+    /// description's ComponentCount values. Radient copies the data into
+    /// transient upload storage during mesh creation and does not retain the
+    /// deltas in CPU memory after the upload has been scheduled.
     const Float32* pDeltas DEFAULT_INITIALIZER(nullptr);
 };
 typedef struct RadientMorphTargetAttributeCreateInfo RadientMorphTargetAttributeCreateInfo;
@@ -100,8 +101,9 @@ typedef struct RadientMorphTargetDesc RadientMorphTargetDesc;
 
 /// Morph-target creation attributes.
 ///
-/// Radient copies Desc, all metadata it references, and the attribute creation
-/// data during mesh creation.
+/// Radient retains a copy of Desc and all metadata it references. Attribute
+/// creation data is copied only into transient upload storage and is not kept
+/// in CPU memory after the GPU upload has been scheduled.
 struct RadientMorphTargetCreateInfo
 {
     /// Complete immutable description of the target to create.

Radient/src/Assets/RadientAssetManagerImpl.cpp

@@ -55,12 +55,14 @@ namespace Diligent
 namespace
 {
 
-constexpr Uint64 RadientDefaultIndexBufferSize       = 16ull * 1024ull * 1024ull;
-constexpr Uint64 RadientDefaultMaxIndexBufferSize    = 256ull * 1024ull * 1024ull;
-constexpr Uint32 RadientDefaultVertexPoolSize        = 1024u * 1024u;
-constexpr Uint32 RadientDefaultTextureAtlasSize      = 2048u;
-constexpr Uint32 RadientDefaultTextureAtlasSlices    = 1u;
-constexpr Uint32 RadientDefaultTextureAtlasMaxSlices = 2048u;
+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 Uint32 RadientDefaultTextureAtlasSlices       = 1u;
+constexpr Uint32 RadientDefaultTextureAtlasMaxSlices    = 2048u;
 
 static constexpr INTERFACE_ID IID_SceneAssetImpl = {0xb59806f1, 0xa08a, 0x4dff, {0xb0, 0x37, 0x84, 0x75, 0xd6, 0xfd, 0x7f, 0x1b}};
 
@@ -207,6 +209,15 @@ GLTF::ResourceManager::CreateInfo CreateResourceManagerInfo()
     CreateInfo.IndexAllocatorCI.ExpansionSize  = static_cast<Uint32>(RadientDefaultIndexBufferSize);
     CreateInfo.IndexAllocatorCI.MaxSize        = RadientDefaultMaxIndexBufferSize;
 
+    CreateInfo.MorphTargetAllocatorCI.Desc.Name              = "Radient morph target buffer";
+    CreateInfo.MorphTargetAllocatorCI.Desc.Size              = RadientDefaultMorphTargetBufferSize;
+    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.DefaultPoolDesc.Name        = "Radient vertex pool";
     CreateInfo.DefaultPoolDesc.VertexCount = RadientDefaultVertexPoolSize;
     CreateInfo.DefaultPoolDesc.Usage       = USAGE_DEFAULT;