Added basic prefabs finally

cmake/targets/CMakeLists.txt

@@ -6,9 +6,9 @@
 # Check for build target, or default
 if(NOT DEFINED DAWN_BUILD_TARGET)
   if(WIN32)
-    set(DAWN_BUILD_TARGET "target-barrygame-win32-glfw")
+    set(DAWN_BUILD_TARGET "target-pokergame-win32-glfw")
   elseif(UNIX AND NOT APPLE)
-    set(DAWN_BUILD_TARGET "target-barrygame-linux64-glfw")
+    set(DAWN_BUILD_TARGET "target-pokergame-linux64-glfw")
   endif()
 endif()
 

cmake/targets/target-barrygame-linux64-glfw/CMakeLists.txt

@@ -0,0 +1,8 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+set(DAWN_BUILDING dawnbarrygame CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_TARGET_LINUX64 true CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})

src/dawn/CMakeLists.txt

@@ -23,6 +23,7 @@ add_subdirectory(display)
 add_subdirectory(input)
 add_subdirectory(locale)
 add_subdirectory(poker)
+add_subdirectory(prefab)
 add_subdirectory(save)
 add_subdirectory(scene)
 add_subdirectory(time)

src/dawn/prefab/CMakeLists.txt

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

src/dawn/prefab/Prefab.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetManager.hpp"
+#include "scene/Scene.hpp"
+
+namespace Dawn {
+  template<class T>
+  class Prefab {
+    public:
+      static std::vector<Asset*> getRequiredAssets() {
+        return T::prefabAssets();
+      }
+
+      static T * create(Scene *scene) {
+        T *item = scene->createSceneItemOfType<T>();
+        item->prefabInit();
+        return item;
+      }
+  };
+}

src/dawn/prefab/SceneItemPrefab.hpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Prefab.hpp"
+#include "scene/SceneItem.hpp"
+
+namespace Dawn {
+  template<class T>
+  class SceneItemPrefab :
+    public SceneItem,
+    public Prefab<T>
+  {
+    protected:
+
+    public:
+      SceneItemPrefab(Scene *scene, sceneitemid_t id) :
+        SceneItem(scene, id)
+      {
+
+      }
+
+      virtual void prefabInit() = 0;
+  };
+}

src/dawn/prefabs/display/SimpleCubePrefab.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefab/SceneItemPrefab.hpp"
+#include "scene/components/Components.hpp"
+#include "display/mesh/CubeMesh.hpp"
+
+namespace Dawn {
+  class SimpleCubePrefab : public SceneItemPrefab<SimpleCubePrefab> {
+    public:
+      MeshRenderer *renderer = nullptr;
+      MeshHost *host = nullptr;
+      Material *material = nullptr;
+
+      static std::vector<Asset*> prefabAssets() {
+        return std::vector<Asset*>();
+      }
+      
+      SimpleCubePrefab(Scene *scene, sceneitemid_t id) :
+        SceneItemPrefab(scene, id)
+      {
+
+      }
+      
+      void prefabInit() override {
+        this->renderer = this->addComponent<MeshRenderer>();
+        this->host = this->addComponent<MeshHost>();
+        this->material = this->addComponent<Material>();
+
+        this->host->mesh.createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
+        CubeMesh::buffer(&this->host->mesh, glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(1, 1, 1), 0, 0);
+
+        // auto param = material->getShader()->getParameterByName("u_Text");
+        // this->material->textureValues[param] = nullptr;
+        this->material->colorValues[material->getShader()->getParameterByName("u_Color")] = COLOR_RED;
+
+        std::cout << "Preab Init" << std::endl;
+      }
+  };
+}

src/dawn/scene/Prefab.hpp

@@ -1,74 +0,0 @@
-// Copyright (c) 2022 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "SceneItem.hpp"
-#include "SceneItemComponent.hpp"
-#include "scene/components/Components.hpp"
-#include "util/array.hpp"
-
-namespace Dawn {
-  class Prefab {
-    protected:
-      virtual std::vector<Asset*> prefabAssets(AssetManager *man) = 0;
-      virtual SceneItem * prefabItem(Scene *scene) = 0;
-
-    public:
-      /**
-       * Returns a list of assets that this prefab requires to be loaded for the
-       * instanciation to work.
-       * 
-       * @param man Asset Manager to retreive the assets from.
-       * @return List of required assets, includes sibling/child assets.
-       */
-      template<class T>
-      static std::vector<Asset*> getAssets(AssetManager *man) {
-        return T::prefabAssets(man);
-      }
-
-      /**
-       * Create a scene item from this prefab.
-       * 
-       * @param scene Scene to add the item to.
-       * @return The created scene item for this prefab.
-       */
-      template<class T>
-      static SceneItem * create(Scene *scene) {
-        return T::prefabItem(scene);
-      }
-  };
-
-  class UIPrefab : public Prefab {
-    protected:
-      /** @deprecated */
-      SceneItem * prefabItem(Scene *scene) override {
-        assertUnreachable();
-      }
-
-      virtual void prefabUIApply(T *existing) = 0;
-
-    public:
-      /**
-       * Applies a UI Prefab styling to an existing UI Element.
-       * 
-       * @param existing Existing item to apply styling to.
-       */
-      static virtual void uiApply(T *existing) {
-        V::prefabUIApply(existing);
-      }
-      
-      /**
-       * Creates a UI Item from this prefab.
-       * 
-       * @param canvas Canvas to create this item on to.
-       * @return Pointer to the created UI Item.
-       */
-      static virtual T * uiCreate(UICanvas *canvas) {
-        auto item = canvas->addElement<T>();
-        V::uiApply(item);
-        return item;
-      }
-  }
-}

src/dawn/scene/Scene.cpp

@@ -33,11 +33,7 @@ void Scene::update() {
 }
 
 SceneItem * Scene::createSceneItem() {
-  sceneitemid_t id = this->nextId++;
-  auto item = new SceneItem(this, id);
-  assertNotNull(item);
-  this->itemsNotInitialized[id] = item;
-  return item;
+  return this->createSceneItemOfType<SceneItem>();
 }
 
 Scene::~Scene() {

src/dawn/scene/Scene.hpp

@@ -35,6 +35,20 @@ namespace Dawn {
        */
       void update();
 
+      /**
+       * Create a Scene Item object and add to the current scene.
+       * 
+       * @return A shared pointer to the created SceneItem.
+       */
+      template<class T>
+      T * createSceneItemOfType() {
+        sceneitemid_t id = this->nextId++;
+        auto item = new T(this, id);
+        assertNotNull(item);
+        this->itemsNotInitialized[id] = item;
+        return item;
+      }
+
       /**
        * Create a Scene Item object and add to the current scene.
        * 

src/dawn/ui/CMakeLists.txt

@@ -11,5 +11,5 @@ target_sources(${DAWN_TARGET_NAME}
     UILabel.cpp
     UISprite.cpp
     UIEmpty.cpp
-    UIGrid.cpp
+    # UIGrid.cpp
 )

src/dawn/visualnovel/CMakeLists.txt

@@ -12,4 +12,5 @@ target_sources(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(components)
 add_subdirectory(events)
+add_subdirectory(scene)
 add_subdirectory(ui)

src/dawn/visualnovel/scene/CMakeLists.txt

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

src/dawn/visualnovel/scene/SimpleVNScene.cpp

@@ -14,7 +14,8 @@ SimpleVNScene::SimpleVNScene(DawnGame *game) : Scene(game) {
 
 std::vector<Asset*> SimpleVNScene::getRequiredAssets() {
   auto assMan = &this->game->assetManager;
-  return PokerGameTextbox::getAssets(assMan);
+  // return PokerGameTextbox::getAssets(assMan);
+  return std::vector<Asset*>();
 }
 
 void SimpleVNScene::stage() {
@@ -29,7 +30,7 @@ void SimpleVNScene::stage() {
 
   // UI
   this->canvas = UICanvas::createCanvas(this);
-  this->textbox = Prefab::create<VisualNovelTextboxPrefab>(this)->getComponent<VisualNovelTextbox>();
+  // this->textbox = Prefab::create<VisualNovelTextboxPrefab>(this)->getComponent<VisualNovelTextbox>();
   this->background = SimpleVisualNovelBackground::create(this);
 
   // VN Manager
@@ -44,8 +45,4 @@ void SimpleVNScene::stage() {
 
   // Begin VN.
   this->vnManager->setEvent(this->getVNEvent());
-}
-
-void SimpleVNScene::vnStage() {
-
 }

src/dawn/visualnovel/scene/SimpleVNScene.hpp

@@ -8,7 +8,6 @@
 #include "game/DawnGame.hpp"
 #include "util/array.hpp"
 #include "scene/components/Components.hpp"
-#include "prefabs/VisualNovelTextboxPrefab.hpp"
 #include "visualnovel/VisualNovelManager.hpp"
 #include "visualnovel/events/VisualNovelTextboxEvent.hpp"
 #include "visualnovel/events/VisualNovelPauseEvent.hpp"
@@ -25,7 +24,7 @@ namespace Dawn {
       VisualNovelFader *vnFader = nullptr;
       VisualNovelManager *vnManager = nullptr;
 
-      virtual void vnStage();
+      virtual void vnStage() = 0;
       virtual IVisualNovelEvent * getVNEvent() = 0;
 
     public:

src/dawnbarrygame/scenes/TestScene.hpp

@@ -28,5 +28,5 @@ namespace Dawn {
 
     public:
       TestScene(DawnGame *game) : SimpleVNScene(game) {}
-  }
+  };
 }

src/dawnglfw/CMakeLists.txt

@@ -18,4 +18,5 @@ target_include_directories(${DAWN_TARGET_NAME}
 
 # Subdirs
 add_subdirectory(host)
-add_subdirectory(input)
+add_subdirectory(input)
+add_subdirectory(time)

src/dawnpokergame/CMakeLists.txt

@@ -24,7 +24,8 @@ add_subdirectory(save)
 add_subdirectory(scenes)
 
 # Assets
-tool_language(language_en locale/en.csv)
+set(DIR_GAME_ASSETS games/pokergame)
+tool_language(language_en ${DIR_GAME_ASSETS}/locale/en.csv)
 tool_texture(texture_test texture_test.png)
 tool_texture(texture_city_day borrowed/city_day.png)
 tool_texture(texture_city_night borrowed/city_night.png)

src/dawnpokergame/game/DawnGame.cpp

@@ -5,6 +5,7 @@
 
 #include "DawnGame.hpp"
 #include "scenes/Scene_1_1.hpp"
+#include "scenes/PrefabTestingScene.hpp"
 
 using namespace Dawn;
 
@@ -22,7 +23,7 @@ int32_t DawnGame::init() {
   this->localeManager.init();
   this->renderManager.init();
 
-  this->scene = new Scene_1_1(this);
+  this->scene = new PrefabTestingScene(this);
   
   return DAWN_GAME_INIT_RESULT_SUCCESS;
 }

src/dawnpokergame/scenes/CMakeLists.txt

@@ -6,6 +6,5 @@
 # Sources
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    SimpleVNScene.cpp
     PokerVNScene.cpp
 )

src/dawnpokergame/scenes/PokerVNScene.cpp

@@ -13,15 +13,13 @@ PokerVNScene::PokerVNScene(DawnGame *game) : SimpleVNScene(game) {
 
 std::vector<Asset*> PokerVNScene::getRequiredAssets() {
   auto assMan = &this->game->assetManager;
-  std::vector<Asset*> assets;
-  vectorAppend(&assets, &SimpleVNScene::getRequiredAssets());
-  vectorAppend(&assets, &PokerPlayerDisplay::getAssets(assMan));
+  std::vector<Asset*> assets, l;
+  vectorAppend(&assets, &(l = SimpleVNScene::getRequiredAssets()));
+  vectorAppend(&assets, &(l = PokerPlayerDisplay::getAssets(assMan)));
   return assets;
 }
 
 void PokerVNScene::vnStage() {
-  SimpleVNScene::vnStage();
-
   auto pokerGameItem = this->createSceneItem();
   this->pokerGame = pokerGameItem->addComponent<PokerGame>();
 

src/dawnpokergame/scenes/PokerVNScene.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "SimpleVNScene.hpp"
+#include "visualnovel/scene/SimpleVNScene.hpp"
 #include "poker/PokerGame.hpp"
 #include "visualnovel/events/PokerBetLoopEvent.hpp"
 #include "visualnovel/events/PokerInitialEvent.hpp"

src/dawnpokergame/scenes/PrefabTestingScene.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/Scene.hpp"
+#include "game/DawnGame.hpp"
+#include "prefabs/display/SimpleCubePrefab.hpp"
+
+namespace Dawn {
+  class PrefabTestingScene : public Scene {
+    protected:
+      SimpleCubePrefab *cube = nullptr;
+      Camera *camera = nullptr;
+
+    public:
+      PrefabTestingScene(DawnGame *game) : Scene(game) {
+        
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        return std::vector<Asset*>();
+      }
+
+      void stage() override {
+        camera = Camera::create(this);
+        camera->transform->lookAt(glm::vec3(5, 5, 5), glm::vec3(0, 0, 0));
+        cube = SimpleCubePrefab::create(this);
+      }
+  };
+}

src/dawnpokergame/scenes/Scene_1_1.hpp

@@ -4,19 +4,17 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "SimpleVNScene.hpp"
+#include "visualnovel/scene/SimpleVNScene.hpp"
 
 namespace Dawn {
   class Scene_1_1 : public SimpleVNScene {
     protected:
       void vnStage() override {
-        SimpleVNScene::vnStage();
       }
       
       std::vector<Asset*> getRequiredAssets() override {
         auto assMan = &this->game->assetManager;
-        std::vector<Asset*> assets;
-        vectorAppend(&assets, &SimpleVNScene::getRequiredAssets());
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
         return assets;
       }
 

src/dawnpokergame/ui/PokerPlayerDisplay.hpp

@@ -34,7 +34,7 @@ namespace Dawn {
     public:
       static std::vector<Asset*> getAssets(AssetManager *assMan) {
         std::vector<Asset*> assets;
-        vectorAppend(&assets, &PokerGameBorder::getAssets(assMan));
+        assets = PokerGameBorder::getAssets(assMan);
         assets.push_back(assMan->get<TrueTypeAsset>("truetype_ark"));
         return assets;
       }

src/dawnwin32/CMakeLists.txt

@@ -16,5 +16,4 @@ target_compile_definitions(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(host)
-add_subdirectory(time)
+add_subdirectory(host)