feat(rendering): add generic camera component to hold the projection …

…matrix of a specific camera

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Binary Serializer and Deserializer (#1306, **@RiscadoA**).
 - Type Client and Type Server (#1302, **@RiscadoA**).
 - Deadzone for input axis (#844, **@kuukitenshi**)
+- Generic Camera component to hold projection matrix (#1331, **@mkuritsu**)
 
 ### Fixed
 

engine/CMakeLists.txt

@@ -129,6 +129,7 @@ set(CUBOS_ENGINE_SOURCE
 	"src/render/camera/plugin.cpp"
 	"src/render/camera/perspective_camera.cpp"
 	"src/render/camera/draws_to.cpp"
+	"src/render/camera/camera.cpp"
 	"src/render/voxels/plugin.cpp"
 	"src/render/voxels/load.cpp"
 	"src/render/voxels/grid.cpp"

engine/include/cubos/engine/render/camera/camera.hpp

@@ -0,0 +1,28 @@
+/// @file
+/// @brief Component @ref cubos::engine::Camera
+/// @ingroup render-camera-plugin
+
+#pragma once
+
+#include <glm/mat4x4.hpp>
+
+#include <cubos/core/reflection/reflect.hpp>
+
+#include <cubos/engine/api.hpp>
+
+namespace cubos::engine
+{
+    /// @brief Generic component to hold the projection matrix of a specific camera (either perspective or orthogonal).
+    /// @note Added automatically once a specific camera is added (e.g @ref cubos::engine::PerspectiveCamera).
+    /// @ingroup render-camera-plugin
+    struct CUBOS_ENGINE_API Camera
+    {
+        CUBOS_REFLECT;
+
+        /// @brief Whether the camera is drawing to a target.
+        bool active{true};
+
+        /// @brief Projection matrix of the camera.
+        glm::mat4 projection{};
+    };
+} // namespace cubos::engine

engine/include/cubos/engine/render/camera/perspective_camera.hpp

@@ -17,9 +17,6 @@ namespace cubos::engine
     {
         CUBOS_REFLECT;
 
-        /// @brief Whether the camera is drawing to a target.
-        bool active = true;
-
         /// @brief Vertical field of view in degrees.
         float fovY = 60.0F;
 

engine/src/gizmos/plugin.cpp

@@ -6,8 +6,8 @@
 
 #include <cubos/engine/gizmos/plugin.hpp>
 #include <cubos/engine/gizmos/target.hpp>
+#include <cubos/engine/render/camera/camera.hpp>
 #include <cubos/engine/render/camera/draws_to.hpp>
-#include <cubos/engine/render/camera/perspective_camera.hpp>
 #include <cubos/engine/render/camera/plugin.hpp>
 #include <cubos/engine/render/picker/picker.hpp>
 #include <cubos/engine/render/picker/plugin.hpp>
@@ -106,7 +106,7 @@ void cubos::engine::gizmosPlugin(Cubos& cubos)
         .tagged(drawToRenderPickerTag)
         .call([](Gizmos& gizmos, GizmosRenderer& gizmosRenderer, const DeltaTime& deltaTime,
                  Query<Entity, RenderTarget&, RenderPicker&, GizmosTarget&> targets,
-                 Query<const LocalToWorld&, const PerspectiveCamera&, const DrawsTo&> cameras) {
+                 Query<const LocalToWorld&, const Camera&, const DrawsTo&> cameras) {
             auto& rd = *gizmosRenderer.renderDevice;
             auto orthoVP =
                 glm::translate(glm::mat4(1.0F), glm::vec3(-1.0F, -1.0F, 0.0F)) * glm::ortho(-0.5F, 0.5F, -0.5F, 0.5F);
@@ -156,11 +156,7 @@ void cubos::engine::gizmosPlugin(Cubos& cubos)
                                   static_cast<int>(drawsTo.viewportSize.y * static_cast<float>(target.size.y)));
 
                     // Prepare camera projection (TODO: fetch this matrix from a Camera component).
-                    auto worldVP = glm::perspective(glm::radians(camera.fovY),
-                                                    (drawsTo.viewportSize.x * static_cast<float>(target.size.x)) /
-                                                        (drawsTo.viewportSize.y * static_cast<float>(target.size.y)),
-                                                    camera.zNear, camera.zFar) *
-                                   glm::inverse(localToWorld.mat);
+                    auto worldVP = camera.projection * glm::inverse(localToWorld.mat);
 
                     // Draw world-space gizmos.
                     rd.setDepthStencilState(gizmosRenderer.doDepthCheckStencilState);
@@ -209,11 +205,7 @@ void cubos::engine::gizmosPlugin(Cubos& cubos)
                                   static_cast<int>(drawsTo.viewportSize.y * static_cast<float>(target.size.y)));
 
                     // Prepare camera projection (TODO: fetch this matrix from a Camera component).
-                    auto worldVP = glm::perspective(glm::radians(camera.fovY),
-                                                    (drawsTo.viewportSize.x * static_cast<float>(target.size.x)) /
-                                                        (drawsTo.viewportSize.y * static_cast<float>(target.size.y)),
-                                                    camera.zNear, camera.zFar) *
-                                   glm::inverse(localToWorld.mat);
+                    auto worldVP = camera.projection * glm::inverse(localToWorld.mat);
 
                     // Draw world-space gizmos.
                     rd.setDepthStencilState(gizmosRenderer.doDepthCheckStencilState);

engine/src/render/camera/camera.cpp

@@ -0,0 +1,13 @@
+#include <cubos/core/ecs/reflection.hpp>
+#include <cubos/core/reflection/external/glm.hpp>
+#include <cubos/core/reflection/external/primitives.hpp>
+
+#include <cubos/engine/render/camera/camera.hpp>
+
+CUBOS_REFLECT_IMPL(cubos::engine::Camera)
+{
+    return core::ecs::TypeBuilder<Camera>("cubos::engine::Camera")
+        .withField("active", &Camera::active)
+        .withField("projection", &Camera::projection)
+        .build();
+}

engine/src/render/camera/draws_to.cpp

@@ -6,6 +6,7 @@
 CUBOS_REFLECT_IMPL(cubos::engine::DrawsTo)
 {
     return core::ecs::TypeBuilder<DrawsTo>("cubos::engine::DrawsTo")
+        .tree()
         .withField("viewportOffset", &DrawsTo::viewportOffset)
         .withField("viewportSize", &DrawsTo::viewportSize)
         .build();

engine/src/render/camera/perspective_camera.cpp

@@ -6,7 +6,6 @@
 CUBOS_REFLECT_IMPL(cubos::engine::PerspectiveCamera)
 {
     return core::ecs::TypeBuilder<PerspectiveCamera>("cubos::engine::PerspectiveCamera")
-        .withField("active", &PerspectiveCamera::active)
         .withField("fovY", &PerspectiveCamera::fovY)
         .withField("zNear", &PerspectiveCamera::zNear)
         .withField("zFar", &PerspectiveCamera::zFar)

engine/src/render/camera/plugin.cpp

@@ -1,10 +1,44 @@
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <cubos/engine/render/camera/camera.hpp>
 #include <cubos/engine/render/camera/draws_to.hpp>
 #include <cubos/engine/render/camera/perspective_camera.hpp>
 #include <cubos/engine/render/camera/plugin.hpp>
+#include <cubos/engine/render/target/plugin.hpp>
+#include <cubos/engine/render/target/target.hpp>
+
+using namespace cubos::engine;
 
 void cubos::engine::cameraPlugin(Cubos& cubos)
 {
+    cubos.depends(renderTargetPlugin);
+
     cubos.component<PerspectiveCamera>();
+    cubos.component<Camera>();
 
     cubos.relation<DrawsTo>();
+
+    cubos.observer("add Camera on add PerspectiveCamera")
+        .onAdd<PerspectiveCamera>()
+        .without<Camera>()
+        .call([](Commands cmds, Query<Entity> query) {
+            for (auto [ent] : query)
+            {
+                cmds.add(ent, Camera{});
+            }
+        });
+
+    cubos.system("update Camera projection by PerspectiveCamera")
+        .call([](Query<Camera&, const PerspectiveCamera&, const DrawsTo&, const RenderTarget&> query) {
+            for (auto [camera, perspective, drawsTo, target] : query)
+            {
+                float aspect = (static_cast<float>(target.size.x) * drawsTo.viewportSize.x) /
+                               (static_cast<float>(target.size.y) * drawsTo.viewportSize.y);
+                if (aspect > 0)
+                {
+                    camera.projection =
+                        glm::perspective(glm::radians(perspective.fovY), aspect, perspective.zNear, perspective.zFar);
+                }
+            }
+        });
 }

engine/src/render/deferred_shading/plugin.cpp

@@ -2,8 +2,8 @@
 #include <cubos/core/io/window.hpp>
 
 #include <cubos/engine/assets/plugin.hpp>
+#include <cubos/engine/render/camera/camera.hpp>
 #include <cubos/engine/render/camera/draws_to.hpp>
-#include <cubos/engine/render/camera/perspective_camera.hpp>
 #include <cubos/engine/render/camera/plugin.hpp>
 #include <cubos/engine/render/deferred_shading/deferred_shading.hpp>
 #include <cubos/engine/render/deferred_shading/plugin.hpp>
@@ -177,13 +177,13 @@ void cubos::engine::deferredShadingPlugin(Cubos& cubos)
                  Query<const LocalToWorld&, const PointLight&> pointLights,
                  Query<const LocalToWorld&, const SpotLight&, Opt<const SpotShadowCaster&>> spotLights,
                  Query<Entity, const HDR&, const GBuffer&, const SSAO&, DeferredShading&> targets,
-                 Query<const LocalToWorld&, const PerspectiveCamera&, const DrawsTo&> perspectiveCameras) {
+                 Query<const LocalToWorld&, const Camera&, const DrawsTo&> cameras) {
             auto& rd = window->renderDevice();
 
             for (auto [targetEnt, hdr, gBuffer, ssao, deferredShading] : targets)
             {
                 // Find the cameras that draw to the GBuffer.
-                for (auto [localToWorld, camera, drawsTo] : perspectiveCameras.pin(1, targetEnt))
+                for (auto [localToWorld, camera, drawsTo] : cameras.pin(1, targetEnt))
                 {
                     if (!camera.active)
                     {
@@ -213,11 +213,7 @@ void cubos::engine::deferredShadingPlugin(Cubos& cubos)
                     // Fill the PerScene constant buffer.
                     PerScene perScene{};
                     perScene.inverseView = localToWorld.mat;
-                    perScene.inverseProjection =
-                        glm::inverse(glm::perspective(glm::radians(camera.fovY),
-                                                      (float(gBuffer.size.x) * drawsTo.viewportSize.x) /
-                                                          (float(gBuffer.size.y) * drawsTo.viewportSize.y),
-                                                      camera.zNear, camera.zFar));
+                    perScene.inverseProjection = glm::inverse(camera.projection);
 
                     perScene.ambientLight = glm::vec4(environment.ambient, 1.0F);
                     perScene.skyGradient[0] = glm::vec4(environment.skyGradient[0], 1.0F);

engine/src/render/g_buffer_rasterizer/plugin.cpp

@@ -2,8 +2,8 @@
 #include <cubos/core/reflection/external/uuid.hpp>
 
 #include <cubos/engine/assets/plugin.hpp>
+#include <cubos/engine/render/camera/camera.hpp>
 #include <cubos/engine/render/camera/draws_to.hpp>
-#include <cubos/engine/render/camera/perspective_camera.hpp>
 #include <cubos/engine/render/camera/plugin.hpp>
 #include <cubos/engine/render/depth/depth.hpp>
 #include <cubos/engine/render/depth/plugin.hpp>
@@ -142,10 +142,10 @@ void cubos::engine::gBufferRasterizerPlugin(Cubos& cubos)
 
     cubos.system("rasterize to GBuffer")
         .tagged(rasterizeToGBufferTag)
-        .with<PerspectiveCamera>()
+        .with<Camera>()
         .related<DrawsTo>()
         .call([](State& state, const Window& window, const RenderMeshPool& pool, const RenderPalette& palette,
-                 Assets& assets, Query<const LocalToWorld&, PerspectiveCamera&, const DrawsTo&> perspectiveCameras,
+                 Assets& assets, Query<const LocalToWorld&, Camera&, const DrawsTo&> cameras,
                  Query<Entity, GBufferRasterizer&, GBuffer&, RenderDepth&, RenderPicker&> targets,
                  Query<Entity, const LocalToWorld&, const RenderMesh&, const RenderVoxelGrid&> meshes) {
             auto& rd = window->renderDevice();
@@ -233,7 +233,7 @@ void cubos::engine::gBufferRasterizerPlugin(Cubos& cubos)
                 }
 
                 // Find the active cameras for this target.
-                for (auto [cameraLocalToWorld, camera, drawsTo] : perspectiveCameras.pin(1, ent))
+                for (auto [cameraLocalToWorld, camera, drawsTo] : cameras.pin(1, ent))
                 {
                     // Skip inactive cameras.
                     if (!camera.active)
@@ -243,10 +243,7 @@ void cubos::engine::gBufferRasterizerPlugin(Cubos& cubos)
 
                     // Send the PerScene data to the GPU.
                     auto view = glm::inverse(cameraLocalToWorld.mat);
-                    auto proj = glm::perspective(glm::radians(camera.fovY),
-                                                 (float(gBuffer.size.x) * drawsTo.viewportSize.x) /
-                                                     (float(gBuffer.size.y) * drawsTo.viewportSize.y),
-                                                 camera.zNear, camera.zFar);
+                    auto proj = camera.projection;
                     PerScene perScene{.viewProj = proj * view};
                     state.perSceneCB->fill(&perScene, sizeof(perScene));
 

engine/src/render/split_screen/plugin.cpp

@@ -1,7 +1,7 @@
 #include <glm/vec2.hpp>
 
+#include <cubos/engine/render/camera/camera.hpp>
 #include <cubos/engine/render/camera/draws_to.hpp>
-#include <cubos/engine/render/camera/perspective_camera.hpp>
 #include <cubos/engine/render/camera/plugin.hpp>
 #include <cubos/engine/render/split_screen/plugin.hpp>
 #include <cubos/engine/render/split_screen/split_screen.hpp>
@@ -62,48 +62,46 @@ void cubos::engine::splitScreenPlugin(Cubos& cubos)
 
     cubos.system("split screen for each DrawsTo relation")
         .tagged(splitScreenTag)
-        .call(
-            [](Query<Entity, const RenderTarget&> targets,
-               Query<const LocalToWorld&, const PerspectiveCamera&, DrawsTo&, const SplitScreen&> perspectiveCameras) {
-                for (auto [targetEnt, target] : targets)
+        .call([](Query<Entity, const RenderTarget&> targets,
+                 Query<const LocalToWorld&, const Camera&, DrawsTo&, const SplitScreen&> cameras) {
+            for (auto [targetEnt, target] : targets)
+            {
+                int cameraCount = 0;
+
+                // Find the cameras that draw to the target.
+                for (auto [localToWorld, camera, drawsTo, splitScreen] : cameras.pin(1, targetEnt))
                 {
-                    int cameraCount = 0;
+                    // Ignore unused argument warnings
+                    (void)splitScreen;
 
-                    // Find the cameras that draw to the target.
-                    for (auto [localToWorld, camera, drawsTo, splitScreen] : perspectiveCameras.pin(1, targetEnt))
+                    if (!camera.active)
                     {
-                        // Ignore unused argument warnings
-                        (void)splitScreen;
+                        continue;
+                    }
 
-                        if (!camera.active)
-                        {
-                            continue;
-                        }
+                    cameraCount += 1;
+                }
 
-                        cameraCount += 1;
-                    }
+                std::vector<glm::ivec2> positions(static_cast<unsigned long>(cameraCount));
+                std::vector<glm::ivec2> sizes(static_cast<unsigned long>(cameraCount));
 
-                    std::vector<glm::ivec2> positions(static_cast<unsigned long>(cameraCount));
-                    std::vector<glm::ivec2> sizes(static_cast<unsigned long>(cameraCount));
+                setViewportCameras({0, 0}, target.size, cameraCount, positions.begin(), sizes.begin());
 
-                    setViewportCameras({0, 0}, target.size, cameraCount, positions.begin(), sizes.begin());
+                unsigned long i = 0;
+                for (auto [localToWorld, camera, drawsTo, splitScreen] : cameras.pin(1, targetEnt))
+                {
+                    // Ignore unused argument warnings
+                    (void)splitScreen;
 
-                    unsigned long i = 0;
-                    for (auto [localToWorld, camera, drawsTo, splitScreen] : perspectiveCameras.pin(1, targetEnt))
+                    if (!camera.active)
                     {
-                        // Ignore unused argument warnings
-                        (void)splitScreen;
-
-                        if (!camera.active)
-                        {
-                            continue;
-                        }
-
-                        drawsTo.viewportOffset =
-                            static_cast<glm::vec2>(positions[i]) / static_cast<glm::vec2>(target.size);
-                        drawsTo.viewportSize = static_cast<glm::vec2>(sizes[i]) / static_cast<glm::vec2>(target.size);
-                        i++;
+                        continue;
                     }
+
+                    drawsTo.viewportOffset = static_cast<glm::vec2>(positions[i]) / static_cast<glm::vec2>(target.size);
+                    drawsTo.viewportSize = static_cast<glm::vec2>(sizes[i]) / static_cast<glm::vec2>(target.size);
+                    i++;
                 }
-            });
+            }
+        });
 }

engine/src/render/ssao/plugin.cpp

@@ -5,8 +5,8 @@
 #include <cubos/core/io/window.hpp>
 
 #include <cubos/engine/assets/plugin.hpp>
+#include <cubos/engine/render/camera/camera.hpp>
 #include <cubos/engine/render/camera/draws_to.hpp>
-#include <cubos/engine/render/camera/perspective_camera.hpp>
 #include <cubos/engine/render/camera/plugin.hpp>
 #include <cubos/engine/render/g_buffer/g_buffer.hpp>
 #include <cubos/engine/render/g_buffer/plugin.hpp>
@@ -146,7 +146,7 @@ void cubos::engine::ssaoPlugin(Cubos& cubos)
     cubos.system("apply SSAO to the GBuffer and output to the SSAO texture")
         .tagged(drawToSSAOTag)
         .call([](State& state, const Window& window, Query<Entity, const GBuffer&, SSAO&> targets,
-                 Query<const LocalToWorld&, const PerspectiveCamera&, const DrawsTo&> perspectiveCameras) {
+                 Query<const LocalToWorld&, const Camera&, const DrawsTo&> cameras) {
             auto& rd = window->renderDevice();
 
             for (auto [targetEnt, gBuffer, ssao] : targets)
@@ -188,7 +188,7 @@ void cubos::engine::ssaoPlugin(Cubos& cubos)
                 }
 
                 // Find the cameras that draw to the SSAO target.
-                for (auto [localToWorld, camera, drawsTo] : perspectiveCameras.pin(1, targetEnt))
+                for (auto [localToWorld, camera, drawsTo] : cameras.pin(1, targetEnt))
                 {
                     if (!camera.active)
                     {
@@ -225,10 +225,7 @@ void cubos::engine::ssaoPlugin(Cubos& cubos)
                     // Fill the PerScene constant buffer.
                     PerScene perScene{};
                     perScene.view = glm::inverse(localToWorld.mat);
-                    perScene.projection = glm::perspective(glm::radians(camera.fovY),
-                                                           (float(gBuffer.size.x) * drawsTo.viewportSize.x) /
-                                                               (float(gBuffer.size.y) * drawsTo.viewportSize.y),
-                                                           camera.zNear, camera.zFar);
+                    perScene.projection = camera.projection;
                     for (std::size_t i = 0; i < state.kernel.size(); ++i)
                     {
                         perScene.samples[i] = glm::vec4(state.kernel[i], 0.0F);