wip

common/custom_data/TFrag3Data.cpp

@@ -587,6 +587,28 @@ void MercModelGroup::serialize(Serializer& ser) {
   ser.from_pod_vector(&vertices);
 }
 
+void ShadowModel::serialize(Serializer& ser) {
+  ser.from_str(&name);
+  ser.from_ptr(&max_bones);
+  ser.from_ptr(&single_tris);
+  ser.from_ptr(&double_tris);
+  ser.from_ptr(&single_edges);
+  ser.from_ptr(&double_edges);
+}
+
+void ShadowModelGroup::serialize(Serializer& ser) {
+  ser.from_pod_vector(&vertices);
+  ser.from_pod_vector(&indices);
+  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 +669,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 +792,11 @@ 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));
+  tracker->add(SHADOW_INDEX, indices.size() * sizeof(u32));
+}
+
 void Level::memory_usage(MemoryUsageTracker* tracker) const {
   for (const auto& texture : textures) {
     texture.memory_usage(tracker);
@@ -793,6 +820,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 +865,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,33 @@ struct MercModelGroup {
   void memory_usage(MemoryUsageTracker* tracker) const;
 };
 
-//
+struct ShadowVertex {
+  float pos[3];
+  float weight;
+  u8 mats[2];
+  u8 flags;
+};
+
+struct ShadowModel {
+  std::string name;
+  u32 max_bones;
+
+  struct Run {
+    u32 first_index;
+    u32 count;
+  };
+  Run single_tris, double_tris, single_edges, double_edges;
+
+  void serialize(Serializer& ser);
+};
+
+struct ShadowModelGroup {
+  std::vector<ShadowVertex> vertices;
+  std::vector<u32> indices;
+  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 +659,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;