example Namespace Reference

Namespaces
namespace	anonymous_namespace{example.cpp}
namespace	anonymous_namespace{matrix.cpp}
namespace	anonymous_namespace{planet.cpp}

Classes
class	BinaryMatrixWindow
class	ConsoleDemoWindow
class	DarkWindow
class	ExampleWindow
class	FireWindow
class	FireworksWindow
class	FractalWindow
class	GlitchCubeWindow
class	MasterPieceWindow
class	Math3DCubeWindow
class	Math3DModelLoaderWindow
class	Math3DPongWindow
class	Math3DPyramidWindow
class	Math3DTextureArrayWindow
class	Math3DTextureWindow
class	Math3DWindow
class	MatrixRainBackdrop
class	MatrixWindow
class	ModelWindow
class	MoonWindow
class	OpenCVModelWindow
class	PlanetWindow
class	PointSpriteWindow
class	PostprocessWindow
struct	PyramidPlacement
class	SnowEffect3D
struct	SnowFlake
class	StarfieldWindow
struct	StarParticle
class	StarshipWindow
class	StaticWindow
class	StencilWindow
struct	SurfaceDeleter
class	TicTacToeWindow
class	WaterWindow

Typedefs
using	Clock = std::chrono::steady_clock

Functions
std::string	joinPath (const std::string &base, const std::string &file)
SDL_Surface *	loadColorKeyedPNG (const std::string &path, std::uint8_t threshold=12, std::uint8_t softness=48)
std::string	resolveShaderEntry (const std::string &shader_path, const std::string &entry)
std::string	trimLine (const std::string &text)

Typedef Documentation

Clock

using example::Clock = std::chrono::steady_clock

Definition at line 27 of file planet.cpp.

Function Documentation

joinPath()

std::string example::joinPath ( const std::string & base, const std::string & file )

nodiscard

Definition at line 51 of file shaders.cpp.

                                                                                   {
        const std::filesystem::path file_path(file);
        if (base.empty() || file_path.is_absolute()) {
            return file_path.string();
        }
        return (std::filesystem::path(base) / file_path).string();
    }

loadColorKeyedPNG()

SDL_Surface * example::loadColorKeyedPNG	(	const std::string &	path,
		std::uint8_t	threshold = 12,
		std::uint8_t	softness = 48 )

Definition at line 45 of file moon.cpp.

                                                                                                           {
        SDL_Surface *loaded_surface = mxvk::LoadPNG(path.c_str());
        if (loaded_surface == nullptr) {
            throw mxvk::Exception("Failed to load PNG: " + path);
        }
 
        SDL_Surface *surface = SDL_ConvertSurface(loaded_surface, SDL_PIXELFORMAT_RGBA32);
        SDL_DestroySurface(loaded_surface);
        if (surface == nullptr) {
            throw mxvk::Exception("Failed to convert PNG to RGBA: " + path);
        }
 
        const SDL_PixelFormatDetails *format_details = SDL_GetPixelFormatDetails(surface->format);
        if (format_details == nullptr) {
            SDL_DestroySurface(surface);
            throw mxvk::Exception("Failed to query pixel format details for: " + path);
        }
 
        if (!SDL_LockSurface(surface)) {
            SDL_DestroySurface(surface);
            throw mxvk::Exception("Failed to lock PNG surface: " + path);
        }
 
        auto *pixels = static_cast<std::uint32_t *>(surface->pixels);
        const int pixel_count = surface->w * surface->h;
        for (int i = 0; i < pixel_count; ++i) {
            std::uint8_t r = 0;
            std::uint8_t g = 0;
            std::uint8_t b = 0;
            std::uint8_t a = 0;
            SDL_GetRGBA(pixels[i], format_details, nullptr, &r, &g, &b, &a);
 
            const int brightness = std::max({static_cast<int>(r), static_cast<int>(g), static_cast<int>(b)});
            if (brightness <= threshold) {
                a = 0;
            } else if (brightness < static_cast<int>(threshold) + static_cast<int>(softness)) {
                const float fade = static_cast<float>(brightness - threshold) / static_cast<float>(std::max<int>(1, softness));
                a = static_cast<std::uint8_t>(std::clamp(static_cast<int>(std::lround(static_cast<float>(a) * fade)), 0, 255));
            }
 
            pixels[i] = SDL_MapRGBA(format_details, nullptr, r, g, b, a);
        }
 
        SDL_UnlockSurface(surface);
        return surface;
    }

resolveShaderEntry()

std::string example::resolveShaderEntry ( const std::string & shader_path, const std::string & entry )

nodiscard

Definition at line 59 of file shaders.cpp.

                                                                                                     {
        const std::filesystem::path entry_path(entry);
        if (entry_path.extension() == ".spv") {
            return joinPath(shader_path, entry);
        }
 
        std::filesystem::path spv_entry = entry_path.parent_path() / "spv" / entry_path.stem();
        spv_entry.replace_extension(".spv");
        const std::filesystem::path spv_path = std::filesystem::path(shader_path) / spv_entry;
        if (std::filesystem::exists(spv_path)) {
            return spv_path.string();
        }
 
        std::filesystem::path sibling_entry = entry_path;
        sibling_entry.replace_extension(".spv");
        const std::filesystem::path sibling_spv_path = std::filesystem::path(shader_path) / sibling_entry;
        if (std::filesystem::exists(sibling_spv_path)) {
            return sibling_spv_path.string();
        }
 
        return joinPath(shader_path, entry);
    }

trimLine()

std::string example::trimLine ( const std::string & text )

nodiscard

Definition at line 37 of file shaders.cpp.

                                                            {
        auto begin = text.begin();
        while (begin != text.end() && std::isspace(static_cast<unsigned char>(*begin)) != 0) {
            ++begin;
        }
 
        auto end = text.end();
        while (end != begin && std::isspace(static_cast<unsigned char>(*(end - 1))) != 0) {
            --end;
        }
 
        return std::string(begin, end);
    }