From e9c66a2e28b99acb8cb6ae948d342899ef869217 Mon Sep 17 00:00:00 2001 From: Jan Date: Mon, 9 Sep 2024 23:46:55 +0200 Subject: [PATCH] chore: move xmodel dumping and loading code into generic files --- .../T6/AssetLoaders/AssetLoaderXModel.cpp | 4 +- .../Game/T6/XModel/JsonXModelLoader.h | 13 - .../Game/T6/XModel/XModelLoaderT6.cpp | 51 ++ .../Game/T6/XModel/XModelLoaderT6.h | 13 + .../GenericXModelLoader.inc.h} | 71 +- .../T6/AssetDumpers/AssetDumperXModel.cpp | 594 +-------------- .../Game/T6/XModel/JsonXModelWriter.cpp | 102 --- .../Game/T6/XModel/JsonXModelWriter.h | 11 - .../Game/T6/XModel/XModelDumperT6.cpp | 17 + .../Game/T6/XModel/XModelDumperT6.h | 9 + .../XModel/GenericXModelDumper.inc.h | 675 ++++++++++++++++++ 11 files changed, 781 insertions(+), 779 deletions(-) delete mode 100644 src/ObjLoading/Game/T6/XModel/JsonXModelLoader.h create mode 100644 src/ObjLoading/Game/T6/XModel/XModelLoaderT6.cpp create mode 100644 src/ObjLoading/Game/T6/XModel/XModelLoaderT6.h rename src/ObjLoading/{Game/T6/XModel/JsonXModelLoader.cpp => XModel/GenericXModelLoader.inc.h} (95%) delete mode 100644 src/ObjWriting/Game/T6/XModel/JsonXModelWriter.cpp delete mode 100644 src/ObjWriting/Game/T6/XModel/JsonXModelWriter.h create mode 100644 src/ObjWriting/Game/T6/XModel/XModelDumperT6.cpp create mode 100644 src/ObjWriting/Game/T6/XModel/XModelDumperT6.h create mode 100644 src/ObjWriting/XModel/GenericXModelDumper.inc.h diff --git a/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderXModel.cpp b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderXModel.cpp index 8509d2d3..2c1ff6f1 100644 --- a/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderXModel.cpp +++ b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderXModel.cpp @@ -1,7 +1,7 @@ #include "AssetLoaderXModel.h" #include "Game/T6/T6.h" -#include "Game/T6/XModel/JsonXModelLoader.h" +#include "Game/T6/XModel/XModelLoaderT6.h" #include "Pool/GlobalAssetPool.h" #include @@ -33,7 +33,7 @@ bool AssetLoaderXModel::LoadFromRaw( xmodel->name = memory->Dup(assetName.c_str()); std::vector dependencies; - if (LoadXModelAsJson(*file.m_stream, *xmodel, memory, manager, dependencies)) + if (LoadXModel(*file.m_stream, *xmodel, memory, manager, dependencies)) manager->AddAsset(assetName, xmodel, std::move(dependencies)); else std::cerr << std::format("Failed to load xmodel \"{}\"\n", assetName); diff --git a/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.h b/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.h deleted file mode 100644 index d7747287..00000000 --- a/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.h +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -#include "AssetLoading/IAssetLoadingManager.h" -#include "Game/T6/T6.h" -#include "Utils/MemoryManager.h" - -#include - -namespace T6 -{ - bool LoadXModelAsJson( - std::istream& stream, XModel& xmodel, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies); -} // namespace T6 diff --git a/src/ObjLoading/Game/T6/XModel/XModelLoaderT6.cpp b/src/ObjLoading/Game/T6/XModel/XModelLoaderT6.cpp new file mode 100644 index 00000000..32e830a9 --- /dev/null +++ b/src/ObjLoading/Game/T6/XModel/XModelLoaderT6.cpp @@ -0,0 +1,51 @@ +#include "XModelLoaderT6.h" + +#include "Game/T6/CommonT6.h" +#include "Game/T6/Json/JsonXModel.h" + +#define GAME_NAMESPACE T6 + +namespace T6 +{ + const char* HITLOC_NAMES[]{ + // clang-format off + "none", + "helmet", + "head", + "neck", + "torso_upper", + "torso_middle", + "torso_lower", + "right_arm_upper", + "left_arm_upper", + "right_arm_lower", + "left_arm_lower", + "right_hand", + "left_hand", + "right_leg_upper", + "left_leg_upper", + "right_leg_lower", + "left_leg_lower", + "right_foot", + "left_foot", + "gun", + "shield", + // clang-format on + }; + static_assert(std::extent_v == HITLOC_COUNT); +} // namespace T6 + +#include "XModel/GenericXModelLoader.inc.h" + +namespace T6 +{ + bool LoadXModel(std::istream& stream, XModel& xmodel, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies) + { + std::set dependenciesSet; + XModelLoader loader(stream, *memory, *manager, dependenciesSet); + + dependencies.assign(dependenciesSet.cbegin(), dependenciesSet.cend()); + + return loader.Load(xmodel); + } +} // namespace T6 diff --git a/src/ObjLoading/Game/T6/XModel/XModelLoaderT6.h b/src/ObjLoading/Game/T6/XModel/XModelLoaderT6.h new file mode 100644 index 00000000..e55883e5 --- /dev/null +++ b/src/ObjLoading/Game/T6/XModel/XModelLoaderT6.h @@ -0,0 +1,13 @@ +#pragma once + +#include "AssetLoading/IAssetLoadingManager.h" +#include "Game/T6/T6.h" +#include "Utils/MemoryManager.h" + +#include +#include + +namespace T6 +{ + bool LoadXModel(std::istream& stream, XModel& xmodel, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies); +} diff --git a/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp b/src/ObjLoading/XModel/GenericXModelLoader.inc.h similarity index 95% rename from src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp rename to src/ObjLoading/XModel/GenericXModelLoader.inc.h index 8b3f6e9b..74ac5fd0 100644 --- a/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp +++ b/src/ObjLoading/XModel/GenericXModelLoader.inc.h @@ -1,8 +1,9 @@ -#include "JsonXModelLoader.h" +#pragma once + +#ifndef GAME_NAMESPACE +#error Must define GAME_NAMESPACE +#endif -#include "Csv/CsvStream.h" -#include "Game/T6/CommonT6.h" -#include "Game/T6/Json/JsonXModel.h" #include "ObjLoading.h" #include "Utils/QuatInt16.h" #include "Utils/StringUtils.h" @@ -13,6 +14,7 @@ #pragma warning(push, 0) #include +#include #pragma warning(pop) #include "XModel/PartClassificationState.h" @@ -23,48 +25,15 @@ #include #include #include -#include #include #include -using namespace nlohmann; -using namespace T6; - -namespace fs = std::filesystem; - -namespace +namespace GAME_NAMESPACE { - const char* HITLOC_NAMES[]{ - // clang-format off - "none", - "helmet", - "head", - "neck", - "torso_upper", - "torso_middle", - "torso_lower", - "right_arm_upper", - "left_arm_upper", - "right_arm_lower", - "left_arm_lower", - "right_hand", - "left_hand", - "right_leg_upper", - "left_leg_upper", - "right_leg_lower", - "left_leg_lower", - "right_foot", - "left_foot", - "gun", - "shield", - // clang-format on - }; - static_assert(std::extent_v == HITLOC_COUNT); - - class JsonLoader + class XModelLoader { public: - JsonLoader(std::istream& stream, MemoryManager& memory, IAssetLoadingManager& manager, std::set& dependencies) + XModelLoader(std::istream& stream, MemoryManager& memory, IAssetLoadingManager& manager, std::set& dependencies) : m_stream(stream), m_memory(memory), m_script_strings(manager.GetAssetLoadingContext()->m_zone->m_script_strings), @@ -77,7 +46,7 @@ namespace bool Load(XModel& xmodel) { - const auto jRoot = json::parse(m_stream); + const auto jRoot = nlohmann::json::parse(m_stream); std::string type; unsigned version; @@ -95,7 +64,7 @@ namespace const auto jXModel = jRoot.get(); return CreateXModelFromJson(jXModel, xmodel); } - catch (const json::exception& e) + catch (const nlohmann::json::exception& e) { std::cerr << std::format("Failed to parse json of xmodel: {}\n", e.what()); } @@ -616,7 +585,7 @@ namespace return false; } - auto extension = fs::path(jLod.file).extension().string(); + auto extension = std::filesystem::path(jLod.file).extension().string(); utils::MakeStringLowerCase(extension); const auto common = LoadModelByExtension(*file.m_stream, extension); @@ -822,18 +791,4 @@ namespace PartClassificationState& m_part_classification_state; std::set& m_dependencies; }; -} // namespace - -namespace T6 -{ - bool LoadXModelAsJson( - std::istream& stream, XModel& xmodel, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies) - { - std::set dependenciesSet; - JsonLoader loader(stream, *memory, *manager, dependenciesSet); - - dependencies.assign(dependenciesSet.cbegin(), dependenciesSet.cend()); - - return loader.Load(xmodel); - } -} // namespace T6 +} // namespace GAME_NAMESPACE diff --git a/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp index d5add6b3..24dc56dc 100644 --- a/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp +++ b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp @@ -1,600 +1,9 @@ #include "AssetDumperXModel.h" -#include "Game/T6/CommonT6.h" -#include "Game/T6/XModel/JsonXModelWriter.h" -#include "ObjWriting.h" -#include "Utils/DistinctMapper.h" -#include "Utils/QuatInt16.h" -#include "XModel/Export/XModelExportWriter.h" -#include "XModel/Gltf/GltfBinOutput.h" -#include "XModel/Gltf/GltfTextOutput.h" -#include "XModel/Gltf/GltfWriter.h" -#include "XModel/Obj/ObjWriter.h" -#include "XModel/XModelWriter.h" - -#include -#include +#include "Game/T6/XModel/XModelDumperT6.h" using namespace T6; -namespace -{ - std::string GetFileNameForLod(const std::string& modelName, const unsigned lod, const std::string& extension) - { - return std::format("model_export/{}_lod{}{}", modelName, lod, extension); - } - - GfxImage* GetMaterialColorMap(const Material* material) - { - std::vector potentialTextureDefs; - - for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) - { - MaterialTextureDef* def = &material->textureTable[textureIndex]; - - if (def->semantic == TS_COLOR_MAP || def->semantic >= TS_COLOR0_MAP && def->semantic <= TS_COLOR15_MAP) - potentialTextureDefs.push_back(def); - } - - if (potentialTextureDefs.empty()) - return nullptr; - if (potentialTextureDefs.size() == 1) - return potentialTextureDefs[0]->image; - - for (const auto* def : potentialTextureDefs) - { - if (tolower(def->nameStart) == 'c' && tolower(def->nameEnd) == 'p') - return def->image; - } - - for (const auto* def : potentialTextureDefs) - { - if (tolower(def->nameStart) == 'r' && tolower(def->nameEnd) == 'k') - return def->image; - } - - for (const auto* def : potentialTextureDefs) - { - if (tolower(def->nameStart) == 'd' && tolower(def->nameEnd) == 'p') - return def->image; - } - - return potentialTextureDefs[0]->image; - } - - GfxImage* GetMaterialNormalMap(const Material* material) - { - std::vector potentialTextureDefs; - - for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) - { - MaterialTextureDef* def = &material->textureTable[textureIndex]; - - if (def->semantic == TS_NORMAL_MAP) - potentialTextureDefs.push_back(def); - } - - if (potentialTextureDefs.empty()) - return nullptr; - if (potentialTextureDefs.size() == 1) - return potentialTextureDefs[0]->image; - - for (const auto* def : potentialTextureDefs) - { - if (def->nameStart == 'n' && def->nameEnd == 'p') - return def->image; - } - - return potentialTextureDefs[0]->image; - } - - GfxImage* GetMaterialSpecularMap(const Material* material) - { - std::vector potentialTextureDefs; - - for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) - { - MaterialTextureDef* def = &material->textureTable[textureIndex]; - - if (def->semantic == TS_SPECULAR_MAP) - potentialTextureDefs.push_back(def); - } - - if (potentialTextureDefs.empty()) - return nullptr; - if (potentialTextureDefs.size() == 1) - return potentialTextureDefs[0]->image; - - for (const auto* def : potentialTextureDefs) - { - if (def->nameStart == 's' && def->nameEnd == 'p') - return def->image; - } - - return potentialTextureDefs[0]->image; - } - - bool HasDefaultArmature(const XModel* model, const unsigned lod) - { - if (model->numRootBones != 1 || model->numBones != 1) - return false; - - const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; - const auto surfCount = model->lodInfo[lod].numsurfs; - - if (!surfs) - return true; - - for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) - { - const auto& surface = surfs[surfIndex]; - - if (surface.vertListCount != 1 || surface.vertInfo.vertsBlend) - return false; - - const auto& vertList = surface.vertList[0]; - if (vertList.boneOffset != 0 || vertList.triOffset != 0 || vertList.triCount != surface.triCount || vertList.vertCount != surface.vertCount) - return false; - } - - return true; - } - - void OmitDefaultArmature(XModelCommon& common) - { - common.m_bones.clear(); - common.m_bone_weight_data.weights.clear(); - common.m_vertex_bone_weights.resize(common.m_vertices.size()); - for (auto& vertexWeights : common.m_vertex_bone_weights) - { - vertexWeights.weightOffset = 0u; - vertexWeights.weightCount = 0u; - } - } - - void AddXModelBones(XModelCommon& out, const AssetDumpingContext& context, const XModel* model) - { - for (auto boneNum = 0u; boneNum < model->numBones; boneNum++) - { - XModelBone bone; - if (model->boneNames[boneNum] < context.m_zone->m_script_strings.Count()) - bone.name = context.m_zone->m_script_strings[model->boneNames[boneNum]]; - else - bone.name = "INVALID_BONE_NAME"; - - if (boneNum >= model->numRootBones) - bone.parentIndex = static_cast(boneNum - static_cast(model->parentList[boneNum - model->numRootBones])); - else - bone.parentIndex = std::nullopt; - - bone.scale[0] = 1.0f; - bone.scale[1] = 1.0f; - bone.scale[2] = 1.0f; - - const auto& baseMat = model->baseMat[boneNum]; - bone.globalOffset[0] = baseMat.trans.x; - bone.globalOffset[1] = baseMat.trans.y; - bone.globalOffset[2] = baseMat.trans.z; - bone.globalRotation = { - baseMat.quat.x, - baseMat.quat.y, - baseMat.quat.z, - baseMat.quat.w, - }; - - if (boneNum < model->numRootBones) - { - bone.localOffset[0] = 0; - bone.localOffset[1] = 0; - bone.localOffset[2] = 0; - bone.localRotation = {0, 0, 0, 1}; - } - else - { - const auto* trans = &model->trans[(boneNum - model->numRootBones) * 3]; - bone.localOffset[0] = trans[0]; - bone.localOffset[1] = trans[1]; - bone.localOffset[2] = trans[2]; - - const auto& quat = model->quats[boneNum - model->numRootBones]; - bone.localRotation = { - QuatInt16::ToFloat(quat.v[0]), - QuatInt16::ToFloat(quat.v[1]), - QuatInt16::ToFloat(quat.v[2]), - QuatInt16::ToFloat(quat.v[3]), - }; - } - - out.m_bones.emplace_back(std::move(bone)); - } - } - - const char* AssetName(const char* input) - { - if (input && input[0] == ',') - return &input[1]; - - return input; - } - - void AddXModelMaterials(XModelCommon& out, DistinctMapper& materialMapper, const XModel* model) - { - for (auto surfaceMaterialNum = 0; surfaceMaterialNum < model->numsurfs; surfaceMaterialNum++) - { - Material* material = model->materialHandles[surfaceMaterialNum]; - if (materialMapper.Add(material)) - { - XModelMaterial xMaterial; - xMaterial.ApplyDefaults(); - - xMaterial.name = AssetName(material->info.name); - const auto* colorMap = GetMaterialColorMap(material); - if (colorMap) - xMaterial.colorMapName = AssetName(colorMap->name); - - const auto* normalMap = GetMaterialNormalMap(material); - if (normalMap) - xMaterial.normalMapName = AssetName(normalMap->name); - - const auto* specularMap = GetMaterialSpecularMap(material); - if (specularMap) - xMaterial.specularMapName = AssetName(specularMap->name); - - out.m_materials.emplace_back(std::move(xMaterial)); - } - } - } - - void AddXModelObjects(XModelCommon& out, const XModel* model, const unsigned lod, const DistinctMapper& materialMapper) - { - const auto surfCount = model->lodInfo[lod].numsurfs; - const auto baseSurfaceIndex = model->lodInfo[lod].surfIndex; - - for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) - { - XModelObject object; - object.name = std::format("surf{}", surfIndex); - object.materialIndex = static_cast(materialMapper.GetDistinctPositionByInputPosition(surfIndex + baseSurfaceIndex)); - - out.m_objects.emplace_back(std::move(object)); - } - } - - void AddXModelVertices(XModelCommon& out, const XModel* model, const unsigned lod) - { - const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; - const auto surfCount = model->lodInfo[lod].numsurfs; - - if (!surfs) - return; - - for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) - { - const auto& surface = surfs[surfIndex]; - - for (auto vertexIndex = 0u; vertexIndex < surface.vertCount; vertexIndex++) - { - const auto& v = surface.verts0[vertexIndex]; - - XModelVertex vertex{}; - vertex.coordinates[0] = v.xyz.x; - vertex.coordinates[1] = v.xyz.y; - vertex.coordinates[2] = v.xyz.z; - Common::Vec3UnpackUnitVec(v.normal, vertex.normal); - Common::Vec4UnpackGfxColor(v.color, vertex.color); - Common::Vec2UnpackTexCoords(v.texCoord, vertex.uv); - - out.m_vertices.emplace_back(vertex); - } - } - } - - void AllocateXModelBoneWeights(const XModel* model, const unsigned lod, XModelVertexBoneWeightCollection& weightCollection) - { - const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; - const auto surfCount = model->lodInfo[lod].numsurfs; - - if (!surfs) - return; - - auto totalWeightCount = 0u; - for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) - { - const auto& surface = surfs[surfIndex]; - - if (surface.vertList) - { - totalWeightCount += surface.vertListCount; - } - - if (surface.vertInfo.vertsBlend) - { - totalWeightCount += surface.vertInfo.vertCount[0] * 1; - totalWeightCount += surface.vertInfo.vertCount[1] * 2; - totalWeightCount += surface.vertInfo.vertCount[2] * 3; - totalWeightCount += surface.vertInfo.vertCount[3] * 4; - } - } - - weightCollection.weights.resize(totalWeightCount); - } - - float BoneWeight16(const uint16_t value) - { - return static_cast(value) / static_cast(std::numeric_limits::max()); - } - - void AddXModelVertexBoneWeights(XModelCommon& out, const XModel* model, const unsigned lod) - { - const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; - const auto surfCount = model->lodInfo[lod].numsurfs; - auto& weightCollection = out.m_bone_weight_data; - - if (!surfs) - return; - - size_t weightOffset = 0u; - - for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) - { - const auto& surface = surfs[surfIndex]; - auto handledVertices = 0u; - - if (surface.vertList) - { - for (auto vertListIndex = 0u; vertListIndex < surface.vertListCount; vertListIndex++) - { - const auto& vertList = surface.vertList[vertListIndex]; - const auto boneWeightOffset = weightOffset; - - weightCollection.weights[weightOffset++] = XModelBoneWeight{vertList.boneOffset / sizeof(DObjSkelMat), 1.0f}; - - for (auto vertListVertexOffset = 0u; vertListVertexOffset < vertList.vertCount; vertListVertexOffset++) - { - out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 1); - } - handledVertices += vertList.vertCount; - } - } - - auto vertsBlendOffset = 0u; - if (surface.vertInfo.vertsBlend) - { - // 1 bone weight - for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[0]; vertIndex++) - { - const auto boneWeightOffset = weightOffset; - const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, 1.0f}; - - vertsBlendOffset += 1; - - out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 1); - } - - // 2 bone weights - for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[1]; vertIndex++) - { - const auto boneWeightOffset = weightOffset; - const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); - const auto boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat); - const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]); - const auto boneWeight0 = 1.0f - boneWeight1; - - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, boneWeight0}; - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex1, boneWeight1}; - - vertsBlendOffset += 3; - - out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 2); - } - - // 3 bone weights - for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[2]; vertIndex++) - { - const auto boneWeightOffset = weightOffset; - const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); - const auto boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat); - const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]); - const auto boneIndex2 = surface.vertInfo.vertsBlend[vertsBlendOffset + 3] / sizeof(DObjSkelMat); - const auto boneWeight2 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 4]); - const auto boneWeight0 = 1.0f - boneWeight1 - boneWeight2; - - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, boneWeight0}; - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex1, boneWeight1}; - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex2, boneWeight2}; - - vertsBlendOffset += 5; - - out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 3); - } - - // 4 bone weights - for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[3]; vertIndex++) - { - const auto boneWeightOffset = weightOffset; - const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); - const auto boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat); - const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]); - const auto boneIndex2 = surface.vertInfo.vertsBlend[vertsBlendOffset + 3] / sizeof(DObjSkelMat); - const auto boneWeight2 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 4]); - const auto boneIndex3 = surface.vertInfo.vertsBlend[vertsBlendOffset + 5] / sizeof(DObjSkelMat); - const auto boneWeight3 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 6]); - const auto boneWeight0 = 1.0f - boneWeight1 - boneWeight2 - boneWeight3; - - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, boneWeight0}; - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex1, boneWeight1}; - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex2, boneWeight2}; - weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex3, boneWeight3}; - - vertsBlendOffset += 7; - - out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 4); - } - - handledVertices += - surface.vertInfo.vertCount[0] + surface.vertInfo.vertCount[1] + surface.vertInfo.vertCount[2] + surface.vertInfo.vertCount[3]; - } - - for (; handledVertices < surface.vertCount; handledVertices++) - { - out.m_vertex_bone_weights.emplace_back(0, 0); - } - } - } - - void AddXModelFaces(XModelCommon& out, const XModel* model, const unsigned lod) - { - const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; - const auto surfCount = model->lodInfo[lod].numsurfs; - - if (!surfs) - return; - - for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) - { - const auto& surface = surfs[surfIndex]; - auto& object = out.m_objects[surfIndex]; - object.m_faces.reserve(surface.triCount); - - for (auto triIndex = 0u; triIndex < surface.triCount; triIndex++) - { - const auto& tri = surface.triIndices[triIndex]; - - XModelFace face{}; - face.vertexIndex[0] = tri.i[0] + surface.baseVertIndex; - face.vertexIndex[1] = tri.i[1] + surface.baseVertIndex; - face.vertexIndex[2] = tri.i[2] + surface.baseVertIndex; - object.m_faces.emplace_back(face); - } - } - } - - void PopulateXModelWriter(XModelCommon& out, const AssetDumpingContext& context, const unsigned lod, const XModel* model) - { - DistinctMapper materialMapper(model->numsurfs); - AllocateXModelBoneWeights(model, lod, out.m_bone_weight_data); - - out.m_name = std::format("{}_lod{}", model->name, lod); - AddXModelMaterials(out, materialMapper, model); - AddXModelObjects(out, model, lod, materialMapper); - AddXModelVertices(out, model, lod); - AddXModelFaces(out, model, lod); - - if (!HasDefaultArmature(model, lod)) - { - AddXModelBones(out, context, model); - AddXModelVertexBoneWeights(out, model, lod); - } - else - { - OmitDefaultArmature(out); - } - } - - void DumpObjMtl(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset) - { - const auto* model = asset->Asset(); - const auto mtlFile = context.OpenAssetFile(std::format("model_export/{}.mtl", model->name)); - - if (!mtlFile) - return; - - const auto writer = obj::CreateMtlWriter(*mtlFile, context.m_zone->m_game->GetShortName(), context.m_zone->m_name); - DistinctMapper materialMapper(model->numsurfs); - - writer->Write(common); - } - - void DumpObjLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset, const unsigned lod) - { - const auto* model = asset->Asset(); - const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".obj")); - - if (!assetFile) - return; - - const auto writer = - obj::CreateObjWriter(*assetFile, std::format("{}.mtl", model->name), context.m_zone->m_game->GetShortName(), context.m_zone->m_name); - DistinctMapper materialMapper(model->numsurfs); - - writer->Write(common); - } - - void DumpXModelExportLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset, const unsigned lod) - { - const auto* model = asset->Asset(); - const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".XMODEL_EXPORT")); - - if (!assetFile) - return; - - const auto writer = xmodel_export::CreateWriterForVersion6(*assetFile, context.m_zone->m_game->GetShortName(), context.m_zone->m_name); - writer->Write(common); - } - - template - void DumpGltfLod( - const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset, const unsigned lod, const std::string& extension) - { - const auto* model = asset->Asset(); - const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, extension)); - - if (!assetFile) - return; - - const auto output = std::make_unique(*assetFile); - const auto writer = gltf::Writer::CreateWriter(output.get(), context.m_zone->m_game->GetShortName(), context.m_zone->m_name); - - writer->Write(common); - } - - void DumpXModelSurfs(const AssetDumpingContext& context, const XAssetInfo* asset) - { - const auto* model = asset->Asset(); - - for (auto currentLod = 0u; currentLod < model->numLods; currentLod++) - { - XModelCommon common; - PopulateXModelWriter(common, context, currentLod, asset->Asset()); - - switch (ObjWriting::Configuration.ModelOutputFormat) - { - case ObjWriting::Configuration_t::ModelOutputFormat_e::OBJ: - DumpObjLod(common, context, asset, currentLod); - if (currentLod == 0u) - DumpObjMtl(common, context, asset); - break; - - case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT: - DumpXModelExportLod(common, context, asset, currentLod); - break; - - case ObjWriting::Configuration_t::ModelOutputFormat_e::GLTF: - DumpGltfLod(common, context, asset, currentLod, ".gltf"); - break; - - case ObjWriting::Configuration_t::ModelOutputFormat_e::GLB: - DumpGltfLod(common, context, asset, currentLod, ".glb"); - break; - - default: - assert(false); - break; - } - } - } - - void DumpXModel(AssetDumpingContext& context, XAssetInfo* asset) - { - const auto assetFile = context.OpenAssetFile(std::format("xmodel/{}.json", asset->m_name)); - if (!assetFile) - return; - - DumpXModelAsJson(*assetFile, asset->Asset(), context); - } -} // namespace - bool AssetDumperXModel::ShouldDump(XAssetInfo* asset) { return !asset->m_name.empty() && asset->m_name[0] != ','; @@ -602,6 +11,5 @@ bool AssetDumperXModel::ShouldDump(XAssetInfo* asset) void AssetDumperXModel::DumpAsset(AssetDumpingContext& context, XAssetInfo* asset) { - DumpXModelSurfs(context, asset); DumpXModel(context, asset); } diff --git a/src/ObjWriting/Game/T6/XModel/JsonXModelWriter.cpp b/src/ObjWriting/Game/T6/XModel/JsonXModelWriter.cpp deleted file mode 100644 index 05104da2..00000000 --- a/src/ObjWriting/Game/T6/XModel/JsonXModelWriter.cpp +++ /dev/null @@ -1,102 +0,0 @@ -#include "JsonXModelWriter.h" - -#include "Game/T6/CommonT6.h" -#include "Game/T6/Json/JsonXModel.h" -#include "ObjWriting.h" - -#include -#include -#include -#include - -using namespace nlohmann; -using namespace T6; - -namespace -{ - class JsonDumper - { - public: - JsonDumper(AssetDumpingContext& context, std::ostream& stream) - : m_stream(stream) - { - } - - void Dump(const XModel* xmodel) const - { - JsonXModel jsonXModel; - CreateJsonXModel(jsonXModel, *xmodel); - json jRoot = jsonXModel; - - jRoot["_type"] = "xmodel"; - jRoot["_version"] = 1; - - m_stream << std::setw(4) << jRoot << "\n"; - } - - private: - static const char* AssetName(const char* input) - { - if (input && input[0] == ',') - return &input[1]; - - return input; - } - - static const char* GetExtensionForModelByConfig() - { - switch (ObjWriting::Configuration.ModelOutputFormat) - { - case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT: - return ".XMODEL_EXPORT"; - case ObjWriting::Configuration_t::ModelOutputFormat_e::OBJ: - return ".OBJ"; - case ObjWriting::Configuration_t::ModelOutputFormat_e::GLTF: - return ".GLTF"; - case ObjWriting::Configuration_t::ModelOutputFormat_e::GLB: - return ".GLB"; - default: - assert(false); - return ""; - } - } - - static void CreateJsonXModel(JsonXModel& jXModel, const XModel& xmodel) - { - if (xmodel.collLod >= 0) - jXModel.collLod = xmodel.collLod; - - for (auto lodNumber = 0u; lodNumber < xmodel.numLods; lodNumber++) - { - JsonXModelLod lod; - lod.file = std::format("model_export/{}_lod{}{}", xmodel.name, lodNumber, GetExtensionForModelByConfig()); - lod.distance = xmodel.lodInfo[lodNumber].dist; - - jXModel.lods.emplace_back(std::move(lod)); - } - - if (xmodel.physPreset && xmodel.physPreset->name) - jXModel.physPreset = AssetName(xmodel.physPreset->name); - - if (xmodel.physConstraints && xmodel.physConstraints->name) - jXModel.physConstraints = AssetName(xmodel.physConstraints->name); - - jXModel.flags = xmodel.flags; - jXModel.lightingOriginOffset.x = xmodel.lightingOriginOffset.x; - jXModel.lightingOriginOffset.y = xmodel.lightingOriginOffset.y; - jXModel.lightingOriginOffset.z = xmodel.lightingOriginOffset.z; - jXModel.lightingOriginRange = xmodel.lightingOriginRange; - } - - std::ostream& m_stream; - }; -} // namespace - -namespace T6 -{ - void DumpXModelAsJson(std::ostream& stream, const XModel* xmodel, AssetDumpingContext& context) - { - const JsonDumper dumper(context, stream); - dumper.Dump(xmodel); - } -} // namespace T6 diff --git a/src/ObjWriting/Game/T6/XModel/JsonXModelWriter.h b/src/ObjWriting/Game/T6/XModel/JsonXModelWriter.h deleted file mode 100644 index f40f008d..00000000 --- a/src/ObjWriting/Game/T6/XModel/JsonXModelWriter.h +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#include "Dumping/AssetDumpingContext.h" -#include "Game/T6/T6.h" - -#include - -namespace T6 -{ - void DumpXModelAsJson(std::ostream& stream, const XModel* xmodel, AssetDumpingContext& context); -} // namespace T6 diff --git a/src/ObjWriting/Game/T6/XModel/XModelDumperT6.cpp b/src/ObjWriting/Game/T6/XModel/XModelDumperT6.cpp new file mode 100644 index 00000000..7ccdd75d --- /dev/null +++ b/src/ObjWriting/Game/T6/XModel/XModelDumperT6.cpp @@ -0,0 +1,17 @@ +#include "XModelDumperT6.h" + +#include "Game/T6/CommonT6.h" +#include "Game/T6/Json/JsonXModel.h" + +#define GAME_NAMESPACE T6 + +#include "XModel/GenericXModelDumper.inc.h" + +namespace T6 +{ + void DumpXModel(AssetDumpingContext& context, XAssetInfo* asset) + { + DumpXModelJson(context, asset); + DumpXModelSurfs(context, asset); + } +} // namespace T6 diff --git a/src/ObjWriting/Game/T6/XModel/XModelDumperT6.h b/src/ObjWriting/Game/T6/XModel/XModelDumperT6.h new file mode 100644 index 00000000..b63027f1 --- /dev/null +++ b/src/ObjWriting/Game/T6/XModel/XModelDumperT6.h @@ -0,0 +1,9 @@ +#pragma once + +#include "Dumping/AssetDumpingContext.h" +#include "Game/T6/T6.h" + +namespace T6 +{ + void DumpXModel(AssetDumpingContext& context, XAssetInfo* asset); +} diff --git a/src/ObjWriting/XModel/GenericXModelDumper.inc.h b/src/ObjWriting/XModel/GenericXModelDumper.inc.h new file mode 100644 index 00000000..6a128bbe --- /dev/null +++ b/src/ObjWriting/XModel/GenericXModelDumper.inc.h @@ -0,0 +1,675 @@ +#pragma once + +#ifndef GAME_NAMESPACE +#error Must define GAME_NAMESPACE +#endif + +#include "Game/T6/CommonT6.h" +#include "ObjWriting.h" +#include "Utils/DistinctMapper.h" +#include "Utils/QuatInt16.h" +#include "XModel/Export/XModelExportWriter.h" +#include "XModel/Gltf/GltfBinOutput.h" +#include "XModel/Gltf/GltfTextOutput.h" +#include "XModel/Gltf/GltfWriter.h" +#include "XModel/Obj/ObjWriter.h" +#include "XModel/XModelWriter.h" + +#include +#include + +namespace GAME_NAMESPACE +{ + inline std::string GetFileNameForLod(const std::string& modelName, const unsigned lod, const std::string& extension) + { + return std::format("model_export/{}_lod{}{}", modelName, lod, extension); + } + + inline GfxImage* GetMaterialColorMap(const Material* material) + { + std::vector potentialTextureDefs; + + for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) + { + MaterialTextureDef* def = &material->textureTable[textureIndex]; + + if (def->semantic == TS_COLOR_MAP || def->semantic >= TS_COLOR0_MAP && def->semantic <= TS_COLOR15_MAP) + potentialTextureDefs.push_back(def); + } + + if (potentialTextureDefs.empty()) + return nullptr; + if (potentialTextureDefs.size() == 1) + return potentialTextureDefs[0]->image; + + for (const auto* def : potentialTextureDefs) + { + if (tolower(def->nameStart) == 'c' && tolower(def->nameEnd) == 'p') + return def->image; + } + + for (const auto* def : potentialTextureDefs) + { + if (tolower(def->nameStart) == 'r' && tolower(def->nameEnd) == 'k') + return def->image; + } + + for (const auto* def : potentialTextureDefs) + { + if (tolower(def->nameStart) == 'd' && tolower(def->nameEnd) == 'p') + return def->image; + } + + return potentialTextureDefs[0]->image; + } + + inline GfxImage* GetMaterialNormalMap(const Material* material) + { + std::vector potentialTextureDefs; + + for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) + { + MaterialTextureDef* def = &material->textureTable[textureIndex]; + + if (def->semantic == TS_NORMAL_MAP) + potentialTextureDefs.push_back(def); + } + + if (potentialTextureDefs.empty()) + return nullptr; + if (potentialTextureDefs.size() == 1) + return potentialTextureDefs[0]->image; + + for (const auto* def : potentialTextureDefs) + { + if (def->nameStart == 'n' && def->nameEnd == 'p') + return def->image; + } + + return potentialTextureDefs[0]->image; + } + + inline GfxImage* GetMaterialSpecularMap(const Material* material) + { + std::vector potentialTextureDefs; + + for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) + { + MaterialTextureDef* def = &material->textureTable[textureIndex]; + + if (def->semantic == TS_SPECULAR_MAP) + potentialTextureDefs.push_back(def); + } + + if (potentialTextureDefs.empty()) + return nullptr; + if (potentialTextureDefs.size() == 1) + return potentialTextureDefs[0]->image; + + for (const auto* def : potentialTextureDefs) + { + if (def->nameStart == 's' && def->nameEnd == 'p') + return def->image; + } + + return potentialTextureDefs[0]->image; + } + + inline bool HasDefaultArmature(const XModel* model, const unsigned lod) + { + if (model->numRootBones != 1 || model->numBones != 1) + return false; + + const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; + const auto surfCount = model->lodInfo[lod].numsurfs; + + if (!surfs) + return true; + + for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) + { + const auto& surface = surfs[surfIndex]; + + if (surface.vertListCount != 1 || surface.vertInfo.vertsBlend) + return false; + + const auto& vertList = surface.vertList[0]; + if (vertList.boneOffset != 0 || vertList.triOffset != 0 || vertList.triCount != surface.triCount || vertList.vertCount != surface.vertCount) + return false; + } + + return true; + } + + inline void OmitDefaultArmature(XModelCommon& common) + { + common.m_bones.clear(); + common.m_bone_weight_data.weights.clear(); + common.m_vertex_bone_weights.resize(common.m_vertices.size()); + for (auto& vertexWeights : common.m_vertex_bone_weights) + { + vertexWeights.weightOffset = 0u; + vertexWeights.weightCount = 0u; + } + } + + inline void AddXModelBones(XModelCommon& out, const AssetDumpingContext& context, const XModel* model) + { + for (auto boneNum = 0u; boneNum < model->numBones; boneNum++) + { + XModelBone bone; + if (model->boneNames[boneNum] < context.m_zone->m_script_strings.Count()) + bone.name = context.m_zone->m_script_strings[model->boneNames[boneNum]]; + else + bone.name = "INVALID_BONE_NAME"; + + if (boneNum >= model->numRootBones) + bone.parentIndex = static_cast(boneNum - static_cast(model->parentList[boneNum - model->numRootBones])); + else + bone.parentIndex = std::nullopt; + + bone.scale[0] = 1.0f; + bone.scale[1] = 1.0f; + bone.scale[2] = 1.0f; + + const auto& baseMat = model->baseMat[boneNum]; + bone.globalOffset[0] = baseMat.trans.x; + bone.globalOffset[1] = baseMat.trans.y; + bone.globalOffset[2] = baseMat.trans.z; + bone.globalRotation = { + baseMat.quat.x, + baseMat.quat.y, + baseMat.quat.z, + baseMat.quat.w, + }; + + if (boneNum < model->numRootBones) + { + bone.localOffset[0] = 0; + bone.localOffset[1] = 0; + bone.localOffset[2] = 0; + bone.localRotation = {0, 0, 0, 1}; + } + else + { + const auto* trans = &model->trans[(boneNum - model->numRootBones) * 3]; + bone.localOffset[0] = trans[0]; + bone.localOffset[1] = trans[1]; + bone.localOffset[2] = trans[2]; + + const auto& quat = model->quats[boneNum - model->numRootBones]; + bone.localRotation = { + QuatInt16::ToFloat(quat.v[0]), + QuatInt16::ToFloat(quat.v[1]), + QuatInt16::ToFloat(quat.v[2]), + QuatInt16::ToFloat(quat.v[3]), + }; + } + + out.m_bones.emplace_back(std::move(bone)); + } + } + + inline const char* AssetName(const char* input) + { + if (input && input[0] == ',') + return &input[1]; + + return input; + } + + inline void AddXModelMaterials(XModelCommon& out, DistinctMapper& materialMapper, const XModel* model) + { + for (auto surfaceMaterialNum = 0; surfaceMaterialNum < model->numsurfs; surfaceMaterialNum++) + { + Material* material = model->materialHandles[surfaceMaterialNum]; + if (materialMapper.Add(material)) + { + XModelMaterial xMaterial; + xMaterial.ApplyDefaults(); + + xMaterial.name = AssetName(material->info.name); + const auto* colorMap = GetMaterialColorMap(material); + if (colorMap) + xMaterial.colorMapName = AssetName(colorMap->name); + + const auto* normalMap = GetMaterialNormalMap(material); + if (normalMap) + xMaterial.normalMapName = AssetName(normalMap->name); + + const auto* specularMap = GetMaterialSpecularMap(material); + if (specularMap) + xMaterial.specularMapName = AssetName(specularMap->name); + + out.m_materials.emplace_back(std::move(xMaterial)); + } + } + } + + inline void AddXModelObjects(XModelCommon& out, const XModel* model, const unsigned lod, const DistinctMapper& materialMapper) + { + const auto surfCount = model->lodInfo[lod].numsurfs; + const auto baseSurfaceIndex = model->lodInfo[lod].surfIndex; + + for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) + { + XModelObject object; + object.name = std::format("surf{}", surfIndex); + object.materialIndex = static_cast(materialMapper.GetDistinctPositionByInputPosition(surfIndex + baseSurfaceIndex)); + + out.m_objects.emplace_back(std::move(object)); + } + } + + inline void AddXModelVertices(XModelCommon& out, const XModel* model, const unsigned lod) + { + const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; + const auto surfCount = model->lodInfo[lod].numsurfs; + + if (!surfs) + return; + + for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) + { + const auto& surface = surfs[surfIndex]; + + for (auto vertexIndex = 0u; vertexIndex < surface.vertCount; vertexIndex++) + { + const auto& v = surface.verts0[vertexIndex]; + + XModelVertex vertex{}; + vertex.coordinates[0] = v.xyz.x; + vertex.coordinates[1] = v.xyz.y; + vertex.coordinates[2] = v.xyz.z; + Common::Vec3UnpackUnitVec(v.normal, vertex.normal); + Common::Vec4UnpackGfxColor(v.color, vertex.color); + Common::Vec2UnpackTexCoords(v.texCoord, vertex.uv); + + out.m_vertices.emplace_back(vertex); + } + } + } + + inline void AllocateXModelBoneWeights(const XModel* model, const unsigned lod, XModelVertexBoneWeightCollection& weightCollection) + { + const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; + const auto surfCount = model->lodInfo[lod].numsurfs; + + if (!surfs) + return; + + auto totalWeightCount = 0u; + for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) + { + const auto& surface = surfs[surfIndex]; + + if (surface.vertList) + { + totalWeightCount += surface.vertListCount; + } + + if (surface.vertInfo.vertsBlend) + { + totalWeightCount += surface.vertInfo.vertCount[0] * 1; + totalWeightCount += surface.vertInfo.vertCount[1] * 2; + totalWeightCount += surface.vertInfo.vertCount[2] * 3; + totalWeightCount += surface.vertInfo.vertCount[3] * 4; + } + } + + weightCollection.weights.resize(totalWeightCount); + } + + inline float BoneWeight16(const uint16_t value) + { + return static_cast(value) / static_cast(std::numeric_limits::max()); + } + + inline void AddXModelVertexBoneWeights(XModelCommon& out, const XModel* model, const unsigned lod) + { + const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; + const auto surfCount = model->lodInfo[lod].numsurfs; + auto& weightCollection = out.m_bone_weight_data; + + if (!surfs) + return; + + size_t weightOffset = 0u; + + for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) + { + const auto& surface = surfs[surfIndex]; + auto handledVertices = 0u; + + if (surface.vertList) + { + for (auto vertListIndex = 0u; vertListIndex < surface.vertListCount; vertListIndex++) + { + const auto& vertList = surface.vertList[vertListIndex]; + const auto boneWeightOffset = weightOffset; + + weightCollection.weights[weightOffset++] = XModelBoneWeight{vertList.boneOffset / sizeof(DObjSkelMat), 1.0f}; + + for (auto vertListVertexOffset = 0u; vertListVertexOffset < vertList.vertCount; vertListVertexOffset++) + { + out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 1); + } + handledVertices += vertList.vertCount; + } + } + + auto vertsBlendOffset = 0u; + if (surface.vertInfo.vertsBlend) + { + // 1 bone weight + for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[0]; vertIndex++) + { + const auto boneWeightOffset = weightOffset; + const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, 1.0f}; + + vertsBlendOffset += 1; + + out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 1); + } + + // 2 bone weights + for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[1]; vertIndex++) + { + const auto boneWeightOffset = weightOffset; + const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); + const auto boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat); + const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]); + const auto boneWeight0 = 1.0f - boneWeight1; + + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, boneWeight0}; + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex1, boneWeight1}; + + vertsBlendOffset += 3; + + out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 2); + } + + // 3 bone weights + for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[2]; vertIndex++) + { + const auto boneWeightOffset = weightOffset; + const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); + const auto boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat); + const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]); + const auto boneIndex2 = surface.vertInfo.vertsBlend[vertsBlendOffset + 3] / sizeof(DObjSkelMat); + const auto boneWeight2 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 4]); + const auto boneWeight0 = 1.0f - boneWeight1 - boneWeight2; + + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, boneWeight0}; + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex1, boneWeight1}; + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex2, boneWeight2}; + + vertsBlendOffset += 5; + + out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 3); + } + + // 4 bone weights + for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[3]; vertIndex++) + { + const auto boneWeightOffset = weightOffset; + const auto boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat); + const auto boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat); + const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]); + const auto boneIndex2 = surface.vertInfo.vertsBlend[vertsBlendOffset + 3] / sizeof(DObjSkelMat); + const auto boneWeight2 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 4]); + const auto boneIndex3 = surface.vertInfo.vertsBlend[vertsBlendOffset + 5] / sizeof(DObjSkelMat); + const auto boneWeight3 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 6]); + const auto boneWeight0 = 1.0f - boneWeight1 - boneWeight2 - boneWeight3; + + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex0, boneWeight0}; + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex1, boneWeight1}; + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex2, boneWeight2}; + weightCollection.weights[weightOffset++] = XModelBoneWeight{boneIndex3, boneWeight3}; + + vertsBlendOffset += 7; + + out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 4); + } + + handledVertices += + surface.vertInfo.vertCount[0] + surface.vertInfo.vertCount[1] + surface.vertInfo.vertCount[2] + surface.vertInfo.vertCount[3]; + } + + for (; handledVertices < surface.vertCount; handledVertices++) + { + out.m_vertex_bone_weights.emplace_back(0, 0); + } + } + } + + inline void AddXModelFaces(XModelCommon& out, const XModel* model, const unsigned lod) + { + const auto* surfs = &model->surfs[model->lodInfo[lod].surfIndex]; + const auto surfCount = model->lodInfo[lod].numsurfs; + + if (!surfs) + return; + + for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++) + { + const auto& surface = surfs[surfIndex]; + auto& object = out.m_objects[surfIndex]; + object.m_faces.reserve(surface.triCount); + + for (auto triIndex = 0u; triIndex < surface.triCount; triIndex++) + { + const auto& tri = surface.triIndices[triIndex]; + + XModelFace face{}; + face.vertexIndex[0] = tri.i[0] + surface.baseVertIndex; + face.vertexIndex[1] = tri.i[1] + surface.baseVertIndex; + face.vertexIndex[2] = tri.i[2] + surface.baseVertIndex; + object.m_faces.emplace_back(face); + } + } + } + + inline void PopulateXModelWriter(XModelCommon& out, const AssetDumpingContext& context, const unsigned lod, const XModel* model) + { + DistinctMapper materialMapper(model->numsurfs); + AllocateXModelBoneWeights(model, lod, out.m_bone_weight_data); + + out.m_name = std::format("{}_lod{}", model->name, lod); + AddXModelMaterials(out, materialMapper, model); + AddXModelObjects(out, model, lod, materialMapper); + AddXModelVertices(out, model, lod); + AddXModelFaces(out, model, lod); + + if (!HasDefaultArmature(model, lod)) + { + AddXModelBones(out, context, model); + AddXModelVertexBoneWeights(out, model, lod); + } + else + { + OmitDefaultArmature(out); + } + } + + inline void DumpObjMtl(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset) + { + const auto* model = asset->Asset(); + const auto mtlFile = context.OpenAssetFile(std::format("model_export/{}.mtl", model->name)); + + if (!mtlFile) + return; + + const auto writer = obj::CreateMtlWriter(*mtlFile, context.m_zone->m_game->GetShortName(), context.m_zone->m_name); + DistinctMapper materialMapper(model->numsurfs); + + writer->Write(common); + } + + inline void DumpObjLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset, const unsigned lod) + { + const auto* model = asset->Asset(); + const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".obj")); + + if (!assetFile) + return; + + const auto writer = + obj::CreateObjWriter(*assetFile, std::format("{}.mtl", model->name), context.m_zone->m_game->GetShortName(), context.m_zone->m_name); + DistinctMapper materialMapper(model->numsurfs); + + writer->Write(common); + } + + inline void DumpXModelExportLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset, const unsigned lod) + { + const auto* model = asset->Asset(); + const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".XMODEL_EXPORT")); + + if (!assetFile) + return; + + const auto writer = xmodel_export::CreateWriterForVersion6(*assetFile, context.m_zone->m_game->GetShortName(), context.m_zone->m_name); + writer->Write(common); + } + + template + void DumpGltfLod( + const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo* asset, const unsigned lod, const std::string& extension) + { + const auto* model = asset->Asset(); + const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, extension)); + + if (!assetFile) + return; + + const auto output = std::make_unique(*assetFile); + const auto writer = gltf::Writer::CreateWriter(output.get(), context.m_zone->m_game->GetShortName(), context.m_zone->m_name); + + writer->Write(common); + } + + inline void DumpXModelSurfs(const AssetDumpingContext& context, const XAssetInfo* asset) + { + const auto* model = asset->Asset(); + + for (auto currentLod = 0u; currentLod < model->numLods; currentLod++) + { + XModelCommon common; + PopulateXModelWriter(common, context, currentLod, asset->Asset()); + + switch (ObjWriting::Configuration.ModelOutputFormat) + { + case ObjWriting::Configuration_t::ModelOutputFormat_e::OBJ: + DumpObjLod(common, context, asset, currentLod); + if (currentLod == 0u) + DumpObjMtl(common, context, asset); + break; + + case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT: + DumpXModelExportLod(common, context, asset, currentLod); + break; + + case ObjWriting::Configuration_t::ModelOutputFormat_e::GLTF: + DumpGltfLod(common, context, asset, currentLod, ".gltf"); + break; + + case ObjWriting::Configuration_t::ModelOutputFormat_e::GLB: + DumpGltfLod(common, context, asset, currentLod, ".glb"); + break; + + default: + assert(false); + break; + } + } + } + + class JsonDumper + { + public: + JsonDumper(AssetDumpingContext& context, std::ostream& stream) + : m_stream(stream) + { + } + + void Dump(const XModel* xmodel) const + { + JsonXModel jsonXModel; + CreateJsonXModel(jsonXModel, *xmodel); + nlohmann::json jRoot = jsonXModel; + + jRoot["_type"] = "xmodel"; + jRoot["_version"] = 1; + + m_stream << std::setw(4) << jRoot << "\n"; + } + + private: + static const char* AssetName(const char* input) + { + if (input && input[0] == ',') + return &input[1]; + + return input; + } + + static const char* GetExtensionForModelByConfig() + { + switch (ObjWriting::Configuration.ModelOutputFormat) + { + case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT: + return ".XMODEL_EXPORT"; + case ObjWriting::Configuration_t::ModelOutputFormat_e::OBJ: + return ".OBJ"; + case ObjWriting::Configuration_t::ModelOutputFormat_e::GLTF: + return ".GLTF"; + case ObjWriting::Configuration_t::ModelOutputFormat_e::GLB: + return ".GLB"; + default: + assert(false); + return ""; + } + } + + static void CreateJsonXModel(JsonXModel& jXModel, const XModel& xmodel) + { + if (xmodel.collLod >= 0) + jXModel.collLod = xmodel.collLod; + + for (auto lodNumber = 0u; lodNumber < xmodel.numLods; lodNumber++) + { + JsonXModelLod lod; + lod.file = std::format("model_export/{}_lod{}{}", xmodel.name, lodNumber, GetExtensionForModelByConfig()); + lod.distance = xmodel.lodInfo[lodNumber].dist; + + jXModel.lods.emplace_back(std::move(lod)); + } + + if (xmodel.physPreset && xmodel.physPreset->name) + jXModel.physPreset = AssetName(xmodel.physPreset->name); + + if (xmodel.physConstraints && xmodel.physConstraints->name) + jXModel.physConstraints = AssetName(xmodel.physConstraints->name); + + jXModel.flags = xmodel.flags; + jXModel.lightingOriginOffset.x = xmodel.lightingOriginOffset.x; + jXModel.lightingOriginOffset.y = xmodel.lightingOriginOffset.y; + jXModel.lightingOriginOffset.z = xmodel.lightingOriginOffset.z; + jXModel.lightingOriginRange = xmodel.lightingOriginRange; + } + + std::ostream& m_stream; + }; + + inline void DumpXModelJson(AssetDumpingContext& context, XAssetInfo* asset) + { + const auto assetFile = context.OpenAssetFile(std::format("xmodel/{}.json", asset->m_name)); + if (!assetFile) + return; + + const JsonDumper dumper(context, *assetFile); + dumper.Dump(asset->Asset()); + } +} // namespace GAME_NAMESPACE