complete static mesh parsing

Author: moritz-h

libsave/include/SatisfactorySave/GameTypes/UE/Core/Math/BoxSphereBounds.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../../../../IO/Archive/Archive.h"
+#include "Vector.h"
+
+namespace SatisfactorySave {
+
+    template<typename T, typename TExtent>
+    struct TBoxSphereBounds {
+    public:
+        TVector<T> Origin;
+        TVector<TExtent> BoxExtent;
+        TExtent SphereRadius = static_cast<TExtent>(0.0);
+
+        void serialize(Archive& ar) {
+            ar << Origin;
+            ar << BoxExtent;
+            ar << SphereRadius;
+        }
+    };
+
+    using FBoxSphereBounds3f = TBoxSphereBounds<float, float>;
+    using FBoxSphereBounds3d = TBoxSphereBounds<double, double>;
+    using FBoxSphereBounds = FBoxSphereBounds3d;
+} // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/Engine/DistanceFieldAtlas.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+#include "../../../IO/Archive/Archive.h"
+#include "../Core/Math/Box.h"
+#include "../Core/Math/IntVector.h"
+#include "../Core/Math/Vector2D.h"
+#include "../CoreUObject/Serialization/BulkData.h"
+#include "satisfactorysave_export.h"
+
+namespace SatisfactorySave {
+    class SATISFACTORYSAVE_API FSparseDistanceFieldMip {
+    public:
+        FIntVector IndirectionDimensions;
+        int32_t NumDistanceFieldBricks = 0;
+        FVector VolumeToVirtualUVScale;
+        FVector VolumeToVirtualUVAdd;
+        FVector2D DistanceFieldToVolumeScaleBias;
+        uint32_t BulkOffset = 0;
+        uint32_t BulkSize = 0;
+
+        void serialize(Archive& ar) {
+            ar << IndirectionDimensions;
+            ar << NumDistanceFieldBricks;
+            ar << VolumeToVirtualUVScale;
+            ar << VolumeToVirtualUVAdd;
+            ar << DistanceFieldToVolumeScaleBias;
+            ar << BulkOffset;
+            ar << BulkSize;
+        }
+    };
+
+    class SATISFACTORYSAVE_API FDistanceFieldVolumeData {
+    public:
+        FBox LocalSpaceMeshBounds;
+        bool bMostlyTwoSided;
+        std::array<FSparseDistanceFieldMip, /*DistanceField::NumMips*/ 3> Mips;
+        std::vector<uint8_t> AlwaysLoadedMip;
+        FByteBulkData StreamableMips;
+
+        void serialize(Archive& ar) {
+            ar << LocalSpaceMeshBounds;
+            ar << bMostlyTwoSided;
+            ar << Mips;
+            ar << AlwaysLoadedMip;
+            ar << StreamableMips;
+        }
+    };
+} // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/Engine/Engine/StaticMesh.h

@@ -1,14 +1,34 @@
 #pragma once
 
+#include <cstdint>
+#include <vector>
+
 #include "../../../../IO/Archive/Archive.h"
+#include "../../../FactoryGame/FGObjectReference.h"
+#include "../../Core/UObject/NameTypes.h"
 #include "../../CoreUObject/UObject/Object.h"
+#include "../MeshUVChannelInfo.h"
 #include "../StaticMeshResources.h"
 #include "satisfactorysave_export.h"
 
 namespace SatisfactorySave {
+    struct SATISFACTORYSAVE_API FStaticMaterial {
+        FObjectReferenceDisc MaterialInterface;
+        FName MaterialSlotName;
+        FMeshUVChannelInfo UVChannelData;
+
+        void serialize(Archive& ar) {
+            ar << MaterialInterface;
+            ar << MaterialSlotName;
+            ar << UVChannelData;
+        }
+    };
+
     class SATISFACTORYSAVE_API UStaticMesh : public UObject {
     public:
         FStaticMeshRenderData RenderData;
+        std::vector<FStaticMaterial> StaticMaterials;
+        uint8_t MaxShadowLOD = 0;
 
         void serialize(Archive& ar) override;
     };

libsave/include/SatisfactorySave/GameTypes/UE/Engine/MeshCardBuild.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <vector>
+
+#include "../../../IO/Archive/Archive.h"
+#include "../Core/Math/Box.h"
+#include "MeshCardRepresentation.h"
+#include "satisfactorysave_export.h"
+
+namespace SatisfactorySave {
+    class SATISFACTORYSAVE_API FLumenCardBuildData {
+    public:
+        FLumenCardOBBf OBB;
+        uint8_t AxisAlignedDirectionIndex = 0;
+
+        void serialize(Archive& ar) {
+            ar << OBB;
+            ar << AxisAlignedDirectionIndex;
+        }
+    };
+
+    class SATISFACTORYSAVE_API FMeshCardsBuildData {
+    public:
+        FBox Bounds;
+        bool bMostlyTwoSided;
+        std::vector<FLumenCardBuildData> CardBuildData;
+
+        void serialize(Archive& ar) {
+            ar << Bounds;
+            ar << bMostlyTwoSided;
+            ar << CardBuildData;
+        }
+    };
+
+    class SATISFACTORYSAVE_API FCardRepresentationData {
+    public:
+        FMeshCardsBuildData MeshCardsBuildData;
+
+        void serialize(Archive& ar) {
+            ar << MeshCardsBuildData;
+        }
+    };
+} // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/Engine/MeshCardRepresentation.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "../../../IO/Archive/Archive.h"
+#include "../Core/Math/Vector.h"
+
+namespace SatisfactorySave {
+    template<typename T>
+    class TLumenCardOBB {
+    public:
+        TVector<T> Origin;
+        TVector<T> AxisX;
+        TVector<T> AxisY;
+        TVector<T> AxisZ;
+        TVector<T> Extent;
+
+        void serialize(Archive& ar) {
+            ar << AxisX;
+            ar << AxisY;
+            ar << AxisZ;
+            ar << Origin;
+            ar << Extent;
+        }
+    };
+
+    using FLumenCardOBBf = TLumenCardOBB<float>;
+    using FLumenCardOBBd = TLumenCardOBB<double>;
+} // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/Engine/MeshUVChannelInfo.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <array>
+
+#include "../../../IO/Archive/Archive.h"
+#include "satisfactorysave_export.h"
+
+namespace SatisfactorySave {
+    struct SATISFACTORYSAVE_API FMeshUVChannelInfo {
+    public:
+        bool bInitialized = false;
+        bool bOverrideDensities = false;
+        std::array<float, /*MAX_TEXCOORDS*/ 4> LocalUVDensities{};
+
+        void serialize(Archive& ar) {
+            ar << bInitialized;
+            ar << bOverrideDensities;
+
+            for (auto& localUVDensity : LocalUVDensities) {
+                ar << localUVDensity;
+            }
+        }
+    };
+} // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/Engine/PerPlatformProperties.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../../../IO/Archive/Archive.h"
+#include "satisfactorysave_export.h"
+
+namespace SatisfactorySave {
+    struct SATISFACTORYSAVE_API FPerPlatformFloat {
+    public:
+        bool bCooked = false;
+        float Default = 0.0f;
+
+        void serialize(Archive& ar) {
+            ar << bCooked;
+            ar << Default;
+        }
+    };
+} // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/Engine/Rendering/NaniteResources.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "../../../../IO/Archive/Archive.h"
+#include "../../Core/Math/Vector.h"
+#include "../../Core/Math/Vector4.h"
+#include "../../CoreUObject/Serialization/BulkData.h"
+#include "satisfactorysave_export.h"
+
+#define NANITE_MAX_BVH_NODE_FANOUT_BITS 2
+#define NANITE_MAX_BVH_NODE_FANOUT (1 << NANITE_MAX_BVH_NODE_FANOUT_BITS)
+
+namespace SatisfactorySave {
+
+    struct SATISFACTORYSAVE_API FPackedHierarchyNode {
+        FVector4f LODBounds[NANITE_MAX_BVH_NODE_FANOUT];
+
+        struct {
+            FVector3f BoxBoundsCenter;
+            uint32_t MinLODError_MaxParentLODError = 0;
+        } Misc0[NANITE_MAX_BVH_NODE_FANOUT];
+
+        struct {
+            FVector3f BoxBoundsExtent;
+            uint32_t ChildStartReference = 0;
+        } Misc1[NANITE_MAX_BVH_NODE_FANOUT];
+
+        struct {
+            uint32_t ResourcePageIndex_NumPages_GroupPartSize = 0;
+        } Misc2[NANITE_MAX_BVH_NODE_FANOUT];
+
+        void serialize(Archive& ar) {
+            for (uint32_t i = 0; i < NANITE_MAX_BVH_NODE_FANOUT; i++) {
+                ar << LODBounds[i];
+                ar << Misc0[i].BoxBoundsCenter;
+                ar << Misc0[i].MinLODError_MaxParentLODError;
+                ar << Misc1[i].BoxBoundsExtent;
+                ar << Misc1[i].ChildStartReference;
+                ar << Misc2[i].ResourcePageIndex_NumPages_GroupPartSize;
+            }
+        }
+    };
+
+    struct SATISFACTORYSAVE_API FPageStreamingState {
+        uint32_t BulkOffset;
+        uint32_t BulkSize;
+        uint32_t PageSize;
+        uint32_t DependenciesStart;
+        uint16_t DependenciesNum;
+        uint8_t MaxHierarchyDepth;
+        uint8_t Flags;
+
+        void serialize(Archive& ar) {
+            ar << BulkOffset;
+            ar << BulkSize;
+            ar << PageSize;
+            ar << DependenciesStart;
+            ar << DependenciesNum;
+            ar << MaxHierarchyDepth;
+            ar << Flags;
+        }
+    };
+
+    struct SATISFACTORYSAVE_API FResources {
+        std::vector<uint8_t> RootData;
+        FByteBulkData StreamablePages;
+        std::vector<uint16_t> ImposterAtlas;
+        std::vector<FPackedHierarchyNode> HierarchyNodes;
+        std::vector<uint32_t> HierarchyRootOffsets;
+        std::vector<FPageStreamingState> PageStreamingStates;
+        std::vector<uint32_t> PageDependencies;
+        uint32_t NumRootPages = 0;
+        int32_t PositionPrecision = 0;
+        int32_t NormalPrecision = 0;
+        uint32_t NumInputTriangles = 0;
+        uint32_t NumInputVertices = 0;
+        uint16_t NumInputMeshes = 0;
+        uint16_t NumInputTexCoords = 0;
+        uint32_t NumClusters = 0;
+        uint32_t ResourceFlags = 0;
+
+        void serialize(Archive& ar) {
+            // https://github.com/EpicGames/UnrealEngine/blob/5.3.2-release/Engine/Source/Runtime/Engine/Private/Rendering/NaniteResources.cpp#L233
+
+            // FStripDataFlags
+            FStripDataFlags flags;
+            ar << flags;
+            flags.validateOnlyEditorDataIsStripped();
+
+            ar << ResourceFlags;
+            ar << StreamablePages;
+            ar << RootData;
+            ar << PageStreamingStates;
+            ar << HierarchyNodes;
+            ar << HierarchyRootOffsets;
+            ar << PageDependencies;
+            ar << ImposterAtlas;
+            ar << NumRootPages;
+            ar << PositionPrecision;
+            ar << NormalPrecision;
+            ar << NumInputTriangles;
+            ar << NumInputVertices;
+            ar << NumInputMeshes;
+            ar << NumInputTexCoords;
+            ar << NumClusters;
+        }
+    };
+} // namespace SatisfactorySave