Move serialize code into a single file

src/decor/decor_object_list.c

@@ -117,4 +117,14 @@ struct DecorObjectDefinition* decorObjectDefinitionForId(int id) {
     }
 
     return &gDecorObjectDefinitions[id];
+}
+
+int decorIdForObjectDefinition(struct DecorObjectDefinition* def) {
+    int result = def - gDecorObjectDefinitions;
+
+    if (result < 0 || result >= sizeof(gDecorObjectDefinitions) / sizeof(*gDecorObjectDefinitions)) {
+        return -1;
+    }
+
+    return result;
 }

src/decor/decor_object_list.h

@@ -10,5 +10,6 @@
 #define DECOR_TYPE_AUTOPORTAL_FRAME     4
 
 struct DecorObjectDefinition* decorObjectDefinitionForId(int id);
+int decorIdForObjectDefinition(struct DecorObjectDefinition* def);
 
 #endif

src/levels/cutscene_runner.c

@@ -477,6 +477,7 @@ void cutsceneSerializeWrite(struct Serializer* serializer, SerializeAction actio
             action(serializer, &curr->soundId, sizeof(u16));
             u8 volume = (u8)(clampf(curr->volume, 0.0f, 1.0f) * 255.0f);
             action(serializer, &volume, sizeof(volume));
+            curr = curr->next;
         }
 
         s16 noSound = SOUND_ID_NONE;
@@ -506,6 +507,7 @@ void cutsceneSerializeRead(struct Serializer* serializer) {
             u8 volume;
             serializeRead(serializer, &volume, sizeof(volume));
             cutsceneQueueSound(nextId, volume * (1.0f / 255.0f), i);
+            serializeRead(serializer, &nextId, sizeof(nextId));
         }
     }
 }

src/menu/save_game_menu.c

@@ -48,6 +48,8 @@ void saveGamePopulate(struct SaveGameMenu* saveGame, int includeNew) {
 
     if (startSelection == -1) {
         saveGame->savefileList->selectedSave = numberOfSaves - 1;
+    } else {
+        saveGame->savefileList->selectedSave = startSelection;
     }
 }
 

src/player/player.c

@@ -820,19 +820,3 @@ void playerUpdate(struct Player* player, struct Transform* cameraTransform) {
     }
 
 }
-
-
-void playerSerialize(struct Serializer* serializer, SerializeAction action, struct Player* player) {
-    action(serializer, &player->lookTransform, sizeof(struct PartialTransform));
-    action(serializer, &player->body.velocity, sizeof(player->body.velocity));
-    action(serializer, &player->flags, sizeof(player->flags));
-}
-
-void playerDeserialize(struct Serializer* serializer, struct Player* player) {
-    serializeRead(serializer, &player->lookTransform, sizeof(struct PartialTransform));
-    player->body.transform.position = player->lookTransform.position;
-    player->body.velocity = gZeroVec;
-
-    serializeRead(serializer, &player->body.velocity, sizeof(player->body.velocity));
-    serializeRead(serializer, &player->flags, sizeof(player->flags));
-}

src/player/player.h

@@ -10,7 +10,6 @@
 #include "../sk64/skelatool_animator.h"
 #include "../sk64/skelatool_armature.h"
 #include "../physics/point_constraint.h"
-#include "../savefile/serializer.h"
 
 #define PLAYER_GRABBING_THROUGH_NOTHING -1
 

src/savefile/checkpoint.c

@@ -3,6 +3,7 @@
 #include "../util/memory.h"
 #include "../levels/cutscene_runner.h"
 #include "../levels/levels.h"
+#include "./scene_serialize.h"
 #include "serializer.h"
 
 char gHasCheckpoint = 0;
@@ -13,8 +14,7 @@ void ckeckpointSerialize(struct Serializer* serializer, SerializeAction action,
 
     signalsSerializeRW(serializer, action);
     cutsceneSerializeWrite(serializer, action);
-    playerSerialize(serializer, action, &scene->player);
-    sceneSerializePortals(serializer, action, scene);
+    sceneSerialize(serializer, action, scene);
 }
 
 void checkpointDeserialize(struct Serializer* serializer, void* data) {
@@ -22,8 +22,7 @@ void checkpointDeserialize(struct Serializer* serializer, void* data) {
 
     signalsSerializeRW(serializer, serializeRead);
     cutsceneSerializeRead(serializer);
-    playerDeserialize(serializer, &scene->player);
-    sceneDeserializePortals(serializer, scene);
+    sceneDeserialize(serializer, scene);
 }
 
 int checkpointEstimateSize(struct Scene* scene) {

src/savefile/checkpoint.h

@@ -7,11 +7,6 @@ typedef void* Checkpoint;
 
 #define MAX_CHECKPOINT_SIZE 2048
 
-struct PartialTransform {
-    struct Vector3 position;
-    struct Quaternion rotation;
-};
-
 void checkpointClear();
 void checkpointUse(Checkpoint checkpoint);
 void checkpointSave(struct Scene* scene);

src/savefile/scene_serialize.c

@@ -0,0 +1,215 @@
+#include "./scene_serialize.h"
+
+#include "../physics/collision_scene.h"
+#include "../decor/decor_object_list.h"
+#include "../util/memory.h"
+#include "../levels/levels.h"
+
+void playerSerialize(struct Serializer* serializer, SerializeAction action, struct Player* player) {
+    action(serializer, &player->lookTransform, sizeof(struct PartialTransform));
+    action(serializer, &player->body.velocity, sizeof(player->body.velocity));
+    action(serializer, &player->body.currentRoom, sizeof(player->body.currentRoom));
+    action(serializer, &player->flags, sizeof(player->flags));
+}
+
+void playerDeserialize(struct Serializer* serializer, struct Player* player) {
+    serializeRead(serializer, &player->lookTransform, sizeof(struct PartialTransform));
+    player->body.transform.position = player->lookTransform.position;
+    player->body.velocity = gZeroVec;
+
+    serializeRead(serializer, &player->body.currentRoom, sizeof(player->body.currentRoom));
+    serializeRead(serializer, &player->body.velocity, sizeof(player->body.velocity));
+    serializeRead(serializer, &player->flags, sizeof(player->flags));
+}
+
+void sceneSerializePortals(struct Serializer* serializer, SerializeAction action, struct Scene* scene) {
+    for (int portalIndex = 0; portalIndex < 2; ++portalIndex) {
+        if (!gCollisionScene.portalTransforms[portalIndex]) {
+            char flags = 0xFF;
+            action(serializer, &flags, sizeof(flags));
+            continue;
+        }
+
+        struct Portal* portal = &scene->portals[portalIndex];
+        char flags = portal->flags;
+        action(serializer, &flags, sizeof(flags));
+
+        action(serializer, &portal->transform, sizeof(struct PartialTransform));
+        action(serializer, &portal->portalSurfaceIndex, sizeof(portal->portalSurfaceIndex));
+        action(serializer, &portal->roomIndex, sizeof(portal->roomIndex));
+        action(serializer, &portal->transformIndex, sizeof(portal->transformIndex));
+
+        if (portal->transformIndex != NO_TRANSFORM_INDEX) {
+            action(serializer, &portal->relativePos, sizeof(portal->relativePos));
+        }
+    }
+}
+
+void sceneDeserializePortals(struct Serializer* serializer, struct Scene* scene) {
+    for (int portalIndex = 0; portalIndex < 2; ++portalIndex) {
+        char flags;
+        serializeRead(serializer, &flags, sizeof(flags));
+
+        if (flags == 0xFF) {
+            continue;
+        }
+
+        struct Portal* portal = &scene->portals[portalIndex];
+
+        struct Transform transform;
+        serializeRead(serializer, &transform, sizeof(struct PartialTransform));  
+        transform.scale = gOneVec;
+
+        short portalSurfaceIndex;
+        short roomIndex;
+        serializeRead(serializer, &portalSurfaceIndex, sizeof(portalSurfaceIndex));
+        serializeRead(serializer, &roomIndex, sizeof(roomIndex));
+
+        struct PortalSurface* existingSurface = portalSurfaceGetOriginalSurface(portalSurfaceIndex, portalIndex);
+
+        portalAttachToSurface(
+            portal, 
+            existingSurface, 
+            portalSurfaceIndex, 
+            &transform,
+            0
+        );
+
+        serializeRead(serializer, &portal->transformIndex, sizeof(portal->transformIndex));
+        if (portal->transformIndex != NO_TRANSFORM_INDEX) {
+            serializeRead(serializer, &portal->relativePos, sizeof(portal->relativePos));
+        }
+
+        portal->transform = transform;
+        gCollisionScene.portalVelocity[portalIndex] = gZeroVec;
+        portal->roomIndex = roomIndex;
+        portal->scale = 1.0f;
+        gCollisionScene.portalTransforms[portalIndex] = &portal->transform;
+        gCollisionScene.portalRooms[portalIndex] = roomIndex;
+
+        if (flags & PortalFlagsPlayerPortal) {
+            portal->flags |= PortalFlagsPlayerPortal;
+        } else {
+            portal->flags &= ~PortalFlagsPlayerPortal;
+        }
+
+        portal->opacity = 0.0f;
+    }
+}   
+
+void buttonsSerializeRW(struct Serializer* serializer, SerializeAction action, struct Button* buttons, int count) {
+    for (int i = 0; i < count; ++i) {
+        action(serializer, &buttons[i].rigidBody.transform.position.y, sizeof(float));
+        action(serializer, &buttons[i].flags, sizeof(buttons[i].flags));
+    }
+}
+
+void decorSerialize(struct Serializer* serializer, SerializeAction action, struct DecorObject** decor, int count) {
+    short countAsShort = 0;
+
+    for (int i = 0; i < count; ++i) {
+        struct DecorObject* entry = decor[i];
+        if (entry->definition->colliderType.type == CollisionShapeTypeNone) {
+            // non moving objects can be loaded from the level definition
+            continue;
+        }
+        
+        ++countAsShort;
+    }
+
+    action(serializer, &countAsShort, sizeof(short));
+
+    for (int i = 0; i < count; ++i) {
+        struct DecorObject* entry = decor[i];
+        if (entry->definition->colliderType.type == CollisionShapeTypeNone) {
+            // non moving objects can be loaded from the level definition
+            continue;
+        }
+
+        short id = decorIdForObjectDefinition(entry->definition);
+
+        action(serializer, &id, sizeof(short));
+
+        action(serializer, &entry->originalPosition, sizeof(struct Vector3));
+        action(serializer, &entry->originalRotation, sizeof(struct Quaternion));
+        action(serializer, &entry->originalRoom, sizeof(short));
+
+        action(serializer, &entry->rigidBody.transform, sizeof(struct PartialTransform));
+        action(serializer, &entry->rigidBody.velocity, sizeof(struct Vector3));
+        action(serializer, &entry->rigidBody.angularVelocity, sizeof(struct Vector3));
+        action(serializer, &entry->rigidBody.flags, sizeof(enum RigidBodyFlags));
+        action(serializer, &entry->rigidBody.currentRoom, sizeof(struct Vector3));
+    }
+}
+
+void decorDeserialize(struct Serializer* serializer, struct Scene* scene) {
+    if (scene->decor) {
+        for (int i = 0; i < scene->decorCount; ++i) {
+            decorObjectDelete(scene->decor[i]);
+        }
+        free(scene->decor);
+    }
+
+    scene->decorCount = 0;
+
+    short countAsShort;
+    serializeRead(serializer, &countAsShort, sizeof(short));
+
+    scene->decor = malloc(sizeof(struct DecorObject*) * (countAsShort + gCurrentLevel->decorCount));
+
+    for (int i = 0; i < countAsShort; ++i) {
+        short id;
+
+        serializeRead(serializer, &id, sizeof(short));
+
+        struct Transform transform;
+        short originalRoom;
+
+        serializeRead(serializer, &transform.position, sizeof(struct Vector3));
+        serializeRead(serializer, &transform.rotation, sizeof(struct Quaternion));
+        serializeRead(serializer, &originalRoom, sizeof(short));
+
+        struct DecorObject* entry = decorObjectNew(decorObjectDefinitionForId(id), &transform, originalRoom);
+
+        serializeRead(serializer, &entry->rigidBody.transform, sizeof(struct PartialTransform));
+        serializeRead(serializer, &entry->rigidBody.velocity, sizeof(struct Vector3));
+        serializeRead(serializer, &entry->rigidBody.angularVelocity, sizeof(struct Vector3));
+        serializeRead(serializer, &entry->rigidBody.flags, sizeof(enum RigidBodyFlags));
+        serializeRead(serializer, &entry->rigidBody.currentRoom, sizeof(struct Vector3));
+
+        scene->decor[i] = entry;
+    }
+
+    for (int i = 0; i < gCurrentLevel->decorCount; ++i) {
+        struct DecorDefinition* decorDef = &gCurrentLevel->decor[i];
+        struct DecorObjectDefinition* def = decorObjectDefinitionForId(decorDef->decorId);
+
+        if (def->colliderType.type != CollisionShapeTypeNone) {
+            // dynamic objects are serialized
+            continue;
+        }
+
+        struct Transform decorTransform;
+        decorTransform.position = decorDef->position;
+        decorTransform.rotation = decorDef->rotation;
+        decorTransform.scale = gOneVec;
+        scene->decor[countAsShort] = decorObjectNew(def, &decorTransform, decorDef->roomIndex);
+        ++countAsShort;
+    }
+
+    scene->decorCount = countAsShort;
+}
+
+void sceneSerialize(struct Serializer* serializer, SerializeAction action, struct Scene* scene) {
+    playerSerialize(serializer, action, &scene->player);
+    sceneSerializePortals(serializer, action, scene);
+    buttonsSerializeRW(serializer, action, scene->buttons, scene->buttonCount);
+    decorSerialize(serializer, action, scene->decor, scene->decorCount);
+}
+
+void sceneDeserialize(struct Serializer* serializer, struct Scene* scene) {
+    playerDeserialize(serializer, &scene->player);
+    sceneDeserializePortals(serializer, scene);
+    buttonsSerializeRW(serializer, serializeRead, scene->buttons, scene->buttonCount);
+    decorDeserialize(serializer, scene);
+}

src/savefile/scene_serialize.h

@@ -0,0 +1,15 @@
+#ifndef __SCENE_SERIALIZE_H__
+#define __SCENE_SERIALIZE_H__
+
+#include "../scene/scene.h"
+#include "./serializer.h"
+
+struct PartialTransform {
+    struct Vector3 position;
+    struct Quaternion rotation;
+};
+
+void sceneSerialize(struct Serializer* serializer, SerializeAction action, struct Scene* scene);
+void sceneDeserialize(struct Serializer* serializer, struct Scene* scene);
+
+#endif

src/scene/scene.c

@@ -123,16 +123,22 @@ void sceneInitNoPauseMenu(struct Scene* scene) {
         buttonInit(&scene->buttons[i], &gCurrentLevel->buttons[i]);
     }
 
-    scene->decorCount = gCurrentLevel->decorCount;
-    scene->decor = malloc(sizeof(struct DecorObject*) * scene->decorCount);
+    if (checkpointExists()) {
+        // if a checkpoint exists it will load the decor
+        scene->decorCount = 0;
+        scene->decor = NULL;
+    } else {
+        scene->decorCount = gCurrentLevel->decorCount;
+        scene->decor = malloc(sizeof(struct DecorObject*) * scene->decorCount);
 
-    for (int i = 0; i < scene->decorCount; ++i) {
-        struct DecorDefinition* decorDef = &gCurrentLevel->decor[i];
-        struct Transform decorTransform;
-        decorTransform.position = decorDef->position;
-        decorTransform.rotation = decorDef->rotation;
-        decorTransform.scale = gOneVec;
-        scene->decor[i] = decorObjectNew(decorObjectDefinitionForId(decorDef->decorId), &decorTransform, decorDef->roomIndex);
+        for (int i = 0; i < scene->decorCount; ++i) {
+            struct DecorDefinition* decorDef = &gCurrentLevel->decor[i];
+            struct Transform decorTransform;
+            decorTransform.position = decorDef->position;
+            decorTransform.rotation = decorDef->rotation;
+            decorTransform.scale = gOneVec;
+            scene->decor[i] = decorObjectNew(decorObjectDefinitionForId(decorDef->decorId), &decorTransform, decorDef->roomIndex);
+        }
     }
 
     scene->doorCount = gCurrentLevel->doorCount;
@@ -797,80 +803,4 @@ void sceneClosePortal(struct Scene* scene, int portalIndex) {
         scene->portals[portalIndex].transformIndex = NO_TRANSFORM_INDEX;
     }
     return;
-}
-
-void sceneSerializePortals(struct Serializer* serializer, SerializeAction action, struct Scene* scene) {
-    for (int portalIndex = 0; portalIndex < 2; ++portalIndex) {
-        if (!gCollisionScene.portalTransforms[portalIndex]) {
-            char flags = 0xFF;
-            action(serializer, &flags, sizeof(flags));
-            continue;
-        }
-
-        struct Portal* portal = &scene->portals[portalIndex];
-        char flags = portal->flags;
-        action(serializer, &flags, sizeof(flags));
-
-        action(serializer, &portal->transform, sizeof(struct PartialTransform));
-        action(serializer, &portal->portalSurfaceIndex, sizeof(portal->portalSurfaceIndex));
-        action(serializer, &portal->roomIndex, sizeof(portal->roomIndex));
-        action(serializer, &portal->transformIndex, sizeof(portal->transformIndex));
-
-        if (portal->transformIndex != NO_TRANSFORM_INDEX) {
-            action(serializer, &portal->relativePos, sizeof(portal->relativePos));
-        }
-    }
-}
-
-void sceneDeserializePortals(struct Serializer* serializer, struct Scene* scene) {
-    for (int portalIndex = 0; portalIndex < 2; ++portalIndex) {
-        char flags;
-        serializeRead(serializer, &flags, sizeof(flags));
-
-        if (flags == 0xFF) {
-            continue;
-        }
-
-        struct Portal* portal = &scene->portals[portalIndex];
-
-        struct Transform transform;
-        serializeRead(serializer, &transform, sizeof(struct PartialTransform));  
-        transform.scale = gOneVec;
-
-        short portalSurfaceIndex;
-        short roomIndex;
-        serializeRead(serializer, &portalSurfaceIndex, sizeof(portalSurfaceIndex));
-        serializeRead(serializer, &roomIndex, sizeof(roomIndex));
-
-        struct PortalSurface* existingSurface = portalSurfaceGetOriginalSurface(portalSurfaceIndex, portalIndex);
-
-        portalAttachToSurface(
-            portal, 
-            existingSurface, 
-            portalSurfaceIndex, 
-            &transform,
-            0
-        );
-
-        serializeRead(serializer, &portal->transformIndex, sizeof(portal->transformIndex));
-        if (portal->transformIndex != NO_TRANSFORM_INDEX) {
-            serializeRead(serializer, &portal->relativePos, sizeof(portal->relativePos));
-        }
-
-        portal->transform = transform;
-        gCollisionScene.portalVelocity[portalIndex] = gZeroVec;
-        portal->roomIndex = roomIndex;
-        portal->scale = 1.0f;
-        gCollisionScene.portalTransforms[portalIndex] = &portal->transform;
-        gCollisionScene.portalRooms[portalIndex] = roomIndex;
-
-        if (flags & PortalFlagsPlayerPortal) {
-            portal->flags |= PortalFlagsPlayerPortal;
-        } else {
-            portal->flags &= ~PortalFlagsPlayerPortal;
-        }
-
-        portal->opacity = 0.0f;
-    }
-
-}   
+}

src/scene/scene.h

@@ -21,7 +21,6 @@
 #include "ball_launcher.h"
 #include "ball_catcher.h"
 #include "portal_gun.h"
-#include "../savefile/serializer.h"
 
 struct SavedPortal{
     struct Ray ray;
@@ -82,7 +81,4 @@ void sceneUpdate(struct Scene* scene);
 int sceneFirePortal(struct Scene* scene, struct Ray* ray, struct Vector3* playerUp, int portalIndex, int roomIndex, int fromPlayer, int just_checking);
 void sceneClosePortal(struct Scene* scene, int portalIndex);
 
-void sceneSerializePortals(struct Serializer* serializer, SerializeAction action, struct Scene* scene);
-void sceneDeserializePortals(struct Serializer* serializer, struct Scene* scene);
-
 #endif