Console.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2022 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_CONSOLE_H
#define GF_CONSOLE_H
 
#include <cstdint>
#include <string_view>
 
#include "Alignment.h"
#include "Array2D.h"
#include "Blend.h"
#include "ConsoleFont.h"
#include "Flags.h"
#include "GraphicsApi.h"
#include "Path.h"
#include "Portability.h"
#include "Texture.h"
#include "Transformable.h"
#include "Vector.h"
 
namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif
 
 
  enum class ConsoleAlignment {
    Left,   
    Center, 
    Right,  
  };
 
  using ConsoleColorControl = char;
 
  constexpr ConsoleColorControl ConsoleColorControl1 = '\x01';
 
  constexpr ConsoleColorControl ConsoleColorControl2 = '\x02';
 
  constexpr ConsoleColorControl ConsoleColorControl3 = '\x03';
 
  constexpr ConsoleColorControl ConsoleColorControl4 = '\x04';
 
  constexpr ConsoleColorControl ConsoleColorControl5 = '\x05';
 
  constexpr ConsoleColorControl ConsoleColorControlStop = '\x06';
 
 
 
  class GF_GRAPHICS_API ConsoleEffect {
  public:
 
    enum Kind : uint32_t {
      None,       
      Set,        
      Multiply,   
      Lighten,    
      Darken,     
      Screen,     
      ColorDodge, 
      ColorBurn,  
      Add,        
      AddAlpha,   
      Burn,       
      Overlay,    
      Alpha,      
      Default,    
    };
 
    constexpr ConsoleEffect(Kind kind)
    : m_kind(kind)
    , m_alpha(0.0f)
    {
 
    }
 
    constexpr ConsoleEffect(Kind kind, float alpha)
    : m_kind(kind)
    , m_alpha(alpha)
    {
 
    }
 
    constexpr Kind getKind() const noexcept {
      return m_kind;
    }
 
    constexpr bool isDefault() const noexcept {
      return m_kind == Default;
    }
 
    constexpr float getAlpha() const noexcept {
      return m_alpha;
    }
 
  private:
    Kind m_kind;
    float m_alpha;
  };
 
  class GF_GRAPHICS_API Console : public Transformable {
  public:
    enum class PrintAction {
      None,   
      Clear,  
    };
 
    Console(const ConsoleFont& font, Vector2i size);
 
    int getWidth() const {
      return m_data.getSize().width;
    }
 
    int getHeight() const {
      return m_data.getSize().height;
    }
 
    void setDefaultBackground(const Color4f& color) {
      m_background = color;
    }
 
    const Color4f& getDefaultBackground() const {
      return m_background;
    }
 
    void setDefaultForeground(const Color4f& color) {
      m_foreground = color;
    }
 
    const Color4f& getDefaultForeground() const {
      return m_foreground;
    }
 
    void clear();
 
    void setCharBackground(Vector2i position, const Color4f& color, ConsoleEffect effect = ConsoleEffect::Set);
 
    const Color4f& getCharBackground(Vector2i position) const;
 
    void setCharForeground(Vector2i position, const Color4f& color);
 
    const Color4f& getCharForeground(Vector2i position) const;
 
    void setChar(Vector2i position, char16_t c);
 
    char16_t getChar(Vector2i position) const;
 
    void putChar(Vector2i position, char16_t c, ConsoleEffect effect = ConsoleEffect::Default);
 
    void putChar(Vector2i position, char16_t c, const Color4f& foreground, const Color4f& background);
 
    void setDefaultConsoleEffect(ConsoleEffect effect) {
      if (!effect.isDefault()) {
        m_effect = effect;
      }
    }
 
    ConsoleEffect getDefaultConsoleEffect() const {
      return m_effect;
    }
 
    void setDefaultAlignment(ConsoleAlignment alignment) {
      m_alignment = alignment;
    }
 
    ConsoleAlignment getDefaultAlignment() const {
      return m_alignment;
    }
 
    void print(Vector2i position, const char *fmt, ...) GF_FORMAT(3, 4);
 
    void print(Vector2i position, ConsoleEffect effect, ConsoleAlignment alignment, const char *fmt, ...) GF_FORMAT(5, 6);
 
    int printRect(const RectI& rect, const char *fmt, ...) GF_FORMAT(3, 4);
 
    int printRect(const RectI& rect, ConsoleEffect effect, ConsoleAlignment alignment, const char *fmt, ...) GF_FORMAT(5, 6);
 
    int getHeight(const RectI& rect, const char *fmt, ...) GF_FORMAT(3, 4);
 
    void setColorControl(ConsoleColorControl ctrl, const Color4f& foreground, const Color4f& background);
 
    void drawRectangle(const RectI& rect, PrintAction action = PrintAction::None, ConsoleEffect effect = ConsoleEffect::Default);
 
    void drawHorizontalLine(Vector2i left, int width, ConsoleEffect effect = ConsoleEffect::Default);
 
    void drawVerticalLine(Vector2i top, int height, ConsoleEffect effect = ConsoleEffect::Default);
 
    void drawFrame(const RectI& rect, PrintAction action = PrintAction::None, ConsoleEffect effect = ConsoleEffect::Default, const char *title = nullptr, ...) GF_FORMAT(5, 6);
 
    void setFade(float amount, const Color4f& color) {
      m_fadingAmount = amount;
      m_fadingColor = color;
    }
 
    float getFadingAmount() const {
      return m_fadingAmount;
    }
 
    const Color4f& getFadingColor() const {
      return m_fadingColor;
    }
 
    void blit(const RectI& src, Console& con, Vector2i dst, float foregroundAlpha = 1.0f, float backgroundAlpha = 1.0f) const;
 
    virtual void draw(RenderTarget& target, const RenderStates& states) override;
 
  private:
    Color4f computeColor(ConsoleEffect effect, const Color4f& existing, const Color4f& current);
 
    int putWord(Vector2i position, ConsoleEffect effect, std::string_view message, const Color4f& foreground, const Color4f& background);
 
    enum class PrintOption {
      Split     = 0x01,
      CountOnly = 0x02,
    };
 
    int printInternal(const RectI& rect, ConsoleEffect effect, ConsoleAlignment alignment, const std::string& message, Flags<PrintOption> flags = None);
 
  private:
    struct Cell {
      Color4f fg;
      Color4f bg;
      char16_t c;
    };
 
    const ConsoleFont *m_font;
    Array2D<Cell, int> m_data;
    Color4f m_background;
    Color4f m_foreground;
 
    ConsoleEffect m_effect;
    ConsoleAlignment m_alignment;
 
    struct ColorControl {
      Color4f fg;
      Color4f bg;
    };
 
    static constexpr char ColorControlCount = 5;
    ColorControl m_controls[ColorControlCount];
 
    float m_fadingAmount;
    Color4f m_fadingColor;
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}
 
#endif // GF_CONSOLE_H