Example physics implemented.

lib/CMakeLists.txt

@@ -42,6 +42,15 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(json)
 
+# JOLT Physics
+FetchContent_Declare(
+  JoltPhysics
+  GIT_REPOSITORY "https://github.com/jrouwe/JoltPhysics"
+  GIT_TAG "v5.2.0"
+  SOURCE_SUBDIR "Build"
+)
+FetchContent_MakeAvailable(JoltPhysics)
+
 # OpenAL
 # if(DAWN_TARGET_OPENAL)
 #   set(LIBTYPE "STATIC")

src/dawn/CMakeLists.txt

@@ -10,6 +10,7 @@ target_link_libraries(${DAWN_TARGET_NAME}
     glm::glm
     nlohmann_json::nlohmann_json
     freetype
+    Jolt
 )
 
 # Includes
@@ -30,7 +31,7 @@ add_subdirectory(game)
 # add_subdirectory(input)
 add_subdirectory(locale)
 add_subdirectory(prefab)
-# add_subdirectory(physics)
+add_subdirectory(physics)
 add_subdirectory(save)
 add_subdirectory(scene)
 # add_subdirectory(state)

src/dawn/component/CMakeLists.txt

@@ -10,4 +10,5 @@ target_sources(${DAWN_TARGET_NAME}
 
 # Subdirs
 add_subdirectory(display)
-add_subdirectory(ui)
+add_subdirectory(ui)
+add_subdirectory(physics)

src/dawn/component/physics/BoxCollider.cpp

@@ -0,0 +1,14 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "BoxCollider.hpp"
+
+using namespace Dawn;
+
+std::shared_ptr<JPH::ShapeSettings> BoxCollider::getShapeSettings() {
+  return std::make_shared<JPH::BoxShapeSettings>(
+    JPH::Vec3(shape.x, shape.y, shape.z)
+  );
+}

src/dawn/component/physics/BoxCollider.hpp

@@ -0,0 +1,17 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Collider.hpp"
+
+namespace Dawn {
+  class BoxCollider : public Collider {
+    protected:
+      std::shared_ptr<JPH::ShapeSettings> getShapeSettings() override;
+
+    public:
+      glm::vec3 shape = glm::vec3(1, 1, 1);
+  };
+}

src/dawn/component/physics/CMakeLists.txt

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

src/dawn/component/physics/Collider.cpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Collider.hpp"
+#include "assert/assert.hpp"
+#include "game/Game.hpp"
+
+using namespace Dawn;
+using namespace JPH;
+using namespace JPH::literals;
+
+void Collider::onInit() {
+  assertNull(this->body, "Body is not NULL?");
+
+  auto settings = this->getShapeSettings();
+  auto shapeResult = settings->Create();
+  auto shape = shapeResult.Get();
+
+  auto pos = getItem()->getLocalPosition();
+
+  BodyCreationSettings bodySettings(
+    shape,
+    RVec3(pos.x, pos.y, pos.z),
+    Quat::sIdentity(),
+    EMotionType::Dynamic,
+    layer
+  );
+
+  this->body = getBodyInterface().CreateBody(bodySettings);
+  assertNotNull(this->body, "Body failed to create?");
+  this->bodyId = this->body->GetID();
+  
+  getBodyInterface().AddBody(this->bodyId, EActivation::Activate);
+}
+
+void Collider::onDispose() {
+  getBodyInterface().RemoveBody(this->bodyId);
+  getBodyInterface().DestroyBody(this->bodyId);
+}
+
+BodyInterface & Collider::getBodyInterface() {
+  return getGame()->physicsManager->getBodyInterface();
+}
+
+BodyID Collider::getBodyId() {
+  return bodyId;
+}

src/dawn/component/physics/Collider.hpp

@@ -0,0 +1,52 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItem.hpp"
+
+namespace Dawn {
+  enum class ColliderType {
+    DYNAMIC,
+    STATIC,
+    KINEMATIC
+  };
+
+  class Collider : public SceneComponent {
+    private:
+      JPH::Body *body = nullptr;
+
+    protected:
+      JPH::BodyID bodyId;
+      JPH::EMotionType emotionType = JPH::EMotionType::Dynamic;
+      JPH::ObjectLayer layer = 1;
+
+      /**
+       * Returns the shape settings for the collider.
+       * 
+       * @return The shape settings for the collider.
+       */
+      virtual std::shared_ptr<JPH::ShapeSettings> getShapeSettings() = 0;
+
+      /**
+       * Returns the JoltPhysics body interface system.
+       * 
+       * @return The JoltPhysics body interface system.
+       */
+      JPH::BodyInterface & getBodyInterface();
+
+    public:
+      ColliderType type = ColliderType::KINEMATIC;
+
+      void onInit() override;
+      void onDispose() override;
+
+      /**
+       * Returns the JoltPhysics body ID of the collider.
+       * 
+       * @return The body ID of the collider.
+       */
+      JPH::BodyID getBodyId();
+  };
+}

src/dawn/dawn.hpp

@@ -47,4 +47,16 @@ extern "C" {
 // #include <glm/gtx/intersect.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #define GLM_ENABLE_EXPERIMENTAL 1
-#include <glm/gtx/matrix_decompose.hpp>
+#include <glm/gtx/matrix_decompose.hpp>
+
+#include <Jolt/Jolt.h>
+#include <Jolt/RegisterTypes.h>
+#include <Jolt/Core/Factory.h>
+#include <Jolt/Core/TempAllocator.h>
+#include <Jolt/Core/JobSystemThreadPool.h>
+#include <Jolt/Physics/PhysicsSettings.h>
+#include <Jolt/Physics/PhysicsSystem.h>
+#include <Jolt/Physics/Collision/Shape/BoxShape.h>
+#include <Jolt/Physics/Collision/Shape/SphereShape.h>
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/Physics/Body/BodyActivationListener.h>

src/dawn/game/IGame.cpp

@@ -24,6 +24,9 @@ void IGame::init() {
   localeManager = std::make_shared<LocaleManager>();
   localeManager->init(selfAsGame);
 
+  physicsManager = std::make_shared<PhysicsManager>();
+  physicsManager->init(selfAsGame);
+
   inputManager.init(selfAsGame);
   saveManager.init(selfAsGame);
 
@@ -45,6 +48,7 @@ void IGame::update() {
 
   timeManager.update();
   if(currentScene) currentScene->update();
+  physicsManager->update();
   renderHost->update(this->getSelfAsGame());
 }
 

src/dawn/game/IGame.hpp

@@ -11,6 +11,7 @@
 #include "asset/AssetManager.hpp"
 #include "locale/LocaleManager.hpp"
 #include "save/SaveManager.hpp"
+#include "physics/PhysicsManager.hpp"
 
 namespace Dawn {
   class Scene;
@@ -46,6 +47,7 @@ namespace Dawn {
       std::shared_ptr<RenderHost> renderHost;
       std::shared_ptr<AssetManager> assetManager;
       std::shared_ptr<LocaleManager> localeManager;
+      std::shared_ptr<PhysicsManager> physicsManager;
       InputManager inputManager;
       TimeManager timeManager;
       SaveManager saveManager;

src/dawn/input/IInputManager.hpp

@@ -8,8 +8,6 @@
 #include "input/InputBind.hpp"
 
 namespace Dawn {
-  class DawnGame;
-
   template<typename T>
   class IInputManager {
     protected:

src/dawn/physics/CMakeLists.txt

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

src/dawn/physics/PhysicsManager.cpp

@@ -0,0 +1,325 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PhysicsManager.hpp"
+#include "game/Game.hpp"
+#include "scene/Scene.hpp"
+#include "component/physics/Collider.hpp"
+
+using namespace Dawn;
+using namespace JPH;
+using namespace JPH::literals;
+
+static void TraceImpl(const char *inFMT, ...) {
+  // Format the message
+  va_list list;
+  va_start(list, inFMT);
+  char buffer[1024];
+  vsnprintf(buffer, sizeof(buffer), inFMT, list);
+  va_end(list);
+
+  // Print to the TTY
+  // std::cout << buffer << std::endl;
+}
+
+#ifdef JPH_ENABLE_ASSERTS
+  static bool AssertFailedImpl(
+    const char *inExpression,
+    const char *inMessage,
+    const char *inFile,
+    uint inLine
+  ) {
+    // Print to the TTY
+    std::cout << inFile << ":" << inLine << ": (" << inExpression << ") " << (inMessage != nullptr? inMessage : "") << std::endl;
+
+    // Breakpoint
+    return true;
+  };
+#endif
+
+namespace Layers {
+  static constexpr ObjectLayer NON_MOVING = 0;
+  static constexpr ObjectLayer MOVING = 1;
+  static constexpr ObjectLayer NUM_LAYERS = 2;
+};
+
+/// Class that determines if two object layers can collide
+class ObjectLayerPairFilterImpl : public ObjectLayerPairFilter {
+  public:
+    virtual bool ShouldCollide(
+      ObjectLayer inObject1,
+      ObjectLayer inObject2
+    ) const override {
+      switch (inObject1) {
+        case Layers::NON_MOVING:
+          return inObject2 == Layers::MOVING;
+        case Layers::MOVING:
+          return true;
+        default:
+          JPH_ASSERT(false);
+          return false;
+      }
+    }
+};
+
+namespace BroadPhaseLayers {
+  static constexpr BroadPhaseLayer NON_MOVING(0);
+  static constexpr BroadPhaseLayer MOVING(1);
+  static constexpr uint NUM_LAYERS(2);
+};
+
+
+class BPLayerInterfaceImpl final : public BroadPhaseLayerInterface {
+  public:
+    BPLayerInterfaceImpl() {
+    mObjectToBroadPhase[Layers::NON_MOVING] = BroadPhaseLayers::NON_MOVING;
+    mObjectToBroadPhase[Layers::MOVING] = BroadPhaseLayers::MOVING;
+  }
+
+  virtual uint GetNumBroadPhaseLayers() const override {
+    return BroadPhaseLayers::NUM_LAYERS;
+  }
+
+  virtual BroadPhaseLayer GetBroadPhaseLayer(
+    ObjectLayer inLayer
+  ) const override {
+    JPH_ASSERT(inLayer < Layers::NUM_LAYERS);
+    return mObjectToBroadPhase[inLayer];
+  }
+
+  #if defined(JPH_EXTERNAL_PROFILE) || defined(JPH_PROFILE_ENABLED)
+    virtual const char * GetBroadPhaseLayerName(
+      BroadPhaseLayer inLayer
+    ) const override {
+      switch ((BroadPhaseLayer::Type)inLayer) {
+        case (BroadPhaseLayer::Type)BroadPhaseLayers::NON_MOVING:
+          return "NON_MOVING";
+        case (BroadPhaseLayer::Type)BroadPhaseLayers::MOVING:
+          return "MOVING";
+        default:
+          JPH_ASSERT(false); return "INVALID";
+      }
+    }
+  #endif
+
+  private:
+    BroadPhaseLayer mObjectToBroadPhase[Layers::NUM_LAYERS];
+};
+
+class ObjectVsBroadPhaseLayerFilterImpl : public ObjectVsBroadPhaseLayerFilter {
+  public:
+    virtual bool ShouldCollide(
+      ObjectLayer inLayer1,
+      BroadPhaseLayer inLayer2
+    ) const override {
+      switch (inLayer1) {
+        case Layers::NON_MOVING:
+          return inLayer2 == BroadPhaseLayers::MOVING;
+        case Layers::MOVING:
+          return true;
+        default:
+          JPH_ASSERT(false);
+          return false;
+      }
+    }
+};
+
+// An example contact listener
+class MyContactListener : public ContactListener {
+  public:
+    // See: ContactListener
+    virtual ValidateResult OnContactValidate(
+      const Body &inBody1,
+      const Body &inBody2,
+      RVec3Arg inBaseOffset,
+      const CollideShapeResult &inCollisionResult
+    ) override {
+      // std::cout << "Contact validate callback" << std::endl;
+      return ValidateResult::AcceptAllContactsForThisBodyPair;
+    }
+
+    virtual void OnContactAdded(
+      const Body &inBody1,
+      const Body &inBody2,
+      const ContactManifold &inManifold,
+      ContactSettings &ioSettings
+    ) override {
+      // std::cout << "A contact was added" << std::endl;
+    }
+
+    virtual void OnContactPersisted(
+      const Body &inBody1,
+      const Body &inBody2,
+      const ContactManifold &inManifold,
+      ContactSettings &ioSettings
+    ) override {
+      // std::cout << "A contact was persisted" << std::endl;
+    }
+
+    virtual void OnContactRemoved(
+      const SubShapeIDPair &inSubShapePair
+    ) override {
+      // std::cout << "A contact was removed" << std::endl;
+    }
+};
+
+// An example activation listener
+class MyBodyActivationListener : public BodyActivationListener {
+  public:
+    virtual void OnBodyActivated(
+      const BodyID &inBodyID,
+      uint64 inBodyUserData
+    ) override {
+      // std::cout << "A body got activated" << std::endl;
+    }
+
+    virtual void OnBodyDeactivated(
+      const BodyID &inBodyID,
+      uint64 inBodyUserData
+    ) override {
+      // std::cout << "A body went to sleep" << std::endl;
+    }
+};
+
+const uint cMaxBodies = 1024;
+const uint cNumBodyMutexes = 0;
+const uint cMaxBodyPairs = 1024;
+const uint cMaxContactConstraints = 1024;
+BPLayerInterfaceImpl broadPhaseLayerInterface;
+ObjectVsBroadPhaseLayerFilterImpl objectVsBroadPhaseLayerFilter;
+ObjectLayerPairFilterImpl objectVsObjectLayerFilter;
+MyBodyActivationListener bodyActivationListener;
+MyContactListener contactListener;
+
+std::shared_ptr<Game> PhysicsManager::getGame() {
+  auto g = game.lock();
+  assertNotNull(g, "Game is null");
+  return g;
+}
+
+BodyInterface & PhysicsManager::getBodyInterface() {
+  return physicsSystem.GetBodyInterface();
+}
+
+void PhysicsManager::init(const std::shared_ptr<Game> &game) {
+  this->game = game;
+
+  RegisterDefaultAllocator();
+
+  Trace = TraceImpl;
+	JPH_IF_ENABLE_ASSERTS(AssertFailed = AssertFailedImpl;)
+
+  Factory::sInstance = new Factory();
+  RegisterTypes();
+
+  tempAllocator = std::make_shared<TempAllocatorImpl>(10 * 1024 * 1024);
+  jobSystem = std::make_shared<JobSystemThreadPool>(
+    cMaxPhysicsJobs,
+    cMaxPhysicsBarriers,
+    thread::hardware_concurrency() - 1
+  );
+
+  physicsSystem.Init(
+    cMaxBodies,
+    cNumBodyMutexes,
+    cMaxBodyPairs,
+    cMaxContactConstraints,
+    broadPhaseLayerInterface,
+    objectVsBroadPhaseLayerFilter,
+    objectVsObjectLayerFilter
+  );
+
+  physicsSystem.SetBodyActivationListener(&bodyActivationListener);
+
+  physicsSystem.SetContactListener(&contactListener);
+
+  BodyInterface &bodyInterface = physicsSystem.GetBodyInterface();
+
+  BoxShapeSettings floorShapeSettings(Vec3(100.0f, 1.0f, 100.0f));
+  floorShapeSettings.SetEmbedded();
+  ShapeSettings::ShapeResult floorShapeResult = floorShapeSettings.Create();
+  ShapeRefC floorShape = floorShapeResult.Get();
+  BodyCreationSettings floorSettings(
+    floorShape,
+    RVec3(0.0_r, -1.0_r, 0.0_r),
+    Quat::sIdentity(),
+    EMotionType::Static,
+    Layers::NON_MOVING
+  );
+  Body *floor = bodyInterface.CreateBody(floorSettings);
+  bodyInterface.AddBody(floor->GetID(), EActivation::DontActivate);
+
+  // BodyCreationSettings sphereSettings(
+  //   new SphereShape(0.5f),
+  //   RVec3(0.0_r, 2.0_r, 0.0_r),
+  //   Quat::sIdentity(),
+  //   EMotionType::Dynamic,
+  //   Layers::MOVING
+  // );
+  // sphereId = bodyInterface.CreateAndAddBody(
+  //   sphereSettings,
+  //   EActivation::Activate
+  // );
+  // bodyInterface.SetLinearVelocity(sphereId, Vec3(0.0f, -5.0f, 0.0f));
+  // physicsSystem.OptimizeBroadPhase();
+}
+
+void PhysicsManager::update() {
+  BodyInterface &bodyInterface = physicsSystem.GetBodyInterface();
+
+  const float cDeltaTime = getGame()->timeManager.delta;
+  const int cCollisionSteps = 1;
+
+  auto scene = getGame()->getCurrentScene();
+  if(scene == nullptr) return;
+
+  // // Now we're ready to simulate the body, keep simulating until it goes to sleep
+  // uint step = 0;
+  // if(!bodyInterface.IsActive(sphereId)) return;
+  // // ++step;
+
+  // // Output current position and velocity of the sphere
+  // RVec3 position = bodyInterface.GetCenterOfMassPosition(sphereId);
+  // Vec3 velocity = bodyInterface.GetLinearVelocity(sphereId);
+
+  // Step the world
+  physicsSystem.Update(
+    cDeltaTime,
+    cCollisionSteps,
+    tempAllocator.get(),
+    jobSystem.get()
+  );
+
+  auto colliders = scene->findComponents<Collider>();
+  for(auto &collider : colliders) {
+    auto bodyId = collider->getBodyId();
+    if(!bodyInterface.IsActive(bodyId)) continue;
+
+    auto pos = bodyInterface.GetCenterOfMassPosition(bodyId);
+    auto rot = bodyInterface.GetRotation(bodyId);
+    collider->getItem()->setLocalPosition(glm::vec3(pos.GetX(), pos.GetY(), pos.GetZ()));
+    collider->getItem()->setLocalRotation(glm::quat(rot.GetW(), rot.GetX(), rot.GetY(), rot.GetZ()));
+  }
+}
+
+PhysicsManager::~PhysicsManager() {
+  BodyInterface &bodyInterface = physicsSystem.GetBodyInterface();
+
+  // bodyInterface.RemoveBody(sphereId);
+  // bodyInterface.DestroyBody(sphereId);
+
+  // Remove and destroy the floor
+  // bodyInterface.RemoveBody(floor->GetID());
+  // bodyInterface.DestroyBody(floor->GetID());
+
+  tempAllocator = nullptr;
+  jobSystem = nullptr;
+
+  UnregisterTypes();
+  delete Factory::sInstance;
+  Factory::sInstance = nullptr;
+
+  game.reset();
+}

src/dawn/physics/PhysicsManager.hpp

@@ -0,0 +1,54 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+
+namespace Dawn {
+  class Game;
+
+  class PhysicsManager final {
+    private:
+      std::weak_ptr<Game> game;
+
+    protected:
+      JPH::PhysicsSystem physicsSystem;
+      std::shared_ptr<JPH::TempAllocatorImpl> tempAllocator;
+      std::shared_ptr<JPH::JobSystemThreadPool> jobSystem;
+
+    public:
+
+      /**
+       * Gets the game associated with the PhysicsManager.
+       * 
+       * @return The game associated with the PhysicsManager.
+       */
+      std::shared_ptr<Game> getGame();
+
+      /**
+       * Gets the JoltPhysics body interface system.
+       * 
+       * @return The JoltPhysics body interface system.
+       */
+      JPH::BodyInterface & getBodyInterface();
+
+      /**
+       * Initializes the PhysicsManager.
+       * 
+       * @param game The game to initialize the PhysicsManager with.
+       */
+      void init(const std::shared_ptr<Game> &game);
+
+      /**
+       * Updates the PhysicsManager.
+       */
+      void update();
+
+      /**
+       * Deconstructs the PhysicsManager.
+       */
+      ~PhysicsManager();
+  };
+}

src/dawnrpg/scene/CMakeLists.txt

@@ -6,4 +6,5 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     HelloWorldScene.cpp
+    RPGScene.cpp
 )

src/dawnrpg/scene/HelloWorldScene.cpp

@@ -7,42 +7,62 @@
 #include "scene/SceneList.hpp"
 #include "component/display/Camera.hpp"
 #include "prefab/SimpleSpinningCube.hpp"
-#include "component/display/material/SimpleTexturedMaterial.hpp"
-#include "component/ui/UICanvas.hpp"
-#include "asset/loader/TextureLoader.hpp"
 
-#include "component/RPGEntity.hpp"
+#include "component/display/material/SimpleTexturedMaterial.hpp"
-#include "component/RPGPlayer.hpp"
+#include "component/display/MeshRenderer.hpp"
+#include "display/mesh/CubeMesh.hpp"
+#include "component/physics/BoxCollider.hpp"
 
 using namespace Dawn;
 
 void Dawn::helloWorldScene(Scene &s) {
-  auto textureRosa = s.getGame()->assetManager->get<TextureLoader>("rosa.texture");
-
-  while(!s.getGame()->assetManager->isEverythingLoaded()) {
-    s.getGame()->assetManager->update();
-  }
-
   auto cameraItem = s.createSceneItem();
   auto camera = cameraItem->addComponent<Camera>();
+  cameraItem->lookAt({ 5, 5, 5 }, { 0, 0, 0 }, { 0, 1, 0 });
   camera->clipFar = 99999.99f;
 
-  // Player:
+  // Ground
   {
-    auto ent = s.createSceneItem();
+    // Create the scene item.
-    ent->setLocalPosition(glm::vec3(0, 0, 0.00f));
+    auto cubeItem = s.createSceneItem();
-    auto eEnt = ent->addComponent<RPGEntity>();
+    cubeItem->setLocalPosition(glm::vec3(0, 10, 0));
-    auto ePlyr = ent->addComponent<RPGPlayer>();
+
-    ePlyr->camera = camera;
+    // Create a simple cube mesh.
+    auto cubeMesh = std::make_shared<Mesh>();
+    cubeMesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
+    CubeMesh::buffer(cubeMesh, glm::vec3(-1, -1, -1), glm::vec3(2, 2, 2), 0, 0);
+
+    // Add a renderer to the scene item.
+    auto cubeMeshRenderer = cubeItem->addComponent<MeshRenderer>();
+    cubeMeshRenderer->mesh = cubeMesh;
+
+    // Add a material to the scene item.
+    auto cubeMaterial = cubeItem->addComponent<SimpleTexturedMaterial>();
+    cubeMaterial->setColor(COLOR_MAGENTA);
+
+    // Add collider
+    auto boxCollider = cubeItem->addComponent<BoxCollider>();
   }
 
-  // Test Entity
   {
-    auto ent = s.createSceneItem();
+    // Create the scene item.
-    ent->setLocalPosition(glm::vec3(-128, -32, -0.01f));
+    auto cubeItem = s.createSceneItem();
-    auto eEnt = ent->addComponent<RPGEntity>();
+    cubeItem->setLocalPosition(glm::vec3(0.88f, 13, 0.1f));
-  }
 
-  auto uiCanvasItem = s.createSceneItem();
+    // Create a simple cube mesh.
-  auto uiCanvas = uiCanvasItem->addComponent<UICanvas>();
+    auto cubeMesh = std::make_shared<Mesh>();
+    cubeMesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
+    CubeMesh::buffer(cubeMesh, glm::vec3(-1, -1, -1), glm::vec3(2, 2, 2), 0, 0);
+
+    // Add a renderer to the scene item.
+    auto cubeMeshRenderer = cubeItem->addComponent<MeshRenderer>();
+    cubeMeshRenderer->mesh = cubeMesh;
+
+    // Add a material to the scene item.
+    auto cubeMaterial = cubeItem->addComponent<SimpleTexturedMaterial>();
+    cubeMaterial->setColor(COLOR_MAGENTA);
+
+    // Add collider
+    auto boxCollider = cubeItem->addComponent<BoxCollider>();
+  }
 }

src/dawnrpg/scene/RPGScene.cpp

@@ -0,0 +1,48 @@
+
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "scene/SceneList.hpp"
+#include "component/display/Camera.hpp"
+#include "prefab/SimpleSpinningCube.hpp"
+#include "component/display/material/SimpleTexturedMaterial.hpp"
+#include "component/ui/UICanvas.hpp"
+#include "asset/loader/TextureLoader.hpp"
+
+#include "component/RPGEntity.hpp"
+#include "component/RPGPlayer.hpp"
+
+using namespace Dawn;
+
+void Dawn::rpgScene(Scene &s) {
+  auto textureRosa = s.getGame()->assetManager->get<TextureLoader>("rosa.texture");
+
+  while(!s.getGame()->assetManager->isEverythingLoaded()) {
+    s.getGame()->assetManager->update();
+  }
+
+  auto cameraItem = s.createSceneItem();
+  auto camera = cameraItem->addComponent<Camera>();
+  camera->clipFar = 99999.99f;
+
+  // Player:
+  {
+    auto ent = s.createSceneItem();
+    ent->setLocalPosition(glm::vec3(0, 0, 0.00f));
+    auto eEnt = ent->addComponent<RPGEntity>();
+    auto ePlyr = ent->addComponent<RPGPlayer>();
+    ePlyr->camera = camera;
+  }
+
+  // Test Entity
+  {
+    auto ent = s.createSceneItem();
+    ent->setLocalPosition(glm::vec3(-128, -32, -0.01f));
+    auto eEnt = ent->addComponent<RPGEntity>();
+  }
+
+  auto uiCanvasItem = s.createSceneItem();
+  auto uiCanvas = uiCanvasItem->addComponent<UICanvas>();
+}

src/dawnrpg/scene/SceneList.hpp

@@ -8,4 +8,5 @@
 
 namespace Dawn {
   void helloWorldScene(Scene &s);
+  void rpgScene(Scene &s);
 }