Utilities for loading and saving PNG images. More...

Namespaces
namespace	anonymous_namespace{mxvk.cpp}
namespace	anonymous_namespace{mxvk_abstract_model.cpp}
namespace	anonymous_namespace{mxvk_ff_capture.cpp}
namespace	anonymous_namespace{mxvk_model.cpp}
namespace	anonymous_namespace{mxvk_resource.cpp}
namespace	detail

Classes
struct	BufferResource
	Owned Vulkan buffer allocation with optional persistent host mapping. More...
struct	CachedTexture
	GPU texture resources cached for a rendered text string. More...
struct	CacheKey
	Cache key combining text content and colour. More...
struct	CacheKeyHash
	Hash functor for CacheKey. More...
class	Camera
	Camera and projection data for the simple software 3D pipeline. More...
struct	CyType
	Cylindrical coordinate. More...
class	Exception
class	Font
	Small RAII wrapper for an SDL_ttf font handle. More...
class	Mat1D
	Two-element column-vector storage used by 2x2 linear solves. More...
class	Mat1x3D
	Three-element column-vector storage used by 3x3 linear solves. More...
class	Mat1x4D
	Four-element column-vector storage. More...
class	Mat2D
	Two-by-two matrix with arithmetic, determinant, inverse, and solve helpers. More...
class	Mat3D
	Three-by-three matrix with multiplication, vector transform, inverse, and solve helpers. More...
class	Mat4D
	Four-by-four homogeneous transform matrix. More...
class	Mat4x3D
	Four-by-three matrix storage. More...
struct	ModelFragmentPushConstants
	Sprite-compatible fragment parameters for UV-based model effects. More...
struct	ModelFragmentUniforms
	Extended shader-viewer uniforms available to fragment shaders at binding 1. More...
struct	MXMaterial
	Parsed subset of Wavefront MTL material fields. More...
class	MXModel
	Loads OBJ/MXMOD meshes and uploads them to Vulkan buffers. More...
class	mxObject
	Simple mesh object loaded from PLG-style indexed triangle data. More...
struct	OBJMaterial
	Wavefront material data used by the software rasterizer. More...
struct	paramLine2D
	Parametric 2D line segment represented by a start point, end point, and direction. More...
struct	paramLine3D
	Parametric 3D line segment represented by a start point, end point, and direction. More...
class	PipeLine
	Clipped software rasterization pipeline for lines and filled triangles. More...
struct	Plane3D
	Plane represented by a point and a normal vector. More...
struct	PointSpriteVertex
	Vertex layout consumed by VK_PointSpriteBatch. More...
struct	Polar
	2D polar coordinate. More...
class	QuatType
	Quaternion used for 3D rotations. More...
class	RenderList
	Flat list of triangles prepared for transformation and rasterization. More...
struct	SDLRendererPixelPlotter
	Pixel plotter adapter that writes packed MXVK colors to an SDL renderer. More...
struct	SpType
	Spherical coordinate. More...
struct	SubMesh
	One indexed sub-range that can reference a dedicated texture slot. More...
struct	TextureResource
	Owned sampled 2D texture resources. More...
struct	Triangle
	Triangle primitive used by the simple software rendering pipeline. More...
struct	UniformBufferObject
	Default transform UBO payload for model shaders. More...
class	vec2D
	Two-dimensional float vector with common arithmetic helpers. More...
class	vec3D
	Three-dimensional float vector with arithmetic, dot, and cross-product helpers. More...
class	vec4D
	Four-dimensional float vector used for homogeneous 3D coordinates. More...
class	VK_Capture
	Vulkan OpenCV video capture source. More...
class	VK_Config
	Parses and manages an INI-style configuration file. More...
class	VK_ConfigItem
	A single key/value pair read from a configuration file. More...
class	VK_Console
	Lightweight command console renderer for mxvk::VK_Window. More...
class	VK_Controller
	RAII wrapper for SDL_Gamepad (standard layout mapping). More...
class	VK_FF_Capture
	FFmpeg-backed video-file capture source. More...
class	VK_IOWindow
class	VK_Joystick
	RAII wrapper for a raw SDL_Joystick device. More...
class	VK_Mixer
	SDL3_mixer-based audio manager. More...
class	VK_PointSpriteBatch
	Reusable Vulkan point-list renderer for textured particle effects. More...
class	VK_Sprite
class	VK_Sprite3D
	Depth-tested 3D billboard sprite batch. More...
class	VK_Stencil
	Owns a stencil attachment and two fullscreen pipelines for stencil-masked rendering. More...
class	VK_Text
class	VK_Window
	Main Vulkan window wrapper for MXVK. More...
class	VKAbstractModel
	Convenience wrapper that owns mesh, textures, descriptors, and pipeline state. More...
struct	VKSpritePixelPlotter
	Pixel plotter adapter that draws square pixels into a VK_Sprite. More...
struct	VKVertex
	Vertex payload consumed by MXVK model shaders. More...
struct	VKVertexHash
	Hash functor for VKVertex. More...
struct	VulkanContext
	Minimal Vulkan handles required by MXVK resource helpers. More...
class	Wrapper
	A nullable smart wrapper around a raw pointer. More...

Concepts
concept	WrapType
	Constrains Wrapper<T> to pointer types only.

Typedefs
using	ConfigFile = VK_Config
using	Console = VK_Console
using	Controller = VK_Controller
using	Item = VK_ConfigItem
using	Joystick = VK_Joystick
using	Mixer = VK_Mixer
using	MXCOLOR = std::uint32_t
	Packed 32-bit color in ARGB byte order.
using	VK_AbstractModel = VKAbstractModel

Enumerations
enum	{ MX_ACTIVE = 0x1 , MX_VISIBLE = 0x2 , MX_BACKFACE = 0x4 , MX_CULLED = 0x8 }
	Object and polygon state bit flags. More...
enum	{ MX_ACTIVE = 0x1 , MX_VISIBLE = 0x2 , MX_BACKFACE = 0x4 , MX_CULLED = 0x8 }
	Object and polygon state bit flags. More...

Functions
VkCommandBuffer	begin_one_time_commands (const VulkanContext &context)
	Allocate and begin a primary one-time command buffer.
std::array< float, 361 >	build_cos_table ()
std::array< float, 361 >	build_sin_table ()
void	BuildTables ()
	Rebuild the sine and cosine lookup tables.
constexpr std::uint8_t	color_a (MXCOLOR color)
	Extract the alpha component from a packed ARGB color.
constexpr std::uint8_t	color_b (MXCOLOR color)
	Extract the blue component from a packed ARGB color.
constexpr std::uint8_t	color_g (MXCOLOR color)
	Extract the green component from a packed ARGB color.
constexpr std::uint8_t	color_r (MXCOLOR color)
	Extract the red component from a packed ARGB color.
void	copy_buffer (const VulkanContext &context, VkBuffer source, VkBuffer destination, VkDeviceSize size)
	Copy one buffer into another with a one-shot Vulkan 1.3 copy command.
void	copy_buffer_to_image (VkCommandBuffer command_buffer, VkBuffer buffer, VkImage image, uint32_t width, uint32_t height)
	Record a Vulkan 1.3 vkCmdCopyBufferToImage2 copy for a full 2D image.
void	create_buffer (const VulkanContext &context, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, BufferResource &buffer)
	Create and bind a Vulkan buffer allocation.
void	create_image (const VulkanContext &context, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage &image, VkDeviceMemory &memory)
	Create a 2D VkImage and allocate/bind its memory.
VkImageView	create_image_view (VkDevice device, VkImage image, VkFormat format, VkImageAspectFlags aspect)
	Create a 2D image view for an image.
VkShaderModule	create_shader_module (VkDevice device, const std::vector< char > &spv_bytes)
	Create a shader module from SPIR-V bytecode.
void	create_texture_from_png (const VulkanContext &context, const std::string &path, TextureResource &texture, VkFormat format=VK_FORMAT_R8G8B8A8_UNORM)
	Load a PNG and upload it into a sampled 2D texture.
void	create_texture_from_surface (const VulkanContext &context, SDL_Surface *surface, TextureResource &texture, VkFormat format=VK_FORMAT_R8G8B8A8_UNORM)
	Upload an SDL surface into a sampled 2D texture.
bool	defaultEnableScreenshot ()
bool &	defaultEnableScreenshotStorage ()
const std::string &	defaultExecutableName ()
std::string &	defaultExecutableNameStorage ()
float	deg2rad (float ang)
	Convert degrees to radians.
void	destroy_buffer (VkDevice device, BufferResource &buffer)
	Unmap and destroy a BufferResource.
void	destroy_texture (VkDevice device, TextureResource &texture)
	Destroy every Vulkan handle owned by a TextureResource.
template<typename PlotPixel>
void	draw_filled_triangle (const vec2D &p0, const vec2D &p1, const vec2D &p2, MXCOLOR color, PlotPixel &&plot_pixel)
	Rasterize a filled triangle by testing pixels against edge functions.
void	draw_filled_triangle (SDL_Renderer *renderer, const vec2D &p0, const vec2D &p1, const vec2D &p2, MXCOLOR color)
	Draw a filled triangle directly to an SDL renderer.
void	draw_filled_triangle (VK_Sprite &sprite, const vec2D &p0, const vec2D &p1, const vec2D &p2, MXCOLOR color, int pixel_size=1)
	Draw a filled triangle directly to a VK_Sprite with optional square pixel size.
template<typename DrawSpan>
void	draw_filled_triangle_spans (vec2D p0, vec2D p1, vec2D p2, MXCOLOR color, DrawSpan &&draw_span)
template<typename DrawSpan>
void	draw_filled_triangle_spans_clipped (vec2D p0, vec2D p1, vec2D p2, int clip_min_y, int clip_max_y, MXCOLOR color, DrawSpan &&draw_span)
	Rasterize a filled triangle as horizontal spans.
template<typename PlotPixel>
void	draw_line (int x0, int y0, int x1, int y1, MXCOLOR color, PlotPixel &&plot_pixel)
	Draw a line with Bresenham-style integer stepping.
void	draw_line (SDL_Renderer *renderer, int x0, int y0, int x1, int y1, MXCOLOR color)
	Draw a line directly to an SDL renderer.
void	draw_line (VK_Sprite &sprite, int x0, int y0, int x1, int y1, MXCOLOR color, int pixel_size=1)
	Draw a line directly to a VK_Sprite with optional square pixel size.
float	edge_function (const vec2D &a, const vec2D &b, const vec2D &p)
	Compute the signed edge function value for point `p` relative to edge `a-b.`
void	end_one_time_commands (const VulkanContext &context, VkCommandBuffer command_buffer)
	End, submit with vkQueueSubmit2, wait idle, and free a one-time command buffer.
float	fast_cosf (float theta_degrees)
	Approximate cosine using the degree lookup table with linear interpolation.
float	fast_sinf (float theta_degrees)
	Approximate sine using the degree lookup table with linear interpolation.
uint32_t	find_memory_type (VkPhysicalDevice physical_device, uint32_t type_filter, VkMemoryPropertyFlags properties)
	Find a memory type satisfying a Vulkan memory type mask and property set.
bool	HasPngExtension (const char *file)
std::vector< char >	load_spv (const std::string &path)
	Load a SPIR-V file from disk.
SDL_Surface *	LoadPNG (const char *file)
	Load a PNG file into an SDL_Surface.
void	map_buffer (VkDevice device, BufferResource &buffer)
	Persistently map a host-visible buffer allocation.
constexpr MXCOLOR	MXVK_RGB (int r, int g, int b)
	Build an opaque ARGB color from red, green, and blue components.
std::ostream &	operator<< (std::ostream &out, const vec2D &v)
	Write a 2D vector to a stream using vec2D::Print().
std::ostream &	operator<< (std::ostream &out, const vec3D &v)
	Write a 3D vector to a stream using vec3D::Print().
std::ostream &	operator<< (std::ostream &out, const vec4D &v)
	Write a 4D vector to a stream using vec4D::Print().
std::istream &	operator>> (std::istream &in, vec2D &v)
	Read a 2D vector from a stream as two scalar coordinates.
std::istream &	operator>> (std::istream &in, vec3D &v)
	Read a 3D vector from a stream as three scalar coordinates.
std::istream &	operator>> (std::istream &in, vec4D &v)
	Read a 4D vector from a stream as four scalar coordinates.
float	rad2deg (float rad)
	Convert radians to degrees.
int	rrand (int x, int y)
	Return a pseudo-random integer in the inclusive range between two bounds.
bool	SavePNG (SDL_Texture texture, SDL_Renderer renderer, const char *filename)
	Save an SDL_Texture to a PNG file.
bool	SavePNG_RGBA (const char filename, void buffer, int w, int h)
	Save a raw RGBA pixel buffer to a PNG file.
bool	SavePNG_RGBA16 (const char filename, const void buffer, int w, int h)
	Save a raw 16-bit RGBA pixel buffer to a PNG file.
bool	SaveRawBytes (const char filename, const void buffer, size_t w, size_t h, size_t bpp)
	Save raw data to a file.
void	setDefaultEnableScreenshot (bool enabled)
void	setDefaultExecutableName (const std::string &name)
MXCOLOR	shade_color (MXCOLOR color, float intensity)
	Scale the RGB channels of a color while preserving alpha.
void	transition_image_layout (VkCommandBuffer command_buffer, VkImage image, VkImageLayout old_layout, VkImageLayout new_layout, VkImageAspectFlags aspect=VK_IMAGE_ASPECT_COLOR_BIT)
	Record a Vulkan 1.3 synchronization2 image layout transition.
void	unmap_buffer (VkDevice device, BufferResource &buffer)
	Unmap a BufferResource if it is currently mapped.
bool	WriteRgbaPng (const char filename, const std::uint8_t pixels, const int width, const int height, const int pitch, const int bit_depth, const bool swap_16bit_endianness)

Variables
std::array< float, 361 >	cos_look = build_cos_table()
	Cosine lookup table with one entry per degree from 0 through 360.
constexpr float	EPSILON = 1.0e-5f
	Default tolerance used for floating-point singularity and zero-length checks.
constexpr float	PI = 3.14159265358979323846f
	Mathematical constant pi as a single-precision value.
std::array< float, 361 >	sin_look = build_sin_table()
	Sine lookup table with one entry per degree from 0 through 360.

Detailed Description

Utilities for loading and saving PNG images.

Typedef Documentation

◆ ConfigFile

using mxvk::ConfigFile = VK_Config

Definition at line 99 of file mxvk_cfg.hpp.

◆ Console

using mxvk::Console = VK_Console

Definition at line 183 of file mxvk_console.hpp.

◆ Controller

using mxvk::Controller = VK_Controller

Definition at line 209 of file mxvk_controller.hpp.

◆ Item

using mxvk::Item = VK_ConfigItem

Definition at line 98 of file mxvk_cfg.hpp.

◆ Joystick

using mxvk::Joystick = VK_Joystick

Definition at line 210 of file mxvk_controller.hpp.

◆ Mixer

using mxvk::Mixer = VK_Mixer

Definition at line 110 of file mxvk_sound.hpp.

◆ MXCOLOR

using mxvk::MXCOLOR = std::uint32_t

Packed 32-bit color in ARGB byte order.

Definition at line 40 of file mxvk_math.h.

◆ VK_AbstractModel

using mxvk::VK_AbstractModel = VKAbstractModel

Definition at line 305 of file mxvk_abstract_model.hpp.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Object and polygon state bit flags.

Enumerator
MX_ACTIVE	Active object or polygon.
MX_VISIBLE	Visible object or polygon.
MX_BACKFACE	Polygon is marked as a backface.
MX_CULLED	Object or polygon is culled.

Definition at line 1356 of file mxvk_math.h.

         {
        /// Active object or polygon.
        MX_ACTIVE = 0x1,
 
        /// Visible object or polygon.
        MX_VISIBLE = 0x2,
 
        /// Polygon is marked as a backface.
        MX_BACKFACE = 0x4,
 
        /// Object or polygon is culled.
        MX_CULLED = 0x8
    };

◆ anonymous enum

anonymous enum

Object and polygon state bit flags.

Enumerator
MX_ACTIVE	Active object or polygon.
MX_VISIBLE	Visible object or polygon.
MX_BACKFACE	Polygon is marked as a backface.
MX_CULLED	Object or polygon is culled.

Definition at line 1356 of file mxvk_math_eigen.hpp.

         {
        /// Active object or polygon.
        MX_ACTIVE = 0x1,
 
        /// Visible object or polygon.
        MX_VISIBLE = 0x2,
 
        /// Polygon is marked as a backface.
        MX_BACKFACE = 0x4,
 
        /// Object or polygon is culled.
        MX_CULLED = 0x8
    };

Function Documentation

◆ begin_one_time_commands()

VkCommandBuffer mxvk::begin_one_time_commands ( const VulkanContext & context )

nodiscard

Allocate and begin a primary one-time command buffer.

Parameters

context Valid upload context with device, queue, and command pool.

Returns: Recording command buffer.

Exceptions

mxvk::Exception if allocation or begin fails.

Definition at line 229 of file mxvk_resource.cpp.

                                                                          {
        validate_upload_context(context);
        VkCommandBufferAllocateInfo alloc_info{};
        alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        alloc_info.commandPool = context.command_pool;
        alloc_info.commandBufferCount = 1;
 
        VkCommandBuffer command_buffer = VK_NULL_HANDLE;
        if (vkAllocateCommandBuffers(context.device, &alloc_info, &command_buffer) != VK_SUCCESS) {
            throw mxvk::Exception("failed to allocate one-time command buffer");
        }
 
        VkCommandBufferBeginInfo begin_info{};
        begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
        begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
        if (vkBeginCommandBuffer(command_buffer, &begin_info) != VK_SUCCESS) {
            vkFreeCommandBuffers(context.device, context.command_pool, 1, &command_buffer);
            throw mxvk::Exception("failed to begin one-time command buffer");
        }
 
        return command_buffer;
    }

◆ build_cos_table()

std::array< float, 361 > mxvk::build_cos_table ( )

inline

Definition at line 98 of file mxvk_math.h.

                                                  {
        std::array<float, 361> values{};
        for (int ang = 0; ang <= 360; ++ang) {
            values[static_cast<std::size_t>(ang)] = std::cos(static_cast<float>(ang) * PI / 180.0f);
        }
        return values;
    }

◆ build_sin_table()

std::array< float, 361 > mxvk::build_sin_table ( )

inline

Definition at line 90 of file mxvk_math.h.

                                                  {
        std::array<float, 361> values{};
        for (int ang = 0; ang <= 360; ++ang) {
            values[static_cast<std::size_t>(ang)] = std::sin(static_cast<float>(ang) * PI / 180.0f);
        }
        return values;
    }

◆ BuildTables()

void mxvk::BuildTables ( )

inline

Rebuild the sine and cosine lookup tables.

Definition at line 113 of file mxvk_math.h.

                              {
        std::cout << "mxvk_math: building trigonometric lookup tables\n";
        for (int ang = 0; ang <= 360; ++ang) {
            const float theta = static_cast<float>(ang) * PI / 180.0f;
            cos_look[static_cast<std::size_t>(ang)] = std::cos(theta);
            sin_look[static_cast<std::size_t>(ang)] = std::sin(theta);
        }
        std::cout << "mxvk_math: trigonometric lookup tables ready (361 entries)\n";
    }

◆ color_a()

std::uint8_t mxvk::color_a ( MXCOLOR color )

inlinenodiscardconstexpr

Extract the alpha component from a packed ARGB color.

Definition at line 69 of file mxvk_math.h.

                                                                     {
        return static_cast<std::uint8_t>((color >> 24u) & 0xFFu);
    }

◆ color_b()

std::uint8_t mxvk::color_b ( MXCOLOR color )

inlinenodiscardconstexpr

Extract the blue component from a packed ARGB color.

Definition at line 64 of file mxvk_math.h.

                                                                     {
        return static_cast<std::uint8_t>(color & 0xFFu);
    }

◆ color_g()

std::uint8_t mxvk::color_g ( MXCOLOR color )

inlinenodiscardconstexpr

Extract the green component from a packed ARGB color.

Definition at line 59 of file mxvk_math.h.

                                                                     {
        return static_cast<std::uint8_t>((color >> 8u) & 0xFFu);
    }

◆ color_r()

std::uint8_t mxvk::color_r ( MXCOLOR color )

inlinenodiscardconstexpr

Extract the red component from a packed ARGB color.

Definition at line 54 of file mxvk_math.h.

                                                                     {
        return static_cast<std::uint8_t>((color >> 16u) & 0xFFu);
    }

◆ copy_buffer()

void mxvk::copy_buffer	(	const VulkanContext &	context,
		VkBuffer	source,
		VkBuffer	destination,
		VkDeviceSize	size )

Copy one buffer into another with a one-shot Vulkan 1.3 copy command.

Parameters

context	Valid upload context.
source	Source buffer.
destination	Destination buffer.
size	Bytes to copy.

Exceptions

mxvk::Exception if command allocation, submission, or completion fails.

Definition at line 282 of file mxvk_resource.cpp.

                                        {
        if (size == 0) {
            return;
        }
 
        VkCommandBuffer command_buffer = begin_one_time_commands(context);
 
        VkBufferCopy2 copy_region{};
        copy_region.sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
        copy_region.size = size;
 
        VkCopyBufferInfo2 copy_info{};
        copy_info.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2;
        copy_info.srcBuffer = source;
        copy_info.dstBuffer = destination;
        copy_info.regionCount = 1;
        copy_info.pRegions = &copy_region;
        vkCmdCopyBuffer2(command_buffer, &copy_info);
 
        end_one_time_commands(context, command_buffer);
    }

◆ copy_buffer_to_image()

void mxvk::copy_buffer_to_image	(	VkCommandBuffer	command_buffer,
		VkBuffer	buffer,
		VkImage	image,
		uint32_t	width,
		uint32_t	height )

Record a Vulkan 1.3 vkCmdCopyBufferToImage2 copy for a full 2D image.

Parameters

command_buffer	Command buffer in recording state.
buffer	Source buffer containing tightly packed RGBA pixels.
image	Destination image in VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
width	Copy width in pixels.
height	Copy height in pixels.

Definition at line 347 of file mxvk_resource.cpp.

                                               {
        VkBufferImageCopy2 region{};
        region.sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
        region.bufferOffset = 0;
        region.bufferRowLength = 0;
        region.bufferImageHeight = 0;
        region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        region.imageSubresource.mipLevel = 0;
        region.imageSubresource.baseArrayLayer = 0;
        region.imageSubresource.layerCount = 1;
        region.imageOffset = {0, 0, 0};
        region.imageExtent = {width, height, 1};
 
        VkCopyBufferToImageInfo2 copy_info{};
        copy_info.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
        copy_info.srcBuffer = buffer;
        copy_info.dstImage = image;
        copy_info.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        copy_info.regionCount = 1;
        copy_info.pRegions = &region;
        vkCmdCopyBufferToImage2(command_buffer, &copy_info);
    }

◆ create_buffer()

void mxvk::create_buffer	(	const VulkanContext &	context,
		VkDeviceSize	size,
		VkBufferUsageFlags	usage,
		VkMemoryPropertyFlags	properties,
		BufferResource &	buffer )

Create and bind a Vulkan buffer allocation.

Parameters

context	Valid Vulkan device and physical device handles.
size	Buffer size in bytes.
usage	VkBufferUsageFlagBits describing intended buffer use.
properties	Required memory properties.
buffer	Output buffer resource; any existing contents are destroyed first.

Exceptions

mxvk::Exception on invalid input or Vulkan allocation failure.

Definition at line 67 of file mxvk_resource.cpp.

                                               {
        validate_context(context);
        if (size == 0) {
            throw mxvk::Exception("create_buffer requires a non-zero size");
        }
        destroy_buffer(context.device, buffer);
 
        VkBufferCreateInfo buffer_info{};
        buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
        buffer_info.size = size;
        buffer_info.usage = usage;
        buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        if (vkCreateBuffer(context.device, &buffer_info, nullptr, &buffer.buffer) != VK_SUCCESS) {
            throw mxvk::Exception("failed to create Vulkan buffer");
        }
 
        VkMemoryRequirements requirements{};
        vkGetBufferMemoryRequirements(context.device, buffer.buffer, &requirements);
 
        VkMemoryAllocateInfo allocation{};
        allocation.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
        allocation.allocationSize = requirements.size;
        try {
            allocation.memoryTypeIndex = find_memory_type(context.physical_device, requirements.memoryTypeBits, properties);
            if (vkAllocateMemory(context.device, &allocation, nullptr, &buffer.memory) != VK_SUCCESS) {
                throw mxvk::Exception("failed to allocate Vulkan buffer memory");
            }
            if (vkBindBufferMemory(context.device, buffer.buffer, buffer.memory, 0) != VK_SUCCESS) {
                throw mxvk::Exception("failed to bind Vulkan buffer memory");
            }
        } catch (...) {
            destroy_buffer(context.device, buffer);
            throw;
        }
        buffer.size = size;
    }

◆ create_image()

void mxvk::create_image	(	const VulkanContext &	context,
		uint32_t	width,
		uint32_t	height,
		VkFormat	format,
		VkImageTiling	tiling,
		VkImageUsageFlags	usage,
		VkMemoryPropertyFlags	properties,
		VkImage &	image,
		VkDeviceMemory &	memory )

Create a 2D VkImage and allocate/bind its memory.

Parameters

context	Valid Vulkan device and physical device handles.
width	Image width in pixels.
height	Image height in pixels.
format	Image format.
tiling	Image tiling mode.
usage	VkImageUsageFlagBits describing intended image use.
properties	Required memory properties.
image	Output image handle.
memory	Output memory handle bound to `image`.

Exceptions

mxvk::Exception on invalid dimensions or Vulkan allocation failure.

Definition at line 142 of file mxvk_resource.cpp.

                                              {
        validate_context(context);
        if (width == 0 || height == 0) {
            throw mxvk::Exception("create_image requires non-zero dimensions");
        }
        if (image != VK_NULL_HANDLE) {
            vkDestroyImage(context.device, image, nullptr);
            image = VK_NULL_HANDLE;
        }
        if (memory != VK_NULL_HANDLE) {
            vkFreeMemory(context.device, memory, nullptr);
            memory = VK_NULL_HANDLE;
        }
 
        VkImageCreateInfo image_info{};
        image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
        image_info.imageType = VK_IMAGE_TYPE_2D;
        image_info.extent = {width, height, 1};
        image_info.mipLevels = 1;
        image_info.arrayLayers = 1;
        image_info.format = format;
        image_info.tiling = tiling;
        image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        image_info.usage = usage;
        image_info.samples = VK_SAMPLE_COUNT_1_BIT;
        image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        if (vkCreateImage(context.device, &image_info, nullptr, &image) != VK_SUCCESS) {
            throw mxvk::Exception("failed to create Vulkan image");
        }
 
        VkMemoryRequirements requirements{};
        vkGetImageMemoryRequirements(context.device, image, &requirements);
 
        VkMemoryAllocateInfo allocation{};
        allocation.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
        allocation.allocationSize = requirements.size;
        try {
            allocation.memoryTypeIndex = find_memory_type(context.physical_device, requirements.memoryTypeBits, properties);
            if (vkAllocateMemory(context.device, &allocation, nullptr, &memory) != VK_SUCCESS) {
                throw mxvk::Exception("failed to allocate Vulkan image memory");
            }
            if (vkBindImageMemory(context.device, image, memory, 0) != VK_SUCCESS) {
                throw mxvk::Exception("failed to bind Vulkan image memory");
            }
        } catch (...) {
            if (memory != VK_NULL_HANDLE) {
                vkFreeMemory(context.device, memory, nullptr);
                memory = VK_NULL_HANDLE;
            }
            if (image != VK_NULL_HANDLE) {
                vkDestroyImage(context.device, image, nullptr);
                image = VK_NULL_HANDLE;
            }
            throw;
        }
    }

◆ create_image_view()

VkImageView mxvk::create_image_view	(	VkDevice	device,
		VkImage	image,
		VkFormat	format,
		VkImageAspectFlags	aspect )

nodiscard

Create a 2D image view for an image.

Parameters

device	Logical device.
image	Image to view.
format	View format.
aspect	Image aspect mask, usually VK_IMAGE_ASPECT_COLOR_BIT.

Returns: Created image view handle.

Exceptions

mxvk::Exception if view creation fails.

Definition at line 207 of file mxvk_resource.cpp.

                                                             {
        VkImageViewCreateInfo view_info{};
        view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
        view_info.image = image;
        view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
        view_info.format = format;
        view_info.subresourceRange.aspectMask = aspect;
        view_info.subresourceRange.baseMipLevel = 0;
        view_info.subresourceRange.levelCount = 1;
        view_info.subresourceRange.baseArrayLayer = 0;
        view_info.subresourceRange.layerCount = 1;
 
        VkImageView image_view = VK_NULL_HANDLE;
        if (vkCreateImageView(device, &view_info, nullptr, &image_view) != VK_SUCCESS) {
            throw mxvk::Exception("failed to create Vulkan image view");
        }
        return image_view;
    }

◆ create_shader_module()

VkShaderModule mxvk::create_shader_module	(	VkDevice	device,
		const std::vector< char > &	spv_bytes )

nodiscard

Create a shader module from SPIR-V bytecode.

Parameters

device	Logical Vulkan device used to create the module.
spv_bytes	SPIR-V bytecode payload.

Returns: Created shader module handle.

Exceptions

mxvk::Exception when inputs are invalid or module creation fails.

Definition at line 30 of file mxvk_shader_module.cpp.

                                                                                           {
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create shader module with a null device");
        }
        if (spv_bytes.empty() || (spv_bytes.size() % 4U) != 0U) {
            throw mxvk::Exception("Invalid SPIR-V shader data");
        }
 
        VkShaderModuleCreateInfo create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
        create_info.codeSize = spv_bytes.size();
        create_info.pCode = reinterpret_cast<const uint32_t *>(spv_bytes.data());
 
        VkShaderModule module = VK_NULL_HANDLE;
        if (vkCreateShaderModule(device, &create_info, nullptr, &module) != VK_SUCCESS) {
            throw mxvk::Exception("Failed to create shader module");
        }
 
        return module;
    }

◆ create_texture_from_png()

void mxvk::create_texture_from_png	(	const VulkanContext &	context,
		const std::string &	path,
		TextureResource &	texture,
		VkFormat	format = VK_FORMAT_R8G8B8A8_UNORM )

Load a PNG and upload it into a sampled 2D texture.

Parameters

context	Valid upload context.
path	PNG path.
texture	Output texture resource; any existing contents are destroyed first.
format	Destination image format. Defaults to VK_FORMAT_R8G8B8A8_UNORM.

Exceptions

mxvk::Exception if loading or upload fails.

Definition at line 437 of file mxvk_resource.cpp.

                                                  {
        std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)> surface(mxvk::LoadPNG(path.c_str()), SDL_DestroySurface);
        if (surface == nullptr) {
            throw mxvk::Exception(std::format("failed to load texture PNG: {}", path));
        }
        create_texture_from_surface(context, surface.get(), texture, format);
    }

◆ create_texture_from_surface()

void mxvk::create_texture_from_surface	(	const VulkanContext &	context,
		SDL_Surface *	surface,
		TextureResource &	texture,
		VkFormat	format = VK_FORMAT_R8G8B8A8_UNORM )

Upload an SDL surface into a sampled 2D texture.

Parameters

context	Valid upload context.
surface	Source surface. Pixels are copied immediately.
texture	Output texture resource; any existing contents are destroyed first.
format	Destination image format. Defaults to VK_FORMAT_R8G8B8A8_UNORM.

The source surface is copied row-by-row into a tight staging buffer to tolerate SDL pitch padding. The surface is expected to contain 4 bytes per pixel, as produced by MXVK's PNG loader.

Exceptions

mxvk::Exception on invalid input, allocation failure, or upload failure.

Definition at line 374 of file mxvk_resource.cpp.

                                                      {
        validate_upload_context(context);
        if (surface == nullptr || surface->pixels == nullptr || surface->w <= 0 || surface->h <= 0) {
            throw mxvk::Exception("create_texture_from_surface requires a valid SDL surface");
        }
        destroy_texture(context.device, texture);
 
        const uint32_t width = static_cast<uint32_t>(surface->w);
        const uint32_t height = static_cast<uint32_t>(surface->h);
        const VkDeviceSize image_size = static_cast<VkDeviceSize>(width) * static_cast<VkDeviceSize>(height) * 4U;
        std::vector<std::byte> tight_pixels(static_cast<size_t>(image_size));
 
        // SDL surfaces may have padded rows; Vulkan buffer-image copies use tight rows here.
        const auto *src = static_cast<const std::byte *>(surface->pixels);
        auto *dst = tight_pixels.data();
        const size_t tight_row_bytes = static_cast<size_t>(width) * 4U;
        for (uint32_t y = 0; y < height; ++y) {
            std::memcpy(dst + y * tight_row_bytes, src + static_cast<size_t>(y) * static_cast<size_t>(surface->pitch), tight_row_bytes);
        }
 
        BufferResource staging{};
        try {
            create_buffer(context,
                          image_size,
                          VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
                          staging);
            map_buffer(context.device, staging);
            std::memcpy(staging.mapped, tight_pixels.data(), tight_pixels.size());
            unmap_buffer(context.device, staging);
 
            create_image(context,
                         width,
                         height,
                         format,
                         VK_IMAGE_TILING_OPTIMAL,
                         VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
                         VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
                         texture.image,
                         texture.memory);
 
            const VkCommandBuffer cmd = begin_one_time_commands(context);
            transition_image_layout(cmd, texture.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
            copy_buffer_to_image(cmd, staging.buffer, texture.image, width, height);
            transition_image_layout(cmd, texture.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
            end_one_time_commands(context, cmd);
 
            destroy_buffer(context.device, staging);
 
            texture.view = create_image_view(context.device, texture.image, format, VK_IMAGE_ASPECT_COLOR_BIT);
            create_sampler(context.device, texture);
            texture.width = width;
            texture.height = height;
        } catch (...) {
            destroy_buffer(context.device, staging);
            destroy_texture(context.device, texture);
            throw;
        }
    }

◆ defaultEnableScreenshot()

bool mxvk::defaultEnableScreenshot ( )

inlinenodiscard

Definition at line 15 of file mxvk_runtime_options.hpp.

                                                        {
        return defaultEnableScreenshotStorage();
    }

◆ defaultEnableScreenshotStorage()

bool & mxvk::defaultEnableScreenshotStorage ( )

inlinenodiscard

Definition at line 6 of file mxvk_runtime_options.hpp.

                                                                {
        static bool enabled = false;
        return enabled;
    }

◆ defaultExecutableName()

const std::string & mxvk::defaultExecutableName ( )

inlinenodiscard

Definition at line 28 of file mxvk_runtime_options.hpp.

                                                                  {
        return defaultExecutableNameStorage();
    }

◆ defaultExecutableNameStorage()

std::string & mxvk::defaultExecutableNameStorage ( )

inlinenodiscard

Definition at line 19 of file mxvk_runtime_options.hpp.

                                                                   {
        static std::string name = "mxvk";
        return name;
    }

◆ deg2rad()

float mxvk::deg2rad ( float ang )

inlinenodiscard

Convert degrees to radians.

Definition at line 124 of file mxvk_math.h.

                                                  {
        return ang * PI / 180.0f;
    }

◆ destroy_buffer()

void mxvk::destroy_buffer	(	VkDevice	device,
		BufferResource &	buffer )

Unmap and destroy a BufferResource.

Parameters

device	Logical device that owns the resource.
buffer	Resource to release and reset.

Definition at line 108 of file mxvk_resource.cpp.

                                                                 {
        if (device == VK_NULL_HANDLE) {
            buffer = {};
            return;
        }
        unmap_buffer(device, buffer);
        if (buffer.buffer != VK_NULL_HANDLE) {
            vkDestroyBuffer(device, buffer.buffer, nullptr);
        }
        if (buffer.memory != VK_NULL_HANDLE) {
            vkFreeMemory(device, buffer.memory, nullptr);
        }
        buffer = {};
    }

◆ destroy_texture()

void mxvk::destroy_texture	(	VkDevice	device,
		TextureResource &	texture )

Destroy every Vulkan handle owned by a TextureResource.

Parameters

device	Logical device that owns the texture.
texture	Texture resource to release and reset.

Definition at line 448 of file mxvk_resource.cpp.

                                                                    {
        if (device == VK_NULL_HANDLE) {
            texture = {};
            return;
        }
        if (texture.sampler != VK_NULL_HANDLE) {
            vkDestroySampler(device, texture.sampler, nullptr);
        }
        if (texture.view != VK_NULL_HANDLE) {
            vkDestroyImageView(device, texture.view, nullptr);
        }
        if (texture.image != VK_NULL_HANDLE) {
            vkDestroyImage(device, texture.image, nullptr);
        }
        if (texture.memory != VK_NULL_HANDLE) {
            vkFreeMemory(device, texture.memory, nullptr);
        }
        texture = {};
    }

◆ draw_filled_triangle() [1/3]

template<typename PlotPixel>

void mxvk::draw_filled_triangle	(	const vec2D &	p0,
		const vec2D &	p1,
		const vec2D &	p2,
		MXCOLOR	color,
		PlotPixel &&	plot_pixel )

Rasterize a filled triangle by testing pixels against edge functions.

Template Parameters

PlotPixel Callable accepting (x, y, MXCOLOR).

Parameters

p0	First triangle vertex in screen coordinates.
p1	Second triangle vertex in screen coordinates.
p2	Third triangle vertex in screen coordinates.
color	Packed ARGB color.
plot_pixel	Pixel plotting callable.

Definition at line 2141 of file mxvk_math.h.

                                                                                                                        {
        const float area = edge_function(p0, p1, p2);
        if (std::fabs(area) <= EPSILON) {
            return;
        }
 
        const int min_x = static_cast<int>(std::floor(std::min({p0.x, p1.x, p2.x})));
        const int max_x = static_cast<int>(std::ceil(std::max({p0.x, p1.x, p2.x})));
        const int min_y = static_cast<int>(std::floor(std::min({p0.y, p1.y, p2.y})));
        const int max_y = static_cast<int>(std::ceil(std::max({p0.y, p1.y, p2.y})));
 
        for (int y = min_y; y <= max_y; ++y) {
            for (int x = min_x; x <= max_x; ++x) {
                const vec2D p(static_cast<float>(x) + 0.5f, static_cast<float>(y) + 0.5f);
                const float w0 = edge_function(p1, p2, p);
                const float w1 = edge_function(p2, p0, p);
                const float w2 = edge_function(p0, p1, p);
                if ((area > 0.0f && w0 >= 0.0f && w1 >= 0.0f && w2 >= 0.0f) ||
                    (area < 0.0f && w0 <= 0.0f && w1 <= 0.0f && w2 <= 0.0f)) {
                    plot_pixel(x, y, color);
                }
            }
        }
    }

◆ draw_filled_triangle() [2/3]

void mxvk::draw_filled_triangle	(	SDL_Renderer *	renderer,
		const vec2D &	p0,
		const vec2D &	p1,
		const vec2D &	p2,
		MXCOLOR	color )

inline

Draw a filled triangle directly to an SDL renderer.

Definition at line 2167 of file mxvk_math.h.

                                                                                                                               {
        draw_filled_triangle(p0, p1, p2, color, SDLRendererPixelPlotter{renderer});
    }

◆ draw_filled_triangle() [3/3]

void mxvk::draw_filled_triangle	(	VK_Sprite &	sprite,
		const vec2D &	p0,
		const vec2D &	p1,
		const vec2D &	p2,
		MXCOLOR	color,
		int	pixel_size = 1 )

inline

Draw a filled triangle directly to a VK_Sprite with optional square pixel size.

Definition at line 2172 of file mxvk_math.h.

                                                                                                                                            {
        draw_filled_triangle(p0, p1, p2, color, VKSpritePixelPlotter{&sprite, pixel_size});
    }

◆ draw_filled_triangle_spans()

template<typename DrawSpan>

void mxvk::draw_filled_triangle_spans	(	vec2D	p0,
		vec2D	p1,
		vec2D	p2,
		MXCOLOR	color,
		DrawSpan &&	draw_span )

Definition at line 2268 of file mxvk_math.h.

                                                                                                       {
        draw_filled_triangle_spans_clipped(p0, p1, p2, std::numeric_limits<int>::min(), std::numeric_limits<int>::max(), color, std::forward<DrawSpan>(draw_span));
    }

◆ draw_filled_triangle_spans_clipped()

template<typename DrawSpan>

void mxvk::draw_filled_triangle_spans_clipped	(	vec2D	p0,
		vec2D	p1,
		vec2D	p2,
		int	clip_min_y,
		int	clip_max_y,
		MXCOLOR	color,
		DrawSpan &&	draw_span )

Rasterize a filled triangle as horizontal spans.

Template Parameters

DrawSpan Callable accepting (x0, x1, y, MXCOLOR).

Parameters

p0	First triangle vertex in screen coordinates.
p1	Second triangle vertex in screen coordinates.
p2	Third triangle vertex in screen coordinates.
clip_min_y	Minimum inclusive scanline to rasterize.
clip_max_y	Maximum inclusive scanline to rasterize.
color	Packed ARGB color.
draw_span	Span drawing callable.

Definition at line 2188 of file mxvk_math.h.

                                                                                                                                               {
        if (std::fabs(edge_function(p0, p1, p2)) <= EPSILON) {
            return;
        }
 
        struct SpanEdge {
            int y0 = 0;
            int y1 = -1;
            float x0 = 0.0f;
            float slope = 0.0f;
 
            [[nodiscard]] float x_at(int y) const {
                return x0 + static_cast<float>(y - y0) * slope;
            }
        };
 
        const int min_y = std::max(clip_min_y, static_cast<int>(std::floor(std::min({p0.y, p1.y, p2.y}))));
        const int max_y = std::min(clip_max_y, static_cast<int>(std::ceil(std::max({p0.y, p1.y, p2.y}))));
        if (min_y > max_y) {
            return;
        }
 
        std::array<SpanEdge, 3> edges{};
        int edge_count = 0;
        const auto add_edge = [&](vec2D a, vec2D b) {
            if (std::fabs(a.y - b.y) <= EPSILON) {
                return;
            }
            if (a.y > b.y) {
                std::swap(a, b);
            }
 
            const int y0 = std::max(min_y, static_cast<int>(std::ceil(a.y - 0.5f)));
            const int y1 = std::min(max_y, static_cast<int>(std::ceil(b.y - 0.5f)) - 1);
            if (y0 > y1) {
                return;
            }
 
            SpanEdge &edge = edges[static_cast<std::size_t>(edge_count++)];
            edge.y0 = y0;
            edge.y1 = y1;
            edge.slope = (b.x - a.x) / (b.y - a.y);
            edge.x0 = a.x + ((static_cast<float>(y0) + 0.5f) - a.y) * edge.slope;
        };
 
        add_edge(p0, p1);
        add_edge(p1, p2);
        add_edge(p2, p0);
 
        for (int y = min_y; y <= max_y; ++y) {
            std::array<float, 3> intersections{};
            int intersection_count = 0;
 
            for (int edge_index = 0; edge_index < edge_count; ++edge_index) {
                const SpanEdge &edge = edges[static_cast<std::size_t>(edge_index)];
                if (y >= edge.y0 && y <= edge.y1) {
                    intersections[static_cast<std::size_t>(intersection_count++)] = edge.x_at(y);
                }
            }
 
            if (intersection_count < 2) {
                continue;
            }
 
            float min_x = intersections[0];
            float max_x = intersections[0];
            for (int i = 1; i < intersection_count; ++i) {
                min_x = std::min(min_x, intersections[static_cast<std::size_t>(i)]);
                max_x = std::max(max_x, intersections[static_cast<std::size_t>(i)]);
            }
 
            const int x0 = static_cast<int>(std::ceil(min_x - 0.5f));
            const int x1 = static_cast<int>(std::floor(max_x - 0.5f));
            if (x0 <= x1) {
                draw_span(x0, x1, y, color);
            }
        }
    }

◆ draw_line() [1/3]

template<typename PlotPixel>

void mxvk::draw_line	(	int	x0,
		int	y0,
		int	x1,
		int	y1,
		MXCOLOR	color,
		PlotPixel &&	plot_pixel )

Draw a line with Bresenham-style integer stepping.

Template Parameters

PlotPixel Callable accepting (x, y, MXCOLOR).

Parameters

x0	Start X coordinate.
y0	Start Y coordinate.
x1	End X coordinate.
y1	End Y coordinate.
color	Packed ARGB color.
plot_pixel	Pixel plotting callable.

Definition at line 2092 of file mxvk_math.h.

                                                                                          {
        const int dx = std::abs(x1 - x0);
        const int sx = x0 < x1 ? 1 : -1;
        const int dy = -std::abs(y1 - y0);
        const int sy = y0 < y1 ? 1 : -1;
        int err = dx + dy;
 
        while (1) {
            plot_pixel(x0, y0, color);
            if (x0 == x1 && y0 == y1) {
                break;
            }
            const int e2 = 2 * err;
            if (e2 >= dy) {
                err += dy;
                x0 += sx;
            }
            if (e2 <= dx) {
                err += dx;
                y0 += sy;
            }
        }
    }

◆ draw_line() [2/3]

void mxvk::draw_line	(	SDL_Renderer *	renderer,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		MXCOLOR	color )

inline

Draw a line directly to an SDL renderer.

Definition at line 2117 of file mxvk_math.h.

                                                                                                 {
        draw_line(x0, y0, x1, y1, color, SDLRendererPixelPlotter{renderer});
    }

◆ draw_line() [3/3]

void mxvk::draw_line	(	VK_Sprite &	sprite,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		MXCOLOR	color,
		int	pixel_size = 1 )

inline

Draw a line directly to a VK_Sprite with optional square pixel size.

Definition at line 2122 of file mxvk_math.h.

                                                                                                              {
        draw_line(x0, y0, x1, y1, color, VKSpritePixelPlotter{&sprite, pixel_size});
    }

◆ edge_function()

float mxvk::edge_function	(	const vec2D &	a,
		const vec2D &	b,
		const vec2D &	p )

inlinenodiscard

Compute the signed edge function value for point p relative to edge a-b.

Definition at line 2127 of file mxvk_math.h.

                                                                                             {
        return (p.x - a.x) * (b.y - a.y) - (p.y - a.y) * (b.x - a.x);
    }

◆ end_one_time_commands()

void mxvk::end_one_time_commands	(	const VulkanContext &	context,
		VkCommandBuffer	command_buffer )

End, submit with vkQueueSubmit2, wait idle, and free a one-time command buffer.

Parameters

context	Valid upload context with device, queue, and command pool.
command_buffer	Command buffer returned by begin_one_time_commands().

Exceptions

mxvk::Exception if end, submit, or queue wait fails.

Definition at line 253 of file mxvk_resource.cpp.

                                                                                             {
        validate_upload_context(context);
        if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) {
            vkFreeCommandBuffers(context.device, context.command_pool, 1, &command_buffer);
            throw mxvk::Exception("failed to end one-time command buffer");
        }
 
        VkCommandBufferSubmitInfo command_buffer_info{};
        command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
        command_buffer_info.commandBuffer = command_buffer;
 
        VkSubmitInfo2 submit_info{};
        submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
        submit_info.commandBufferInfoCount = 1;
        submit_info.pCommandBufferInfos = &command_buffer_info;
 
        if (vkQueueSubmit2(context.graphics_queue, 1, &submit_info, VK_NULL_HANDLE) != VK_SUCCESS) {
            vkFreeCommandBuffers(context.device, context.command_pool, 1, &command_buffer);
            throw mxvk::Exception("failed to submit one-time command buffer");
        }
        if (vkQueueWaitIdle(context.graphics_queue) != VK_SUCCESS) {
            vkFreeCommandBuffers(context.device, context.command_pool, 1, &command_buffer);
            throw mxvk::Exception("failed to wait for one-time command completion");
        }
 
        // Upload command buffers are transient; callers only observe completion.
        vkFreeCommandBuffers(context.device, context.command_pool, 1, &command_buffer);
    }

◆ fast_cosf()

float mxvk::fast_cosf ( float theta_degrees )

inlinenodiscard

Approximate cosine using the degree lookup table with linear interpolation.

Parameters

theta_degrees Angle in degrees.

Returns: Approximate cosine of the angle.

Definition at line 138 of file mxvk_math.h.

                                                              {
        theta_degrees = std::fmod(theta_degrees, 360.0f);
        if (theta_degrees < 0.0f) {
            theta_degrees += 360.0f;
        }
        const int theta_int = static_cast<int>(theta_degrees);
        const float theta_frac = theta_degrees - static_cast<float>(theta_int);
        return cos_look[static_cast<std::size_t>(theta_int)] + theta_frac * (cos_look[static_cast<std::size_t>(theta_int + 1)] - cos_look[static_cast<std::size_t>(theta_int)]);
    }

◆ fast_sinf()

float mxvk::fast_sinf ( float theta_degrees )

inlinenodiscard

Approximate sine using the degree lookup table with linear interpolation.

Parameters

theta_degrees Angle in degrees.

Returns: Approximate sine of the angle.

Definition at line 153 of file mxvk_math.h.

                                                              {
        theta_degrees = std::fmod(theta_degrees, 360.0f);
        if (theta_degrees < 0.0f) {
            theta_degrees += 360.0f;
        }
        const int theta_int = static_cast<int>(theta_degrees);
        const float theta_frac = theta_degrees - static_cast<float>(theta_int);
        return sin_look[static_cast<std::size_t>(theta_int)] + theta_frac * (sin_look[static_cast<std::size_t>(theta_int + 1)] - sin_look[static_cast<std::size_t>(theta_int)]);
    }

◆ find_memory_type()

uint32_t mxvk::find_memory_type	(	VkPhysicalDevice	physical_device,
		uint32_t	type_filter,
		VkMemoryPropertyFlags	properties )

nodiscard

Find a memory type satisfying a Vulkan memory type mask and property set.

Parameters

physical_device	Physical device to query.
type_filter	Memory type bitmask from VkMemoryRequirements.
properties	Required VkMemoryPropertyFlagBits.

Returns: Matching memory type index.

Exceptions

mxvk::Exception if no matching memory type is available.

Definition at line 48 of file mxvk_resource.cpp.

                                                                {
        if (physical_device == VK_NULL_HANDLE) {
            throw mxvk::Exception("find_memory_type requires a valid physical device");
        }
 
        VkPhysicalDeviceMemoryProperties memory_properties{};
        vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
        for (uint32_t i = 0; i < memory_properties.memoryTypeCount; ++i) {
            if ((type_filter & (1U << i)) &&
                (memory_properties.memoryTypes[i].propertyFlags & properties) == properties) {
                return i;
            }
        }
 
        throw mxvk::Exception("failed to find suitable Vulkan memory type");
    }

◆ HasPngExtension()

bool mxvk::HasPngExtension ( const char * file )

nodiscard

Definition at line 22 of file mxvk_png.cpp.

                                                         {
        if (file == nullptr) {
            return false;
        }
 
        std::string lower(file);
        std::ranges::transform(lower, lower.begin(),
                               [](const unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
        return lower.ends_with(".png");
    }

◆ load_spv()

std::vector< char > mxvk::load_spv ( const std::string & path )

nodiscard

Load a SPIR-V file from disk.

Parameters

path	Absolute or relative path to a .spv file.

Returns: Raw bytes loaded from file.

Exceptions

mxvk::Exception when the file cannot be opened, is empty, or is not 4-byte aligned.

Definition at line 9 of file mxvk_shader_module.cpp.

                                                    {
        if (path.empty()) {
            throw mxvk::Exception("SPIR-V path is empty");
        }
 
        std::ifstream file(path, std::ios::binary);
        if (!file.is_open()) {
            throw mxvk::Exception("Failed to open SPIR-V file: " + path);
        }
 
        const std::vector<char> bytes((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        if (bytes.empty()) {
            throw mxvk::Exception("SPIR-V file is empty: " + path);
        }
        if ((bytes.size() % 4U) != 0U) {
            throw mxvk::Exception("SPIR-V file size is not 4-byte aligned: " + path);
        }
 
        return bytes;
    }

◆ LoadPNG()

SDL_Surface * mxvk::LoadPNG ( const char * file )

Load a PNG file into an SDL_Surface.

Parameters

file	Path to the PNG file.

Returns: Newly allocated SDL_Surface, or nullptr on failure.

Definition at line 103 of file mxvk_png.cpp.

                                           {
        if (!HasPngExtension(file)) {
            return nullptr;
        }
 
        FILE *fp = std::fopen(file, "rb");
        if (fp == nullptr) {
            std::cerr << "Failed to open PNG file: " << file << "\n";
            return nullptr;
        }
 
        png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
        if (png == nullptr) {
            std::fclose(fp);
            return nullptr;
        }
 
        png_infop info = png_create_info_struct(png);
        if (info == nullptr) {
            png_destroy_read_struct(&png, nullptr, nullptr);
            std::fclose(fp);
            return nullptr;
        }
 
        if (setjmp(png_jmpbuf(png))) {
            png_destroy_read_struct(&png, &info, nullptr);
            std::fclose(fp);
            return nullptr;
        }
 
        png_init_io(png, fp);
        png_read_info(png, info);
 
        const int width = static_cast<int>(png_get_image_width(png, info));
        const int height = static_cast<int>(png_get_image_height(png, info));
        const png_byte color_type = png_get_color_type(png, info);
        const png_byte bit_depth = png_get_bit_depth(png, info);
 
        if (width <= 0 || height <= 0) {
            png_destroy_read_struct(&png, &info, nullptr);
            std::fclose(fp);
            return nullptr;
        }
 
        if (bit_depth == 16) {
            png_set_strip_16(png);
        }
 
        if (color_type == PNG_COLOR_TYPE_PALETTE) {
            png_set_palette_to_rgb(png);
        }
 
        if (png_get_valid(png, info, PNG_INFO_tRNS) != 0) {
            png_set_tRNS_to_alpha(png);
        }
 
        if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
            png_set_gray_to_rgb(png);
        }
 
        if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_GRAY ||
            color_type == PNG_COLOR_TYPE_PALETTE) {
            png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
        }
 
        png_read_update_info(png, info);
 
        SDL_Surface *surface = SDL_CreateSurface(width, height, SDL_PIXELFORMAT_RGBA32);
        if (surface == nullptr) {
            png_destroy_read_struct(&png, &info, nullptr);
            std::fclose(fp);
            return nullptr;
        }
 
        const png_size_t row_bytes = png_get_rowbytes(png, info);
        if (row_bytes > static_cast<png_size_t>(surface->pitch)) {
            std::cerr << "mx: Unexpected PNG row stride mismatch for file: " << file << "\n";
            SDL_DestroySurface(surface);
            png_destroy_read_struct(&png, &info, nullptr);
            std::fclose(fp);
            return nullptr;
        }
 
        auto *pixels = static_cast<std::uint8_t *>(surface->pixels);
        std::vector<png_bytep> row_pointers(static_cast<std::size_t>(height));
        for (int y = 0; y < height; ++y) {
            row_pointers[static_cast<std::size_t>(y)] = pixels + (y * surface->pitch);
        }
 
        png_read_image(png, row_pointers.data());
        png_read_end(png, nullptr);
 
        png_destroy_read_struct(&png, &info, nullptr);
        std::fclose(fp);
        return surface;
    }

◆ map_buffer()

void mxvk::map_buffer	(	VkDevice	device,
		BufferResource &	buffer )

Persistently map a host-visible buffer allocation.

Parameters

device	Logical device that owns the buffer memory.
buffer	Buffer resource to map.

Exceptions

mxvk::Exception if the buffer is invalid or mapping fails.

Definition at line 123 of file mxvk_resource.cpp.

                                                             {
        if (buffer.mapped != nullptr) {
            return;
        }
        if (device == VK_NULL_HANDLE || buffer.memory == VK_NULL_HANDLE || buffer.size == 0) {
            throw mxvk::Exception("map_buffer requires a valid buffer allocation");
        }
        if (vkMapMemory(device, buffer.memory, 0, buffer.size, 0, &buffer.mapped) != VK_SUCCESS || buffer.mapped == nullptr) {
            throw mxvk::Exception("failed to map Vulkan buffer memory");
        }
    }

◆ MXVK_RGB()

MXCOLOR mxvk::MXVK_RGB	(	int	r,
		int	g,
		int	b )

inlinenodiscardconstexpr

Build an opaque ARGB color from red, green, and blue components.

Parameters

r	Red component in the low 8 bits.
g	Green component in the low 8 bits.
b	Blue component in the low 8 bits.

Returns: Packed color with alpha set to 255.

Definition at line 49 of file mxvk_math.h.

                                                                         {
        return 0xFF000000u | ((static_cast<MXCOLOR>(r) & 0xFFu) << 16u) | ((static_cast<MXCOLOR>(g) & 0xFFu) << 8u) | (static_cast<MXCOLOR>(b) & 0xFFu);
    }

◆ operator<<() [1/3]

std::ostream & mxvk::operator<<	(	std::ostream &	out,
		const vec2D &	v )

inline

Write a 2D vector to a stream using vec2D::Print().

Definition at line 281 of file mxvk_math.h.

                                                                   {
        return out << v.Print();
    }

◆ operator<<() [2/3]

std::ostream & mxvk::operator<<	(	std::ostream &	out,
		const vec3D &	v )

inline

Write a 3D vector to a stream using vec3D::Print().

Definition at line 406 of file mxvk_math.h.

                                                                   {
        return out << v.Print();
    }

◆ operator<<() [3/3]

std::ostream & mxvk::operator<<	(	std::ostream &	out,
		const vec4D &	v )

inline

Write a 4D vector to a stream using vec4D::Print().

Definition at line 562 of file mxvk_math.h.

                                                                   {
        return out << v.Print();
    }

◆ operator>>() [1/3]

std::istream & mxvk::operator>>	(	std::istream &	in,
		vec2D &	v )

inline

Read a 2D vector from a stream as two scalar coordinates.

Definition at line 286 of file mxvk_math.h.

                                                            {
        return in >> v.x >> v.y;
    }

◆ operator>>() [2/3]

std::istream & mxvk::operator>>	(	std::istream &	in,
		vec3D &	v )

inline

Read a 3D vector from a stream as three scalar coordinates.

Definition at line 411 of file mxvk_math.h.

                                                            {
        return in >> v.x >> v.y >> v.z;
    }

◆ operator>>() [3/3]

std::istream & mxvk::operator>>	(	std::istream &	in,
		vec4D &	v )

inline

Read a 4D vector from a stream as four scalar coordinates.

Definition at line 567 of file mxvk_math.h.

                                                            {
        return in >> v.x >> v.y >> v.z >> v.w;
    }

◆ rad2deg()

float mxvk::rad2deg ( float rad )

inlinenodiscard

Convert radians to degrees.

Definition at line 129 of file mxvk_math.h.

                                                  {
        return rad * 180.0f / PI;
    }

◆ rrand()

int mxvk::rrand	(	int	x,
		int	y )

inlinenodiscard

Return a pseudo-random integer in the inclusive range between two bounds.

Parameters

x	First bound.
y	Second bound.

Returns: Random integer in [min(x, y), max(x, y)].

Definition at line 169 of file mxvk_math.h.

                                                 {
        if (x > y) {
            std::swap(x, y);
        }
        return x + (std::rand() % (y - x + 1));
    }

◆ SavePNG()

bool mxvk::SavePNG	(	SDL_Texture *	texture,
		SDL_Renderer *	renderer,
		const char *	filename )

Save an SDL_Texture to a PNG file.

Parameters

texture	Source texture.
renderer	Renderer used to read back the texture pixels.
filename	Destination file path.

Returns: true on success, false on failure.

Definition at line 200 of file mxvk_png.cpp.

                                                                                     {
        if (texture == nullptr || renderer == nullptr || filename == nullptr) {
            std::cerr << "mx: Invalid SavePNG parameters.\n";
            return false;
        }
 
        float width_f = 0.0F;
        float height_f = 0.0F;
        if (!SDL_GetTextureSize(texture, &width_f, &height_f)) {
            std::cerr << "mx: Failed to query texture size: " << SDL_GetError() << "\n";
            return false;
        }
 
        if (!std::isfinite(width_f) || !std::isfinite(height_f) || width_f <= 0.0F || height_f <= 0.0F) {
            std::cerr << "mx: Invalid texture size while saving PNG.\n";
            return false;
        }
 
        const int width = static_cast<int>(width_f);
        const int height = static_cast<int>(height_f);
        if (width <= 0 || height <= 0) {
            std::cerr << "mx: Invalid integer texture size while saving PNG.\n";
            return false;
        }
 
        SDL_Texture *previous_target = SDL_GetRenderTarget(renderer);
        if (!SDL_SetRenderTarget(renderer, texture)) {
            std::cerr << "mx: Failed to set render target: " << SDL_GetError() << "\n";
            return false;
        }
 
        SDL_Surface *captured = SDL_RenderReadPixels(renderer, nullptr);
 
        if (!SDL_SetRenderTarget(renderer, previous_target)) {
            std::cerr << "mx: Failed to restore render target: " << SDL_GetError() << "\n";
        }
 
        if (captured == nullptr) {
            std::cerr << "mx: Failed to read pixels from renderer: " << SDL_GetError() << "\n";
            return false;
        }
 
        std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)> captured_surface(captured, &SDL_DestroySurface);
 
        SDL_Surface *rgba32_surface_raw = captured_surface.get();
        std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)> converted_surface(nullptr, &SDL_DestroySurface);
        if (captured_surface->format != SDL_PIXELFORMAT_RGBA32) {
            rgba32_surface_raw = SDL_ConvertSurface(captured_surface.get(), SDL_PIXELFORMAT_RGBA32);
            if (rgba32_surface_raw == nullptr) {
                std::cerr << "mx: Failed to convert surface to RGBA32: " << SDL_GetError() << "\n";
                return false;
            }
            converted_surface.reset(rgba32_surface_raw);
        }
 
        const auto *pixels = static_cast<const std::uint8_t *>(rgba32_surface_raw->pixels);
        return WriteRgbaPng(filename,
                            pixels,
                            rgba32_surface_raw->w,
                            rgba32_surface_raw->h,
                            rgba32_surface_raw->pitch,
                            8,
                            false);
    }

◆ SavePNG_RGBA()

bool mxvk::SavePNG_RGBA	(	const char *	filename,
		void *	buffer,
		int	w,
		int	h )

Save a raw RGBA pixel buffer to a PNG file.

Parameters

filename	Destination file path.
buffer	Pointer to the raw RGBA pixel data.
w	Image width in pixels.
h	Image height in pixels.

Returns: true on success, false on failure.

Definition at line 300 of file mxvk_png.cpp.

                                                                        {
        const int pitch = w * 4;
        return WriteRgbaPng(filename,
                            static_cast<const std::uint8_t *>(buffer),
                            w,
                            h,
                            pitch,
                            8,
                            false);
    }

◆ SavePNG_RGBA16()

bool mxvk::SavePNG_RGBA16	(	const char *	filename,
		const void *	buffer,
		int	w,
		int	h )

Save a raw 16-bit RGBA pixel buffer to a PNG file.

Parameters

filename	Destination file path.
buffer	Pointer to the raw 16-bit RGBA pixel data.
w	Image width in pixels.
h	Image height in pixels.

Returns: true on success, false on failure.

Definition at line 311 of file mxvk_png.cpp.

                                                                                {
        const int pitch = w * 8;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
        constexpr bool swap_16bit_endianness = true;
#else
        constexpr bool swap_16bit_endianness = false;
#endif
        return WriteRgbaPng(filename,
                            static_cast<const std::uint8_t *>(buffer),
                            w,
                            h,
                            pitch,
                            16,
                            swap_16bit_endianness);
    }

◆ SaveRawBytes()

bool mxvk::SaveRawBytes	(	const char *	filename,
		const void *	buffer,
		size_t	w,
		size_t	h,
		size_t	bpp )

Save raw data to a file.

Parameters

filename	Output file path
buffer	Pointer to the source data (read-only)
w	Width of the image in pixels
h	Height of the image in pixels
bpp	Bytes per pixel (e.g., 2 for YUYV, 4 for RGBA)

Returns: true on success, false on failure.

Definition at line 265 of file mxvk_png.cpp.

                                                                                                {
        if (filename == nullptr || buffer == nullptr || bpp == 0U) {
            std::cerr << "mx: Invalid SaveRawBytes parameters.\n";
            return false;
        }
 
        if (w != 0U && h > (std::numeric_limits<size_t>::max() / w)) {
            std::cerr << "mx: Raw byte size overflow while writing: " << filename << "\n";
            return false;
        }
 
        const size_t pixels = w * h;
        if (pixels != 0U && bpp > (std::numeric_limits<size_t>::max() / pixels)) {
            std::cerr << "mx: Raw byte size overflow while writing: " << filename << "\n";
            return false;
        }
 
        const size_t size = pixels * bpp;
        FILE *fptr = std::fopen(filename, "wb");
        if (fptr == nullptr) {
            std::cerr << "mx: Failed to open output file: " << filename << "\n";
            return false;
        }
 
        const size_t written = std::fwrite(buffer, sizeof(unsigned char), size, fptr);
        if (written != size) {
            std::cerr << "mx: Error writing frame: " << filename << "\n";
            std::fclose(fptr);
            return false;
        }
 
        std::fclose(fptr);
        return true;
    }

◆ setDefaultEnableScreenshot()

void mxvk::setDefaultEnableScreenshot ( bool enabled )

inline

Definition at line 11 of file mxvk_runtime_options.hpp.

                                                         {
        defaultEnableScreenshotStorage() = enabled;
    }

◆ setDefaultExecutableName()

void mxvk::setDefaultExecutableName ( const std::string & name )

inline

Definition at line 24 of file mxvk_runtime_options.hpp.

                                                                {
        defaultExecutableNameStorage() = name.empty() ? "mxvk" : name;
    }

◆ shade_color()

MXCOLOR mxvk::shade_color	(	MXCOLOR	color,
		float	intensity )

inlinenodiscard

Scale the RGB channels of a color while preserving alpha.

Parameters

color	Packed ARGB color to shade.
intensity	Multiplier clamped to the range [0, 1].

Returns: Shaded packed ARGB color.

Definition at line 79 of file mxvk_math.h.

                                                                             {
        intensity = std::clamp(intensity, 0.0f, 1.0f);
        const auto scale = [intensity](std::uint8_t component) {
            return static_cast<int>(std::clamp(static_cast<float>(component) * intensity, 0.0f, 255.0f));
        };
        return (static_cast<MXCOLOR>(color_a(color)) << 24u) |
               ((static_cast<MXCOLOR>(scale(color_r(color))) & 0xFFu) << 16u) |
               ((static_cast<MXCOLOR>(scale(color_g(color))) & 0xFFu) << 8u) |
               (static_cast<MXCOLOR>(scale(color_b(color))) & 0xFFu);
    }

◆ transition_image_layout()

void mxvk::transition_image_layout	(	VkCommandBuffer	command_buffer,
		VkImage	image,
		VkImageLayout	old_layout,
		VkImageLayout	new_layout,
		VkImageAspectFlags	aspect = VK_IMAGE_ASPECT_COLOR_BIT )

Record a Vulkan 1.3 synchronization2 image layout transition.

Parameters

command_buffer	Command buffer in recording state.
image	Image to transition.
old_layout	Current image layout.
new_layout	Desired image layout.
aspect	Image aspect mask.

Supported transitions are:

VK_IMAGE_LAYOUT_UNDEFINED to VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Exceptions

mxvk::Exception for unsupported transitions.

Definition at line 307 of file mxvk_resource.cpp.

                                                            {
        VkImageMemoryBarrier2 barrier{};
        barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
        barrier.oldLayout = old_layout;
        barrier.newLayout = new_layout;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.image = image;
        barrier.subresourceRange.aspectMask = aspect;
        barrier.subresourceRange.baseMipLevel = 0;
        barrier.subresourceRange.levelCount = 1;
        barrier.subresourceRange.baseArrayLayer = 0;
        barrier.subresourceRange.layerCount = 1;
 
        // MXVK requires Vulkan 1.3 synchronization2, so uploads use stage/access2 masks.
        if (old_layout == VK_IMAGE_LAYOUT_UNDEFINED && new_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
            barrier.srcStageMask = VK_PIPELINE_STAGE_2_NONE;
            barrier.srcAccessMask = VK_ACCESS_2_NONE;
            barrier.dstStageMask = VK_PIPELINE_STAGE_2_COPY_BIT;
            barrier.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        } else if (old_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && new_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
            barrier.srcStageMask = VK_PIPELINE_STAGE_2_COPY_BIT;
            barrier.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
            barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
            barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
        } else {
            throw mxvk::Exception("unsupported image layout transition");
        }
 
        VkDependencyInfo dependency{};
        dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
        dependency.imageMemoryBarrierCount = 1;
        dependency.pImageMemoryBarriers = &barrier;
        vkCmdPipelineBarrier2(command_buffer, &dependency);
    }

◆ unmap_buffer()

void mxvk::unmap_buffer	(	VkDevice	device,
		BufferResource &	buffer )

Unmap a BufferResource if it is currently mapped.

Parameters

device	Logical device that owns the buffer memory.
buffer	Buffer resource to unmap.

Definition at line 135 of file mxvk_resource.cpp.

                                                               {
        if (device != VK_NULL_HANDLE && buffer.memory != VK_NULL_HANDLE && buffer.mapped != nullptr) {
            vkUnmapMemory(device, buffer.memory);
        }
        buffer.mapped = nullptr;
    }

◆ WriteRgbaPng()

bool mxvk::WriteRgbaPng	(	const char *	filename,
		const std::uint8_t *	pixels,
		const int	width,
		const int	height,
		const int	pitch,
		const int	bit_depth,
		const bool	swap_16bit_endianness )

nodiscard

Definition at line 33 of file mxvk_png.cpp.

                                                                      {
        if (filename == nullptr || pixels == nullptr || width <= 0 || height <= 0 || pitch <= 0) {
            std::cerr << "mx: Invalid PNG write parameters.\n";
            return false;
        }
 
        FILE *file = std::fopen(filename, "wb");
        if (file == nullptr) {
            std::cerr << "mx: Failed to open file for writing: " << filename << "\n";
            return false;
        }
 
        png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
        if (png == nullptr) {
            std::cerr << "mx: Failed to create PNG write struct.\n";
            std::fclose(file);
            return false;
        }
 
        png_infop info = png_create_info_struct(png);
        if (info == nullptr) {
            std::cerr << "mx: Failed to create PNG info struct.\n";
            png_destroy_write_struct(&png, nullptr);
            std::fclose(file);
            return false;
        }
 
        if (setjmp(png_jmpbuf(png))) {
            std::cerr << "mx: Error during PNG creation.\n";
            png_destroy_write_struct(&png, &info);
            std::fclose(file);
            return false;
        }
 
        png_init_io(png, file);
        png_set_IHDR(png,
                     info,
                     width,
                     height,
                     bit_depth,
                     PNG_COLOR_TYPE_RGBA,
                     PNG_INTERLACE_NONE,
                     PNG_COMPRESSION_TYPE_DEFAULT,
                     PNG_FILTER_TYPE_DEFAULT);
 
        if (bit_depth == 16 && swap_16bit_endianness) {
            png_set_swap(png);
        }
 
        png_write_info(png, info);
 
        std::vector<png_bytep> rows(static_cast<std::size_t>(height));
        for (int y = 0; y < height; ++y) {
            rows[static_cast<std::size_t>(y)] = const_cast<png_bytep>(pixels + (y * pitch));
        }
 
        png_write_image(png, rows.data());
        png_write_end(png, nullptr);
 
        png_destroy_write_struct(&png, &info);
        std::fclose(file);
        return true;
    }

Variable Documentation

◆ cos_look

std::array< float, 361 > mxvk::cos_look = build_cos_table()

inline

Cosine lookup table with one entry per degree from 0 through 360.

Definition at line 110 of file mxvk_math.h.

◆ EPSILON

float mxvk::EPSILON = 1.0e-5f

inlineconstexpr

Default tolerance used for floating-point singularity and zero-length checks.

Definition at line 37 of file mxvk_math.h.

◆ PI

float mxvk::PI = 3.14159265358979323846f

inlineconstexpr

Mathematical constant pi as a single-precision value.

Definition at line 34 of file mxvk_math.h.

◆ sin_look

std::array< float, 361 > mxvk::sin_look = build_sin_table()

inline

Sine lookup table with one entry per degree from 0 through 360.

Definition at line 107 of file mxvk_math.h.

MXVK Vulkan Framework 0.24.0 C++20 Vulkan rendering framework for practical 2D and 3D application development with SDL3.

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ ConfigFile

◆ Console

◆ Controller

◆ Item

◆ Joystick

◆ Mixer

◆ MXCOLOR

◆ VK_AbstractModel

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ begin_one_time_commands()

◆ build_cos_table()

◆ build_sin_table()

◆ BuildTables()

◆ color_a()

◆ color_b()

◆ color_g()

◆ color_r()

◆ copy_buffer()

◆ copy_buffer_to_image()

◆ create_buffer()

◆ create_image()

◆ create_image_view()

◆ create_shader_module()

◆ create_texture_from_png()

◆ create_texture_from_surface()

◆ defaultEnableScreenshot()

◆ defaultEnableScreenshotStorage()

◆ defaultExecutableName()

◆ defaultExecutableNameStorage()

◆ deg2rad()

◆ destroy_buffer()

◆ destroy_texture()

◆ draw_filled_triangle() [1/3]

◆ draw_filled_triangle() [2/3]

◆ draw_filled_triangle() [3/3]

◆ draw_filled_triangle_spans()

◆ draw_filled_triangle_spans_clipped()

◆ draw_line() [1/3]

◆ draw_line() [2/3]

◆ draw_line() [3/3]

◆ edge_function()

◆ end_one_time_commands()

◆ fast_cosf()

◆ fast_sinf()

◆ find_memory_type()

◆ HasPngExtension()

◆ load_spv()

◆ LoadPNG()

◆ map_buffer()

◆ MXVK_RGB()

◆ operator<<() [1/3]

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ operator>>() [1/3]

◆ operator>>() [2/3]

◆ operator>>() [3/3]

◆ rad2deg()

◆ rrand()

◆ SavePNG()

◆ SavePNG_RGBA()

◆ SavePNG_RGBA16()

◆ SaveRawBytes()

◆ setDefaultEnableScreenshot()

◆ setDefaultExecutableName()

◆ shade_color()

◆ transition_image_layout()

◆ unmap_buffer()

◆ WriteRgbaPng()