Saving userdata to ogf

Author: yohjimane

src/Layers/xrRender/ModelPool.cpp

@@ -32,7 +32,6 @@
 #include "ModelNaming.h"
 
 #include <filesystem>
-#include <optional>
 #include <system_error>
 
 extern bool ENGINE_API g_bRendering;

src/Layers/xrRender/OzzKinematicsVisual.cpp

@@ -411,6 +411,9 @@ bool COzzKinematicsVisual::InitializeFromPayload(bool spawn_children)
         return false;
     }
 
+    if (!LoadUserDataFromBuffer(user_data_payload_) && !user_data_payload_.empty())
+        Msg("[OzzKinematicsVisual] Failed to initialize user data from bundle payload");
+
     if (!ApplyExtendedBoneMetadata(bone_metadata_))
         Msg("[OzzKinematicsVisual] Bone metadata application failed; falling back to defaults");
 
@@ -482,6 +485,7 @@ bool COzzKinematicsVisual::LoadFromBundle(const char* name, const std::filesyste
     mesh_payload_.assign(bundle.mesh.begin(), bundle.mesh.end());
     motion_references_ = bundle.motion_refs;
     bone_metadata_ = bundle.bone_metadata;
+    user_data_payload_.assign(bundle.user_data.begin(), bundle.user_data.end());
 
     meshes_.clear();
 
@@ -506,6 +510,7 @@ void COzzKinematicsVisual::Copy(dxRender_Visual* pFrom)
         meshes_ = other->meshes_;
         motion_references_ = other->motion_references_;
         bone_metadata_ = other->bone_metadata_;
+        user_data_payload_ = other->user_data_payload_;
 
         R_ASSERT2(InitializeFromPayload(), "Failed to copy OzzKinematicsVisual state");
     }
@@ -541,6 +546,7 @@ void COzzKinematicsVisual::Release()
     skeleton_payload_.clear();
     mesh_payload_.clear();
     motion_references_.clear();
+    user_data_payload_.clear();
     DestroySurfaces();
     children.clear();
     bone_palette_.clear();

src/Layers/xrRender/OzzKinematicsVisual.h

@@ -73,6 +73,7 @@ class COzzKinematicsVisual final : public FHierrarhyVisual, public OzzKinematics
 private:
     xr_vector<std::uint8_t> skeleton_payload_;
     xr_vector<std::uint8_t> mesh_payload_;
+    std::vector<std::uint8_t> user_data_payload_;
     xr_vector<ozz::sample::Mesh> meshes_;
     xr_vector<COzzSkinnedSurface*> surfaces_;
     xr_vector<Fmatrix> bone_palette_;

src/xrAnimation/LegacyOgfConverter.cpp

@@ -458,6 +458,7 @@ enum : uint32_t
     kChunkSwidata = OGF_SWIDATA,
     kChunkMotionRefs = OGF_S_MOTION_REFS,
     kChunkMotionRefs2 = OGF_S_MOTION_REFS2,
+    kChunkUserData = OGF_S_USERDATA,
 };
 
 } // namespace
@@ -2192,6 +2193,8 @@ void ConvertLegacyVisualToOzzBundleImpl(const LegacyVisualInput& input,
     const std::byte* data = input.buffer.data();
     const size_t size = input.buffer.size();
 
+    const auto chunks = ParseChunks(data, size);
+
     std::vector<BoneRecord> bones;
     const bool need_skeleton = options.build_skeleton || options.build_mesh;
 
@@ -2304,6 +2307,18 @@ void ConvertLegacyVisualToOzzBundleImpl(const LegacyVisualInput& input,
     out_result.motion_refs.reserve(motion_refs.size());
     for (const auto& ref : motion_refs)
         out_result.motion_refs.emplace_back(ref.c_str());
+
+    if (const auto user_data_it = chunks.find(kChunkUserData); user_data_it != chunks.end())
+    {
+        const Chunk& chunk = user_data_it->second;
+        out_result.user_data.resize(chunk.size);
+        if (chunk.size > 0)
+            std::memcpy(out_result.user_data.data(), chunk.data, chunk.size);
+    }
+    else
+    {
+        out_result.user_data.clear();
+    }
 }
 
 bool ConvertLegacyVisualToOzzBundle(const LegacyVisualInput& input,

src/xrAnimation/LegacyOgfConverter.h

@@ -52,6 +52,7 @@ struct LegacyVisualConversionResult
     std::vector<std::uint8_t> mesh_binary;
     size_t mesh_surface_count = 0;
     ExtendedBoneMetadataCollection bone_metadata;
+    std::vector<std::uint8_t> user_data;
 };
 
 bool ConvertLegacyVisualToOzzBundle(const LegacyVisualInput& input,

src/xrAnimation/OzzBundle.cpp

@@ -16,6 +16,7 @@ namespace
 constexpr char kOzzxMagic[8] = { 'O', 'Z', 'Z', 'X', 'P', 'A', 'C', 'K' };
 constexpr char kBoneMetadataMagic[4] = { 'B', 'M', 'D', 'T' };
 constexpr std::uint32_t kBoneMetadataVersion = 1u;
+constexpr char kUserDataMagic[4] = { 'U', 'D', 'T', 'A' };
 }
 
 static bool ReadFully(std::ifstream& stream, void* buffer, std::size_t size)
@@ -193,6 +194,59 @@ static bool WriteBoneMetadataBlock(std::ofstream& stream, const ExtendedBoneMeta
     return true;
 }
 
+static bool ReadUserDataBlock(std::ifstream& stream, std::vector<std::uint8_t>& out_user_data)
+{
+    const std::streampos checkpoint = stream.tellg();
+
+    char magic[sizeof(kUserDataMagic)] = {};
+    if (!ReadFully(stream, magic, sizeof(magic)))
+    {
+        stream.clear();
+        stream.seekg(checkpoint, std::ios::beg);
+        out_user_data.clear();
+        return true;
+    }
+
+    if (std::memcmp(magic, kUserDataMagic, sizeof(kUserDataMagic)) != 0)
+    {
+        stream.seekg(checkpoint, std::ios::beg);
+        out_user_data.clear();
+        return true;
+    }
+
+    std::uint32_t data_size = 0;
+    if (!ReadFully(stream, &data_size, sizeof(data_size)))
+        return false;
+
+    out_user_data.clear();
+    out_user_data.resize(data_size);
+    if (data_size > 0 && !ReadFully(stream, out_user_data.data(), data_size))
+        return false;
+
+    return true;
+}
+
+static bool WriteUserDataBlock(std::ofstream& stream, const std::vector<std::uint8_t>& user_data)
+{
+    if (user_data.size() > static_cast<std::size_t>(std::numeric_limits<std::uint32_t>::max()))
+    {
+        std::cerr << "User data payload too large for .ozzx bundle: " << user_data.size() << std::endl;
+        return false;
+    }
+
+    if (!WriteFully(stream, kUserDataMagic, sizeof(kUserDataMagic)))
+        return false;
+
+    const std::uint32_t data_size = static_cast<std::uint32_t>(user_data.size());
+    if (!WriteFully(stream, &data_size, sizeof(data_size)))
+        return false;
+
+    if (data_size > 0 && !WriteFully(stream, user_data.data(), user_data.size()))
+        return false;
+
+    return true;
+}
+
 bool ReadOzzxBundle(const std::filesystem::path& path, OzzxBundle& out_bundle)
 {
     std::ifstream stream(path, std::ios::binary);
@@ -249,6 +303,12 @@ bool ReadOzzxBundle(const std::filesystem::path& path, OzzxBundle& out_bundle)
         return false;
     }
 
+    if (!ReadUserDataBlock(stream, out_bundle.user_data))
+    {
+        std::cerr << "Failed to read user data block from: " << path << std::endl;
+        return false;
+    }
+
     out_bundle.motion_refs.clear();
 
     std::uint32_t motion_ref_count = 0;
@@ -352,6 +412,12 @@ bool WriteOzzxBundle(const std::filesystem::path& path, const OzzxBundle& bundle
         return false;
     }
 
+    if (!WriteUserDataBlock(stream, bundle.user_data))
+    {
+        std::cerr << "Failed to write user data block: " << path << std::endl;
+        return false;
+    }
+
     if (!WriteFully(stream, &motion_ref_count, sizeof(motion_ref_count)))
     {
         std::cerr << "Failed to write motion reference count: " << path << std::endl;

src/xrAnimation/OzzBundle.h

@@ -21,6 +21,7 @@ struct OzzxBundle
     std::vector<std::uint8_t> mesh;
     xr_vector<xr_string> motion_refs;
     ExtendedBoneMetadataCollection bone_metadata;
+    std::vector<std::uint8_t> user_data;
 };
 
 bool ReadOzzxBundle(const std::filesystem::path& path, OzzxBundle& out_bundle);

src/xrAnimation/OzzKinematics.cpp

@@ -445,6 +445,29 @@ bool OzzKinematics::InitializeFromOzzBuffer(ozz::span<const std::byte> skeletonD
     return true;
 }
 
+bool OzzKinematics::LoadUserDataFromBuffer(const std::vector<std::uint8_t>& buffer)
+{
+    userDataOwner.reset();
+    userData = nullptr;
+
+    if (buffer.empty())
+        return true;
+
+    IReader reader(const_cast<std::uint8_t*>(buffer.data()), buffer.size());
+
+    pcstr config_path = "";
+    if (FS.path_exist("$game_config$"))
+    {
+        const FS_Path* path = FS.get_path("$game_config$");
+        if (path)
+            config_path = path->m_Path;
+    }
+
+    userDataOwner = xr_make_unique<CInifile>(&reader, config_path);
+    userData = userDataOwner.get();
+    return userData != nullptr;
+}
+
 void OzzKinematics::NotImplemented(pcstr function_name) const
 {
     Msg("[OzzKinematics] %s is not implemented yet", function_name);
@@ -463,6 +486,7 @@ void OzzKinematics::ResetRuntimeState()
     sampledLocals.clear();
     modelTransforms.clear();
     samplingContext.Resize(0);
+    userDataOwner.reset();
     userData = nullptr;
     rootBone = BI_NONE;
     visibleMask = 0;

src/xrAnimation/OzzKinematics.h

@@ -12,6 +12,7 @@
 #include "OzzAnimationController.h"
 #include "ExtendedBoneMetadata.h"
 #include <filesystem>
+#include <vector>
 
 #include "ozz/animation/runtime/sampling_job.h"
 #include "ozz/animation/runtime/skeleton.h"
@@ -42,6 +43,7 @@ class OzzKinematics : public IKinematics, public IKinematicsAnimated
     bool InitializeFromOzz(pcstr skeletonPath, const xr_vector<xr_string>& motionRefs = xr_vector<xr_string>());
     bool InitializeFromOzzBuffer(ozz::span<const std::byte> skeletonData, const xr_vector<xr_string>& motionRefs = xr_vector<xr_string>());
     bool ApplyExtendedBoneMetadata(const ExtendedBoneMetadataCollection& metadata);
+    bool LoadUserDataFromBuffer(const std::vector<std::uint8_t>& buffer);
 
     // Pose management helpers.
     bool SetPoseLocals(ozz::span<const ozz::math::SoaTransform> locals);
@@ -224,6 +226,7 @@ class OzzKinematics : public IKinematics, public IKinematicsAnimated
 
 private:
     CInifile* userData;
+    xr_unique_ptr<CInifile> userDataOwner;
     accel boneMapByName;
     accel boneMapByPtr;
     xr_vector<CBoneInstance> boneInstances;

src/xrAnimation/StartupConversionInventory.cpp

@@ -350,6 +350,7 @@ bool WriteBundleFile(const StartupConversionParams& params,
     bundle.mesh = conversion.mesh_binary;
     bundle.motion_refs = conversion.motion_refs;
     bundle.bone_metadata = conversion.bone_metadata;
+    bundle.user_data = conversion.user_data;
 
     const std::string path_string = output_path.string();