Little documentation update

.gitignore

@@ -76,3 +76,5 @@ yarn.lock
 
 *.log
 assets/borrowed
+
+.~lock*

src/dawn/asset/assets/TilesetAsset.hpp

@@ -17,6 +17,12 @@ namespace Dawn {
     public:
       struct TilesetGrid tileset;
 
+      /**
+       * Creates a new TilesetAsset Loader.
+       * 
+       * @param assMan Asset Manager this tileset asset belongs to.
+       * @param name Tileset asset name.
+       */
       TilesetAsset(AssetManager *assMan, std::string name);
 
       void updateSync() override;

src/dawn/display/animation/Animation.cpp

@@ -0,0 +1,17 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Animation.hpp"
+
+using namespace Dawn;
+
+void Animation::restart() {
+  this->time = 0;
+  this->finished = false;
+}
+
+void Animation::clear() {
+  this->duration = 0;
+}

src/dawn/display/animation/Animation.hpp

@@ -17,21 +17,24 @@ namespace Dawn {
       float_t duration = 0;
       Event<> eventAnimationEnd;
       
+      /**
+       * Ticks the animation along. Delta is whatever you want to update the
+       * animation by (in seconds). Animations can overshoot if necessary and
+       * will not be clamped (by default). Subclasses may interpret ticks in
+       * different ways.
+       * 
+       * @param delta Time delta (in seconds) to tick the animaiton by.
+       */
       virtual void tick(float_t delta) = 0;
       
       /**
        * Restart a running animation.
        */
-      virtual void restart() {
-        this->time = 0;
-        this->finished = false;
-      }
+      virtual void restart();
 
       /**
        * Clears an animaton of all its animation items and keyframes.
        */
-      virtual void clear() {
-        this->duration = 0;
-      }
+      virtual void clear();
   };
 }

src/dawn/display/animation/CMakeLists.txt

@@ -4,7 +4,8 @@
 # https://opensource.org/licenses/MIT
 
 # Sources
-# target_sources(${DAWN_TARGET_NAME}
-#   PRIVATE
-#     Animation.cpp
-# )
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    Animation.cpp
+    TiledSpriteAnimation.cpp
+)

src/dawn/display/animation/SimpleAnimation.hpp

@@ -24,6 +24,12 @@ namespace Dawn {
         this->modifies = modifies;
       }
 
+      /**
+       * Adds a keyframe that will be slerped to at a given time.
+       * 
+       * @param time Time the keyframe occurs.
+       * @param value Value at this given time.
+       */
       void addKeyframe(float_t time, T value) {
         struct SimpleKeyframe<T> keyframe;
         keyframe.time = time;
@@ -33,6 +39,22 @@ namespace Dawn {
         this->keyframes.push_back(keyframe);
       }
 
+      /**
+       * Quickly add a series of keyframes. For example, if you want to have a
+       * keyframe series of;
+       * [ 1, 3, 5, 7, 9 ]
+       * 
+       * And occur at times
+       * [ 0, 2, 4, 6, 8 ]
+       * 
+       * You would pass frameTime as 2, and step as 2.
+       * 
+       * @param startTime When the first keyframe occurs.
+       * @param frameTime At what rate do keyframes occur.
+       * @param start Initial value (the value at startTime).
+       * @param end The end value (for the last keyframe).
+       * @param step How to step the value.
+       */
       void addSequentialKeyframes(
         float_t startTime,
         float_t frameTime,
@@ -49,6 +71,14 @@ namespace Dawn {
         }
       }
 
+      /**
+       * Shorthand addSequentialKeyframes, assumes a step of 1 and a startTime
+       * of 0.
+       * 
+       * @param frameTime Time between frames.
+       * @param start Initial value.
+       * @param end End value.
+       */
       void addSequentialKeyframes(float_t frameTime, T start, T end) {
         this->addSequentialKeyframes(0, frameTime, start, end, 1);
       }

src/dawn/display/animation/TiledSpriteAnimation.cpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TiledSpriteAnimation.hpp"
+
+using namespace Dawn;
+
+TiledSpriteAnimation::TiledSpriteAnimation(TiledSprite *sprite) :
+  SimpleAnimation(&frame),
+  sprite(sprite)
+{
+}
+
+void TiledSpriteAnimation::tick(float_t delta) {
+  SimpleAnimation::tick(delta);
+  this->sprite->setTile(frame);
+}

src/dawn/display/animation/TiledSpriteAnimation.hpp

@@ -13,15 +13,13 @@ namespace Dawn {
       int32_t frame = 0;
       TiledSprite *sprite = nullptr;
 
-      TiledSpriteAnimation(TiledSprite *sprite) :
-        SimpleAnimation(&frame),
-        sprite(sprite)
-      {
-      }
+      /**
+       * Construct a new Tiled Sprite Animation.
+       * 
+       * @param sprite Sprite that this animation will control.
+       */
+      TiledSpriteAnimation(TiledSprite *sprite);
 
-      void tick(float_t delta) override {
-        SimpleAnimation::tick(delta);
-        this->sprite->setTile(frame);
-      }
+      void tick(float_t delta) override;
   };
 }

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

@@ -29,15 +29,60 @@ namespace Dawn {
     public:
       TiledSprite(SceneItem *item);
 
-      void setTileset(Tileset *tileset);
-      void setTilesetAndSize(TilesetGrid *gridTileset, glm::vec2 center);
-      void setTilesetAndSize(TilesetGrid *gridTileset);
-      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;
+
+      /**
+       * Sets which tileset to use for this sprite.
+       * 
+       * @param tileset Tileset to use.
+       */
+      void setTileset(Tileset *tileset);
+
+      /**
+       * Sets the tileset for the sprite, and autosizes the sprite based on
+       * this tileset.
+       * 
+       * @param gridTileset Tileset to use.
+       * @param center The center offset of the sprite.
+       */
+      void setTilesetAndSize(TilesetGrid *gridTileset, glm::vec2 center);
+
+      /**
+       * Sets the tileset for the sprite, and autosizes the sprite based on
+       * this tileset. This will put the sprite centered on its origin.
+       * 
+       * @param gridTileset Tileset to use.
+       */
+      void setTilesetAndSize(TilesetGrid *gridTileset);
+
+      /**
+       * Updates the selected tile.
+       * 
+       * @param tile Tile to use.
+       */
+      void setTile(int32_t tile);
+
+      /**
+       * Adjust how the sprite is flippxed.
+       * 
+       * @param flippedState Flipped axis flags.
+       */
+      void setFlippedState(flag_t flippedState);
+
+      /**
+       * Sets the dimensions of this tiled sprite.
+       * 
+       * @param size Size of the sprite.
+       * @param center Negative center offset.
+       */
+      void setSize(glm::vec2 size, glm::vec2 center);
+
+      /**
+       * Sets the size of this sprite. This will center the sprite on its origin
+       * 
+       * @param size Size of the sprite.
+       */
+      void setSize(glm::vec2 size);
   };
 }

src/dawn/visualnovel/components/SimpleVisualNovelBackground.cpp

@@ -33,6 +33,7 @@ void SimpleVisualNovelBackground::setTexture(Texture *texture) {
   auto param = this->material->getShader()->getParameterByName("u_Text");
   this->material->textureValues[param] = texture;
   
+  // Since we go both negative and positive, actual height is doubled
   float_t aspect = (float_t)texture->getWidth() / (float_t)texture->getHeight();
   float_t height = 0.5f;
 

src/dawn/visualnovel/components/SimpleVisualNovelBackground.hpp

@@ -12,11 +12,32 @@ namespace Dawn {
       Material *material;
       MeshHost *meshHost;
 
+      /**
+       * Create a simple Visual Novel Background prefab.
+       * 
+       * @param scene Scene to add this background to.
+       * @return Created background Scene Item.
+       */
       static SimpleVisualNovelBackground * create(Scene *scene);
 
+      /**
+       * Construct a Simple Visual Novel Background. Simple Background is used
+       * for a quick up and running Visual Novel scene, but does not have any
+       * special effects or controls beyond updating a texture and mesh.
+       * 
+       * @param item Scene Item this background belongs to.
+       */
       SimpleVisualNovelBackground(SceneItem *item);
+      
       std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;
+
+      /**
+       * Set the texture for the background. Auto updates the material and the
+       * dimensions of the internal quad.
+       * 
+       * @param texture Texture to use.
+       */
       void setTexture(Texture *texture);
   };
 }

src/dawnpokergame/CMakeLists.txt

@@ -20,6 +20,7 @@ add_subdirectory(game)
 add_subdirectory(prefabs)
 add_subdirectory(ui)
 add_subdirectory(visualnovel)
+add_subdirectory(scenes)
 
 # Assets
 tool_texture(texture_test texture_test.png)

src/dawnpokergame/prefabs/VNPenny.hpp

@@ -25,27 +25,24 @@ namespace Dawn {
         auto textureAsset = scene->game->assetManager.get<TextureAsset>("texture_penny");
         auto tilesetAsset = scene->game->assetManager.get<TilesetAsset>("tileset_penny");
 
-        // auto meshRenderer = item->addComponent<MeshRenderer>();
-        // auto material = item->addComponent<Material>();
-        // auto meshHost = item->addComponent<MeshHost>();
-        // auto tiledSprite = item->addComponent<TiledSprite>();
-        // auto animation = item->addComponent<AnimationController>();
+        auto meshRenderer = item->addComponent<MeshRenderer>();
+        auto material = item->addComponent<Material>();
+        auto meshHost = item->addComponent<MeshHost>();
+        auto tiledSprite = item->addComponent<TiledSprite>();
+        auto animation = item->addComponent<AnimationController>();
         auto pokerPlayer = item->addComponent<PokerPlayer>();
 
+        auto param = material->getShader()->getParameterByName("u_Text");
+        material->textureValues[param] = &textureAsset->texture;
+        
+        tiledSprite->setTilesetAndSize(&tilesetAsset->tileset);
+
+        auto anim = new TiledSpriteAnimation(tiledSprite);
+        anim->addSequentialKeyframes(0.1f, 0, 22);
+        anim->loop = true;
+        animation->animation = anim;
+
         return item;
-
-        // auto param = material->getShader()->getParameterByName("u_Text");
-        // material->textureValues[param] = &textureAsset->texture;
-        
-        // tiledSprite->setTileset(&tilesetAsset->tileset);
-        // tiledSprite->setSize(glm::vec2(tilesetAsset->tileset.divX, tilesetAsset->tileset.divY));
-
-        // auto anim = new TiledSpriteAnimation(tiledSprite);
-        // anim->addSequentialKeyframes(0.1f, 0, 22);
-        // anim->loop = true;
-        // animation->animation = anim;
-
-        // return item;
       }
   };
 }

src/dawnpokergame/scenes/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/dawnpokergame/scenes/SimpleVNScene.cpp

@@ -0,0 +1,57 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SimpleVNScene.hpp"
+
+using namespace Dawn;
+
+SimpleVNScene::SimpleVNScene(DawnGame *game) : Scene(game) {
+
+}
+
+
+std::vector<Asset*> SimpleVNScene::getRequiredAssets() {
+  auto assMan = &this->game->assetManager;
+  std::vector<Asset*> assets;
+
+  vectorAppend(&assets, &PokerGameTextbox::getAssets(assMan));
+  vectorAppend(&assets, &PokerPlayerDisplay::getAssets(assMan));
+  vectorAppend(&assets, &VNPenny::getAssets(assMan));
+
+  return assets;
+}
+
+void SimpleVNScene::stage() {
+  // Camera
+  this->camera = Camera::create(this);
+  this->camera->transform->lookAtPixelPerfect(
+    glm::vec3(0, 0, 0),
+    glm::vec3(0, 0, 0),
+    1.0f,
+    camera->fov
+  );
+
+  // UI
+  this->canvas = UICanvas::createCanvas(this);
+  this->textbox = PokerGameTextbox::create(canvas);
+  this->background = SimpleVisualNovelBackground::create(this);
+
+  // VN Manager
+  auto vnManagerItem = this->createSceneItem();
+  this->vnManager = vnManagerItem->addComponent<VisualNovelManager>();
+
+  // Stage VN Items
+  this->vnStage();
+
+  // Fader (Drawn over the top of everything else)
+  this->vnFader = VisualNovelFader::create(canvas);
+
+  // Begin VN.
+  this->vnManager->setEvent(this->getVNEvent());
+}
+
+void SimpleVNScene::vnStage() {
+
+}

src/dawnpokergame/scenes/SimpleVNScene.hpp

@@ -0,0 +1,48 @@
+// 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 "util/array.hpp"
+#include "scene/components/Components.hpp"
+#include "ui/PokerGameTextbox.hpp"
+#include "visualnovel/VisualNovelManager.hpp"
+#include "visualnovel/events/VisualNovelTextboxEvent.hpp"
+#include "visualnovel/events/VisualNovelPauseEvent.hpp"
+#include "visualnovel/events/VisualNovelFadeEvent.hpp"
+#include "visualnovel/events/VisualNovelChangeSimpleBackgroundEvent.hpp"
+#include "poker/PokerGame.hpp"
+#include "visualnovel/events/PokerBetLoopEvent.hpp"
+#include "visualnovel/events/PokerInitialEvent.hpp"
+#include "ui/PokerPlayerDisplay.hpp"
+#include "prefabs/VNPenny.hpp"
+
+namespace Dawn {
+  class SimpleVNScene : public Scene {
+    protected:
+      Camera *camera = nullptr;
+      UICanvas *canvas = nullptr;
+      VisualNovelTextbox *textbox = nullptr;
+      SimpleVisualNovelBackground *background = nullptr;
+      VisualNovelFader *vnFader = nullptr;
+      VisualNovelManager *vnManager = nullptr;
+
+      virtual void vnStage();
+      virtual IVisualNovelEvent * getVNEvent() = 0;
+
+    public:
+      /**
+       * Constructs a new Simple VN Scene. Custom class that implements the most
+       * common VN Things.
+       * 
+       * @param game 
+       */
+      SimpleVNScene(DawnGame *game);
+
+      std::vector<Asset*> getRequiredAssets() override;
+      void stage() override;
+  };
+}

src/dawnpokergame/scenes/TestScene.hpp

@@ -4,60 +4,13 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "scene/Scene.hpp"
-#include "game/DawnGame.hpp"
-#include "util/array.hpp"
-#include "scene/components/Components.hpp"
-#include "ui/PokerGameTextbox.hpp"
-#include "visualnovel/VisualNovelManager.hpp"
-#include "visualnovel/events/VisualNovelTextboxEvent.hpp"
-#include "visualnovel/events/VisualNovelPauseEvent.hpp"
-#include "visualnovel/events/VisualNovelFadeEvent.hpp"
-#include "visualnovel/events/VisualNovelChangeSimpleBackgroundEvent.hpp"
-#include "poker/PokerGame.hpp"
-#include "visualnovel/events/PokerBetLoopEvent.hpp"
-#include "visualnovel/events/PokerInitialEvent.hpp"
-#include "ui/PokerPlayerDisplay.hpp"
-#include "prefabs/VNPenny.hpp"
+#include "SimpleVNScene.hpp"
 
 namespace Dawn {
-  class TestScene : public Scene {
-    public:
-      TestScene(DawnGame *game) : Scene(game) {
-
-      }
-
-      std::vector<Asset*> getRequiredAssets() override {
-        auto assMan = &this->game->assetManager;
-        std::vector<Asset*> assets;
-
-        vectorAppend(&assets, &PokerGameTextbox::getAssets(assMan));
-        vectorAppend(&assets, &PokerPlayerDisplay::getAssets(assMan));
-        vectorAppend(&assets, &VNPenny::getAssets(assMan));
-
-        assets.push_back(assMan->get<TextureAsset>("texture_tavern_night"));
-
-        return assets;
-      }
-
-      void stage() override {
-        // Camera
-        auto camera = Camera::create(this);
-        camera->transform->lookAtPixelPerfect(
-          glm::vec3(0, 0, 0),
-          glm::vec3(0, 0, 0),
-          1.0f,
-          camera->fov
-        );
-
-        // UI
-        auto canvas = UICanvas::createCanvas(this);
-        auto textbox = PokerGameTextbox::create(canvas);
-        auto background = SimpleVisualNovelBackground::create(this);
-
-        // VN Manager
-        auto vnManagerItem = this->createSceneItem();
-        auto vnManager = vnManagerItem->addComponent<VisualNovelManager>();
+  class TestScene : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        SimpleVNScene::vnStage();
 
         // Poker Test
         auto pokerGameItem = this->createSceneItem();
@@ -71,14 +24,17 @@ namespace Dawn {
           uiPlayer->setPlayer(player->getComponent<PokerPlayer>());
         }
         
-        auto vnFader = VisualNovelFader::create(canvas);
 
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
         auto texture = this->game->assetManager.get<TextureAsset>("texture_tavern_night");
 
-        auto betting = vnManager
-          ->setEvent(new VisualNovelChangeSimpleBackgroundEvent(
-            vnManager, &texture->texture
-          ))
+        auto start = new VisualNovelChangeSimpleBackgroundEvent(
+          vnManager, &texture->texture
+        );
+
+        start
           ->then(new VisualNovelPauseEvent(vnManager, 1.0f))
           ->then(new VisualNovelFadeEvent(
             vnManager, COLOR_BLACK, false, &easeOutCubic, 1.0f
@@ -88,6 +44,21 @@ namespace Dawn {
           ->then(new VisualNovelTextboxEvent(vnManager, "Game Started"))
           ->then(new PokerInitialEvent(vnManager))
         ;
+
+        return start;
+      }
+
+    public:
+      TestScene(DawnGame *game) : SimpleVNScene(game) {
+
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        auto assMan = &this->game->assetManager;
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, &SimpleVNScene::getRequiredAssets());
+        assets.push_back(assMan->get<TextureAsset>("texture_tavern_night"));
+        return assets;
       }
   };
 }