Classes
struct	AABB

class	AABBCollisionShape

class	Animation

class	AnimationLibrary

struct	AnimationTrack

struct	AnimationTrackKeyValue

class	AssetsPack

class	AsyncQueue

class	AsyncTasksPool

class	BPLayerInterfaceImpl

class	BloomPass

struct	BlurData

class	BoxCollisionShape

struct	Camera

class	CollisionObject

struct	CollisionObjectEvent

class	CollisionShape

struct	CollisionSubShape

class	ContactListener

struct	Context

struct	ContextConfiguration

class	ConvexHullCollisionShape

class	CustomRenderpass

class	DeferredRenderer

class	DeferredTasksBuffer

class	DepthPrepass

class	DeviceMemoryArray

class	DirectoryWatcher

struct	DirectoryWatcherEvent

class	DisplayAttachment

struct	DrawCommand

struct	DrawParam

struct	DrawSession

struct	Environment

struct	Event

struct	EventHandler

class	EventManager

class	Exception

class	FXAAPass

class	Font

struct	FontEvent

struct	FontParams

class	ForwardColorPass

class	ForwardRenderer

class	FrameScalingPass

class	FrameSharpeningPass

struct	Frustum

class	FrustumCulling

class	FullScreenCompute

class	GBufferPass

class	GTAOPass

class	GammaCorrectionPass

class	GenerateDrawCommands

class	GenerateVectorDrawCommands

class	GlobalDescriptorSet

struct	GraphicPipelineData

class	HostVisibleMemoryArray

class	Image

struct	ImageEvent

class	ImageManager

struct	ImageTexture

class	Input

struct	InputAction

struct	InputActionEntry

struct	InputEvent

struct	InputEventGamepadButton

struct	InputEventKey

struct	InputEventMouseButton

struct	InputEventMouseMotion

struct	InputEventTextInput

struct	InstanceData

class	JoltPhysicsEngine

class	JoltPhysicsWorld

struct	LayerCollideWith

struct	LayerCollisionTable

struct	Light

struct	LightData

class	LightingPass

class	Locale

class	Log

class	LogStream

class	LogStreamBuf

struct	LoggingConfiguration

class	Lysa

struct	MainLoopEvent

struct	ManagedResource

class	Material

struct	MaterialData

struct	MaterialEvent

class	MaterialManager

class	MemoryArray

struct	MemoryBlock

class	Mesh

class	MeshCollisionShape

struct	MeshData

class	MeshInstance

struct	MeshInstanceData

class	MeshManager

struct	MeshSurface

struct	MeshSurfaceData

class	ObjectLayerPairFilterImpl

class	ObjectVsBroadPhaseLayerFilterImpl

class	PhysXPhysicsEngine

class	PhysXPhysicsWorld

class	PhysicsDebugRenderer

class	PhysicsEngine

struct	PhysicsEngineConfiguration

class	PhysicsWorld

struct	PredefinedFontParams

class	PropertyTween

class	QuadMesh

struct	Ray

class	RayCast

struct	RayCastHit

struct	RayHit

struct	Rect

class	RenderTarget

struct	RenderTargetConfiguration

struct	RenderTargetEvent

struct	RenderView

class	Renderer

struct	RendererConfiguration

class	RenderingWindow

struct	RenderingWindowConfiguration

struct	RenderingWindowEvent

class	Renderpass

struct	Resource

struct	ResourcesCapacity

class	ResourcesManager

class	ResourcesPack

class	ResourcesPackStreambuf

class	ResourcesRegistry

class	SMAAPass

class	SSAOPass

class	Samplers

class	Scene

struct	SceneConfiguration

struct	SceneData

class	SceneFrameData

struct	SceneOperation

class	ShaderMaterial

class	ShaderMaterialPass

class	ShadowMapPass

class	SphereCollisionShape

class	StandardMaterial

class	StaticCompoundCollisionShape

class	TAAPass

struct	TextureInfoData

class	Timer

class	Timers

class	TransparencyPass

class	TriangleMesh

class	Tween

class	TweenSequence

class	Tweens

struct	TypeRegistry

class	UniqueResource

class	UnmanagedResource

class	Vector2DRenderer

class	Vector3DRenderer

struct	VectorDrawCommand

struct	Vertex

struct	VertexData

class	VirtualFS

struct	VirtualFSConfiguration

Typedefs
using	event_type = std::string

using	EventHandlerCallback = std::function< void (Event &)>

using	uint8 = std::uint8_t

using	uint16 = std::uint16_t

using	uint32 = std::uint32_t

using	uint64 = std::uint64_t

using	int8 = std::int8_t

using	int16 = std::int16_t

using	int32 = std::int32_t

using	int64 = std::int64_t

using	size_t = std::size_t

using	unique_id = int64

using	pipeline_id = uint32

using	collision_layer = uint32

Enums
enum class	InputActionEntryType { KEYBOARD, MOUSE, GAMEPAD }

enum class	InputEventType : uint8 { KEY = 0, MOUSE_MOTION = 1, MOUSE_BUTTON = 2, GAMEPAD_BUTTON = 3, TEXT_INPUT = 4 }

enum class	KeyModifier : uint8 { SHIFT = 0x0001, CONTROL = 0x0002, ALT = 0x0004, SUPER = 0x0008 }

enum	Key : uint32 { KEY_NONE = 0, KEY_SPACE = 1, KEY_DASH = 2, KEY_PIPE = 3, KEY_APOSTROPHE = 4, KEY_COMMA = 5, KEY_PERIOD = 6, KEY_QUESTIONMARK = 7, KEY_0 = 8, KEY_1 = 9, KEY_2 = 10, KEY_3 = 11, KEY_4 = 12, KEY_5 = 13, KEY_6 = 14, KEY_7 = 15, KEY_8 = 16, KEY_9 = 17, KEY_SEMICOLON = 18, KEY_EQUAL = 19, KEY_A = 20, KEY_B = 21, KEY_C = 22, KEY_D = 23, KEY_E = 24, KEY_F = 25, KEY_G = 26, KEY_H = 27, KEY_I = 28, KEY_J = 29, KEY_K = 30, KEY_L = 31, KEY_M = 32, KEY_N = 33, KEY_O = 34, KEY_P = 35, KEY_Q = 36, KEY_R = 37, KEY_S = 38, KEY_T = 39, KEY_U = 40, KEY_V = 41, KEY_W = 42, KEY_X = 43, KEY_Y = 44, KEY_Z = 45, KEY_LEFT_BRACKET = 46, KEY_BACKSLASH = 47, KEY_RIGHT_BRACKET = 48, KEY_GRAVE_ACCENT = 49, KEY_ESCAPE = 50, KEY_ENTER = 51, KEY_TAB = 52, KEY_BACKSPACE = 53, KEY_INSERT = 54, KEY_DELETE = 55, KEY_RIGHT = 56, KEY_LEFT = 57, KEY_DOWN = 58, KEY_UP = 59, KEY_PAGE_UP = 60, KEY_PAGE_DOWN = 61, KEY_HOME = 62, KEY_END = 63, KEY_CAPS_LOCK = 64, KEY_SCROLL_LOCK = 65, KEY_NUM_LOCK = 66, KEY_PRINT_SCREEN = 67, KEY_PAUSE = 68, KEY_F1 = 69, KEY_F2 = 70, KEY_F3 = 71, KEY_F4 = 72, KEY_F5 = 73, KEY_F6 = 74, KEY_F7 = 75, KEY_F8 = 76, KEY_F9 = 77, KEY_F10 = 78, KEY_F11 = 79, KEY_F12 = 80, KEY_KP_0 = 81, KEY_KP_1 = 82, KEY_KP_2 = 83, KEY_KP_3 = 84, KEY_KP_4 = 85, KEY_KP_5 = 86, KEY_KP_6 = 87, KEY_KP_7 = 88, KEY_KP_8 = 89, KEY_KP_9 = 90, KEY_KP_PERIOD = 91, KEY_KP_DIVIDE = 92, KEY_KP_MULTIPLY = 93, KEY_KP_SUBTRACT = 94, KEY_KP_ADD = 95, KEY_KP_ENTER = 96, KEY_KP_EQUAL = 97, KEY_LEFT_SHIFT = 98, KEY_LEFT_CONTROL = 99, KEY_LEFT_ALT = 100, KEY_LEFT_SUPER = 101, KEY_RIGHT_SHIFT = 102, KEY_RIGHT_CONTROL = 103, KEY_RIGHT_ALT = 104, KEY_RIGHT_SUPER = 105 }

enum class	MouseButton : uint8 { NONE = 0b0000, LEFT = 0b0001, RIGHT = 0b0010, MIDDLE = 0b0100, WHEEL = 0b1000 }

enum class	GamepadButton : uint8 { A = 0, CROSS = A, B = 1, CIRCLE = B, X = 2, SQUARE = X, Y = 3, TRIANGLE = Y, LB = 4, L1 = LB, RB = 5, R1 = RB, BACK = 6, SHARE = BACK, START = 7, MENU = START, LT = 8, L2 = LT, RT = 9, R2 = RT, DPAD_UP = 10, DPAD_RIGHT = 11, DPAD_DOWN = 12, DPAD_LEFT = 13, LAST = DPAD_LEFT }

enum class	GamepadAxisJoystick : uint8 { LEFT = 0, RIGHT = 1 }

enum class	GamepadAxis : uint8 { LEFT_X = 0, LEFT_Y = 1, RIGHT_X = 2, RIGHT_Y = 3, LEFT_TRIGGER = 4, RIGHT_TRIGGER = 5, LAST = RIGHT_TRIGGER }

enum	LoggingMode : uint32 { LOGGING_MODE_NONE = 0, LOGGING_MODE_WINDOW = 0x001, LOGGING_MODE_FILE = 0x010, LOGGING_MODE_STDOUT = 0x100 }

enum class	LogLevel : int32 { TRACE = -1, DEBUG = 0, INFO = 1, GAME1 = 2, GAME2 = 3, GAME3 = 4, WARNING = 5, ERROR = 6, CRITICAL = 7, INTERNAL = 100 }

enum class	PhysicsEngineType { JOLT, PHYSX }

enum class	CombineMode { AVERAGE = 0, MIN = 1, MAX = 2, MULTIPLY = 3 }

enum class	RendererType : uint8 { FORWARD = 0, DEFERRED = 1 }

enum class	ToneMappingType : uint8 { NONE = 0, REINHARD = 1, ACES = 2 }

enum class	PostProcessAntiAliasingType : uint8 { NONE = 0, FXAA = 1, SMAA = 2 }

enum class	FrameScalingType : uint8 { NONE = 0, BILINEAR = 1, AMD_FSR_1 = 2 }

enum class	FrameSharpeningType : uint8 { NONE = 0, AMD_FSR_1 = 1 }

enum class	AmbientOcclusionType : uint8 { NONE = 0, SSAO = 1, GTAO = 2 }

enum class	SceneOperationType { ADD_INSTANCE, REMOVE_INSTANCE, UPDATE_INSTANCE, MOVE_PIPELINE_INSTANCE, ADD_LIGHT, REMOVE_LIGHT, SET_ENVIRONMENT }

enum class	DrawPrimType : uint32 { LINE_LIST = 0, LINE_STRIP = 1, TRI_PLAIN = 2, TRI_IMAGE = 3, TRI_GLYPH = 4 }

enum class	TextAlignment { LEFT, CENTER, RIGHT }

enum class	AnimationType : uint8 { TRANSLATION = 1, ROTATION = 2, SCALE = 3 }

enum class	AnimationInterpolation : uint8 { LINEAR = 0, STEP = 1 }

enum class	AnimationLoopMode : uint8 { NONE = 0, LINEAR = 1 }

enum class	LightType : int8 { LIGHT_UNKNOWN = -1, LIGHT_DIRECTIONAL = 0, LIGHT_OMNI = 1, LIGHT_SPOT = 2 }

enum class	RenderingPhase { AFTER_LIGHTING_PASS = 0, AFTER_COLOR_PASS = 1, AFTER_TRANSPARENCY_PASS = 2, AFTER_BLOOM_PASS = 3, AFTER_POSTPROCESSING_PASS = 4, AFTER_AA_PASS = 5, COUNT = AFTER_AA_PASS + 1, DEFAULT = AFTER_COLOR_PASS }

enum class	Transparency { DISABLED = 0, ALPHA = 1 }

enum class	MeshAlignment { CENTER, LEFT, RIGHT }

enum class	MouseMode : uint8 { VISIBLE = 0, VISIBLE_CAPTURED = 1, HIDDEN = 2, HIDDEN_CAPTURED = 3 }

enum class	MouseCursor : uint8 { ARROW = 0, WAIT = 1, RESIZE_H = 2, RESIZE_V = 3 }

enum class	RenderingWindowMode : uint32 { WINDOWED = 0, WINDOWED_MAXIMIZED = 1, WINDOWED_FULLSCREEN = 2, FULLSCREEN = 3 }

enum class	TransitionType : uint8 { LINEAR = 0, IN_QUAD, OUT_QUAD, IN_OUT_QUAD, SMOOTH, IN_CUBIC, OUT_CUBIC, IN_OUT_CUBIC, IN_BACK, OUT_BACK }

enum class	DirectoryEntryType : uint8 { FILE, DIRECTORY }

Functions
void	vireoDebugCallback (vireo::DebugLevel level, const std::string &message)

constexpr Context &	ctx ()

template<typename Expr >
constexpr void	assert (Expr &&, const std::string_view, const std::source_location &=std::source_location::current ()) noexcept

float3	euler_angles (quaternion q)

float	radians (const float angle)

bool	almost_equals (const float f1, const float f2)

bool	almost_equals (const quaternion &f1, const quaternion &f2)

float4x4	look_at (const float3 &eye, const float3 &center, const float3 &up)

float4x4	perspective (float fov, float aspect, float near, float far)

float4x4	orthographic (float left, float right, float top, float bottom, float znear, float zfar)

quaternion	to_quaternion (const float4x4 &m)

uint32	randomi (uint32 max)

float	randomf (float max)

float2	mul (const float2 &a, const float b)

float3	mul (const float3 &a, const float b)

float4	mul (const float4 &a, const float b)

float2	mul (const float a, const float2 &b)

float3	mul (const float a, const float3 &b)

float4	mul (const float a, const float4 &b)

float2	mul (const float2 &a, const float2 &b)

float3	mul (const float3 &a, const float3 &b)

float4	mul (const float4 &a, const float4 &b)

float2	add (const float2 &a, const float2 &b)

float3	add (const float3 &a, const float3 &b)

float4	add (const float4 &a, const float4 &b)

float2	sub (const float2 &a, const float2 &b)

float3	sub (const float3 &a, const float3 &b)

float4	sub (const float4 &a, const float4 &b)

std::optional< RayHit >	ray_triangle (const Ray &ray, const float3 &v0, const float3 &v1, const float3 &v2)

consteval bool	is_windows ()

float	get_current_time_milliseconds ()

std::string	sanitize_name (const std::string &name)

bool	dir_exists (const std::string &dirName)

float3	to_float3 (const std::string &str)

float4	to_float4 (const std::string &str)

std::vector< std::string_view >	split (std::string_view str, char delimiter)

std::string	to_hexstring (const void *ptr)

std::string	to_hexstring (uint32 ptr)

std::string	to_string (const wchar_t *wstr)

std::string	to_string (const float3 &vec)

std::string	to_string (const float2 &vec)

std::string	to_string (const quaternion &vec)

std::string	to_string (const float4 &vec)

std::u32string	to_utf32 (const std::string &utf8)

std::string	to_lower (const std::string &str)

std::string	get_locale ()

float	halton_sequence (const uint32 index, const uint32 base)

Variables
constexpr bool	lua_bindings = false

constexpr bool	ENABLE_LOG = true
	Indicates at compile-time that logging is enabled. More...

const float3	AXIS_X {1.0f, 0.0f, 0.0f}

const float3	AXIS_Y {0.0f, 1.0f, 0.0f}

const float3	AXIS_Z {0.0f, 0.0f, 1.0f}

const float3	AXIS_UP = {0.0f, 1.0f, 0.0f}

const float3	AXIS_DOWN = {0.0f, -1.0f, 0.0f}

const float3	AXIS_FRONT = {0.0f, 0.0f, -1.0f}

const float3	AXIS_BACK = {0.0f, 0.0f, 1.0f}

const float3	AXIS_RIGHT = {1.0f, 0.0f, 0.0f}

const float3	AXIS_LEFT = {-1.0f, 0.0f, 0.0f}

const float2	FLOAT2ZERO {0.0f}

const float3	FLOAT3ZERO {0.0f}

const float4	FLOAT4ZERO {0.0f}

const quaternion	QUATERNION_IDENTITY {0.0f, 0.0f, 0.0f, 1.0f}

const float3x3	TRANSFORM_BASIS {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}

constexpr float	HALF_PI = std::numbers::pi_v<float> / 2.0f

constexpr uint32	PHYSX_MAX_COLLISIONS_LAYERS {100}

constexpr Rect	RECT_FULLSCREEN {0.0f, 0.0f, -1.0f, -1.0f}

const float3	DEFAULT_CLEAR_COLOR {0.0f, 0.0f, 0.0f}

constexpr float	VECTOR_2D_SCREEN_SIZE {1000.0f}

constexpr pipeline_id	DEFAULT_PIPELINE_ID {0}

constexpr unique_id	INVALID_ID {-1}

Typedef Documentation

using collision_layer = uint32

Bitmask used to filter physics collision pairs.

using event_type = std::string

Alias representing an application-defined event kind.

using EventHandlerCallback = std::function<void(Event&)>

Callback signature for event handlers.

using int16 = std::int16_t

Signed 16-bit integer.

using int32 = std::int32_t

Signed 32-bit integer.

using int64 = std::int64_t

Signed 64-bit integer.

using int8 = std::int8_t

Signed 8-bit integer.

using pipeline_id = uint32

Identifier for a compiled graphic pipeline.

using size_t = std::size_t

Platform-native size type.

using uint16 = std::uint16_t

Unsigned 16-bit integer.

using uint32 = std::uint32_t

Unsigned 32-bit integer.

using uint64 = std::uint64_t

Unsigned 64-bit integer.

using uint8 = std::uint8_t

Unsigned 8-bit integer.

using unique_id = int64

Opaque unique resource identifier.

Enumeration Type Documentation

enum class AmbientOcclusionType : uint8

strong

Type of ambient occlusion algorithm

Enum Values	Documentation
NONE
SSAO
GTAO

enum class AnimationInterpolation : uint8

strong

Interpolation type to apply when calculating animation values

Enum Values	Documentation
LINEAR	The animated values are linearly interpolated between keyframes.
STEP	The animated values remain constant to the output of the first keyframe, until the next keyframe.

enum class AnimationLoopMode : uint8

strong

Animation loop mode

Enum Values	Documentation
NONE	No loop (default)
LINEAR	Restart from the start of the track

enum class AnimationType : uint8

strong

Animation type for an animation track

Enum Values	Documentation
TRANSLATION	The values are the translation along the X, Y, and Z axes.
ROTATION	The values are a quaternion in the order x, y, z, w where w is the scalar.
SCALE	The values are scaling factors along the X, Y, and Z axes.

enum class CombineMode

strong

Enum Values	Documentation
AVERAGE
MIN
MAX
MULTIPLY

enum class DirectoryEntryType : uint8

strong

Type of an entry reported by VirtualFS::forEachDirectoryEntry()

Enum Values	Documentation
FILE
DIRECTORY

enum class DrawPrimType : uint32

strong

Primitive type tag stored in each DrawParam, used by the GPU to select the correct pipeline.

Enum Values	Documentation
LINE_LIST	Disconnected line segments (one segment per pair of vertices).
LINE_STRIP	Connected polyline (one segment between each consecutive vertex pair).
TRI_PLAIN	Solid-color filled triangle.
TRI_IMAGE	Textured quad (two triangles) sampled from a bound image.
TRI_GLYPH	SDF/MSDF glyph quad sampled from a font atlas.

enum class FrameScalingType : uint8

strong

Frame scaling algorithm applied between the in-scene vector rendering and the UI rendering

Enum Values	Documentation
NONE
BILINEAR
AMD_FSR_1

enum class FrameSharpeningType : uint8

strong

Frame sharpening applied after the frame scaling

Enum Values	Documentation
NONE
AMD_FSR_1

enum class GamepadAxis : uint8

strong

Gamepad axis & triggers

Enum Values	Documentation
LEFT_X	Left stick/joystick X.
LEFT_Y	Left stick/joystick Y.
RIGHT_X	Right stick/joystick X.
RIGHT_Y	Right stick/joystick Y.
LEFT_TRIGGER
RIGHT_TRIGGER
LAST

enum class GamepadAxisJoystick : uint8

strong

Gamepad thumbs joysticks

Enum Values	Documentation
LEFT	Left stick/joystick.
RIGHT	Right stick/joystick.

enum class GamepadButton : uint8

strong

Gamepas buttons

Enum Values	Documentation
A	A or X.
CROSS	A or X.
B	B or ○.
CIRCLE	B or ○.
X	X or □.
SQUARE	X or □.
Y	Y or △.
TRIANGLE	Y or △.
LB	Left shoulder/bumper.
L1	Left shoulder/bumper.
RB	Right shoulder/bumper.
R1	Right shoulder/bumper.
BACK	Back/Share.
SHARE	Back/Share.
START	Start/Menu.
MENU	Start/Menu.
LT	Left trigger.
L2	Left trigger.
RT	Right trigger.
R2	Right trigger.
DPAD_UP	Directional hat ↑.
DPAD_RIGHT	Directional hat →.
DPAD_DOWN	Directional hat ↓.
DPAD_LEFT	Directional hat ←.
LAST

enum class InputActionEntryType

strong

Source device type for this entry.

Enum Values	Documentation
KEYBOARD
MOUSE
GAMEPAD

enum class InputEventType : uint8

strong

Source of an input event

Enum Values	Documentation
KEY	A key have been pressed or released.
MOUSE_MOTION	The mouse cursor moved.
MOUSE_BUTTON	A mouse button have been pressed or released.
GAMEPAD_BUTTON	A gamepad button have been pressed or released.
TEXT_INPUT	User input.

enum Key : uint32

Key codes, QWERTY layout to keep the WASD keys

Enum Values	Documentation
KEY_NONE
KEY_SPACE	Space.
KEY_DASH
KEY_PIPE	\|
KEY_APOSTROPHE	'
KEY_COMMA	,
KEY_PERIOD	$.
KEY_QUESTIONMARK	?
KEY_0	0
KEY_1	1
KEY_2	2
KEY_3	3
KEY_4	4
KEY_5	5
KEY_6	6
KEY_7	7
KEY_8	8
KEY_9	9
KEY_SEMICOLON	;
KEY_EQUAL	=
KEY_A	A.
KEY_B	B.
KEY_C	C.
KEY_D	D.
KEY_E	E.
KEY_F	F.
KEY_G	G.
KEY_H	H.
KEY_I	I.
KEY_J	J.
KEY_K	K.
KEY_L	L.
KEY_M	M.
KEY_N	N.
KEY_O	O.
KEY_P	P.
KEY_Q	Q.
KEY_R	R.
KEY_S	S.
KEY_T	T.
KEY_U	U.
KEY_V	V.
KEY_W	W.
KEY_X	X.
KEY_Y	Y.
KEY_Z	Z.
KEY_LEFT_BRACKET	[
KEY_BACKSLASH	backslash
KEY_RIGHT_BRACKET	]
KEY_GRAVE_ACCENT
KEY_ESCAPE	ESC.
KEY_ENTER	⏎
KEY_TAB	Tabulation.
KEY_BACKSPACE	back space
KEY_INSERT	Insert.
KEY_DELETE	Delete.
KEY_RIGHT	→
KEY_LEFT	←
KEY_DOWN	↓
KEY_UP	↑
KEY_PAGE_UP	Page ↑.
KEY_PAGE_DOWN	Page ↓.
KEY_HOME	Home/Start.
KEY_END	End.
KEY_CAPS_LOCK	Left caps lock.
KEY_SCROLL_LOCK	Scroll lock.
KEY_NUM_LOCK	Numeric keypad lock.
KEY_PRINT_SCREEN	Print.
KEY_PAUSE	Pause.
KEY_F1	F1.
KEY_F2	F2.
KEY_F3	F3.
KEY_F4	F4.
KEY_F5	F5.
KEY_F6	F6.
KEY_F7	F7.
KEY_F8	F8.
KEY_F9	F9.
KEY_F10	F10.
KEY_F11	F11.
KEY_F12	F12.
KEY_KP_0	Keypad 0.
KEY_KP_1	Keypad 1.
KEY_KP_2	Keypad 2.
KEY_KP_3	Keypad 3.
KEY_KP_4	Keypad 4.
KEY_KP_5	Keypad 5.
KEY_KP_6	Keypad 6.
KEY_KP_7	Keypad 7.
KEY_KP_8	Keypad 8.
KEY_KP_9	Keypad 9.
KEY_KP_PERIOD	Keypad .
KEY_KP_DIVIDE	Keypad /.
KEY_KP_MULTIPLY	Keypad *.
KEY_KP_SUBTRACT	Keypad -.
KEY_KP_ADD	Keypad +.
KEY_KP_ENTER	Keypad ⏎.
KEY_KP_EQUAL	Keypad =.
KEY_LEFT_SHIFT	Left Shift.
KEY_LEFT_CONTROL	Left Control.
KEY_LEFT_ALT	Left Alt.
KEY_LEFT_SUPER	Left Super/Windows.
KEY_RIGHT_SHIFT	Right Shift.
KEY_RIGHT_CONTROL	Right Control.
KEY_RIGHT_ALT	Right Alt.
KEY_RIGHT_SUPER	Right Super/Windows.

enum class KeyModifier : uint8

strong

Keyboard modifier keys

Enum Values	Documentation
SHIFT	Left & right shift keys.
CONTROL	Left & right control keys.
ALT	Left & right alt keys.
SUPER	Super/Windows key.

enum class LightType : int8

strong

Light type

Enum Values	Documentation
LIGHT_UNKNOWN	Unknown light type
LIGHT_DIRECTIONAL	Directional light
LIGHT_OMNI	Omni (point) light
LIGHT_SPOT	Spot light

enum LoggingMode : uint32

Where to log messages

Enum Values	Documentation
LOGGING_MODE_NONE	Disable logging.
LOGGING_MODE_WINDOW	Open an external Window (on the first screen if you have multiple screen) to display the log messages. Log message appearance in the Window can be deferred to the next frame if the log message is sent from a thread different from the main thread
LOGGING_MODE_FILE	Log the messages into a file named 'log.txt'
LOGGING_MODE_STDOUT	Log the messages to std::cout. WIN32 applications needs to be linked with `-mconsole`

enum class LogLevel : int32

strong

Log levels

Enum Values	Documentation
TRACE
DEBUG
INFO
GAME1
GAME2
GAME3
WARNING
ERROR
CRITICAL
INTERNAL

enum class MeshAlignment

strong

Horizontal alignment origin for procedural meshes vertex generation.

Enum Values	Documentation
CENTER	Origin at the horizontal center.
LEFT	Origin at the left edge (X = 0 is the left side)
RIGHT	Origin at the right edge (X = 0 is the right side)

enum class MouseButton : uint8

strong

Mouse buttons

Enum Values	Documentation
NONE
LEFT	Left.
RIGHT	Right.
MIDDLE	Middle.
WHEEL	Wheel. Pressed==true means rotated backward.

enum class MouseCursor : uint8

strong

Mouse cursors types

Enum Values	Documentation
ARROW	"Normal" arrow cursor
WAIT	Waiting cursor.
RESIZE_H	Horizontal resize cursor.
RESIZE_V	Vertical resize cursor.

enum class MouseMode : uint8

strong

Mouse visibility & capture mode

Enum Values	Documentation
VISIBLE	Makes the mouse cursor visible.
VISIBLE_CAPTURED	Confines the mouse cursor to the game Window, and make it visible.
HIDDEN	Makes the mouse cursor hidden.
HIDDEN_CAPTURED	Confines the mouse cursor to the game Window, and make it hidden.

enum class PhysicsEngineType

strong

Lists the available physics backends supported by the engine.

JOLT: Uses the Jolt Physics library.
PHYSX: Uses NVIDIA PhysX.

Enum Values	Documentation
JOLT
PHYSX

enum class PostProcessAntiAliasingType : uint8

strong

AA algorithm applied at the end of the post processing passes

Enum Values	Documentation
NONE
FXAA
SMAA

enum class RendererType : uint8

strong

Type of rendering path

Enum Values	Documentation
FORWARD
DEFERRED

enum class RenderingPhase

strong

Rendering stage for shader based materials and custom render passes

Enum Values	Documentation
AFTER_LIGHTING_PASS	During color passes : after deferred lighting pass and before TAA pass.
AFTER_COLOR_PASS	After all color passes and before OIT pass.
AFTER_TRANSPARENCY_PASS	After OIT pass (before bloom pass)
AFTER_BLOOM_PASS	After bloom pass (before post-processing passes)
AFTER_POSTPROCESSING_PASS	After post-processing passes pass (before post-processing AA passes)
AFTER_AA_PASS	After post-processing AA passes (before vector passes)
COUNT
DEFAULT

enum class RenderingWindowMode : uint32

strong

Rendering Window mode

Enum Values	Documentation
WINDOWED	A Window with a border and a title that can be minimized.
WINDOWED_MAXIMIZED	A maximized Window with a border and a title that can be minimized.
WINDOWED_FULLSCREEN	A maximized Window without a border and without a title.
FULLSCREEN	A full-screen Window. The screen resolution will be changed.

enum class SceneOperationType

strong

Enum Values	Documentation
ADD_INSTANCE
REMOVE_INSTANCE
UPDATE_INSTANCE
MOVE_PIPELINE_INSTANCE
ADD_LIGHT
REMOVE_LIGHT
SET_ENVIRONMENT

enum class TextAlignment

strong

Horizontal alignment of text relative to the position anchor.

Enum Values	Documentation
LEFT	left edge of the text
CENTER	horizontal center of the text
RIGHT	right edge of the text

enum class ToneMappingType : uint8

strong

Tonne mapping algorithm applied after all the post processing passes and before the vector renderers

Enum Values	Documentation
NONE
REINHARD
ACES

enum class TransitionType : uint8

strong

Easing curve applied to the normalized time [0,1] of a Tween.

Enum Values	Documentation
LINEAR
IN_QUAD
OUT_QUAD
IN_OUT_QUAD
SMOOTH
IN_CUBIC
OUT_CUBIC
IN_OUT_CUBIC
IN_BACK
OUT_BACK

enum class Transparency

strong

A Material transparency mode Any transparency mode other than Transparency::DISABLED has a greater performance impact compared to opaque rendering.

Enum Values	Documentation
DISABLED	The material will not use transparency. This is the fastest to render.
ALPHA	The material will use the texture's alpha values for transparency.

Function Documentation

float2 lysa::add	(	const float2 &	a,
		const float2 &	b
	)

float3 lysa::add	(	const float3 &	a,
		const float3 &	b
	)

float4 lysa::add	(	const float4 &	a,
		const float4 &	b
	)

bool lysa::almost_equals	(	const float	f1,
		const float	f2
	)

inline

Compare two floating-point values with a relative tolerance.

Uses max(abs(a), abs(b)) scaled by 1e-4 as tolerance.

Parameters

f1	First value.
f2	Second value.

Returns: true if the values are approximately equal; false otherwise.

bool lysa::almost_equals	(	const quaternion &	f1,
		const quaternion &	f2
	)

inline

Approximate equality for quaternions.

Each component is compared using almostEquals(float, float).

Parameters

f1	First quaternion.
f2	Second quaternion.

Returns: true if all components are approximately equal; false otherwise.

constexpr void lysa::assert	(	Expr &&	,
		const std::string_view	,
		const std::source_location &	= `std::source_location::current()`
	)

constexprnoexcept

No-op placeholder for release builds.

constexpr Context& lysa::ctx ( )

constexpr

bool lysa::dir_exists ( const std::string & dirName )

Tests whether a directory exists at the given path.

Parameters

dirName OS path to check.

Returns: True if the directory exists; false otherwise.

float3 lysa::euler_angles ( quaternion q )

Convert a unit quaternion to Euler angles (XYZ order).

The returned angles are in radians and follow the conventional pitch (X), yaw (Y), roll (Z) ordering.

Parameters

q	Input quaternion. It does not need to be normalized; the function normalizes it internally.

Returns: float3 containing {pitch, yaw, roll} in radians.

Note: Angles are wrapped to the principal values typically produced by atan2/asin and may exhibit gimbal lock at +/- 90 degrees pitch.

float lysa::get_current_time_milliseconds ( )

Returns the current time in milliseconds.

Returns: Elapsed time in milliseconds as a floating‑point value.

std::string lysa::get_locale ( )

Returns the current user/system locale name.

The result uses the hyphen notation (e.g. "fr", "fr-FR", "en-US"), with any encoding or modifier suffix removed (e.g. "fr_FR.UTF-8" becomes "fr-FR"). Falls back to "en" if the locale cannot be determined.

Returns: Locale name.

float lysa::halton_sequence	(	const uint32	index,
		const uint32	base
	)

Returns a number in a halton sequence

https://en.wikipedia.org/wiki/Halton_sequence

consteval bool lysa::is_windows ( )

float4x4 lysa::look_at	(	const float3 &	eye,
		const float3 &	center,
		const float3 &	up
	)

Build a right-handed look-at view matrix.

Parameters

eye	Camera position in world space.
center	Target point the camera looks at.
up	World up direction.

Returns: 4x4 view matrix.

float2 lysa::mul	(	const float	a,
		const float2 &	b
	)

float3 lysa::mul	(	const float	a,
		const float3 &	b
	)

float4 lysa::mul	(	const float	a,
		const float4 &	b
	)

float2 lysa::mul	(	const float2 &	a,
		const float	b
	)

float2 lysa::mul	(	const float2 &	a,
		const float2 &	b
	)

float3 lysa::mul	(	const float3 &	a,
		const float	b
	)

float3 lysa::mul	(	const float3 &	a,
		const float3 &	b
	)

float4 lysa::mul	(	const float4 &	a,
		const float	b
	)

float4 lysa::mul	(	const float4 &	a,
		const float4 &	b
	)

float4x4 lysa::orthographic	(	float	left,
		float	right,
		float	top,
		float	bottom,
		float	znear,
		float	zfar
	)

Build a right-handed orthographic projection matrix.

Parameters

left	Left plane.
right	Right plane.
top	Top plane.
bottom	Bottom plane.
znear	Near clipping plane.
zfar	Far clipping plane.

Returns: 4x4 orthographic projection matrix.

float4x4 lysa::perspective	(	float	fov,
		float	aspect,
		float	near,
		float	far
	)

Build a right-handed perspective projection matrix.

Parameters

fov	Vertical field of view in radians.
aspect	Aspect ratio (width/height).
near	Near clipping plane distance (> 0).
far	Far clipping plane distance (> near).

Returns: 4x4 projection matrix.

float lysa::radians ( const float angle )

Convert a scalar angle in degrees to radians.

Convenience overload that forwards to the vectorized version.

Parameters

angle Angle in degrees.

Returns: Angle in radians.

float lysa::randomf ( float max )

Generate a random float in [0.0f, max].

Parameters

max	Inclusive upper bound.

Returns: Pseudo-random value uniformly distributed in [0.0f, max].

uint32 lysa::randomi ( uint32 max )

Generate a random unsigned integer in [0, max].

Parameters

max	Inclusive upper bound.

Returns: Pseudo-random value uniformly distributed in [0, max].

std::optional<RayHit> lysa::ray_triangle	(	const Ray &	ray,
		const float3 &	v0,
		const float3 &	v1,
		const float3 &	v2
	)

Ray vs triangle intersection

Parameters

ray	World-space ray origin and direction (does not need to be normalized, but `t` is expressed in units of `dir`'s magnitude).
v0	First triangle vertex in world space.
v1	Second triangle vertex in world space (counter-clockwise order).
v2	Third triangle vertex in world space (counter-clockwise order).
distance	[out] intersection distance
tnormal	[out] intersection face normal vector

Returns: True intersection point

std::string lysa::sanitize_name ( const std::string & name )

Produces a sanitized version of a name suitable for identifiers or paths.

Typical sanitization removes or replaces characters that are not alphanumeric, underscore, hyphen or dot, and collapses whitespace.

Parameters

name	Input name to sanitize.

Returns: A sanitized, ASCII‑safe string.

std::vector<std::string_view> lysa::split	(	std::string_view	str,
		char	delimiter
	)

Splits a string view into sub‑views using a single‑character delimiter.

The returned views reference the original memory in str; no allocations are performed for the tokens themselves. Callers must ensure that the lifetime of the original string outlives the returned views.

Consecutive delimiters yield empty tokens.

Parameters

str	Source string view to split.
delimiter	Delimiter character (e.g., ',').

Returns: Vector of string_view tokens pointing into str.

float2 lysa::sub	(	const float2 &	a,
		const float2 &	b
	)

float3 lysa::sub	(	const float3 &	a,
		const float3 &	b
	)

float4 lysa::sub	(	const float4 &	a,
		const float4 &	b
	)

float3 lysa::to_float3 ( const std::string & str )

Parses a float3 from a textual representation.

Expected formats typically include:

"x y z"
"x,y,z"

Parameters

str	Input string containing three floating‑point numbers.

Returns: Parsed float3 value; undefined behavior if the format is invalid.

float4 lysa::to_float4 ( const std::string & str )

Parses a float4 from a textual representation.

Expected formats typically include:

"x y z w"
"x,y,z,w"

Parameters

str	Input string containing four floating‑point numbers.

Returns: Parsed float4 value; undefined behavior if the format is invalid.

std::string lysa::to_hexstring ( const void * ptr )

Returns a hexadecimal textual representation of a memory address.

Parameters

ptr	Pointer value to format.

Returns: Hex string for ptr.

std::string lysa::to_hexstring ( uint32 ptr )

Returns a hexadecimal textual representation of an integer value.

Parameters

ptr	Integer value to format in hex.

Returns: Hex string for the input value.

std::string lysa::to_lower ( const std::string & str )

Returns a lowercase copy of the input ASCII/UTF‑8 string.

Locale‑dependent rules may not be applied; intended for identifiers and case‑insensitive comparisons in engine code.

Parameters

str	Source string.

Returns: Lowercased copy of str.

quaternion lysa::to_quaternion ( const float4x4 & m )

Extract a quaternion from a 4x4 rotation matrix.

Converts the upper-left 3x3 rotation part of the 4x4 matrix into a unit quaternion.

Parameters

m	Input 4x4 matrix.

Returns: Unit quaternion representing the rotation.

std::string lysa::to_string ( const float2 & vec )

Returns a human‑readable string for a float2.

Parameters

vec	Vector to print.

Returns: String representation of vec.

std::string lysa::to_string ( const float3 & vec )

Returns a human‑readable string for a float3.

Parameters

vec	Vector to print.

Returns: String representation of vec.

std::string lysa::to_string ( const float4 & vec )

Returns a human‑readable string for a float4.

Parameters

vec	Vector to print.

Returns: String representation of vec.

std::string lysa::to_string ( const quaternion & vec )

Returns a human‑readable string for a quaternion (x, y, z, w order).

Parameters

vec	Quaternion to print.

Returns: String representation of vec.

std::string lysa::to_string ( const wchar_t * wstr )

Converts a wide‑character C‑string to a UTF‑8 std::string.

Parameters

wstr	Null‑terminated wide string.

Returns: UTF‑8 encoded string.

std::u32string lysa::to_utf32 ( const std::string & utf8 )

Converts a UTF‑8 string to UTF‑32 (char32_t) string.

Parameters

utf8	Source string encoded in UTF‑8.

Returns: UTF‑32 string (UCS‑4 code points).

void lysa::vireoDebugCallback	(	vireo::DebugLevel	level,
		const std::string &	message
	)

Default Vireo RHI debug callback — forwards messages to the engine log system.

Variable Documentation

const float3 AXIS_BACK = {0.0f, 0.0f, 1.0f}

BACK Axis

const float3 AXIS_DOWN = {0.0f, -1.0f, 0.0f}

DOWN Axis

const float3 AXIS_FRONT = {0.0f, 0.0f, -1.0f}

FRONT Axis

const float3 AXIS_LEFT = {-1.0f, 0.0f, 0.0f}

LEFT Axis

const float3 AXIS_RIGHT = {1.0f, 0.0f, 0.0f}

RIGHT Axis

const float3 AXIS_UP = {0.0f, 1.0f, 0.0f}

UP Axis

const float3 AXIS_X {1.0f, 0.0f, 0.0f}

X Axis

const float3 AXIS_Y {0.0f, 1.0f, 0.0f}

Y Axis

const float3 AXIS_Z {0.0f, 0.0f, 1.0f}

Z Axis

const float3 DEFAULT_CLEAR_COLOR {0.0f, 0.0f, 0.0f}

Default clear color for windows and color frame buffers

constexpr pipeline_id DEFAULT_PIPELINE_ID {0}

constexpr

constexpr bool ENABLE_LOG = true

constexpr

Indicates at compile-time that logging is enabled.

const float2 FLOAT2ZERO {0.0f}

2D zero initialized vector

const float3 FLOAT3ZERO {0.0f}

3D zero initialized vector

const float4 FLOAT4ZERO {0.0f}

4D zero initialized vector

constexpr float HALF_PI = std::numbers::pi_v<float> / 2.0f

constexpr

constexpr unique_id INVALID_ID {-1}

constexpr

Sentinel value representing an absent or uninitialized identifier.

constexpr bool lua_bindings = false

constexpr

constexpr uint32 PHYSX_MAX_COLLISIONS_LAYERS {100}

constexpr

const quaternion QUATERNION_IDENTITY {0.0f, 0.0f, 0.0f, 1.0f}

Unit quaternion with no rotation

constexpr Rect RECT_FULLSCREEN {0.0f, 0.0f, -1.0f, -1.0f}

constexpr

const float3x3 TRANSFORM_BASIS {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}

The Basis of 3D transform. It is composed of 3 axes (Basis.x, Basis.y, and Basis.z). Together, these represent the transform's rotation, scale, and shear.

constexpr float VECTOR_2D_SCREEN_SIZE {1000.0f}

constexpr

The screen size (width & height) in units for the 2D vector renderer

Classes

Typedefs

Enums

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation