matrix::anonymous_namespace{rain.cpp} Namespace Reference

Functions
bool	acquire_ttf ()
std::function< SDL_Color()>	make_tinted_head_color (SDL_Color base_color)
std::function< SDL_Color(int)>	make_tinted_level_color (SDL_Color base_color)
std::optional< SDL_Color >	parse_color_spec (const std::string &spec)
std::optional< Uint8 >	parse_u8_component (const std::string &value, int base)
void	release_ttf ()
std::string	trim_copy (const std::string &value)

Variables
constexpr int	default_surface_height = 720
constexpr int	default_surface_width = 1280
std::mutex	ttf_mutex
std::size_t	ttf_refcount = 0

Function Documentation

acquire_ttf()

bool matrix::anonymous_namespace{rain.cpp}::acquire_ttf

(

)

Definition at line 19 of file rain.cpp.

                           {
            std::lock_guard<std::mutex> lock(ttf_mutex);
            if (ttf_refcount == 0 && !TTF_Init()) {
                return false;
            }
            ++ttf_refcount;
            return true;
        }

make_tinted_head_color()

std::function< SDL_Color()> matrix::anonymous_namespace{rain.cpp}::make_tinted_head_color

(

SDL_Color

base_color

)

Definition at line 109 of file rain.cpp.

                                                                              {
            return [base_color]() {
                return SDL_Color{base_color.r, base_color.g, base_color.b, 255};
            };
        }

make_tinted_level_color()

std::function< SDL_Color(int)> matrix::anonymous_namespace{rain.cpp}::make_tinted_level_color

(

SDL_Color

base_color

)

Definition at line 97 of file rain.cpp.

                                                                                  {
            return [base_color](int level) {
                constexpr int max_level = 7;
                const float t = std::clamp(static_cast<float>(level) / static_cast<float>(max_level), 0.0f, 1.0f);
                const Uint8 r = static_cast<Uint8>(std::lerp(0.0f, static_cast<float>(base_color.r), std::pow(t, 1.0f)));
                const Uint8 g = static_cast<Uint8>(std::lerp(0.0f, static_cast<float>(base_color.g), std::pow(t, 1.0f)));
                const Uint8 b = static_cast<Uint8>(std::lerp(0.0f, static_cast<float>(base_color.b), std::pow(t, 1.0f)));
                const Uint8 a = static_cast<Uint8>(std::lerp(95.0f, 235.0f, t));
                return SDL_Color{r, g, b, a};
            };
        }

parse_color_spec()

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

(

const std::string &

spec

)

Definition at line 60 of file rain.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 > matrix::anonymous_namespace{rain.cpp}::parse_u8_component	(	const std::string &	value,
		int	base )

Definition at line 48 of file rain.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);
        }

release_ttf()

void matrix::anonymous_namespace{rain.cpp}::release_ttf

(

)

Definition at line 28 of file rain.cpp.

                           {
            std::lock_guard<std::mutex> lock(ttf_mutex);
            if (ttf_refcount == 0) {
                return;
            }
            --ttf_refcount;
            if (ttf_refcount == 0) {
                TTF_Quit();
            }
        }

trim_copy()

std::string matrix::anonymous_namespace{rain.cpp}::trim_copy

(

const std::string &

value

)

Definition at line 39 of file rain.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);
        }

Variable Documentation

default_surface_height

int matrix::anonymous_namespace{rain.cpp}::default_surface_height = 720

constexpr

Definition at line 14 of file rain.cpp.

default_surface_width

int matrix::anonymous_namespace{rain.cpp}::default_surface_width = 1280

constexpr

Definition at line 13 of file rain.cpp.

ttf_mutex

std::mutex matrix::anonymous_namespace{rain.cpp}::ttf_mutex

Definition at line 16 of file rain.cpp.

ttf_refcount

std::size_t matrix::anonymous_namespace{rain.cpp}::ttf_refcount = 0

Definition at line 17 of file rain.cpp.