Fixed whatever was wrong with my shader

src/dawn/scene/SceneItem.cpp

@@ -36,8 +36,8 @@ void SceneItem::init() {
       auto it2 = deps.begin();
       while(it2 != deps.end()) {
         if(*it2 == nullptr) {
-          continue;
           ++it2;
+          continue;
         }
 
         // Has the dep not yet inited?

src/dawn/scene/components/CMakeLists.txt

@@ -5,4 +5,5 @@
 
 # Subdirs
 add_subdirectory(display)
+add_subdirectory(example)
 add_subdirectory(ui)

src/dawn/scene/components/Components.hpp

@@ -10,4 +10,6 @@
 #include "scene/components/display/Material.hpp"
 #include "scene/components/display/TiledSprite.hpp"
 
+#include "scene/components/example/ExampleSpin.hpp"
+
 #include "scene/components/ui/UICanvas.hpp"

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

@@ -12,7 +12,7 @@ namespace Dawn {
   
   class Material : public SceneItemComponent {
     private:
-      Shader *shader;
+      Shader *shader = nullptr;
 
       /**
        * Internal method that will be invoked to go through and update all of

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

@@ -14,15 +14,14 @@ MeshRenderer::MeshRenderer(SceneItem *item) : SceneItemComponent(item) {
 
 std::vector<SceneItemComponent*> MeshRenderer::getDependencies() {
   return std::vector<SceneItemComponent*>{
-    this->item->getComponent<MeshHost>()
+    this->meshHost = 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;
+  if(this->mesh == nullptr && this->meshHost != nullptr) {
+    this->mesh = &this->meshHost->mesh;
   }
 }

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

@@ -8,7 +8,12 @@
 #include "display/mesh/Mesh.hpp"
 
 namespace Dawn {
+  class MeshHost;
+
   class MeshRenderer : public SceneItemComponent {
+    protected:
+      MeshHost *meshHost = nullptr;
+
     public:
       Mesh * mesh = nullptr;
 

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

@@ -12,6 +12,52 @@ TiledSprite::TiledSprite(SceneItem *item) : SceneItemComponent(item) {
 
 }
 
+glm::vec2 TiledSprite::getUV0() {
+  auto tile = this->tileset->getTile(tileIndex);
+  return glm::vec2(
+    (this->flipState & TILED_SPRITE_FLIP_X) == 0 ? tile.uv0.x : tile.uv1.x,
+    (this->flipState & TILED_SPRITE_FLIP_Y) == 0 ? tile.uv0.y : tile.uv1.y
+  );
+}
+
+glm::vec2 TiledSprite::getUV1() {
+  auto tile = this->tileset->getTile(tileIndex);
+  return glm::vec2(
+    (this->flipState & TILED_SPRITE_FLIP_X) == 0 ? tile.uv1.x : tile.uv0.x,
+    (this->flipState & TILED_SPRITE_FLIP_Y) == 0 ? tile.uv1.y : tile.uv0.y
+  );
+}
+
+void TiledSprite::setTileset(Tileset *tileset) {
+  assertNotNull(tileset);
+  this->tileset = tileset;
+  this->setTile(0);
+}
+
+void TiledSprite::setTile(int32_t tileIndex) {
+  assertNotNull(this->tileset);
+  this->tileIndex = tileIndex;
+  if(this->host != nullptr) {
+    QuadMesh::bufferCoordinates(
+      &this->host->mesh, this->getUV0(), this->getUV1(), 0
+    );
+  }
+}
+
+void TiledSprite::setSize(glm::vec2 size, glm::vec2 center) {
+  this->xy0 = -center;
+  this->xy1 = size - center;
+  if(this->host != nullptr) {
+    QuadMesh::bufferPositions(
+      &this->host->mesh, this->xy0, this->xy1, 0
+    );
+  }
+}
+
+void TiledSprite::setSize(glm::vec2 size) {
+  this->setSize(size, size / 2.0f);
+}
+
 std::vector<SceneItemComponent*> TiledSprite::getDependencies() {
   this->renderer = this->item->getComponent<MeshRenderer>();
   this->host = this->item->getComponent<MeshHost>();
@@ -24,12 +70,12 @@ std::vector<SceneItemComponent*> TiledSprite::getDependencies() {
 
 void TiledSprite::onStart() {
   SceneItemComponent::onStart();
-
   assertNotNull(this->host);
+  assertNotNull(this->tileset);
 
   QuadMesh::initQuadMesh(&this->host->mesh, 
-    glm::vec2(0, 0), glm::vec2(0, 0),
-    glm::vec2(1, 1), glm::vec2(0.125f, 0.125f),
+    this->xy0, this->getUV0(),
+    this->xy1, this->getUV1(),
     0
   );
 }

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

@@ -10,15 +10,32 @@
 #include "display/mesh/QuadMesh.hpp"
 #include "display/Tileset.hpp"
 
+#define TILED_SPRITE_FLIP_Y FLAG_DEFINE(0)
+#define TILED_SPRITE_FLIP_X FLAG_DEFINE(1)
+
 namespace Dawn {
   class TiledSprite : public SceneItemComponent {
     protected:
-      MeshRenderer *renderer;
-      MeshHost *host;
+      MeshRenderer *renderer = nullptr;
+      MeshHost *host = nullptr;
+      Tileset *tileset = nullptr;
+      flag_t flipState = TILED_SPRITE_FLIP_Y;
+      int32_t tileIndex;
+      glm::vec2 xy0 = glm::vec2(0, 0);
+      glm::vec2 xy1 = glm::vec2(1, 1);
+
+      glm::vec2 getUV0();
+      glm::vec2 getUV1();
 
     public:
       TiledSprite(SceneItem *item);
 
+      void setTileset(Tileset *tileset);
+      void setTile(int32_t tile);
+      void setFlippedState(flag_t flippedState);
+      void setSize(glm::vec2 size, glm::vec2 center);
+      void setSize(glm::vec2 size);
+
       std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;
   };

src/dawn/scene/components/example/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
+    ExampleSpin.cpp
+)

src/dawn/scene/components/example/ExampleSpin.cpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ExampleSpin.hpp"
+#include "scene/Scene.hpp"
+#include "game/DawnGame.hpp"
+#include "scene/components/display/MeshRenderer.hpp"
+#include "display/mesh/CubeMesh.hpp"
+
+using namespace Dawn;
+
+SceneItem * ExampleSpin::create(Scene *scene) {
+  auto item = scene->createSceneItem();
+  auto mr = item->addComponent<MeshRenderer>();
+  mr->mesh = new Mesh();
+  mr->mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
+  CubeMesh::buffer(mr->mesh, glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(1, 1, 1), 0, 0);
+  auto mat = item->addComponent<Material>();
+  item->addComponent<ExampleSpin>();
+
+  return item;
+}
+
+ExampleSpin::ExampleSpin(SceneItem *item) :
+  SceneItemComponent(item)
+{
+  getScene()->eventSceneUnpausedUpdate.addListener(this, &ExampleSpin::onUnpausedUpdate);
+}
+
+
+void ExampleSpin::onUnpausedUpdate() {
+  auto quat = this->transform->getLocalRotation();
+  quat = glm::rotate(quat, getGame()->timeManager.delta, glm::vec3(0, 1, 0));
+  quat = glm::rotate(quat, getGame()->timeManager.delta / 2.0f, glm::vec3(1, 0, 0));
+  quat = glm::rotate(quat, getGame()->timeManager.delta / 4.0f, glm::vec3(0, 0, 1));
+
+  this->transform->setLocalRotation(quat);
+}
+
+ExampleSpin::~ExampleSpin() {
+  getScene()->eventSceneUnpausedUpdate.removeListener(this, &ExampleSpin::onUnpausedUpdate);
+}

src/dawn/scene/components/example/ExampleSpin.hpp

@@ -0,0 +1,19 @@
+// 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/shader/Shader.hpp"
+
+namespace Dawn {
+  class ExampleSpin : public SceneItemComponent {
+    public:
+      static SceneItem * create(Scene *scene);
+
+      ExampleSpin(SceneItem *item);
+      void onUnpausedUpdate();
+      ~ExampleSpin();
+  };
+}