refactor(engine): change gizmos structure to not have logic on resources

core/include/cubos/core/gl/render_device.hpp

@@ -884,7 +884,7 @@ namespace cubos::core::gl
         /// @param stencil Stencil value.
         virtual void clearStencil(int stencil) = 0;
 
-        /// @brief Draws Lines.
+        /// @brief Draws lines.
         /// @param offset Index of the first vertex to be drawn.
         /// @param count Number of vertices that will be drawn.
         virtual void drawLines(std::size_t offset, std::size_t count) = 0;

core/src/cubos/core/gl/ogl_render_device.cpp

@@ -842,8 +842,19 @@ class OGLVertexBuffer : public impl::VertexBuffer
 
     void* map() override
     {
+        GLenum glErr = glGetError();
+        if (glErr != 0)
+        {
+            LOG_GL_ERROR(glErr);
+        }
         glBindBuffer(GL_ARRAY_BUFFER, this->id);
-        return glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+        void* r = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+        glErr = glGetError();
+        if (glErr != 0)
+        {
+            LOG_GL_ERROR(glErr);
+        }
+        return r;
     }
 
     void unmap() override
@@ -1451,17 +1462,32 @@ void OGLRenderDevice::setFramebuffer(Framebuffer fb)
 
 RasterState OGLRenderDevice::createRasterState(const RasterStateDesc& desc)
 {
+    GLenum glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
     auto rs = std::make_shared<OGLRasterState>();
     rs->cullEnabled = static_cast<GLboolean>(desc.cullEnabled);
     rs->scissorEnabled = static_cast<GLboolean>(desc.scissorEnabled);
     faceToGL(desc.cullFace, rs->cullFace);
     windingToGL(desc.frontFace, rs->frontFace);
     rasterModeToGL(desc.rasterMode, rs->polygonMode);
+    glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
     return rs;
 }
 
 void OGLRenderDevice::setRasterState(RasterState rs)
 {
+    GLenum glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
     auto rsImpl = std::static_pointer_cast<OGLRasterState>(rs ? rs : mDefaultRS);
 
     if (rsImpl->cullEnabled == 0U)
@@ -1485,6 +1511,11 @@ void OGLRenderDevice::setRasterState(RasterState rs)
 
     glFrontFace(rsImpl->frontFace);
     glPolygonMode(GL_FRONT_AND_BACK, rsImpl->polygonMode);
+    glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
 }
 
 DepthStencilState OGLRenderDevice::createDepthStencilState(const DepthStencilStateDesc& desc)
@@ -2449,13 +2480,33 @@ void OGLRenderDevice::drawTriangles(std::size_t offset, std::size_t count)
 
 void OGLRenderDevice::drawLines(std::size_t offset, std::size_t count)
 {
+    GLenum glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
     glDrawArrays(GL_LINES, static_cast<GLint>(offset), static_cast<GLsizei>(count));
+    glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
 }
 
 void OGLRenderDevice::drawTrianglesIndexed(std::size_t offset, std::size_t count)
 {
+    GLenum glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
     glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(count), static_cast<GLenum>(mCurrentIndexFormat),
                    reinterpret_cast<const void*>(offset * mCurrentIndexSz));
+    glErr = glGetError();
+    if (glErr != 0)
+    {
+        LOG_GL_ERROR(glErr);
+    }
 }
 
 void OGLRenderDevice::drawTrianglesInstanced(std::size_t offset, std::size_t count, std::size_t instanceCount)

docs/pages/3_examples/2_engine/main.md

@@ -8,6 +8,7 @@ multiple plugins of the engine:
 - @subpage examples-engine-hello-cubos - @copybrief examples-engine-hello-cubos
 - @subpage examples-engine-settings - @copybrief examples-engine-settings
 - @subpage examples-engine-renderer - @copybrief examples-engine-renderer
+- @subpage examples-engine-gizmos - @copybrief examples-engine-gizmos
 - @subpage examples-engine-scene - @copybrief examples-engine-scene
 - @subpage examples-engine-input - @copybrief examples-engine-input
 - @subpage examples-engine-assets - @copybrief examples-engine-assets

engine/include/cubos/engine/gizmos/gizmos.hpp

@@ -11,22 +11,42 @@
 
 #include <cubos/engine/cubos.hpp>
 
-using cubos::core::gl::RenderDevice;
-using cubos::core::gl::ShaderPipeline;
-using cubos::engine::DeltaTime;
-
 namespace cubos::engine
 {
-    /// @brief Resource which draws gizmos.
+    /// @brief Resource that holds the information needed to draw a gizmo
+    class GizmosRenderer final
+    {
+    public:
+        cubos::core::gl::ShaderPipeline pipeline;    ///< Shader pipeline to be used when drawing gizmos
+        cubos::core::gl::RenderDevice* renderDevice; ///< Active render device
+
+        /// @brief Set of buffers and structs that hold te information needed to draw a specific type of mesh
+        struct Primitive
+        {
+            cubos::core::gl::VertexBuffer vb;
+            cubos::core::gl::VertexArray va;
+            cubos::core::gl::IndexBuffer ib;
+            cubos::core::gl::VertexArrayDesc vaDesc;
+        };
+
+        Primitive linePrimitive; ///< GL line information
+        Primitive boxPrimitive;  ///< GL box information
+
+        /// @brief Sets up the GizmosRenderer to be used
+        /// @param renderDevice the current RenderDevice being used
+        void init(cubos::core::gl::RenderDevice* renderDevice);
+
+    private:
+        void initLinePrimitive();
+        void initBoxPrimitive();
+    };
+
+    /// @brief Resource which queues for drawing gizmos, basic primitives useful for debugging and tools.
     ///
     /// @ingroup gizmos-plugin
     class Gizmos final
     {
     public:
-        /// @brief Initiates the Gizmos resource.
-        /// @param renderDevice Active render device.
-        void init(RenderDevice& renderDevice);
-
         /// @brief Sets the color to be used when drawing any subsequent gizmos.
         /// @param color Color to be used.
         void color(const glm::vec3& color);
@@ -55,18 +75,40 @@ namespace cubos::engine
         /// frame.
         void drawWireBox(const std::string& id, glm::vec3 corner, glm::vec3 oppositeCorner, float lifespan = 0);
 
-        /// @brief Draws all the gizmos that were called to be drawn.
-        /// @param deltaTime Resource holding the time since the previous frame.
-        void drawQueuedGizmos(DeltaTime deltaTime);
+        /// @brief Class that describes a type of gizmo
+        class GizmoBase
+        {
+        protected:
+            const std::string& mId; ///< Gizmo identifier
+            glm::vec3 mColor;       ///< Color of the gizmo
+            float mLifespan;        ///< Time in seconds the gizmo has left to live
+
+        public:
+            GizmoBase(const std::string& id, glm::vec3 color, float lifespan)
+                : mId(id)
+                , mColor(color)
+                , mLifespan(lifespan)
+            {
+            }
+
+            /// @brief draws the gizmo to screen
+            /// @param renderer the GizmosRenderer in use
+            virtual void draw(GizmosRenderer renderer) = 0;
+
+            /// @brief decreases the time the gizmo has left before it is destroyed
+            /// @param delta the time in seconds since the last frame
+            bool decreaseLifespan(float delta)
+            {
+                mLifespan -= delta;
+                return mLifespan <= 0;
+            }
+
+            virtual ~GizmoBase() = default;
+        };
 
+        std::vector<std::shared_ptr<GizmoBase>> gizmosVector; ///< Queued gizmos to be drawn.
     private:
-        ShaderPipeline mPipeline;    ///< Shader pipeline to be used when drawing gizmos
-        RenderDevice* mRenderDevice; ///< Active render device
-        glm::vec3 mColor;            ///< Currently set color
-        class GizmoBase;
-        class LineGizmo;
-        class BoxGizmo;
-        std::vector<std::shared_ptr<GizmoBase>> mGizmosVector; ///< Queued gizmos to be drawn.
+        glm::vec3 mColor; ///< Currently set color
     };
 
-} // namespace cubos::engine
+} // namespace cubos::engine

engine/include/cubos/engine/gizmos/plugin.hpp

@@ -14,7 +14,7 @@ namespace cubos::engine
 {
     /// @defgroup gizmos-plugin Gizmos
     /// @ingroup engine
-    /// @brief Allows gizmos to be drawn.
+    /// @brief Used to draw gizmos helpful for debugging and tools.
     ///
     /// ## Resources
     /// - @ref Gizmos - stores gizmos information.

engine/samples/gizmos/main.cpp

@@ -6,11 +6,9 @@
 using cubos::core::ecs::Commands;
 using cubos::core::ecs::Write;
 
-using cubos::engine::Gizmos;
-
 using namespace cubos::engine;
 
-static void mockCamera(Write<ActiveCameras> camera, Commands cmds)
+static void setCameraSystem(Write<ActiveCameras> camera, Commands cmds)
 {
     camera->entities[0] = cmds.create()
                               .add(Camera{.fovY = 60.0F, .zNear = 0.1F, .zFar = 100.0F})
@@ -42,15 +40,17 @@ static void drawStartingLineSystem(Write<Gizmos> gizmos)
 }
 /// [Start Up System]
 
-/// [Run]
 int main(int argc, char** argv)
 {
+    /// [Adding plugin]
     Cubos cubos{argc, argv};
     cubos.addPlugin(gizmosPlugin);
+    /// [Adding plugin]
     cubos.addPlugin(rendererPlugin);
-    cubos.startupSystem(mockCamera);
+    cubos.startupSystem(setCameraSystem);
+    /// [Run]
     cubos.startupSystem(drawStartingLineSystem).tagged("sample.init").after("cubos.gizmos.init");
     cubos.system(drawSystem);
+    /// [Run]
     cubos.run();
 }
-/// [Run]

engine/samples/gizmos/page.md

@@ -0,0 +1,19 @@
+# Gizmos {#examples-engine-gizmos}
+
+@brief Using the @ref gizmos-plugin plugin.
+
+This example shows the @ref gizmos-plugin plugin, which allows drawing simple primitives. These are not intended for use in the final product, only in developer tools and for debugging.
+
+The plugin function is included from the @ref engine/gizmos/plugin.hpp header.
+
+@snippet gizmos/main.cpp Adding plugin
+
+To draw a gizmo, all you need to do is to get a reference to the @ref cubos::engine::Gizmos resource, and then call the draw function on it for the gizmo you want to draw. Additionally, you can also call the @ref cubos::engine::Gizmos::color function to set the color for future gizmos. So, for example if you want to draw a line in a given system, all you need to do is the following:
+
+@snippet gizmos/main.cpp Start Up System
+
+This code will draw a red line from the top-left of the screen to the bottom right, and it will stay there for 10 seconds.
+
+In this other example, we draw a line, a box, and a wire box. Unlike the one in the previous example, this system is not a start-up system, so the draw functions get called every single frame. When this happensl, you should set the lifetime of a gizmo to 0, which means it will be drawn for a single frame only. This way we avoid drawing gizmos on top of identical ones that were already there, or in the case of moving gizmos, leaving a trail of old version behind them.
+
+@snippet gizmos/main.cpp System