7 files changed, 249 insertions, 130 deletions

diff --git a/gltfview/src/game.c b/gltfview/src/game.c
index c331190..64be4f3 100644
--- a/gltfview/src/game.c
+++ b/gltfview/src/game.c
@@ -39,6 +39,78 @@ static const int WIDTH   = 1350;
 static const int HEIGHT  = 900;
 static const int MAX_FPS = 60;
 
+/// Initialize the game's plugin.
+static bool init_plugin(Game* game) {
+  assert(game);
+  assert(game->plugin);
+  // Plugin state is allowed to be null, either when the plugin does not
+  // expose an init() or when init() does not initialize a state.
+  if (plugin_resolve(game->plugin, plugin_init, "init")) {
+    State* plugin_state = 0;
+    if (!plugin_call(game->plugin, plugin_init, "init", game, &plugin_state)) {
+      return false;
+    }
+    set_plugin_state(game->plugin, plugin_state);
+  }
+  return true; // Plugin does not need to expose an init().
+}
+
+/// Shutdown the game's plugin.
+/// The game's plugin is allowed to be null in the call to this function.
+static void shutdown_plugin(Game* game) {
+  assert(game);
+  if (game->plugin &&
+      (plugin_resolve(game->plugin, plugin_shutdown, "shutdown"))) {
+    void* plugin_state = get_plugin_state(game->plugin);
+    plugin_call(game->plugin, plugin_shutdown, "shutdown", game, plugin_state);
+    set_plugin_state(game->plugin, 0);
+  }
+}
+
+/// Boot the game's plugin.
+static bool boot_plugin(Game* game) {
+  assert(game);
+  assert(game->plugin);
+  if (plugin_resolve(game->plugin, plugin_boot, "boot")) {
+    void* plugin_state = get_plugin_state(game->plugin);
+    return plugin_call(game->plugin, plugin_boot, "boot", game, plugin_state);
+  }
+  return true; // Plugin does not need to expose a boot().
+}
+
+/// Update the plugin's state.
+static void update_plugin(Game* game, double t, double dt) {
+  assert(game);
+  assert(game->plugin);
+  if (plugin_resolve(game->plugin, plugin_update, "update")) {
+    void* plugin_state = get_plugin_state(game->plugin);
+    plugin_call(
+        game->plugin, plugin_update, "update", game, plugin_state, t, dt);
+  }
+}
+
+/// Plugin render.
+static void render_plugin(const Game* game) {
+  assert(game);
+  assert(game->plugin);
+  if (plugin_resolve(game->plugin, plugin_render, "render")) {
+    void* plugin_state = get_plugin_state(game->plugin);
+    plugin_call(game->plugin, plugin_render, "render", game, plugin_state);
+  }
+}
+
+/// Plugin resize.
+static void resize_plugin(Game* game, int width, int height) {
+  assert(game);
+  assert(game->plugin);
+  if (plugin_resolve(game->plugin, plugin_resize, "resize")) {
+    void* plugin_state = get_plugin_state(game->plugin);
+    plugin_call(
+        game->plugin, plugin_resize, "resize", game, plugin_state, width,
+        height);
+  }
+}
+
 void app_end(Game* game);
 
 bool app_init(const GfxAppDesc* desc, void** app_state) {
@@ -88,30 +160,14 @@ bool app_init(const GfxAppDesc* desc, void** app_state) {
   if (!(game->gfx = gfx_init())) {
     goto cleanup;
   }
-  if (!(game->scene = gfx_make_scene())) {
+
+  if (!init_plugin(game)) {
     goto cleanup;
   }
-  if (!(game->camera = gfx_make_camera())) {
+  if (!boot_plugin(game)) {
     goto cleanup;
   }
 
-  if (plugin_resolve(game->plugin, plugin_init, "init")) {
-    void* plugin_state = plugin_call(game->plugin, plugin_init, "init", game);
-    if (!plugin_state) {
-      goto cleanup;
-    }
-    set_plugin_state(game->plugin, plugin_state);
-  }
-
-  if (plugin_resolve(game->plugin, plugin_boot, "boot")) {
-    void* plugin_state = get_plugin_state(game->plugin);
-    bool  boot_success =
-        plugin_call(game->plugin, plugin_boot, "boot", plugin_state, game);
-    if (!boot_success) {
-      goto cleanup;
-    }
-  }
-
   *app_state = game;
   return true;
 
@@ -123,6 +179,7 @@ cleanup:
 
 void app_end(Game* game) {
   assert(game);
+  shutdown_plugin(game);
   if (game->gfx) {
     gfx_destroy(&game->gfx);
   }
@@ -136,53 +193,24 @@ void app_end(Game* game) {
 
 void app_update(Game* game, double t, double dt) {
   plugin_engine_update(game->plugin_engine);
-  if (plugin_reloaded(game->plugin) &&
-      plugin_resolve(game->plugin, plugin_init, "init")) {
-    void* plugin_state = plugin_call(game->plugin, plugin_init, "init", game);
-    assert(plugin_state); // TODO: handle error better.
-    set_plugin_state(game->plugin, plugin_state);
+  if (plugin_reloaded(game->plugin)) {
+    shutdown_plugin(game);
+    const bool result = init_plugin(game);
+    assert(result); // TODO: handle error better.
   }
 
-  if (plugin_resolve(game->plugin, plugin_update, "update")) {
-    // Plugin state may be null if plugin does not expose init().
-    void* plugin_state = get_plugin_state(game->plugin);
-    plugin_call(
-        game->plugin, plugin_update, "update", plugin_state, game, t, dt);
-  }
+  update_plugin(game, t, dt);
 }
 
 void app_render(const Game* game) {
   RenderBackend* render_backend = gfx_get_render_backend(game->gfx);
-  Renderer*      renderer       = gfx_get_renderer(game->gfx);
-
   gfx_start_frame(render_backend);
-
-  gfx_render_scene(
-      renderer,
-      &(RenderSceneParams){
-          .mode = RenderDefault, .scene = game->scene, .camera = game->camera});
-
-  if (plugin_resolve(game->plugin, plugin_render, "render")) {
-    // Plugin state may be null if plugin does not expose init().
-    void* plugin_state = get_plugin_state(game->plugin);
-    plugin_call(game->plugin, plugin_render, "render", plugin_state, game);
-  }
-
+  render_plugin(game);
   gfx_end_frame(render_backend);
 }
 
 void app_resize(Game* game, int width, int height) {
-  RenderBackend* render_backend = gfx_get_render_backend(game->gfx);
-  gfx_set_viewport(render_backend, width, height);
-
-  const R    fovy       = 90 * TO_RAD;
-  const R    aspect     = (R)width / (R)height;
-  const R    near       = 0.1;
-  const R    far        = 1000;
-  const mat4 projection = mat4_perspective(fovy, aspect, near, far);
-
-  Camera* camera     = gfx_get_camera_camera(game->camera);
-  camera->projection = projection;
+  resize_plugin(game, width, height);
 }
 
 GFX_APP_MAIN(WIDTH, HEIGHT, MAX_FPS);
diff --git a/gltfview/src/game.h b/gltfview/src/game.h
index 53725c7..93a5e39 100644
--- a/gltfview/src/game.h
+++ b/gltfview/src/game.h
@@ -16,6 +16,4 @@ typedef struct {
   PluginEngine* plugin_engine;
   Plugin*       plugin;
   Gfx*          gfx;
-  Scene*        scene;  // TODO: Move scene graph to plugin?
-  SceneCamera*  camera; // TODO: Move too.
 } Game;
diff --git a/gltfview/src/plugins/gltf_view.c b/gltfview/src/plugins/gltf_view.c
index c3457a8..c19d1b8 100644
--- a/gltfview/src/plugins/gltf_view.c
+++ b/gltfview/src/plugins/gltf_view.c
@@ -1,6 +1,7 @@
-#include "gltf_view.h"
+#include "plugin.h"
 
 #include <gfx/renderer.h>
+#include <gfx/scene.h>
 #include <gfx/util/scene.h>
 #include <gfx/util/skyquad.h>
 #include <gfx/util/texture.h>
@@ -23,6 +24,11 @@ static const char* GIRL =
 
 #define DEFAULT_SCENE_FILE GIRL
 
+struct State {
+  Scene*       scene;
+  SceneCamera* camera;
+};
+
 /// Load the skyquad texture.
 static Texture* load_environment_map(RenderBackend* render_backend) {
   return gfx_load_texture(
@@ -57,15 +63,17 @@ static SceneNode* load_skyquad(RenderBackend* render_backend, SceneNode* root) {
 }
 
 /// Load the 3D scene.
-static SceneNode* load_scene(Game* game, const char* scene_filepath) {
+static SceneNode* load_scene(
+    Game* game, State* state, const char* scene_filepath) {
   assert(game);
   assert(game->gfx);
-  assert(game->scene);
+  assert(state);
+  assert(state->scene);
 
-  SceneNode*     root           = gfx_get_scene_root(game->scene);
+  SceneNode*     root           = gfx_get_scene_root(state->scene);
   RenderBackend* render_backend = gfx_get_render_backend(game->gfx);
 
-  Camera* camera = gfx_get_camera_camera(game->camera);
+  Camera* camera = gfx_get_camera_camera(state->camera);
   spatial3_set_position(&camera->spatial, vec3_make(0, 0, 2));
 
   SceneNode* sky_light_node = load_skyquad(render_backend, root);
@@ -85,16 +93,20 @@ static SceneNode* load_scene(Game* game, const char* scene_filepath) {
   return scene_node;
 }
 
-State* init(Game* game) {
+bool init(Game* game, State** pp_state) {
   assert(game);
 
   State* state = calloc(1, sizeof(State));
-  return state;
-}
+  if (!state) {
+    goto cleanup;
+  }
 
-bool boot(State* state, Game* game) {
-  assert(state);
-  assert(game);
+  if (!(state->scene = gfx_make_scene())) {
+    goto cleanup;
+  }
+  if (!(state->camera = gfx_make_camera())) {
+    goto cleanup;
+  }
 
   const int    argc = game->argc;
   const char** argv = game->argv;
@@ -102,27 +114,44 @@ bool boot(State* state, Game* game) {
   // Usage: <scene file>
   const char* scene_filepath = argc > 1 ? argv[1] : DEFAULT_SCENE_FILE;
 
-  SceneNode* node = load_scene(game, scene_filepath);
+  SceneNode* node = load_scene(game, state, scene_filepath);
   if (!node) {
-    return false;
+    goto cleanup;
   }
   Anima* anima = gfx_get_node_anima(node);
   gfx_play_animation(
       anima, &(AnimationPlaySettings){.name = "Walk", .loop = true});
 
+  *pp_state = state;
   return true;
+
+cleanup:
+  shutdown(game, state);
+  if (state) {
+    free(state);
+  }
+  return false;
 }
 
-void update(State* state, Game* game, double t, double dt) {
-  assert(state);
+void shutdown(Game* game, State* state) {
+  assert(game);
+  if (state) {
+    gfx_destroy_camera(&state->camera);
+    gfx_destroy_scene(&state->scene);
+    // State freed by plugin engine.
+  }
+}
+
+void update(Game* game, State* state, double t, double dt) {
   assert(game);
-  assert(game->scene);
-  assert(game->camera);
+  assert(state);
+  assert(state->scene);
+  assert(state->camera);
 
-  gfx_animate_scene(game->scene, (R)t);
+  gfx_animate_scene(state->scene, (R)t);
 
   const vec3 orbit_point = vec3_make(0, 2, 0);
-  Camera*    camera      = gfx_get_camera_camera(game->camera);
+  Camera*    camera      = gfx_get_camera_camera(state->camera);
   spatial3_orbit(
       &camera->spatial, orbit_point,
       /*radius=*/2.5,
@@ -150,18 +179,18 @@ static void render_bounding_boxes(ImmRenderer* imm, const SceneNode* node) {
   }
 }
 
-void render(State* state, const Game* game) {
+void render(const Game* game, const State* state) {
   assert(state);
   assert(game);
   assert(game->gfx);
-  assert(game->scene);
-  assert(game->camera);
+  assert(state->scene);
+  assert(state->camera);
 
   ImmRenderer* imm = gfx_get_imm_renderer(game->gfx);
   assert(imm);
   gfx_imm_start(imm);
-  gfx_imm_set_camera(imm, gfx_get_camera_camera(game->camera));
+  gfx_imm_set_camera(imm, gfx_get_camera_camera(state->camera));
   gfx_imm_set_colour(imm, vec4_make(0.2, 0.2, 1.0, 0.3));
-  render_bounding_boxes(imm, gfx_get_scene_root(game->scene));
+  render_bounding_boxes(imm, gfx_get_scene_root(state->scene));
   gfx_imm_end(imm);
 }
diff --git a/gltfview/src/plugins/gltf_view.h b/gltfview/src/plugins/gltf_view.h
deleted file mode 100644
index 670d88d..0000000
--- a/gltfview/src/plugins/gltf_view.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include "plugin.h"
-
-#include <gfx/scene.h>
-
-typedef struct State {
-  int unused;
-} State;
diff --git a/gltfview/src/plugins/plugin.h b/gltfview/src/plugins/plugin.h
index 0e0e12c..a2632cd 100644
--- a/gltfview/src/plugins/plugin.h
+++ b/gltfview/src/plugins/plugin.h
@@ -1,21 +1,5 @@
 /*
  * Game plugin.
- *
- * A game plugin exposes three functions:
- * - boot(): called once when the plugin is first loaded during the lifetime of
- * the game.
- * - init() -> state: creates and returns the plugin's state.
- * - update(state): takes and updates the state, possibly with side effects.
- * - render(): performs custom rendering.
- *
- * boot() is convenient for one-time initialization of the scene.
- *
- * init() is called every time the plugin is loaded. It is assumed that the
- * plugin's state is encapsulated in the object returned.
- *
- * update() updates the plugin state and has side effects on the scene. It is
- * assumed that update does not reference any global, mutable state outside of
- * the scene and the plugin state returned by init().
  */
 #pragma once
 
@@ -28,22 +12,41 @@
 
 typedef struct State State;
 
-/// Initialize the plugin's state.
-State* init(Game*);
+/// Initialize the plugin, which may optionally return a state object.
+///
+/// This function is called every time the plugin is (re)loaded.
+///
+/// It is assumed that the plugin's state is fully encapsulated in the returned
+/// state object. The plugin should not store any (mutable) state outside of the
+/// returned state object (e.g., no mutable global variables.)
+bool init(Game*, State**);
+
+/// Shut down the plugin.
+///
+/// This function is called before the plugin is unloaded.
+///
+/// The plugin should perform any destruction needed, but not free the state
+/// object; freeing the state object's memory is handled by the caller.
+void shutdown(Game*, State*);
 
 /// Function called the first time the plugin is loaded throughout the
-/// application's lifetime. Allows the plugin to do one-time initialization of
-/// the game state.
-bool boot(State*, Game*);
+/// application's lifetime. This allows the plugin to do one-time initialization
+/// of the game state.
+bool boot(Game*, State*);
 
 /// Update the plugin's and the game's state.
-void update(State*, Game*, double t, double dt);
+void update(Game*, State*, double t, double dt);
 
-/// Optional plugin rendering hook.
-void render(State*, const Game*);
+/// Render hook.
+void render(const Game*, const State*);
+
+/// Called when the game's window is resized.
+void resize(Game* game, State* state, int width, int height);
 
 // Signatures for the plugin's exposed functions.
-typedef void* (*plugin_init)(Game*);
-typedef bool (*plugin_boot)(State*, Game*);
-typedef void (*plugin_update)(State*, Game*, double t, double dt);
-typedef void (*plugin_render)(State*, const Game*);
+typedef bool (*plugin_init)(Game*, State**);
+typedef bool (*plugin_shutdown)(Game*, State*);
+typedef bool (*plugin_boot)(Game*, State*);
+typedef void (*plugin_update)(Game*, State*, double t, double dt);
+typedef void (*plugin_render)(const Game*, const State*);
+typedef void (*plugin_resize)(Game* game, State* state, int width, int height);
diff --git a/gltfview/src/plugins/texture_view.c b/gltfview/src/plugins/texture_view.c
index f16c8d1..b424158 100644
--- a/gltfview/src/plugins/texture_view.c
+++ b/gltfview/src/plugins/texture_view.c
@@ -1,6 +1,7 @@
-#include "texture_view.h"
+#include "plugin.h"
 
 #include <gfx/render_backend.h>
+#include <gfx/renderer.h>
 #include <gfx/scene.h>
 #include <gfx/util/geometry.h>
 #include <gfx/util/shader.h>
@@ -9,13 +10,25 @@
 #include <math/camera.h>
 
 #include <assert.h>
+#include <stdlib.h>
 
 // Default texture to load if no texture is provided.
 static const char* DEFAULT_TEXTURE = "/assets/skybox/clouds1/clouds1_west.bmp";
 // static const char* DEFAULT_TEXTURE = "/assets/checkerboard.jpg";
 
-bool boot(State* state, Game* game) {
+struct State {
+  Scene*       scene;
+  SceneCamera* camera;
+};
+
+bool init(Game* game, State** pp_state) {
   assert(game);
+  assert(pp_state);
+
+  State* state = calloc(1, sizeof(State));
+  if (!state) {
+    goto cleanup;
+  }
 
   // Usage: [texture file]
   const char* texture_file = game->argc > 1 ? game->argv[1] : DEFAULT_TEXTURE;
@@ -30,17 +43,17 @@ bool boot(State* state, Game* game) {
                           .mipmaps               = false,
                           .data.texture.filepath = mstring_make(texture_file)});
   if (!texture) {
-    return false;
+    goto cleanup;
   }
 
   ShaderProgram* shader = gfx_make_view_texture_shader(render_backend);
   if (!shader) {
-    return false;
+    goto cleanup;
   }
 
   Geometry* geometry = gfx_make_quad_11(render_backend);
   if (!geometry) {
-    return false;
+    goto cleanup;
   }
 
   MaterialDesc material_desc = (MaterialDesc){.num_uniforms = 1};
@@ -50,25 +63,85 @@ bool boot(State* state, Game* game) {
        .name          = sstring_make("Texture")};
   Material* material = gfx_make_material(&material_desc);
   if (!material) {
-    return false;
+    goto cleanup;
   }
 
   const MeshDesc mesh_desc =
       (MeshDesc){.geometry = geometry, .material = material, .shader = shader};
   Mesh* mesh = gfx_make_mesh(&mesh_desc);
   if (!mesh) {
-    return false;
+    goto cleanup;
   }
 
   SceneObject* object = gfx_make_object();
   if (!object) {
-    return false;
+    goto cleanup;
   }
   gfx_add_object_mesh(object, mesh);
 
+  if (!(state->scene = gfx_make_scene())) {
+    goto cleanup;
+  }
+
   SceneNode* node = gfx_make_object_node(object);
-  SceneNode* root = gfx_get_scene_root(game->scene);
+  if (!node) {
+    goto cleanup;
+  }
+  SceneNode* root = gfx_get_scene_root(state->scene);
+  if (!root) {
+    goto cleanup;
+  }
   gfx_set_node_parent(node, root);
 
+  if (!(state->camera = gfx_make_camera())) {
+    goto cleanup;
+  }
+
+  *pp_state = state;
   return true;
+
+cleanup:
+  shutdown(game, state);
+  if (state) {
+    free(state);
+  }
+  return false;
+}
+
+void shutdown(Game* game, State* state) {
+  assert(game);
+  if (state) {
+    gfx_destroy_camera(&state->camera);
+    gfx_destroy_scene(&state->scene);
+    // State freed by plugin engine.
+  }
+}
+
+void render(const Game* game, const State* state) {
+  assert(game);
+  assert(state);
+
+  Renderer* renderer = gfx_get_renderer(game->gfx);
+  gfx_render_scene(
+      renderer, &(RenderSceneParams){
+                    .mode   = RenderDefault,
+                    .scene  = state->scene,
+                    .camera = state->camera});
+}
+
+void resize(Game* game, State* state, int width, int height) {
+  assert(game);
+  assert(state);
+
+  RenderBackend* render_backend = gfx_get_render_backend(game->gfx);
+  gfx_set_viewport(render_backend, width, height);
+
+  const R    fovy       = 90 * TO_RAD;
+  const R    aspect     = (R)width / (R)height;
+  const R    near       = 0.1;
+  const R    far        = 1000;
+  const mat4 projection = mat4_perspective(fovy, aspect, near, far);
+
+  Camera* camera     = gfx_get_camera_camera(state->camera);
+  camera->projection = projection;
 }
diff --git a/gltfview/src/plugins/texture_view.h b/gltfview/src/plugins/texture_view.h
deleted file mode 100644
index 956f34a..0000000
--- a/gltfview/src/plugins/texture_view.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-#include "plugin.h"