Namespaces
namespace	anonymous_namespace{tests.h}

namespace	detail

namespace	literals

namespace	lua

namespace	term

Classes
struct	AABBCollider

struct	AdHocTimer

class	alloc_block
	Non-owning handle to an aggregate header and data block. More...

struct	allocator_base
	Base class for allocators, implements a few basic operations. More...

struct	allocator_opts
	Configuration object for allocator_base. More...

struct	always_false

struct	Animation

class	AnimationFunction

class	Animations

struct	ANSIEscapeCode
	ANSI escape code sequences. More...

class	Audio
	Audio manager. More...

class	AudioWidget

class	AudioWorker

struct	BBCollider

class	BindingGroup

class	Buffer

struct	Camera
	Abstract orthographic/perspective camera. More...

struct	CameraUBO

struct	Collider

struct	Colliders

struct	Collision

struct	CollisionStats

class	CommandPool

class	ComponentButton

class	Components

struct	Compute
	Base class for computation back ends, which may be hardware-accelerated. More...

struct	constant
	Function object which always produces the same value. More...

struct	CubeRenderer

class	DedicatedBuffer

class	delegate
	Static container for a callable and its arguments. More...

class	delegate_fn
	Unique type for a function or member function pointer. More...

class	DescriptorPool

class	DescriptorSets

class	Device
	Owning wrapper for a VkDevice. More...

struct	DeviceInfo
	Aggregate type for information about a physical device. More...

class	DeviceMemory
	Manages device memory queries, allocations, and lifetime. More...

struct	DeviceMemoryInfo
	Aggregate type for information about a device's memory heaps. More...

class	Edit

struct	fixed_string

struct	Flags
	Wrapper for a small unsigned integral representing flags. More...

class	FlowGridLayout
	Resizable `QGridLayout` composed of uniform, fixed-size widgets. More...

struct	Font

class	Fonts

struct	FPS

class	FrameLimiter
	Simulates a v-sync pause using `sleep`. More...

struct	Gen

class	Generator

struct	GLBuffer

struct	GLDebugGroup
	RAII-based debug group manager. More...

struct	GLFrameBuffer

class	GLFWBackend

class	GLPost
	Post-processing operations. More...

struct	GLProgram

struct	GLShader

struct	GLTexArray

struct	Graphics

struct	GraphicsStats

struct	GravityCollider

class	Grid

struct	Handle
	Base class for strongly-typed handles in 32-bit platforms. More...

struct	Image

class	Input
	Dispatches keyboard input events to pre-registered Lua functions. More...

class	Instance
	Owning wrapper for a Vulkan instance. More...

struct	InstanceInfo
	Aggregate type for information about an instance. More...

struct	Light

class	LightAnimation

class	Lighting

struct	LightsUBO

class	Log

class	lua_vector
	Type used to get/push vectors as user data in Lua. More...

class	LuaSyntaxHighlighter

class	Map

struct	mat

struct	mat3_base

struct	mat4_base

class	Math

struct	mem_obj

struct	member_less

struct	member_obj_type
	Type associated with a member object/function pointer. More...

struct	member_obj_type< O(T::*)>

struct	member_obj_type< R(T::*)(Args...)>

class	MouseInput
	Mouse event manager. More...

class	OpenGLHandle

class	owning_view

class	PCMWidget

struct	PlaneCollider

struct	Platform

class	pointer_flag

struct	Profile

struct	ProfileStats

struct	Pseudograph

struct	range_to

struct	reallocator
	Simple allocator which supports reallocation. More...

struct	Renderer

class	Renderers
	Rendering subsystem. More...

class	Schedule
	Executor of deferred and recurrent tasks. More...

class	scoped

class	Socket

class	SourceEditor

struct	SphereCollider

class	SpriteAnimation

struct	SpriteRenderer

class	StagingBuffer
	Manages staging buffers for a group of frames. More...

class	static_vector
	Fixed-size vector with an embedded free list. More...

class	Stats

struct	StatsBase

class	Sun

struct	SurfaceInfo
	Aggregate type for information about a surface. More...

class	SwapChain
	Presentation swap chain and associated objects. More...

class	tagging_allocator
	Generic implementation of a `malloc(3)`-style allocator with headers. More...

class	Terminal
	Handles interactions with the output terminal. More...

struct	Text

class	Textbox

class	Textures
	Texture manager, loads and caches image data from files/buffers. More...

struct	Timing

struct	to
	Function object which converts its argument to T via `static_cast`. More...

class	tracking_allocator
	Allocator which tracks the amount of memory allocated. More...

struct	VAO

struct	vec

struct	vec2_base

struct	vec3_base

struct	vec4_base

struct	vec_type

struct	vec_type< T, 2 >

struct	vec_type< T, 3 >

struct	vec_type< T, 4 >

struct	Vertex

struct	VoxelRenderer

struct	VT100EscapeCode
	Character sequences to control a VT100 terminal. More...

struct	VT520EscapeCode
	Character sequences to control a VT520 terminal. More...

class	WAV
	A non-owning wrapper for a byte buffer containing a WAV file. More...

Concepts
concept	VkNamedRange

concept	vector

concept	tagging_descriptor
	Associates a block type with an allocator.

concept	alloc_tracker
	Describes how allocations of a particular type are tracked.

concept	trivial

concept	standard_layout

concept	derived_from

concept	convertible_to_strict
	As `std::convertible_to`, but excluding implicit conversions.

concept	integral

concept	unsigned_integral

concept	arithmetic

concept	char_type

concept	byte_type

concept	pointer

concept	byte_pointer

concept	member_pointer

concept	function

concept	c_function_pointer

concept	member_function_pointer

concept	function_pointer

concept	lvalue_ref

concept	rvalue_ref

concept	enum_

concept	c_enum

concept	scoped_enum

concept	stateless_lambda

concept	type_list

Typedefs
using	MemoryAllocation = std::uint64_t

template<typename T >
using	vk_create_info_type
	Maps types to *CretaeInfo structures.

using	Hash = std::size_t

using	imat3 = mat3_base<int32_t>

using	umat3 = mat3_base<uint32_t>

using	mat3 = mat3_base<float>

using	dmat3 = mat3_base<double>

using	imat4 = mat4_base<int32_t>

using	umat4 = mat4_base<uint32_t>

using	mat4 = mat4_base<float>

using	dmat4 = mat4_base<double>

template<typename T , std::size_t N>
using	vec_type_t = typename vec_type<T, N>::type

template<typename T >
using	vector_type = typename T::type

using	ivec2 = vec2_base<std::int32_t>

using	uvec2 = vec2_base<std::uint32_t>

using	zvec2 = vec2_base<std::size_t>

using	vec2 = vec2_base<float>

using	dvec2 = vec2_base<double>

using	ivec3 = vec3_base<std::int32_t>

using	uvec3 = vec3_base<std::uint32_t>

using	zvec3 = vec3_base<std::size_t>

using	vec3 = vec3_base<float>

using	dvec3 = vec3_base<double>

using	ivec4 = vec4_base<std::int32_t>

using	uvec4 = vec4_base<std::uint32_t>

using	zvec4 = vec4_base<std::size_t>

using	vec4 = vec4_base<float>

using	dvec4 = vec4_base<double>

template<typename T >
using	stateless_allocator = allocator_base<T, allocator_opts{.is_always_equal = true}>
	Base class for allocators that have no state.

template<typename T >
using	stateful_allocator = allocator_base<T, allocator_opts{.is_always_equal = false}>
	Base class for allocators that have state.

using	i8 = std::int8_t

using	i16 = std::int16_t

using	i32 = std::int32_t

using	i64 = std::int64_t

using	u8 = std::uint8_t

using	u16 = std::uint16_t

using	u32 = std::uint32_t

using	u64 = std::uint64_t

template<auto f>
using	fn_args = typename detail::fn_args< >::type

template<typename ... Ts>
using	types = detail::types_impl<Ts...>

template<typename T >
using	member_obj_type_t = typename member_obj_type<T>::type

Enumerations
enum class	empty

Functions
template<typename T >
static T::pointer	add (T *v, typename T::const_reference c)

template<Compute::Backend >
std::unique_ptr< Compute >	compute_create_backend (const void *params)

template<>
std::unique_ptr< Compute >	compute_create_backend< backend > (const void *params)

template<>
std::unique_ptr< Compute >	compute_create_backend< Compute::Backend::PSEUDOCOMP > (const void *params)

template<template< typename > typename V, typename T , std::size_t N>
std::ostream &	operator<< (std::ostream &os, const vec< V, T, N > &v)

std::ostream &	operator<< (std::ostream &os, const mat4 &m)

std::ostream &	operator<< (std::ostream &os, const Vertex &v)

std::ostream &	operator<< (std::ostream &os, const mat3 &m)

template<Graphics::Backend >
std::unique_ptr< Graphics >	graphics_create_backend (const void *params)

template<>
std::unique_ptr< Graphics >	graphics_create_backend< backend > (const void *params)

template<>
std::unique_ptr< Graphics >	graphics_create_backend< backend_es > (const void *params)

const char *	gl_strerror (GLenum error)

const char *	gl_enum_str (GLenum e)

bool	gl_check_result (const char *func_name)

bool	gl_set_obj_name (GLenum type, GLuint obj, std::string_view name)

template<>
std::unique_ptr< Graphics >	graphics_create_backend< Backend > (const void *params)

template<>
std::unique_ptr< Graphics >	graphics_create_backend< backend > (const void *params)

	NNGN_APPLY2 (C, VkBuffer, BUFFER) NNGN_IGNORE2(C

COMMAND_BUFFER	NNGN_APPLY2 (C, VkCommandPool, COMMAND_POOL) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL	NNGN_IGNORE2 (C, VkDescriptorSet, DESCRIPTOR_SET) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT	NNGN_IGNORE2 (C, VkDeviceMemory, DEVICE_MEMORY) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE	NNGN_APPLY2 (C, VkFramebuffer, FRAMEBUFFER) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE	NNGN_APPLY2 (C, VkImageView, IMAGE_VIEW) NNGN_IGNORE2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE	NNGN_IGNORE2 (C, VkQueue, QUEUE) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE	NNGN_APPLY2 (C, VkPipelineLayout, PIPELINE_LAYOUT) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS	NNGN_APPLY2 (C, VkSampler, SAMPLER) NNGN_APPLY2(C

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE	NNGN_APPLY2 (C, VkShaderModule, SHADER_MODULE) template<> inline const expr auto vk_obj_type< VkBuffer >

const char *	vk_strerror (VkResult result)

const char *	vk_enum_str (VkDebugUtilsMessageSeverityFlagBitsEXT f)

std::string	vk_version_str (Graphics::Version v)

std::string	vk_version_str (std::uint32_t v)
	Unpacks a Vulkan version number into a character array.

Graphics::Version	vk_parse_version (std::uint32_t v)
	Unpacks a Vulkan version number.

const char *	vk_enum_str (VkDebugUtilsMessageTypeFlagsEXT f)

std::vector< Graphics::Extension >	vk_parse_extensions (std::span< const VkExtensionProperties > s)
	Populates Graphics::Extension objects from their Vulkan equivalents.

Graphics::PresentMode	vk_present_mode (VkPresentModeKHR m)
	Populates a Graphics::PresentMode from its Vulkan equivalent.

template<typename T >
vk_create_info_type< T >	vk_create_info (vk_create_info_type< T > info)

nngn::uvec2	vk_extent_to_vec (VkExtent2D e)

VkExtent2D	vk_vec_to_extent (nngn::uvec2 v)

bool	vk_check_result (const char *func, VkResult r)
	Checks that `r` is `VK_SUCCESS` or emits a log message.

template<c_function_pointer auto f>
auto	vk_enumerate (const auto &...args)
	Creates a vector from the result of calling `f` with `args`.

template<typename T , auto ... Ps>
constexpr auto	vk_vertex_input (std::span< const VkVertexInputBindingDescription > bindings)

std::vector< const char * >	vk_names (const VkNamedRange auto &r)
	Extracts the `name` character array from common objects.

template<standard_layout T, auto ... Ps>
auto	vk_vertex_attrs ()

constexpr VkPipelineVertexInputStateCreateInfo	vk_vertex_input (std::span< const VkVertexInputBindingDescription > bindings, std::span< const VkVertexInputAttributeDescription > attrs)

template<>
std::unique_ptr< Graphics >	graphics_create_backend< Backend > (const void *params)

std::unique_ptr< Input::Source >	input_graphics_source (Graphics *g)

std::unique_ptr< Input::Source >	input_terminal_source (int fd, Input::TerminalFlag flags)

Hash	hash (std::span< const char > s)

template<template< typename > typename CRTP, typename T , std::size_t N>
constexpr bool	operator== (const mat< CRTP, T, N > &m0, const mat< CRTP, T, N > &m1)

template<template< typename > typename CRTP, typename T , std::size_t N>
constexpr CRTP< T >	operator* (T s, const mat< CRTP, T, N > &m)

template<template< typename > typename CRTP, typename T , std::size_t N>
constexpr CRTP< T >	operator* (const mat< CRTP, T, N > &m0, const mat< CRTP, T, N > &m1)

template<template< typename > typename CRTP, typename T , std::size_t N>
constexpr vec_type_t< T, N >	operator* (const mat< CRTP, T, N > &m, const vec_type_t< T, N > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr const R *	begin (const T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr const R *	end (const T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr R *	begin (T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr R *	end (T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr bool	operator== (const T< R > &v0, const T< R > &v1)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr bool	operator!= (const T< R > &v0, const T< R > &v1)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator+ (R s, const T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator- (R s, const T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator* (R s, const T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator/ (R s, const T< R > &v)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator+ (const T< R > &v, R s)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator- (const T< R > &v, R s)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator* (const T< R > &v, R s)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator/ (const T< R > &v, R s)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator+ (const T< R > &v0, const T< R > &v1)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator- (const T< R > &v0, const T< R > &v1)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator* (const T< R > &v0, const T< R > &v1)

template<template< typename > typename T, typename R > requires vector<T, R>
constexpr T< R >	operator/ (const T< R > &v0, const T< R > &v1)

static void	end_step (AdHocTimer::Step s, Timing::time_point last)

template<typename D >
static auto	now (const Timing &t)

template<typename D >
static auto	fnow (const Timing &t)

template<typename D >
static auto	dt (const Timing &t)

template<typename D >
static auto	fdt (const Timing &t)

template<typename T , allocator_opts o>
bool	operator== (const allocator_base< T, o > &, const allocator_base< T, o > &)

template<typename T , allocator_opts o>
bool	operator!= (const allocator_base< T, o > &, const allocator_base< T, o > &)

template<std::size_t N>
	fixed_string (const char(&)[N]) -> fixed_string< N - 1 >

template<std::ranges::sized_range ... Rs>
constexpr auto	cat (const Rs &...rs)
	Concatenates multiple fixed_string objects into a character array.

template<typename T >
constexpr Flags< T >	operator& (Flags< T > lhs, Flags< T > rhs)

template<typename T >
constexpr Flags< T >	operator\| (Flags< T > lhs, Flags< T > rhs)

template<typename T >
constexpr Flags< T >	operator^ (Flags< T > lhs, Flags< T > rhs)

std::ostream &	operator<< (std::ostream &os, Log::record r)

constexpr auto *	data_end (std::ranges::contiguous_range auto &&r)

template<typename T >
void	resize_and_init (T *p, std::size_t n, auto &&f)

template<typename V >
void	set_capacity (V *v, size_t n)

template<std::size_t N>
consteval auto	to_array (const char *s)

template<std::size_t N>
consteval auto	to_array (const char(&s)[N])

template<std::size_t N>
consteval auto	to_array (const std::ranges::contiguous_range auto &r)

template<std::size_t N, std::ranges::view V>
consteval auto	to_array (V &&v)

constexpr bool	contains (const std::ranges::contiguous_range auto &r, const auto &x)

constexpr bool	in_range (const std::ranges::contiguous_range auto &r, const auto &x)

template<std::ranges::forward_range R, typename Proj = std::identity>
constexpr bool	is_sequence (R &&r, Proj proj={})

template<std::ranges::range R>
constexpr void	iota (R &&r, std::ranges::range_value_t< R > &&x={})

constexpr auto	reduce (std::ranges::range auto &&r)

constexpr auto	reduce (std::ranges::range auto &&r, auto &&init={}, auto &&op=std::plus<>{})

void	const_time_erase (auto v, auto p)

template<std::input_iterator I, std::output_iterator< std::iter_value_t< I > > O>
constexpr void	fill_with_pattern (I f, I l, O df, O dl)

constexpr void	fill_with_pattern (std::ranges::range auto &&p, std::ranges::range auto &&r)

template<typename T >
constexpr T *	memcpy (T *dst, std::ranges::contiguous_range auto &&r)

template<typename T >
constexpr T *	memmove (T *dst, std::ranges::contiguous_range auto &&r)

std::string	regexp_replace (std::string &&s, const std::regex &r, const char *fmt)

std::string	regexp_replace (std::string_view s, const std::regex &r, const char *fmt)

template<typename F , typename ... Ts>
auto	make_scoped (F &&f, Ts &&...ts)

template<typename T , typename F , typename ... Ts>
auto	make_scoped_obj (T &&t, F &&f, Ts &&...ts)

template<typename T >
std::span< T >	slice (std::span< T > s, auto b, auto e)

template<typename T >
auto	split (std::span< T > s, std::size_t i)

auto	split (std::string_view s, std::string_view::iterator i)

std::string	fmt (auto &&...args)

template<typename T >
auto	tuple_tail (T &&t)

bool	read_file (std::string_view filename, std::string *ret)

bool	read_file (std::string_view filename, std::vector< std::byte > *ret)

template<typename ... Ts>
constexpr	chain_cast (auto &&x)
	Performs successive `static_cast`s, right to left.

template<typename To , typename From >
To	narrow (const From &x)
	Casts `x` to a narrower type, asserting that the value is preserved.

template<typename T , typename U >
constexpr	cast (U &&x)
	Cast value to `T` with the strictest cast operator.

template<typename To , typename From > requires byte_pointer<To> \|\| byte_pointer<From>
constexpr To	byte_cast (From p)
	`reinterpret_cast` restricted to conversions from/to `char`/`uchar`.

template<typename To , typename From > requires byte_type<To> \|\| char_type<To> \|\| byte_type<From> \|\| char_type<From>
std::span< To >	byte_cast (std::span< From > s)
	Cast between `span`s where one is a byte type.

template<enum_ T>
constexpr auto	to_underlying (T t)

constexpr auto	ptr_diff (const auto lhs, const auto rhs)
	Signed distance in bytes between pointers.

constexpr bool	ptr_cmp (const auto p0, const auto p1)
	Compares the address of two pointers.

template<standard_layout T>
std::size_t	offsetof_ptr (auto T::*p)
	Similar to the stdlib's `offsetof`, but using member data pointers.

auto	as_bytes (const void *p)

auto	as_bytes (void *p)

std::span< const std::byte >	as_byte_span (const auto *x)

std::span< std::byte >	as_byte_span (auto *x)

constexpr bool	str_less (const char lhs, const char rhs)

template<typename To , typename From > requires ( sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<To> && std::is_trivially_copyable_v<From>)
constexpr auto	bit_cast (const From &from)

template<typename T >
constexpr auto	set_bit (T t, T mask, bool value)

constexpr	rptr (auto &&r)
	Allows passing an rvalue pointer to a function.

bool	operator== (const Vertex &l, const Vertex &r)

template<typename T >
char *	toString (const vec2_base< T > &t)

template<typename T >
char *	toString (const vec3_base< T > &t)

template<typename T >
char *	toString (const vec4_base< T > &t)

char *	toString (const mat3 &t)

char *	toString (const mat4 &t)

char *	toString (const Vertex &t)

std::string	str (const static_vector< S > &v)

QString	qstring_from_view (std::string_view v)

Variables
template<typename T >
using	const_iterator

template<typename T >
static constexpr Compute::Type	arg_type = Compute::Type::NONE

template<typename T >
constexpr empty	vk_struct_type = {}
	Maps types to VkStructureType values.

template<typename T >
constexpr empty	vk_obj_type = {}
	Maps types to VkObjectType values.

	VkCommandBuffer

COMMAND_BUFFER	VkDescriptorPool

COMMAND_BUFFER DESCRIPTOR_POOL	VkDescriptorSetLayout

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT	VkFence

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE	VkImage

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE	VkPipeline

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE	VkPipelineCache

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE	VkRenderPass

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS	VkSemaphore

template<>
constexpr auto	vk_obj_type< VkCommandBuffer > = VK_OBJECT_TYPE_COMMAND_BUFFER

template<>
constexpr auto	vk_obj_type< VkCommandPool > = VK_OBJECT_TYPE_COMMAND_POOL

template<>
constexpr auto	vk_obj_type< VkDescriptorPool > = VK_OBJECT_TYPE_DESCRIPTOR_POOL

template<>
constexpr auto	vk_obj_type< VkDescriptorSet > = VK_OBJECT_TYPE_DESCRIPTOR_SET

template<>
constexpr auto	vk_obj_type< VkDescriptorSetLayout > = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT

template<>
constexpr auto	vk_obj_type< VkDeviceMemory > = VK_OBJECT_TYPE_DEVICE_MEMORY

template<>
constexpr auto	vk_obj_type< VkFence > = VK_OBJECT_TYPE_FENCE

template<>
constexpr auto	vk_obj_type< VkFramebuffer > = VK_OBJECT_TYPE_FRAMEBUFFER

template<>
constexpr auto	vk_obj_type< VkImage > = VK_OBJECT_TYPE_IMAGE

template<>
constexpr auto	vk_obj_type< VkImageView > = VK_OBJECT_TYPE_IMAGE_VIEW

template<>
constexpr auto	vk_obj_type< VkPipeline > = VK_OBJECT_TYPE_PIPELINE

template<>
constexpr auto	vk_obj_type< VkQueue > = VK_OBJECT_TYPE_QUEUE

template<>
constexpr auto	vk_obj_type< VkPipelineCache > = VK_OBJECT_TYPE_PIPELINE_CACHE

template<>
constexpr auto	vk_obj_type< VkPipelineLayout > = VK_OBJECT_TYPE_PIPELINE_LAYOUT

template<>
constexpr auto	vk_obj_type< VkRenderPass > = VK_OBJECT_TYPE_RENDER_PASS

template<>
constexpr auto	vk_obj_type< VkSampler > = VK_OBJECT_TYPE_SAMPLER

template<>
constexpr auto	vk_obj_type< VkSemaphore > = VK_OBJECT_TYPE_SEMAPHORE

template<>
constexpr auto	vk_obj_type< VkShaderModule > = VK_OBJECT_TYPE_SHADER_MODULE

Typedef Documentation

◆ dmat3

using nngn::dmat3 = mat3_base<double>

◆ dmat4

using nngn::dmat4 = mat4_base<double>

◆ dvec2

using nngn::dvec2 = vec2_base<double>

◆ dvec3

using nngn::dvec3 = vec3_base<double>

◆ dvec4

using nngn::dvec4 = vec4_base<double>

◆ fn_args

template<auto f>

using nngn::fn_args = typename detail::fn_args< >::type

◆ Hash

using nngn::Hash = std::size_t

◆ i16

using nngn::i16 = std::int16_t

◆ i32

using nngn::i32 = std::int32_t

◆ i64

using nngn::i64 = std::int64_t

◆ i8

using nngn::i8 = std::int8_t

◆ imat3

using nngn::imat3 = mat3_base<int32_t>

◆ imat4

using nngn::imat4 = mat4_base<int32_t>

◆ ivec2

using nngn::ivec2 = vec2_base<std::int32_t>

◆ ivec3

using nngn::ivec3 = vec3_base<std::int32_t>

◆ ivec4

using nngn::ivec4 = vec4_base<std::int32_t>

◆ mat3

using nngn::mat3 = mat3_base<float>

◆ mat4

using nngn::mat4 = mat4_base<float>

◆ member_obj_type_t

template<typename T >

using nngn::member_obj_type_t = typename member_obj_type<T>::type

See also: member_obj_type

◆ MemoryAllocation

using nngn::MemoryAllocation = std::uint64_t

◆ stateful_allocator

template<typename T >

using nngn::stateful_allocator = allocator_base<T, allocator_opts{.is_always_equal = false}>

Base class for allocators that have state.

Automatically implements an equality operator which always returns false.

◆ stateless_allocator

template<typename T >

using nngn::stateless_allocator = allocator_base<T, allocator_opts{.is_always_equal = true}>

Base class for allocators that have no state.

Automatically implements an equality operator which always returns true.

◆ types

template<typename ... Ts>

using nngn::types = detail::types_impl<Ts...>

◆ u16

using nngn::u16 = std::uint16_t

◆ u32

using nngn::u32 = std::uint32_t

◆ u64

using nngn::u64 = std::uint64_t

◆ u8

using nngn::u8 = std::uint8_t

◆ umat3

using nngn::umat3 = mat3_base<uint32_t>

◆ umat4

using nngn::umat4 = mat4_base<uint32_t>

◆ uvec2

using nngn::uvec2 = vec2_base<std::uint32_t>

◆ uvec3

using nngn::uvec3 = vec3_base<std::uint32_t>

◆ uvec4

using nngn::uvec4 = vec4_base<std::uint32_t>

◆ vec2

using nngn::vec2 = vec2_base<float>

◆ vec3

using nngn::vec3 = vec3_base<float>

◆ vec4

using nngn::vec4 = vec4_base<float>

◆ vec_type_t

template<typename T , std::size_t N>

using nngn::vec_type_t = typename vec_type<T, N>::type

◆ vector_type

template<typename T >

using nngn::vector_type = typename T::type

◆ vk_create_info_type

template<typename T >

using nngn::vk_create_info_type

Initial value:

typename detail::vk_create_info_type_impl<T>::type

Maps types to *CretaeInfo structures.

◆ zvec2

using nngn::zvec2 = vec2_base<std::size_t>

◆ zvec3

using nngn::zvec3 = vec3_base<std::size_t>

◆ zvec4

using nngn::zvec4 = vec4_base<std::size_t>

Enumeration Type Documentation

◆ empty

enum class nngn::empty

strong

Function Documentation

◆ add()

template<typename T >

static T::pointer nngn::add	(	T *	v,
		typename T::const_reference	c )

static

Here is the call graph for this function:

Here is the caller graph for this function:

◆ as_byte_span() [1/2]

std::span< std::byte > nngn::as_byte_span ( auto * x )

inline

Here is the call graph for this function:

◆ as_byte_span() [2/2]

std::span< const std::byte > nngn::as_byte_span ( const auto * x )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ as_bytes() [1/2]

auto nngn::as_bytes ( const void * p )

inline

Here is the caller graph for this function:

◆ as_bytes() [2/2]

auto nngn::as_bytes ( void * p )

inline

◆ begin() [1/2]

template<template< typename > typename T, typename R >
requires vector<T, R>

const R * nngn::begin ( const T< R > & v )

inlineconstexpr

Here is the caller graph for this function:

◆ begin() [2/2]

template<template< typename > typename T, typename R >
requires vector<T, R>

R * nngn::begin ( T< R > & v )

inlineconstexpr

◆ bit_cast()

template<typename To , typename From >
requires ( sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<To> && std::is_trivially_copyable_v<From>)

auto nngn::bit_cast ( const From & from )

constexpr

◆ byte_cast() [1/2]

template<typename To , typename From >
requires byte_pointer<To> || byte_pointer<From>

To nngn::byte_cast ( From p )

constexpr

reinterpret_cast restricted to conversions from/to char/uchar.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ byte_cast() [2/2]

template<typename To , typename From >
requires byte_type<To> || char_type<To> || byte_type<From> || char_type<From>

std::span< To > nngn::byte_cast ( std::span< From > s )

Cast between spans where one is a byte type.

Here is the call graph for this function:

◆ cast()

template<typename T , typename U >

nngn::cast ( U && x )

constexpr

Cast value to T with the strictest cast operator.

Here is the caller graph for this function:

◆ cat()

template<std::ranges::sized_range ... Rs>

auto nngn::cat ( const Rs &... rs )

constexpr

Concatenates multiple fixed_string objects into a character array.

Here is the call graph for this function:

◆ chain_cast()

template<typename ... Ts>

nngn::chain_cast ( auto && x )

constexpr

Performs successive static_casts, right to left.

Here is the caller graph for this function:

◆ compute_create_backend()

template<Compute::Backend >

std::unique_ptr< Compute > nngn::compute_create_backend ( const void * params )

◆ compute_create_backend< backend >()

template<>

std::unique_ptr< Compute > nngn::compute_create_backend< backend > ( const void * params )

◆ compute_create_backend< Compute::Backend::PSEUDOCOMP >()

template<>

std::unique_ptr< Compute > nngn::compute_create_backend< Compute::Backend::PSEUDOCOMP > ( const void * params )

◆ const_time_erase()

void nngn::const_time_erase	(	auto *	v,
		auto *	p )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contains()

bool nngn::contains	(	const std::ranges::contiguous_range auto &	r,
		const auto &	x )

constexpr

Here is the caller graph for this function:

◆ data_end()

auto * nngn::data_end ( std::ranges::contiguous_range auto && r )

constexpr

Here is the caller graph for this function:

◆ dt()

template<typename D >

static auto nngn::dt ( const Timing & t )

static

Here is the caller graph for this function:

◆ end() [1/2]

template<template< typename > typename T, typename R >
requires vector<T, R>

const R * nngn::end ( const T< R > & v )

inlineconstexpr

◆ end() [2/2]

template<template< typename > typename T, typename R >
requires vector<T, R>

R * nngn::end ( T< R > & v )

inlineconstexpr

◆ end_step()

static void nngn::end_step	(	AdHocTimer::Step *	s,
		Timing::time_point *	last )

static

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fdt()

template<typename D >

static auto nngn::fdt ( const Timing & t )

static

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_with_pattern() [1/2]

template<std::input_iterator I, std::output_iterator< std::iter_value_t< I > > O>

void nngn::fill_with_pattern	(	I	f,
		I	l,
		O	df,
		O	dl )

constexpr

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_with_pattern() [2/2]

void nngn::fill_with_pattern	(	std::ranges::range auto &&	p,
		std::ranges::range auto &&	r )

constexpr

Here is the call graph for this function:

◆ fixed_string()

template<std::size_t N>

nngn::fixed_string ( const char(&)[N] ) -> fixed_string< N - 1 >

◆ fmt()

std::string nngn::fmt ( auto &&... args )

Here is the caller graph for this function:

◆ fnow()

template<typename D >

static auto nngn::fnow ( const Timing & t )

static

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gl_check_result()

bool nngn::gl_check_result ( const char * func_name )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gl_enum_str()

const char * nngn::gl_enum_str ( GLenum e )

Here is the caller graph for this function:

◆ gl_set_obj_name()

bool nngn::gl_set_obj_name	(	GLenum	type,
		GLuint	obj,
		std::string_view	name )

inline

Here is the caller graph for this function:

◆ gl_strerror()

const char * nngn::gl_strerror ( GLenum error )

template<>

std::unique_ptr< Graphics > nngn::graphics_create_backend< backend_es > ( const void * params )

◆ hash()

Hash nngn::hash ( std::span< const char > s )

inline

Here is the caller graph for this function:

◆ in_range()

bool nngn::in_range	(	const std::ranges::contiguous_range auto &	r,
		const auto &	x )

constexpr

Here is the caller graph for this function:

◆ input_graphics_source()

std::unique_ptr< Input::Source > nngn::input_graphics_source ( Graphics * g )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ input_terminal_source()

std::unique_ptr< Input::Source > nngn::input_terminal_source	(	int	fd,
		Input::TerminalFlag	flags )

Here is the caller graph for this function:

◆ iota()

template<std::ranges::range R>

void nngn::iota	(	R &&	r,
		std::ranges::range_value_t< R > &&	x = {} )

constexpr

◆ is_sequence()

template<std::ranges::forward_range R, typename Proj = std::identity>

bool nngn::is_sequence	(	R &&	r,
		Proj	proj = {} )

constexpr

Here is the caller graph for this function:

◆ make_scoped()

template<typename F , typename ... Ts>

auto nngn::make_scoped	(	F &&	f,
		Ts &&...	ts )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_scoped_obj()

template<typename T , typename F , typename ... Ts>

auto nngn::make_scoped_obj	(	T &&	t,
		F &&	f,
		Ts &&...	ts )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ memcpy()

template<typename T >

T * nngn::memcpy	(	T *	dst,
		std::ranges::contiguous_range auto &&	r )

constexpr

Here is the call graph for this function:

Here is the caller graph for this function:

◆ memmove()

template<typename T >

T * nngn::memmove	(	T *	dst,
		std::ranges::contiguous_range auto &&	r )

constexpr

Here is the call graph for this function:

Here is the caller graph for this function:

◆ narrow()

template<typename To , typename From >

To nngn::narrow ( const From & x )

Casts x to a narrower type, asserting that the value is preserved.

Here is the caller graph for this function:

◆ NNGN_APPLY2() [1/7]

nngn::NNGN_APPLY2	(	C	,
		VkBuffer	,
		BUFFER	)

◆ NNGN_APPLY2() [2/7]

COMMAND_BUFFER nngn::NNGN_APPLY2	(	C	,
		VkCommandPool	,
		COMMAND_POOL	)

◆ NNGN_APPLY2() [3/7]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE nngn::NNGN_APPLY2	(	C	,
		VkFramebuffer	,
		FRAMEBUFFER	)

◆ NNGN_APPLY2() [4/7]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE nngn::NNGN_APPLY2	(	C	,
		VkImageView	,
		IMAGE_VIEW	)

◆ NNGN_APPLY2() [5/7]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE nngn::NNGN_APPLY2	(	C	,
		VkPipelineLayout	,
		PIPELINE_LAYOUT	)

◆ NNGN_APPLY2() [6/7]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS nngn::NNGN_APPLY2	(	C	,
		VkSampler	,
		SAMPLER	)

◆ NNGN_APPLY2() [7/7]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE nngn::NNGN_APPLY2	(	C	,
		VkShaderModule	,
		SHADER_MODULE	) const

◆ NNGN_IGNORE2() [1/3]

COMMAND_BUFFER DESCRIPTOR_POOL nngn::NNGN_IGNORE2	(	C	,
		VkDescriptorSet	,
		DESCRIPTOR_SET	)

◆ NNGN_IGNORE2() [2/3]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT nngn::NNGN_IGNORE2	(	C	,
		VkDeviceMemory	,
		DEVICE_MEMORY	)

◆ NNGN_IGNORE2() [3/3]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE nngn::NNGN_IGNORE2	(	C	,
		VkQueue	,
		QUEUE	)

◆ now()

template<typename D >

static auto nngn::now ( const Timing & t )

static

Here is the caller graph for this function:

◆ offsetof_ptr()

template<standard_layout T>

std::size_t nngn::offsetof_ptr ( auto T::* p )

Similar to the stdlib's offsetof, but using member data pointers.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator!=() [1/2]

template<typename T , allocator_opts o>

bool nngn::operator!=	(	const allocator_base< T, o > &	,
		const allocator_base< T, o > &	)

◆ operator!=() [2/2]

template<template< typename > typename T, typename R >
requires vector<T, R>

bool nngn::operator!=	(	const T< R > &	v0,
		const T< R > &	v1 )

constexpr

◆ operator&()

template<typename T >

Flags< T > nngn::operator&	(	Flags< T >	lhs,
		Flags< T >	rhs )

constexpr

◆ operator*() [1/6]

template<template< typename > typename CRTP, typename T , std::size_t N>

vec_type_t< T, N > nngn::operator*	(	const mat< CRTP, T, N > &	m,
		const vec_type_t< T, N > &	v )

inlineconstexpr

Here is the call graph for this function:

◆ operator*() [2/6]

template<template< typename > typename CRTP, typename T , std::size_t N>

CRTP< T > nngn::operator*	(	const mat< CRTP, T, N > &	m0,
		const mat< CRTP, T, N > &	m1 )

inlineconstexpr

◆ operator*() [3/6]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator*	(	const T< R > &	v,
		R	s )

inlineconstexpr

◆ operator*() [4/6]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator*	(	const T< R > &	v0,
		const T< R > &	v1 )

inlineconstexpr

◆ operator*() [5/6]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator*	(	R	s,
		const T< R > &	v )

inlineconstexpr

◆ operator*() [6/6]

template<template< typename > typename CRTP, typename T , std::size_t N>

CRTP< T > nngn::operator*	(	T	s,
		const mat< CRTP, T, N > &	m )

inlineconstexpr

◆ operator+() [1/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator+	(	const T< R > &	v,
		R	s )

inlineconstexpr

◆ operator+() [2/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator+	(	const T< R > &	v0,
		const T< R > &	v1 )

inlineconstexpr

◆ operator+() [3/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator+	(	R	s,
		const T< R > &	v )

inlineconstexpr

◆ operator-() [1/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator-	(	const T< R > &	v,
		R	s )

inlineconstexpr

◆ operator-() [2/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator-	(	const T< R > &	v0,
		const T< R > &	v1 )

inlineconstexpr

◆ operator-() [3/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator-	(	R	s,
		const T< R > &	v )

inlineconstexpr

◆ operator/() [1/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator/	(	const T< R > &	v,
		R	s )

inlineconstexpr

◆ operator/() [2/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator/	(	const T< R > &	v0,
		const T< R > &	v1 )

inlineconstexpr

◆ operator/() [3/3]

template<template< typename > typename T, typename R >
requires vector<T, R>

T< R > nngn::operator/	(	R	s,
		const T< R > &	v )

inlineconstexpr

◆ operator<<() [1/5]

std::ostream & nngn::operator<<	(	std::ostream &	os,
		const mat3 &	m )

inline

◆ operator<<() [2/5]

std::ostream & nngn::operator<<	(	std::ostream &	os,
		const mat4 &	m )

inline

◆ operator<<() [3/5]

template<template< typename > typename V, typename T , std::size_t N>

std::ostream & nngn::operator<<	(	std::ostream &	os,
		const vec< V, T, N > &	v )

inline

◆ operator<<() [4/5]

std::ostream & nngn::operator<<	(	std::ostream &	os,
		const Vertex &	v )

inline

◆ operator<<() [5/5]

std::ostream & nngn::operator<<	(	std::ostream &	os,
		Log::record	r )

◆ operator==() [1/4]

template<typename T , allocator_opts o>

bool nngn::operator==	(	const allocator_base< T, o > &	,
		const allocator_base< T, o > &	)

◆ operator==() [2/4]

template<template< typename > typename CRTP, typename T , std::size_t N>

bool nngn::operator==	(	const mat< CRTP, T, N > &	m0,
		const mat< CRTP, T, N > &	m1 )

constexpr

◆ operator==() [3/4]

template<template< typename > typename T, typename R >
requires vector<T, R>

bool nngn::operator==	(	const T< R > &	v0,
		const T< R > &	v1 )

constexpr

Here is the call graph for this function:

◆ operator==() [4/4]

bool nngn::operator==	(	const Vertex &	l,
		const Vertex &	r )

◆ operator^()

template<typename T >

Flags< T > nngn::operator^	(	Flags< T >	lhs,
		Flags< T >	rhs )

constexpr

◆ operator|()

template<typename T >

Flags< T > nngn::operator\|	(	Flags< T >	lhs,
		Flags< T >	rhs )

constexpr

◆ ptr_cmp()

bool nngn::ptr_cmp	(	const auto *	p0,
		const auto *	p1 )

inlineconstexpr

Compares the address of two pointers.

◆ ptr_diff()

auto nngn::ptr_diff	(	const auto *	lhs,
		const auto *	rhs )

inlineconstexpr

Signed distance in bytes between pointers.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ qstring_from_view()

QString nngn::qstring_from_view ( std::string_view v )

inline

Here is the caller graph for this function:

◆ read_file() [1/2]

bool nngn::read_file	(	std::string_view	filename,
		std::string *	ret )

Here is the caller graph for this function:

◆ read_file() [2/2]

bool nngn::read_file	(	std::string_view	filename,
		std::vector< std::byte > *	ret )

◆ reduce() [1/2]

auto nngn::reduce ( std::ranges::range auto && r )

constexpr

Here is the caller graph for this function:

◆ reduce() [2/2]

auto nngn::reduce	(	std::ranges::range auto &&	r,
		auto &&	init = {},
		auto &&	op = std::plus<>{} )

constexpr

◆ regexp_replace() [1/2]

std::string nngn::regexp_replace	(	std::string &&	s,
		const std::regex &	r,
		const char *	fmt )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regexp_replace() [2/2]

std::string nngn::regexp_replace	(	std::string_view	s,
		const std::regex &	r,
		const char *	fmt )

inline

Here is the call graph for this function:

◆ resize_and_init()

template<typename T >

void nngn::resize_and_init	(	T *	p,
		std::size_t	n,
		auto &&	f )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rptr()

nngn::rptr ( auto && r )

constexpr

Allows passing an rvalue pointer to a function.

E.g. takes_ptr(rptr(Obj{})).

Here is the caller graph for this function:

◆ set_bit()

template<typename T >

auto nngn::set_bit	(	T	t,
		T	mask,
		bool	value )

constexpr

Here is the caller graph for this function:

◆ set_capacity()

template<typename V >

void nngn::set_capacity	(	V *	v,
		size_t	n )

Here is the caller graph for this function:

◆ slice()

template<typename T >

std::span< T > nngn::slice	(	std::span< T >	s,
		auto	b,
		auto	e )

Here is the caller graph for this function:

◆ split() [1/2]

template<typename T >

auto nngn::split	(	std::span< T >	s,
		std::size_t	i )

◆ split() [2/2]

auto nngn::split	(	std::string_view	s,
		std::string_view::iterator	i )

inline

Here is the call graph for this function:

◆ str()

std::string nngn::str ( const static_vector< S > & v )

Here is the call graph for this function:

◆ str_less()

bool nngn::str_less	(	const char *	lhs,
		const char *	rhs )

char * nngn::toString ( const Vertex & t )

inline

◆ tuple_tail()

template<typename T >

auto nngn::tuple_tail ( T && t )

Here is the caller graph for this function:

◆ vk_check_result()

bool nngn::vk_check_result	(	const char *	func,
		VkResult	r )

inline

Checks that r is VK_SUCCESS or emits a log message.

Returns: c == VK_SUCCESS

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vk_create_info()

template<typename T >

vk_create_info_type< T > nngn::vk_create_info ( vk_create_info_type< T > info )

Here is the caller graph for this function:

◆ vk_enum_str() [1/2]

const char * nngn::vk_enum_str ( VkDebugUtilsMessageSeverityFlagBitsEXT f )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vk_enum_str() [2/2]

const char * nngn::vk_enum_str ( VkDebugUtilsMessageTypeFlagsEXT f )

Here is the call graph for this function:

◆ vk_enumerate()

template<c_function_pointer auto f>

auto nngn::vk_enumerate ( const auto &... args )

Creates a vector from the result of calling f with args.

Simplifies the usual two-step enumeration sequence of calls when dynamic allocation is desired.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vk_extent_to_vec()

nngn::uvec2 nngn::vk_extent_to_vec ( VkExtent2D e )

inline

Here is the caller graph for this function:

◆ vk_names()

std::vector< const char * > nngn::vk_names ( const VkNamedRange auto & r )

Extracts the name character array from common objects.

◆ vk_parse_extensions()

std::vector< Graphics::Extension > nngn::vk_parse_extensions ( std::span< const VkExtensionProperties > s )

Populates Graphics::Extension objects from their Vulkan equivalents.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vk_parse_version()

Graphics::Version nngn::vk_parse_version ( std::uint32_t v )

Unpacks a Vulkan version number.

Here is the caller graph for this function:

◆ vk_present_mode()

Graphics::PresentMode nngn::vk_present_mode ( VkPresentModeKHR m )

Populates a Graphics::PresentMode from its Vulkan equivalent.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vk_strerror()

const char * nngn::vk_strerror ( VkResult result )

Here is the caller graph for this function:

◆ vk_vec_to_extent()

VkExtent2D nngn::vk_vec_to_extent ( nngn::uvec2 v )

inline

Here is the caller graph for this function:

◆ vk_version_str() [1/2]

std::string nngn::vk_version_str ( Graphics::Version v )

Here is the caller graph for this function:

◆ vk_version_str() [2/2]

std::string nngn::vk_version_str ( std::uint32_t v )

Unpacks a Vulkan version number into a character array.

Here is the call graph for this function:

◆ vk_vertex_attrs()

template<standard_layout T, auto ... Ps>

auto nngn::vk_vertex_attrs ( )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vk_vertex_input() [1/2]

template<typename T , auto ... Ps>

auto nngn::vk_vertex_input ( std::span< const VkVertexInputBindingDescription > bindings )

constexpr

Here is the caller graph for this function:

◆ vk_vertex_input() [2/2]

VkPipelineVertexInputStateCreateInfo nngn::vk_vertex_input	(	std::span< const VkVertexInputBindingDescription >	bindings,
		std::span< const VkVertexInputAttributeDescription >	attrs )

empty nngn::vk_struct_type = {}

inlineconstexpr

Maps types to VkStructureType values.

◆ VkCommandBuffer

nngn::VkCommandBuffer

◆ VkDescriptorPool

COMMAND_BUFFER nngn::VkDescriptorPool

◆ VkDescriptorSetLayout

COMMAND_BUFFER DESCRIPTOR_POOL nngn::VkDescriptorSetLayout

◆ VkFence

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT nngn::VkFence

◆ VkImage

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE nngn::VkImage

◆ VkPipeline

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE nngn::VkPipeline

◆ VkPipelineCache

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE nngn::VkPipelineCache

◆ VkRenderPass

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE nngn::VkRenderPass

◆ VkSemaphore

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS nngn::VkSemaphore

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ dmat3

◆ dmat4

◆ dvec2

◆ dvec3

◆ dvec4

◆ fn_args

◆ Hash

◆ i16

◆ i32

◆ i64

◆ i8

◆ imat3

◆ imat4

◆ ivec2

◆ ivec3

◆ ivec4

◆ mat3

◆ mat4

◆ member_obj_type_t

◆ MemoryAllocation

◆ stateful_allocator

◆ stateless_allocator

◆ types

◆ u16

◆ u32

◆ u64

◆ u8

◆ umat3

◆ umat4

◆ uvec2

◆ uvec3

◆ uvec4

◆ vec2

◆ vec3

◆ vec4

◆ vec_type_t

◆ vector_type

◆ vk_create_info_type

◆ zvec2

◆ zvec3

◆ zvec4

Enumeration Type Documentation

◆ empty

Function Documentation

◆ add()

◆ as_byte_span() [1/2]

◆ as_byte_span() [2/2]

◆ as_bytes() [1/2]

◆ as_bytes() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ bit_cast()

◆ byte_cast() [1/2]

◆ byte_cast() [2/2]

◆ cast()

◆ cat()

◆ chain_cast()

◆ compute_create_backend()

◆ compute_create_backend< backend >()

◆ compute_create_backend< Compute::Backend::PSEUDOCOMP >()

◆ const_time_erase()

◆ contains()

◆ data_end()

◆ dt()

◆ end() [1/2]

◆ end() [2/2]

◆ end_step()

◆ fdt()

◆ fill_with_pattern() [1/2]

◆ fill_with_pattern() [2/2]

◆ fixed_string()

◆ fmt()