Namespaces
namespace	cpp20

namespace	cpp23

namespace	detail

namespace	graphics

namespace	literals

namespace	ui

Classes
struct	AABB

class	AABBGeometry

struct	AnalyticPlane

class	Angle

class	AntiAliasingLevel

class	App

struct	AppClock

class	AppMainLoopStatus

class	AppMetadata

class	AppSettings

struct	ArrowProperties

class	BookOfShadersTab

class	BoolLike

class	BoxGeometry

struct	BoxGeometryParams

class	BVH

struct	BVHCollision

class	BVHNode

class	BVHPrim

class	CachedSceneRenderer

class	Camera

struct	CameraClippingPlanes

class	CameraViewAxes

class	ChequeredTexture

struct	Circle

class	CircleGeometry

struct	CircleGeometryParams

class	CircularBuffer

class	Class

class	ClonePtr

struct	ClosedInterval

class	CloseTabEvent

struct	ColorHSLA

struct	ColorRenderBufferParams

class	ConeGeometry

struct	ConeGeometryParams

struct	Converter

struct	Converter< KeyModifiers, PhysicalKeyModifiers >

struct	Converter< osc::Color, SimTK::Vec3 >

struct	Converter< osc::EulerAngles, SimTK::Rotation >

struct	Converter< osc::EulerAngles, SimTK::Vec3 >

struct	Converter< osc::Matrix3x3, SimTK::Mat33 >

struct	Converter< osc::Quaternion, SimTK::Rotation >

struct	Converter< osc::Transform, SimTK::Transform >

struct	Converter< osc::Vector3, SimTK::fVec3 >

struct	Converter< osc::Vector3, SimTK::Inertia >

struct	Converter< osc::Vector3, SimTK::Vec3 >

struct	Converter< PhysicalKeyModifiers, KeyModifiers >

struct	Converter< SimTK::fVec3, osc::Vector3 >

struct	Converter< SimTK::Mat33, osc::Matrix3x3 >

struct	Converter< SimTK::Rotation, osc::EulerAngles >

struct	Converter< SimTK::Rotation, osc::Matrix4x4 >

struct	Converter< SimTK::Rotation, osc::Quaternion >

struct	Converter< SimTK::Transform, osc::Matrix4x4 >

struct	Converter< SimTK::Transform, osc::Transform >

struct	Converter< SimTK::UnitVec3, osc::Vector3 >

struct	Converter< SimTK::Vec3, osc::Vector3 >

struct	Converter< SimTK::Vec3, osc::Vector3d >

struct	Converter< SimTK::Vec6, std::array< float, 6 > >

struct	Converter< std::byte, Unorm8 >

struct	Converter< T, U >

struct	Converter< Unorm8, std::byte >

class	CookiecutterScreen

class	CookiecutterTab

class	CoordinateAxis

class	CoordinateDirection

class	CopyOnUpdPtr

class	CopyOnUpdSharedValue

class	CStringView

class	CSV

class	Cubemap

class	Cursor

class	CustomWidgetsTab

class	CylinderGeometry

struct	CylinderGeometryParams

class	DAE

struct	DAEMetadata

class	DefaultConstructOnCopy

struct	DegreesAngularUnitTraits

class	DenselyPackedOptionsIterable

struct	DepthStencilRenderBufferParams

struct	Disc

class	DisplayStateChangeEvent

class	DodecahedronGeometry

struct	DodecahedronGeometryParams

class	DrawingTestTab

class	DropFileEvent

struct	Ellipsoid

class	ErrorTab

struct	EulerPerspectiveCamera

class	Event

class	FileChangePoller

class	FileDialogFilter

class	FileDialogResponse

class	Flags

class	FrustumCullingTab

struct	FrustumPlanes

class	GraphicsContext

class	GridGeometry

struct	GridGeometryParams

class	GuiRuler

struct	Hasher

struct	Hasher< std::pair< T1, T2 > >

class	HittestTab

class	Icon

class	IconCache

class	IconWithMenu

class	IconWithoutMenu

class	IcosahedronGeometry

struct	IcosahedronGeometryParams

class	Image

class	ImGuiDemoTab

class	ImGuizmoDemoTab

class	ImPlotDemoTab

struct	IsScalar

struct	IsScalar< Angle< Rep, Units > >

struct	IsScalar< Snorm< T > >

struct	IsScalar< T >

struct	IsScalar< Unorm< T > >

class	JPEG

class	KeyCombination

class	KeyEvent

class	LatheGeometry

struct	LatheGeometryParams

class	LifetimedPtr

class	LifetimeWatcher

struct	LineSegment

class	Logger

class	LOGLBasicLightingTab

class	LOGLBlendingTab

class	LOGLBloomTab

class	LOGLCoordinateSystemsTab

class	LOGLCSMTab

class	LOGLCubemapsTab

class	LOGLDeferredShadingTab

class	LOGLFaceCullingTab

class	LOGLFramebuffersTab

class	LOGLGammaTab

class	LOGLHDRTab

class	LOGLHelloTriangleTab

class	LOGLLightingMapsTab

class	LOGLMultipleLightsTab

class	LOGLNormalMappingTab

class	LOGLParallaxMappingTab

class	LOGLPBRDiffuseIrradianceTab

class	LOGLPBRLightingTab

class	LOGLPBRLightingTexturedTab

class	LOGLPBRSpecularIrradianceTab

class	LOGLPBRSpecularIrradianceTexturedTab

class	LOGLPointShadowsTab

class	LOGLShadowMappingTab

class	LOGLSSAOTab

class	LOGLTexturingTab

class	LogMessage

class	LogMessageView

class	LogSink

class	LogViewer

class	LogViewerPanel

class	MandelbrotTab

class	Material

class	MaterialPropertyBlock

struct	Matrix

struct	Matrix< T, 3, 3 >

struct	Matrix< T, 4, 4 >

class	Mesh

class	MeshBasicMaterial

struct	MeshBasicMaterialParams

class	MeshBasicTexturedMaterial

struct	MeshBasicTexturedMaterialParams

class	MeshDepthWritingMaterial

class	MeshGenTestTab

class	MeshIndicesView

class	MeshNormalVectorsMaterial

class	MeshPhongMaterial

struct	MeshPhongMaterialParams

class	MouseCapturingCamera

class	MouseEvent

class	MouseWheelEvent

class	NativeFilesystem

class	Negative

class	Node

class	NodePath

struct	NonTypeAt

struct	NonTypeAt< NonTypelist< T, Head, Tails... >, 0 >

struct	NonTypeAt< NonTypelist< T, Head, Tails... >, Index >

struct	NonTypelist

struct	NonTypelist< T >

struct	NonTypelist< T, Head, Tails... >

struct	NonTypelistSize

struct	NonTypelistSize< NonTypelist< T, Els... > >

class	Normalized

class	NullOstream

class	NullStreambuf

class	OBJ

class	Object

class	ObjectPropertyEdit

struct	OBJMetadata

class	OctahedronGeometry

struct	OctahedronGeometryParams

class	OpenNamedPanelEvent

class	OpenPanelEvent

class	OpenPopupEvent

class	OpenTabEvent

struct	OptionList

class	OverlayFilesystem

struct	Overload

class	Panel

class	PanelManager

class	PanelPrivate

class	PerfMeasurement

class	PerfMeasurementMetadata

class	PerfPanel

struct	Plane

class	PlaneGeometry

struct	PlaneGeometryParams

class	PNG

struct	PolarPerspectiveCamera

class	PolyhedronGeometry

struct	PolyhedronGeometryParams

class	Popup

class	PopupManager

class	PopupPrivate

class	PropertyInfo

struct	Qua

class	QuitEvent

struct	RadianAngularUnitTraits

struct	Ray

struct	RayCollision

class	Rect

struct	RectCorners

class	RedoButton

class	RenderTarget

struct	RenderTargetColorAttachment

struct	RenderTargetDepthStencilAttachment

class	RenderTexture

struct	RenderTextureParams

class	ResetUIContextEvent

class	ResourceDirectoryEntry

class	ResourceLoader

class	ResourcePath

class	ResourceStream

struct	Rgb

struct	Rgba

class	RingGeometry

struct	RingGeometryParams

class	SaveChangesPopup

struct	SaveChangesPopupConfig

class	SceneCache

struct	SceneCollision

struct	SceneDecoration

class	SceneRenderer

struct	SceneRendererParams

class	SceneViewer

class	ScopedLifetime

class	ScopeExit

class	Screenshot

class	ScreenshotAnnotation

class	ScreenshotTab

class	Shader

class	SharedColorRenderBuffer

class	SharedDepthStencilRenderBuffer

class	SharedLifetimeBlock

class	SharedPreHashedString

class	Snorm

struct	Sphere

class	SphereGeometry

struct	SphereGeometryParams

class	SpscReceiver

class	SpscSender

class	SpscWorker

class	STL

struct	STLMetadata

class	StringName

class	SubMeshDemo

class	SubMeshDescriptor

class	SVG

class	SynchronizedValue

class	SynchronizedValueGuard

class	Tab

class	TabPrivate

class	TabRegistry

class	TabRegistryEntry

class	TabTestingScreen

class	TemporaryDirectory

struct	TemporaryDirectoryParameters

class	TemporaryFile

struct	TemporaryFileParameters

struct	Tetrahedron

class	TetrahedronGeometry

struct	TetrahedronGeometryParams

class	TextInputEvent

class	Texture2D

class	TorusGeometry

struct	TorusGeometryParams

class	TorusKnotGeometry

struct	TorusKnotGeometryParams

struct	Transform

struct	TransparentStringHasher

struct	Triangle

struct	TurnsAngularUnitTraits

struct	TypeAt

struct	TypeAt< Typelist< Head, Tails... >, 0 >

struct	TypeAt< Typelist< Head, Tails... >, Index >

class	TypeInfoReference

struct	Typelist

struct	Typelist< Head, Tails... >

struct	Typelist<>

struct	TypelistSize

struct	TypelistSize< Typelist< Types... > >

class	UID

class	UndoButton

class	UndoRedo

class	UndoRedoBase

class	UndoRedoEntry

class	UndoRedoEntryBase

class	UndoRedoPanel

class	Unorm

class	VariableLengthArray

class	Variant

struct	VariantTypeTraits

struct	VariantTypeTraits< VariantType::Bool >

struct	VariantTypeTraits< VariantType::Color >

struct	VariantTypeTraits< VariantType::Float >

struct	VariantTypeTraits< VariantType::Int >

struct	VariantTypeTraits< VariantType::None >

struct	VariantTypeTraits< VariantType::String >

struct	VariantTypeTraits< VariantType::StringName >

struct	VariantTypeTraits< VariantType::VariantArray >

struct	VariantTypeTraits< VariantType::Vector2 >

struct	VariantTypeTraits< VariantType::Vector3 >

class	Vector

class	VertexAttributeDescriptor

class	VertexFormat

class	VirtualFilesystem

class	Widget

class	WidgetPrivate

class	WidgetTestingScreen

class	WindowEvent

class	WindowID

class	WindowMenu

class	WireframeGeometry

Concepts
concept	AssociativeContainer

concept	AssociativeContainerKeyFor

concept	BitCastable

concept	ConvertibleToAnyOf

concept	DereferencesTo

concept	InputRangeWithSizeGreaterThan

concept	NamedInputStream

concept	ObjectRepresentationByte

concept	RangeWithSizeGreaterThan

concept	SameAsAnyOf

concept	ColorComponent

concept	MaterialPropertyValue

concept	AngularUnitTraits

concept	HasAbsFunction

concept	HasFloorFunction

concept	HasModFunction

concept	HasMinFunction

concept	HasMaxFunction

concept	HasClampFunction

concept	HasSaturateFunction

concept	HasLerpFunction

concept	LessThanComparable

concept	LessThanOrEqualToComparable

concept	HasMidpointFunction

concept	Scalar

concept	ScalarOrBoolean

concept	StandardRegisterableTab

concept	DenselyPackedOptionsEnum

concept	FlagsEnum

concept	Hashable

concept	OutputStreamable

concept	Undoable

concept	WatchableLifetime

Typedefs
using	ImageLoadingFlags = Flags< ImageLoadingFlag >

using	OBJWriterFlags = Flags< OBJWriterFlag >

using	BlitFlags = Flags< BlitFlag >

using	CameraClearFlags = Flags< CameraClearFlag >

using	Color = Rgba< float >

using	Color24 = Rgb< Unorm8 >

using	Color32 = Rgba< Unorm8 >

using	SolidGeometries = Typelist< BoxGeometry, CircleGeometry, ConeGeometry, CylinderGeometry, DodecahedronGeometry, IcosahedronGeometry, OctahedronGeometry, RingGeometry, SphereGeometry, TetrahedronGeometry, TorusGeometry, TorusKnotGeometry >

using	MaterialPropertyValueTypes = Typelist< bool, Color, Color32, Cubemap, float, int, Matrix3x3, Matrix4x4, RenderTexture, SharedColorRenderBuffer, SharedDepthStencilRenderBuffer, Texture2D, Vector2, Vector3, Vector4 >

using	MeshUpdateFlags = Flags< MeshUpdateFlag >

using	SceneDecorationFlags = Flags< SceneDecorationFlag >

using	SceneDecorationShading = std::variant< Color, Material, std::pair< Material, MaterialPropertyBlock > >

using	Snorm8 = Snorm< int8_t >

using	Unorm8 = Unorm< uint8_t >

template<typename T >
using	RadiansT = Angle< T, RadianAngularUnitTraits >

using	Radians = RadiansT< float >

using	Radiansd = RadiansT< double >

template<typename T >
using	DegreesT = Angle< T, DegreesAngularUnitTraits >

using	Degrees = DegreesT< float >

using	Degreesd = DegreesT< double >

template<typename T >
using	TurnsT = Angle< T, TurnsAngularUnitTraits >

using	Turns = TurnsT< float >

using	Turnsd = TurnsT< double >

template<typename Units >
using	EulerAnglesIn = Vector< Units, 3 >

using	EulerAngles = EulerAnglesIn< Radians >

using	Matrix3x3 = Matrix< float, 3, 3 >

using	Matrix3x3f = Matrix< float, 3, 3 >

using	Matrix3x3d = Matrix< double, 3, 3 >

using	Matrix3x3i = Matrix< int, 3, 3 >

using	Matrix3x3z = Matrix< ptrdiff_t, 3, 3 >

using	Matrix3x3zu = Matrix< size_t, 3, 3 >

using	Matrix3x3u32 = Matrix< uint32_t, 3, 3 >

using	Matrix4x4 = Matrix< float, 4, 4 >

using	Matrix4x4f = Matrix< float, 4, 4 >

using	Matrix4x4d = Matrix< double, 4, 4 >

using	Matrix4x4i = Matrix< int, 4, 4 >

using	Matrix4x4z = Matrix< ptrdiff_t, 4, 4 >

using	Matrix4x4zu = Matrix< size_t, 4, 4 >

using	Matrix4x4u32 = Matrix< uint32_t, 4, 4 >

using	Quaternion = Qua< float >

using	Quaternionf = Qua< float >

using	Quaterniond = Qua< double >

using	Quaternioni = Qua< int >

using	Quaternionu32 = Qua< uint32_t >

using	Vector2 = Vector< float, 2 >

using	Vector2f = Vector< float, 2 >

using	Vector2d = Vector< double, 2 >

using	Vector2i = Vector< int, 2 >

using	Vector2z = Vector< ptrdiff_t, 2 >

using	Vector2uz = Vector< size_t, 2 >

using	Vector2u32 = Vector< uint32_t, 2 >

using	Vector3 = Vector< float, 3 >

using	Vector3f = Vector< float, 3 >

using	Vector3d = Vector< double, 3 >

using	Vector3i = Vector< int, 3 >

using	Vector3z = Vector< ptrdiff_t, 3 >

using	Vector3uz = Vector< size_t, 3 >

using	Vector3u32 = Vector< uint32_t, 3 >

using	Vector4 = Vector< float, 4 >

using	Vector4f = Vector< float, 4 >

using	Vector4d = Vector< double, 4 >

using	Vector4i = Vector< int, 4 >

using	Vector4z = Vector< ptrdiff_t, 4 >

using	Vector4uz = Vector< size_t, 4 >

using	Vector4u32 = Vector< uint32_t, 4 >

using	AppNanos = std::chrono::duration< AppClock::rep, std::nano >

using	AppMicros = std::chrono::duration< AppClock::rep, std::micro >

using	AppMillis = std::chrono::duration< AppClock::rep, std::milli >

using	AppSeconds = std::chrono::duration< AppClock::rep >

using	AppMinutes = std::chrono::duration< AppClock::rep, std::ratio< 60 > >

using	AppHours = std::chrono::duration< AppClock::rep, std::ratio< 3600 > >

using	KeyModifiers = Flags< KeyModifier >

using	PhysicalKeyModifiers = Flags< PhysicalKeyModifier >

using	PerfClock = std::chrono::steady_clock

template<typename TList , size_t Index>
using	TypeAtT = typename TypeAt< TList, Index >::type

template<typename TTypelist >
using	VariantOfTypelistElements = decltype(detail::to_variant(std::declval< TTypelist >()))

using	VariantTypeList = OptionList< VariantType, VariantType::None, VariantType::Bool, VariantType::Color, VariantType::Float, VariantType::Int, VariantType::String, VariantType::StringName, VariantType::Vector2, VariantType::Vector3, VariantType::VariantArray >

using	OscarDemosTypelist = Typelist< BookOfShadersTab, LOGLBloomTab, LOGLDeferredShadingTab, LOGLGammaTab, LOGLHDRTab, LOGLNormalMappingTab, LOGLParallaxMappingTab, LOGLPointShadowsTab, LOGLShadowMappingTab, LOGLSSAOTab, LOGLBlendingTab, LOGLCubemapsTab, LOGLFaceCullingTab, LOGLFramebuffersTab, LOGLCoordinateSystemsTab, LOGLHelloTriangleTab, LOGLTexturingTab, LOGLCSMTab, LOGLBasicLightingTab, LOGLLightingMapsTab, LOGLMultipleLightsTab, LOGLPBRDiffuseIrradianceTab, LOGLPBRLightingTab, LOGLPBRLightingTexturedTab, LOGLPBRSpecularIrradianceTab, LOGLPBRSpecularIrradianceTexturedTab, CustomWidgetsTab, DrawingTestTab, FrustumCullingTab, HittestTab, ImGuiDemoTab, ImPlotDemoTab, ImGuizmoDemoTab, MandelbrotTab, MeshGenTestTab, SubMeshDemo >

Enumerations
enum class	ImageLoadingFlag { None = 0 , FlipVertically = 1<<0 , TreatComponentsAsSpatialVectors = 1<<1 }

enum class	OBJWriterFlag { None = 0 , NoWriteNormals = 1<<0 , Default = None }

enum class	BlendingEquation : uint8_t { Add , Min , Max , NUM_OPTIONS , Default = Add }

enum class	BlitFlag { None = 0 , AlphaBlend = 1<<0 }

enum class	CameraClearFlag : uint8_t { None = 0 , SolidColor = 1<<0 , Depth = 1<<1 , All = SolidColor \| Depth , Default = SolidColor \| Depth }

enum class	CameraProjection { Perspective , Orthographic , NUM_OPTIONS , Default = Perspective }

enum class	ColorRenderBufferFormat { R8_UNORM , R8G8B8A8_UNORM , R8G8B8A8_SRGB , R16G16_SFLOAT , R16G16B16_SFLOAT , R16G16B16A16_SFLOAT , R32_SFLOAT , NUM_OPTIONS , Default = R8G8B8A8_SRGB , DefaultHDR = R16G16B16A16_SFLOAT }

enum class	ColorSpace { Linear , sRGB , NUM_OPTIONS }

enum class	CubemapFace { PositiveX , NegativeX , PositiveY , NegativeY , PositiveZ , NegativeZ , NUM_OPTIONS }

enum class	CullMode : uint8_t { Off , Front , Back , NUM_OPTIONS , Default = Off }

enum class	DepthFunction : uint8_t { Less , LessOrEqual , NUM_OPTIONS , Default = Less }

enum class	DepthStencilRenderBufferFormat { D24_UNorm_S8_UInt , D32_SFloat , NUM_OPTIONS , Default = D24_UNorm_S8_UInt }

enum class	DestinationBlendingFactor : uint8_t { One , Zero , SourceAlpha , OneMinusSourceAlpha , NUM_OPTIONS , Default = OneMinusSourceAlpha }

enum class	MeshTopology { Triangles , Lines , NUM_OPTIONS , Default = Triangles }

enum class	MeshUpdateFlag { None = 0 , DontValidateIndices = 1<<0 , DontRecalculateBounds = 1<<1 , Default = None }

enum class	RenderBufferLoadAction { Load , Clear , NUM_OPTIONS }

enum class	RenderBufferStoreAction { Resolve , DontCare , NUM_OPTIONS }

enum class	SceneDecorationFlag : unsigned { None = 0 , NoCastsShadows = 1<<0 , NoDrawInScene = 1<<1 , RimHighlight0 = 1<<2 , RimHighlight1 = 1<<3 , DrawWireframeOverlay = 1<<4 , NoSceneVolumeContribution = 1<<5 , CanBackfaceCull = 1<<6 , Default = None , WireframeOverlayedDefault = Default \| DrawWireframeOverlay , AnnotationElement = NoCastsShadows \| NoSceneVolumeContribution , OnlyWireframe = NoDrawInScene \| DrawWireframeOverlay , Hidden = NoCastsShadows \| NoDrawInScene , AllRimHighlightGroups = RimHighlight0 \| RimHighlight1 }

enum class	ShaderPropertyType { Float , Vector2 , Vector3 , Vector4 , Matrix3x3 , Matrix4x4 , Int , Bool , Sampler2D , SamplerCube , Unknown , NUM_OPTIONS }

enum class	SourceBlendingFactor : uint8_t { One , Zero , SourceAlpha , OneMinusSourceAlpha , NUM_OPTIONS , Default = SourceAlpha }

enum class	TextureComponentFormat { Uint8 , Float32 , NUM_OPTIONS }

enum class	TextureDimensionality { Tex2D , Cube , NUM_OPTIONS }

enum class	TextureFilterMode { Nearest , Linear , Mipmap , NUM_OPTIONS }

enum class	TextureFormat { R8 , RG16 , RGB24 , RGBA32 , RGFloat , RGBFloat , RGBAFloat , NUM_OPTIONS }

enum class	TextureWrapMode { Repeat , Clamp , Mirror , NUM_OPTIONS }

enum class	VertexAttribute { Position , Normal , Tangent , Color , TexCoord0 , NUM_OPTIONS }

enum class	VertexAttributeFormat { Float32x2 , Float32x3 , Float32x4 , Unorm8x4 , Snorm8x4 , NUM_OPTIONS }

enum class	AppSettingScope { System , User , NUM_OPTIONS }

enum class	CursorShape { Arrow , IBeam , ResizeAll , ResizeVertical , ResizeHorizontal , ResizeDiagonalNESW , ResizeDiagonalNWSE , PointingHand , Wait , Progress , Forbidden , Hidden , NUM_OPTIONS , Default = Arrow }

enum class	EventType { DropFile , KeyDown , KeyUp , TextInput , MouseButtonDown , MouseButtonUp , MouseMove , MouseWheel , DisplayStateChange , Quit , Window , Custom , NUM_OPTIONS }

enum class	WindowEventType { GainedMouseFocus , LostMouseFocus , GainedKeyboardFocus , LostKeyboardFocus , WindowClosed , WindowMoved , WindowResized , WindowDisplayScaleChanged , Unknown , NUM_OPTIONS }

enum class	Key { Tab , LeftArrow , RightArrow , UpArrow , DownArrow , PageUp , PageDown , Home , End , Insert , Delete , Backspace , Space , Return , Escape , Apostrophe , Comma , Minus , Period , Slash , Semicolon , Equals , LeftBracket , Backslash , RightBracket , Grave , CapsLock , ScrollLock , NumLockClear , PrintScreen , Pause , Keypad0 , Keypad1 , Keypad2 , Keypad3 , Keypad4 , Keypad5 , Keypad6 , Keypad7 , Keypad8 , Keypad9 , KeypadPeriod , KeypadDivide , KeypadMultiply , KeypadMinus , KeypadPlus , KeypadEnter , KeypadEquals , LeftCtrl , LeftShift , LeftAlt , LeftGui , RightCtrl , RightShift , RightAlt , RightGui , Application , _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9 , A , B , C , D , E , F , G , H , I , J , K , L , M , N , O , P , Q , R , S , T , U , V , W , X , Y , Z , F1 , F2 , F3 , F4 , F5 , F6 , F7 , F8 , F9 , F10 , F11 , F12 , F13 , F14 , F15 , F16 , F17 , F18 , F19 , F20 , F21 , F22 , F23 , F24 , AppBack , AppForward , Unknown , NUM_OPTIONS }

enum class	KeyModifier : uint16_t { None = 0 , Shift = 1<<0 , Ctrl = 1<<1 , Meta = 1<<2 , Alt = 1<<3 , NUM_FLAGS = 4 }

enum class	LogLevel { trace = 0 , debug , info , warn , err , critical , off , NUM_OPTIONS , DEFAULT = info }

enum class	MouseButton : unsigned { None = 0 , Left = 1<<0 , Right = 1<<1 , Middle = 1<<2 , Back = 1<<3 , Forward = 1<<4 }

enum class	MouseInputSource { Mouse , TouchScreen }

enum class	PhysicalKeyModifier : uint16_t { None = 0 , Shift = 1<<0 , Ctrl = 1<<1 , Meta = 1<<2 , Alt = 1<<3 , NUM_FLAGS = 4 }

enum class	ToggleablePanelFlags : uint32_t { None = 0u , IsEnabledByDefault = 1u<<0u , IsSpawnable = 1u<<1u , Default = IsEnabledByDefault }

enum class	TabSaveResult { Done , Cancelled }

enum class	VariantType { None , Bool , Color , Float , Int , String , StringName , Vector2 , Vector3 , VariantArray , NUM_OPTIONS }

Functions
bool	operator== (const Class &, const Class &)

std::ostream &	operator<< (std::ostream &, const Object &)

std::ostream &	operator<< (std::ostream &, AntiAliasingLevel)

bool	operator== (const Camera &, const Camera &)

std::ostream &	operator<< (std::ostream &, const Camera &)

std::ostream &	operator<< (std::ostream &, CameraProjection)

float	to_linear_colorspace (float srgb_component_value)

float	to_srgb_colorspace (float linear_component_value)

Color	to_linear_colorspace (const Color &)

Color	to_srgb_colorspace (const Color &)

std::string	to_html_string_rgba (const Color &)

std::optional< Color >	try_parse_html_color_string (std::string_view)

Color	multiply_luminance (const Color &color, float factor)

template<std::integral T>
constexpr T	to_integer (const Color32 &color32)

std::ostream &	operator<< (std::ostream &, const ColorHSLA &)

constexpr bool	is_srgb_encoded (ColorRenderBufferFormat format)

std::ostream &	operator<< (std::ostream &, ColorRenderBufferFormat)

std::ostream &	operator<< (std::ostream &, DepthStencilRenderBufferFormat)

std::ostream &	operator<< (std::ostream &, const Material &)

bool	operator== (const MaterialPropertyBlock &, const MaterialPropertyBlock &)

std::ostream &	operator<< (std::ostream &, const MaterialPropertyBlock &)

std::ostream &	operator<< (std::ostream &, const Mesh &)

Vector3	mass_center_of (const Mesh &)

Vector3	average_centroid_of (const Mesh &)

std::vector< Vector4 >	calc_tangent_vectors (const MeshTopology &, std::span< const Vector3 > vertices, std::span< const Vector3 > normals, std::span< const Vector2 > tex_coords, const MeshIndicesView &)

std::optional< Sphere >	bounding_sphere_of (const Mesh &)

std::ostream &	operator<< (std::ostream &, MeshTopology)

std::ostream &	operator<< (std::ostream &, const RenderTexture &)

std::ostream &	operator<< (std::ostream &, const RenderTextureParams &)

template<size_t I, typename T >
constexpr const T &	get (const Rgb< T > &v)

template<size_t I, typename T >
constexpr T &	get (Rgb< T > &v)

template<size_t I, typename T >
constexpr T &&	get (Rgb< T > &&v)

template<size_t I, typename T >
constexpr const T &&	get (const Rgb< T > &&v)

template<ColorComponent T>
std::ostream &	operator<< (std::ostream &o, const Rgba< T > &rgba)

template<ColorComponent T>
constexpr const T *	value_ptr (const Rgba< T > &rgba)

template<ColorComponent T>
constexpr T *	value_ptr (Rgba< T > &rgba)

template<size_t I, ColorComponent T>
constexpr const T &	get (const Rgba< T > &rgba)

template<size_t I, ColorComponent T>
constexpr T &	get (Rgba< T > &rgba)

template<size_t I, ColorComponent T>
constexpr T &&	get (Rgba< T > &&rgba)

template<size_t I, ColorComponent T>
constexpr const T &&	get (const Rgba< T > &&rgba)

template<ColorComponent T, std::invocable< const T & > UnaryOperation>
constexpr auto	map (const Rgba< T > &x, UnaryOperation op) -> Rgba< decltype(std::invoke(op, x[0]))>

template<ColorComponent T, std::invocable< const T &, const T & > BinaryOperation>
constexpr auto	map (const Rgba< T > &x, const Rgba< T > &y, BinaryOperation op) -> Rgba< decltype(std::invoke(op, x[0], y[0]))>

template<ColorComponent T, typename TInterpolant >
constexpr auto	lerp (const Rgba< T > &x, const Rgba< T > &y, TInterpolant t)

template<ColorComponent T>
constexpr Rgba< T >	saturate (const Rgba< T > &x)

void	draw_bvh (SceneCache &, const BVH &, const std::function< void(SceneDecoration &&)> &out)

void	draw_aabb (SceneCache &, const AABB &, const std::function< void(SceneDecoration &&)> &out)

void	draw_aabbs (SceneCache &, std::span< const AABB >, const std::function< void(SceneDecoration &&)> &out)

void	draw_bvh_leaf_nodes (SceneCache &, const BVH &, const std::function< void(SceneDecoration &&)> &out)

void	draw_xz_floor_lines (SceneCache &, const std::function< void(SceneDecoration &&)> &out, float scale=5.0f)

void	draw_xz_grid (SceneCache &, const std::function< void(SceneDecoration &&)> &out)

void	draw_xy_grid (SceneCache &, const std::function< void(SceneDecoration &&)> &out)

void	draw_yz_grid (SceneCache &, const std::function< void(SceneDecoration &&)> &out)

void	draw_arrow (SceneCache &, const ArrowProperties &, const std::function< void(SceneDecoration &&)> &out)

void	draw_line_segment (SceneCache &, const LineSegment &, const Color &, float radius, const std::function< void(SceneDecoration &&)> &out)

void	update_scene_bvh (std::span< const SceneDecoration >, BVH &)

void	for_each_ray_collision_with_scene (const BVH &scene_bvh, SceneCache &, std::span< const SceneDecoration >, const Ray &world_space_ray, const std::function< void(SceneCollision &&)> &out)

std::vector< SceneCollision >	get_all_ray_collisions_with_scene (const BVH &scene_bvh, SceneCache &, std::span< const SceneDecoration >, const Ray &world_space_ray)

std::optional< RayCollision >	get_closest_world_space_ray_triangle_collision (const Mesh &, const BVH &triangle_bvh, const Transform &, const Ray &world_space_ray)

std::optional< RayCollision >	get_closest_world_space_ray_triangle_collision (const PolarPerspectiveCamera &, const Mesh &, const BVH &triangle_bvh, const Rect &screen_render_rect, Vector2 mouse_screen_position)

SceneRendererParams	calc_standard_dark_scene_render_params (const PolarPerspectiveCamera &, AntiAliasingLevel, Vector2 dimensions, float device_pixel_ratio)

BVH	create_triangle_bvh (const Mesh &)

FrustumPlanes	calc_frustum_planes (const Camera &camera, float aspect_ratio)

std::ostream &	operator<< (std::ostream &, const Shader &)

std::ostream &	operator<< (std::ostream &, ShaderPropertyType)

std::ostream &	operator<< (std::ostream &, const Texture2D &)

size_t	num_bytes_per_component_in (TextureComponentFormat)

std::ostream &	operator<< (std::ostream &, TextureFilterMode)

size_t	num_components_in (TextureFormat)

TextureComponentFormat	component_format_of (TextureFormat)

size_t	num_bytes_per_pixel_in (TextureFormat)

std::optional< TextureFormat >	to_texture_format (size_t num_components, TextureComponentFormat)

std::ostream &	operator<< (std::ostream &, TextureWrapMode)

template<std::unsigned_integral T>
std::ostream &	operator<< (std::ostream &o, const Unorm< T > &unorm)

template<std::unsigned_integral T, std::floating_point TInterpolant>
constexpr Unorm< T >	lerp (Unorm< T > a, Unorm< T > b, TInterpolant t)

template<std::unsigned_integral T>
constexpr Unorm< T >	saturate (const Unorm< T > &v)

std::ostream &	operator<< (std::ostream &, const AABB &)

constexpr Vector3	centroid_of (const AABB &aabb)

constexpr Vector3	dimensions_of (const AABB &aabb)

constexpr Vector3	half_widths_of (const AABB &aabb)

constexpr float	volume_of (const AABB &aabb)

constexpr bool	is_point (const AABB &aabb)

constexpr bool	has_zero_volume (const AABB &aabb)

std::array< Vector3, 8 >	corner_vertices_of (const AABB &aabb)

AABB	transform_aabb (const Matrix4x4 &m, const AABB &aabb)

AABB	transform_aabb (const Transform &t, const AABB &aabb)

constexpr AABB	bounding_aabb_of (const Vector3 &x)

constexpr AABB	bounding_aabb_of (const AABB &x, const Vector3 &y)

constexpr AABB	bounding_aabb_of (const AABB &x, const AABB &y)

constexpr AABB	bounding_aabb_of (const std::optional< AABB > &x, const AABB &y)

constexpr std::optional< AABB >	bounding_aabb_of (std::optional< AABB > x, std::optional< AABB > y)

template<std::ranges::input_range R, class Proj = std::identity> requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector3&>
constexpr std::optional< AABB >	bounding_aabb_of (R &&r, Proj proj={})

template<InputRangeWithSizeGreaterThan< 0 > R, class Proj = std::identity> requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector3&>
constexpr AABB	bounding_aabb_of (R &&r, Proj proj={})

template<std::ranges::input_range Range, class Proj = std::identity> requires std::convertible_to<typename std::projected<std::ranges::iterator_t<Range>, Proj>::value_type, const AABB&>
constexpr std::optional< AABB >	bounding_aabb_of (Range &&r, Proj proj={})

template<std::ranges::input_range Range, class Proj = std::identity> requires std::convertible_to<typename std::projected<std::ranges::iterator_t<Range>, Proj>::value_type, const std::optional<AABB>&>
	and (not std::convertible_to< typename std::projected< std::ranges::iterator_t< Range >, Proj >::value_type, const AABB & >) const expr std

std::optional< Rect >	loosely_project_into_ndc (const AABB &aabb, const Matrix4x4 &view_mat, const Matrix4x4 &proj_mat, float znear, float zfar)

std::ostream &	operator<< (std::ostream &, const AnalyticPlane &)

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
constexpr std::common_type_t< Angle< Rep1, Units1 >, Angle< Rep2, Units2 > >	operator+ (const Angle< Rep1, Units1 > &lhs, const Angle< Rep2, Units2 > &rhs)

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
constexpr std::common_type_t< Angle< Rep1, Units1 >, Angle< Rep2, Units2 > >	operator- (const Angle< Rep1, Units1 > &lhs, const Angle< Rep2, Units2 > &rhs)

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
constexpr bool	operator== (const Angle< Rep1, Units1 > &lhs, const Angle< Rep2, Units2 > &rhs)

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
constexpr auto	operator<=> (const Angle< Rep1, Units1 > &lhs, const Angle< Rep2, Units2 > &rhs)

template<std::floating_point Rep, AngularUnitTraits Units>
std::ostream &	operator<< (std::ostream &o, const Angle< Rep, Units > &angle)

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
auto	mod (Angle< Rep1, Units1 > x, Angle< Rep2, Units2 > y) -> std::common_type_t< decltype(x), decltype(y)>

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2> requires (not std::is_same_v<Units1, Units2>)
constexpr auto	min (Angle< Rep1, Units1 > x, Angle< Rep2, Units2 > y) -> std::common_type_t< decltype(x), decltype(y)>

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2> requires (not std::is_same_v<Units1, Units2>)
constexpr auto	max (Angle< Rep1, Units1 > x, Angle< Rep2, Units2 > y) -> std::common_type_t< decltype(x), decltype(y)>

template<std::floating_point Rep, AngularUnitTraits Units, std::convertible_to< Angle< Rep, Units > > AngleMin, std::convertible_to< Angle< Rep, Units > > AngleMax> requires ( not std::is_same_v<Angle<Rep, Units>, AngleMin> or not std::is_same_v<Angle<Rep, Units>, AngleMax> or not std::is_same_v<AngleMin, AngleMax> )
constexpr Angle< Rep, Units >	clamp (const Angle< Rep, Units > &v, const AngleMin &min, const AngleMax &max)

template<std::floating_point T>
constexpr ClosedInterval< T >	unit_interval ()

template<typename T >
constexpr ClosedInterval< T >	expand_by_absolute_amount (const ClosedInterval< T > &interval, T abs_amount)

template<typename T >
constexpr ClosedInterval< T >	bounding_interval_of (const T &x)

template<typename T >
constexpr ClosedInterval< T >	bounding_interval_of (const ClosedInterval< T > &x, const T &y)

template<typename T >
constexpr ClosedInterval< T >	bounding_interval_of (const std::optional< ClosedInterval< T > > &x, const T &y)

template<typename T >
constexpr ClosedInterval< T >	bounding_interval_of (const ClosedInterval< T > &x, const ClosedInterval< T > &y)

template<typename T >
constexpr ClosedInterval< T >	bounding_interval_of (const std::optional< ClosedInterval< T > > &x, const ClosedInterval< T > &y)

template<typename T >
constexpr const T &	clamp (const T &v, const ClosedInterval< T > &interval)

bool	is_intersecting (const Rect &, const Vector2 &)

bool	is_intersecting (const FrustumPlanes &, const AABB &)

std::optional< RayCollision >	find_collision (const Ray &, const Sphere &)

std::optional< RayCollision >	find_collision (const Ray &, const AABB &)

std::optional< RayCollision >	find_collision (const Ray &, const Plane &)

std::optional< RayCollision >	find_collision (const Ray &, const Disc &)

std::optional< RayCollision >	find_collision (const Ray &, const Triangle &)

template<std::signed_integral T>
T	abs (T num)

template<HasAbsFunction T, size_t N>
Vector< T, N >	abs (const Vector< T, N > &x)

template<std::floating_point T>
T	floor (T num)

template<HasFloorFunction T, size_t N>
Vector< T, N >	floor (const Vector< T, N > &x)

template<std::floating_point T>
T	copysign (T mag, T sgn)

template<std::integral T>
constexpr T	mod (T x, T y)

template<std::floating_point T>
T	mod (T x, T y)

template<HasModFunction T, size_t N>
constexpr Vector< T, N >	mod (const Vector< T, N > &x, const Vector< T, N > &y)

template<HasMinFunction T, size_t N>
constexpr Vector< T, N >	elementwise_min (const Vector< T, N > &x, const Vector< T, N > &y)

template<HasMaxFunction T, size_t N> requires std::is_arithmetic_v<T>
constexpr Vector< T, N >	elementwise_max (const Vector< T, N > &x, const Vector< T, N > &y)

template<HasClampFunction T, size_t N>
constexpr Vector< T, N >	elementwise_clamp (const Vector< T, N > &v, const Vector< T, N > &lo, const Vector< T, N > &hi)

template<HasClampFunction T, size_t N>
constexpr Vector< T, N >	elementwise_clamp (const Vector< T, N > &v, const T &lo, const T &hi)

template<std::floating_point T>
constexpr T	saturate (T num)

template<HasSaturateFunction T, size_t N>
constexpr Vector< T, N >	saturate (const Vector< T, N > &x)

template<typename Arithmetic1 , typename Arithmetic2 , typename Arithmetic3 > requires std::is_arithmetic_v<Arithmetic1>
and std::is_arithmetic_v< Arithmetic2 > and std::is_arithmetic_v< Arithmetic3 > constexpr auto	lerp (const Arithmetic1 &a, const Arithmetic2 &b, const Arithmetic3 &t)

template<typename T , size_t N, typename TInterpolant > requires HasLerpFunction<T, TInterpolant>
constexpr auto	lerp (const Vector< T, N > &x, const Vector< T, N > &y, const TInterpolant &t) -> Vector< decltype(lerp(x[0], y[0], t)), N >

template<std::equality_comparable T, size_t N>
constexpr Vector< bool, N >	elementwise_equal (const Vector< T, N > &x, const Vector< T, N > &y)

template<LessThanComparable T, size_t N>
constexpr Vector< bool, N >	elementwise_less (const Vector< T, N > &x, const Vector< T, N > &y)

template<LessThanComparable T, size_t N>
constexpr Vector< bool, N >	elementwise_less (const Vector< T, N > &x, const T &v)

template<LessThanOrEqualToComparable T, size_t N>
constexpr Vector< bool, N >	elementwise_less_equal (const Vector< T, N > &x, const Vector< T, N > &y)

template<typename T > requires HasAbsFunction<T>
and LessThanComparable< T > bool	equal_within_absdiff (T x, T y, T absdiff)

template<typename T , size_t N> requires HasAbsFunction<T>
and LessThanComparable< T > Vector< bool, N >	equal_within_absdiff (const Vector< T, N > &x, const Vector< T, N > &y, const Vector< T, N > &absdiff)

template<typename T , size_t N> requires HasAbsFunction<T>
and LessThanComparable< T > Vector< bool, N >	equal_within_absdiff (const Vector< T, N > &x, const Vector< T, N > &y, const T &absdiff)

template<std::floating_point T>
bool	equal_within_epsilon (T x, T y)

template<std::floating_point T, size_t N>
Vector< bool, N >	equal_within_epsilon (const Vector< T, N > &x, const Vector< T, N > &y)

template<std::floating_point T>
bool	equal_within_scaled_epsilon (T x, T y)

template<std::floating_point T>
bool	equal_within_reldiff (T x, T y, T reldiff)

template<std::floating_point T, size_t N>
Vector< bool, N >	equal_within_reldiff (const Vector< T, N > &x, const Vector< T, N > &y, T reldiff)

template<std::floating_point T>
bool	isnan (T num)

template<std::floating_point T, size_t N>
Vector< bool, N >	isnan (const Vector< T, N > &x)

template<std::floating_point T>
T	log (T num)

template<std::floating_point T>
T	pow (T base, T exp)

template<typename T > requires std::is_integral_v<T>
or std::is_floating_point_v< T > or std::is_pointer_v< T > constexpr T	midpoint (T a, T b)

template<typename T , size_t N>
Vector< T, N >	midpoint (const Vector< T, N > &x, const Vector< T, N > &y)

template<std::ranges::range R, typename T = typename std::ranges::range_value_t<R>::value_type, size_t N = std::tuple_size_v<typename std::ranges::range_value_t<R>>> requires std::is_arithmetic_v<T>
constexpr Vector< T, N >	centroid_of (const R &r)

template<typename T , size_t N> requires std::is_arithmetic_v<T>
constexpr Vector< T, N >	centroid_of (const std::initializer_list< Vector< T, N > > &vs)

std::ostream &	operator<< (std::ostream &, CoordinateAxis)

std::ostream &	operator<< (std::ostream &, CoordinateDirection)

constexpr CoordinateDirection	cross (CoordinateDirection x, CoordinateDirection y)

std::ostream &	operator<< (std::ostream &, const Disc &)

float	ease_out_elastic (float)

constexpr std::array< Vector3, 3 >	axis_directions_of (const Ellipsoid &ellipsoid)

template<typename T , size_t N, std::invocable< const T & > UnaryOperation>
constexpr auto	map (const Vector< T, N > &x, UnaryOperation op) -> Vector< decltype(std::invoke(op, x[0])), N >

template<typename T , size_t N, std::invocable< const T &, const T & > BinaryOperation>
constexpr auto	map (const Vector< T, N > &x, const Vector< T, N > &y, BinaryOperation op) -> Vector< decltype(std::invoke(op, x[0], y[0])), N >

template<typename T , size_t N, std::invocable< const T &, const T &, const T & > TernaryOperation>
constexpr auto	map (const Vector< T, N > &x, const Vector< T, N > &y, const Vector< T, N > &z, TernaryOperation op) -> Vector< decltype(std::invoke(op, x[0], y[0], z[0])), N >

template<size_t N>
constexpr bool	all_of (const Vector< bool, N > &v)

template<size_t N>
constexpr bool	any_of (const Vector< bool, N > &v)

template<size_t N>
constexpr bool	none_of (const Vector< bool, N > &v)

template<std::floating_point T>
T	sqrt (T num)

template<std::floating_point T>
T	inversesqrt (T x)

template<typename T > requires std::is_arithmetic_v<T>
constexpr T	dot (T x, T y)

template<typename T , size_t N> requires std::is_arithmetic_v<T>
constexpr T	dot (const Vector< T, N > &x, const Vector< T, N > &y)

template<typename T > requires std::is_arithmetic_v<T>
constexpr Vector< T, 3 >	cross (const Vector< T, 3 > &x, const Vector< T, 3 > &y)

template<std::floating_point T, size_t N>
T	length (const Vector< T, N > &v)

template<std::floating_point T, size_t N>
constexpr T	length2 (const Vector< T, N > &v)

template<std::floating_point T, size_t N>
Vector< T, N >	normalize (const Vector< T, N > &v)

template<std::integral T, std::floating_point FloatingPointResult = float>
constexpr FloatingPointResult	aspect_ratio_of (Vector< T, 2 > v)

template<std::floating_point T>
constexpr T	aspect_ratio_of (Vector< T, 2 > v)

template<typename T > requires std::is_arithmetic_v<T>
constexpr T	area_of (const Vector< T, 2 > &v)

std::ostream &	operator<< (std::ostream &, const LineSegment &)

Radians	vertical_to_horizontal_field_of_view (Radians vertical_field_of_view, float aspect_ratio)

Vector2	topleft_normalized_point_to_ndc (Vector2 normalized_point)

Vector2	ndc_point_to_topleft_normalized (Vector2 ndc_point)

Vector4	topleft_normalized_point_to_ndc_cube (Vector2 normalized_point)

Ray	perspective_unproject_topleft_normalized_pos_to_world (Vector2 normalized_point, Vector3 camera_world_space_origin, const Matrix4x4 &camera_view_matrix, const Matrix4x4 &camera_proj_matrix)

Rect	ndc_rect_to_topleft_viewport_rect (const Rect &ndc_rect, const Rect &viewport)

Vector2	project_onto_viewport_rect (const Vector3 &world_space_position, const Matrix4x4 &view_matrix, const Matrix4x4 &projection_matrix, const Rect &viewport_rect)

std::optional< Sphere >	bounding_sphere_of (std::span< const Vector3 >)

Sphere	bounding_sphere_of (const AABB &)

AABB	bounding_aabb_of (const Sphere &)

Ray	transform_ray (const Ray &, const Matrix4x4 &)

Ray	inverse_transform_ray (const Ray &, const Transform &)

Matrix4x4	matrix4x4_transform_between (const Disc &, const Disc &)

Matrix4x4	matrix4x4_transform_between (const LineSegment &, const LineSegment &)

Transform	transform_between (const LineSegment &, const LineSegment &)

Transform	cylinder_to_line_segment_transform (const LineSegment &, float radius)

Transform	y_to_y_cone_to_segment_transform (const LineSegment &, float radius)

Matrix4x4	matrix4x4_transform_between_directions (const Vector3 &dir1, const Vector3 &dir2)

EulerAngles	extract_eulers_xyz (const Quaternion &)

Vector3	transform_point (const Matrix4x4 &mat, const Vector3 &point)

Vector3	transform_vector (const Matrix4x4 &mat, const Vector3 &vector)

Quaternion	to_world_space_rotation_quaternion (const EulerAngles &)

void	apply_world_space_rotation (Transform &application_target, const EulerAngles &euler_angles, const Vector3 &rotation_center)

float	volume_of (const Tetrahedron &)

std::array< Matrix4x4, 6 >	calc_cubemap_view_proj_matrices (const Matrix4x4 &projection_matrix, Vector3 cube_center)

template<typename T , size_t C, size_t R>
std::ostream &	operator<< (std::ostream &o, const Matrix< T, C, R > &m)

template<typename T , size_t C, size_t R>
std::string	to_string (const Matrix< T, C, R > &m)

template<size_t I, typename T , size_t C, size_t R>
constexpr const Matrix< T, C, R >::value_type &	get (const Matrix< T, C, R > &m)

template<size_t I, typename T , size_t C, size_t R>
constexpr Matrix< T, C, R >::value_type &	get (Matrix< T, C, R > &m)

template<size_t I, typename T , size_t C, size_t R>
constexpr Matrix< T, C, R >::value_type &&	get (Matrix< T, C, R > &&m)

template<size_t I, typename T , size_t C, size_t R>
constexpr const Matrix< T, C, R >::value_type &&	get (const Matrix< T, C, R > &&m)

template<typename T >
Matrix< T, 3, 3 >	operator+ (const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >	operator- (const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >	operator+ (const Matrix< T, 3, 3 > &m, T scalar)

template<typename T >
Matrix< T, 3, 3 >	operator+ (T scalar, const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >	operator+ (const Matrix< T, 3, 3 > &m1, const Matrix< T, 3, 3 > &m2)

template<typename T >
Matrix< T, 3, 3 >	operator- (const Matrix< T, 3, 3 > &m, T scalar)

template<typename T >
Matrix< T, 3, 3 >	operator- (T scalar, const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >	operator- (const Matrix< T, 3, 3 > &m1, const Matrix< T, 3, 3 > &m2)

template<typename T >
Matrix< T, 3, 3 >	operator* (const Matrix< T, 3, 3 > &m, T scalar)

template<typename T >
Matrix< T, 3, 3 >	operator* (T scalar, const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >::column_type	operator* (const Matrix< T, 3, 3 > &m, const typename Matrix< T, 3, 3 >::row_type &v)

template<typename T >
Matrix< T, 3, 3 >::row_type	operator* (const typename Matrix< T, 3, 3 >::column_type &v, const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >	operator* (const Matrix< T, 3, 3 > &a, const Matrix< T, 3, 3 > &b)

template<typename T >
Matrix< T, 3, 3 >	operator/ (const Matrix< T, 3, 3 > &m, T scalar)

template<typename T >
Matrix< T, 3, 3 >	operator/ (T scalar, const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >::column_type	operator/ (const Matrix< T, 3, 3 > &m, const typename Matrix< T, 3, 3 >::row_type &v)

template<typename T >
Matrix< T, 3, 3 >::row_type	operator/ (const typename Matrix< T, 3, 3 >::column_type &v, const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 3, 3 >	operator/ (const Matrix< T, 3, 3 > &m1, const Matrix< T, 3, 3 > &m2)

template<typename T >
constexpr T	identity ()

template<>
constexpr Matrix3x3	identity< Matrix3x3 > ()

template<typename T >
Matrix< T, 4, 4 >	operator+ (const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >	operator- (const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >	operator+ (const Matrix< T, 4, 4 > &m, T scalar)

template<typename T >
Matrix< T, 4, 4 >	operator+ (T scalar, const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >	operator+ (const Matrix< T, 4, 4 > &m1, const Matrix< T, 4, 4 > &m2)

template<typename T >
Matrix< T, 4, 4 >	operator- (const Matrix< T, 4, 4 > &m, T scalar)

template<typename T >
Matrix< T, 4, 4 >	operator- (T scalar, const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >	operator- (const Matrix< T, 4, 4 > &m1, const Matrix< T, 4, 4 > &m2)

template<typename T >
Matrix< T, 4, 4 >	operator* (const Matrix< T, 4, 4 > &m, T scalar)

template<typename T >
Matrix< T, 4, 4 >	operator* (T scalar, const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >::column_type	operator* (const Matrix< T, 4, 4 > &m, const typename Matrix< T, 4, 4 >::row_type &v)

template<typename T >
Matrix< T, 4, 4 >::row_type	operator* (const typename Matrix< T, 4, 4 >::column_type &v, const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >	operator* (const Matrix< T, 4, 4 > &a, const Matrix< T, 4, 4 > &b)

template<typename T >
Matrix< T, 4, 4 >	operator/ (const Matrix< T, 4, 4 > &m, T scalar)

template<typename T >
Matrix< T, 4, 4 >	operator/ (T scalar, const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >::column_type	operator/ (const Matrix< T, 4, 4 > &m, const typename Matrix< T, 4, 4 >::row_type &v)

template<typename T >
Matrix< T, 4, 4 >::row_type	operator/ (const typename Matrix< T, 4, 4 >::column_type &v, const Matrix< T, 4, 4 > &m)

template<typename T >
Matrix< T, 4, 4 >	operator/ (const Matrix< T, 4, 4 > &m1, const Matrix< T, 4, 4 > &m2)

template<>
constexpr Matrix4x4	identity< Matrix4x4 > ()

template<std::floating_point T>
Matrix< T, 4, 4 >	look_at (const Vector< T, 3 > &eye, const Vector< T, 3 > &center, const Vector< T, 3 > &up)

template<std::floating_point T, AngularUnitTraits Units>
Matrix< T, 4, 4 >	perspective (Angle< T, Units > vertical_field_of_view, T aspect, T z_near, T z_far)

template<std::floating_point T>
Matrix< T, 4, 4 >	ortho (T left, T right, T bottom, T top, T z_near, T z_far)

template<typename T >
Matrix< T, 4, 4 >	scale (const Matrix< T, 4, 4 > &m, const Vector< T, 3 > &v)

template<std::floating_point T, AngularUnitTraits Units>
Matrix< T, 4, 4 >	rotate (const Matrix< T, 4, 4 > &m, Angle< T, Units > angle, Vector< T, 3 > axis)

template<typename T >
Matrix< T, 4, 4 >	translate (const Matrix< T, 4, 4 > &m, const Vector< T, 3 > &v)

template<std::floating_point T>
T	determinant_of (const Matrix< T, 3, 3 > &m)

template<std::floating_point T>
T	determinant_of (const Matrix< T, 4, 4 > &m)

template<std::floating_point T>
T	inverse (const Matrix< T, 3, 3 > &m)

template<std::floating_point T>
Matrix< T, 4, 4 >	inverse (const Matrix< T, 4, 4 > &m)

template<typename T >
constexpr Matrix< T, 3, 3 >	transpose (const Matrix< T, 3, 3 > &m)

template<typename T >
Matrix< T, 4, 4 >	transpose (const Matrix< T, 4, 4 > &m)

template<std::floating_point T>
Vector< RadiansT< T >, 3 >	extract_eulers_xyz (const Matrix< T, 4, 4 > &m)

template<typename T >
bool	decompose (const Matrix< T, 4, 4 > &model_matrix, Vector< T, 3 > &r_scale, Qua< T > &r_orientation, Vector< T, 3 > &r_translation, Vector< T, 3 > &r_skew, Vector< T, 4 > &r_perspective)

template<std::floating_point T>
constexpr Matrix< T, 3, 3 >	adjugate (const Matrix< T, 3, 3 > &m)

template<std::floating_point T>
Matrix< T, 3, 3 >	normal_matrix (const Matrix< T, 4, 4 > &m)

template<std::floating_point T>
Matrix< T, 4, 4 >	normal_matrix4x4 (const Matrix< T, 4, 4 > &m)

template<typename T , size_t C, size_t R>
constexpr const T *	value_ptr (const Matrix< T, C, R > &m)

template<typename T , size_t C, size_t R>
constexpr T *	value_ptr (Matrix< T, C, R > &m)

template<std::floating_point T>
std::ostream &	operator<< (std::ostream &out, const Normalized< T > &normalized_value)

std::ostream &	operator<< (std::ostream &, const Plane &)

constexpr AnalyticPlane	to_analytic_plane (const Vector3 &point, const Vector3 &normal)

constexpr AnalyticPlane	to_analytic_plane (const Plane &plane)

constexpr float	signed_distance_between (const AnalyticPlane &plane, const Vector3 &vector)

constexpr float	signed_distance_between (const Plane &plane, const Vector3 &vector)

bool	is_in_front_of (const AnalyticPlane &plane, const AABB &aabb)

bool	is_in_front_of (const Plane &plane, const AABB &aabb)

PolarPerspectiveCamera	create_camera_with_radius (float)

PolarPerspectiveCamera	create_camera_focused_on (const AABB &)

Vector3	recommended_light_direction (const PolarPerspectiveCamera &)

void	focus_along_axis (PolarPerspectiveCamera &, size_t, bool negate=false)

void	focus_along_x (PolarPerspectiveCamera &)

void	focus_along_minus_x (PolarPerspectiveCamera &)

void	focus_along_y (PolarPerspectiveCamera &)

void	focus_along_minus_y (PolarPerspectiveCamera &)

void	focus_along_z (PolarPerspectiveCamera &)

void	focus_along_minus_z (PolarPerspectiveCamera &)

void	zoom_in (PolarPerspectiveCamera &)

void	zoom_out (PolarPerspectiveCamera &)

void	reset (PolarPerspectiveCamera &)

void	auto_focus (PolarPerspectiveCamera &, const AABB &element_aabb, float aspect_ratio=1.0f)

template<typename T >
constexpr Qua< T >	operator+ (const Qua< T > &q)

template<typename T >
constexpr Qua< T >	operator- (const Qua< T > &q)

template<typename T >
constexpr Qua< T >	operator+ (const Qua< T > &q, const Qua< T > &p)

template<typename T >
constexpr Qua< T >	operator- (const Qua< T > &q, const Qua< T > &p)

template<typename T >
constexpr Qua< T >	operator* (const Qua< T > &q, const Qua< T > &p)

template<typename T >
constexpr Vector< T, 3 >	operator* (const Qua< T > &q, const Vector< T, 3 > &v)

template<typename T >
constexpr Vector< T, 3 >	operator* (const Vector< T, 3 > &v, const Qua< T > &q)

template<typename T >
constexpr Vector< T, 4 >	operator* (const Qua< T > &q, const Vector< T, 4 > &v)

template<typename T >
constexpr Vector< T, 4 >	operator* (const Vector< T, 4 > &v, const Qua< T > &q)

template<typename T >
constexpr Qua< T >	operator* (const Qua< T > &q, const T &s)

template<typename T >
constexpr Qua< T >	operator* (const T &s, const Qua< T > &q)

template<typename T >
constexpr Qua< T >	operator/ (const Qua< T > &q, const T &s)

template<typename T >
std::ostream &	operator<< (std::ostream &o, const Qua< T > &v)

template<typename T >
std::string	to_string (const Qua< T > &v)

template<size_t I, typename T >
constexpr const T &	get (const Qua< T > &v)

template<size_t I, typename T >
constexpr T &	get (Qua< T > &v)

template<size_t I, typename T >
constexpr T &&	get (Qua< T > &&v)

template<size_t I, typename T >
constexpr const T &&	get (const Qua< T > &&v)

template<>
constexpr Quaternion	identity< Quaternion > ()

template<std::floating_point T>
Vector< bool, 4 >	isnan (const Qua< T > &q)

template<typename T > requires std::is_arithmetic_v<T>
constexpr Qua< T >	conjugate (const Qua< T > &q)

template<typename T > requires std::is_arithmetic_v<T>
constexpr T	dot (const Qua< T > &a, const Qua< T > &b)

template<typename T > requires std::is_arithmetic_v<T>
constexpr Qua< T >	inverse (const Qua< T > &q)

template<typename T >
T	length (const Qua< T > &q)

template<std::floating_point T>
Qua< T >	normalize (const Qua< T > &q)

template<typename T >
Qua< T >	quaternion_cast (const Matrix< T, 3, 3 > &m)

template<typename T >
Qua< T >	quaternion_cast (const Matrix< T, 4, 4 > &m)

template<typename T >
constexpr Matrix< T, 3, 3 >	matrix3x3_cast (const Qua< T > &q)

template<typename T >
constexpr Matrix< T, 4, 4 >	matrix4x4_cast (const Qua< T > &q)

template<typename T >
constexpr Qua< T >	quaternion_identity ()

template<std::floating_point T, AngularUnitTraits Units, std::convertible_to< const Vector< T, 3 > & > VectorLike>
Qua< T >	angle_axis (Angle< T, Units > angle, VectorLike &&axis)

template<std::floating_point T, AngularUnitTraits Units>
Qua< T >	angle_axis (Angle< T, Units > angle, CoordinateDirection direction)

template<typename T >
Qua< T >	rotation (const Vector< T, 3 > &origin, const Vector< T, 3 > &destination)

template<typename T >
RadiansT< T >	pitch (const Qua< T > &q)

template<typename T >
RadiansT< T >	yaw (const Qua< T > &q)

template<typename T >
RadiansT< T >	roll (const Qua< T > &q)

template<typename T >
Vector< RadiansT< T >, 3 >	to_euler_angles (const Qua< T > &x)

std::ostream &	operator<< (std::ostream &, const Ray &)

std::ostream &	operator<< (std::ostream &, const Rect &)

float	aspect_ratio_of (const Rect &rect)

constexpr Rect	bounding_rect_of (const Vector2 &x)

Rect	bounding_rect_of (const Rect &x, const Vector2 &y)

Rect	bounding_rect_of (const Rect &x, const Rect &y)

template<std::ranges::input_range R, typename Proj = std::identity> requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector2&>
constexpr Rect	bounding_rect_of (R &&r, Proj proj={})

Rect	bounding_rect_of (const Circle &circle)

Rect	clamp (const Rect &, const Vector2 &min, const Vector2 &max)

std::ostream &	operator<< (std::ostream &, const Sphere &)

constexpr Vector3	operator* (const Transform &transform, Vector3 point)

template<>
constexpr Transform	identity< Transform > ()

std::ostream &	operator<< (std::ostream &out, const Transform &transform)

constexpr Matrix3x3	matrix3x3_cast (const Transform &transform)

constexpr Matrix4x4	matrix4x4_cast (const Transform &transform)

Matrix4x4	inverse_matrix4x4_cast (const Transform &transform)

constexpr Matrix3x3	normal_matrix (const Transform &transform)

constexpr Matrix4x4	normal_matrix_4x4 (const Transform &transform)

bool	try_decompose_to_transform (const Matrix4x4 &m, Transform &out)

Transform	decompose_to_transform (const Matrix4x4 &m)

Vector3	transform_vector (const Transform &transform, const Vector3 &vector)

Vector3	inverse_transform_vector (const Transform &transform, const Vector3 &vector)

constexpr Vector3	transform_point (const Transform &transform, const Vector3 &point)

constexpr Vector3	inverse_transform_point (const Transform &transform, Vector3 point)

EulerAngles	extract_eulers_xyz (const Transform &transform)

EulerAngles	extract_extrinsic_eulers_xyz (const Transform &transform)

Transform	point_axis_along (const Transform &transform, Vector3::size_type axis_index, const Vector3 &new_direction)

Transform	point_axis_towards (const Transform &transform, Vector3::size_type axis_index, const Vector3 &position)

Transform	rotate_axis (const Transform &transform, Vector3::size_type axis_index, Radians angle)

bool	any_element_is_nan (const Transform &transform)

template<typename T > requires std::is_arithmetic_v<T>
constexpr bool	can_form_triangle (const Vector< T, 3 > &a, const Vector< T, 3 > &b, const Vector< T, 3 > &c)

template<std::floating_point T>
Vector< T, 3 >	triangle_normal (const Vector< T, 3 > &a, const Vector< T, 3 > &b, const Vector< T, 3 > &c)

Vector< float, 3 >	triangle_normal (const Triangle &t)

template<std::floating_point GenType>
GenType	sin (GenType v)

template<std::floating_point Rep, AngularUnitTraits Units>
Rep	sin (Angle< Rep, Units > v)

template<std::floating_point T, size_t N>
Vector< T, N >	sin (const Vector< T, N > &v)

template<std::floating_point Rep, AngularUnitTraits Units, size_t N>
Vector< Rep, N >	sin (const Vector< Angle< Rep, Units >, N > &v)

template<std::floating_point GenType>
GenType	cos (GenType v)

template<std::floating_point Rep, AngularUnitTraits Units>
Rep	cos (Angle< Rep, Units > v)

template<std::floating_point T, size_t N>
Vector< T, N >	cos (const Vector< T, N > &v)

template<std::floating_point Rep, AngularUnitTraits Units, size_t N>
Vector< Rep, N >	cos (const Vector< Angle< Rep, Units >, N > &v)

template<std::floating_point GenType>
GenType	tan (GenType v)

template<std::floating_point Rep, AngularUnitTraits Units>
Rep	tan (Angle< Rep, Units > v)

template<std::floating_point T, size_t N>
Vector< T, N >	tan (const Vector< T, N > &v)

template<std::floating_point Rep, AngularUnitTraits Units, size_t N>
Vector< Rep, N >	tan (const Vector< Angle< Rep, Units >, N > &v)

template<std::floating_point Rep>
RadiansT< Rep >	atan (Rep v)

template<std::floating_point Rep>
RadiansT< Rep >	acos (Rep num)

template<std::floating_point Rep>
RadiansT< Rep >	asin (Rep num)

template<std::floating_point Rep>
RadiansT< Rep >	atan2 (Rep x, Rep y)

template<typename T , size_t N> requires (requires (const Vector<T, N>& v) { +v[0]; })
constexpr auto	operator+ (const Vector< T, N > &vec)

template<typename T , size_t N> requires (requires (const Vector<T, N>& v) { -v[0]; })
constexpr auto	operator- (const Vector< T, N > &vec)

template<typename T , size_t N> requires (requires (const Vector<T, N>& v) { !v[0]; })
constexpr auto	operator! (const Vector< T, N > &vec)

template<typename T , size_t N, typename U > requires ( requires (const Vector<T, N>& v, const U& rhs) { v[0] + rhs; } )
constexpr auto	operator+ (const Vector< T, N > &lhs, const U &rhs)

template<typename T , typename U , size_t N> requires ( requires (const T& lhs, const Vector<U, N>& rhs) { lhs + rhs[0]; } )
constexpr auto	operator+ (const T &lhs, const Vector< U, N > &rhs)

template<typename T , typename U , size_t N> requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] + rhs[0]; })
constexpr auto	operator+ (const Vector< T, N > &lhs, const Vector< U, N > &rhs)

template<typename T , size_t N, typename U > requires (requires (const Vector<T, N>& v, const U& rhs) { v[0] - rhs; })
constexpr auto	operator- (const Vector< T, N > &lhs, const U &rhs)

template<typename T , typename U , size_t N> requires (requires (const T& lhs, const Vector<U, N>& rhs) { lhs - rhs[0]; })
constexpr auto	operator- (const T &lhs, const Vector< U, N > &rhs)

template<typename T , typename U , size_t N> requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] - rhs[0]; })
constexpr auto	operator- (const Vector< T, N > &lhs, const Vector< U, N > &rhs)

template<typename T , size_t N, typename U > requires (requires (const Vector<T, N>& v, const U& rhs) { v[0] * rhs; })
constexpr auto	operator* (const Vector< T, N > &lhs, const U &rhs)

template<typename T , typename U , size_t N> requires (requires (const T& lhs, const Vector<U, N>& rhs) { U(lhs * rhs[0]); })
constexpr auto	operator* (const T &lhs, const Vector< U, N > &rhs)

template<typename T , typename U , size_t N> requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] * rhs[0]; })
constexpr auto	operator* (const Vector< T, N > &lhs, const Vector< U, N > &rhs)

template<typename T , size_t N, typename U > requires (requires (const Vector<T, N>& v, const U& rhs) { v[0] / rhs; })
constexpr auto	operator/ (const Vector< T, N > &lhs, const U &rhs)

template<typename T , typename U , size_t N> requires (requires (const T& lhs, const Vector<U, N>& rhs) { lhs / rhs[0]; })
constexpr auto	operator/ (const T &lhs, const Vector< U, N > &rhs)

template<typename T , typename U , size_t N> requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] / rhs[0]; })
constexpr auto	operator/ (const Vector< T, N > &lhs, const Vector< U, N > &rhs)

template<detail::OutputStreamable T, size_t N>
std::ostream &	operator<< (std::ostream &out, const Vector< T, N > &v)

template<size_t I, typename T , size_t N>
constexpr const T &	get (const Vector< T, N > &v)

template<size_t I, typename T , size_t N>
constexpr T &	get (Vector< T, N > &v)

template<size_t I, typename T , size_t N>
constexpr T &&	get (Vector< T, N > &&v)

template<size_t I, typename T , size_t N>
constexpr const T &&	get (const Vector< T, N > &&v)

template<Scalar T, size_t N>
constexpr const T *	value_ptr (const Vector< T, N > &vec)

template<Scalar T, size_t N>
constexpr T *	value_ptr (Vector< T, N > &vec)

constexpr KeyCombination	operator\| (KeyModifiers modifiers, Key key)

constexpr KeyModifiers	operator\| (KeyModifier lhs, KeyModifier rhs)

std::shared_ptr< Logger >	global_default_logger ()

Logger *	global_default_logger_raw ()

LogLevel	log_level ()

template<typename... Args>
void	log_message (LogLevel level, CStringView fmt, const Args &... args)

template<typename... Args>
void	log_trace (CStringView fmt, const Args &... args)

template<typename... Args>
void	log_debug (CStringView fmt, const Args &... args)

template<typename... Args>
void	log_info (CStringView fmt, const Args &... args)

template<typename... Args>
void	log_warn (CStringView fmt, const Args &... args)

template<typename... Args>
void	log_error (CStringView fmt, const Args &... args)

template<typename... Args>
void	log_critical (CStringView fmt, const Args &... args)

LogLevel	global_get_traceback_level ()

void	global_set_traceback_level (LogLevel)

SynchronizedValue< CircularBuffer< LogMessage, detail::c_max_log_traceback_messages > > &	global_get_traceback_log ()

CStringView	to_cstringview (LogLevel)

std::optional< LogLevel >	try_parse_as_log_level (std::string_view)

std::ostream &	operator<< (std::ostream &, LogLevel)

std::tm	system_calendar_time ()

std::filesystem::path	current_executable_directory ()

std::filesystem::path	user_data_directory (std::string_view organization_name, std::string_view application_name)

void	open_file_in_os_default_application (const std::filesystem::path &)

void	open_url_in_os_default_web_browser (std::string_view)

std::string	get_clipboard_text ()

bool	set_clipboard_text (std::string_view)

std::pair< std::fstream, std::filesystem::path >	mkstemp (std::string_view suffix={}, std::string_view prefix={})

std::filesystem::path	mkdtemp (std::string_view suffix={}, std::string_view prefix={})

std::ostream &	operator<< (std::ostream &, const ResourceDirectoryEntry &)

template<std::derived_from< VirtualFilesystem > TResourceLoader, typename... Args> requires std::constructible_from<TResourceLoader, Args&&...>
ResourceLoader	make_resource_loader (Args &&... args)

constexpr ToggleablePanelFlags	operator- (ToggleablePanelFlags lhs, ToggleablePanelFlags rhs)

constexpr bool	operator& (ToggleablePanelFlags lhs, ToggleablePanelFlags rhs)

template<class T , class Proj = std::identity, std::indirect_strict_weak_order< std::projected< const T *, Proj > > Comp = std::ranges::less>
constexpr const T &	max (const T &a, const T &b, Comp comp={}, Proj proj={})

template<class T , class Proj = std::identity, std::indirect_strict_weak_order< std::projected< const T *, Proj > > Comp = std::ranges::less>
constexpr const T &	min (const T &a, const T &b, Comp comp={}, Proj proj={})

template<class T , class Proj = std::identity, std::indirect_strict_weak_order< std::projected< const T *, Proj > > Comp = std::ranges::less>
constexpr const T &	clamp (const T &v, const T &lo, const T &hi, Comp comp={}, Proj proj={})

template<std::ranges::random_access_range R, class Proj = std::identity, std::indirect_strict_weak_order< std::projected< std::ranges::iterator_t< R >, Proj > > Comp = std::ranges::less>
constexpr std::ranges::range_size_t< R >	max_element_index (R &&r, Comp comp={}, Proj proj={})

template<std::ranges::random_access_range R> requires std::ranges::borrowed_range<R>
constexpr std::ranges::range_reference_t< R >	at (R &&r, std::ranges::range_size_t< R > pos)

template<std::ranges::input_range R, typename T , typename Proj = std::identity> requires std::indirect_binary_predicate<std::ranges::equal_to, std::projected<std::ranges::iterator_t<R>, Proj>, const T*>
std::optional< std::ranges::range_value_t< R > >	find_or_nullopt (R &&r, const T &value, Proj proj={})

template<AssociativeContainer Lookup, AssociativeContainerKeyFor< Lookup > Key>
std::optional< typename Lookup::mapped_type >	lookup_or_nullopt (const Lookup &lookup, const Key &key)

template<std::ranges::input_range R, typename T , typename Proj = std::identity> requires std::ranges::borrowed_range<R>
auto	find_or_nullptr (R &&r, const T &value, Proj proj={}) -> decltype(std::addressof(*std::ranges::begin(r)))

template<AssociativeContainer T, AssociativeContainerKeyFor< T > Key>
auto *	lookup_or_nullptr (const T &container, const Key &key)

template<AssociativeContainer T, AssociativeContainerKeyFor< T > Key>
auto *	lookup_or_nullptr (T &container, const Key &key)

template<typename Downcasted , typename T1 , typename T2 > requires std::equality_comparable<Downcasted>
and std::is_polymorphic_v< Downcasted > and std::derived_from< Downcasted, T1 > and std::derived_from< Downcasted, T2 > constexpr bool	is_eq_downcasted (const T1 &lhs, const T2 &rhs)

constexpr void	append_range (R1 &r1, R2 &&r2)

template<std::unsigned_integral T>
constexpr T	swap_single_bit (T value, int bit_index0, int bit_index1)

bool *	cast_to_bool_ptr (BoolLike *bool_like)

const bool *	cast_to_bool_ptr (const BoolLike *bool_like)

std::string	to_string (const CStringView &cstring_view)

std::ostream &	operator<< (std::ostream &, const CStringView &)

std::string	operator+ (const char *, const CStringView &)

std::string	operator+ (const std::string &, const CStringView &)

template<typename Rep , typename Period , typename Arithmetic > requires std::is_arithmetic_v<Rep>
and std::is_arithmetic_v< Arithmetic > constexpr std::chrono::duration< Rep, Period >	lerp (const std::chrono::duration< Rep, Period > &a, const std::chrono::duration< Rep, Period > &b, const Arithmetic &t)

template<typename Clock , typename Duration , typename Arithmetic > requires std::is_arithmetic_v<Arithmetic>
constexpr std::chrono::time_point< Clock, Duration >	lerp (const std::chrono::time_point< Clock, Duration > &a, const std::chrono::time_point< Clock, Duration > &b, const Arithmetic &t)

template<typename T , typename... Args> requires std::constructible_from<T, Args&&...>
ClonePtr< T >	make_cloneable (Args &&... args)

template<typename U , typename T > requires detail::HasConverter<std::remove_cvref_t<T>, U>
constexpr U	to (T &&value)

template<typename T , typename... Args>
CopyOnUpdPtr< T >	make_cow (Args &&... args)

template<typename U , typename... Args>
CopyOnUpdSharedValue< U >	make_cowv (Args &&... args)

template<DenselyPackedOptionsEnum TEnum>
constexpr size_t	num_options ()

template<DenselyPackedOptionsEnum TEnum>
constexpr size_t	to_index (TEnum v)

template<DenselyPackedOptionsEnum TEnum>
constexpr std::optional< TEnum >	from_index (size_t pos)

template<DenselyPackedOptionsEnum TEnum, typename Proj = std::identity>
constexpr DenselyPackedOptionsIterable< TEnum, Proj >	make_option_iterable (Proj &&proj={})

template<FlagsEnum TEnum>
constexpr size_t	num_flags ()

std::string	potentially_nested_exception_to_string (const std::exception &, int indent=0)

template<size_t N>
consteval std::string_view	extract_filename (const char(&p)[N])

void	for_each_file_with_extensions_recursive (const std::filesystem::path &root, const std::function< void(std::filesystem::path)> &consumer, std::span< const std::string_view > extensions)

std::vector< std::filesystem::path >	find_files_with_extensions_recursive (const std::filesystem::path &root, std::span< const std::string_view > extensions)

void	for_each_file_recursive (const std::filesystem::path &root, const std::function< void(std::filesystem::path)> &consumer)

std::vector< std::filesystem::path >	find_files_recursive (const std::filesystem::path &root)

bool	is_filename_lexicographically_greater_than (const std::filesystem::path &p1, const std::filesystem::path &p2)

bool	is_subpath (const std::filesystem::path &dir, const std::filesystem::path &path)

template<class TEnum > requires std::is_enum_v<TEnum>
constexpr auto	to_underlying (const Flags< TEnum > &e) noexcept

template<Hashable T>
size_t	hash_combine (size_t seed, const T &v) noexcept(noexcept(std::hash< T >{}(v)))

template<Hashable T>
size_t	hash_of (const T &v) noexcept(noexcept(std::hash< T >{}(v)))

template<Hashable T, Hashable... Ts>
size_t	hash_of (const T &v, const Ts &... vs)

template<typename Range >
size_t	hash_range (const Range &range) noexcept(noexcept(hash_combine(0, *std::ranges::begin(range))))

template<typename T , typename U >
bool	operator== (const LifetimedPtr< T > &lhs, const LifetimedPtr< U > &rhs)

template<typename T >
bool	operator== (const LifetimedPtr< T > &lhs, std::nullptr_t)

template<ObjectRepresentationByte Byte = std::byte, BitCastable T>
constexpr std::span< const Byte, sizeof(T)>	view_object_representation (const T &v)

template<ObjectRepresentationByte Byte = std::byte, std::ranges::contiguous_range Range> requires BitCastable<typename Range::value_type>
constexpr std::span< const Byte >	view_object_representations (const Range &range)

template<typename T , std::invocable< T & > UnaryFunction>
void	for_each_parallel_unsequenced (size_t min_chunk_size, std::span< T > values, UnaryFunction mutator)

void	clear_all_perf_measurements ()

std::vector< PerfMeasurement >	get_all_perf_measurements ()

template<typename EF >
	ScopeExit (EF) -> ScopeExit< EF >

template<typename T >
std::pair< SpscSender< T >, SpscReceiver< T > >	make_spsc_channel ()

template<typename Variant , typename T >
constexpr size_t	variant_index ()

template<typename... Ts>
	Overload (Ts...) -> Overload< Ts... >

bool	contains_case_insensitive (std::string_view sv, std::string_view substr)

bool	is_string_case_insensitive_greater_than (std::string_view a, std::string_view b)

bool	is_equal_case_insensitive (std::string_view a, std::string_view b)

bool	is_valid_identifier (std::string_view sv)

std::string_view	strip_whitespace (std::string_view sv)

std::optional< float >	from_chars_strip_whitespace (std::string_view sv)

std::string	truncate_with_ellipsis (std::string_view sv, size_t max_length)

std::string_view	substring_after_last (std::string_view sv, std::string_view::value_type delimiter)

std::optional< std::pair< std::string_view, std::string_view > >	rsplit_once (std::string_view sv, std::string_view::value_type delimiter)

std::pair< char, char >	to_hex_chars (uint8_t)

std::optional< uint8_t >	try_parse_hex_chars_as_byte (char, char)

template<OutputStreamable T>
std::string	stream_to_string (const T &v)

template<std::ranges::input_range R> requires OutputStreamable<std::ranges::range_value_t<R>>
std::string	join (R &&r, std::string_view delimiter)

std::string	replace (std::string_view str, std::string_view from, std::string_view to)

std::ostream &	operator<< (std::ostream &, const UID &)

bool	operator== (const Variant &, const Variant &)

void	swap (Variant &, Variant &) noexcept

std::ostream &	operator<< (std::ostream &, const Variant &)

std::ostream &	operator<< (std::ostream &, VariantType)

Variables
template<typename T >
constexpr bool	IsScalarV = IsScalar<T>::value

template<std::ranges::range R1, std::ranges::input_range R2>
	and { r1.insert(it, first, last)

template<typename NTList >
constexpr size_t	NonTypelistSizeV = NonTypelistSize<NTList>::value

template<typename TList >
constexpr size_t	TypelistSizeV = TypelistSize<TList>::value

Typedef Documentation

◆ AppHours

using osc::AppHours = typedef std::chrono::duration<AppClock::rep, std::ratio<3600> >

◆ AppMicros

using osc::AppMicros = typedef std::chrono::duration<AppClock::rep, std::micro>

◆ AppMillis

using osc::AppMillis = typedef std::chrono::duration<AppClock::rep, std::milli>

◆ AppMinutes

using osc::AppMinutes = typedef std::chrono::duration<AppClock::rep, std::ratio<60> >

◆ AppNanos

using osc::AppNanos = typedef std::chrono::duration<AppClock::rep, std::nano>

◆ AppSeconds

using osc::AppSeconds = typedef std::chrono::duration<AppClock::rep>

◆ BlitFlags

using osc::BlitFlags = typedef Flags<BlitFlag>

◆ CameraClearFlags

using osc::CameraClearFlags = typedef Flags<CameraClearFlag>

◆ Color

using osc::Color = typedef Rgba<float>

◆ Color24

using osc::Color24 = typedef Rgb<Unorm8>

◆ Color32

using osc::Color32 = typedef Rgba<Unorm8>

◆ Degrees

using osc::Degrees = typedef DegreesT<float>

◆ Degreesd

using osc::Degreesd = typedef DegreesT<double>

◆ DegreesT

template<typename T >

using osc::DegreesT = typedef Angle<T, DegreesAngularUnitTraits>

◆ EulerAngles

using osc::EulerAngles = typedef EulerAnglesIn<Radians>

◆ EulerAnglesIn

template<typename Units >

using osc::EulerAnglesIn = typedef Vector<Units, 3>

◆ ImageLoadingFlags

using osc::ImageLoadingFlags = typedef Flags<ImageLoadingFlag>

◆ KeyModifiers

using osc::KeyModifiers = typedef Flags<KeyModifier>

◆ MaterialPropertyValueTypes

using osc::MaterialPropertyValueTypes = typedef Typelist< bool, Color, Color32, Cubemap, float, int, Matrix3x3, Matrix4x4, RenderTexture, SharedColorRenderBuffer, SharedDepthStencilRenderBuffer, Texture2D, Vector2, Vector3, Vector4 >

◆ Matrix3x3

using osc::Matrix3x3 = typedef Matrix<float, 3, 3>

◆ Matrix3x3d

using osc::Matrix3x3d = typedef Matrix<double, 3, 3>

◆ Matrix3x3f

using osc::Matrix3x3f = typedef Matrix<float, 3, 3>

◆ Matrix3x3i

using osc::Matrix3x3i = typedef Matrix<int, 3, 3>

◆ Matrix3x3u32

using osc::Matrix3x3u32 = typedef Matrix<uint32_t, 3, 3>

◆ Matrix3x3z

using osc::Matrix3x3z = typedef Matrix<ptrdiff_t, 3, 3>

◆ Matrix3x3zu

using osc::Matrix3x3zu = typedef Matrix<size_t, 3, 3>

◆ Matrix4x4

using osc::Matrix4x4 = typedef Matrix<float, 4, 4>

◆ Matrix4x4d

using osc::Matrix4x4d = typedef Matrix<double, 4, 4>

◆ Matrix4x4f

using osc::Matrix4x4f = typedef Matrix<float, 4, 4>

◆ Matrix4x4i

using osc::Matrix4x4i = typedef Matrix<int, 4, 4>

◆ Matrix4x4u32

using osc::Matrix4x4u32 = typedef Matrix<uint32_t, 4, 4>

◆ Matrix4x4z

using osc::Matrix4x4z = typedef Matrix<ptrdiff_t, 4, 4>

◆ Matrix4x4zu

using osc::Matrix4x4zu = typedef Matrix<size_t, 4, 4>

◆ MeshUpdateFlags

using osc::MeshUpdateFlags = typedef Flags<MeshUpdateFlag>

◆ OBJWriterFlags

using osc::OBJWriterFlags = typedef Flags<OBJWriterFlag>

◆ OscarDemosTypelist

◆ PerfClock

using osc::PerfClock = typedef std::chrono::steady_clock

◆ PhysicalKeyModifiers

using osc::PhysicalKeyModifiers = typedef Flags<PhysicalKeyModifier>

◆ Quaternion

using osc::Quaternion = typedef Qua<float>

◆ Quaterniond

using osc::Quaterniond = typedef Qua<double>

◆ Quaternionf

using osc::Quaternionf = typedef Qua<float>

◆ Quaternioni

using osc::Quaternioni = typedef Qua<int>

◆ Quaternionu32

using osc::Quaternionu32 = typedef Qua<uint32_t>

◆ Radians

using osc::Radians = typedef RadiansT<float>

◆ Radiansd

using osc::Radiansd = typedef RadiansT<double>

◆ RadiansT

template<typename T >

using osc::RadiansT = typedef Angle<T, RadianAngularUnitTraits>

◆ SceneDecorationFlags

using osc::SceneDecorationFlags = typedef Flags<SceneDecorationFlag>

◆ SceneDecorationShading

using osc::SceneDecorationShading = typedef std::variant< Color, Material, std::pair<Material, MaterialPropertyBlock> >

◆ Snorm8

using osc::Snorm8 = typedef Snorm<int8_t>

◆ SolidGeometries

using osc::SolidGeometries = typedef Typelist< BoxGeometry, CircleGeometry, ConeGeometry, CylinderGeometry, DodecahedronGeometry, IcosahedronGeometry, OctahedronGeometry, RingGeometry, SphereGeometry, TetrahedronGeometry, TorusGeometry, TorusKnotGeometry >

◆ Turns

using osc::Turns = typedef TurnsT<float>

◆ Turnsd

using osc::Turnsd = typedef TurnsT<double>

◆ TurnsT

template<typename T >

using osc::TurnsT = typedef Angle<T, TurnsAngularUnitTraits>

◆ TypeAtT

template<typename TList , size_t Index>

using osc::TypeAtT = typedef typename TypeAt<TList, Index>::type

◆ Unorm8

using osc::Unorm8 = typedef Unorm<uint8_t>

◆ VariantOfTypelistElements

template<typename TTypelist >

using osc::VariantOfTypelistElements = typedef decltype(detail::to_variant(std::declval<TTypelist>()))

◆ VariantTypeList

using osc::VariantTypeList = typedef OptionList<VariantType, VariantType::None, VariantType::Bool, VariantType::Color, VariantType::Float, VariantType::Int, VariantType::String, VariantType::StringName, VariantType::Vector2, VariantType::Vector3, VariantType::VariantArray >

◆ Vector2

using osc::Vector2 = typedef Vector<float, 2>

◆ Vector2d

using osc::Vector2d = typedef Vector<double, 2>

◆ Vector2f

using osc::Vector2f = typedef Vector<float, 2>

◆ Vector2i

using osc::Vector2i = typedef Vector<int, 2>

◆ Vector2u32

using osc::Vector2u32 = typedef Vector<uint32_t, 2>

◆ Vector2uz

using osc::Vector2uz = typedef Vector<size_t, 2>

◆ Vector2z

using osc::Vector2z = typedef Vector<ptrdiff_t, 2>

◆ Vector3

using osc::Vector3 = typedef Vector<float, 3>

◆ Vector3d

using osc::Vector3d = typedef Vector<double, 3>

◆ Vector3f

using osc::Vector3f = typedef Vector<float, 3>

◆ Vector3i

using osc::Vector3i = typedef Vector<int, 3>

◆ Vector3u32

using osc::Vector3u32 = typedef Vector<uint32_t, 3>

◆ Vector3uz

using osc::Vector3uz = typedef Vector<size_t, 3>

◆ Vector3z

using osc::Vector3z = typedef Vector<ptrdiff_t, 3>

◆ Vector4

using osc::Vector4 = typedef Vector<float, 4>

◆ Vector4d

using osc::Vector4d = typedef Vector<double, 4>

◆ Vector4f

using osc::Vector4f = typedef Vector<float, 4>

◆ Vector4i

using osc::Vector4i = typedef Vector<int, 4>

◆ Vector4u32

using osc::Vector4u32 = typedef Vector<uint32_t, 4>

◆ Vector4uz

using osc::Vector4uz = typedef Vector<size_t, 4>

◆ Vector4z

using osc::Vector4z = typedef Vector<ptrdiff_t, 4>

Enumeration Type Documentation

◆ AppSettingScope

enum class osc::AppSettingScope

strong

Enumerator
System
User
NUM_OPTIONS

◆ BlendingEquation

enum class osc::BlendingEquation : uint8_t

strong

Enumerator
Add
Min
Max
NUM_OPTIONS
Default

◆ BlitFlag

enum class osc::BlitFlag

strong

Enumerator
None
AlphaBlend

◆ CameraClearFlag

enum class osc::CameraClearFlag : uint8_t

strong

Enumerator
None
SolidColor
Depth
All
Default

◆ CameraProjection

enum class osc::CameraProjection

strong

Enumerator
Perspective
Orthographic
NUM_OPTIONS
Default

◆ ColorRenderBufferFormat

enum class osc::ColorRenderBufferFormat

strong

Enumerator
R8_UNORM
R8G8B8A8_UNORM
R8G8B8A8_SRGB
R16G16_SFLOAT
R16G16B16_SFLOAT
R16G16B16A16_SFLOAT
R32_SFLOAT
NUM_OPTIONS
Default
DefaultHDR

◆ ColorSpace

enum class osc::ColorSpace

strong

Enumerator
Linear
sRGB
NUM_OPTIONS

◆ CubemapFace

enum class osc::CubemapFace

strong

Enumerator
PositiveX
NegativeX
PositiveY
NegativeY
PositiveZ
NegativeZ
NUM_OPTIONS

◆ CullMode

enum class osc::CullMode : uint8_t

strong

Enumerator
Off
Front
Back
NUM_OPTIONS
Default

◆ CursorShape

enum class osc::CursorShape

strong

Enumerator
Arrow
IBeam
ResizeAll
ResizeVertical
ResizeHorizontal
ResizeDiagonalNESW
ResizeDiagonalNWSE
PointingHand
Wait
Progress
Forbidden
Hidden
NUM_OPTIONS
Default

◆ DepthFunction

enum class osc::DepthFunction : uint8_t

strong

Enumerator
Less
LessOrEqual
NUM_OPTIONS
Default

◆ DepthStencilRenderBufferFormat

enum class osc::DepthStencilRenderBufferFormat

strong

Enumerator
D24_UNorm_S8_UInt
D32_SFloat
NUM_OPTIONS
Default

◆ DestinationBlendingFactor

enum class osc::DestinationBlendingFactor : uint8_t

strong

Enumerator
One
Zero
SourceAlpha
OneMinusSourceAlpha
NUM_OPTIONS
Default

◆ EventType

enum class osc::EventType

strong

Enumerator
DropFile
KeyDown
KeyUp
TextInput
MouseButtonDown
MouseButtonUp
MouseMove
MouseWheel
DisplayStateChange
Quit
Window
Custom
NUM_OPTIONS

◆ ImageLoadingFlag

enum class osc::ImageLoadingFlag

strong

Enumerator
None
FlipVertically
TreatComponentsAsSpatialVectors

◆ Key

enum class osc::Key

strong

Enumerator
Tab
LeftArrow
RightArrow
UpArrow
DownArrow
PageUp
PageDown
Home
End
Insert
Delete
Backspace
Space
Return
Escape
Apostrophe
Comma
Minus
Period
Slash
Semicolon
Equals
LeftBracket
Backslash
RightBracket
Grave
CapsLock
ScrollLock
NumLockClear
PrintScreen
Pause
Keypad0
Keypad1
Keypad2
Keypad3
Keypad4
Keypad5
Keypad6
Keypad7
Keypad8
Keypad9
KeypadPeriod
KeypadDivide
KeypadMultiply
KeypadMinus
KeypadPlus
KeypadEnter
KeypadEquals
LeftCtrl
LeftShift
LeftAlt
LeftGui
RightCtrl
RightShift
RightAlt
RightGui
Application
_0
_1
_2
_3
_4
_5
_6
_7
_8
_9
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
F1
F2
F3
F4
F5
F6
F7
F8
F9
F10
F11
F12
F13
F14
F15
F16
F17
F18
F19
F20
F21
F22
F23
F24
AppBack
AppForward
Unknown
NUM_OPTIONS

◆ KeyModifier

enum class osc::KeyModifier : uint16_t

strong

Enumerator
None
Shift
Ctrl
Meta
Alt
NUM_FLAGS

◆ LogLevel

enum class osc::LogLevel

strong

Enumerator
trace
debug
info
warn
err
critical
off
NUM_OPTIONS
DEFAULT

◆ MeshTopology

enum class osc::MeshTopology

strong

Enumerator
Triangles
Lines
NUM_OPTIONS
Default

◆ MeshUpdateFlag

enum class osc::MeshUpdateFlag

strong

Enumerator
None
DontValidateIndices
DontRecalculateBounds
Default

◆ MouseButton

enum class osc::MouseButton : unsigned

strong

Enumerator
None
Left
Right
Middle
Back
Forward

◆ MouseInputSource

enum class osc::MouseInputSource

strong

Enumerator
Mouse
TouchScreen

◆ OBJWriterFlag

enum class osc::OBJWriterFlag

strong

Enumerator
None
NoWriteNormals
Default

◆ PhysicalKeyModifier

enum class osc::PhysicalKeyModifier : uint16_t

strong

Enumerator
None
Shift
Ctrl
Meta
Alt
NUM_FLAGS

◆ RenderBufferLoadAction

enum class osc::RenderBufferLoadAction

strong

Enumerator
Load
Clear
NUM_OPTIONS

◆ RenderBufferStoreAction

enum class osc::RenderBufferStoreAction

strong

Enumerator
Resolve
DontCare
NUM_OPTIONS

◆ SceneDecorationFlag

enum class osc::SceneDecorationFlag : unsigned

strong

Enumerator
None
NoCastsShadows
NoDrawInScene
RimHighlight0
RimHighlight1
DrawWireframeOverlay
NoSceneVolumeContribution
CanBackfaceCull
Default
WireframeOverlayedDefault
AnnotationElement
OnlyWireframe
Hidden
AllRimHighlightGroups

◆ ShaderPropertyType

enum class osc::ShaderPropertyType

strong

Enumerator
Float
Vector2
Vector3
Vector4
Matrix3x3
Matrix4x4
Int
Bool
Sampler2D
SamplerCube
Unknown
NUM_OPTIONS

◆ SourceBlendingFactor

enum class osc::SourceBlendingFactor : uint8_t

strong

Enumerator
One
Zero
SourceAlpha
OneMinusSourceAlpha
NUM_OPTIONS
Default

◆ TabSaveResult

enum class osc::TabSaveResult

strong

Enumerator
Done
Cancelled

◆ TextureComponentFormat

enum class osc::TextureComponentFormat

strong

Enumerator
Uint8
Float32
NUM_OPTIONS

◆ TextureDimensionality

enum class osc::TextureDimensionality

strong

Enumerator
Tex2D
Cube
NUM_OPTIONS

◆ TextureFilterMode

enum class osc::TextureFilterMode

strong

Enumerator
Nearest
Linear
Mipmap
NUM_OPTIONS

◆ TextureFormat

enum class osc::TextureFormat

strong

Enumerator
R8
RG16
RGB24
RGBA32
RGFloat
RGBFloat
RGBAFloat
NUM_OPTIONS

◆ TextureWrapMode

enum class osc::TextureWrapMode

strong

Enumerator
Repeat
Clamp
Mirror
NUM_OPTIONS

◆ ToggleablePanelFlags

enum class osc::ToggleablePanelFlags : uint32_t

strong

Enumerator
None
IsEnabledByDefault
IsSpawnable
Default

◆ VariantType

enum class osc::VariantType

strong

Enumerator
None
Bool
Color
Float
Int
String
StringName
Vector2
Vector3
VariantArray
NUM_OPTIONS

◆ VertexAttribute

enum class osc::VertexAttribute

strong

Enumerator
Position
Normal
Tangent
Color
TexCoord0
NUM_OPTIONS

◆ VertexAttributeFormat

enum class osc::VertexAttributeFormat

strong

Enumerator
Float32x2
Float32x3
Float32x4
Unorm8x4
Snorm8x4
NUM_OPTIONS

◆ WindowEventType

enum class osc::WindowEventType

strong

Enumerator
GainedMouseFocus
LostMouseFocus
GainedKeyboardFocus
LostKeyboardFocus
WindowClosed
WindowMoved
WindowResized
WindowDisplayScaleChanged
Unknown
NUM_OPTIONS

Function Documentation

◆ abs() [1/2]

template<HasAbsFunction T, size_t N>

Vector< T, N > osc::abs ( const Vector< T, N > & x )

◆ abs() [2/2]

template<std::signed_integral T>

T osc::abs ( T num )

◆ acos()

template<std::floating_point Rep>

RadiansT< Rep > osc::acos ( Rep num )

◆ adjugate()

template<std::floating_point T>

constexpr Matrix< T, 3, 3 > osc::adjugate ( const Matrix< T, 3, 3 > & m )

constexpr

◆ all_of()

template<size_t N>

constexpr bool osc::all_of ( const Vector< bool, N > & v )

constexpr

◆ and()

template<std::ranges::input_range Range, class Proj = std::identity>
requires std::convertible_to<typename std::projected<std::ranges::iterator_t<Range>, Proj>::value_type, const std::optional<AABB>&>

osc::and ( not std::convertible_to< typename std::projected< std::ranges::iterator_t< Range >, Proj >::value_type, const AABB & > ) const

◆ angle_axis() [1/2]

template<std::floating_point T, AngularUnitTraits Units>

Qua< T > osc::angle_axis	(	Angle< T, Units >	angle,
		CoordinateDirection	direction
	)

◆ angle_axis() [2/2]

template<std::floating_point T, AngularUnitTraits Units, std::convertible_to< const Vector< T, 3 > & > VectorLike>

Qua< T > osc::angle_axis	(	Angle< T, Units >	angle,
		VectorLike &&	axis
	)

◆ any_element_is_nan()

bool osc::any_element_is_nan ( const Transform & transform )

inline

◆ any_of()

template<size_t N>

constexpr bool osc::any_of ( const Vector< bool, N > & v )

constexpr

◆ append_range()

constexpr void osc::append_range	(	R1 &	r1,
		R2 &&	r2
	)

constexpr

◆ apply_world_space_rotation()

void osc::apply_world_space_rotation	(	Transform &	application_target,
		const EulerAngles &	euler_angles,
		const Vector3 &	rotation_center
	)

◆ area_of()

template<typename T >
requires std::is_arithmetic_v<T>

constexpr T osc::area_of ( const Vector< T, 2 > & v )

constexpr

◆ asin()

template<std::floating_point Rep>

RadiansT< Rep > osc::asin ( Rep num )

◆ aspect_ratio_of() [1/3]

float osc::aspect_ratio_of ( const Rect & rect )

inline

◆ aspect_ratio_of() [2/3]

template<std::integral T, std::floating_point FloatingPointResult = float>

constexpr FloatingPointResult osc::aspect_ratio_of ( Vector< T, 2 > v )

constexpr

◆ aspect_ratio_of() [3/3]

template<std::floating_point T>

constexpr T osc::aspect_ratio_of ( Vector< T, 2 > v )

constexpr

◆ at()

template<std::ranges::random_access_range R>
requires std::ranges::borrowed_range<R>

constexpr std::ranges::range_reference_t< R > osc::at	(	R &&	r,
		std::ranges::range_size_t< R >	pos
	)

constexpr

◆ atan()

template<std::floating_point Rep>

RadiansT< Rep > osc::atan ( Rep v )

◆ atan2()

template<std::floating_point Rep>

RadiansT< Rep > osc::atan2	(	Rep	x,
		Rep	y
	)

◆ auto_focus()

void osc::auto_focus	(	PolarPerspectiveCamera &	,
		const AABB &	element_aabb,
		float	aspect_ratio = `1.0f`
	)

◆ average_centroid_of()

Vector3 osc::average_centroid_of ( const Mesh & )

◆ axis_directions_of()

constexpr std::array< Vector3, 3 > osc::axis_directions_of ( const Ellipsoid & ellipsoid )

constexpr

◆ bounding_aabb_of() [1/9]

constexpr AABB osc::bounding_aabb_of	(	const AABB &	x,
		const AABB &	y
	)

constexpr

◆ bounding_aabb_of() [2/9]

constexpr AABB osc::bounding_aabb_of	(	const AABB &	x,
		const Vector3 &	y
	)

constexpr

◆ bounding_aabb_of() [3/9]

AABB osc::bounding_aabb_of ( const Sphere & )

◆ bounding_aabb_of() [4/9]

constexpr AABB osc::bounding_aabb_of	(	const std::optional< AABB > &	x,
		const AABB &	y
	)

constexpr

◆ bounding_aabb_of() [5/9]

constexpr AABB osc::bounding_aabb_of ( const Vector3 & x )

constexpr

◆ bounding_aabb_of() [6/9]

template<std::ranges::input_range R, class Proj = std::identity>
requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector3&>

constexpr std::optional< AABB > osc::bounding_aabb_of	(	R &&	r,
		Proj	proj = `{}`
	)

constexpr

◆ bounding_aabb_of() [7/9]

template<InputRangeWithSizeGreaterThan< 0 > R, class Proj = std::identity>
requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector3&>

constexpr AABB osc::bounding_aabb_of	(	R &&	r,
		Proj	proj = `{}`
	)

constexpr

◆ bounding_aabb_of() [8/9]

template<std::ranges::input_range Range, class Proj = std::identity>
requires std::convertible_to<typename std::projected<std::ranges::iterator_t<Range>, Proj>::value_type, const AABB&>

constexpr std::optional< AABB > osc::bounding_aabb_of	(	Range &&	r,
		Proj	proj = `{}`
	)

constexpr

◆ bounding_aabb_of() [9/9]

constexpr std::optional< AABB > osc::bounding_aabb_of	(	std::optional< AABB >	x,
		std::optional< AABB >	y
	)

constexpr

◆ bounding_interval_of() [1/5]

template<typename T >

constexpr ClosedInterval< T > osc::bounding_interval_of	(	const ClosedInterval< T > &	x,
		const ClosedInterval< T > &	y
	)

constexpr

◆ bounding_interval_of() [2/5]

template<typename T >

constexpr ClosedInterval< T > osc::bounding_interval_of	(	const ClosedInterval< T > &	x,
		const T &	y
	)

constexpr

◆ bounding_interval_of() [3/5]

template<typename T >

constexpr ClosedInterval< T > osc::bounding_interval_of	(	const std::optional< ClosedInterval< T > > &	x,
		const ClosedInterval< T > &	y
	)

constexpr

◆ bounding_interval_of() [4/5]

template<typename T >

constexpr ClosedInterval< T > osc::bounding_interval_of	(	const std::optional< ClosedInterval< T > > &	x,
		const T &	y
	)

constexpr

◆ bounding_interval_of() [5/5]

template<typename T >

constexpr ClosedInterval< T > osc::bounding_interval_of ( const T & x )

constexpr

◆ bounding_rect_of() [1/5]

Rect osc::bounding_rect_of ( const Circle & circle )

◆ bounding_rect_of() [2/5]

Rect osc::bounding_rect_of	(	const Rect &	x,
		const Rect &	y
	)

inline

◆ bounding_rect_of() [3/5]

Rect osc::bounding_rect_of	(	const Rect &	x,
		const Vector2 &	y
	)

inline

◆ bounding_rect_of() [4/5]

constexpr Rect osc::bounding_rect_of ( const Vector2 & x )

constexpr

◆ bounding_rect_of() [5/5]

template<std::ranges::input_range R, typename Proj = std::identity>
requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector2&>

constexpr Rect osc::bounding_rect_of	(	R &&	r,
		Proj	proj = `{}`
	)

constexpr

◆ bounding_sphere_of() [1/3]

Sphere osc::bounding_sphere_of ( const AABB & )

◆ bounding_sphere_of() [2/3]

std::optional< Sphere > osc::bounding_sphere_of ( const Mesh & )

◆ bounding_sphere_of() [3/3]

std::optional< Sphere > osc::bounding_sphere_of ( std::span< const Vector3 > )

◆ calc_cubemap_view_proj_matrices()

std::array< Matrix4x4, 6 > osc::calc_cubemap_view_proj_matrices	(	const Matrix4x4 &	projection_matrix,
		Vector3	cube_center
	)

◆ calc_frustum_planes()

FrustumPlanes osc::calc_frustum_planes	(	const Camera &	camera,
		float	aspect_ratio
	)

◆ calc_standard_dark_scene_render_params()

SceneRendererParams osc::calc_standard_dark_scene_render_params	(	const PolarPerspectiveCamera &	,
		AntiAliasingLevel	,
		Vector2	dimensions,
		float	device_pixel_ratio
	)

◆ calc_tangent_vectors()

std::vector< Vector4 > osc::calc_tangent_vectors	(	const MeshTopology &	,
		std::span< const Vector3 >	vertices,
		std::span< const Vector3 >	normals,
		std::span< const Vector2 >	tex_coords,
		const MeshIndicesView &
	)

◆ can_form_triangle()

template<typename T >
requires std::is_arithmetic_v<T>

constexpr bool osc::can_form_triangle	(	const Vector< T, 3 > &	a,
		const Vector< T, 3 > &	b,
		const Vector< T, 3 > &	c
	)

constexpr

◆ cast_to_bool_ptr() [1/2]

bool * osc::cast_to_bool_ptr ( BoolLike * bool_like )

inline

◆ cast_to_bool_ptr() [2/2]

const bool * osc::cast_to_bool_ptr ( const BoolLike * bool_like )

inline

◆ centroid_of() [1/3]

constexpr Vector3 osc::centroid_of ( const AABB & aabb )

constexpr

◆ centroid_of() [2/3]

template<std::ranges::range R, typename T = typename std::ranges::range_value_t<R>::value_type, size_t N = std::tuple_size_v<typename std::ranges::range_value_t<R>>>
requires std::is_arithmetic_v<T>

constexpr Vector< T, N > osc::centroid_of ( const R & r )

constexpr

◆ centroid_of() [3/3]

template<typename T , size_t N>
requires std::is_arithmetic_v<T>

constexpr Vector< T, N > osc::centroid_of ( const std::initializer_list< Vector< T, N > > & vs )

constexpr

◆ clamp() [1/4]

template<std::floating_point Rep, AngularUnitTraits Units, std::convertible_to< Angle< Rep, Units > > AngleMin, std::convertible_to< Angle< Rep, Units > > AngleMax>
requires ( not std::is_same_v<Angle<Rep, Units>, AngleMin> or not std::is_same_v<Angle<Rep, Units>, AngleMax> or not std::is_same_v<AngleMin, AngleMax> )

constexpr Angle< Rep, Units > osc::clamp	(	const Angle< Rep, Units > &	v,
		const AngleMin &	min,
		const AngleMax &	max
	)

constexpr

◆ clamp() [2/4]

Rect osc::clamp	(	const Rect &	,
		const Vector2 &	min,
		const Vector2 &	max
	)

◆ clamp() [3/4]

template<typename T >

constexpr const T & osc::clamp	(	const T &	v,
		const ClosedInterval< T > &	interval
	)

constexpr

◆ clamp() [4/4]

template<class T , class Proj = std::identity, std::indirect_strict_weak_order< std::projected< const T *, Proj > > Comp = std::ranges::less>

constexpr const T & osc::clamp	(	const T &	v,
		const T &	lo,
		const T &	hi,
		Comp	comp = `{}`,
		Proj	proj = `{}`
	)

constexpr

◆ clear_all_perf_measurements()

void osc::clear_all_perf_measurements ( )

◆ component_format_of()

TextureComponentFormat osc::component_format_of ( TextureFormat )

◆ conjugate()

template<typename T >
requires std::is_arithmetic_v<T>

constexpr Qua< T > osc::conjugate ( const Qua< T > & q )

constexpr

◆ contains_case_insensitive()

bool osc::contains_case_insensitive	(	std::string_view	sv,
		std::string_view	substr
	)

◆ copysign()

template<std::floating_point T>

T osc::copysign	(	T	mag,
		T	sgn
	)

◆ corner_vertices_of()

std::array< Vector3, 8 > osc::corner_vertices_of ( const AABB & aabb )

◆ cos() [1/4]

template<std::floating_point Rep, AngularUnitTraits Units>

Rep osc::cos ( Angle< Rep, Units > v )

◆ cos() [2/4]

template<std::floating_point Rep, AngularUnitTraits Units, size_t N>

Vector< Rep, N > osc::cos ( const Vector< Angle< Rep, Units >, N > & v )

◆ cos() [3/4]

template<std::floating_point T, size_t N>

Vector< T, N > osc::cos ( const Vector< T, N > & v )

◆ cos() [4/4]

template<std::floating_point GenType>

GenType osc::cos ( GenType v )

◆ create_camera_focused_on()

PolarPerspectiveCamera osc::create_camera_focused_on ( const AABB & )

◆ create_camera_with_radius()

PolarPerspectiveCamera osc::create_camera_with_radius ( float )

◆ create_triangle_bvh()

BVH osc::create_triangle_bvh ( const Mesh & )

◆ cross() [1/2]

template<typename T >
requires std::is_arithmetic_v<T>

constexpr Vector< T, 3 > osc::cross	(	const Vector< T, 3 > &	x,
		const Vector< T, 3 > &	y
	)

constexpr

◆ cross() [2/2]

constexpr CoordinateDirection osc::cross	(	CoordinateDirection	x,
		CoordinateDirection	y
	)

constexpr

◆ current_executable_directory()

std::filesystem::path osc::current_executable_directory ( )

◆ cylinder_to_line_segment_transform()

Transform osc::cylinder_to_line_segment_transform	(	const LineSegment &	,
		float	radius
	)

◆ decompose()

template<typename T >

bool osc::decompose	(	const Matrix< T, 4, 4 > &	model_matrix,
		Vector< T, 3 > &	r_scale,
		Qua< T > &	r_orientation,
		Vector< T, 3 > &	r_translation,
		Vector< T, 3 > &	r_skew,
		Vector< T, 4 > &	r_perspective
	)

◆ decompose_to_transform()

Transform osc::decompose_to_transform ( const Matrix4x4 & m )

inline

◆ determinant_of() [1/2]

template<std::floating_point T>

T osc::determinant_of ( const Matrix< T, 3, 3 > & m )

◆ determinant_of() [2/2]

template<std::floating_point T>

T osc::determinant_of ( const Matrix< T, 4, 4 > & m )

◆ dimensions_of()

constexpr Vector3 osc::dimensions_of ( const AABB & aabb )

constexpr

◆ dot() [1/3]

template<typename T >
requires std::is_arithmetic_v<T>

constexpr T osc::dot	(	const Qua< T > &	a,
		const Qua< T > &	b
	)

constexpr

◆ dot() [2/3]

template<typename T , size_t N>
requires std::is_arithmetic_v<T>

constexpr T osc::dot	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ dot() [3/3]

template<typename T >
requires std::is_arithmetic_v<T>

constexpr T osc::dot	(	T	x,
		T	y
	)

constexpr

◆ draw_aabb()

void osc::draw_aabb	(	SceneCache &	,
		const AABB &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_aabbs()

void osc::draw_aabbs	(	SceneCache &	,
		std::span< const AABB >	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_arrow()

void osc::draw_arrow	(	SceneCache &	,
		const ArrowProperties &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_bvh()

void osc::draw_bvh	(	SceneCache &	,
		const BVH &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_bvh_leaf_nodes()

void osc::draw_bvh_leaf_nodes	(	SceneCache &	,
		const BVH &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_line_segment()

void osc::draw_line_segment	(	SceneCache &	,
		const LineSegment &	,
		const Color &	,
		float	radius,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_xy_grid()

void osc::draw_xy_grid	(	SceneCache &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_xz_floor_lines()

void osc::draw_xz_floor_lines	(	SceneCache &	,
		const std::function< void(SceneDecoration &&)> &	out,
		float	scale = `5.0f`
	)

◆ draw_xz_grid()

void osc::draw_xz_grid	(	SceneCache &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ draw_yz_grid()

void osc::draw_yz_grid	(	SceneCache &	,
		const std::function< void(SceneDecoration &&)> &	out
	)

◆ ease_out_elastic()

float osc::ease_out_elastic ( float )

◆ elementwise_clamp() [1/2]

template<HasClampFunction T, size_t N>

constexpr Vector< T, N > osc::elementwise_clamp	(	const Vector< T, N > &	v,
		const T &	lo,
		const T &	hi
	)

constexpr

◆ elementwise_clamp() [2/2]

template<HasClampFunction T, size_t N>

constexpr Vector< T, N > osc::elementwise_clamp	(	const Vector< T, N > &	v,
		const Vector< T, N > &	lo,
		const Vector< T, N > &	hi
	)

constexpr

◆ elementwise_equal()

template<std::equality_comparable T, size_t N>

constexpr Vector< bool, N > osc::elementwise_equal	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ elementwise_less() [1/2]

template<LessThanComparable T, size_t N>

constexpr Vector< bool, N > osc::elementwise_less	(	const Vector< T, N > &	x,
		const T &	v
	)

constexpr

◆ elementwise_less() [2/2]

template<LessThanComparable T, size_t N>

constexpr Vector< bool, N > osc::elementwise_less	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ elementwise_less_equal()

template<LessThanOrEqualToComparable T, size_t N>

constexpr Vector< bool, N > osc::elementwise_less_equal	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ elementwise_max()

template<HasMaxFunction T, size_t N>
requires std::is_arithmetic_v<T>

constexpr Vector< T, N > osc::elementwise_max	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ elementwise_min()

template<HasMinFunction T, size_t N>

constexpr Vector< T, N > osc::elementwise_min	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ equal_within_absdiff() [1/3]

template<typename T , size_t N>
requires HasAbsFunction<T>

and LessThanComparable< T > Vector< bool, N > osc::equal_within_absdiff	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y,
		const T &	absdiff
	)

◆ equal_within_absdiff() [2/3]

template<typename T , size_t N>
requires HasAbsFunction<T>

and LessThanComparable< T > Vector< bool, N > osc::equal_within_absdiff	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y,
		const Vector< T, N > &	absdiff
	)

◆ equal_within_absdiff() [3/3]

template<typename T >
requires HasAbsFunction<T>

and LessThanComparable< T > bool osc::equal_within_absdiff	(	T	x,
		T	y,
		T	absdiff
	)

◆ equal_within_epsilon() [1/2]

template<std::floating_point T, size_t N>

Vector< bool, N > osc::equal_within_epsilon	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

◆ equal_within_epsilon() [2/2]

template<std::floating_point T>

bool osc::equal_within_epsilon	(	T	x,
		T	y
	)

◆ equal_within_reldiff() [1/2]

template<std::floating_point T, size_t N>

Vector< bool, N > osc::equal_within_reldiff	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y,
		T	reldiff
	)

◆ equal_within_reldiff() [2/2]

template<std::floating_point T>

bool osc::equal_within_reldiff	(	T	x,
		T	y,
		T	reldiff
	)

◆ equal_within_scaled_epsilon()

template<std::floating_point T>

bool osc::equal_within_scaled_epsilon	(	T	x,
		T	y
	)

◆ expand_by_absolute_amount()

template<typename T >

constexpr ClosedInterval< T > osc::expand_by_absolute_amount	(	const ClosedInterval< T > &	interval,
		T	abs_amount
	)

constexpr

◆ extract_eulers_xyz() [1/3]

template<std::floating_point T>

Vector< RadiansT< T >, 3 > osc::extract_eulers_xyz ( const Matrix< T, 4, 4 > & m )

◆ extract_eulers_xyz() [2/3]

EulerAngles osc::extract_eulers_xyz ( const Quaternion & )

◆ extract_eulers_xyz() [3/3]

EulerAngles osc::extract_eulers_xyz ( const Transform & transform )

inline

◆ extract_extrinsic_eulers_xyz()

EulerAngles osc::extract_extrinsic_eulers_xyz ( const Transform & transform )

inline

◆ extract_filename()

template<size_t N>

consteval std::string_view osc::extract_filename ( const char(&) p[N] )

◆ find_collision() [1/5]

std::optional< RayCollision > osc::find_collision	(	const Ray &	,
		const AABB &
	)

◆ find_collision() [2/5]

std::optional< RayCollision > osc::find_collision	(	const Ray &	,
		const Disc &
	)

◆ find_collision() [3/5]

std::optional< RayCollision > osc::find_collision	(	const Ray &	,
		const Plane &
	)

◆ find_collision() [4/5]

std::optional< RayCollision > osc::find_collision	(	const Ray &	,
		const Sphere &
	)

◆ find_collision() [5/5]

std::optional< RayCollision > osc::find_collision	(	const Ray &	,
		const Triangle &
	)

◆ find_files_recursive()

std::vector< std::filesystem::path > osc::find_files_recursive ( const std::filesystem::path & root )

◆ find_files_with_extensions_recursive()

std::vector< std::filesystem::path > osc::find_files_with_extensions_recursive	(	const std::filesystem::path &	root,
		std::span< const std::string_view >	extensions
	)

◆ find_or_nullopt()

template<std::ranges::input_range R, typename T , typename Proj = std::identity>
requires std::indirect_binary_predicate<std::ranges::equal_to, std::projected<std::ranges::iterator_t<R>, Proj>, const T*>

std::optional< std::ranges::range_value_t< R > > osc::find_or_nullopt	(	R &&	r,
		const T &	value,
		Proj	proj = `{}`
	)

◆ find_or_nullptr()

template<std::ranges::input_range R, typename T , typename Proj = std::identity>
requires std::ranges::borrowed_range<R>

auto osc::find_or_nullptr	(	R &&	r,
		const T &	value,
		Proj	proj = `{}`
	)		-> decltype(std::addressof(*std::ranges::begin(r)))

◆ floor() [1/2]

template<HasFloorFunction T, size_t N>

Vector< T, N > osc::floor ( const Vector< T, N > & x )

◆ floor() [2/2]

template<std::floating_point T>

T osc::floor ( T num )

◆ focus_along_axis()

void osc::focus_along_axis	(	PolarPerspectiveCamera &	,
		size_t	,
		bool	negate = `false`
	)

◆ focus_along_minus_x()

void osc::focus_along_minus_x ( PolarPerspectiveCamera & )

◆ focus_along_minus_y()

void osc::focus_along_minus_y ( PolarPerspectiveCamera & )

◆ focus_along_minus_z()

void osc::focus_along_minus_z ( PolarPerspectiveCamera & )

◆ focus_along_x()

void osc::focus_along_x ( PolarPerspectiveCamera & )

◆ focus_along_y()

void osc::focus_along_y ( PolarPerspectiveCamera & )

◆ focus_along_z()

void osc::focus_along_z ( PolarPerspectiveCamera & )

◆ for_each_file_recursive()

void osc::for_each_file_recursive	(	const std::filesystem::path &	root,
		const std::function< void(std::filesystem::path)> &	consumer
	)

◆ for_each_file_with_extensions_recursive()

void osc::for_each_file_with_extensions_recursive	(	const std::filesystem::path &	root,
		const std::function< void(std::filesystem::path)> &	consumer,
		std::span< const std::string_view >	extensions
	)

◆ for_each_parallel_unsequenced()

template<typename T , std::invocable< T & > UnaryFunction>

void osc::for_each_parallel_unsequenced	(	size_t	min_chunk_size,
		std::span< T >	values,
		UnaryFunction	mutator
	)

◆ for_each_ray_collision_with_scene()

void osc::for_each_ray_collision_with_scene	(	const BVH &	scene_bvh,
		SceneCache &	,
		std::span< const SceneDecoration >	,
		const Ray &	world_space_ray,
		const std::function< void(SceneCollision &&)> &	out
	)

◆ from_chars_strip_whitespace()

std::optional< float > osc::from_chars_strip_whitespace ( std::string_view sv )

◆ from_index()

template<DenselyPackedOptionsEnum TEnum>

constexpr std::optional< TEnum > osc::from_index ( size_t pos )

constexpr

◆ get() [1/20]

template<size_t I, typename T , size_t C, size_t R>

constexpr const Matrix< T, C, R >::value_type && osc::get ( const Matrix< T, C, R > && m )

constexpr

◆ get() [2/20]

template<size_t I, typename T , size_t C, size_t R>

constexpr const Matrix< T, C, R >::value_type & osc::get ( const Matrix< T, C, R > & m )

constexpr

◆ get() [3/20]

template<size_t I, typename T >

constexpr const T && osc::get ( const Qua< T > && v )

constexpr

◆ get() [4/20]

template<size_t I, typename T >

constexpr const T & osc::get ( const Qua< T > & v )

constexpr

◆ get() [5/20]

template<size_t I, typename T >

constexpr const T && osc::get ( const Rgb< T > && v )

constexpr

◆ get() [6/20]

template<size_t I, typename T >

constexpr const T & osc::get ( const Rgb< T > & v )

constexpr

◆ get() [7/20]

template<size_t I, ColorComponent T>

constexpr const T && osc::get ( const Rgba< T > && rgba )

constexpr

◆ get() [8/20]

template<size_t I, ColorComponent T>

constexpr const T & osc::get ( const Rgba< T > & rgba )

constexpr

◆ get() [9/20]

template<size_t I, typename T , size_t N>

constexpr const T && osc::get ( const Vector< T, N > && v )

constexpr

◆ get() [10/20]

template<size_t I, typename T , size_t N>

constexpr const T & osc::get ( const Vector< T, N > & v )

constexpr

◆ get() [11/20]

template<size_t I, typename T , size_t C, size_t R>

constexpr Matrix< T, C, R >::value_type && osc::get ( Matrix< T, C, R > && m )

constexpr

◆ get() [12/20]

template<size_t I, typename T , size_t C, size_t R>

constexpr Matrix< T, C, R >::value_type & osc::get ( Matrix< T, C, R > & m )

constexpr

◆ get() [13/20]

template<size_t I, typename T >

constexpr T && osc::get ( Qua< T > && v )

constexpr

◆ get() [14/20]

template<size_t I, typename T >

constexpr T & osc::get ( Qua< T > & v )

constexpr

◆ get() [15/20]

template<size_t I, typename T >

constexpr T && osc::get ( Rgb< T > && v )

constexpr

◆ get() [16/20]

template<size_t I, typename T >

constexpr T & osc::get ( Rgb< T > & v )

constexpr

◆ get() [17/20]

template<size_t I, ColorComponent T>

constexpr T && osc::get ( Rgba< T > && rgba )

constexpr

◆ get() [18/20]

template<size_t I, ColorComponent T>

constexpr T & osc::get ( Rgba< T > & rgba )

constexpr

◆ get() [19/20]

template<size_t I, typename T , size_t N>

constexpr T && osc::get ( Vector< T, N > && v )

constexpr

◆ get() [20/20]

template<size_t I, typename T , size_t N>

constexpr T & osc::get ( Vector< T, N > & v )

constexpr

◆ get_all_perf_measurements()

std::vector< PerfMeasurement > osc::get_all_perf_measurements ( )

◆ get_all_ray_collisions_with_scene()

std::vector< SceneCollision > osc::get_all_ray_collisions_with_scene	(	const BVH &	scene_bvh,
		SceneCache &	,
		std::span< const SceneDecoration >	,
		const Ray &	world_space_ray
	)

◆ get_clipboard_text()

std::string osc::get_clipboard_text ( )

◆ get_closest_world_space_ray_triangle_collision() [1/2]

std::optional< RayCollision > osc::get_closest_world_space_ray_triangle_collision	(	const Mesh &	,
		const BVH &	triangle_bvh,
		const Transform &	,
		const Ray &	world_space_ray
	)

◆ get_closest_world_space_ray_triangle_collision() [2/2]

std::optional< RayCollision > osc::get_closest_world_space_ray_triangle_collision	(	const PolarPerspectiveCamera &	,
		const Mesh &	,
		const BVH &	triangle_bvh,
		const Rect &	screen_render_rect,
		Vector2	mouse_screen_position
	)

◆ global_default_logger()

std::shared_ptr< Logger > osc::global_default_logger ( )

◆ global_default_logger_raw()

Logger * osc::global_default_logger_raw ( )

◆ global_get_traceback_level()

LogLevel osc::global_get_traceback_level ( )

◆ global_get_traceback_log()

SynchronizedValue< CircularBuffer< LogMessage, detail::c_max_log_traceback_messages > > & osc::global_get_traceback_log ( )

◆ global_set_traceback_level()

void osc::global_set_traceback_level ( LogLevel )

◆ half_widths_of()

constexpr Vector3 osc::half_widths_of ( const AABB & aabb )

constexpr

◆ has_zero_volume()

constexpr bool osc::has_zero_volume ( const AABB & aabb )

constexpr

◆ hash_combine()

template<Hashable T>

size_t osc::hash_combine	(	size_t	seed,
		const T &	v
	)

noexcept

◆ hash_of() [1/2]

template<Hashable T>

size_t osc::hash_of ( const T & v )

noexcept

◆ hash_of() [2/2]

template<Hashable T, Hashable... Ts>

size_t osc::hash_of	(	const T &	v,
		const Ts &...	vs
	)

◆ hash_range()

template<typename Range >

size_t osc::hash_range ( const Range & range )

noexcept

◆ identity()

template<typename T >

constexpr T osc::identity ( )

constexpr

◆ identity< Matrix3x3 >()

template<>

constexpr Matrix3x3 osc::identity< Matrix3x3 > ( )

constexpr

◆ identity< Matrix4x4 >()

template<>

constexpr Matrix4x4 osc::identity< Matrix4x4 > ( )

constexpr

◆ identity< Quaternion >()

template<>

constexpr Quaternion osc::identity< Quaternion > ( )

constexpr

◆ identity< Transform >()

template<>

constexpr Transform osc::identity< Transform > ( )

constexpr

◆ inverse() [1/3]

template<std::floating_point T>

T osc::inverse ( const Matrix< T, 3, 3 > & m )

◆ inverse() [2/3]

template<std::floating_point T>

Matrix< T, 4, 4 > osc::inverse ( const Matrix< T, 4, 4 > & m )

◆ inverse() [3/3]

template<typename T >
requires std::is_arithmetic_v<T>

constexpr Qua< T > osc::inverse ( const Qua< T > & q )

constexpr

◆ inverse_matrix4x4_cast()

Matrix4x4 osc::inverse_matrix4x4_cast ( const Transform & transform )

inline

◆ inverse_transform_point()

constexpr Vector3 osc::inverse_transform_point	(	const Transform &	transform,
		Vector3	point
	)

constexpr

◆ inverse_transform_ray()

Ray osc::inverse_transform_ray	(	const Ray &	,
		const Transform &
	)

◆ inverse_transform_vector()

Vector3 osc::inverse_transform_vector	(	const Transform &	transform,
		const Vector3 &	vector
	)

inline

◆ inversesqrt()

template<std::floating_point T>

T osc::inversesqrt ( T x )

◆ is_eq_downcasted()

template<typename Downcasted , typename T1 , typename T2 >
requires std::equality_comparable<Downcasted>

and std::is_polymorphic_v< Downcasted > and std::derived_from< Downcasted, T1 > and std::derived_from< Downcasted, T2 > constexpr bool osc::is_eq_downcasted	(	const T1 &	lhs,
		const T2 &	rhs
	)

constexpr

◆ is_equal_case_insensitive()

bool osc::is_equal_case_insensitive	(	std::string_view	a,
		std::string_view	b
	)

◆ is_filename_lexicographically_greater_than()

bool osc::is_filename_lexicographically_greater_than	(	const std::filesystem::path &	p1,
		const std::filesystem::path &	p2
	)

◆ is_in_front_of() [1/2]

bool osc::is_in_front_of	(	const AnalyticPlane &	plane,
		const AABB &	aabb
	)

inline

◆ is_in_front_of() [2/2]

bool osc::is_in_front_of	(	const Plane &	plane,
		const AABB &	aabb
	)

inline

◆ is_intersecting() [1/2]

bool osc::is_intersecting	(	const FrustumPlanes &	,
		const AABB &
	)

◆ is_intersecting() [2/2]

bool osc::is_intersecting	(	const Rect &	,
		const Vector2 &
	)

◆ is_point()

constexpr bool osc::is_point ( const AABB & aabb )

constexpr

◆ is_srgb_encoded()

constexpr bool osc::is_srgb_encoded ( ColorRenderBufferFormat format )

constexpr

◆ is_string_case_insensitive_greater_than()

bool osc::is_string_case_insensitive_greater_than	(	std::string_view	a,
		std::string_view	b
	)

◆ is_subpath()

bool osc::is_subpath	(	const std::filesystem::path &	dir,
		const std::filesystem::path &	path
	)

◆ is_valid_identifier()

bool osc::is_valid_identifier ( std::string_view sv )

◆ isnan() [1/3]

template<std::floating_point T>

Vector< bool, 4 > osc::isnan ( const Qua< T > & q )

◆ isnan() [2/3]

template<std::floating_point T, size_t N>

Vector< bool, N > osc::isnan ( const Vector< T, N > & x )

◆ isnan() [3/3]

template<std::floating_point T>

bool osc::isnan ( T num )

◆ join()

template<std::ranges::input_range R>
requires OutputStreamable<std::ranges::range_value_t<R>>

std::string osc::join	(	R &&	r,
		std::string_view	delimiter
	)

◆ length() [1/2]

template<typename T >

T osc::length ( const Qua< T > & q )

◆ length() [2/2]

template<std::floating_point T, size_t N>

T osc::length ( const Vector< T, N > & v )

◆ length2()

template<std::floating_point T, size_t N>

constexpr T osc::length2 ( const Vector< T, N > & v )

constexpr

◆ lerp() [1/6]

template<typename Arithmetic1 , typename Arithmetic2 , typename Arithmetic3 >
requires std::is_arithmetic_v<Arithmetic1>

and std::is_arithmetic_v< Arithmetic2 > and std::is_arithmetic_v< Arithmetic3 > constexpr auto osc::lerp	(	const Arithmetic1 &	a,
		const Arithmetic2 &	b,
		const Arithmetic3 &	t
	)

constexpr

◆ lerp() [2/6]

template<ColorComponent T, typename TInterpolant >

constexpr auto osc::lerp	(	const Rgba< T > &	x,
		const Rgba< T > &	y,
		TInterpolant	t
	)

constexpr

◆ lerp() [3/6]

template<typename Rep , typename Period , typename Arithmetic >
requires std::is_arithmetic_v<Rep>

and std::is_arithmetic_v< Arithmetic > constexpr std::chrono::duration< Rep, Period > osc::lerp	(	const std::chrono::duration< Rep, Period > &	a,
		const std::chrono::duration< Rep, Period > &	b,
		const Arithmetic &	t
	)

constexpr

◆ lerp() [4/6]

template<typename Clock , typename Duration , typename Arithmetic >
requires std::is_arithmetic_v<Arithmetic>

constexpr std::chrono::time_point< Clock, Duration > osc::lerp	(	const std::chrono::time_point< Clock, Duration > &	a,
		const std::chrono::time_point< Clock, Duration > &	b,
		const Arithmetic &	t
	)

constexpr

◆ lerp() [5/6]

template<typename T , size_t N, typename TInterpolant >
requires HasLerpFunction<T, TInterpolant>

constexpr auto osc::lerp	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y,
		const TInterpolant &	t
	)		-> Vector<decltype(lerp(x[0], y[0], t)), N>

constexpr

◆ lerp() [6/6]

template<std::unsigned_integral T, std::floating_point TInterpolant>

constexpr Unorm< T > osc::lerp	(	Unorm< T >	a,
		Unorm< T >	b,
		TInterpolant	t
	)

constexpr

◆ log()

template<std::floating_point T>

T osc::log ( T num )

◆ log_critical()

template<typename... Args>

void osc::log_critical	(	CStringView	fmt,
		const Args &...	args
	)

◆ log_debug()

template<typename... Args>

void osc::log_debug	(	CStringView	fmt,
		const Args &...	args
	)

inline

◆ log_error()

template<typename... Args>

void osc::log_error	(	CStringView	fmt,
		const Args &...	args
	)

◆ log_info()

template<typename... Args>

void osc::log_info	(	CStringView	fmt,
		const Args &...	args
	)

◆ log_level()

LogLevel osc::log_level ( )

inline

◆ log_message()

template<typename... Args>

void osc::log_message	(	LogLevel	level,
		CStringView	fmt,
		const Args &...	args
	)

inline

◆ log_trace()

template<typename... Args>

void osc::log_trace	(	CStringView	fmt,
		const Args &...	args
	)

inline

◆ log_warn()

template<typename... Args>

void osc::log_warn	(	CStringView	fmt,
		const Args &...	args
	)

◆ look_at()

template<std::floating_point T>

Matrix< T, 4, 4 > osc::look_at	(	const Vector< T, 3 > &	eye,
		const Vector< T, 3 > &	center,
		const Vector< T, 3 > &	up
	)

◆ lookup_or_nullopt()

template<AssociativeContainer Lookup, AssociativeContainerKeyFor< Lookup > Key>

std::optional< typename Lookup::mapped_type > osc::lookup_or_nullopt	(	const Lookup &	lookup,
		const Key &	key
	)

◆ lookup_or_nullptr() [1/2]

template<AssociativeContainer T, AssociativeContainerKeyFor< T > Key>

auto * osc::lookup_or_nullptr	(	const T &	container,
		const Key &	key
	)

◆ lookup_or_nullptr() [2/2]

template<AssociativeContainer T, AssociativeContainerKeyFor< T > Key>

auto * osc::lookup_or_nullptr	(	T &	container,
		const Key &	key
	)

◆ loosely_project_into_ndc()

std::optional< Rect > osc::loosely_project_into_ndc	(	const AABB &	aabb,
		const Matrix4x4 &	view_mat,
		const Matrix4x4 &	proj_mat,
		float	znear,
		float	zfar
	)

◆ make_cloneable()

template<typename T , typename... Args>
requires std::constructible_from<T, Args&&...>

ClonePtr< T > osc::make_cloneable ( Args &&... args )

◆ make_cow()

template<typename T , typename... Args>

CopyOnUpdPtr< T > osc::make_cow ( Args &&... args )

◆ make_cowv()

template<typename U , typename... Args>

CopyOnUpdSharedValue< U > osc::make_cowv ( Args &&... args )

◆ make_option_iterable()

template<DenselyPackedOptionsEnum TEnum, typename Proj = std::identity>

constexpr DenselyPackedOptionsIterable< TEnum, Proj > osc::make_option_iterable ( Proj && proj = {} )

constexpr

◆ make_resource_loader()

template<std::derived_from< VirtualFilesystem > TResourceLoader, typename... Args>
requires std::constructible_from<TResourceLoader, Args&&...>

ResourceLoader osc::make_resource_loader ( Args &&... args )

◆ make_spsc_channel()

template<typename T >

std::pair< SpscSender< T >, SpscReceiver< T > > osc::make_spsc_channel ( )

◆ map() [1/5]

template<ColorComponent T, std::invocable< const T &, const T & > BinaryOperation>

constexpr auto osc::map	(	const Rgba< T > &	x,
		const Rgba< T > &	y,
		BinaryOperation	op
	)		-> Rgba<decltype(std::invoke(op, x[0], y[0]))>

constexpr

◆ map() [2/5]

template<ColorComponent T, std::invocable< const T & > UnaryOperation>

constexpr auto osc::map	(	const Rgba< T > &	x,
		UnaryOperation	op
	)		-> Rgba<decltype(std::invoke(op, x[0]))>

constexpr

◆ map() [3/5]

template<typename T , size_t N, std::invocable< const T &, const T & > BinaryOperation>

constexpr auto osc::map	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y,
		BinaryOperation	op
	)		-> Vector<decltype(std::invoke(op, x[0], y[0])), N>

constexpr

◆ map() [4/5]

template<typename T , size_t N, std::invocable< const T &, const T &, const T & > TernaryOperation>

constexpr auto osc::map	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y,
		const Vector< T, N > &	z,
		TernaryOperation	op
	)		-> Vector<decltype(std::invoke(op, x[0], y[0], z[0])), N>

constexpr

◆ map() [5/5]

template<typename T , size_t N, std::invocable< const T & > UnaryOperation>

constexpr auto osc::map	(	const Vector< T, N > &	x,
		UnaryOperation	op
	)		-> Vector<decltype(std::invoke(op, x[0])), N>

constexpr

◆ mass_center_of()

Vector3 osc::mass_center_of ( const Mesh & )

◆ matrix3x3_cast() [1/2]

template<typename T >

constexpr Matrix< T, 3, 3 > osc::matrix3x3_cast ( const Qua< T > & q )

constexpr

◆ matrix3x3_cast() [2/2]

constexpr Matrix3x3 osc::matrix3x3_cast ( const Transform & transform )

constexpr

◆ matrix4x4_cast() [1/2]

template<typename T >

constexpr Matrix< T, 4, 4 > osc::matrix4x4_cast ( const Qua< T > & q )

constexpr

◆ matrix4x4_cast() [2/2]

constexpr Matrix4x4 osc::matrix4x4_cast ( const Transform & transform )

constexpr

◆ matrix4x4_transform_between() [1/2]

Matrix4x4 osc::matrix4x4_transform_between	(	const Disc &	,
		const Disc &
	)

◆ matrix4x4_transform_between() [2/2]

Matrix4x4 osc::matrix4x4_transform_between	(	const LineSegment &	,
		const LineSegment &
	)

◆ matrix4x4_transform_between_directions()

Matrix4x4 osc::matrix4x4_transform_between_directions	(	const Vector3 &	dir1,
		const Vector3 &	dir2
	)

◆ max() [1/2]

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
requires (not std::is_same_v<Units1, Units2>)

constexpr auto osc::max	(	Angle< Rep1, Units1 >	x,
		Angle< Rep2, Units2 >	y
	)		-> std::common_type_t<decltype(x), decltype(y)>

constexpr

◆ max() [2/2]

template<class T , class Proj = std::identity, std::indirect_strict_weak_order< std::projected< const T *, Proj > > Comp = std::ranges::less>

constexpr const T & osc::max	(	const T &	a,
		const T &	b,
		Comp	comp = `{}`,
		Proj	proj = `{}`
	)

constexpr

◆ max_element_index()

template<std::ranges::random_access_range R, class Proj = std::identity, std::indirect_strict_weak_order< std::projected< std::ranges::iterator_t< R >, Proj > > Comp = std::ranges::less>

constexpr std::ranges::range_size_t< R > osc::max_element_index	(	R &&	r,
		Comp	comp = `{}`,
		Proj	proj = `{}`
	)

constexpr

◆ midpoint() [1/2]

template<typename T , size_t N>

Vector< T, N > osc::midpoint	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

◆ midpoint() [2/2]

template<typename T >
requires std::is_integral_v<T>

or std::is_floating_point_v< T > or std::is_pointer_v< T > constexpr T osc::midpoint	(	T	a,
		T	b
	)

constexpr

◆ min() [1/2]

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>
requires (not std::is_same_v<Units1, Units2>)

constexpr auto osc::min	(	Angle< Rep1, Units1 >	x,
		Angle< Rep2, Units2 >	y
	)		-> std::common_type_t<decltype(x), decltype(y)>

constexpr

◆ min() [2/2]

template<class T , class Proj = std::identity, std::indirect_strict_weak_order< std::projected< const T *, Proj > > Comp = std::ranges::less>

constexpr const T & osc::min	(	const T &	a,
		const T &	b,
		Comp	comp = `{}`,
		Proj	proj = `{}`
	)

constexpr

◆ mkdtemp()

std::filesystem::path osc::mkdtemp	(	std::string_view	suffix = `{}`,
		std::string_view	prefix = `{}`
	)

◆ mkstemp()

std::pair< std::fstream, std::filesystem::path > osc::mkstemp	(	std::string_view	suffix = `{}`,
		std::string_view	prefix = `{}`
	)

◆ mod() [1/4]

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>

auto osc::mod	(	Angle< Rep1, Units1 >	x,
		Angle< Rep2, Units2 >	y
	)		-> std::common_type_t<decltype(x), decltype(y)>

◆ mod() [2/4]

template<HasModFunction T, size_t N>

constexpr Vector< T, N > osc::mod	(	const Vector< T, N > &	x,
		const Vector< T, N > &	y
	)

constexpr

◆ mod() [3/4]

template<std::integral T>

constexpr T osc::mod	(	T	x,
		T	y
	)

constexpr

◆ mod() [4/4]

template<std::floating_point T>

T osc::mod	(	T	x,
		T	y
	)

◆ multiply_luminance()

Color osc::multiply_luminance	(	const Color &	color,
		float	factor
	)

◆ ndc_point_to_topleft_normalized()

Vector2 osc::ndc_point_to_topleft_normalized ( Vector2 ndc_point )

◆ ndc_rect_to_topleft_viewport_rect()

Rect osc::ndc_rect_to_topleft_viewport_rect	(	const Rect &	ndc_rect,
		const Rect &	viewport
	)

◆ none_of()

template<size_t N>

constexpr bool osc::none_of ( const Vector< bool, N > & v )

constexpr

◆ normal_matrix() [1/2]

template<std::floating_point T>

Matrix< T, 3, 3 > osc::normal_matrix ( const Matrix< T, 4, 4 > & m )

◆ normal_matrix() [2/2]

constexpr Matrix3x3 osc::normal_matrix ( const Transform & transform )

constexpr

◆ normal_matrix4x4()

template<std::floating_point T>

Matrix< T, 4, 4 > osc::normal_matrix4x4 ( const Matrix< T, 4, 4 > & m )

◆ normal_matrix_4x4()

constexpr Matrix4x4 osc::normal_matrix_4x4 ( const Transform & transform )

constexpr

◆ normalize() [1/2]

template<std::floating_point T>

Qua< T > osc::normalize ( const Qua< T > & q )

◆ normalize() [2/2]

template<std::floating_point T, size_t N>

Vector< T, N > osc::normalize ( const Vector< T, N > & v )

◆ num_bytes_per_component_in()

size_t osc::num_bytes_per_component_in ( TextureComponentFormat )

◆ num_bytes_per_pixel_in()

size_t osc::num_bytes_per_pixel_in ( TextureFormat )

◆ num_components_in()

size_t osc::num_components_in ( TextureFormat )

◆ num_flags()

template<FlagsEnum TEnum>

constexpr size_t osc::num_flags ( )

constexpr

◆ num_options()

template<DenselyPackedOptionsEnum TEnum>

constexpr size_t osc::num_options ( )

constexpr

◆ open_file_in_os_default_application()

void osc::open_file_in_os_default_application ( const std::filesystem::path & )

◆ open_url_in_os_default_web_browser()

void osc::open_url_in_os_default_web_browser ( std::string_view )

◆ operator!()

template<typename T , size_t N>
requires (requires (const Vector<T, N>& v) { !v[0]; })

constexpr auto osc::operator! ( const Vector< T, N > & vec )

constexpr

◆ operator&()

constexpr bool osc::operator&	(	ToggleablePanelFlags	lhs,
		ToggleablePanelFlags	rhs
	)

constexpr

◆ operator*() [1/21]

template<typename T >

Matrix< T, 3, 3 > osc::operator*	(	const Matrix< T, 3, 3 > &	a,
		const Matrix< T, 3, 3 > &	b
	)

◆ operator*() [2/21]

template<typename T >

Matrix< T, 3, 3 >::column_type osc::operator*	(	const Matrix< T, 3, 3 > &	m,
		const typename Matrix< T, 3, 3 >::row_type &	v
	)

◆ operator*() [3/21]

template<typename T >

Matrix< T, 3, 3 > osc::operator*	(	const Matrix< T, 3, 3 > &	m,
		T	scalar
	)

◆ operator*() [4/21]

template<typename T >

Matrix< T, 4, 4 > osc::operator*	(	const Matrix< T, 4, 4 > &	a,
		const Matrix< T, 4, 4 > &	b
	)

◆ operator*() [5/21]

template<typename T >

Matrix< T, 4, 4 >::column_type osc::operator*	(	const Matrix< T, 4, 4 > &	m,
		const typename Matrix< T, 4, 4 >::row_type &	v
	)

◆ operator*() [6/21]

template<typename T >

Matrix< T, 4, 4 > osc::operator*	(	const Matrix< T, 4, 4 > &	m,
		T	scalar
	)

◆ operator*() [7/21]

template<typename T >

constexpr Qua< T > osc::operator*	(	const Qua< T > &	q,
		const Qua< T > &	p
	)

constexpr

◆ operator*() [8/21]

template<typename T >

constexpr Qua< T > osc::operator*	(	const Qua< T > &	q,
		const T &	s
	)

constexpr

◆ operator*() [9/21]

template<typename T >

constexpr Vector< T, 3 > osc::operator*	(	const Qua< T > &	q,
		const Vector< T, 3 > &	v
	)

constexpr

◆ operator*() [10/21]

template<typename T >

constexpr Vector< T, 4 > osc::operator*	(	const Qua< T > &	q,
		const Vector< T, 4 > &	v
	)

constexpr

◆ operator*() [11/21]

template<typename T , typename U , size_t N>
requires (requires (const T& lhs, const Vector<U, N>& rhs) { U(lhs * rhs[0]); })

constexpr auto osc::operator*	(	const T &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator*() [12/21]

template<typename T >

constexpr Qua< T > osc::operator*	(	const T &	s,
		const Qua< T > &	q
	)

constexpr

◆ operator*() [13/21]

constexpr Vector3 osc::operator*	(	const Transform &	transform,
		Vector3	point
	)

constexpr

◆ operator*() [14/21]

template<typename T >

Matrix< T, 3, 3 >::row_type osc::operator*	(	const typename Matrix< T, 3, 3 >::column_type &	v,
		const Matrix< T, 3, 3 > &	m
	)

◆ operator*() [15/21]

template<typename T >

Matrix< T, 4, 4 >::row_type osc::operator*	(	const typename Matrix< T, 4, 4 >::column_type &	v,
		const Matrix< T, 4, 4 > &	m
	)

◆ operator*() [16/21]

template<typename T >

constexpr Vector< T, 3 > osc::operator*	(	const Vector< T, 3 > &	v,
		const Qua< T > &	q
	)

constexpr

◆ operator*() [17/21]

template<typename T >

constexpr Vector< T, 4 > osc::operator*	(	const Vector< T, 4 > &	v,
		const Qua< T > &	q
	)

constexpr

◆ operator*() [18/21]

template<typename T , size_t N, typename U >
requires (requires (const Vector<T, N>& v, const U& rhs) { v[0] * rhs; })

constexpr auto osc::operator*	(	const Vector< T, N > &	lhs,
		const U &	rhs
	)

constexpr

◆ operator*() [19/21]

template<typename T , typename U , size_t N>
requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] * rhs[0]; })

constexpr auto osc::operator*	(	const Vector< T, N > &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator*() [20/21]

template<typename T >

Matrix< T, 3, 3 > osc::operator*	(	T	scalar,
		const Matrix< T, 3, 3 > &	m
	)

◆ operator*() [21/21]

template<typename T >

Matrix< T, 4, 4 > osc::operator*	(	T	scalar,
		const Matrix< T, 4, 4 > &	m
	)

◆ operator+() [1/17]

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>

constexpr std::common_type_t< Angle< Rep1, Units1 >, Angle< Rep2, Units2 > > osc::operator+	(	const Angle< Rep1, Units1 > &	lhs,
		const Angle< Rep2, Units2 > &	rhs
	)

constexpr

◆ operator+() [2/17]

std::string osc::operator+	(	const char *	,
		const CStringView &
	)

◆ operator+() [3/17]

template<typename T >

Matrix< T, 3, 3 > osc::operator+ ( const Matrix< T, 3, 3 > & m )

◆ operator+() [4/17]

template<typename T >

Matrix< T, 3, 3 > osc::operator+	(	const Matrix< T, 3, 3 > &	m,
		T	scalar
	)

◆ operator+() [5/17]

template<typename T >

Matrix< T, 3, 3 > osc::operator+	(	const Matrix< T, 3, 3 > &	m1,
		const Matrix< T, 3, 3 > &	m2
	)

◆ operator+() [6/17]

template<typename T >

Matrix< T, 4, 4 > osc::operator+ ( const Matrix< T, 4, 4 > & m )

◆ operator+() [7/17]

template<typename T >

Matrix< T, 4, 4 > osc::operator+	(	const Matrix< T, 4, 4 > &	m,
		T	scalar
	)

◆ operator+() [8/17]

template<typename T >

Matrix< T, 4, 4 > osc::operator+	(	const Matrix< T, 4, 4 > &	m1,
		const Matrix< T, 4, 4 > &	m2
	)

◆ operator+() [9/17]

template<typename T >

constexpr Qua< T > osc::operator+ ( const Qua< T > & q )

constexpr

◆ operator+() [10/17]

template<typename T >

constexpr Qua< T > osc::operator+	(	const Qua< T > &	q,
		const Qua< T > &	p
	)

constexpr

◆ operator+() [11/17]

std::string osc::operator+	(	const std::string &	,
		const CStringView &
	)

◆ operator+() [12/17]

template<typename T , typename U , size_t N>
requires ( requires (const T& lhs, const Vector<U, N>& rhs) { lhs + rhs[0]; } )

constexpr auto osc::operator+	(	const T &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator+() [13/17]

template<typename T , size_t N, typename U >
requires ( requires (const Vector<T, N>& v, const U& rhs) { v[0] + rhs; } )

constexpr auto osc::operator+	(	const Vector< T, N > &	lhs,
		const U &	rhs
	)

constexpr

◆ operator+() [14/17]

template<typename T , typename U , size_t N>
requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] + rhs[0]; })

constexpr auto osc::operator+	(	const Vector< T, N > &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator+() [15/17]

template<typename T , size_t N>
requires (requires (const Vector<T, N>& v) { +v[0]; })

constexpr auto osc::operator+ ( const Vector< T, N > & vec )

constexpr

◆ operator+() [16/17]

template<typename T >

Matrix< T, 3, 3 > osc::operator+	(	T	scalar,
		const Matrix< T, 3, 3 > &	m
	)

◆ operator+() [17/17]

template<typename T >

Matrix< T, 4, 4 > osc::operator+	(	T	scalar,
		const Matrix< T, 4, 4 > &	m
	)

◆ operator-() [1/16]

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>

constexpr std::common_type_t< Angle< Rep1, Units1 >, Angle< Rep2, Units2 > > osc::operator-	(	const Angle< Rep1, Units1 > &	lhs,
		const Angle< Rep2, Units2 > &	rhs
	)

constexpr

◆ operator-() [2/16]

template<typename T >

Matrix< T, 3, 3 > osc::operator- ( const Matrix< T, 3, 3 > & m )

◆ operator-() [3/16]

template<typename T >

Matrix< T, 3, 3 > osc::operator-	(	const Matrix< T, 3, 3 > &	m,
		T	scalar
	)

◆ operator-() [4/16]

template<typename T >

Matrix< T, 3, 3 > osc::operator-	(	const Matrix< T, 3, 3 > &	m1,
		const Matrix< T, 3, 3 > &	m2
	)

◆ operator-() [5/16]

template<typename T >

Matrix< T, 4, 4 > osc::operator- ( const Matrix< T, 4, 4 > & m )

◆ operator-() [6/16]

template<typename T >

Matrix< T, 4, 4 > osc::operator-	(	const Matrix< T, 4, 4 > &	m,
		T	scalar
	)

◆ operator-() [7/16]

template<typename T >

Matrix< T, 4, 4 > osc::operator-	(	const Matrix< T, 4, 4 > &	m1,
		const Matrix< T, 4, 4 > &	m2
	)

◆ operator-() [8/16]

template<typename T >

constexpr Qua< T > osc::operator- ( const Qua< T > & q )

constexpr

◆ operator-() [9/16]

template<typename T >

constexpr Qua< T > osc::operator-	(	const Qua< T > &	q,
		const Qua< T > &	p
	)

constexpr

◆ operator-() [10/16]

template<typename T , typename U , size_t N>
requires (requires (const T& lhs, const Vector<U, N>& rhs) { lhs - rhs[0]; })

constexpr auto osc::operator-	(	const T &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator-() [11/16]

template<typename T , size_t N, typename U >
requires (requires (const Vector<T, N>& v, const U& rhs) { v[0] - rhs; })

constexpr auto osc::operator-	(	const Vector< T, N > &	lhs,
		const U &	rhs
	)

constexpr

◆ operator-() [12/16]

template<typename T , typename U , size_t N>
requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] - rhs[0]; })

constexpr auto osc::operator-	(	const Vector< T, N > &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator-() [13/16]

template<typename T , size_t N>
requires (requires (const Vector<T, N>& v) { -v[0]; })

constexpr auto osc::operator- ( const Vector< T, N > & vec )

constexpr

◆ operator-() [14/16]

template<typename T >

Matrix< T, 3, 3 > osc::operator-	(	T	scalar,
		const Matrix< T, 3, 3 > &	m
	)

◆ operator-() [15/16]

template<typename T >

Matrix< T, 4, 4 > osc::operator-	(	T	scalar,
		const Matrix< T, 4, 4 > &	m
	)

◆ operator-() [16/16]

constexpr ToggleablePanelFlags osc::operator-	(	ToggleablePanelFlags	lhs,
		ToggleablePanelFlags	rhs
	)

constexpr

◆ operator/() [1/14]

template<typename T >

Matrix< T, 3, 3 >::column_type osc::operator/	(	const Matrix< T, 3, 3 > &	m,
		const typename Matrix< T, 3, 3 >::row_type &	v
	)

◆ operator/() [2/14]

template<typename T >

Matrix< T, 3, 3 > osc::operator/	(	const Matrix< T, 3, 3 > &	m,
		T	scalar
	)

◆ operator/() [3/14]

template<typename T >

Matrix< T, 3, 3 > osc::operator/	(	const Matrix< T, 3, 3 > &	m1,
		const Matrix< T, 3, 3 > &	m2
	)

◆ operator/() [4/14]

template<typename T >

Matrix< T, 4, 4 >::column_type osc::operator/	(	const Matrix< T, 4, 4 > &	m,
		const typename Matrix< T, 4, 4 >::row_type &	v
	)

◆ operator/() [5/14]

template<typename T >

Matrix< T, 4, 4 > osc::operator/	(	const Matrix< T, 4, 4 > &	m,
		T	scalar
	)

◆ operator/() [6/14]

template<typename T >

Matrix< T, 4, 4 > osc::operator/	(	const Matrix< T, 4, 4 > &	m1,
		const Matrix< T, 4, 4 > &	m2
	)

◆ operator/() [7/14]

template<typename T >

constexpr Qua< T > osc::operator/	(	const Qua< T > &	q,
		const T &	s
	)

constexpr

◆ operator/() [8/14]

template<typename T , typename U , size_t N>
requires (requires (const T& lhs, const Vector<U, N>& rhs) { lhs / rhs[0]; })

constexpr auto osc::operator/	(	const T &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator/() [9/14]

template<typename T >

Matrix< T, 3, 3 >::row_type osc::operator/	(	const typename Matrix< T, 3, 3 >::column_type &	v,
		const Matrix< T, 3, 3 > &	m
	)

◆ operator/() [10/14]

template<typename T >

Matrix< T, 4, 4 >::row_type osc::operator/	(	const typename Matrix< T, 4, 4 >::column_type &	v,
		const Matrix< T, 4, 4 > &	m
	)

◆ operator/() [11/14]

template<typename T , size_t N, typename U >
requires (requires (const Vector<T, N>& v, const U& rhs) { v[0] / rhs; })

constexpr auto osc::operator/	(	const Vector< T, N > &	lhs,
		const U &	rhs
	)

constexpr

◆ operator/() [12/14]

template<typename T , typename U , size_t N>
requires (requires (const Vector<T, N>& lhs, const Vector<U, N>& rhs) { lhs[0] / rhs[0]; })

constexpr auto osc::operator/	(	const Vector< T, N > &	lhs,
		const Vector< U, N > &	rhs
	)

constexpr

◆ operator/() [13/14]

template<typename T >

Matrix< T, 3, 3 > osc::operator/	(	T	scalar,
		const Matrix< T, 3, 3 > &	m
	)

◆ operator/() [14/14]

template<typename T >

Matrix< T, 4, 4 > osc::operator/	(	T	scalar,
		const Matrix< T, 4, 4 > &	m
	)

◆ operator<<() [1/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		AntiAliasingLevel
	)

◆ operator<<() [2/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		CameraProjection
	)

◆ operator<<() [3/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		ColorRenderBufferFormat
	)

◆ operator<<() [4/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const AABB &
	)

◆ operator<<() [5/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const AnalyticPlane &
	)

◆ operator<<() [6/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Camera &
	)

◆ operator<<() [7/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const ColorHSLA &
	)

◆ operator<<() [8/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const CStringView &
	)

◆ operator<<() [9/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Disc &
	)

◆ operator<<() [10/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const LineSegment &
	)

◆ operator<<() [11/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Material &
	)

◆ operator<<() [12/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const MaterialPropertyBlock &
	)

◆ operator<<() [13/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Mesh &
	)

◆ operator<<() [14/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Object &
	)

◆ operator<<() [15/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Plane &
	)

◆ operator<<() [16/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Ray &
	)

◆ operator<<() [17/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Rect &
	)

◆ operator<<() [18/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const RenderTexture &
	)

◆ operator<<() [19/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const RenderTextureParams &
	)

◆ operator<<() [20/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const ResourceDirectoryEntry &
	)

◆ operator<<() [21/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Shader &
	)

◆ operator<<() [22/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Sphere &
	)

◆ operator<<() [23/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Texture2D &
	)

◆ operator<<() [24/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const UID &
	)

◆ operator<<() [25/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		const Variant &
	)

◆ operator<<() [26/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		CoordinateAxis
	)

◆ operator<<() [27/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		CoordinateDirection
	)

◆ operator<<() [28/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		DepthStencilRenderBufferFormat
	)

◆ operator<<() [29/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		LogLevel
	)

◆ operator<<() [30/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		MeshTopology
	)

◆ operator<<() [31/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		ShaderPropertyType
	)

◆ operator<<() [32/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		TextureFilterMode
	)

◆ operator<<() [33/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		TextureWrapMode
	)

◆ operator<<() [34/42]

std::ostream & osc::operator<<	(	std::ostream &	,
		VariantType
	)

◆ operator<<() [35/42]

template<std::floating_point Rep, AngularUnitTraits Units>

std::ostream & osc::operator<<	(	std::ostream &	o,
		const Angle< Rep, Units > &	angle
	)

◆ operator<<() [36/42]

template<typename T , size_t C, size_t R>

std::ostream & osc::operator<<	(	std::ostream &	o,
		const Matrix< T, C, R > &	m
	)

◆ operator<<() [37/42]

template<typename T >

std::ostream & osc::operator<<	(	std::ostream &	o,
		const Qua< T > &	v
	)

◆ operator<<() [38/42]

template<ColorComponent T>

std::ostream & osc::operator<<	(	std::ostream &	o,
		const Rgba< T > &	rgba
	)

◆ operator<<() [39/42]

template<std::unsigned_integral T>

std::ostream & osc::operator<<	(	std::ostream &	o,
		const Unorm< T > &	unorm
	)

◆ operator<<() [40/42]

template<std::floating_point T>

std::ostream & osc::operator<<	(	std::ostream &	out,
		const Normalized< T > &	normalized_value
	)

◆ operator<<() [41/42]

std::ostream & osc::operator<<	(	std::ostream &	out,
		const Transform &	transform
	)

inline

◆ operator<<() [42/42]

template<detail::OutputStreamable T, size_t N>

std::ostream & osc::operator<<	(	std::ostream &	out,
		const Vector< T, N > &	v
	)

◆ operator<=>()

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>

constexpr auto osc::operator<=>	(	const Angle< Rep1, Units1 > &	lhs,
		const Angle< Rep2, Units2 > &	rhs
	)

constexpr

◆ operator==() [1/7]

template<std::floating_point Rep1, AngularUnitTraits Units1, std::floating_point Rep2, AngularUnitTraits Units2>

constexpr bool osc::operator==	(	const Angle< Rep1, Units1 > &	lhs,
		const Angle< Rep2, Units2 > &	rhs
	)

constexpr

◆ operator==() [2/7]

bool osc::operator==	(	const Camera &	,
		const Camera &
	)

◆ operator==() [3/7]

bool osc::operator==	(	const Class &	,
		const Class &
	)

◆ operator==() [4/7]

template<typename T , typename U >

bool osc::operator==	(	const LifetimedPtr< T > &	lhs,
		const LifetimedPtr< U > &	rhs
	)

◆ operator==() [5/7]

template<typename T >

bool osc::operator==	(	const LifetimedPtr< T > &	lhs,
		std::nullptr_t
	)

◆ operator==() [6/7]

bool osc::operator==	(	const MaterialPropertyBlock &	,
		const MaterialPropertyBlock &
	)

◆ operator==() [7/7]

bool osc::operator==	(	const Variant &	,
		const Variant &
	)

◆ operator|() [1/2]

constexpr KeyModifiers osc::operator\|	(	KeyModifier	lhs,
		KeyModifier	rhs
	)

constexpr

◆ operator|() [2/2]

constexpr KeyCombination osc::operator\|	(	KeyModifiers	modifiers,
		Key	key
	)

constexpr

◆ ortho()

template<std::floating_point T>

Matrix< T, 4, 4 > osc::ortho	(	T	left,
		T	right,
		T	bottom,
		T	top,
		T	z_near,
		T	z_far
	)

◆ Overload()

template<typename... Ts>

osc::Overload ( Ts... ) -> Overload< Ts... >

◆ perspective()

template<std::floating_point T, AngularUnitTraits Units>

Matrix< T, 4, 4 > osc::perspective	(	Angle< T, Units >	vertical_field_of_view,
		T	aspect,
		T	z_near,
		T	z_far
	)

◆ perspective_unproject_topleft_normalized_pos_to_world()

Ray osc::perspective_unproject_topleft_normalized_pos_to_world	(	Vector2	normalized_point,
		Vector3	camera_world_space_origin,
		const Matrix4x4 &	camera_view_matrix,
		const Matrix4x4 &	camera_proj_matrix
	)

◆ pitch()

template<typename T >

RadiansT< T > osc::pitch ( const Qua< T > & q )

◆ point_axis_along()

Transform osc::point_axis_along	(	const Transform &	transform,
		Vector3::size_type	axis_index,
		const Vector3 &	new_direction
	)

inline

◆ point_axis_towards()

Transform osc::point_axis_towards	(	const Transform &	transform,
		Vector3::size_type	axis_index,
		const Vector3 &	position
	)

inline

◆ potentially_nested_exception_to_string()

std::string osc::potentially_nested_exception_to_string	(	const std::exception &	,
		int	indent = `0`
	)

◆ pow()

template<std::floating_point T>

T osc::pow	(	T	base,
		T	exp
	)

◆ project_onto_viewport_rect()

Vector2 osc::project_onto_viewport_rect	(	const Vector3 &	world_space_position,
		const Matrix4x4 &	view_matrix,
		const Matrix4x4 &	projection_matrix,
		const Rect &	viewport_rect
	)

◆ quaternion_cast() [1/2]

template<typename T >

Qua< T > osc::quaternion_cast ( const Matrix< T, 3, 3 > & m )

◆ quaternion_cast() [2/2]

template<typename T >

Qua< T > osc::quaternion_cast ( const Matrix< T, 4, 4 > & m )

◆ quaternion_identity()

template<typename T >

constexpr Qua< T > osc::quaternion_identity ( )

constexpr

◆ recommended_light_direction()

Vector3 osc::recommended_light_direction ( const PolarPerspectiveCamera & )

◆ replace()

std::string osc::replace	(	std::string_view	str,
		std::string_view	from,
		std::string_view	to
	)

◆ reset()

void osc::reset ( PolarPerspectiveCamera & )

◆ roll()

template<typename T >

RadiansT< T > osc::roll ( const Qua< T > & q )

◆ rotate()

template<std::floating_point T, AngularUnitTraits Units>

Matrix< T, 4, 4 > osc::rotate	(	const Matrix< T, 4, 4 > &	m,
		Angle< T, Units >	angle,
		Vector< T, 3 >	axis
	)

◆ rotate_axis()

Transform osc::rotate_axis	(	const Transform &	transform,
		Vector3::size_type	axis_index,
		Radians	angle
	)

inline

◆ rotation()

template<typename T >

Qua< T > osc::rotation	(	const Vector< T, 3 > &	origin,
		const Vector< T, 3 > &	destination
	)

◆ rsplit_once()

std::optional< std::pair< std::string_view, std::string_view > > osc::rsplit_once	(	std::string_view	sv,
		std::string_view::value_type	delimiter
	)

◆ saturate() [1/4]

template<ColorComponent T>

constexpr Rgba< T > osc::saturate ( const Rgba< T > & x )

constexpr

◆ saturate() [2/4]

template<std::unsigned_integral T>

constexpr Unorm< T > osc::saturate ( const Unorm< T > & v )

constexpr

◆ saturate() [3/4]

template<HasSaturateFunction T, size_t N>

constexpr Vector< T, N > osc::saturate ( const Vector< T, N > & x )

constexpr

◆ saturate() [4/4]

template<std::floating_point T>

constexpr T osc::saturate ( T num )

constexpr

◆ scale()

template<typename T >

Matrix< T, 4, 4 > osc::scale	(	const Matrix< T, 4, 4 > &	m,
		const Vector< T, 3 > &	v
	)

◆ ScopeExit()

template<typename EF >

osc::ScopeExit ( EF ) -> ScopeExit< EF >

One template deduction guide permits the deduction of an argument of function or function object type.

The argument (after function-to-pointer decay, if any) is copied or moved into the constructed scope_exit.

◆ set_clipboard_text()

bool osc::set_clipboard_text ( std::string_view )

◆ signed_distance_between() [1/2]

constexpr float osc::signed_distance_between	(	const AnalyticPlane &	plane,
		const Vector3 &	vector
	)

constexpr

◆ signed_distance_between() [2/2]

constexpr float osc::signed_distance_between	(	const Plane &	plane,
		const Vector3 &	vector
	)

constexpr

◆ sin() [1/4]

template<std::floating_point Rep, AngularUnitTraits Units>

Rep osc::sin ( Angle< Rep, Units > v )

◆ sin() [2/4]

template<std::floating_point Rep, AngularUnitTraits Units, size_t N>

Vector< Rep, N > osc::sin ( const Vector< Angle< Rep, Units >, N > & v )

◆ sin() [3/4]

template<std::floating_point T, size_t N>

Vector< T, N > osc::sin ( const Vector< T, N > & v )

◆ sin() [4/4]

template<std::floating_point GenType>

GenType osc::sin ( GenType v )

◆ sqrt()

template<std::floating_point T>

T osc::sqrt ( T num )

◆ stream_to_string()

template<OutputStreamable T>

std::string osc::stream_to_string ( const T & v )

◆ strip_whitespace()

std::string_view osc::strip_whitespace ( std::string_view sv )

◆ substring_after_last()

std::string_view osc::substring_after_last	(	std::string_view	sv,
		std::string_view::value_type	delimiter
	)

◆ swap()

void osc::swap	(	Variant &	,
		Variant &
	)

noexcept

◆ swap_single_bit()

template<std::unsigned_integral T>

constexpr T osc::swap_single_bit	(	T	value,
		int	bit_index0,
		int	bit_index1
	)

constexpr

◆ system_calendar_time()

std::tm osc::system_calendar_time ( )

◆ tan() [1/4]

template<std::floating_point Rep, AngularUnitTraits Units>

Rep osc::tan ( Angle< Rep, Units > v )

◆ tan() [2/4]

template<std::floating_point Rep, AngularUnitTraits Units, size_t N>

Vector< Rep, N > osc::tan ( const Vector< Angle< Rep, Units >, N > & v )

◆ tan() [3/4]

template<std::floating_point T, size_t N>

Vector< T, N > osc::tan ( const Vector< T, N > & v )

◆ tan() [4/4]

template<std::floating_point GenType>

GenType osc::tan ( GenType v )

◆ to()

template<typename U , typename T >
requires detail::HasConverter<std::remove_cvref_t<T>, U>

constexpr U osc::to ( T && value )

constexpr

◆ to_analytic_plane() [1/2]

constexpr AnalyticPlane osc::to_analytic_plane ( const Plane & plane )

constexpr

◆ to_analytic_plane() [2/2]

constexpr AnalyticPlane osc::to_analytic_plane	(	const Vector3 &	point,
		const Vector3 &	normal
	)

constexpr

◆ to_cstringview()

CStringView osc::to_cstringview ( LogLevel )

◆ to_euler_angles()

template<typename T >

Vector< RadiansT< T >, 3 > osc::to_euler_angles ( const Qua< T > & x )

◆ to_hex_chars()

std::pair< char, char > osc::to_hex_chars ( uint8_t )

◆ to_html_string_rgba()

std::string osc::to_html_string_rgba ( const Color & )

◆ to_index()

template<DenselyPackedOptionsEnum TEnum>

constexpr size_t osc::to_index ( TEnum v )

constexpr

◆ to_integer()

template<std::integral T>

constexpr T osc::to_integer ( const Color32 & color32 )

constexpr

◆ to_linear_colorspace() [1/2]

Color osc::to_linear_colorspace ( const Color & )

◆ to_linear_colorspace() [2/2]

float osc::to_linear_colorspace ( float srgb_component_value )

◆ to_srgb_colorspace() [1/2]

Color osc::to_srgb_colorspace ( const Color & )

◆ to_srgb_colorspace() [2/2]

float osc::to_srgb_colorspace ( float linear_component_value )

◆ to_string() [1/3]

std::string osc::to_string ( const CStringView & cstring_view )

inline

◆ to_string() [2/3]

template<typename T , size_t C, size_t R>

std::string osc::to_string ( const Matrix< T, C, R > & m )

◆ to_string() [3/3]

template<typename T >

std::string osc::to_string ( const Qua< T > & v )

◆ to_texture_format()

std::optional< TextureFormat > osc::to_texture_format	(	size_t	num_components,
		TextureComponentFormat
	)

◆ to_underlying()

template<class TEnum >
requires std::is_enum_v<TEnum>

constexpr auto osc::to_underlying ( const Flags< TEnum > & e )

constexprnoexcept

◆ to_world_space_rotation_quaternion()

Quaternion osc::to_world_space_rotation_quaternion ( const EulerAngles & )

◆ topleft_normalized_point_to_ndc()

Vector2 osc::topleft_normalized_point_to_ndc ( Vector2 normalized_point )

◆ topleft_normalized_point_to_ndc_cube()

Vector4 osc::topleft_normalized_point_to_ndc_cube ( Vector2 normalized_point )

◆ transform_aabb() [1/2]

AABB osc::transform_aabb	(	const Matrix4x4 &	m,
		const AABB &	aabb
	)

◆ transform_aabb() [2/2]

AABB osc::transform_aabb	(	const Transform &	t,
		const AABB &	aabb
	)

◆ transform_between()

Transform osc::transform_between	(	const LineSegment &	,
		const LineSegment &
	)

◆ transform_point() [1/2]

Vector3 osc::transform_point	(	const Matrix4x4 &	mat,
		const Vector3 &	point
	)

inline

◆ transform_point() [2/2]

constexpr Vector3 osc::transform_point	(	const Transform &	transform,
		const Vector3 &	point
	)

constexpr

◆ transform_ray()

Ray osc::transform_ray	(	const Ray &	,
		const Matrix4x4 &
	)

◆ transform_vector() [1/2]

Vector3 osc::transform_vector	(	const Matrix4x4 &	mat,
		const Vector3 &	vector
	)

inline

◆ transform_vector() [2/2]

Vector3 osc::transform_vector	(	const Transform &	transform,
		const Vector3 &	vector
	)

inline

◆ translate()

template<typename T >

Matrix< T, 4, 4 > osc::translate	(	const Matrix< T, 4, 4 > &	m,
		const Vector< T, 3 > &	v
	)

◆ transpose() [1/2]

template<typename T >

constexpr Matrix< T, 3, 3 > osc::transpose ( const Matrix< T, 3, 3 > & m )

constexpr

◆ transpose() [2/2]

template<typename T >

Matrix< T, 4, 4 > osc::transpose ( const Matrix< T, 4, 4 > & m )

◆ triangle_normal() [1/2]

Vector< float, 3 > osc::triangle_normal ( const Triangle & t )

inline

◆ triangle_normal() [2/2]

template<std::floating_point T>

Vector< T, 3 > osc::triangle_normal	(	const Vector< T, 3 > &	a,
		const Vector< T, 3 > &	b,
		const Vector< T, 3 > &	c
	)

◆ truncate_with_ellipsis()

std::string osc::truncate_with_ellipsis	(	std::string_view	sv,
		size_t	max_length
	)

◆ try_decompose_to_transform()

bool osc::try_decompose_to_transform	(	const Matrix4x4 &	m,
		Transform &	out
	)

inline

◆ try_parse_as_log_level()

std::optional< LogLevel > osc::try_parse_as_log_level ( std::string_view )

◆ try_parse_hex_chars_as_byte()

std::optional< uint8_t > osc::try_parse_hex_chars_as_byte	(	char	,
		char
	)

◆ try_parse_html_color_string()

std::optional< Color > osc::try_parse_html_color_string ( std::string_view )

◆ unit_interval()

template<std::floating_point T>

constexpr ClosedInterval< T > osc::unit_interval ( )

constexpr

◆ update_scene_bvh()

void osc::update_scene_bvh	(	std::span< const SceneDecoration >	,
		BVH &
	)

◆ user_data_directory()

std::filesystem::path osc::user_data_directory	(	std::string_view	organization_name,
		std::string_view	application_name
	)

◆ value_ptr() [1/6]

template<typename T , size_t C, size_t R>

constexpr const T * osc::value_ptr ( const Matrix< T, C, R > & m )

constexpr

◆ value_ptr() [2/6]

template<ColorComponent T>

constexpr const T * osc::value_ptr ( const Rgba< T > & rgba )

constexpr

◆ value_ptr() [3/6]

template<Scalar T, size_t N>

constexpr const T * osc::value_ptr ( const Vector< T, N > & vec )

constexpr

◆ value_ptr() [4/6]

template<typename T , size_t C, size_t R>

constexpr T * osc::value_ptr ( Matrix< T, C, R > & m )

constexpr

◆ value_ptr() [5/6]

template<ColorComponent T>

constexpr T * osc::value_ptr ( Rgba< T > & rgba )

constexpr

◆ value_ptr() [6/6]

template<Scalar T, size_t N>

constexpr T * osc::value_ptr ( Vector< T, N > & vec )

constexpr

◆ variant_index()

template<typename Variant , typename T >

constexpr size_t osc::variant_index ( )

constexpr

◆ vertical_to_horizontal_field_of_view()

Radians osc::vertical_to_horizontal_field_of_view	(	Radians	vertical_field_of_view,
		float	aspect_ratio
	)

◆ view_object_representation()

template<ObjectRepresentationByte Byte = std::byte, BitCastable T>

constexpr std::span< const Byte, sizeof(T)> osc::view_object_representation ( const T & v )

constexpr

◆ view_object_representations()

template<ObjectRepresentationByte Byte = std::byte, std::ranges::contiguous_range Range>
requires BitCastable<typename Range::value_type>

constexpr std::span< const Byte > osc::view_object_representations ( const Range & range )

constexpr

◆ volume_of() [1/2]

constexpr float osc::volume_of ( const AABB & aabb )

constexpr

◆ volume_of() [2/2]

float osc::volume_of ( const Tetrahedron & )

◆ y_to_y_cone_to_segment_transform()

Transform osc::y_to_y_cone_to_segment_transform	(	const LineSegment &	,
		float	radius
	)

◆ yaw()

template<typename T >

RadiansT< T > osc::yaw ( const Qua< T > & q )

◆ zoom_in()

void osc::zoom_in ( PolarPerspectiveCamera & )

◆ zoom_out()

void osc::zoom_out ( PolarPerspectiveCamera & )

Variable Documentation

◆ and

template<std::ranges::range R1, std::ranges::input_range R2>

osc::and { r1.insert(it, first, last)

◆ IsScalarV

template<typename T >

constexpr bool osc::IsScalarV = IsScalar<T>::value

inlineconstexpr

◆ NonTypelistSizeV

template<typename NTList >

constexpr size_t osc::NonTypelistSizeV = NonTypelistSize<NTList>::value

inlineconstexpr

◆ TypelistSizeV

template<typename TList >

constexpr size_t osc::TypelistSizeV = TypelistSize<TList>::value

inlineconstexpr

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AppHours

◆ AppMicros

◆ AppMillis

◆ AppMinutes

◆ AppNanos

◆ AppSeconds

◆ BlitFlags

◆ CameraClearFlags

◆ Color

◆ Color24

◆ Color32

◆ Degrees

◆ Degreesd

◆ DegreesT

◆ EulerAngles

◆ EulerAnglesIn

◆ ImageLoadingFlags

◆ KeyModifiers

◆ MaterialPropertyValueTypes

◆ Matrix3x3

◆ Matrix3x3d

◆ Matrix3x3f

◆ Matrix3x3i

◆ Matrix3x3u32

◆ Matrix3x3z

◆ Matrix3x3zu

◆ Matrix4x4

◆ Matrix4x4d

◆ Matrix4x4f

◆ Matrix4x4i

◆ Matrix4x4u32

◆ Matrix4x4z

◆ Matrix4x4zu

◆ MeshUpdateFlags

◆ OBJWriterFlags

◆ OscarDemosTypelist

◆ PerfClock

◆ PhysicalKeyModifiers

◆ Quaternion

◆ Quaterniond

◆ Quaternionf

◆ Quaternioni

◆ Quaternionu32

◆ Radians

◆ Radiansd

◆ RadiansT

◆ SceneDecorationFlags

◆ SceneDecorationShading

◆ Snorm8

◆ SolidGeometries

◆ Turns

◆ Turnsd

◆ TurnsT

◆ TypeAtT

◆ Unorm8

◆ VariantOfTypelistElements

◆ VariantTypeList

◆ Vector2

◆ Vector2d

◆ Vector2f

◆ Vector2i

◆ Vector2u32

◆ Vector2uz

◆ Vector2z

◆ Vector3

◆ Vector3d

◆ Vector3f

◆ Vector3i

◆ Vector3u32

◆ Vector3uz

◆ Vector3z

◆ Vector4