Rewrite of exporting system, much more human friendly error messages. Levels now consist of multiple rooms

art/Exporter.py

@@ -5,14 +5,14 @@ import shutil
 import struct
 from mathutils import *; from math import *
 from bpy_extras.io_utils import (axis_conversion)
+from dataclasses import dataclass
 
 C = bpy.context
 D = bpy.data
 
-LEVEL_EXPORT_NAME = "level"
+ROOMS_EXPORT_NAME = "rooms"
 EXPORT_DIRECTORY = "../assets/exported_3d"
 
-print("\n\nLet's get it started")
 
 if os.path.exists(bpy.path.abspath(f"//{EXPORT_DIRECTORY}")):
     shutil.rmtree(bpy.path.abspath(f"//{EXPORT_DIRECTORY}"))
@@ -63,11 +63,6 @@ def normalize_joint_weights(weights):
     return result
 
 # for the level.bin 
-level_object_data = []
-collision_cubes = []
-placed_entities = []
-saved_meshes = set()
-
 mapping = axis_conversion(
     from_forward = "Y",
     from_up = "Z",
@@ -76,10 +71,6 @@ mapping = axis_conversion(
 )
 mapping.resize_4x4()
 
-with open(bpy.path.abspath(f"//{EXPORT_DIRECTORY}/shorttest.bin"), "wb") as f:
-    for i in range(4):
-        write_u16(f, i)
-
 project_directory = bpy.path.abspath("//")
 def is_file_in_project(file_path):
     file_name = os.path.basename(file_path)
@@ -90,22 +81,24 @@ def is_file_in_project(file_path):
 
 saved_images = set()
 def ensure_tex_saved_and_get_name(o) -> str:
-    """returns the path to the mesh's texture's png in the exported directory"""
+    """returns the name of the mesh's texture's png in the exported directory, of the current object"""
+    assert o.type == "MESH", f"Object {o.name} isn't a mesh and is attempting to be saved as such"
     mesh_name = o.to_mesh().name
+    
+    # find the image object in the material of the object
     img_obj = None
-    assert len(o.material_slots) == 1, f"Don't know which material slot to pick from in mesh {mesh_name} object {o.name}"
+    assert len(o.material_slots) == 1, f"Don't know which material slot to pick from in mesh {mesh_name} object {o.name}, there must only be one material slot on every mesh"
     mat = o.material_slots[0]
     for node in mat.material.node_tree.nodes:
         if node.type == "TEX_IMAGE":
+            assert img_obj == None, f"Material on object {o.name} has more than one image node in its material, so I don't know which image node to use in the game engine. Make sure materials only use one image node"
             img_obj = node.image
-            break
     assert img_obj, f"Mesh {mesh_name} in its material doesn't have an image object"
     image_filename = f"{img_obj.name}.png"
     if image_filename in saved_images:
         pass
     else:
         save_to = f"//{EXPORT_DIRECTORY}/{image_filename}"
-        print(f"Saving image {image_filename} to {bpy.path.abspath((save_to))}...")
         if img_obj.packed_file:
             img_obj.save(filepath=bpy.path.abspath(save_to))
         else:
@@ -123,33 +116,45 @@ def ensure_tex_saved_and_get_name(o) -> str:
 
     return image_filename
 
+def export_armatures():
+    print("Exporting armatures...")
+    exported = D.collections.get("Exported")
+    assert exported != None, f"No exported collection named 'Exported' in scene, very bad! Did everything to get exported get deleted?"
 
-def object_in_collection(o, collection):
+    armatures_collection = exported.children.get("Armatures")
-    """Probably only works for root level collections"""
+    assert armatures_collection  != None, f"No child named 'Armatures' on the exported collection, this is required"
-    return o.users_collection[0].name == collection or (o.users_collection[0] in D.collections[collection].children_recursive)
 
-# meshes can either be Meshes, or Armatures. Armatures contain all mesh data to draw it, and any anims it has
+    A = armatures_collection
-for o in D.objects:
+    armatures_to_export = []
-    if o.hide_get(): continue
+    for o in A.objects:
         if o.type == "MESH":
-        if o.parent and o.parent.type == "ARMATURE":
+            assert o.parent, f"Mesh named {o.name} without parent in armatures collection is invalid, only armatures allowed in there!"
-            mesh_object = o
+            assert o.parent.type == "ARMATURE", f"Mesh named {o.name} isn't an armature, and isn't a child of an armature. This isn't allowed."
-            o = o.parent
+        elif o.type == "ARMATURE":
-            object_transform_info = (mesh_name, mapping @ o.location, o.rotation_euler, o.scale)
+            armatures_to_export.append(o)
-            if object_in_collection(o, "Level") or object_in_collection(o, "PlacedEntities"):
-                assert False, "Cannot put armatures in the level. The level is for static placed meshes. For dynamic entities, you put them outside of the level collection, their entity kind is encoded, and the game code decides how to draw them"
         else:
-                pass
+            assert False, f"Object named {o.name} is of an unknown type '{o.type}', only objects that are Meshes or Armature are allowed in the armatures collection"
-                #placed_entities.append((mesh_object.name,) + object_transform_info)
+
-            armature_name = o.data.name
+    for armature_object in armatures_to_export:
-            output_filepath = bpy.path.abspath(f"//{EXPORT_DIRECTORY}/{armature_name}.bin")
+        # get the body mesh object
-            image_filename = ensure_tex_saved_and_get_name(mesh_object)
+        body_object = None
-            print(f"Exporting armature with image filename {image_filename} to {output_filepath}")
+        for c in armature_object.children:
+            if c.name.startswith("Body"):
+                assert body_object == None, f"On object {armature_object.name}, more than one child has a name that starts with 'Body', specifically '{body_object.name}' and '{c.name}', only one child's name is allowed to start with 'Body' in this object."
+                body_object = c
+        
+        # initialize important variables
+        mesh_object = body_object
+        armature_object = armature_object
+        output_filepath = bpy.path.abspath(f"//{EXPORT_DIRECTORY}/{armature_object.name}.bin")
+        mesh_image_filename = ensure_tex_saved_and_get_name(mesh_object)
+        #print(f"Exporting armature with image filename {mesh_image_filename} to {output_filepath}")
+
         with open(output_filepath, "wb") as f:
-                write_b8(f, True)
+            write_b8(f, True) # first byte is true if it's an armature file
-                write_string(f, image_filename)
+            write_string(f, mesh_image_filename)
             bones_in_armature = []
-                for b in o.data.bones:
+            for b in armature_object.data.bones:
                 bones_in_armature.append(b)
                 
             # the inverse model space pos of the bones
@@ -177,15 +182,15 @@ for o in D.objects:
             
             # it's very important that the array of pose bones contains the same amount of bones
             # as there are in the edit bones. Because the edit bones are exported, etc etc. Cowabunga!
-                assert(len(o.pose.bones) == len(bones_in_armature))
+            assert(len(armature_object.pose.bones) == len(bones_in_armature))
 
-                armature = o
+            armature = armature_object
             anims = []
             assert armature.animation_data, "Armatures are assumed to have an animation right now"
             for track in armature.animation_data.nla_tracks:
                 for strip in track.strips:
                     anims.append(strip.action)
-                print(f"Writing {len(anims)} animations")
+            #print(f"Writing {len(anims)} animations")
             write_u64(f, len(anims))
             for animation in anims:
                 write_string(f, animation.name)
@@ -195,7 +200,7 @@ for o in D.objects:
                 startFrame = int(animation.frame_range.x)
                 endFrame = int(animation.frame_range.y)
                 total_frames = (endFrame - startFrame) + 1 # the end frame is inclusive
-                    print(f"Exporting animation {animation.name} with {total_frames} frames")
+                #print(f"Exporting animation {animation.name} with {total_frames} frames")
                 
                 write_u64(f, total_frames)
                 
@@ -205,8 +210,8 @@ for o in D.objects:
                     bpy.context.scene.frame_set(frame)
 
                     write_f32(f, time_through_this_frame_occurs_at)
-                        for pose_bone_i in range(len(o.pose.bones)):
+                    for pose_bone_i in range(len(armature_object.pose.bones)):
-                            pose_bone = o.pose.bones[pose_bone_i]
+                        pose_bone = armature_object.pose.bones[pose_bone_i]
                         
                         # in the engine, it's assumed that the poses are in the same order as the bones
                         # they're referring to. This checks that that is the case.
@@ -218,11 +223,7 @@ for o in D.objects:
                             parent_space_pose = pose_bone.parent.matrix.inverted() @ pose_bone.matrix
                         else:
                             parent_space_pose = mapping @ pose_bone.matrix
-                                #parent_space_pose = pose_bone.matrix
-                                #print("parent_space_pose of the bone with no parent:")
-                                #print(parent_space_pose)
 
-                            #parent_space_pose = mapping @ pose_bone.matrix
                         translation = parent_space_pose.to_translation()
                         rotation = parent_space_pose.to_quaternion()
                         scale = parent_space_pose.to_scale()
@@ -242,7 +243,7 @@ for o in D.objects:
             
             
             vertices = []
-                armature = o
+            armature = armature_object
             for polygon in mesh.polygons:
                 if len(polygon.loop_indices) == 3:
                     for loopIndex in polygon.loop_indices:
@@ -283,44 +284,149 @@ for o in D.objects:
                 for i in range(4):
                     write_f32(f, jointWeights[i])
                 vertex_i += 1
-                print(f"Wrote {len(vertices)} vertices")
+            #print(f"Wrote {len(vertices)} vertices")
+    print("Success!")
+
+def collect_and_validate_mesh_objects(collection_with_only_mesh_objects):
+    to_return = []
+
+    for o in collection_with_only_mesh_objects.all_objects:
+        assert o.type == "MESH", f"The collection '{collection_with_only_mesh_objects.name}' is assumed to contain only mesh objects but the object '{o.name}' which is a child of it isn't a mesh object"
+        to_return.append(o)
+
+    return to_return
+
+def get_startswith(name_of_overarching_thing, iterable, starts_with):
+    """
+    Gets the thing in iterable that starts with starts with, and makes sure there's only *one* thing that starts with starts with
+    name_of_overarching_thing is for the error message, for reporting in what collection things went wrong in.
+    """
+    to_return = None
+    for thing in iterable:
+        if thing.name.startswith(starts_with):
+            assert to_return == None, f"Duplicate thing that starts with '{starts_with}' found in {name_of_overarching_thing} called {thing.name}"
+            to_return = thing
+    assert to_return != None, f"Couldn't find thing that starts with '{starts_with}' as a child of '{name_of_overarching_thing}', but one is required"
+    return to_return
+
+def no_hidden(objects):
+    to_return = []
+    for o in objects:
+        if not o.hide_get():
+            to_return.append(o)
+    return to_return
+
+def export_meshes_and_levels():
+    print("Exporting meshes and levels")
+    exported = D.collections.get("Exported")
+    assert exported != None, f"No exported collection named 'Exported' in scene, very bad! Did everything to get exported get deleted?"
+
+    mesh_names_to_export = set()
+    meshes_to_export = []
+
+    # add the collection 'Meshes' objects to mesh_objects_to_export 
+    if True:
+        meshes = get_startswith("Exported", exported.children, "Meshes")
+        to_export = collect_and_validate_mesh_objects(meshes)
+        for m in no_hidden(to_export):
+            mesh_names_to_export.add(m.name)
+            meshes_to_export.append(m)
+
+    # export each level: its placed entities, placed meshes, and add to meshes_to_export and mesh_names_to_export. Those must be exported to their correct paths for the rooms to point at valid data.
+    rooms = exported.children.get("Rooms")
+    assert rooms != None, f"No child named 'Rooms' on the exported collection, this is required"
+    with open(bpy.path.abspath(f"//{EXPORT_DIRECTORY}/{ROOMS_EXPORT_NAME}.bin"), "wb") as f:
+        write_u64(f, len(rooms.children))
+        for room_collection in rooms.children:
+            write_string(f, room_collection.name) # the name of the room is the name of the room collection
+
+            # placed meshes (exported mesh name (which is the object's name), location, rotation, scale)
+            placed_meshes = []
+            if True:
+                meshes_collection = get_startswith(room_collection.name, room_collection.children, "Meshes")
+                for m in no_hidden(meshes_collection.objects):
+                    assert m.rotation_euler.order == 'XYZ', f"Invalid rotation euler order for object of name '{m.name}', it's {m.rotation_euler.order} but must be XYZ"
+                    assert m.type == "MESH", f"In meshes collection '{meshes_collection.name}' object {m.name} must be of type 'MESH' but instead is of type {m.type}"
+                    if not m.name in mesh_names_to_export:
+                        mesh_names_to_export.add(m.name)
+                        meshes_to_export.append(m)
+                    placed_meshes.append((m.name, mapping @ m.location, m.rotation_euler, m.scale))
+
+            # colliders (location, dimensions)
+            placed_colliders = []
+            if True:
+                colliders_collection = get_startswith(room_collection.name, room_collection.children, "Colliders")
+                for o in no_hidden(colliders_collection.objects):
+                    assert o.name.startswith("CollisionCube"), f"Object {o.name} doesn't start with 'CollisionCube' and it's in the Colliders group of room {room_collection.name}, colliders must be collision cubes"
+                    placed_colliders.append((o.location, o.dimensions))
+
+            # fill out placed_entities with a tuple of (name, location, rotation, scale)
+            placed_entities = []
+            if True:
+                entities_collection = get_startswith(room_collection.name, room_collection.children, "Entities")
 
-        else: # if the parent type isn't an armature, i.e just a bog standard mesh
+                for o in no_hidden(entities_collection.objects):
-            mesh_name = o.to_mesh().name # use this over o.name so instanced objects which refer to the same mesh, both use the same serialized mesh.
+                    assert o.rotation_euler.order == 'XYZ', f"Invalid rotation euler order for object of name '{o.name}', it's {o.rotation_euler.order} but must be XYZ"
+                    placed_entities.append((o.name, mapping @ o.location, o.rotation_euler, o.scale))
 
-            object_transform_info = (mesh_name, mapping @ o.location, o.rotation_euler, o.scale)
 
-            if object_in_collection(o, "Level") and mesh_name == "CollisionCube":
+            write_u64(f, len(placed_meshes))
-                collision_cubes.append((o.location, o.dimensions))
+            for p in placed_meshes:
-            else:
+                mesh_name, blender_pos, blender_rotation, blender_scale = p
-                if object_in_collection(o, "Level"):
+                write_string(f, mesh_name)
-                    print(f"Object {o.name} has mesh name {o.to_mesh().name}")
+                write_f32(f, blender_pos.x)
-                    assert(o.rotation_euler.order == 'XYZ')
+                write_f32(f, blender_pos.y)
-                    level_object_data.append(object_transform_info)
+                write_f32(f, blender_pos.z)
-                elif object_in_collection(o, "PlacedEntities"):
+                write_f32(f, blender_rotation.x)
-                    placed_entities.append((o.name,) + object_transform_info)
+                write_f32(f, blender_rotation.y)
-                
+                write_f32(f, blender_rotation.z)
-                if mesh_name in saved_meshes:
+                write_f32(f, blender_scale.x)
-                    continue
+                write_f32(f, blender_scale.y)
-                saved_meshes.add(mesh_name)
+                write_f32(f, blender_scale.z)
-                print(f"""Mesh name {mesh_name} in level {object_in_collection(o, "Level")} collections {o.users_collection}""")
+
-                image_filename = ensure_tex_saved_and_get_name(o)
+            write_u64(f, len(placed_colliders))
-                
+            for c in placed_colliders:
-                assert(mesh_name != LEVEL_EXPORT_NAME)
+                blender_pos, blender_dims = c
+                write_f32(f,  blender_pos.x)
+                write_f32(f, -blender_pos.y)
+                write_f32(f, blender_dims.x)
+                write_f32(f, blender_dims.y)
+                assert blender_dims.x > 0.0
+                assert blender_dims.y > 0.0
+            
+            write_u64(f, len(placed_entities))
+            for e in placed_entities:
+                entity_name, blender_pos, blender_rotation, blender_scale = e
+                write_string(f, entity_name)
+                write_f32(f, blender_pos.x)
+                write_f32(f, blender_pos.y)
+                write_f32(f, blender_pos.z)
+                write_f32(f, blender_rotation.x)
+                write_f32(f, blender_rotation.y)
+                write_f32(f, blender_rotation.z)
+                write_f32(f, blender_scale.x)
+                write_f32(f, blender_scale.y)
+                write_f32(f, blender_scale.z)
+
+    # export all the meshes that the rooms file is referring to, and all the meshes that just need to be plain exported
+    for m in meshes_to_export:
+        assert o.type == "MESH"
+        assert o.parent == None, f"Mesh '{m.name}' has a parent, but exporting mesh objects with parents isn't supported"
+        mesh_name = m.name
+        image_filename = ensure_tex_saved_and_get_name(m)
         output_filepath = bpy.path.abspath(f"//{EXPORT_DIRECTORY}/{mesh_name}.bin")
-                print(f"Exporting mesh to {output_filepath} with image_filename {image_filename}")
         with open(output_filepath, "wb") as f:
             write_b8(f, False) # if it's an armature or not, first byte of the file
-                    write_string(f, image_filename) # the image filename!
+            write_string(f, image_filename)
 
             bm = bmesh.new()
-                    mesh = o.to_mesh()
+            mesh = m.to_mesh()
+            assert len(mesh.uv_layers) == 1, f"Mesh object {m.name} has more than 1 uv layer, which isn't allowed"
             bm.from_mesh(mesh)
             bmesh.ops.triangulate(bm, faces=bm.faces)
             bm.transform(mapping)
             bm.to_mesh(mesh)
             
-                    
             vertices = []
 
             for polygon in mesh.polygons:
@@ -334,7 +440,6 @@ for o in D.objects:
                         vertices.append((position, uv))
             
             write_u64(f, len(vertices))
-                    print(f"\n\n{output_filepath} vertices:")
             for v_and_uv in vertices:
                 v, uv = v_and_uv
                 write_f32(f, v.x)
@@ -342,53 +447,8 @@ for o in D.objects:
                 write_f32(f, v.z)
                 write_f32(f, uv.x)
                 write_f32(f, uv.y)
-                        if len(vertices) < 100:
+    print("Success!")
-                            print(v)
-                    print(f"Wrote {len(vertices)} vertices")
-
-with open(bpy.path.abspath(f"//{EXPORT_DIRECTORY}/{LEVEL_EXPORT_NAME}.bin"), "wb") as f:
-    write_u64(f, len(level_object_data))
-    for o in level_object_data:
-        mesh_name, blender_pos, blender_rotation, blender_scale = o
-        print(f"Writing instanced object of mesh {mesh_name}")
-        write_string(f, mesh_name)
-        write_f32(f, blender_pos.x)
-        write_f32(f, blender_pos.y)
-        write_f32(f, blender_pos.z)
 
-        write_f32(f, blender_rotation.x)
-        write_f32(f, blender_rotation.y)
-        write_f32(f, blender_rotation.z)
-        
-        write_f32(f, blender_scale.x)
-        write_f32(f, blender_scale.y)
-        write_f32(f, blender_scale.z)
-    
-    write_u64(f, len(collision_cubes))
-    for c in collision_cubes:
-        blender_pos, blender_dims = c
-        write_f32(f,  blender_pos.x)
-        write_f32(f, -blender_pos.y)
-        write_f32(f, blender_dims.x)
-        write_f32(f, blender_dims.y)
-        assert(blender_dims.x > 0.0)
-        assert(blender_dims.y > 0.0)
-    
-    write_u64(f, len(placed_entities))
-    for p in placed_entities:
-        # underscore is mesh name, prefer object name for name of npc. More obvious
-        object_name, _, blender_pos, blender_rotation, blender_scale = p
-        print(f"Writing placed entity '{object_name}'")
-        write_string(f, object_name)
-        write_f32(f, blender_pos.x)
-        write_f32(f, blender_pos.y)
-        write_f32(f, blender_pos.z)
-        
-        write_f32(f, blender_rotation.x)
-        write_f32(f, blender_rotation.y)
-        write_f32(f, blender_rotation.z)
-        
-        write_f32(f, blender_scale.x)
-        write_f32(f, blender_scale.y)
-        write_f32(f, blender_scale.z)
 
+export_armatures()
+export_meshes_and_levels()

main.c

@@ -1250,14 +1250,37 @@ typedef struct CollisionCylinder
 	Circle bounds;
 } CollisionCylinder;
 
-typedef struct
+typedef struct Room
 {
-	Mesh *mesh_list;
+	struct Room *next;
+
+	MD_String8 name;
 	PlacedMesh *placed_mesh_list;
 	CollisionCylinder *collision_list;
 	PlacedEntity *placed_entity_list;
+} Room;
+
+typedef struct
+{
+	Mesh *mesh_list;
+	Room *room_list;
 } ThreeDeeLevel;
 
+Room *get_cur_room(ThreeDeeLevel *level)
+{
+	Room *in_room = 0;
+	for(Room *cur = level->room_list; cur; cur = cur->next)
+	{
+		if(MD_S8Match(cur->name, MD_S8Lit("Forest"), 0))
+		{
+			in_room = cur;
+			break;
+		}
+	}
+	assert(in_room);
+	return in_room;
+}
+
 void ser_BlenderTransform(SerState *ser, BlenderTransform *t)
 {
 	ser_Vec3(ser, &t->pos);
@@ -1298,6 +1321,14 @@ ThreeDeeLevel load_level(MD_Arena *arena, MD_String8 binary_file)
 	};
 	ThreeDeeLevel out = {0};
 
+	MD_u64 num_rooms = 0;
+	ser_MD_u64(&ser, &num_rooms);
+
+	for(MD_u64 i = 0; i < num_rooms; i++)
+	{
+		Room *new_room = MD_PushArray(arena, Room, 1);
+		ser_MD_String8(&ser, &new_room->name, arena);
+
 		// placed meshes
 		{
 			MD_u64 num_placed = 0;
@@ -1315,12 +1346,11 @@ ThreeDeeLevel load_level(MD_Arena *arena, MD_String8 binary_file)
 
 				new_placed->t = blender_to_game_transform(blender_transform);
 
-			MD_StackPush(out.placed_mesh_list, new_placed);
+				MD_StackPush(new_room->placed_mesh_list, new_placed);
 
 				// Log("Placed mesh '%.*s' pos %f %f %f rotation %f %f %f %f scale %f %f %f\n", MD_S8VArg(placed_mesh_name), v3varg(new_placed->t.offset), qvarg(new_placed->t.rotation), v3varg(new_placed->t.scale));
 
 				// load the mesh if we haven't already
-
 				bool mesh_found = false;
 				for (Mesh *cur = out.mesh_list; cur; cur = cur->next)
 				{
@@ -1364,7 +1394,7 @@ ThreeDeeLevel load_level(MD_Arena *arena, MD_String8 binary_file)
 			ser_Vec2(&ser, &size);
 			new_cylinder->bounds.center = twodee_pos;
 			new_cylinder->bounds.radius = (size.x + size.y) * 0.5f; // @TODO(Phillip): @Temporary
-		MD_StackPush(out.collision_list, new_cylinder);
+			MD_StackPush(new_room->collision_list, new_cylinder);
 		}
 
 		// placed entities
@@ -1378,7 +1408,6 @@ ThreeDeeLevel load_level(MD_Arena *arena, MD_String8 binary_file)
 				MD_String8 placed_entity_name = {0};
 				ser_MD_String8(&ser, &placed_entity_name, scratch.arena);
 
-
 				bool found = false;
 				ARR_ITER_I(CharacterGen, characters, kind)
 				{
@@ -1393,7 +1422,7 @@ ThreeDeeLevel load_level(MD_Arena *arena, MD_String8 binary_file)
 				if (found)
 				{
 					new_placed->t = blender_to_game_transform(blender_transform);
-				MD_StackPush(out.placed_entity_list, new_placed);
+					MD_StackPush(new_room->placed_entity_list, new_placed);
 				}
 				else
 				{
@@ -1404,6 +1433,8 @@ ThreeDeeLevel load_level(MD_Arena *arena, MD_String8 binary_file)
 			}
 		}
 
+		MD_StackPush(out.room_list, new_room);
+	}
 
 	assert(!ser.cur_error.failed);
 	MD_ReleaseScratch(scratch);
@@ -2095,8 +2126,10 @@ void initialize_gamestate_from_threedee_level(GameState *gs, ThreeDeeLevel *leve
 {
 	memset(gs, 0, sizeof(GameState));
 
+	Room *in_room = get_cur_room(level);
+
 	bool found_player = false;
-	for(PlacedEntity *cur = level->placed_entity_list; cur; cur = cur->next)
+	for(PlacedEntity *cur = in_room->placed_entity_list; cur; cur = cur->next)
 	{
 		Entity *cur_entity = new_entity(gs);
 		cur_entity->npc_kind = cur->npc_kind;
@@ -3168,7 +3201,6 @@ Armature *armatures[] = {
 	&angel_armature,
 };
 
-Mesh mesh_player = {0};
 Mesh mesh_simple_worm = {0};
 Mesh mesh_shotgun = {0};
 
@@ -3251,17 +3283,14 @@ void init(void)
 
 	MD_String8 binary_file;
 
-	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/level.bin"));
+	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/rooms.bin"));
 	level_threedee = load_level(persistent_arena, binary_file);
 
-	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/ExportedWithAnims.bin"));
+	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/Shotgun.bin"));
-	mesh_player = load_mesh(persistent_arena, binary_file, MD_S8Lit("ExportedWithAnims.bin"));
+	mesh_shotgun = load_mesh(persistent_arena, binary_file, MD_S8Lit("Shotgun.bin"));
-
-	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/ShotgunMesh.bin"));
-	mesh_shotgun = load_mesh(persistent_arena, binary_file, MD_S8Lit("ShotgunMesh.bin"));
 
-	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/ArmatureExportedWithAnims.bin"));
+	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/NormalGuyArmature.bin"));
-	player_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("ArmatureExportedWithAnims.bin"));
+	player_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("NormalGuyArmature.bin"));
 
 	man_in_black_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("Man In Black"));
 	man_in_black_armature.image = image_man_in_black;
@@ -3269,8 +3298,8 @@ void init(void)
 	angel_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("Angel"));
 	angel_armature.image = image_angel;
 
-	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/Farmer.bin"));
+	binary_file = MD_LoadEntireFile(frame_arena, MD_S8Lit("assets/exported_3d/FarmerArmature.bin"));
-	farmer_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("Farmer.bin"));
+	farmer_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("FarmerArmature.bin"));
 
 	shifted_farmer_armature = load_armature(persistent_arena, binary_file, MD_S8Lit("Farmer.bin"));
 	shifted_farmer_armature.image = image_shifted_farmer;
@@ -4517,7 +4546,7 @@ Vec2 move_and_slide(MoveSlideParams p)
 	BUFF(CollisionObj, 256) to_check = { 0 };
 
 	// add world boxes
-	for(CollisionCylinder *cur = level_threedee.collision_list; cur; cur = cur->next)
+	for(CollisionCylinder *cur = get_cur_room(&level_threedee)->collision_list; cur; cur = cur->next)
 	{
 		BUFF_APPEND(&to_check, ((CollisionObj){cur->bounds, gs.world_entity}));
 	}
@@ -5632,7 +5661,7 @@ void frame(void)
 
 		// @Place(draw 3d things)
 
-		for(PlacedMesh *cur = level_threedee.placed_mesh_list; cur; cur = cur->next)
+		for(PlacedMesh *cur = get_cur_room(&level_threedee)->placed_mesh_list; cur; cur = cur->next)
 		{
 			float seed = (float)((int64_t)cur % 1024);
 

todo.txt

@@ -1,9 +1,9 @@
 Urgent:
+- room system where characters can go to rooms. camera constrained to room bounds, and know which rooms are near them to go to
 - REALLY look into characters not being able to shoot eachother
 - Silent threshold for each character from 0 to 1 that controls random chance after every eavesdropped dialog that the character says nothing in response
 - Tag memories from drama as permanent so they're never forgotten and always seed character behavior
 - gman character that gives you randomized goals such as (kill so and so) or (befriend blank) or (get john to go to other room), and decides itself with gpt when you're done with the game, when you've 'learned your lesson'.
-- room system where characters can go to rooms. camera constrained to room bounds, and know which rooms are near them to go to
 - make them understand they're holding their shotgun more
 - Fix everything about the shotgun, put shotgun away  
 - can't interact with characters while they're thinking