Barely progress on tilesets

src/dawn/display/Tileset.hpp

@@ -0,0 +1,83 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  struct Tile {
+    public:
+      glm::vec2 uv0;
+      glm::vec2 uv1;
+  };
+
+  struct Tileset {
+    public:
+      std::vector<struct Tile> tiles;
+  };
+
+  struct TilesetGrid : public Tileset{
+    public:
+      int32_t rows;
+      int32_t columns;
+      
+      TilesetGrid(
+        int32_t columns,
+        int32_t rows,
+        int32_t width,
+        int32_t height,
+        int32_t gapX,
+        int32_t gapY,
+        int32_t borderX,
+        int32_t borderY
+      ) {
+        assertTrue(columns >= 1);
+        assertTrue(rows >= 1);
+        assertTrue(width >= 1);
+        assertTrue(height >= 1);
+        assertTrue(gapX >= 0);
+        assertTrue(gapY >= 0);
+        assertTrue(borderX >= 0);
+        assertTrue(borderY >= 0);
+        assertTrue(width >= (columns + (gapX * columns) + borderX + borderX));
+        assertTrue(height >= (rows + (gapY * rows) + borderY + borderY));
+
+        this->rows = rows;
+        this->columns = columns;
+
+        // Calculate division sizes (pixels)
+        float_t divX = (
+          (float_t)width - ((float_t)borderX * 2.0f) -
+          ((float_t)gapX * ((float_t)columns - 1))
+        ) / columns;
+        float_t divY = (
+          (float_t)height - ((float_t)borderY * 2.0f) -
+          ((float_t)gapY * ((float_t)rows - 1))
+        ) / rows;
+
+        // Calculate the division sizes (units)
+        float_t tdivX = divX / (float_t)width;
+        float_t tdivY = divY / (float_t)height;
+
+        for(int32_t y = 0; y < rows; y++) {
+          for(int32_t x = 0; x < columns; x++) {
+            struct Tile tile;
+            tile.uv0.x = (borderX + (divX * x) + (gapX * x)) / width;
+            tile.uv1.x = tile.uv0.x + tdivX;
+                
+            tile.uv0.y = (borderY + (divY * y) + (gapY * y)) / height;
+            tile.uv1.y = tile.uv0.y + tdivY;
+            this->tiles.push_back(tile);
+          }
+        }
+      }
+
+      struct Tile getTile(int32_t row, int32_t column) {
+        assertTrue(row > 0 && row < this->rows);
+        assertTrue(column > 0 && column < this->columns);
+        return this->tiles[row + (column * this->rows)];
+      }
+  };
+}

src/dawn/display/animation/Animation.hpp

@@ -28,7 +28,7 @@ namespace Dawn {
       bool_t finished = false;
       float_t time = 0;
       float_t duration = 0;
-      easefunction_t *easing = &easeLinear;
+      easefunction_t *easing = &easeOutQuad;
       std::vector<struct TimelineItem<T>> timelineItems;
       Event<> eventAnimationEnd;
 

src/dawn/display/font/CMakeLists.txt

@@ -8,14 +8,4 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     TrueTypeFont.cpp
     FontMeasure.cpp
-)
-
-tool_truetype(truetype_ark
-  ark-pixel.ttf
-  truetype_ark
-  96
-  96
-  10
-)
-
-add_dependencies(${DAWN_TARGET_NAME} truetype_ark)
+)

src/dawn/display/mesh/QuadMesh.cpp

@@ -48,4 +48,15 @@ void QuadMesh::bufferQuadMesh(
   QuadMesh::bufferQuadMeshWithZ(
     mesh, xy0, uv0, xy1, uv1, 0, verticeStart, indiceStart
   );
+}
+
+void QuadMesh::initQuadMesh(
+  Mesh *mesh,
+  glm::vec2 xy0, glm::vec2 uv0,
+  glm::vec2 xy1, glm::vec2 uv1,
+  float_t z
+) {
+  assertNotNull(mesh);
+  mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+  QuadMesh::bufferQuadMeshWithZ(mesh, xy0, uv0, xy1, uv1, z, 0, 0);
 }

src/dawn/display/mesh/QuadMesh.hpp

@@ -49,5 +49,12 @@ namespace Dawn {
         glm::vec2 xy1, glm::vec2 uv1,
         int32_t verticeStart, int32_t indiceStart
       );
+
+      static void initQuadMesh(
+        Mesh *mesh,
+        glm::vec2 xy0, glm::vec2 uv0,
+        glm::vec2 xy1, glm::vec2 uv1,
+        float_t z
+      );
   };
 }

src/dawn/scene/SceneItem.cpp

@@ -35,6 +35,11 @@ void SceneItem::init() {
       bool_t waiting = false;
       auto it2 = deps.begin();
       while(it2 != deps.end()) {
+        if(*it2 == nullptr) {
+          continue;
+          ++it2;
+        }
+
         // Has the dep not yet inited?
         if(!(*it2)->hasInitialized) {
           waiting = true;

src/dawn/scene/components/Components.hpp

@@ -5,7 +5,9 @@
 
 #pragma once
 #include "scene/components/display/Camera.hpp"
+#include "scene/components/display/MeshHost.hpp"
 #include "scene/components/display/MeshRenderer.hpp"
 #include "scene/components/display/Material.hpp"
+#include "scene/components/display/TiledSprite.hpp"
 
 #include "scene/components/ui/UICanvas.hpp"

src/dawn/scene/components/display/CMakeLists.txt

@@ -8,5 +8,7 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     Camera.cpp
     Material.cpp
+    MeshHost.cpp
     MeshRenderer.cpp
+    TiledSprite.cpp
 )

src/dawn/scene/components/display/MeshHost.cpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "MeshHost.hpp"
+
+using namespace Dawn;
+
+MeshHost::MeshHost(SceneItem *item) :
+  mesh(),
+  SceneItemComponent(item)
+{
+
+}
+

src/dawn/scene/components/display/MeshHost.hpp

@@ -0,0 +1,17 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+#include "display/mesh/Mesh.hpp"
+
+namespace Dawn {
+  class MeshHost : public SceneItemComponent {
+    public:
+      Mesh mesh;
+
+      MeshHost(SceneItem *item);
+  };
+}

src/dawn/scene/components/display/MeshRenderer.cpp

@@ -4,8 +4,25 @@
 // https://opensource.org/licenses/MIT
 
 #include "MeshRenderer.hpp"
+#include "MeshHost.hpp"
+#include "scene/SceneItem.hpp"
 
 using namespace Dawn;
 
 MeshRenderer::MeshRenderer(SceneItem *item) : SceneItemComponent(item) {
+}
+
+std::vector<SceneItemComponent*> MeshRenderer::getDependencies() {
+  return std::vector<SceneItemComponent*>{
+    this->item->getComponent<MeshHost>()
+  };
+}
+
+void MeshRenderer::onStart() {
+  SceneItemComponent::onStart();
+
+  if(mesh == nullptr) {
+    auto host = this->item->getComponent<MeshHost>();
+    if(host != nullptr) this->mesh = &host->mesh;
+  }
 }

src/dawn/scene/components/display/MeshRenderer.hpp

@@ -18,5 +18,8 @@ namespace Dawn {
        * @param item Scene Item this mesh renderer belongs to.
        */
       MeshRenderer(SceneItem *item);
+
+      std::vector<SceneItemComponent*> getDependencies() override;
+      void onStart() override;
   };
 }

src/dawn/scene/components/display/TiledSprite.cpp

@@ -0,0 +1,35 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TiledSprite.hpp"
+#include "scene/SceneItem.hpp"
+
+using namespace Dawn;
+
+TiledSprite::TiledSprite(SceneItem *item) : SceneItemComponent(item) {
+
+}
+
+std::vector<SceneItemComponent*> TiledSprite::getDependencies() {
+  this->renderer = this->item->getComponent<MeshRenderer>();
+  this->host = this->item->getComponent<MeshHost>();
+
+  return std::vector<SceneItemComponent*>{
+    this->renderer,
+    this->host
+  };
+}
+
+void TiledSprite::onStart() {
+  SceneItemComponent::onStart();
+
+  assertNotNull(this->host);
+
+  QuadMesh::initQuadMesh(&this->host->mesh, 
+    glm::vec2(0, 0), glm::vec2(0, 0),
+    glm::vec2(1, 1), glm::vec2(0.125f, 0.125f),
+    0
+  );
+}

src/dawn/scene/components/display/TiledSprite.hpp

@@ -0,0 +1,25 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+#include "scene/components/display/MeshRenderer.hpp"
+#include "scene/components/display/MeshHost.hpp"
+#include "display/mesh/QuadMesh.hpp"
+#include "display/Tileset.hpp"
+
+namespace Dawn {
+  class TiledSprite : public SceneItemComponent {
+    protected:
+      MeshRenderer *renderer;
+      MeshHost *host;
+
+    public:
+      TiledSprite(SceneItem *item);
+
+      std::vector<SceneItemComponent*> getDependencies() override;
+      void onStart() override;
+  };
+}

src/dawnpokergame/CMakeLists.txt

@@ -17,5 +17,23 @@ target_include_directories(${DAWN_TARGET_NAME}
 
 # Subdirs
 add_subdirectory(game)
+add_subdirectory(prefabs)
 add_subdirectory(ui)
-add_subdirectory(visualnovel)
+add_subdirectory(visualnovel)
+
+# Assets
+tool_texture(texture_test texture_test.png)
+tool_texture(texture_penny characters/penny/penny-blink.png)
+tool_truetype(truetype_ark
+  ark-pixel.ttf
+  truetype_ark
+  96
+  96
+  10
+)
+
+add_dependencies(${DAWN_TARGET_NAME}
+  texture_test
+  texture_penny
+  truetype_ark
+)

src/dawnpokergame/game/CMakeLists.txt

@@ -7,8 +7,4 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     DawnGame.cpp
-)
-
-tool_texture(texture_test texture_test.png texture_test)
-
-add_dependencies(${DAWN_TARGET_NAME} texture_test)
+)

src/dawnpokergame/prefabs/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
+#     VNPlayer.cpp
+# )

src/dawnpokergame/prefabs/VNPenny.hpp

@@ -0,0 +1,33 @@
+// 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 "asset/Asset.hpp"
+#include "poker/PokerPlayer.hpp"
+#include "scene/components/Components.hpp"
+
+namespace Dawn {
+  class VNPenny {
+    public:
+      static std::vector<Asset*> getAssets(AssetManager *assMan) {
+        return std::vector<Asset*>{
+          assMan->get<TextureAsset>("texture_penny")
+        };
+      }
+
+      static SceneItem * create(Scene *scene) {
+        auto item = scene->createSceneItem();
+
+        auto meshRenderer = item->addComponent<MeshRenderer>();
+        auto material = item->addComponent<Material>();
+        auto meshHost = item->addComponent<MeshHost>();
+        auto tiledSprite = item->addComponent<TiledSprite>();
+        auto pokerPlayer = item->addComponent<PokerPlayer>();
+
+        return item;
+      }
+  };
+}

src/dawnpokergame/scenes/TestScene.hpp

@@ -16,6 +16,7 @@
 #include "visualnovel/events/PokerInitialEvent.hpp"
 #include "visualnovel/events/SimpleLoopEvent.hpp"
 #include "ui/PokerPlayerDisplay.hpp"
+#include "prefabs/VNPenny.hpp"
 
 namespace Dawn {
   class TestScene : public Scene {
@@ -30,6 +31,7 @@ namespace Dawn {
 
         vectorAppend(&assets, &PokerGameTextbox::getAssets(assMan));
         vectorAppend(&assets, &PokerPlayerDisplay::getAssets(assMan));
+        vectorAppend(&assets, &VNPenny::getAssets(assMan));
 
         return assets;
       }
@@ -52,12 +54,11 @@ namespace Dawn {
         auto pokerGame = pokerGameItem->addComponent<PokerGame>();
 
         for(int32_t i = 0; i < 5; i++) {
-          auto pokerPlayerInstance = this->createSceneItem();
-          auto pokerPlayer = pokerPlayerInstance->addComponent<PokerPlayer>();
+          auto player = VNPenny::create(this);
 
           auto uiPlayer = canvas->addElement<PokerPlayerDisplay>();
           uiPlayer->setTransform(UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_STRETCH, glm::vec4(i * 220, 0, 0, 0), 0);
-          uiPlayer->setPlayer(pokerPlayer);
+          uiPlayer->setPlayer(player->getComponent<PokerPlayer>());
         }
 
         auto betting = vnManager

src/dawnpokergame/visualnovel/CMakeLists.txt

@@ -3,5 +3,11 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    VNPlayer.cpp
+)
+
 # Subdirs
 add_subdirectory(events)

src/dawnpokergame/visualnovel/VNPlayer.cpp

@@ -0,0 +1,12 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "VNPlayer.hpp"
+
+using namespace Dawn;
+
+VNPlayer::VNPlayer(SceneItem *item) : SceneItemComponent(item) {
+  
+}

src/dawnpokergame/visualnovel/VNPlayer.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "scene/SceneItemComponent.hpp"
+
+namespace Dawn {
+  class VNPlayer : public SceneItemComponent {
+    protected:
+      
+
+    public:
+      VNPlayer(SceneItem *item);
+  };
+}

src/dawntools/display/CMakeLists.txt

@@ -7,9 +7,9 @@ add_subdirectory(texturegen)
 add_subdirectory(truetypegen)
 
 # Texture Tool
-function(tool_texture target in out)
+function(tool_texture target in)
   add_custom_target(${target}
-    COMMAND texturegen "${DAWN_ASSETS_SOURCE_DIR}/${in}" "${DAWN_ASSETS_BUILD_DIR}/${out}"
+    COMMAND texturegen "${DAWN_ASSETS_SOURCE_DIR}/${in}" "${DAWN_ASSETS_BUILD_DIR}/${target}"
     COMMENT "Generating texture ${target} from ${in}"
     DEPENDS texturegen
   )