Namespaces
namespace	SystemInfo

Classes
struct	ACESTonemap

struct	ACESTonemapInstance

struct	AGXTonemap

struct	AGXTonemapInstance

struct	AmbientAudioSourceComponent

struct	AmbientLight

class	AnimatorComponent

class	AnimatorSystem

struct	AnimBlendTree

class	App

struct	AppConfig

class	AudioAsset

struct	AudioDataProvider

struct	AudioFilterLayer

struct	AudioGainFilterLayer

class	AudioGraphAsset

struct	AudioGraphComposed

class	AudioListener

struct	AudioMeshAsset

struct	AudioMeshComponent

class	AudioPlayer

class	AudioRingbuffer

struct	AudioSnapshot

struct	AudioSourceBase

struct	AudioSourceComponent

struct	AutoCTTI

struct	BasePushConstantUBO

struct	basic_immutable_span

struct	BillboardParticleRenderMaterialInstance

struct	BillboardRenderParticleMaterial

struct	BillboardRenderParticleMaterial_impl

struct	BloomEffect

struct	BoneTransform

class	BoxCollider

class	BoxReverbationAudioSpace

class	BufferedVRAMSparseSet

class	BufferedVRAMStructureBase

class	BufferedVRAMVector

struct	CacheBase

class	CameraComponent

class	CapsuleCollider

struct	CheckedComponentHandle

class	CheckedComponentHandleBase

class	clamped_vec2

struct	ColorRGB

struct	ColorRGBA

struct	ComponentHandle

class	ComponentHandleBase

class	ComponentWithOwner

class	Constraint

struct	ConstraintTarget

struct	ContactPairPoint

struct	ControllerAxis

struct	ControllerButton

struct	ConvexMeshCollider

struct	CubemapTexture

struct	DataProviderNone

class	Debug

class	DebugDrawer

struct	DefaultSkyMaterial

struct	DefaultSkyMaterialInstance

struct	DepthPyramid

struct	DirectionalLight

struct	DummyTonemap

struct	DummyTonemapInstance

struct	EmitterState

struct	EmitterStateNumericFields

struct	Entity

struct	EnvironmentLight

struct	Event

class	FileStream

struct	FXAAEffect

struct	GameObject

struct	GenericWeakReadThroughCache

struct	GeometryAudioSpace

class	GUIComponent

class	HasDestroy

class	HasQueryTypes

struct	IDebugRenderable

struct	IInputListener

struct	Index

struct	Index< T, T, Ts... >

struct	Index< T, U, Ts... >

struct	IndirectLightingSettings

class	InputManager

struct	InstantaneousAmbientAudioSource

struct	InstantaneousAudioSource

struct	InstantaneousAudioSourceToPlay

struct	ISkyMaterial

struct	ISkyMaterialInstance

struct	IStream

struct	IStreamResult

struct	JointAnimation

struct	JointAnimationTrack

class	Light

struct	LightingType

struct	LitMaterial

class	Material

struct	MaterialConfig

struct	MaterialInstance

struct	MaterialRenderOptions

struct	MaterialSort

struct	MaterialVariant

struct	maybestackarray_freer

class	MemoryStream

class	MeshAsset

struct	MeshAssetOptions

class	MeshAssetSkinned

struct	MeshAttributes

struct	MeshCollection

struct	MeshCollectionSkinned

struct	MeshCollectionSkinnedManager

struct	MeshCollectionStatic

struct	MeshCollectionStaticManager

struct	MeshCollider

struct	MeshPart

struct	MeshPartBase

struct	MeshParticleMeshSelectionMaterial

struct	MeshParticleMeshSelectionMaterialInstance

struct	MeshParticleRenderMaterial

struct	MeshParticleRenderMaterial_Impl

struct	MeshParticleRenderMaterialInstance

struct	MeshPartView

struct	MeshRange

struct	NameToBoneResult

class	NavMeshComponent

class	NetworkBase

class	NetworkClient

struct	NetworkIdentity

class	NetworkManager

class	NetworkServer

struct	ParticleBillboardUBO

struct	ParticleEmitter

struct	ParticleQuadVert

struct	ParticleRenderFilterResult

struct	ParticleRenderMaterial

struct	ParticleRenderMaterialConfig

struct	ParticleRenderMaterialInstance

struct	ParticleUpdateMaterial

struct	ParticleUpdateMaterialInstance

struct	ParticleUpdateUBO

struct	PBRMaterial

struct	PBRMaterialBaked

class	PBRMaterialBakedInstance

class	PBRMaterialInstance

struct	PBRMeshParticleRenderMaterial

struct	PBRMeshParticleRenderMaterialInstance

struct	PBRPushConstantData

struct	PBRUBO

class	PhysicsBodyComponent

struct	PhysicsCallback

class	PhysicsCollider

class	PhysicsLinkSystemRead

class	PhysicsLinkSystemWrite

class	PhysicsMaterial

class	PhysicsSolver

class	PhysicsTaskDispatcher

struct	PipelineOptions

struct	PipelineUseConfiguration

class	PlanarSampleBufferInlineView

struct	PlanarSampleBufferInlineViewAcessControlled

class	PointerInputBinder

struct	PointLight

struct	PolymorphicComponentHandle

struct	PolymorphicGetResult

struct	PostProcessEffectStack

struct	PostProcessInstanceConfig

struct	PostProcessPass

struct	Queryable

struct	QueryableDelta

struct	RAIILock

struct	ReinhardJodieTonemap

struct	ReinhardJodieTonemapInstance

class	RenderEngine

struct	RenderTargetCollection

struct	RenderTexture

struct	RenderViewCollection

class	RigidBodyDynamicComponent

struct	RigidBodyStaticComponent

class	RPCComponent

class	RPCMsgUnpacker

class	RPCSystem

struct	SampledAudioDataProvider

struct	ScreenEffect

struct	ScreenEffectBase

struct	ScreenEffectConfig

struct	ScreenEffectInternalConfig

struct	ScreenEffectPassInstance

class	ScriptComponent

class	ScriptSystem

struct	SerializedJointAnimationHeader

struct	SerializedJointAnimationTrackHeader

struct	SerializedMeshDataHeader

struct	SerializedSkeleton

struct	SerializedSkeletonDataHeader

struct	ShadowLightBase

struct	SharedBufferPool

struct	signature

struct	signature< Ret(Args...)>

struct	signature< Ret(Obj::*)(Args...) const >

struct	signature< Ret(Obj::*)(Args...)>

class	SimpleAudioSpace

struct	SingleAudioRenderBuffer_t

struct	SingleAudioRenderBuffer_t_readwritetrack

class	SkeletonAsset

struct	SkeletonData

struct	SkeletonMask

class	SkinnedMeshComponent

struct	Skybox

struct	SocketConstraint

struct	SocketSystem

struct	Special

class	SphereCollider

class	SpinLock

class	SpotLight

struct	SpritesheetParticleRenderMaterial

struct	SpritesheetParticleRenderMaterialInstance

class	StaticMesh

struct	Texture

struct	TKey

struct	TonemapPass

struct	Transform

struct	Transformation

class	Tween

struct	UnlitMaterial

class	unordered_vector

class	UnorderedSparseSet

class	UnorderedSparseSetGenericContainer

struct	UV

struct	Validator

struct	ValidatorProvider

struct	ValidatorProviderBase

struct	Vertex

struct	Vertex2D

struct	VertexColor

struct	VertexColorUV

struct	VertexNormalUV

struct	VertexUV

struct	VertexWeights

class	VFSInterface

struct	ViewportOverride

class	VirtualFilesystem

struct	VRAMSparseSet

class	VRAMUnorderedVector

struct	VRAMVector

struct	VRAMVectorBase

struct	Window

class	World

struct	WorldDataProvider

Concepts
concept	is_fun

concept	is_mem_fun

concept	is_functor

concept	TinVariadic

concept	SystemHasBefore

concept	SystemHasAfter

concept	IsEngineDataProvider

Typedefs
using	TranslationKey = TKey< glm::vec3 >

using	ScaleKey = TranslationKey

using	RotationKey = TKey< glm::quat >

using	anim_id_t = uint16_t

typedef std::chrono::high_resolution_clock	clocktype

typedef std::chrono::duration< double, std::micro >	timeDiff

typedef std::chrono::seconds	deltaSeconds

typedef std::chrono::time_point< clocktype >	timePoint

template<typename T , size_t N>
using	Array = std::array< T, N >

using	SingleAudioRenderBuffer = SingleAudioRenderBuffer_t< true >

using	SingleAudioRenderBufferNoScratch = SingleAudioRenderBuffer_t< false >

using	RoomMat = vraudio::MaterialName

using	InterleavedSampleBufferView = std::span< float, std::dynamic_extent >

template<is_functor T>
using	functor_args_t = typename signature< decltype(&std::decay_t< T >::operator())>::type

typedef uint32_t	color_t

typedef size_t	ctti_t

template<typename T >
using	LinkedList = plf::list< T >

template<typename T >
using	Colony = plf::colony< T >

template<typename ... A>
using	Function = std::function< A... >

typedef Function< void(float)>	axisCallback

typedef Function< void()>	actionCallback

using	renderlayer_t = uint32_t

using	perobject_t = uint16_t

template<typename T , typename U , typename lock = std::mutex, typename hash = phmap::priv::hash_default_hash<T>, typename eq = phmap::priv::hash_default_eq<T>>
using	locked_hashmap = phmap::parallel_flat_hash_map< T, U, hash, eq, phmap::priv::Allocator< std::pair< const T, U > >, 4, lock >

template<typename T , typename U , typename lock = std::mutex, typename hash = phmap::priv::hash_default_hash<T>, typename eq = phmap::priv::hash_default_eq<T>>
using	locked_node_hashmap = phmap::parallel_node_hash_map< T, U, hash, eq, phmap::priv::Allocator< std::pair< const T, U > >, 4, lock >

template<typename T , typename lock = std::mutex, typename hash = phmap::priv::hash_default_hash<T>, typename eq = phmap::priv::hash_default_eq<T>>
using	locked_hashset = phmap::parallel_flat_hash_set< T, hash, eq, phmap::priv::Allocator< T >, 4, lock >

template<typename T , typename lock = std::mutex, typename hash = phmap::priv::hash_default_hash<T>, typename eq = phmap::priv::hash_default_eq<T>>
using	locked_node_hashset = phmap::parallel_node_hash_set< T, hash, eq, phmap::priv::Allocator< T >, 4, lock >

template<typename T , typename U >
using	UnorderedMap = phmap::flat_hash_map< T, U >

template<typename T , typename U >
using	UnorderedNodeMap = phmap::node_hash_map< T, U >

template<typename T >
using	UnorderedSet = phmap::flat_hash_set< T >

template<typename T , typename U >
using	OrderedMap = phmap::btree_map< T, U >

typedef Array< decimalType, 3 >	RawVec3

typedef Array< decimalType, 4 >	RawQuat

using	VertexAttrib_t = uint8_t

typedef VertexNormalUV	vertex_t

using	VertexPosition_t = decltype(VertexNormalUV::position)

using	VertexNormal_t = decltype(VertexNormalUV::normal)

using	VertexTangent_t = decltype(VertexNormalUV::tangent)

using	VertexBitangent_t = decltype(VertexNormalUV::bitangent)

using	VertexUV_t = decltype(VertexNormalUV::uv)

using	allocation_freelist_t = LinkedList< Range >

using	allocation_allocatedlist_t = allocation_freelist_t

using	ParticleRenderMaterialVariant = std::variant< Ref< BillboardParticleRenderMaterialInstance >, Ref< MeshParticleRenderMaterialInstance > >

using	PostProcessPassInstance = ScreenEffectPassInstance< PostProcessPass >

using	PostProcessEffect = ScreenEffect< PostProcessPassInstance >

template<typename T >
using	ConcurrentQueue = moodycamel::ConcurrentQueue< T >

template<typename T >
using	Queue = std::queue< T >

using	TonemapPassInstance = ScreenEffectPassInstance< TonemapPass >

using	Random = effolkronium::random_static

template<typename T >
using	Vector = std::vector< T >

template<typename T >
using	UnorderedVector = unordered_vector< T, Vector< T > >

Enumerations
enum	ActionState { Released = 0 , Pressed = 1 }

enum class	CID { NONE = 0 , C0 = 1 << 0 , C1 = 1 << 1 , C2 = 1 << 2 , C3 = 1 << 3 , C4 = 1 << 4 , C5 = 1 << 5 , C6 = 1 << 6 , C7 = 1 << 7 , C8 = 1 << 8 , C9 = 1 << 9 , C10 = 1 << 10 , C11 = 1 << 11 , C12 = 1 << 12 , C13 = 1 << 13 , C14 = 1 << 14 , C15 = 1 << 15 , ANY = ~0 }

enum class	OpacityMode : uint8_t { Opaque , Transparent }

enum class	LightingMode : uint8_t { Unlit , Lit }

enum class	PhysicsMaterialFlag { DisableFriction = 1 << 0 , DisableStrongFriction = 1 << 1 }

enum class	PhysicsCombineMode { Average = 0 , Min = 1 , Multiply = 2 , Max = 3 , NValues = 4 , Pad32 = 0x7fffffff }

enum class	PostProcessTextureInput : uint8_t { Unused , EngineColor , UserDefined }

enum class	PostProcessOutput : uint8_t { EngineColor , UserDefined }

enum class	IStreamStatus { Success , EndOfStream , Unknown }

Functions
void	AdditiveBlendSamples (InterleavedSampleBufferView &A, const InterleavedSampleBufferView &B)

void	AdditiveBlendSamples (PlanarSampleBufferInlineView &A, const PlanarSampleBufferInlineView &B)

template<is_functor T>
auto	arguments (T &&t) -> typename signature< decltype(&std::decay_t< T >::operator())>::type

template<is_functor T>
auto	arguments (const T &t) -> typename signature< decltype(&std::decay_t< T >::operator())>::type

template<std::integral T>
constexpr T	closest_multiple_of (T x, T B)

template<typename T >
T	closest_power_of (T x, T p)

consteval uint32_t	Hash32_CT (const char *str, size_t n, uint32_t basis=uint_least32_t(2166136261))

consteval uint64_t	Hash64_CT (const char *str, size_t n, uint64_t basis=uint_least64_t(14695981039346656037U))

template<size_t N>
consteval uint32_t	Hash32_CT (const char(&s)[N])

template<size_t N>
consteval uint64_t	Hash64_CT (const char(&s)[N])

consteval uint32_t	Hash32_CT (const std::string_view &v)

consteval uint64_t	Hash64_CT (const std::string_view &v)

template<typename T >
consteval std::string_view	type_name_impl ()

template<>
consteval std::string_view	type_name_impl< void > ()

template<typename T , std::enable_if_t< fundamental_specialized< T >, bool > = false>
consteval std::string_view	type_name ()

template<class... Args>
constexpr auto	Format (fmt_src::format_string< Args... > formatstr, Args &&... args)

template<typename ... T>
auto	VFormat (const std::string_view formatstr, T &&... args)

App *	GetApp ()

constexpr CID	operator\| (CID lhs, CID rhs)

constexpr CID &	operator\|= (CID &lhs, CID rhs)

constexpr CID	operator& (CID lhs, CID rhs)

constexpr CID &	operator&= (CID &lhs, CID rhs)

template<typename Tuple , typename VTuple = std::remove_reference_t<Tuple>, std::size_t... Indices>
constexpr std::array< std::common_type_t< std::tuple_element_t< Indices, VTuple >... >, sizeof...(Indices)>	to_array (Tuple &&tuple, std::index_sequence< Indices... >)

template<typename Tuple , typename VTuple = std::remove_reference_t<Tuple>>
constexpr decltype(auto)	to_array (Tuple &&tuple)

NameToBoneResult	NameToBone (const aiScene *scene)

SkeletonData	CreateSkeleton (const NameToBoneResult &result)

SerializedSkeleton	FlattenSkeleton (const SkeletonData &skeleton)

template<typename E >
constexpr auto	to_underlying (E e) noexcept

auto	Enumerate (const auto &data)

auto	Enumerate (auto &data)

RGLShaderLibraryPtr	LoadShaderByFilename (const std::string &name, RGLDevicePtr device)

void	DumpTextFloat (float *ptr, uint16_t size)

void	DumpTextFloatGraph (float *ptr, uint16_t size)

std::vector< RGL::PipelineLayoutDescriptor::LayoutBindingDesc >	augmentLitMaterialBindings (const std::vector< RGL::PipelineLayoutDescriptor::LayoutBindingDesc > &bindings, OpacityMode opacityMode)

std::vector< RGL::PipelineLayoutDescriptor::LayoutBindingDesc >	augmentUnlitMaterialBindings (const std::vector< RGL::PipelineLayoutDescriptor::LayoutBindingDesc > &bindings, OpacityMode opacityMode)

	STATIC (RavEngine::Texture::Manager::defaultTexture)

	STATIC (RavEngine::Texture::Manager::defaultNormalTexture)

	STATIC (RavEngine::Texture::Manager::zeroTexture)

MeshPart	AIMesh2MeshPart (const aiMesh *mesh, const matrix4 &scalemat)

void	ASSERT (bool cond, const std::string &msg)

Variables
const decltype(MaterialConfig::vertConfig)	defaultVertexConfig

const decltype(MaterialConfig::colorBlendConfig)	defaultColorBlendConfig

const decltype(MaterialConfig::colorBlendConfig)	defaultTransparentColorBlendConfig

const decltype(MaterialConfig::colorBlendConfig)	defaultColorBlendConfigLitPrepass

const decltype(MaterialConfig::colorBlendConfig)	defaultColorBlendConfigUnlitPrepass

const decltype(MaterialConfig::colorBlendConfig)	defaultUnlitColorBlendConfig

const decltype(MaterialConfig::colorBlendConfig)	defaultTransparentUnlitColorBlendConfig

constexpr renderlayer_t	ALL_LAYERS = std::numeric_limits<decltype(ALL_LAYERS)>::max()

constexpr perobject_t	FrustumCullingBit = 1

constexpr perobject_t	OcclusionCullingBit = 1 << 1

constexpr perobject_t	CastsShadowsBit = 1 << 2

constexpr perobject_t	RecievesShadowsBit = 1 << 3

constexpr perobject_t	ALL_ATTRIBUTES = std::numeric_limits<decltype(ALL_ATTRIBUTES)>::max()

constexpr decimalType	PI = 3.1415926535897932385

const RGL::RenderPipelineDescriptor::VertexConfig	quadVertexConfig

template<typename T , typename... Ts>
constexpr std::size_t	Index_v = Index<T, Ts...>::value

constexpr MeshAttributes	shadowAttributes = { .position = true, .normal = false, .tangent = false, .bitangent = false, .uv0 = true, .lightmapUV = false }

constexpr MeshAttributes	depthPrepassAttributes = { .position = true, .normal = true, .tangent = true, .bitangent = true, .uv0 = true, .lightmapUV = false }

Detailed Description

Multi-inherit from this interface to provide delegates for collision events

Typedef Documentation

◆ Array

template<typename T , size_t N>

using RavEngine::Array = typedef std::array<T,N>

A fixed-size array class.

◆ InterleavedSampleBufferView

using RavEngine::InterleavedSampleBufferView = typedef std::span<float,std::dynamic_extent>

Represents audio samples in interleaved float format. For example, dual-channel audio would be represented as LRLRLRLR....

Function Documentation

◆ AIMesh2MeshPart()

MeshPart RavEngine::AIMesh2MeshPart	(	const aiMesh *	mesh,
		const matrix4 &	scaleMat
	)

Convert an assimp mesh to a MeshPart

Parameters

mesh	the assimp mesh to convert
scaleMat	the matrix to apply to each vertex of the mesh

Returns: converted MeshPart

◆ closest_multiple_of()

template<std::integral T>

constexpr T RavEngine::closest_multiple_of	(	T	numToRound,
		T	multiple
	)

inlineconstexpr

Parameters

x	the number to round
B	the multiple base

Returns: the closest multiple of B to x in the upwards direction. If x is already a multiple of B, returns x.

◆ closest_power_of()

template<typename T >

T RavEngine::closest_power_of	(	T	x,
		T	p
	)

inline

Parameters

x	the number to round
p	the power

Returns: x rounded up to the nearest power of p

◆ LoadShaderByFilename()

RGLShaderLibraryPtr RavEngine::LoadShaderByFilename	(	const std::string &	name,
		RGLDevicePtr	device
	)

Load a shader given its filename (ie "myshader_vsh"). Must include extension.

Parameters

name	filename of the shader

Returns: RGLShaderLibrary

◆ to_underlying()

template<typename E >

constexpr auto RavEngine::to_underlying ( E e )

inlineconstexprnoexcept

Get the underlying type. Useful for enum class.

◆ type_name_impl()

template<typename T >

consteval std::string_view RavEngine::type_name_impl ( )

Derive the type name string

Variable Documentation

◆ quadVertexConfig

const RGL::RenderPipelineDescriptor::VertexConfig RavEngine::quadVertexConfig

Initial value:

{
        .vertexBindings = {
            {
                .binding = 0,
                .stride = sizeof(ParticleQuadVert)
            }
        },
        .attributeDescs = {
            {
                .location = 0,
                .binding = 0,
                .offset = offsetof(ParticleQuadVert,pos),
                .format = RGL::VertexAttributeFormat::R32G32_SignedFloat
            }
        }
    }

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ Array

◆ InterleavedSampleBufferView

Function Documentation

◆ AIMesh2MeshPart()

◆ closest_multiple_of()

◆ closest_power_of()

◆ LoadShaderByFilename()

◆ to_underlying()

◆ type_name_impl()

Variable Documentation

◆ quadVertexConfig