example::anonymous_namespace{example.cpp} Namespace Reference

Classes
struct	SaucerFlight
struct	StarParticle

Functions
SDL_Surface *	create_star_surface ()
SDL_Surface *	load_transparent_saucer (const std::string &png_path)
float	random_float (float min_value, float max_value)

Variables
constexpr float	k_pi = 3.14159265358979323846f

Function Documentation

create_star_surface()

SDL_Surface * example::anonymous_namespace{example.cpp}::create_star_surface

(

)

Definition at line 72 of file example.cpp.

                                           {
            SDL_Surface *surface = SDL_CreateSurface(40, 40, SDL_PIXELFORMAT_RGBA32);
            if (surface == nullptr) {
                return nullptr;
            }
 
            const SDL_PixelFormatDetails *format_details = SDL_GetPixelFormatDetails(surface->format);
            if (format_details == nullptr) {
                SDL_DestroySurface(surface);
                return nullptr;
            }
 
            if (!SDL_LockSurface(surface)) {
                SDL_DestroySurface(surface);
                return nullptr;
            }
 
            auto *pixels = static_cast<std::uint32_t *>(surface->pixels);
            for (int y = 0; y < surface->h; ++y) {
                for (int x = 0; x < surface->w; ++x) {
                    const float dx = (static_cast<float>(x) + 0.5f) - (static_cast<float>(surface->w) * 0.5f);
                    const float dy = (static_cast<float>(y) + 0.5f) - (static_cast<float>(surface->h) * 0.5f);
                    const float dist = std::sqrt((dx * dx) + (dy * dy)) / (static_cast<float>(surface->w) * 0.5f);
                    const float core = std::clamp(1.0f - dist * 1.9f, 0.0f, 1.0f);
                    const float glow = std::clamp(1.0f - dist * 3.8f, 0.0f, 1.0f);
                    const std::uint8_t alpha = static_cast<std::uint8_t>(std::lround((core * core * 255.0f) + (glow * 80.0f)));
                    const std::uint8_t brightness = static_cast<std::uint8_t>(std::lround((core * 255.0f) + (glow * 150.0f)));
                    pixels[y * surface->w + x] = SDL_MapRGBA(format_details, nullptr, brightness, brightness, brightness, alpha);
                }
            }
 
            SDL_UnlockSurface(surface);
            return surface;
        }

load_transparent_saucer()

SDL_Surface * example::anonymous_namespace{example.cpp}::load_transparent_saucer

(

const std::string &

png_path

)

Definition at line 27 of file example.cpp.

                                                                        {
            SDL_Surface *loaded_surface = mxvk::LoadPNG(png_path.c_str());
            if (loaded_surface == nullptr) {
                throw mxvk::Exception("Failed to load sprite3D image: " + png_path);
            }
 
            SDL_Surface *rgba_surface = SDL_ConvertSurface(loaded_surface, SDL_PIXELFORMAT_RGBA32);
            SDL_DestroySurface(loaded_surface);
            if (rgba_surface == nullptr) {
                throw mxvk::Exception(std::format("Failed to convert sprite3D image to RGBA: {}", png_path));
            }
 
            const SDL_PixelFormatDetails *format_details = SDL_GetPixelFormatDetails(rgba_surface->format);
            if (format_details == nullptr) {
                SDL_DestroySurface(rgba_surface);
                throw mxvk::Exception("Failed to query pixel format details for: " + png_path);
            }
 
            if (!SDL_LockSurface(rgba_surface)) {
                SDL_DestroySurface(rgba_surface);
                throw mxvk::Exception("Failed to lock sprite3D surface: " + png_path);
            }
 
            auto *pixels = static_cast<std::uint32_t *>(rgba_surface->pixels);
            const int pixel_count = rgba_surface->w * rgba_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);
 
                if ((r | g | b) == 0) {
                    a = 0;
                } else {
                    a = 255;
                }
 
                pixels[i] = SDL_MapRGBA(format_details, nullptr, r, g, b, a);
            }
 
            SDL_UnlockSurface(rgba_surface);
            return rgba_surface;
        }

random_float()

float example::anonymous_namespace{example.cpp}::random_float	(	float	min_value,
		float	max_value )

Definition at line 135 of file example.cpp.

                                                             {
            static thread_local std::default_random_engine engine{std::random_device{}()};
            std::uniform_real_distribution<float> dist(min_value, max_value);
            return dist(engine);
        }

Variable Documentation

k_pi

float example::anonymous_namespace{example.cpp}::k_pi = 3.14159265358979323846f

constexpr

Definition at line 25 of file example.cpp.