text.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <unordered_map>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/simple_asset/stexture.hpp"
#include "NNL/utility/data.hpp"
namespace nnl {

namespace text {

constexpr u16 kSpecialCodeMask = 0xF000;

const std::unordered_map<u16, std::string_view> kSpecialCodeToString{
    {0x1000, "{TRIANGLE}"},
    {0x1001, "{CIRCLE}"},
    {0x1002, "{X}"},
    {0x1003, "{SQUARE}"},
    {0x1004, "{UP}"},          // D-pad up
    {0x1005, "{DOWN}"},        // D-pad down
    {0x1006, "{LEFT}"},        // D-pad left
    {0x1007, "{RIGHT}"},       // D-pad right
    {0x1008, "{L}"},           // L
    {0x1009, ""},              // second half of L
    {0x100A, "{R}"},           // R
    {0x100B, ""},              // second half of R
    {0x100C, "{SELECT}"},      // select
    {0x100D, ""},              // second half of select
    {0x100E, "{START}"},       // start
    {0x100F, ""},              // second half of start
    {0x1010, "{JOYSTICK}"},    // joystick
    {0x1011, "{UNDERSCORE}"},  // underscore
    {0x1012, "{HEART}"},       // heart
    {0x1013, "{NOTE}"},        // note
    {0x1014, "{HEART1}"},      // slim heart
    {0x1015, "{NOTE1}"},       // slim note
    {0x1016, "{STAR}"},        // star
 
    {0x8000, "\0"},  // string terminator
    {0x8001, "\n"},  // new line
    {0x8002, "{8002}"},
    {0x8003, "{8003}"},
    {0x8004, "{8004}"},
    {0x8005, "{SMALL}"},     // small text size
    {0x8006, "{NORMAL}"},    // normal text size
    {0x8007, "{LARGE}"},     // large text size
    {0x8008, "{WHITE}"},     // reset/white
    {0x800A, "{BLACK}"},     // black text
    {0x800B, "{RED}"},       // red text
    {0x800C, "{BLUE}"},      // blue text
    {0x800D, "{ORANGE}"},    // orange text
    {0x800E, "{GREEN}"},     // green text
    {0x800F, "{800F}"},      //
    {0x8010, "{8010}"},      //
    {0x8011, "{8011}"},      //
    {0x8012, "{8012}"},      //
    {0x8013, "{8013}"},      //
    {0x8014, "{8014}"},      //
    {0x8015, "{8015}"},      //
    {0x8016, "{8016}"},      //
    {0x8017, "{8017}"},      //
    {0x8018, "{8018}"},      //
    {0x8019, "{8019}"},      //
    {0x801A, "{801A}"},      //
    {0x801B, "{801B}"},      //
    {0x801C, "{801C}"},      //
    {0x801D, "{801D}"},      // used 1 time in Spanish (tutorial)
    {0x801E, "{801E}"},      //
    {0x801F, "{801F}"},      //
    {0x8020, "{8020}"},      //
    {0x8021, "{8021}"},      //
    {0x8022, "{CYAN}"},      // cyan text
    {0x8023, "{MAGENTA}"},   // magenta text
    {0x8031, "\t"},          //
    {0x8032, "{EWHITE}"},    // Encircles a character with a white copy of itself
    {0x8033, "{EBLACK}"},    //
    {0x8034, "{EBLUE}"},     //
    {0x8035, "{EMAGENTA}"},  //
    {0x8036, "{ERED}"},      //
    {0x8037, " "},           // space
    {0x8038, "{VAR0}"},
    {0x8039, "{VAR1}"},
 
    {0x803A, "{803A}"},  //
    {0x803B, "{803B}"},  //
    {0x803C, "{803C}"},  //
    {0x803D, "{803D}"},  //
    {0x803E, "{803E}"},  //
    {0x803F, "{803F}"},  //
 
    {0x8040, "{VAR2}"},  // variable
    {0x8041, "{VAR3}"},  // variable
    {0x8042, "{VAR4}"},  // variable
    {0x8043, "{VAR5}"},  // small text size //variable ???
    {0x8044, "{VAR6}"},  // variable ???
    {0x8045, "{VAR7}"},  // variable
    {0x8046, "{VAR8}"},  // variable
    {0x8047, "{VAR9}"},  // variable
    {0x8048, "{VARA}"},  // small text size //variable ???
    {0x8049, "{VARB}"},  // variable ???
    {0x804A, "{804A}"},  // variable ???
    {0x804B, "{804B}"},  // variable ???
    {0x804C, "{804C}"},  // variable ???
    {0x804D, "{804D}"},  // variable ???
    {0x804E, "{804E}"},  // variable ???
    {0x804F, "{804F}"},  // variable ???
    {0x8050, "{VARC}"},  // variable ???
    {0x8051, "{VARD}"},
    {0x8052, "{VARE}"},
    {0x8053, "{VARF}"},
    // 1F4BD
};

using IndexedString = std::vector<u16>;
struct Text {
  std::vector<IndexedString>
      strings;  
  std::vector<u16> characters;  
};

std::vector<std::string> Convert(const Text& text,
                                 const std::unordered_map<u16, std::string_view>& replacements = kSpecialCodeToString);
Text Convert(const std::vector<std::string>& stext,
             const std::unordered_map<u16, std::string_view>& replacements = kSpecialCodeToString,
             const std::vector<u16>& characters = {});

bool IsOfType(BufferView buffer);
 
bool IsOfType(const std::filesystem::path& path);
 
bool IsOfType(Reader& f);

Text Import(BufferView buffer);
 
Text Import(const std::filesystem::path& path);
 
Text Import(Reader& f);
[[nodiscard]] Buffer Export(const Text& text);
 
void Export(const Text& text, const std::filesystem::path& path);
 
void Export(const Text& text, Writer& f);

struct BitmapFont {
  std::vector<STexture> bitmaps;  
  std::vector<u8> advance_width;  
};

struct BitmapFontParams {
  unsigned int size = 128;          
  unsigned int columns = 8;         
  float opacity_factor = 1.5f;      
  float scale_factor = 1.0f;        
  int spacing_offset = 0;           
  bool simulate_kerning = false;    
  bool filter_nearest = false;      
  unsigned int alpha_levels = 256;  
};

BitmapFont GenerateBitmapFont(Text& text, const std::filesystem::path& ttf_font_path,
                              const BitmapFontParams& params = {});
 
BitmapFont GenerateBitmapFont(Text& text, BufferView ttf_font_file, const BitmapFontParams& params = {});

std::string GenerateFNT(const Text& text, const std::vector<u8>& advance_width, const std::vector<STexture>& bitmaps,
                        int columns = -1);
 
namespace raw {
constexpr u32 kMagicBytes = utl::data::FourCC("CDL!");  
 
struct RHeader {
  u32 num_strings = 0;
  std::vector<u32> offset_strings;
  u32 offset_cdl = 0;
  std::map<u32, std::vector<u16>> strings;
};
 
struct RCDL {
  u32 magic_bytes = kMagicBytes;
  u32 num_characters = 0;
  u32 num_0 = 0;  // reserved(?)
  u32 num_1 = 0;  // reserved(?)
  std::vector<u16> characters;
};
 
struct RText {
  RHeader header;
  RCDL cdl;
};
 
Text Convert(RText&& rtext);
 
RText Parse(Reader& f);
}  // namespace raw
 
}  // namespace text

}  // namespace nnl