Console.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 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 "Alignment.h"
#include "Array2D.h"
#include "Blend.h"
#include "ConsoleFont.h"
#include "Flags.h"
#include "Path.h"
#include "Portability.h"
#include "StringRef.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_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_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, StringRef message, const Color4f& foreground, const Color4f& background);

    enum class PrintOption {
      Split     = 0x01,
      CountOnly = 0x02,
    };

    using PrintOptionFlags = Flags<PrintOption>;

    int printInternal(const RectI& rect, ConsoleEffect effect, ConsoleAlignment alignment, const std::string& message, PrintOptionFlags 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