add console toolkit

Author: jube

examples/17-console.cc

@@ -41,32 +41,33 @@ int main()
   rich_style.set_style("gf", { gf::Orange, gf::Azure });
   rich_style.set_style("warn", { gf::Black, gf::Yellow });
 
-  gf::ConsoleBuffer console_buffer({ 80, 50 });
+  gf::Console console({ 80, 50 });
 
-  console_buffer.put_character({ 40, 25 }, '@', style);
-  console_buffer.put_character({ 42, 25 }, gf::ConsoleChar::WhiteSmilingFace, style);
+  console.put_character({ 40, 25 }, '@', style);
+  console.put_character({ 42, 25 }, gf::ConsoleChar::WhiteSmilingFace, style);
 
-  console_buffer.print({ 1, 1 }, gf::ConsoleAlignment::Left, rich_style, "String with a <style=red>red</> word.");
+  console.print({ 1, 1 }, gf::ConsoleAlignment::Left, rich_style, "String with a <style=red>red</> word.");
 
-  console_buffer.print(console_buffer.cells.size() - 2, gf::ConsoleAlignment::Right, rich_style, "Made with <style=gf>gf</>!");
+  console.print(console.size() - 2, gf::ConsoleAlignment::Right, rich_style, "Made with <style=gf>gf</>!");
 
   const std::string_view text = "This is a simple but long text with <style=warn>multiple</> lines.";
 
-  console_buffer.print_area(rect({ 2, 5 }, { 16, 5 }), gf::ConsoleAlignment::Left, rich_style, text);
-  console_buffer.print_area(rect({ 2, 15 }, { 16, 5 }), gf::ConsoleAlignment::Center, rich_style, text);
-  console_buffer.print_area(rect({ 2, 25 }, { 16, 5 }), gf::ConsoleAlignment::Right, rich_style, text);
+  console.print_area(rect({ 2, 5 }, { 16, 5 }), gf::ConsoleAlignment::Left, rich_style, text);
+  console.print_area(rect({ 2, 15 }, { 16, 5 }), gf::ConsoleAlignment::Center, rich_style, text);
+  console.print_area(rect({ 2, 25 }, { 16, 5 }), gf::ConsoleAlignment::Right, rich_style, text);
 
-  console_buffer.clear(rect({ 30, 5 }, { 16, 5 }), style);
-  console_buffer.draw_frame(rect({ 30, 5 }, { 16, 5 }), style);
-  console_buffer.draw_frame(rect({ 30, 15 }, { 16, 5 }), style, "Frame title");
+  console.clear(rect({ 30, 5 }, { 16, 5 }), style);
+  console.draw_frame(rect({ 30, 5 }, { 16, 5 }), style);
+  console.draw_frame(rect({ 30, 15 }, { 16, 5 }), style, "Frame title");
 
-  gf::ConsoleEntity console_entity(&console_font, console_buffer, scene_manager.render_manager());
+  gf::ConsoleEntity console_entity(&console_font);
+  console_entity.graphics().update(console, scene_manager.render_manager());
   console_entity.set_location({ 1000.0f, 1000.0f });
   console_entity.set_origin({ 0.5f, 0.5f });
 
   gf::Scene scene;
   scene.set_world_center({ 1000.0f, 1000.0f });
-  scene.set_world_size(console_buffer.cells.size() * console_font.character_size());
+  scene.set_world_size(console.size() * console_font.character_size());
 
   scene.add_world_entity(&console_entity);
 

include/gf2/core/ConsoleBuffer.h renamed to include/gf2/core/Console.h

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Zlib
 // Copyright (c) 2023-2025 Julien Bernard
-#ifndef GF_CONSOLE_BUFFER_H
-#define GF_CONSOLE_BUFFER_H
+#ifndef GF_CONSOLE_H
+#define GF_CONSOLE_H
 
 #include <cstdint>
 
@@ -31,12 +31,16 @@ namespace gf {
     return ar | cell.foreground | cell.background | cell.character;
   }
 
-  struct GF_CORE_API ConsoleBuffer {
-    Array2D<ConsoleCell> cells;
+  class GF_CORE_API Console {
+  public:
+    Console(Vec2I size = { 0, 0 })
+    : m_cells(size)
+    {
+    }
 
-    ConsoleBuffer(Vec2I size = { 0, 0 })
-    : cells(size)
+    Vec2I size() const
     {
+      return m_cells.size();
     }
 
     void clear(const ConsoleStyle& style = ConsoleStyle());
@@ -119,7 +123,10 @@ namespace gf {
       raw_draw_frame(area, style, actual_title);
     }
 
-    void blit_to(ConsoleBuffer& console, RectI source, Vec2I destination, float foreground_alpha = 1.0f, float background_alpha = 1.0f) const;
+    void blit_to(Console& console, RectI source, Vec2I destination, float foreground_alpha = 1.0f, float background_alpha = 1.0f) const;
+
+    Array2D<ConsoleCell>& raw();
+    const Array2D<ConsoleCell>& raw() const;
 
   private:
     static constexpr uint8_t PrintSplit = 0x01;
@@ -130,25 +137,27 @@ namespace gf {
     int raw_print(RectI area, const std::string& message, ConsoleAlignment alignment, const ConsoleRichStyle& style, uint8_t flags = 0x00);
     int raw_print_multiline(RectI area, const std::string& message, ConsoleAlignment alignment, const ConsoleRichStyle& style, uint8_t flags = 0x00);
     void raw_draw_frame(RectI area, const ConsoleStyle& style, std::string_view title);
+
+    Array2D<ConsoleCell> m_cells;
   };
 
   template<typename Archive>
-  Archive& operator|(Archive& ar, MaybeConst<ConsoleBuffer, Archive>& buffer)
+  Archive& operator|(Archive& ar, MaybeConst<Console, Archive>& buffer)
   {
-    return ar | buffer.cells;
+    return ar | buffer.raw();
   }
 
   struct GF_CORE_API ConsoleResource {
     std::filesystem::path console_font;
-    ConsoleBuffer buffer;
+    Vec2I size;
   };
 
   template<typename Archive>
   Archive& operator|(Archive& ar, MaybeConst<ConsoleResource, Archive>& resource)
   {
-    return ar | resource.console_font | resource.buffer;
+    return ar | resource.console_font | resource.size;
   }
 
 }
 
-#endif // GF_CONSOLE_BUFFER_H
+#endif // GF_CONSOLE_H

include/gf2/core/ConsoleElement.h

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Zlib
+// Copyright (c) 2023-2025 Julien Bernard
+#ifndef GF_CONSOLE_ELEMENT_H
+#define GF_CONSOLE_ELEMENT_H
+
+#include "CoreApi.h"
+
+namespace gf {
+  class Console;
+
+  class GF_CORE_API ConsoleElement {
+  public:
+    ConsoleElement() = default;
+    ConsoleElement(const ConsoleElement&) = delete;
+    ConsoleElement(ConsoleElement&&) noexcept = default;
+    virtual ~ConsoleElement();
+
+    ConsoleElement& operator=(const ConsoleElement&) = delete;
+    ConsoleElement& operator=(ConsoleElement&&) noexcept = default;
+
+    virtual void update();
+    virtual void render(Console& buffer);
+  };
+
+}
+
+#endif // GF_CONSOLE_ELEMENT_H

include/gf2/core/ConsoleElementContainer.h

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Zlib
+// Copyright (c) 2023-2025 Julien Bernard
+#ifndef GF_CONSOLE_ELEMENT_CONTAINER_H
+#define GF_CONSOLE_ELEMENT_CONTAINER_H
+
+#include <vector>
+
+#include "ConsoleElement.h"
+#include "CoreApi.h"
+
+namespace gf {
+  class Console;
+
+  class GF_CORE_API ConsoleElementContainer {
+  public:
+
+    void add_element(ConsoleElement* element);
+
+    void update();
+    void render(Console& buffer);
+
+  private:
+    std::vector<ConsoleElement*> m_elements;
+  };
+
+}
+
+#endif // GF_CONSOLE_ELEMENT_CONTAINER_H

include/gf2/core/ConsoleScene.h

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Zlib
+// Copyright (c) 2023-2025 Julien Bernard
+#ifndef GF_CONSOLE_SCENE_H
+#define GF_CONSOLE_SCENE_H
+
+#include "ConsoleElementContainer.h"
+#include "CoreApi.h"
+#include "SceneTypes.h"
+
+namespace gf {
+  class Console;
+  class Event;
+
+  class GF_CORE_API ConsoleScene {
+  public:
+    ConsoleScene() = default;
+    ConsoleScene(const ConsoleScene&) = delete;
+    ConsoleScene(ConsoleScene&&) noexcept = default;
+    virtual ~ConsoleScene();
+
+    ConsoleScene& operator=(const ConsoleScene&) = delete;
+    ConsoleScene& operator=(ConsoleScene&&) noexcept = default;
+
+    void set_rank(SceneRank rank);
+    SceneRank rank() const;
+
+    void pause();
+    void resume();
+    bool paused() const;
+
+    void hide();
+    void show();
+    bool hidden() const;
+
+    void add_element(ConsoleElement* element);
+
+    virtual void process_event(const Event& event);
+    virtual void handle_actions();
+    virtual void update();
+    virtual void render(Console& buffer);
+
+  protected:
+    void update_elements();
+    void render_elements(Console& buffer);
+
+  private:
+    SceneRank m_rank = SceneRank::None;
+    SceneStatus m_status = SceneStatus::Resumed;
+    SceneVisibility m_visibility = SceneVisibility::Shown;
+
+    ConsoleElementContainer m_elements;
+  };
+
+}
+
+#endif // GF_CONSOLE_SCENE_H

include/gf2/core/ConsoleSceneManager.h

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Zlib
+// Copyright (c) 2023-2025 Julien Bernard
+#ifndef GF_CONSOLE_SCENE_MANAGER_H
+#define GF_CONSOLE_SCENE_MANAGER_H
+
+#include <vector>
+
+#include "Console.h"
+#include "ConsoleScene.h"
+#include "CoreApi.h"
+#include "Vec2.h"
+
+namespace gf {
+
+  class GF_CORE_API ConsoleSceneManager {
+  public:
+    ConsoleSceneManager(Vec2I size);
+
+    void push_scene(ConsoleScene* scene);
+
+    void pop_scene();
+    void pop_all_scenes();
+
+    void replace_scene(ConsoleScene* scene);
+
+    void process_event(const Event& event);
+    void handle_actions();
+    void update();
+    void render();
+
+    Console& console();
+
+  private:
+    Console m_console;
+    std::vector<ConsoleScene*> m_scenes;
+  };
+
+}
+
+#endif // GF_CONSOLE_SCENE_MANAGER_H

include/gf2/core/SceneTypes.h

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Zlib
+// Copyright (c) 2023-2025 Julien Bernard
+#ifndef GF_SCENE_TYPES_H
+#define GF_SCENE_TYPES_H
+
+#include <cstdint>
+
+namespace gf {
+
+  enum class SceneRank : uint8_t {
+    None,
+    Active,
+    Top,
+  };
+
+  enum class SceneStatus : uint8_t {
+    Resumed,
+    Paused,
+  };
+
+  enum class SceneVisibility : uint8_t {
+    Shown,
+    Hidden,
+  };
+
+}
+
+#endif // GF_SCENE_TYPES_H

include/gf2/framework/ConsoleSystem.h

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Zlib
+// Copyright (c) 2023-2025 Julien Bernard
+#ifndef GF_CONSOLE_SYSTEM_H
+#define GF_CONSOLE_SYSTEM_H
+
+#include <gf2/core/ConsoleSceneManager.h>
+
+#include <gf2/graphics/Scene.h>
+#include <gf2/graphics/ConsoleEntity.h>
+
+#include "FrameworkApi.h"
+
+namespace gf {
+
+  class GF_FRAMEWORK_API ConsoleSystem : public Scene {
+  public:
+    ConsoleSystem(Vec2I size, const ConsoleFont* font, RenderManager* render_manager);
+
+
+    ConsoleSceneManager* console_scene_manager()
+    {
+      return &m_console_scene_manager;
+    }
+
+  private:
+    void do_process_event(const Event& event) override;
+    void do_handle_actions() override;
+    void do_update(Time time) override;
+
+    RenderManager* m_render_manager = nullptr;
+    ConsoleSceneManager m_console_scene_manager;
+    ConsoleEntity m_console_entity;
+  };
+
+}
+
+#endif // GF_CONSOLE_SYSTEM_H

include/gf2/graphics/ConsoleEntity.h

@@ -3,7 +3,7 @@
 #ifndef GF_CONSOLE_ENTITY_H
 #define GF_CONSOLE_ENTITY_H
 
-#include "Console.h"
+#include "ConsoleGraphics.h"
 #include "GraphicsApi.h"
 #include "TransformableEntity.h"
 
@@ -12,18 +12,18 @@ namespace gf {
   class GF_GRAPHICS_API ConsoleEntity : public TransformableEntity {
   public:
     ConsoleEntity() = default;
-    ConsoleEntity(const ConsoleFont* font, const ConsoleBuffer& buffer, RenderManager* render_manager);
-    ConsoleEntity(const ConsoleResource& resource, RenderManager* render_manager, ResourceManager* resource_manager);
+    ConsoleEntity(const ConsoleFont* font);
+    ConsoleEntity(const ConsoleResource& resource, ResourceManager* resource_manager);
 
-    Console& console()
+    ConsoleGraphics& graphics()
     {
       return m_console;
     }
 
     void render(RenderRecorder& recorder) override;
 
   private:
-    Console m_console;
+    ConsoleGraphics m_console;
   };
 
 }