WIP t6 custom map loading

src/Common/Game/T6/T6_Assets.h

@@ -1246,13 +1246,13 @@ namespace T6
 
     struct GfxWorldVertexData0
     {
-        byte128* data;
+        byte128* data; // GfxPackedWorldVertex
         void /*ID3D11Buffer*/* vb;
     };
 
     struct GfxWorldVertexData1
     {
-        byte128* data;
+        byte128* data; // GfxPackedWorldVertex
         void /*ID3D11Buffer*/* vb;
     };
 
@@ -1278,6 +1278,16 @@ namespace T6
     typedef tdef_align32(4) char aligned_byte_pointer;
     typedef tdef_align32(4) GfxCompressedLightGridCoeffs GfxCompressedLightGridCoeffs_align4;
 
+    struct GfxLightGridRow
+    {
+        uint16_t colStart;
+        uint16_t colCount;
+        uint16_t zStart;
+        uint16_t zCount;
+        unsigned int firstEntry;
+        char lookupTable[1]; // The lookup table has a variable length
+    };
+
     struct GfxLightGrid
     {
         unsigned int sunPrimaryLightIndex;
@@ -1288,7 +1298,7 @@ namespace T6
         unsigned int colAxis;
         uint16_t* rowDataStart;
         unsigned int rawRowDataSize;
-        aligned_byte_pointer* rawRowData;
+        aligned_byte_pointer* rawRowData; // GfxLightGridRow
         unsigned int entryCount;
         GfxLightGridEntry* entries;
         unsigned int colorCount;
@@ -3898,6 +3908,17 @@ namespace T6
         int baseIndex;
     };
 
+    enum GfxSurfaceFlags
+    {
+        GFX_SURFACE_CASTS_SUN_SHADOW = 0x1,
+        GFX_SURFACE_HAS_PRIMARY_LIGHT_CONFLICT = 0x2,
+        GFX_SURFACE_IS_SKY = 0x4,
+        GFX_SURFACE_NO_DRAW = 0x8,
+        GFX_SURFACE_CASTS_SHADOW = 0x10,
+        GFX_SURFACE_QUANTIZED = 0x20,
+        GFX_SURFACE_NO_COLOR = 0x40
+    };
+
     struct type_align32(16) GfxSurface
     {
         srfTriangles_t tris;
@@ -3930,6 +3951,12 @@ namespace T6
         uint16_t numLmapVertexColors;
     };
 
+    enum StaticModelFlag
+    {
+        STATIC_MODEL_FLAG_NO_SHADOW = 0x1,
+        STATIC_MODEL_FLAG_LIGHTMAP_VC = 0x2,
+    };
+
     struct GfxStaticModelDrawInst
     {
         float cullDist;
@@ -5728,6 +5755,11 @@ namespace T6
         unsigned int packed;
     };
 
+    union PackedLmapCoords
+    {
+        unsigned int packed;
+    };
+
     struct type_align(16) GfxPackedVertex
     {
         vec3_t xyz;
@@ -5738,6 +5770,17 @@ namespace T6
         PackedUnitVec tangent;
     };
 
+    struct GfxPackedWorldVertex
+    {
+        vec3_t xyz;
+        float binormalSign;
+        GfxColor color;
+        PackedTexCoords texCoord;
+        PackedUnitVec normal;
+        PackedUnitVec tangent;
+        PackedLmapCoords lmapCoord;
+    };
+
     struct XRigidVertList
     {
         uint16_t boneOffset;
@@ -7053,6 +7096,23 @@ namespace T6
         char* stringValue;
     };
 
+    enum GfxLightType
+    {
+        GFX_LIGHT_TYPE_NONE = 0x0,
+        GFX_LIGHT_TYPE_DIR = 0x1,
+        GFX_LIGHT_TYPE_SPOT = 0x2,
+        GFX_LIGHT_TYPE_SPOT_SQUARE = 0x3,
+        GFX_LIGHT_TYPE_SPOT_ROUND = 0x4,
+        GFX_LIGHT_TYPE_OMNI = 0x5,
+        GFX_LIGHT_TYPE_COUNT = 0x6,
+        GFX_LIGHT_TYPE_DIR_SHADOWMAP = 0x6,
+        GFX_LIGHT_TYPE_SPOT_SHADOWMAP = 0x7,
+        GFX_LIGHT_TYPE_SPOT_SQUARE_SHADOWMAP = 0x8,
+        GFX_LIGHT_TYPE_SPOT_ROUND_SHADOWMAP = 0x9,
+        GFX_LIGHT_TYPE_OMNI_SHADOWMAP = 0xA,
+        GFX_LIGHT_TYPE_COUNT_WITH_SHADOWMAP_VERSIONS = 0xB,
+    };
+
 #ifndef __zonecodegenerator
 } // namespace T6
 #endif

src/Linker/Linker.cpp

@@ -1,5 +1,4 @@
 #include "Linker.h"
-
 #include "LinkerArgs.h"
 #include "LinkerPaths.h"
 #include "ObjContainer/SoundBank/SoundBankWriter.h"
@@ -330,7 +329,7 @@ class LinkerImpl final : public Linker
 
             PathGameContext gameContext(paths, projectName, zoneDefinition->m_game);
 
-            if (!zoneDefinition->m_assets.empty())
+            if (!zoneDefinition->m_assets.empty() || zoneDefinition->m_map_type != ZoneDefinitionMapType::NONE)
             {
                 if (!BuildFastFile(paths, projectName, targetName, *zoneDefinition))
                     return false;

src/Linker/ZoneCreation/ZoneCreator.cpp

@@ -72,7 +72,7 @@ namespace zone_creator
         OutputPathFilesystem cacheDir(context.m_cache_dir);
         objCompiler->ConfigureCreatorCollection(
             creatorCollection, *zone, zoneDefinitionContext, *context.m_asset_search_path, lookup, creationContext, outDir, cacheDir);
-        objLoader->ConfigureCreatorCollection(creatorCollection, *zone, *context.m_asset_search_path, lookup);
+        objLoader->ConfigureCreatorCollection(creatorCollection, *zone, *context.m_asset_search_path, lookup, *context.m_definition);
 
         for (const auto& assetEntry : context.m_definition->m_assets)
         {
@@ -84,7 +84,8 @@ namespace zone_creator
             ++zoneDefinitionContext.m_asset_index_in_definition;
         }
 
-        creatorCollection.FinalizeZone(creationContext);
+        if (!creatorCollection.FinalizeZone(creationContext))
+            return nullptr;
 
         return zone;
     }

src/ObjCommon/XModel/Gltf/JsonGltf.h

@@ -18,6 +18,74 @@ namespace gltf
 
     NLOHMANN_DEFINE_TYPE_EXTENSION(JsonAsset, version, generator);
 
+    class JsonPunctualSpotLightProperties
+    {
+    public:
+        std::optional<float> innerConeAngle;
+        std::optional<float> outerConeAngle;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonPunctualSpotLightProperties, innerConeAngle, outerConeAngle);
+
+    enum class JsonPunctualLightType
+    {
+        DIRECTIONAL,
+        POINT,
+        SPOT
+    };
+
+    NLOHMANN_JSON_SERIALIZE_ENUM(JsonPunctualLightType,
+                                 {
+                                     {JsonPunctualLightType::DIRECTIONAL, "directional"},
+                                     {JsonPunctualLightType::POINT,       "point"      },
+                                     {JsonPunctualLightType::SPOT,        "spot"       },
+    });
+
+    class JsonPunctualLight
+    {
+    public:
+        std::optional<std::array<float, 3>> color;
+        std::optional<float> intensity;
+        std::optional<std::string> name;
+        std::optional<float> range;
+        std::optional<JsonPunctualSpotLightProperties> spot;
+        JsonPunctualLightType type;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonPunctualLight, color, intensity, name, range, spot, type);
+
+    class JsonPunctualLightsExt
+    {
+    public:
+        std::optional<std::vector<JsonPunctualLight>> lights;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonPunctualLightsExt, lights);
+
+    class JsonExtension
+    {
+    public:
+        std::optional<JsonPunctualLightsExt> KHR_lights_punctual;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonExtension, KHR_lights_punctual);
+
+    class JsonPunctualLightIndex
+    {
+    public:
+        int light;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonPunctualLightIndex, light);
+
+    class JsonNodeExtension
+    {
+    public:
+        std::optional<JsonPunctualLightIndex> KHR_lights_punctual;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonNodeExtension, KHR_lights_punctual);
+
     class JsonNode
     {
     public:
@@ -29,9 +97,12 @@ namespace gltf
         std::optional<std::vector<unsigned>> children;
         std::optional<unsigned> skin;
         std::optional<unsigned> mesh;
+
+        std::optional<JsonNodeExtension> extensions;
+        std::optional<nlohmann::json> extras;
     };
 
-    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonNode, name, translation, rotation, scale, matrix, children, skin, mesh);
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonNode, name, translation, rotation, scale, matrix, children, skin, mesh, extensions, extras);
 
     class JsonBuffer
     {
@@ -207,10 +278,11 @@ namespace gltf
     {
     public:
         std::optional<JsonTextureInfo> baseColorTexture;
+        std::optional<std::array<float, 4>> baseColorFactor;
         std::optional<float> metallicFactor;
     };
 
-    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonPbrMetallicRoughness, baseColorTexture, metallicFactor);
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonPbrMetallicRoughness, baseColorTexture, baseColorFactor, metallicFactor);
 
     class JsonNormalTextureInfo
     {
@@ -220,16 +292,26 @@ namespace gltf
 
     NLOHMANN_DEFINE_TYPE_EXTENSION(JsonNormalTextureInfo, index);
 
+    class JsonMaterialExtras
+    {
+    public:
+        std::optional<std::string> type;
+    };
+
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonMaterialExtras, type);
+
     class JsonMaterial
     {
     public:
         std::optional<std::string> name;
         std::optional<JsonPbrMetallicRoughness> pbrMetallicRoughness;
         std::optional<JsonNormalTextureInfo> normalTexture;
         std::optional<bool> doubleSided;
+
+        std::optional<JsonMaterialExtras> extras;
     };
 
-    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonMaterial, name, pbrMetallicRoughness, normalTexture, doubleSided);
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonMaterial, name, pbrMetallicRoughness, normalTexture, doubleSided, extras);
 
     enum class JsonMeshPrimitivesMode
     {
@@ -318,9 +400,12 @@ namespace gltf
     {
     public:
         std::optional<std::string> uri;
+
+        std::optional<unsigned int> bufferView;
+        std::optional<std::string> mimeType;
     };
 
-    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonImage, uri);
+    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonImage, uri, bufferView, mimeType);
 
     class JsonRoot
     {
@@ -338,8 +423,9 @@ namespace gltf
         std::optional<unsigned> scene;
         std::optional<std::vector<JsonScene>> scenes;
         std::optional<std::vector<JsonTexture>> textures;
+        std::optional<JsonExtension> extensions;
     };
 
     NLOHMANN_DEFINE_TYPE_EXTENSION(
-        JsonRoot, accessors, animations, asset, buffers, bufferViews, images, materials, meshes, nodes, skins, scene, scenes, textures);
+        JsonRoot, accessors, animations, asset, buffers, bufferViews, images, materials, meshes, nodes, skins, scene, scenes, textures, extensions);
 } // namespace gltf

src/ObjCompiling/Game/T6/KeyValuePairs/KeyValuePairsCompilerT6.cpp

@@ -32,12 +32,12 @@ namespace
             return AssetCreationResult::NoAction();
         }
 
-        void FinalizeZone(AssetCreationContext& context) override
+        bool FinalizeZone(AssetCreationContext& context) override
         {
             m_kvp_creator.Finalize(m_zone_definition);
             const auto commonKvps = m_kvp_creator.GetFinalKeyValuePairs();
             if (commonKvps.empty())
-                return;
+                return true;
 
             auto* gameKvps = m_memory.Alloc<KeyValuePairs>();
             gameKvps->name = m_memory.Dup(m_zone.m_name.c_str());
@@ -61,6 +61,8 @@ namespace
             }
 
             context.AddAsset(AssetRegistration<AssetKeyValuePairs>(m_zone.m_name, gameKvps));
+
+            return true;
         }
 
     private:

src/ObjLoading.lua

@@ -64,4 +64,4 @@ function ObjLoading:project()
 		eigen:include(includes)
 		json:include(includes)
 		libtomcrypt:include(includes)
-end
+end

src/ObjLoading/Asset/AssetCreationContext.cpp

@@ -120,6 +120,9 @@ XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_
         return LoadDefaultAssetDependency(assetType, std::format(",{}", assetName));
     }
 
+    if (assetName.starts_with(','))
+        return LoadDefaultAssetDependency(assetType, assetName);
+
     if (m_ignored_asset_lookup->IsAssetIgnored(assetType, assetName))
         return LoadDefaultAssetDependency(assetType, std::format(",{}", assetName));
 

src/ObjLoading/Asset/AssetCreatorCollection.cpp

@@ -79,10 +79,15 @@ AssetCreationResult AssetCreatorCollection::CreateDefaultAsset(const asset_type_
     return AssetCreationResult::NoAction();
 }
 
-void AssetCreatorCollection::FinalizeZone(AssetCreationContext& context) const
+bool AssetCreatorCollection::FinalizeZone(AssetCreationContext& context) const
 {
     for (const auto& creator : m_asset_creators)
-        creator->FinalizeZone(context);
+    {
+        if (!creator->FinalizeZone(context))
+            return false;
+    }
     for (const auto& postProcessor : m_asset_post_processors)
         postProcessor->FinalizeZone(context);
+
+    return true;
 }

src/ObjLoading/Asset/AssetCreatorCollection.h

@@ -27,7 +27,7 @@ class AssetCreatorCollection
 
     AssetCreationResult CreateAsset(asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const;
     AssetCreationResult CreateDefaultAsset(asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const;
-    void FinalizeZone(AssetCreationContext& context) const;
+    bool FinalizeZone(AssetCreationContext& context) const;
 
 private:
     std::vector<std::vector<IAssetCreator*>> m_asset_creators_by_type;

src/ObjLoading/Asset/IAssetCreator.h

@@ -26,7 +26,10 @@ class IAssetCreator
     [[nodiscard]] virtual std::optional<asset_type_t> GetHandlingAssetType() const = 0;
     virtual AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) = 0;
 
-    virtual void FinalizeZone(AssetCreationContext& context) {}
+    virtual bool FinalizeZone(AssetCreationContext& context)
+    {
+        return true;
+    };
 };
 
 template<typename AssetType> class AssetCreator : public IAssetCreator