anonymous_namespace{binary_matrix.cpp} Namespace Reference

Classes
struct	Stream
struct	SurfaceDeleter
struct	TtfDeleter

Typedefs
using	Clock = std::chrono::steady_clock
using	FontPtr = std::unique_ptr<TTF_Font, TtfDeleter>
using	SurfacePtr = std::unique_ptr<SDL_Surface, SurfaceDeleter>

Functions
SDL_Color	matrixTrailColor (int level)
std::optional< SDL_Color >	parse_color_spec (const std::string &spec)
std::optional< Uint8 >	parse_u8_component (const std::string &value, int base)
SurfacePtr	renderGlyph (TTF_Font *font, const std::string &glyph, const SDL_Color &color)
std::string	trim_copy (const std::string &value)

Typedef Documentation

Clock

using anonymous_namespace{binary_matrix.cpp}::Clock = std::chrono::steady_clock

Definition at line 26 of file binary_matrix.cpp.

FontPtr

using anonymous_namespace{binary_matrix.cpp}::FontPtr = std::unique_ptr<TTF_Font, TtfDeleter>

Definition at line 46 of file binary_matrix.cpp.

SurfacePtr

using anonymous_namespace{binary_matrix.cpp}::SurfacePtr = std::unique_ptr<SDL_Surface, SurfaceDeleter>

Definition at line 36 of file binary_matrix.cpp.

Function Documentation

matrixTrailColor()

SDL_Color anonymous_namespace{binary_matrix.cpp}::matrixTrailColor

(

int

level

)

Definition at line 59 of file binary_matrix.cpp.

                                          {
        constexpr int maxLevel = 7;
        const float t = std::clamp(static_cast<float>(level) / static_cast<float>(maxLevel), 0.0f, 1.0f);
        const Uint8 r = static_cast<Uint8>(std::lerp(0.0f, 180.0f, std::pow(t, 2.8f)));
        const Uint8 g = static_cast<Uint8>(std::lerp(36.0f, 255.0f, std::pow(t, 0.72f)));
        const Uint8 b = static_cast<Uint8>(std::lerp(8.0f, 205.0f, std::pow(t, 3.2f)));
        const Uint8 a = static_cast<Uint8>(std::lerp(120.0f, 255.0f, t));
        return SDL_Color{r, g, b, a};
    }

parse_color_spec()

std::optional< SDL_Color > anonymous_namespace{binary_matrix.cpp}::parse_color_spec

(

const std::string &

spec

)

Definition at line 90 of file binary_matrix.cpp.

                                                                   {
        const std::string value = trim_copy(spec);
        if (value.empty()) {
            return std::nullopt;
        }
 
        if (value.front() == '#') {
            if (value.size() != 7) {
                return std::nullopt;
            }
            const auto r = parse_u8_component(value.substr(1, 2), 16);
            const auto g = parse_u8_component(value.substr(3, 2), 16);
            const auto b = parse_u8_component(value.substr(5, 2), 16);
            if (!r || !g || !b) {
                return std::nullopt;
            }
            return SDL_Color{*r, *g, *b, 255};
        }
 
        const std::size_t first = value.find(',');
        if (first == std::string::npos) {
            return std::nullopt;
        }
        const std::size_t second = value.find(',', first + 1);
        if (second == std::string::npos || value.find(',', second + 1) != std::string::npos) {
            return std::nullopt;
        }
 
        const auto r = parse_u8_component(value.substr(0, first), 10);
        const auto g = parse_u8_component(value.substr(first + 1, second - first - 1), 10);
        const auto b = parse_u8_component(value.substr(second + 1), 10);
        if (!r || !g || !b) {
            return std::nullopt;
        }
        return SDL_Color{*r, *g, *b, 255};
    }

parse_u8_component()

std::optional< Uint8 > anonymous_namespace{binary_matrix.cpp}::parse_u8_component	(	const std::string &	value,
		int	base )

Definition at line 78 of file binary_matrix.cpp.

                                                                            {
        int parsed = 0;
        const std::string trimmed = trim_copy(value);
        const char *begin = trimmed.data();
        const char *end = trimmed.data() + trimmed.size();
        const std::from_chars_result result = std::from_chars(begin, end, parsed, base);
        if (result.ec != std::errc{} || result.ptr != end || parsed < 0 || parsed > 255) {
            return std::nullopt;
        }
        return static_cast<Uint8>(parsed);
    }

renderGlyph()

SurfacePtr anonymous_namespace{binary_matrix.cpp}::renderGlyph	(	TTF_Font *	font,
		const std::string &	glyph,
		const SDL_Color &	color )

Definition at line 127 of file binary_matrix.cpp.

                                                                                           {
        SDL_Surface *rendered = TTF_RenderText_Blended(font, glyph.c_str(), 0, color);
        if (rendered == nullptr) {
            return {};
        }
 
        SurfacePtr converted(SDL_ConvertSurface(rendered, SDL_PIXELFORMAT_RGBA32));
        SDL_DestroySurface(rendered);
        if (converted != nullptr) {
            SDL_SetSurfaceBlendMode(converted.get(), SDL_BLENDMODE_BLEND);
        }
        return converted;
    }

trim_copy()

std::string anonymous_namespace{binary_matrix.cpp}::trim_copy

(

const std::string &

value

)

Definition at line 69 of file binary_matrix.cpp.

                                                {
        const auto begin = value.find_first_not_of(" \t\r\n");
        if (begin == std::string::npos) {
            return {};
        }
        const auto end = value.find_last_not_of(" \t\r\n");
        return value.substr(begin, end - begin + 1);
    }