added support for cameras to SfSystem + renamed MetaComponent to GraphicsComponent

Author: phisko

README.md

@@ -31,7 +31,7 @@ These are pre-built, extensible and pluggable elements that can be used in any p
 ##### Components
 
 * [LuaComponent](common/components/LuaComponent.md): defines the lua scripts to be run by the `LuaSystem` for a `GameObject`
-* [MetaComponent](common/components/MetaComponent.md): provides metadata about a `GameObject`, such as its appearance, used by the `SfSystem`
+* [GraphicsComponent](common/components/GraphicsComponent.md): provides graphical information about a `GameObject`, such as its appearance, used by the `SfSystem`
 * [TransformComponent](common/components/TransformComponent.md): defines a `GameObject`'s position and size
 * [PhysicsComponent](common/components/PhysicsComponent.md): defines a `GameObject`'s movement
 * [PathfinderComponent](common/components/PathfinderComponent.md): defines a `GameObject`'s pathfinding information
@@ -83,7 +83,7 @@ Below is a commented main function that creates an entity and attaches some comp
 
 #include "common/systems/LuaSystem.hpp"
 #include "common/systems/LogSystem.hpp"
-#include "common/components/MetaComponent.hpp"
+#include "common/components/GraphicsComponent.hpp"
 #include "common/components/TransformComponent.hpp"
 
 int main(int, char **av)
@@ -110,7 +110,7 @@ int main(int, char **av)
     // Create a GameObject and attach Components to it
     auto &player = em.createEntity<kengine::GameObject>("player");
     player.attachComponent<kengine::TransformComponent3d>();
-    player.attachComponent<kengine::MetaComponent>();
+    player.attachComponent<kengine::GraphicsComponent>();
 
     // Attach a lua script to a GameObject
     auto &luaComp = player.attachComponent<kengine::LuaComponent>();
@@ -122,7 +122,7 @@ int main(int, char **av)
         auto &lua = em.getSystem<kengine::LuaSystem>();
         lua.addScriptDirectory("scripts"); // The LuaSystem automatically opens the "scripts" directory, this is just an example
         lua.registerTypes<
-                kengine::MetaComponent,
+                kengine::GraphicsComponent,
                 kengine::TransformComponent3d, putils::Point<double, 3>, putils::Rect<double, 3>,
                 kengine::LuaComponent,
                 kengine::packets::Log
@@ -157,7 +157,7 @@ local new = createEntity("GameObject", "bob",
 local otherRef = getEntity("bob")
 
 -- attach a component
-local meta = new:attachMetaComponent()
+local meta = new:attachGraphicsComponent()
 meta.appearance = "human"
 
 local transform = new:attachTransformComponent()
@@ -172,7 +172,7 @@ for i, e in ipairs(getGameObjects()) do
 end
 
 -- iterate over specific entities
-for i, e in ipairs(getGameObjectsWithMetaComponent()) do
+for i, e in ipairs(getGameObjectsWithGraphicsComponent()) do
     local comp = e:getTransformComponent()
     print(comp)
 end

common/components/GraphicsComponent.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+#include "SerializableComponent.hpp"
+
+namespace kengine {
+    class GraphicsComponent : public kengine::SerializableComponent<GraphicsComponent>,
+                          public putils::Reflectible<GraphicsComponent> {
+    public:
+        GraphicsComponent(std::string_view appearance = "")
+                : appearance(appearance) {}
+
+        const std::string type = pmeta_nameof(GraphicsComponent);
+        std::string appearance;
+
+        /*
+         * Reflectible
+         */
+
+    public:
+        pmeta_get_class_name(GraphicsComponent);
+        pmeta_get_attributes(
+                pmeta_reflectible_attribute(&GraphicsComponent::type),
+                pmeta_reflectible_attribute(&GraphicsComponent::appearance)
+        );
+    };
+}

common/components/MetaComponent.md renamed to common/components/GraphicsComponent.md

@@ -1,4 +1,4 @@
-# [MetaComponent](MetaComponent.hpp)
+# [GraphicsComponent](GraphicsComponent.hpp)
 
 `Component` providing metadata about a `GameObject`, such as its appearance.
 

common/components/MetaComponent.hpp

@@ -43,10 +43,10 @@ This also defines the following function for lua scripts:
 * `sendT(T packet)` (e.g. `sendLog(Log packet)`): sends `packet` as a datapacket to all `Systems`
 
 If `T` is a `Component`, the following member functions is added to the `GameObject` lua type for lua scripts:
-* `getT()` (e.g. `getMetaComponent()`)
-* `hasT()` (e.g. `hasMetaComponent()`)
-* `attachT()` (e.g. `attachMetaComponent()`)
-* `detachT()` (e.g. `detachMetaComponent()`)
+* `getT()` (e.g. `getGraphicsComponent()`)
+* `hasT()` (e.g. `hasGraphicsComponent()`)
+* `attachT()` (e.g. `attachGraphicsComponent()`)
+* `detachT()` (e.g. `detachGraphicsComponent()`)
 
 A global `getGameObjectsWithT()` is also defined, that returns all the `GameObjects` with a `T` component.
 

common/systems/LuaSystem.md

@@ -9,7 +9,7 @@
 #include "OgreTextComponent.hpp"
 
 #include "common/components/TransformComponent.hpp"
-#include "common/components/MetaComponent.hpp"
+#include "common/components/GraphicsComponent.hpp"
 #include "common/components/CameraComponent.hpp"
 #include "common/components/GUIComponent.hpp"
 
@@ -159,7 +159,7 @@ void OgreSystem::execute()
 
 void OgreSystem::registerGameObject(kengine::GameObject &go)
 {
-    if (!go.hasComponent<kengine::MetaComponent>() && !go.hasComponent<kengine::CameraComponent3d>() && !go.hasComponent<kengine::GUIComponent>())
+    if (!go.hasComponent<kengine::GraphicsComponent>() && !go.hasComponent<kengine::CameraComponent3d>() && !go.hasComponent<kengine::GUIComponent>())
         return;
     ToSpawnLock _(_toSpawnMutex);
     _toSpawn.push_back(&go);
@@ -266,7 +266,7 @@ void OgreSystem::createEntity(kengine::GameObject &go) noexcept
         return;
     }
 
-    const auto &appearance = go.getComponent<kengine::MetaComponent>().appearance;
+    const auto &appearance = go.getComponent<kengine::GraphicsComponent>().appearance;
 
     if (appearance == "light")
     {

common/systems/ogre/OgreSystem.cpp

@@ -8,7 +8,7 @@
 
 ##### 'Normal' objects
 
-`OgreSystem` reads the mesh to be used for a `GameObject` from its [MetaComponent](../../components/MetaComponent.md)'s `appearance` property.
+`OgreSystem` reads the mesh to be used for a `GameObject` from its [GraphicsComponent](../../components/GraphicsComponent.md)'s `appearance` property.
 
 If `appearance` is *"light"*, `OgreSystem` will spawn a `PointLight` instead of a mesh.
 

common/systems/ogre/OgreSystem.md

@@ -6,6 +6,7 @@
 
 #include "common/systems/LuaSystem.hpp"
 #include "common/components/GUIComponent.hpp"
+#include "common/components/CameraComponent.hpp"
 
 EXPORT kengine::ISystem * getSystem(kengine::EntityManager & em) {
     return new kengine::SfSystem(em);
@@ -97,6 +98,23 @@ namespace kengine {
      */
 
     void SfSystem::execute() {
+        for (auto go : _em.getGameObjects<kengine::CameraComponent3d>()) {
+            auto & view = _engine.getView(go->getName());
+
+            const auto & frustrum = go->getComponent<kengine::CameraComponent3d>().frustrum;
+            view.setCenter(
+                    (float)(frustrum.topLeft.x + frustrum.size.x / 2) * _tileSize.x,
+                    (float)(frustrum.topLeft.z + frustrum.size.z / 2) * _tileSize.y
+            );
+            view.setSize((float)frustrum.size.x * _tileSize.x, (float)frustrum.size.z * _tileSize.y);
+
+            const auto & box = go->getComponent<kengine::TransformComponent3d>().boundingBox;
+            view.setViewport(sf::FloatRect{
+                    (float)box.topLeft.x, (float)box.topLeft.z,
+                    (float)box.size.x, (float)box.size.z
+            });
+            _engine.setViewHeight(go->getName(), (size_t)box.topLeft.y);
+        }
 
         // Update positions
         for (auto go : _em.getGameObjects<SfComponent>()) {
@@ -129,7 +147,6 @@ namespace kengine {
     }
 
     void SfSystem::handleEvents() noexcept {
-         // Event handling
         static const std::unordered_map<sf::Event::EventType, std::function<void(const sf::Event &)>> handlers {
                 {
                         {
@@ -212,7 +229,7 @@ namespace kengine {
 
     void SfSystem::handle(const kengine::packets::RegisterGameObject & p) {
         auto & go = p.go;
-        if (!go.hasComponent<SfComponent>() && !go.hasComponent<MetaComponent>() &&
+        if (!go.hasComponent<SfComponent>() && !go.hasComponent<GraphicsComponent>() &&
             !go.hasComponent<kengine::GUIComponent>())
             return;
 
@@ -238,14 +255,17 @@ namespace kengine {
         }
         catch (const std::exception & e) {
             send(kengine::packets::Log{
-                    putils::concat("[SfSystem] Unknown appearance: ", go.getComponent<MetaComponent>().appearance)
+                    putils::concat("[SfSystem] Unknown appearance: ", go.getComponent<GraphicsComponent>().appearance)
             });
         }
     }
 
     void SfSystem::handle(const kengine::packets::RemoveGameObject & p) {
         auto & go = p.go;
 
+        if (go.hasComponent<kengine::CameraComponent3d>() && _engine.hasView(go.getName()))
+            _engine.removeView(go.getName());
+
         if (!go.hasComponent<SfComponent>())
             return;
 
@@ -300,16 +320,14 @@ namespace kengine {
             return comp;
         }
 
-        const auto & meta = go.getComponent<MetaComponent>();
+        const auto & meta = go.getComponent<GraphicsComponent>();
 
         auto str = _appearances.find(meta.appearance) != _appearances.end()
                    ? _appearances.at(meta.appearance)
                    : meta.appearance;
 
         auto & comp = go.attachComponent<SfComponent>(
-                std::make_unique<pse::Sprite>(str,
-                                              sf::Vector2f{ 0, 0 },
-                                              sf::Vector2f{ 16, 16 })
+                std::make_unique<pse::Sprite>(str, sf::Vector2f{ 0, 0 }, sf::Vector2f{ 16, 16 })
         );
 
         return comp;

common/systems/sfml/SfSystem.cpp

@@ -2,7 +2,7 @@
 
 #include <SDL2/SDL.h>
 #include "System.hpp"
-#include "common/components/MetaComponent.hpp"
+#include "common/components/GraphicsComponent.hpp"
 #include "common/packets/RegisterAppearance.hpp"
 #include "common/packets/Input.hpp"
 #include "common/packets/RemoveGameObject.hpp"

common/systems/sfml/SfSystem.hpp

@@ -8,7 +8,7 @@
 
 ##### 'Normal' objects
 
-`SfSystem` reads the resource file to be used for a `GameObject` from its [MetaComponent](../../components/MetaComponent.md)'s `appearance` property.
+`SfSystem` reads the resource file to be used for a `GameObject` from its [GraphicsComponent](../../components/GraphicsComponent.md)'s `appearance` property.
 
 If `appearance` was previously registered as an abstract appearance through a [RegisterAppearance](../../packets/RegisterAppearance.hpp) datapacket, the resource file that was associated to it is loaded instead.
 
@@ -18,6 +18,16 @@ If `appearance` was previously registered as an abstract appearance through a [R
 /!\ That 3d is important! TransformComponent2d, 2i, 3i, 3f... Will not be detected!
 ```
 
+##### Cameras
+
+A *"default"* camera is added upon system construction, meaning typical use does not require any action. For further configuration of the rendered areas, `CameraComponents` can be used.
+
+If a `GameObject` is found to have a [CameraComponent](../../components/CameraComponent.hpp), a camera will be added to the scene.
+
+ The `CameraComponent`'s `frustrum` property defines the area to be rendered, whereas the `GameObject`'s `TransformComponent3d`'s `boundingBox` property defines the bounds of the viewport to be displayed.
+
+Refer to [the SFML website](https://www.sfml-dev.org/tutorials/2.0/graphics-view.php) for more information about viewports.
+
 ##### GUI
 
 If a `GameObject` is found to have a [GUIComponent](../../components/GUIComponent.md), it will be rendered as text using the information held in that `GUIComponent`.