nngn
Loading...
Searching...
No Matches
nngn Namespace Reference

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 an 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
 
struct  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...)>
 
struct  ModelRenderer
 
class  Models
 
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 = typename detail::vk_create_info_type_impl< T >::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 imat4 = mat4_base< int32_t >
 
using umat4 = mat4_base< uint32_t >
 
using mat4 = mat4_base< float >
 
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
 
using dmat3 = mat3_base< double >
 
using dmat4 = mat4_base< double >
 

Enumerations

enum class  empty
 
enum class  empty
 

Functions

template<typename T >
static T::pointer add (T *v, typename T::const_reference c)
 
template<Compute::Backend >
std::unique_ptr< Computecompute_create_backend (const void *params)
 
template<>
std::unique_ptr< Computecompute_create_backend< backend > (const void *params)
 
template<>
std::unique_ptr< Computecompute_create_backend< Compute::Backend::PSEUDOCOMP > (const void *params)
 
template<Graphics::Backend >
std::unique_ptr< Graphicsgraphics_create_backend (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_create_backend< backend > (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_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< Graphicsgraphics_create_backend< Backend > (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_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) NNGN_APPLY2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER NNGN_IGNORE2 (C, VkCommandBuffer, COMMAND_BUFFER) NNGN_APPLY2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL NNGN_APPLY2 (C, VkDescriptorPool, DESCRIPTOR_POOL) NNGN_IGNORE2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET NNGN_APPLY2 (C, VkDescriptorSetLayout, DESCRIPTOR_SET_LAYOUT) NNGN_IGNORE2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY NNGN_APPLY2 (C, VkFence, FENCE) NNGN_APPLY2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER NNGN_APPLY2 (C, VkImage, IMAGE) NNGN_APPLY2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW NNGN_IGNORE2 (C, VkPipeline, PIPELINE) NNGN_IGNORE2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE NNGN_APPLY2 (C, VkPipelineCache, PIPELINE_CACHE) NNGN_APPLY2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT NNGN_APPLY2 (C, VkRenderPass, RENDER_PASS) NNGN_APPLY2(C
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT SAMPLER NNGN_APPLY2 (C, VkSemaphore, SEMAPHORE) NNGN_APPLY2(C
 
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::Extensionvk_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< Tvk_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< Graphicsgraphics_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< Toperator* (T s, const mat< CRTP, T, N > &m)
 
template<template< typename > typename CRTP, typename T , std::size_t N>
constexpr CRTP< Toperator* (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, Noperator* (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.
 
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 Tmemcpy (T *dst, std::ranges::contiguous_range auto &&r)
 
template<typename T >
constexpr Tmemmove (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< Tslice (std::span< T > s, auto b, auto e)
 
template<typename T >
auto split (std::span< T > s, std::size_t 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_casts, 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 spans 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)
 
template<typename T >
static T::pointer add (T *v, typename T::const_reference c)
 
template<>
std::unique_ptr< Computecompute_create_backend< backend > (const void *params)
 
template<>
std::unique_ptr< Computecompute_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<>
std::unique_ptr< Graphicsgraphics_create_backend< backend > (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_create_backend< backend_es > (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_create_backend< Backend > (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_create_backend< backend > (const void *params)
 
template<>
std::unique_ptr< Graphicsgraphics_create_backend< Backend > (const void *params)
 
bool parse_obj (std::istream *f, std::span< char > buffer, std::invocable< vec3 > auto &&vertex, std::invocable< vec3 > auto &&tex, std::invocable< vec3 > auto &&normal, std::invocable< std::array< zvec3, 3 > > auto &&face)
 Processes an OBJ file using the callable arguments.
 
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 >
constexpr Flags< Toperator& (Flags< T > lhs, Flags< T > rhs)
 
template<typename T >
constexpr Flags< Toperator| (Flags< T > lhs, Flags< T > rhs)
 
template<typename T >
constexpr Flags< Toperator^ (Flags< T > lhs, Flags< T > rhs)
 
auto split (std::string_view s, std::string_view::iterator i)
 

Variables

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
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE VkBuffer
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER VkCommandPool
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL VkDescriptorSet
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET VkDeviceMemory
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY VkFramebuffer
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER VkImageView
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW VkQueue
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE VkPipelineLayout
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT VkSampler
 
COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT SAMPLER VkShaderModule
 
template<typename T >
using const_iterator = typedef
 
template<typename T >
static constexpr Compute::Type arg_type = Compute::Type::NONE
 

Typedef Documentation

◆ dmat3

using nngn::dmat3 = typedef mat3_base<double>

◆ dmat4

using nngn::dmat4 = typedef mat4_base<double>

◆ dvec2

typedef vec2_base< double > nngn::dvec2

◆ dvec3

typedef vec3_base< double > nngn::dvec3

◆ dvec4

typedef vec4_base< double > nngn::dvec4

◆ fn_args

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

◆ Hash

typedef std::size_t nngn::Hash

◆ i16

typedef std::int16_t nngn::i16

◆ i32

typedef std::int32_t nngn::i32

◆ i64

typedef std::int64_t nngn::i64

◆ i8

typedef std::int8_t nngn::i8

◆ imat3

typedef mat3_base< int32_t > nngn::imat3

◆ imat4

typedef mat4_base< int32_t > nngn::imat4

◆ ivec2

typedef vec2_base< std::int32_t > nngn::ivec2

◆ ivec3

typedef vec3_base< std::int32_t > nngn::ivec3

◆ ivec4

typedef vec4_base< std::int32_t > nngn::ivec4

◆ mat3

◆ mat4

◆ member_obj_type_t

template<typename T >
using nngn::member_obj_type_t = typedef typename member_obj_type<T>::type
See also
member_obj_type

◆ MemoryAllocation

typedef std::uint64_t nngn::MemoryAllocation

◆ stateful_allocator

template<typename T >
using nngn::stateful_allocator = typedef 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 = typedef 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 = typedef detail::types_impl<Ts...>

◆ u16

typedef std::uint16_t nngn::u16

◆ u32

typedef std::uint32_t nngn::u32

◆ u64

typedef std::uint64_t nngn::u64

◆ u8

typedef std::uint8_t nngn::u8

◆ umat3

typedef mat3_base< uint32_t > nngn::umat3

◆ umat4

typedef mat4_base< uint32_t > nngn::umat4

◆ uvec2

typedef vec2_base< std::uint32_t > nngn::uvec2

◆ uvec3

typedef vec3_base< std::uint32_t > nngn::uvec3

◆ uvec4

typedef vec4_base< std::uint32_t > nngn::uvec4

◆ vec2

◆ vec3

◆ vec4

◆ vec_type_t

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

◆ vector_type

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

◆ vk_create_info_type

template<typename T >
using nngn::vk_create_info_type = typedef typename detail::vk_create_info_type_impl<T>::type

Maps types to *CretaeInfo structures.

◆ zvec2

typedef vec2_base< std::size_t > nngn::zvec2

◆ zvec3

typedef vec3_base< std::size_t > nngn::zvec3

◆ zvec4

typedef vec4_base< std::size_t > nngn::zvec4

Enumeration Type Documentation

◆ empty [1/2]

enum class nngn::empty
strong

◆ empty [2/2]

enum class nngn::empty
strong

Function Documentation

◆ add() [1/2]

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:

◆ add() [2/2]

template<typename T >
static T::pointer nngn::add ( T v,
typename T::const_reference  c 
)
static
Here is the call 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>
constexpr 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>
constexpr 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>)
constexpr auto nngn::bit_cast ( const From &  from)
constexpr

◆ byte_cast() [1/2]

template<typename To , typename From >
requires byte_pointer<To> || byte_pointer<From>
constexpr To nngn::byte_cast ( From  p)
constexpr

reinterpret_cast restricted to conversions from/to char/uchar.

◆ 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.

◆ cast()

template<typename T , typename U >
constexpr 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>
constexpr 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>
constexpr nngn::chain_cast ( auto &&  x)
constexpr

Performs successive static_casts, right to left.

◆ compute_create_backend()

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

◆ compute_create_backend< backend >() [1/2]

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

◆ compute_create_backend< backend >() [2/2]

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

◆ compute_create_backend< Compute::Backend::PSEUDOCOMP >() [1/2]

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

◆ compute_create_backend< Compute::Backend::PSEUDOCOMP >() [2/2]

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()

constexpr bool nngn::contains ( const std::ranges::contiguous_range auto &  r,
const auto &  x 
)
constexpr
Here is the caller graph for this function:

◆ data_end()

constexpr auto * nngn::data_end ( std::ranges::contiguous_range auto &&  r)
constexpr
Here is the caller graph for this function:

◆ dt() [1/2]

template<typename D >
static auto nngn::dt ( const Timing t)
static
Here is the caller graph for this function:

◆ dt() [2/2]

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

◆ end() [1/2]

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

◆ end() [2/2]

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

◆ end_step() [1/2]

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:

◆ end_step() [2/2]

static void nngn::end_step ( AdHocTimer::Step s,
Timing::time_point last 
)
static
Here is the call graph for this function:

◆ fdt() [1/2]

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

◆ fdt() [2/2]

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

◆ fill_with_pattern() [1/2]

template<std::input_iterator I, std::output_iterator< std::iter_value_t< I > > O>
constexpr void nngn::fill_with_pattern ( f,
l,
df,
dl 
)
constexpr
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fill_with_pattern() [2/2]

constexpr 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() [1/2]

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

◆ fnow() [2/2]

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

◆ 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)
Here is the caller graph for this function:

◆ graphics_create_backend()

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

◆ graphics_create_backend< backend >() [1/4]

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

◆ graphics_create_backend< Backend >() [1/4]

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

◆ graphics_create_backend< backend >() [2/4]

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

◆ graphics_create_backend< Backend >() [2/4]

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

◆ graphics_create_backend< backend >() [3/4]

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

◆ graphics_create_backend< Backend >() [3/4]

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

◆ graphics_create_backend< backend >() [4/4]

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

◆ graphics_create_backend< Backend >() [4/4]

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

◆ graphics_create_backend< backend_es >() [1/2]

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

◆ graphics_create_backend< backend_es >() [2/2]

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()

constexpr 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>
constexpr 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>
constexpr 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 >
constexpr T * nngn::memcpy ( T dst,
std::ranges::contiguous_range auto &&  r 
)
constexpr
Here is the caller graph for this function:

◆ memmove()

template<typename T >
constexpr T * nngn::memmove ( T dst,
std::ranges::contiguous_range auto &&  r 
)
constexpr
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.

◆ NNGN_APPLY2() [1/14]

nngn::NNGN_APPLY2 ( C  ,
VkBuffer  ,
BUFFER   
)

◆ NNGN_APPLY2() [2/14]

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

◆ NNGN_APPLY2() [3/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL nngn::NNGN_APPLY2 ( C  ,
VkDescriptorPool  ,
DESCRIPTOR_POOL   
)

◆ NNGN_APPLY2() [4/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET nngn::NNGN_APPLY2 ( C  ,
VkDescriptorSetLayout  ,
DESCRIPTOR_SET_LAYOUT   
)

◆ NNGN_APPLY2() [5/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY nngn::NNGN_APPLY2 ( C  ,
VkFence  ,
FENCE   
)

◆ NNGN_APPLY2() [6/14]

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

◆ NNGN_APPLY2() [7/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER nngn::NNGN_APPLY2 ( C  ,
VkImage  ,
IMAGE   
)

◆ NNGN_APPLY2() [8/14]

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

◆ NNGN_APPLY2() [9/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE nngn::NNGN_APPLY2 ( C  ,
VkPipelineCache  ,
PIPELINE_CACHE   
)

◆ NNGN_APPLY2() [10/14]

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

◆ NNGN_APPLY2() [11/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT nngn::NNGN_APPLY2 ( C  ,
VkRenderPass  ,
RENDER_PASS   
)

◆ NNGN_APPLY2() [12/14]

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

◆ NNGN_APPLY2() [13/14]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT SAMPLER nngn::NNGN_APPLY2 ( C  ,
VkSemaphore  ,
SEMAPHORE   
)

◆ NNGN_APPLY2() [14/14]

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

◆ NNGN_IGNORE2() [1/5]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER nngn::NNGN_IGNORE2 ( C  ,
VkCommandBuffer  ,
COMMAND_BUFFER   
)

◆ NNGN_IGNORE2() [2/5]

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

◆ NNGN_IGNORE2() [3/5]

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

◆ NNGN_IGNORE2() [4/5]

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW nngn::NNGN_IGNORE2 ( C  ,
VkPipeline  ,
PIPELINE   
)

◆ NNGN_IGNORE2() [5/5]

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

◆ now() [1/2]

template<typename D >
static auto nngn::now ( const Timing t)
static
Here is the caller graph for this function:

◆ now() [2/2]

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

◆ 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>
constexpr bool nngn::operator!= ( const T< R > &  v0,
const T< R > &  v1 
)
constexpr

◆ operator&()

template<typename T >
constexpr 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>
constexpr 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>
constexpr 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>
constexpr T< R > nngn::operator* ( const T< R > &  v,
s 
)
inlineconstexpr

◆ operator*() [4/6]

template<template< typename > typename T, typename R >
requires vector<T, R>
constexpr 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>
constexpr T< R > nngn::operator* ( s,
const T< R > &  v 
)
inlineconstexpr

◆ operator*() [6/6]

template<template< typename > typename CRTP, typename T , std::size_t N>
constexpr 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>
constexpr T< R > nngn::operator+ ( const T< R > &  v,
s 
)
inlineconstexpr

◆ operator+() [2/3]

template<template< typename > typename T, typename R >
requires vector<T, R>
constexpr 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>
constexpr T< R > nngn::operator+ ( s,
const T< R > &  v 
)
inlineconstexpr

◆ operator-() [1/3]

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

◆ operator-() [2/3]

template<template< typename > typename T, typename R >
requires vector<T, R>
constexpr 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>
constexpr T< R > nngn::operator- ( s,
const T< R > &  v 
)
inlineconstexpr

◆ operator/() [1/3]

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

◆ operator/() [2/3]

template<template< typename > typename T, typename R >
requires vector<T, R>
constexpr 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>
constexpr T< R > nngn::operator/ ( 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>
constexpr 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>
constexpr 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 >
constexpr Flags< T > nngn::operator^ ( Flags< T lhs,
Flags< T rhs 
)
constexpr

◆ operator|()

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

◆ parse_obj()

bool nngn::parse_obj ( std::istream *  f,
std::span< char >  buffer,
std::invocable< vec3 > auto &&  vertex,
std::invocable< vec3 > auto &&  tex,
std::invocable< vec3 > auto &&  normal,
std::invocable< std::array< zvec3, 3 > > auto &&  face 
)
inline

Processes an OBJ file using the callable arguments.

Each argument is called immediately after a line containing the corresponding command is found.

For vertices, texture coordinates, and normal vectors, missing elements result in zeroes in the value passed to the callable (e.g. v 1 results in a call to vertex({1, 0, 0})).

Faces are always emitted as triangles. After being processed as defined by the OBJ format (i.e. filling values for entries such as 1, 1/2, 1//2, etc.), each group of three vertices is passed as an argument to the face callable. Currently, the list is treated as a triangular fan, such that a line in the form f 1 2 3 4 5 … results in the triangles {1, 2, 3}, {1, 3, 4}, {1, 4, 5}, etc. This list of triangular faces is assumed to be in counter-clockwise (i.e. right-handed) orientation.

Parameters
vertexCalled for each line containing a v definition.
texCalled for each line containing a vt definition.
normalCalled for each line containing a vn definition.
faceCalled repeatedly for each line containing an f definition. Each element in the array argument corresponds to a {v,vt,vn} group and the array defines a triangular face, as described in detail above.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ptr_cmp()

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

Compares the address of two pointers.

◆ ptr_diff()

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

Signed distance in bytes between pointers.

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]

constexpr auto nngn::reduce ( std::ranges::range auto &&  r)
constexpr
Here is the caller graph for this function:

◆ reduce() [2/2]

constexpr 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()

constexpr 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 >
constexpr 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 
)
Here is the caller graph for this function:

◆ 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:
Here is the caller graph for this function:

◆ str_less()

constexpr bool nngn::str_less ( const char *  lhs,
const char *  rhs 
)
inlineconstexpr
Here is the caller graph for this function:

◆ to_array() [1/4]

template<std::size_t N>
consteval auto nngn::to_array ( const char *  s)
Here is the caller graph for this function:

◆ to_array() [2/4]

template<std::size_t N>
consteval auto nngn::to_array ( const char(&)  s[N])
Here is the call graph for this function:

◆ to_array() [3/4]

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

◆ to_array() [4/4]

template<std::size_t N, std::ranges::view V>
consteval auto nngn::to_array ( V &&  v)
Here is the call graph for this function:

◆ to_underlying()

template<enum_ T>
constexpr auto nngn::to_underlying ( T  t)
inlineconstexpr
Here is the caller graph for this function:

◆ toString() [1/6]

char * nngn::toString ( const mat3 t)
inline

◆ toString() [2/6]

char * nngn::toString ( const mat4 t)
inline

◆ toString() [3/6]

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

◆ toString() [4/6]

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

◆ toString() [5/6]

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

◆ toString() [6/6]

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

◆ tuple_tail()

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

◆ 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)

◆ 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.

Here is the caller graph for this function:

◆ 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:

◆ vk_vertex_input() [1/2]

template<typename T , auto ... Ps>
constexpr auto nngn::vk_vertex_input ( std::span< const VkVertexInputBindingDescription >  bindings)
constexpr
Here is the caller graph for this function:

◆ vk_vertex_input() [2/2]

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

Variable Documentation

◆ arg_type [1/2]

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

◆ arg_type [2/2]

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

◆ const_iterator

template<typename T >
typedef nngn::const_iterator

◆ vk_obj_type

template<typename T >
constexpr empty nngn::vk_obj_type = {}
inlineconstexpr

Maps types to VkObjectType values.

◆ vk_struct_type

template<typename T >
constexpr empty nngn::vk_struct_type = {}
inlineconstexpr

Maps types to VkStructureType values.

◆ VkBuffer

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE nngn::VkBuffer

◆ VkCommandBuffer

nngn::VkCommandBuffer

◆ VkCommandPool

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER nngn::VkCommandPool

◆ VkDescriptorPool

COMMAND_BUFFER nngn::VkDescriptorPool

◆ VkDescriptorSet

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL nngn::VkDescriptorSet

◆ VkDescriptorSetLayout

COMMAND_BUFFER DESCRIPTOR_POOL nngn::VkDescriptorSetLayout

◆ VkDeviceMemory

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET nngn::VkDeviceMemory

◆ VkFence

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT nngn::VkFence

◆ VkFramebuffer

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY nngn::VkFramebuffer

◆ VkImage

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE nngn::VkImage

◆ VkImageView

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER nngn::VkImageView

◆ 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

◆ VkPipelineLayout

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE nngn::VkPipelineLayout

◆ VkQueue

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW nngn::VkQueue

◆ VkRenderPass

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE nngn::VkRenderPass

◆ VkSampler

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT nngn::VkSampler

◆ VkSemaphore

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

◆ VkShaderModule

COMMAND_BUFFER DESCRIPTOR_POOL DESCRIPTOR_SET_LAYOUT FENCE IMAGE PIPELINE PIPELINE_CACHE RENDER_PASS SEMAPHORE BUFFER COMMAND_POOL DESCRIPTOR_SET DEVICE_MEMORY FRAMEBUFFER IMAGE_VIEW QUEUE PIPELINE_LAYOUT SAMPLER nngn::VkShaderModule