New shadow renderer

common/custom_data/TFrag3Data.cpp

@@ -587,6 +587,42 @@ void MercModelGroup::serialize(Serializer& ser) {
   ser.from_pod_vector(&vertices);
 }
 
+void ShadowModelFragment::serialize(Serializer& ser) {
+  ser.from_ptr(&first_vertex);
+  ser.from_ptr(&num_one_bone_vertices);
+  ser.from_ptr(&num_two_bone_vertices);
+  ser.from_pod_vector(&single_tris);
+  ser.from_pod_vector(&double_tris);
+  ser.from_pod_vector(&single_edges);
+  ser.from_pod_vector(&double_edges);
+}
+
+void ShadowModel::serialize(Serializer& ser) {
+  ser.from_str(&name);
+  ser.from_ptr(&max_bones);
+
+  if (ser.is_saving()) {
+    ser.save<size_t>(fragments.size());
+  } else {
+    fragments.resize(ser.load<size_t>());
+  }
+  for (auto& frag : fragments) {
+    frag.serialize(ser);
+  }
+}
+
+void ShadowModelGroup::serialize(Serializer& ser) {
+  ser.from_pod_vector(&vertices);
+  if (ser.is_saving()) {
+    ser.save<size_t>(models.size());
+  } else {
+    models.resize(ser.load<size_t>());
+  }
+  for (auto& model : models) {
+    model.serialize(ser);
+  }
+}
+
 void Level::serialize(Serializer& ser) {
   ser.from_ptr(&version);
   if (ser.is_loading() && version != TFRAG3_VERSION) {
@@ -647,9 +683,9 @@ void Level::serialize(Serializer& ser) {
   }
 
   hfrag.serialize(ser);
-
   collision.serialize(ser);
   merc_data.serialize(ser);
+  shadow_data.serialize(ser);
 
   ser.from_ptr(&version2);
   if (ser.is_loading() && version2 != TFRAG3_VERSION) {
@@ -770,6 +806,10 @@ void Hfragment::memory_usage(tfrag3::MemoryUsageTracker* tracker) const {
   tracker->add(MemoryUsageCategory::HFRAG_CORNERS, corners.size() * sizeof(HfragmentCorner));
 }
 
+void ShadowModelGroup::memory_usage(MemoryUsageTracker* tracker) const {
+  tracker->add(SHADOW_VERTS, vertices.size() * sizeof(ShadowVertex));
+}
+
 void Level::memory_usage(MemoryUsageTracker* tracker) const {
   for (const auto& texture : textures) {
     texture.memory_usage(tracker);
@@ -793,6 +833,7 @@ void Level::memory_usage(MemoryUsageTracker* tracker) const {
   hfrag.memory_usage(tracker);
   collision.memory_usage(tracker);
   merc_data.memory_usage(tracker);
+  shadow_data.memory_usage(tracker);
 }
 
 void print_memory_usage(const tfrag3::Level& lev, int uncompressed_data_size) {
@@ -837,8 +878,9 @@ void print_memory_usage(const tfrag3::Level& lev, int uncompressed_data_size) {
       {"hfrag-verts", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_VERTS]},
       {"hfrag-index", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_INDEX]},
       {"hfrag-time-of-day", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_TIME_OF_DAY]},
-      {"hfrag-corners", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_CORNERS]}
-
+      {"hfrag-corners", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_CORNERS]},
+      {"shadow-vert", mem_use.data[SHADOW_VERTS]},
+      {"shadow-ind", mem_use.data[SHADOW_INDEX]},
   };
   for (auto& known : known_categories) {
     total_accounted += known.second;

common/custom_data/Tfrag3Data.h

@@ -18,7 +18,7 @@ namespace tfrag3 {
 // - if changing any large things (vertices, vis, bvh, colors, textures) update get_memory_usage
 // - if adding a new category to the memory usage, update extract_level to print it.
 
-constexpr int TFRAG3_VERSION = 43;
+constexpr int TFRAG3_VERSION = 44;
 
 enum MemoryUsageCategory {
   TEXTURE,
@@ -66,6 +66,9 @@ enum MemoryUsageCategory {
   HFRAG_TIME_OF_DAY,
   HFRAG_CORNERS,
 
+  SHADOW_VERTS,
+  SHADOW_INDEX,
+
   COLLISION,
 
   NUM_CATEGORIES
@@ -614,7 +617,48 @@ struct MercModelGroup {
   void memory_usage(MemoryUsageTracker* tracker) const;
 };
 
-//
+struct ShadowVertex {
+  float pos[3];
+  float weight;
+  u8 mats[2];
+  u8 flags;
+};
+static_assert(sizeof(ShadowVertex) == 20);
+
+struct ShadowTri {
+  u8 verts[3];
+};
+
+struct ShadowEdge {
+  u8 ind[2];
+  u8 tri[2];
+};
+
+struct ShadowModelFragment {
+  std::vector<ShadowTri> single_tris, double_tris;
+  std::vector<ShadowEdge> single_edges, double_edges;
+  u32 first_vertex;
+  u32 num_one_bone_vertices;
+  u32 num_two_bone_vertices;
+  void serialize(Serializer& ser);
+};
+
+struct ShadowModel {
+  static constexpr int kMaxVertices = 254;
+  static constexpr int kMaxTris = 254;
+  std::string name;
+  u32 max_bones;
+  std::vector<ShadowModelFragment> fragments;
+
+  void serialize(Serializer& ser);
+};
+
+struct ShadowModelGroup {
+  std::vector<ShadowVertex> vertices;
+  std::vector<ShadowModel> models;
+  void serialize(Serializer& ser);
+  void memory_usage(MemoryUsageTracker* tracker) const;
+};
 
 constexpr int TFRAG_GEOS = 3;
 constexpr int TIE_GEOS = 4;
@@ -630,6 +674,7 @@ struct Level {
   Hfragment hfrag;
   CollisionMesh collision;
   MercModelGroup merc_data;
+  ShadowModelGroup shadow_data;
   u16 version2 = TFRAG3_VERSION;
   void serialize(Serializer& ser);
   void memory_usage(MemoryUsageTracker* tracker) const;

decompiler/CMakeLists.txt

@@ -62,6 +62,7 @@ add_library(
         level_extractor/extract_joint_group.cpp
         level_extractor/extract_level.cpp
         level_extractor/extract_merc.cpp
+        level_extractor/extract_shadow.cpp
         level_extractor/extract_tfrag.cpp
         level_extractor/extract_tie.cpp
         level_extractor/extract_shrub.cpp

decompiler/level_extractor/extract_level.cpp

@@ -3,6 +3,8 @@
 #include <set>
 #include <thread>
 
+#include "extract_shadow.h"
+
 #include "common/log/log.h"
 #include "common/util/FileUtil.h"
 #include "common/util/SimpleThreadGroup.h"
@@ -129,6 +131,7 @@ void extract_art_groups_from_level(const ObjectFileDB& db,
         extract_merc(ag_file, tex_db, db.dts, tex_remap, level_data, false, db.version(),
                      swapped_info);
         extract_joint_group(ag_file, db.dts, db.version(), art_group_data);
+        extract_shadow(ag_file, db.dts, level_data, false, db.version());
       }
     }
   }