Created basic movement.

src/dawn/util/Easing.cpp

@@ -45,4 +45,55 @@ float_t Easing::easeOutQuart(float_t t) {
 
 float_t Easing::easeInOutQuart(float_t t) {
   return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (--t) * t * t * t;
+}
+
+float_t Easing::easeInQuint(float_t t) {
+  return t * t * t * t * t;
+}
+
+float_t Easing::easeOutQuint(float_t t) {
+  return 1 + (--t) * t * t * t * t;
+}
+
+float_t Easing::easeInOutQuint(float_t t) {
+  return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t;
+}
+
+float_t Easing::easeInSine(float_t t) {
+  return 1 - cos(t * M_PI_2);
+}
+
+float_t Easing::easeOutSine(float_t t) {
+  return sin(t * M_PI_2);
+}
+
+float_t Easing::easeInOutSine(float_t t) {
+  return 0.5 * (1 - cos(M_PI * t));
+}
+
+float_t Easing::easeInExpo(float_t t) {
+  return t == 0 ? 0 : pow(2, 10 * (t - 1));
+}
+
+float_t Easing::easeOutExpo(float_t t) {
+  return t == 1 ? 1 : 1 - pow(2, -10 * t);
+}
+
+float_t Easing::easeInOutExpo(float_t t) {
+  if(t == 0) return 0;
+  if(t == 1) return 1;
+  if(t < 0.5) return 0.5 * pow(2, 20 * t - 10);
+  return 1 - 0.5 * pow(2, -20 * t + 10);
+}
+
+float_t Easing::easeInCirc(float_t t) {
+  return 1 - sqrt(1 - t * t);
+}
+
+float_t Easing::easeOutCirc(float_t t) {
+  return sqrt(1 - (--t) * t);
+}
+
+float_t Easing::easeInOutCirc(float_t t) {
+  return t < 0.5 ? 0.5 * (1 - sqrt(1 - 4 * t * t)) : 0.5 * (sqrt(-((2 * t) - 3) * ((2 * t) - 1)) + 1);
 }

src/dawn/util/Easing.hpp

@@ -88,5 +88,101 @@ namespace Dawn {
        * @return Eased value.
        */
       static float_t easeInOutQuart(float_t t);
+
+      /**
+       * Quintic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInQuint(float_t t);
+
+      /**
+       * Quintic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutQuint(float_t t);
+
+      /**
+       * Quintic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutQuint(float_t t);
+
+      /**
+       * Sine easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInSine(float_t t);
+
+      /**
+       * Sine easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutSine(float_t t);
+
+      /**
+       * Sine easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutSine(float_t t);
+
+      /**
+       * Exponential easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInExpo(float_t t);
+
+      /**
+       * Exponential easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutExpo(float_t t);
+
+      /**
+       * Exponential easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutExpo(float_t t);
+
+      /**
+       * Circular easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInCirc(float_t t);
+
+      /**
+       * Circular easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutCirc(float_t t);
+
+      /**
+       * Circular easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutCirc(float_t t);
   };
 }

src/dawnglfw/input/InputManager.cpp

@@ -17,6 +17,7 @@ void InputManager::init(const std::shared_ptr<Game> game) {
     double_t y
   ) {
     auto game = (Game*)glfwGetWindowUserPointer(window);
+    assertNotNull(game, "Game is not set on window user pointer.");
     game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_X] = (float_t) x;
     game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_Y] = (float_t) y;
   });
@@ -28,21 +29,17 @@ void InputManager::init(const std::shared_ptr<Game> game) {
     int32_t mods
   ) {
     auto game = (Game*)glfwGetWindowUserPointer(window);
-    game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = (
+    assertNotNull(game, "Game is not set on window user pointer.");
-      action == GLFW_PRESS ? 1.0f : 0.0f
+    switch(action) {
-    );
+      case GLFW_PRESS:
-  });
+        game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = 1.0f;
-
+        return;
-  glfwSetMouseButtonCallback(window, [](
+      case GLFW_RELEASE:
-    GLFWwindow* window,
+        game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = 0.0f;
-    int32_t button,
+        return;
-    int32_t action,
+      default:
-    int32_t mods
+        return;
-  ) {
+    }
-    auto game = (Game*)glfwGetWindowUserPointer(window);
-    game->inputManager.rawInputValues[button] = (
-      action == GLFW_PRESS ? 1.0f : 0.0f
-    );
   });
 
   glfwSetKeyCallback(window, [](
@@ -53,9 +50,18 @@ void InputManager::init(const std::shared_ptr<Game> game) {
     int32_t mods
   ) {
     auto game = (Game*)glfwGetWindowUserPointer(window);
-    game->inputManager.rawInputValues[key] = (
+    assertNotNull(game, "Game is not set on window user pointer.");
-      action == GLFW_PRESS ? 1.0f : 0.0f
+
-    );
+    switch(action) {
+      case GLFW_PRESS:
+        game->inputManager.rawInputValues[key] = 1.0f;
+        return;
+      case GLFW_RELEASE:
+        game->inputManager.rawInputValues[key] = 0.0f;
+        return;
+      default:
+        return;
+    }
   });
 
   // Set default values
@@ -63,6 +69,12 @@ void InputManager::init(const std::shared_ptr<Game> game) {
   this->bind(InputBind::Up, GLFW_KEY_UP);
   this->bind(InputBind::Down, GLFW_KEY_S);
   this->bind(InputBind::Down, GLFW_KEY_DOWN);
+  this->bind(InputBind::Left, GLFW_KEY_A);
+  this->bind(InputBind::Left, GLFW_KEY_LEFT);
+  this->bind(InputBind::Right, GLFW_KEY_D);
+  this->bind(InputBind::Right, GLFW_KEY_RIGHT);
+  this->bind(InputBind::Run, GLFW_KEY_LEFT_SHIFT);
+  this->bind(InputBind::Run, GLFW_KEY_RIGHT_SHIFT);
 }
 
 float_t InputManager::getInputValue(int32_t axis) {

src/dawnrpg/component/entity/Entity.cpp

@@ -6,17 +6,41 @@
 #include "Entity.hpp"
 #include "scene/Scene.hpp"
 #include "assert/assert.hpp"
+#include "util/Easing.hpp"
 
 using namespace Dawn;
 
+const glm::vec3 EntityTilePosition::toWorldSpace() {
+  return glm::vec3(
+    this->x,
+    this->y,
+    this->z
+  );
+}
+
 void Entity::onInit() {
   auto world = this->world.lock();
   assertNotNull(world, "World is no longer active?");
 
   listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float delta) {
     if(this->stepTime <= 0.0f) return;
-    this->stepTime = 0;
+    this->stepTime -= delta * this->stepSpeed;
-    this->getItem()->setLocalPosition(glm::vec3(this->tileX, this->tileY, this->tileZ));
+
+    glm::vec3 nextPosition = this->tilePosition.toWorldSpace();
+    
+    if(this->stepTime <= 0) {
+      this->getItem()->setLocalPosition(nextPosition);
+      this->stepTime = 0.0f;
+      this->eventMove.emit();
+      this->eventStepEnd.emit();
+      return;
+    }
+
+    float_t t = Easing::easeInOutSine(1.0f - this->stepTime);
+    glm::vec3 lastPosition = this->lastTilePosition.toWorldSpace();
+    glm::vec3 newLocal = glm::mix(lastPosition, nextPosition, t);
+    this->getItem()->setLocalPosition(newLocal);
+    this->eventMove.emit();
   }));
 }
 
@@ -24,24 +48,24 @@ void Entity::onDispose() {
   
 }
 
-void Entity::move(const enum EntityDirection direction) {
+void Entity::move(
-  entitytileposition_t newTileX, newTileY, newTileZ;
+  const enum EntityDirection direction,
-  newTileX = tileX;
+  const float_t stepSpeed
-  newTileY = tileY;
+) {
-  newTileZ = tileZ;
+  struct EntityTilePosition newPosition = this->tilePosition;
 
   switch(direction) {
     case EntityDirection::Up:
-      newTileZ--;
+      newPosition.z--;
       break;
     case EntityDirection::Down:
-      newTileZ++;
+      newPosition.z++;
       break;
     case EntityDirection::Left:
-      newTileX--;
+      newPosition.x--;
       break;
     case EntityDirection::Right:
-      newTileX++;
+      newPosition.x++;
       break;
     default:
       assertUnreachable("Invalid direction: %d", direction);
@@ -51,9 +75,22 @@ void Entity::move(const enum EntityDirection direction) {
   // If the tile is not walkable, return early.
 
   // Move the entity to the new tile.
-  this->tileX = newTileX;
+  this->lastTilePosition = this->tilePosition;
-  this->tileY = newTileY;
+  this->tilePosition = newPosition;
-  this->tileZ = newTileZ;
   this->direction = direction;
   this->stepTime = 1.0f;
+  this->stepSpeed = stepSpeed;
+
+  this->eventStepStart.emit();
+}
+
+void Entity::setPosition(struct EntityTilePosition pos) {
+  this->stepTime = 0.0f;
+  this->tilePosition = pos;
+  this->lastTilePosition = pos;
+  this->getItem()->setLocalPosition(pos.toWorldSpace());
+}
+
+bool_t Entity::isMoving() {
+  return this->stepTime > 0.0f;
 }

src/dawnrpg/component/entity/Entity.hpp

@@ -5,10 +5,14 @@
 
 #pragma once
 #include "scene/SceneComponent.hpp"
+#include "event/Event.hpp"
 
 typedef uint32_t entityid_t;
 typedef int64_t entitytileposition_t;
 
+#define ENTITY_STEP_SPEED_DEFAULT 3.0f
+#define ENTITY_STEP_SPEED_RUNNING 6.0f
+
 namespace Dawn {
   class World;
 
@@ -18,20 +22,42 @@ namespace Dawn {
     Left,
     Right
   };
+  
+  struct EntityTilePosition {
+    entitytileposition_t x, y, z;
+    
+    /**
+     * Converts the tile position to a world space position.
+     * 
+     * @return This tile position in world space.
+     */
+    const glm::vec3 toWorldSpace();
+  };
 
   class Entity : public SceneComponent {
     private:
-      entitytileposition_t tileX = 0, tileY = 0, tileZ = 0;
+      struct EntityTilePosition lastTilePosition;
       enum EntityDirection direction = EntityDirection::Down;
       float_t stepTime = 0.0f;
+      float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT;
 
     protected:
+      struct EntityTilePosition tilePosition;
 
     public:
       std::weak_ptr<World> world;
+      Event<> eventStepStart;
+      Event<> eventStepEnd;
+      Event<> eventMove;
       
       void onInit() override;
       void onDispose() override;
-      void move(const enum EntityDirection direction);
+      void move(
+        const enum EntityDirection direction,
+        const float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT
+      );
+      void setPosition(struct EntityTilePosition position);
+
+      bool_t isMoving();
   };
 }

src/dawnrpg/component/entity/Player.cpp

@@ -13,17 +13,39 @@ void Player::onInit() {
   Entity::onInit();
 
   listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float delta) {
+    if(this->isMoving()) return;
+
     InputManager &im = getGame()->inputManager;
-    if(im.isPressed(InputBind::Up)) {
+    bool_t run = im.isDown(InputBind::Run);
-      this->move(EntityDirection::Up);
+    float_t stepSpeed = run ? ENTITY_STEP_SPEED_RUNNING : ENTITY_STEP_SPEED_DEFAULT;
-    } else if(im.isPressed(InputBind::Down)) {
+
-      this->move(EntityDirection::Down);
+    if(im.isDown(InputBind::Up)) {
-    } else if(im.isPressed(InputBind::Left)) {
+      this->move(EntityDirection::Up, stepSpeed);
-      this->move(EntityDirection::Left);
+    } else if(im.isDown(InputBind::Down)) {
-    } else if(im.isPressed(InputBind::Right)) {
+      this->move(EntityDirection::Down, stepSpeed);
-      this->move(EntityDirection::Right);
+    } else if(im.isDown(InputBind::Left)) {
+      this->move(EntityDirection::Left, stepSpeed);
+    } else if(im.isDown(InputBind::Right)) {
+      this->move(EntityDirection::Right, stepSpeed);
     }
   }));
+
+  listeners.push_back(eventMove.listen([this]() {
+    this->updateCameraPosition();
+  }));
+
+  this->updateCameraPosition();
+}
+
+void Player::updateCameraPosition() {
+  auto c = camera.lock();
+  if(!c) return;
+  glm::vec3 pos = this->getItem()->getLocalPosition();
+  c->getItem()->lookAt(
+    pos + glm::vec3(0, 8, 1),
+    pos,
+    glm::vec3(0, 1, 0)
+  );
 }
 
 void Player::onDispose() {

src/dawnrpg/component/entity/Player.hpp

@@ -5,12 +5,16 @@
 
 #pragma once
 #include "component/entity/Entity.hpp"
+#include "component/display/Camera.hpp"
 
 namespace Dawn {
   class Player : public Entity {
     protected:
+      void updateCameraPosition();
 
     public:
+      std::weak_ptr<Camera> camera;
+
       void onInit() override;
       void onDispose() override;
   };

src/dawnrpg/input/InputBinds.hpp

@@ -10,6 +10,7 @@ namespace Dawn {
     Up,
     Down,
     Left,
-    Right
+    Right,
+    Run
   };
 }

src/dawnrpg/prefab/CMakeLists.txt

@@ -7,4 +7,5 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     PlayerPrefab.cpp
     WorldPrefab.cpp
+    TestEntityPrefab.cpp
 )

src/dawnrpg/prefab/PlayerPrefab.cpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #include "PlayerPrefab.hpp"
-#include "display/mesh/QuadMesh.hpp"
+#include "display/mesh/CubeMesh.hpp"
 
 using namespace Dawn;
 
@@ -19,11 +19,11 @@ struct PlayerPrefab Dawn::createPlayerPrefab(
   player.player->world = world;
 
   player.mesh = std::make_shared<Mesh>();
-  player.mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+  player.mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
-  QuadMesh::buffer(
+  CubeMesh::buffer(
     player.mesh,
-    glm::vec4(0, 0, 1, 1),
+    glm::vec3(-0.5f, -0.5f, -0.5f),
-    glm::vec4(0, 0, 1, 1),
+    glm::vec3(1, 1, 1),
     0, 0
   );
 

src/dawnrpg/prefab/TestEntityPrefab.cpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TestEntityPrefab.hpp"
+#include "display/mesh/CubeMesh.hpp"
+
+using namespace Dawn;
+
+struct TestEntityPrefab Dawn::createTestEntityPrefab(
+  const std::shared_ptr<World> world
+) {
+  struct TestEntityPrefab entity;
+  entity.item = world->getScene()->createSceneItem();
+  entity.item->setParent(world->getItem());
+
+  entity.entity = entity.item->addComponent<Entity>();
+  entity.entity->world = world;
+
+  entity.mesh = std::make_shared<Mesh>();
+  entity.mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
+  CubeMesh::buffer(
+    entity.mesh,
+    glm::vec3(-0.5f, -0.5f, -0.5f),
+    glm::vec3(1, 1, 1),
+    0, 0
+  );
+
+  entity.meshRenderer = entity.item->addComponent<MeshRenderer>();
+  entity.meshRenderer->mesh = entity.mesh;
+
+  entity.material = entity.item->addComponent<SimpleTexturedMaterial>();
+  entity.material->setColor(COLOR_GREEN);
+
+  return entity;
+}

src/dawnrpg/prefab/TestEntityPrefab.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefab/Prefab.hpp"
+#include "component/world/World.hpp"
+#include "component/display/MeshRenderer.hpp"
+#include "component/display/material/SimpleTexturedMaterial.hpp"
+
+namespace Dawn {
+  struct TestEntityPrefab : public Prefab {
+    public:
+      std::shared_ptr<Entity> entity;
+      std::shared_ptr<Mesh> mesh;
+      std::shared_ptr<MeshRenderer> meshRenderer;
+      std::shared_ptr<SimpleTexturedMaterial> material;
+  };
+
+  struct TestEntityPrefab createTestEntityPrefab(
+    const std::shared_ptr<World> world
+  );
+}

src/dawnrpg/scenes/WorldScene.cpp

@@ -6,6 +6,7 @@
 
 #include "scenes/SceneList.hpp"
 #include "prefab/PlayerPrefab.hpp"
+#include "prefab/TestEntityPrefab.hpp"
 #include "prefab/WorldPrefab.hpp"
 #include "component/display/Camera.hpp"
 // #include "prefab/SimpleSpinningCube.hpp"
@@ -43,4 +44,8 @@ void Dawn::worldScene(Scene &s) {
   
   auto world = createWorldPrefab(s);
   auto player = createPlayerPrefab(world.world);
+  player.player->camera = camera;
+
+  auto test = createTestEntityPrefab(world.world);
+  test.entity->setPosition({ 5, 0, 0 });
 }