Add context sharing on prefabs.

assets/prefabs/rosa.json

@@ -1,5 +1,5 @@
 {
-  "name": "Test Cube",
+  "name": "Rosa",
   
   "assets": {
     "rosa": {
@@ -8,21 +8,20 @@
     }
   },
 
-  "position": [ 0, 0, 0 ],
-
   "components": {
-    "mat": {
+    "material": {
       "type": "SimpleTexturedMaterial",
-      "color": "blue",
       "texture": "rosa"
     },
-
+    "meshRenderer": {
-    "renderer": {
       "type": "MeshRenderer"
     },
-    
+    "entity": {
-    "mesh": {
+      "type": "RPGEntity"
-      "type": "CubeMesh"
+    },
+    "player": {
+      "type": "RPGPlayer",
+      "camera": "camera"
     }
   }
 }

assets/scenes/test_rpg_scene.json

@@ -0,0 +1,30 @@
+{
+  "name": "Test RPG Scene",
+  
+  "assets": {
+    "rosa": {
+      "type": "prefab",
+      "path": "prefabs/rosa.json"
+    }
+  },
+
+  "items": {
+    "camera": {
+      "components": {
+        "camera": {
+          "type": "camera"
+        }
+      }
+    },
+
+    "rosa": {
+      "prefab": "rosa",
+      "position": [ 0, 0, 0 ]
+    },
+
+    "rosa2": {
+      "prefab": "rosa",
+      "position": [ 2, 0, 0 ]
+    }
+  }
+}

assets/test_scene.json

@@ -1,32 +0,0 @@
-{
-  "name": "Test Scene",
-  "assets": {
-    "rosa": {
-      "type": "texture",
-      "path": "rosa.texture"
-    },
-    "cube": {
-      "type": "prefab",
-      "path": "test_cube.json"
-    }
-  },
-  
-  "items": {
-    "camera": {
-      "lookAt": {
-        "position": [ 3, 3, 3 ],
-        "look": [ 0, 0, 0 ],
-        "view": [ 0, 1, 0 ]
-      },
-      "components": {
-        "camera": {
-          "type": "Camera"
-        }
-      }
-    },
-
-    "cube": {
-      "prefab": "cube"
-    }
-  }
-}

src/dawn/asset/loader/LoaderForSceneItems.cpp

@@ -35,7 +35,9 @@ void LoaderForSceneItems::setupDependencies() {
         loader = getAssetManager()->get<JSONLoader>(path);
 
       } else if(type == "prefab") {
-        loader = getAssetManager()->get<PrefabLoader>(path);
+        auto prefabLoader = getAssetManager()->get<PrefabLoader>(path);
+        prefabLoader->parentLoader = weak_from_this();
+        loader = prefabLoader;
 
       } else {
         assertUnreachable("Unknown asset type: %s", type.c_str());

src/dawn/asset/loader/LoaderForSceneItems.hpp

@@ -8,10 +8,14 @@
 #include "scene/Scene.hpp"
 
 namespace Dawn {
-  class LoaderForSceneItems : public AssetLoader {
+  class LoaderForSceneitems;
+
+  class LoaderForSceneItems :
+    public AssetLoader,
+    public std::enable_shared_from_this<LoaderForSceneItems>
+  {
     protected:
       std::shared_ptr<JSONLoader> jsonLoader;
-      struct SceneComponentLoadContext ctx;
 
       /**
        * Loads the dependencies into the context for the data available in
@@ -20,6 +24,8 @@ namespace Dawn {
       void setupDependencies();
 
     public:
+      struct SceneComponentLoadContext ctx;
+
       LoaderForSceneItems(
         const std::shared_ptr<AssetManager> assetManager,
         const std::string name

src/dawn/asset/loader/PrefabLoader.cpp

@@ -4,6 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #include "PrefabLoader.hpp"
+#include "SceneLoader.hpp"
 #include "game/Game.hpp"
 #include "assert/assert.hpp"
 #include "asset/loader/TextureLoader.hpp"
@@ -64,6 +65,11 @@ std::string PrefabLoader::getAssetType() const {
 void PrefabLoader::stagePrefab(std::shared_ptr<SceneItem> item) {
   assertTrue(this->loaded, "Prefab not loaded");
 
+  // Can we merge with the parent context?
+  auto parentLoaderLock = this->parentLoader.lock();
+  if(parentLoaderLock) this->ctx.merge(parentLoaderLock->ctx);
+
+  // Force-set new context values
   ctx.scene = item->getScene();
   ctx.data = this->jsonLoader->data;
 

src/dawn/asset/loader/PrefabLoader.hpp

@@ -8,6 +8,7 @@
 #include "scene/Scene.hpp"
 
 namespace Dawn {
+  
   enum class PrefabLoaderState {
     INITIAL,
     LOADING_JSON,
@@ -23,6 +24,7 @@ namespace Dawn {
 
     public:
       const static std::string ASSET_TYPE;
+      std::weak_ptr<LoaderForSceneItems> parentLoader;
 
       PrefabLoader(
         const std::shared_ptr<AssetManager> assetManager,

src/dawn/component/SceneComponentRegistry.cpp

@@ -5,48 +5,29 @@
 
 #include "SceneComponentRegistry.hpp"
 
-#include "component/display/Camera.hpp"
-#include "component/display/material/SimpleTexturedMaterial.hpp"
-#include "component/display/MeshRenderer.hpp"
-#include "component/display/mesh/CubeMeshComponent.hpp"
-
-#ifdef DAWN_ENABLE_PHYSICS
-  #include "component/physics/CubeCollider.hpp"
-  #include "component/physics/SphereCollider.hpp"
-#endif
 
 using namespace Dawn;
 
+std::unordered_map<
+  std::string,
+  std::function<std::shared_ptr<SceneComponent>(
+    const std::shared_ptr<SceneItem> &
+  )>
+> SceneComponentRegistry::REGISTRY = {
+  
+};
+
 std::shared_ptr<SceneComponent> SceneComponentRegistry::createComponent(
   const std::string &type,
   const std::shared_ptr<SceneItem> &item
 ) {
-  if(type.length() == 0) {
+  auto typeLower = String::toLowercase(type);
-    assertUnreachable("Component type is empty!");
+  assertMapHasKey(
+    SceneComponentRegistry::REGISTRY,
+    typeLower,
+    "Component type not registered: %s",
+    type.c_str()
+  );
 
-  } else if(type == "Camera") {
+  return SceneComponentRegistry::REGISTRY[typeLower](item);
-    return item->addComponent<Camera>();
-
-  } else if(type == "SimpleTexturedMaterial") {
-    return item->addComponent<SimpleTexturedMaterial>();
-
-  } else if(type == "MeshRenderer") {
-    return item->addComponent<MeshRenderer>();
-
-  } else if(type == "CubeMesh" || type == "CubeMeshComponent") {
-    return item->addComponent<CubeMeshComponent>();
-
-  #ifdef DAWN_ENABLE_PHYSICS
-    } else if(type == "CubeCollider") {
-      return item->addComponent<CubeCollider>();
-
-    } else if(type == "SphereCollider") {
-      return item->addComponent<SphereCollider>();
-  #endif
-
-  } else {
-    assertUnreachable("Unknown component type: %s", type.c_str());
-  }
-
-  return nullptr;
 }

src/dawn/component/SceneComponentRegistry.hpp

@@ -5,10 +5,30 @@
 
 #pragma once
 #include "scene/Scene.hpp"
+#include "util/String.hpp"
 
 namespace Dawn {
   class SceneComponentRegistry final {
+    private:
+    
     public:
+      static std::unordered_map<
+        std::string,
+        std::function<std::shared_ptr<SceneComponent>(
+          const std::shared_ptr<SceneItem> &
+        )>
+      > REGISTRY;
+      
+      template<class T>
+      static void reg(const std::string name) {
+        auto nameLower = String::toLowercase(name);
+        SceneComponentRegistry::REGISTRY[nameLower] = [](
+          const std::shared_ptr<SceneItem> &item
+        ) {
+          return item->addComponent<T>();
+        };
+      }
+
       /**
        * Creates a scene component by its type name. Type names are unique and
        * must be registered in order to be constructed by their string name.

src/dawn/component/display/Camera.cpp

@@ -21,7 +21,7 @@ void Camera::onDispose() {
   renderTarget = nullptr;
 }
 
-void Camera::load(const SceneComponentLoadContext &ctx) {
+void Camera::load(SceneComponentLoadContext &ctx) {
   SceneComponent::load(ctx);
 
   if(ctx.data.contains("fov")) {

src/dawn/component/display/Camera.hpp

@@ -33,7 +33,7 @@ namespace Dawn {
 
       void onInit() override;
       void onDispose() override;
-      void load(const SceneComponentLoadContext &ctx) override;
+      void load(SceneComponentLoadContext &ctx) override;
 
       /**
        * Returns the aspect ratio that the camera is using. In future I may 

src/dawn/component/display/material/SimpleTexturedMaterial.cpp

@@ -9,7 +9,7 @@
 
 using namespace Dawn;
 
-void SimpleTexturedMaterial::load(const SceneComponentLoadContext &ctx) {
+void SimpleTexturedMaterial::load(SceneComponentLoadContext &ctx) {
   if(ctx.data.contains("color")) {
     this->setColor(JSON::color(ctx.data["color"]));
   }

src/dawn/component/display/material/SimpleTexturedMaterial.hpp

@@ -15,7 +15,7 @@ namespace Dawn {
       std::shared_ptr<Texture> texture;
 
     public:
-      void load(const SceneComponentLoadContext &ctx) override;
+      void load(SceneComponentLoadContext &ctx) override;
       
       /**
        * Returns the color of this material.

src/dawn/component/display/mesh/CubeMeshComponent.cpp

@@ -27,7 +27,7 @@ void CubeMeshComponent::onDispose() {
   mesh = nullptr;
 }
 
-void CubeMeshComponent::load(const SceneComponentLoadContext &ctx) {
+void CubeMeshComponent::load(SceneComponentLoadContext &ctx) {
   if(!mesh) mesh = std::make_shared<Mesh>();
 
 }

src/dawn/component/display/mesh/CubeMeshComponent.hpp

@@ -14,6 +14,6 @@ namespace Dawn {
 
       void onInit() override;
       void onDispose() override;
-      void load(const SceneComponentLoadContext &ctx) override;
+      void load(SceneComponentLoadContext &ctx) override;
   };
 }

src/dawn/game/IGame.cpp

@@ -6,13 +6,26 @@
 #include "game/Game.hpp"
 #include "scene/Scene.hpp"
 #include "util/Flag.hpp"
-
 #include "asset/loader/SceneLoader.hpp"
+#include "component/SceneComponentRegistry.hpp"
+
+// Components to register
+#include "component/display/Camera.hpp"
+#include "component/display/material/SimpleTexturedMaterial.hpp"
+#include "component/display/MeshRenderer.hpp"
+#include "component/display/mesh/CubeMeshComponent.hpp"
+
+#ifdef DAWN_ENABLE_PHYSICS
+#endif
 
 using namespace Dawn;
 
 IGame::IGame() {
-
+  SceneComponentRegistry::reg<Camera>("Camera");
+  SceneComponentRegistry::reg<SimpleTexturedMaterial>("SimpleTexturedMaterial");
+  SceneComponentRegistry::reg<MeshRenderer>("MeshRenderer");
+  SceneComponentRegistry::reg<CubeMeshComponent>("CubeMeshComponent");
+  SceneComponentRegistry::reg<CubeMeshComponent>("CubeMesh");
 }
 
 void IGame::init() {

src/dawn/scene/SceneComponent.cpp

@@ -59,7 +59,7 @@ std::shared_ptr<Game> SceneComponent::getGame() {
   return this->getScene()->getGame();
 }
 
-void SceneComponent::load(const SceneComponentLoadContext &context) {
+void SceneComponent::load(SceneComponentLoadContext &context) {
   // Override this method to load data from a JSON object.
 }
 

src/dawn/scene/SceneComponent.hpp

@@ -35,6 +35,21 @@ namespace Dawn {
       assertNotNull(asset, "Asset is not of the correct type.");
       return asset;
     }
+
+    void merge(const struct SceneComponentLoadContext &ctx) {
+      for(auto &item : ctx.items) {
+        if(items.find(item.first) != items.end()) continue;
+        this->items[item.first] = item.second;
+      }
+      for(auto &cmp : ctx.components) {
+        if(components.find(cmp.first) != components.end()) continue;
+        this->components[cmp.first] = cmp.second;
+      }
+      for(auto &asset : ctx.assets) {
+        if(assets.find(asset.first) != assets.end()) continue;
+        this->assets[asset.first] = asset.second;
+      }
+    }
   };
 
   class SceneComponent : std::enable_shared_from_this<SceneComponent> {
@@ -104,7 +119,7 @@ namespace Dawn {
        * 
        * @param json JSON Data that this object needs to load.
        */
-      virtual void load(const SceneComponentLoadContext &context);
+      virtual void load(SceneComponentLoadContext &context);
 
       /**
        * Disposes this scene component.

src/dawn/scene/SceneItem.cpp

@@ -76,7 +76,7 @@ void SceneItem::deinit() {
   this->components.clear();
 }
 
-void SceneItem::load(const SceneComponentLoadContext &ctx) {
+void SceneItem::load(SceneComponentLoadContext &ctx) {
   // Load prefab first, it can be overriden by other properties.
   if(ctx.data.contains("prefab")) {
     auto prefabLoader = ctx.getAsset<PrefabLoader>(

src/dawn/scene/SceneItem.hpp

@@ -55,7 +55,7 @@ namespace Dawn {
        * 
        * @param ctx Context to load this scene item from.
        */
-      void load(const SceneComponentLoadContext &ctx);
+      void load(SceneComponentLoadContext &ctx);
 
       /**
        * Returns the scene that this scene item belongs to.

src/dawnphysics/physics/PhysicsManager.cpp

@@ -7,6 +7,10 @@
 #include "game/Game.hpp"
 #include "scene/Scene.hpp"
 #include "component/physics/Collider.hpp"
+#include "component/SceneComponentRegistry.hpp"
+
+#include "component/physics/CubeCollider.hpp"
+#include "component/physics/SphereCollider.hpp"
 
 using namespace Dawn;
 using namespace JPH;
@@ -206,6 +210,9 @@ BodyInterface & PhysicsManager::getBodyInterface() {
 void PhysicsManager::init(const std::shared_ptr<Game> &game) {
   this->game = game;
 
+  SceneComponentRegistry::reg<CubeCollider>("CubeCollider");
+  SceneComponentRegistry::reg<SphereCollider>("SphereCollider");
+
   RegisterDefaultAllocator();
 
   Trace = TraceImpl;

src/dawnrpg/CMakeLists.txt

@@ -12,9 +12,8 @@ target_include_directories(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(component)
 add_subdirectory(game)
-add_subdirectory(scene)
 
 # Assets
 tool_texture(rosa rosa.png)
-tool_copy(test_cube test_cube.json)
+tool_copy(prefab_rosa prefabs/rosa.json)
-tool_copy(test_scene test_scene.json)
+tool_copy(test_rpg_scene scenes/test_rpg_scene.json)

src/dawnrpg/component/RPGEntity.cpp

@@ -14,7 +14,6 @@ using namespace Dawn;
 void RPGEntity::onInit() {
   const glm::vec2 size = { RPG_ENTITY_SIZE, RPG_ENTITY_SIZE };
   const glm::vec2 position = -size;
-  const auto sprites = getGame()->assetManager->get<TextureLoader>("rosa.texture");
 
   mesh = std::make_shared<Mesh>();
   mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
@@ -25,20 +24,13 @@ void RPGEntity::onInit() {
     0, 0, 0
   );
 
-  meshRenderer = getItem()->addComponent<MeshRenderer>();
+  getItem()->getComponent<MeshRenderer>()->mesh = mesh;
-  meshRenderer->mesh = mesh;
-
-  material = getItem()->addComponent<SimpleTexturedMaterial>();
-  material->setColor(COLOR_WHITE);
-  material->setTexture(sprites->getTexture());
 
   updateSprite();
 }
 
 void RPGEntity::onDispose() {
-  meshRenderer = nullptr;
   mesh = nullptr;
-  material = nullptr;
 }
 
 enum RPGEntityDirection RPGEntity::getFacingDirection() {
@@ -52,6 +44,7 @@ void RPGEntity::setFacingDirection(const enum RPGEntityDirection dir) {
 }
 
 void RPGEntity::updateSprite() {
+  auto material = getItem()->getComponent<SimpleTexturedMaterial>();
   struct TilesetGrid tileset(
     3, 4,
     material->getTexture()->getWidth(), material->getTexture()->getHeight(),

src/dawnrpg/component/RPGEntity.hpp

@@ -20,9 +20,7 @@ namespace Dawn {
     private:
 
     protected:
-      std::shared_ptr<MeshRenderer> meshRenderer;
       std::shared_ptr<Mesh> mesh;
-      std::shared_ptr<SimpleTexturedMaterial> material;
 
       enum RPGEntityDirection facingDirection = RPGEntityDirection::SOUTH;
 

src/dawnrpg/component/RPGPlayer.cpp

@@ -5,6 +5,7 @@
 
 #include "RPGPlayer.hpp"
 #include "scene/Scene.hpp"
+#include "assert/assert.hpp"
 
 using namespace Dawn;
 
@@ -68,4 +69,15 @@ void RPGPlayer::onInit() {
 
 void RPGPlayer::onDispose() {
   this->rpgEntity = nullptr;
+}
+
+void RPGPlayer::load(SceneComponentLoadContext &ctx) {
+  SceneComponent::load(ctx);
+
+  if(ctx.data.contains("camera")) {
+    assertMapHasKey(ctx.components, ctx.data["camera"], "Camera not found!");
+    const auto component = ctx.components[ctx.data["camera"].get<std::string>()];
+    this->camera = std::dynamic_pointer_cast<Camera>(component);
+    assertNotNull(this->camera, "Camera not found!");
+  }
 }

src/dawnrpg/component/RPGPlayer.hpp

@@ -18,5 +18,6 @@ namespace Dawn {
 
       void onInit() override;
       void onDispose() override;
+      void load(SceneComponentLoadContext &ctx) override;
   };
 }

src/dawnrpg/game/Game.cpp

@@ -4,16 +4,20 @@
 // https://opensource.org/licenses/MIT
 
 #include "Game.hpp"
-#include "scene/SceneList.hpp"
+#include "component/SceneComponentRegistry.hpp"
+
+#include "component/RPGEntity.hpp"
+#include "component/RPGPlayer.hpp"
 
 using namespace Dawn;
 
 Game::Game() : IGame() {
-  
+  SceneComponentRegistry::reg<RPGEntity>("RPGEntity");
+  SceneComponentRegistry::reg<RPGPlayer>("RPGPlayer");
 }
 
 std::string Game::getInitialScene() {
-  return "test_scene.json";
+  return "scenes/test_rpg_scene.json";
 }
 
 void Game::initManagers() {

src/dawnrpg/scene/CMakeLists.txt

@@ -1,9 +0,0 @@
-# Copyright (c) 2023 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-target_sources(${DAWN_TARGET_NAME}
-  PRIVATE
-    RPGScene.cpp
-)

src/dawnrpg/scene/RPGScene.cpp

@@ -1,47 +0,0 @@
-
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "scene/SceneList.hpp"
-#include "component/display/Camera.hpp"
-#include "component/display/material/SimpleTexturedMaterial.hpp"
-#include "component/ui/UICanvas.hpp"
-#include "asset/loader/TextureLoader.hpp"
-
-#include "component/RPGEntity.hpp"
-#include "component/RPGPlayer.hpp"
-
-using namespace Dawn;
-
-void Dawn::rpgScene(Scene &s) {
-  auto textureRosa = s.getGame()->assetManager->get<TextureLoader>("rosa.texture");
-
-  while(!s.getGame()->assetManager->isEverythingLoaded()) {
-    s.getGame()->assetManager->update();
-  }
-
-  auto cameraItem = s.createSceneItem();
-  auto camera = cameraItem->addComponent<Camera>();
-  camera->clipFar = 99999.99f;
-
-  // Player:
-  {
-    auto ent = s.createSceneItem();
-    ent->setLocalPosition(glm::vec3(0, 0, 0.00f));
-    auto eEnt = ent->addComponent<RPGEntity>();
-    auto ePlyr = ent->addComponent<RPGPlayer>();
-    ePlyr->camera = camera;
-  }
-
-  // Test Entity
-  {
-    auto ent = s.createSceneItem();
-    ent->setLocalPosition(glm::vec3(-128, -32, -0.01f));
-    auto eEnt = ent->addComponent<RPGEntity>();
-  }
-
-  auto uiCanvasItem = s.createSceneItem();
-  auto uiCanvas = uiCanvasItem->addComponent<UICanvas>();
-}

src/dawnrpg/scene/SceneList.hpp

@@ -1,11 +0,0 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "scene/Scene.hpp"
-
-namespace Dawn {
-  void rpgScene(Scene &s);
-}