Namespaces
	artnet

	audio

	font

	group

	gui

	icon

	index

	input

	layer

	mask

	material

	math

	openssl

	portal

	projectinfo

	rtti

	sampler

	scene

	SDL

	sequencecurveenums

	sequenceguiactions

	sequenceguiclipboard

	shader

	sorter

	uniform

	utility

	vertexid

	wspp

Classes
class	APIArgument

class	APIBaseValue

class	APICallBack

class	APIComponent

class	APIComponentInstance

class	APIEvent

class	APIMessage

class	APIService

class	APISignature

class	APIValue

class	APIWebSocketClient

class	APIWebSocketEvent

class	APIWebSocketServer

class	APIWebSocketService

class	App

class	AppEventHandler

class	AppRunner

class	ArtNetController

class	ArtNetEvent

class	ArtNetInputComponent

class	ArtNetInputComponentInstance

class	ArtNetListener

class	ArtNetReceiver

class	ArtNetService

class	AudioFormat

class	AVState

class	BaseApp

class	BaseColor

class	BaseFillPolicy

class	BaseMaterial

class	BaseMaterialInstance

class	BaseMaterialInstanceResource

class	BaseParameterBlender

class	BaseSequenceTrackCurve

class	BaseShader

class	BaseVertexAttribute

class	Bitmap

class	BitmapFileBuffer

class	BitmapFromFile

class	BlinnPhongColorShader

class	BlinnPhongTextureShader

class	BlurShader

class	BoxFrameMesh

class	BoxMesh

class	BufferBinding

class	BufferBindingInstance

class	BufferBindingNumeric

class	BufferBindingNumericInstance

class	BufferBindingStruct

class	BufferBindingStructInstance

struct	BufferData

class	BufferObjectDeclaration

class	Calendar

class	CalendarComponent

class	CalendarComponentInstance

class	CalendarEvent

class	CalendarInstance

class	CalendarItem

class	CameraComponent

class	CameraComponentInstance

class	CameraController

class	CameraControllerInstance

class	Circle

class	ClonedComponentResource

class	Color

class	ColorAdjustmentShader

class	Component

class	ComponentInstance

class	ComponentInstanceProperties

class	ComponentInstancePtr

struct	ComponentInstancePtrInitProxy

class	ComponentPtr

class	ComponentPtrBase

class	ComponentPtrInstancePropertyValue

class	ComponentResourcePath

class	ComputeComponent

class	ComputeComponentInstance

class	ComputeMaterial

class	ComputeMaterialInstance

class	ComputeMaterialInstanceResource

struct	ComputePipelineKey

class	ComputeShader

class	ComputeShaderFromFile

class	ConsoleLogHandler

class	ConstantFillPolicy

class	ConstantShader

class	ControllerAxisEvent

class	ControllerButtonEvent

class	ControllerButtonPressEvent

class	ControllerButtonReleaseEvent

class	ControllerConnectionEvent

class	ControllerEvent

class	ControllerInputComponent

class	ControllerInputComponentInstance

class	Core

class	CoreExtension

class	CoreFactory

class	CubeDepthRenderTarget

class	CubeMapFromFile

class	CubeMapShader

class	CubeRenderTarget

class	DailyCalendarItem

class	Date

class	DateTime

class	DefaultInputRouter

class	DefaultInputRouterComponent

class	DefaultInputRouterComponentInstance

class	DepthComparer

class	DepthRenderTarget

class	DepthRenderTexture2D

class	DepthRenderTextureCube

struct	DescriptorSet

class	DescriptorSetAllocator

class	DescriptorSetCache

class	Device

class	DirectionalLightComponent

class	DirectionalLightComponentInstance

class	DirectoryWatcher

class	Display

class	EmptyMesh

class	Entity

struct	EntityCreationParameters

class	EntityInstance

class	EntityInstancePtr

struct	EntityInstancePtrInitProxy

class	EntityObjectGraphItem

class	EntityPtr

class	Event

class	FadeShader

class	FileLogHandler

class	FillPolicy

class	FirstPersonController

class	FirstPersonControllerInstance

class	Font

class	FontInstance

struct	FontProperties

class	FontService

class	FontShader

struct	Frame

class	GeometryFromFile

class	Glyph

class	GlyphCache

class	GnomonMesh

class	GnomonShader

class	GPUBuffer

class	GPUBufferNumeric

class	GPUMesh

class	Group

class	GUIAppEventHandler

class	Hexagon

class	ICalendar

class	Icon

class	IGlyphRepresentation

class	IGroup

class	Image

struct	ImageData

class	ImageFromFile

class	IMesh

class	IMGuiService

class	IMGuiServiceConfiguration

class	IndexBuffer

class	InputComponent

class	InputComponentInstance

class	InputEvent

class	InputRouter

class	InputService

class	InstancePropertyValue

class	IRenderTarget

class	IWebSocketClient

class	IWebSocketClientEndPoint

class	IWebSocketServer

class	IWebSocketServerEndPoint

class	KeyEvent

class	KeyInputComponent

class	KeyInputComponentInstance

class	KeyPressEvent

class	KeyReleaseEvent

class	LicenseConfiguration

struct	LicenseInformation

class	LicenseService

class	LightComponent

class	LightComponentInstance

class	Line

class	LineFromFile

class	Logger

class	LogHandler

class	LogLevel

class	LogMessage

class	Material

class	MaterialInstance

class	MaterialInstanceResource

class	Mesh

class	MeshFromFile

class	MeshInstance

struct	MeshProperties

struct	MeshShape

class	MidiEvent

class	MidiInputComponent

class	MidiInputComponentInstance

class	MidiInputPort

class	MidiOutputPort

class	MidiPortInfo

class	MidiService

class	Module

struct	ModuleDescriptor

class	ModuleInfo

class	ModuleManager

class	MonthlyCalendarItem

class	MouseWheelEvent

class	ObjectGraph

class	OperationalCalendar

class	OrbitController

class	OrbitControllerInstance

class	OrthoCameraComponent

class	OrthoCameraComponentInstance

struct	OrthoCameraProperties

class	OrthoController

class	OrthoControllerInstance

class	OSCArgument

class	OSCBaseValue

class	OSCBlob

class	OSCColor

class	OSCEvent

class	OSCInputComponent

class	OSCInputComponentInstance

class	OSCNil

class	OSCPacketListener

class	OSCReceiver

class	OSCReceivingSocket

class	OSCSender

class	OSCService

class	OSCString

class	OSCTimeTag

class	OSCValue

class	Parameter

class	ParameterBlendComponent

class	ParameterBlendComponentInstance

class	ParameterBlender

class	ParameterBlendGroup

class	ParameterButton

class	ParameterDropDown

class	ParameterEnum

class	ParameterEnumBase

class	ParameterGUI

class	ParameterGUIService

class	ParameterizedWindowEvent

class	ParameterMat

class	ParameterNumeric

class	ParameterService

class	ParameterServiceConfiguration

class	ParameterSimple

class	ParameterVec

class	PathMapping

class	PerspCameraComponent

class	PerspCameraComponentInstance

struct	PerspCameraProperties

class	PhysicalDevice

struct	PipelineKey

class	PlaneMesh

class	PointerClickEvent

class	PointerEvent

class	PointerInputComponent

class	PointerInputComponentInstance

class	PointerInstancePropertyValue

class	PointerMoveEvent

class	PointerPressEvent

class	PointerReleaseEvent

class	PointLightComponent

class	PointLightComponentInstance

class	PolyLine

struct	PolyLineProperties

class	PortalComponent

class	PortalComponentInstance

class	PortalEvent

struct	PortalEventHeader

class	PortalItem

class	PortalItemButton

class	PortalItemColor

class	PortalItemDropDown

class	PortalItemNumeric

class	PortalItemOperationalCalendar

class	PortalItemSimple

class	PortalItemTextArea

class	PortalItemVec

class	PortalService

class	PortalWebSocketServer

class	ProjectInfo

class	PublicKey

class	PythonScript

class	PythonScriptComponent

class	PythonScriptComponentInstance

class	PythonScriptService

class	RandomFillPolicy

class	RColor

class	Rectangle

class	Renderable2DGlyph

class	Renderable2DMipMapGlyph

class	Renderable2DTextComponent

class	Renderable2DTextComponentInstance

class	Renderable3DTextComponent

class	Renderable3DTextComponentInstance

class	RenderableComponent

class	RenderableComponentInstance

class	RenderableGlyph

class	RenderableMesh

class	RenderableMeshComponent

class	RenderableMeshComponentInstance

class	RenderableTextComponent

class	RenderableTextComponentInstance

class	RenderAdvancedService

class	RenderAdvancedServiceConfiguration

class	RenderBloomComponent

class	RenderBloomComponentInstance

class	RenderChain

class	RenderFaderComponent

class	RenderFaderComponentInstance

class	RenderFrustumComponent

class	RenderFrustumComponentInstance

class	RenderGnomonComponent

class	RenderGnomonComponentInstance

class	RenderLayer

class	RenderService

class	RenderServiceConfiguration

class	RenderSkyBoxComponent

class	RenderSkyBoxComponentInstance

class	RenderTag

class	RenderTarget

class	RenderTexture2D

class	RenderTextureCube

class	RenderToTextureComponent

class	RenderToTextureComponentInstance

class	RenderVideoComponent

class	RenderVideoComponentInstance

class	RenderWindow

class	Resource

class	ResourceManager

class	RGBAColor

class	RGBColor

class	RootEntity

class	RotateComponent

class	RotateComponentInstance

struct	RotateProperties

class	RTTIObjectGraphItem

class	Sampler

class	Sampler2D

class	Sampler2DArray

class	Sampler2DArrayInstance

class	Sampler2DInstance

class	SamplerArray

class	SamplerArrayInstance

class	SamplerCube

class	SamplerCubeArray

class	SamplerCubeArrayInstance

class	SamplerCubeInstance

class	SamplerDeclaration

class	SamplerInstance

class	ScatterPointsMesh

class	Scene

class	SceneService

class	SDLAppEventHandler

class	SDLEventConverter

class	SDLInputService

class	SecureWebSocketClientEndPoint

class	SecureWebSocketServerEndPoint

class	Sequence

class	SequenceAudioGUIService

class	SequenceAudioTrackView

class	SequenceController

class	SequenceControllerAudio

class	SequenceControllerCurve

class	SequenceControllerEvent

class	SequenceCurveTrackView

class	SequenceEditor

class	SequenceEditorGUI

struct	SequenceEditorGUIState

class	SequenceEditorGUIView

class	SequenceEvent

class	SequenceEventBase

class	SequenceEventTrackSegmentView

class	SequenceEventTrackSegmentViewBase

class	SequenceEventTrackView

class	SequenceGUIService

class	SequenceMarker

class	SequencePlayer

class	SequencePlayerAdapter

class	SequencePlayerAudioAdapter

class	SequencePlayerAudioClock

class	SequencePlayerAudioClockProcess

class	SequencePlayerAudioOutput

class	SequencePlayerClock

class	SequencePlayerCurveAdapter

class	SequencePlayerCurveAdapterBase

class	SequencePlayerCurveOutput

class	SequencePlayerEventAdapter

class	SequencePlayerEventOutput

class	SequencePlayerIndependentClock

class	SequencePlayerOutput

class	SequencePlayerStandardClock

class	SequenceService

class	SequenceServiceAudio

class	SequenceTrack

class	SequenceTrackAudio

class	SequenceTrackCurve

class	SequenceTrackEvent

class	SequenceTrackSegment

class	SequenceTrackSegmentAudio

class	SequenceTrackSegmentCurve

class	SequenceTrackSegmentEvent

class	SequenceTrackSegmentEventBase

class	SequenceTrackView

class	SerialPort

class	SerialService

class	Service

class	ServiceConfiguration

class	ServiceObjectGraphItem

class	ServiceRunner

class	Shader

class	ShaderConstant

class	ShaderConstantDeclaration

class	ShaderConstantInstance

class	ShaderFromFile

struct	ShaderSpecializationConstantInfo

class	ShaderStorageBufferObject

class	ShaderVariableDeclaration

class	ShaderVariableStructArrayDeclaration

class	ShaderVariableStructBufferDeclaration

class	ShaderVariableStructDeclaration

class	ShaderVariableValueArrayDeclaration

class	ShaderVariableValueDeclaration

class	ShapeTriangle

class	ShapeTriangleFanIterator

class	ShapeTriangleIterator

class	ShapeTriangleListIterator

class	ShapeTriangleStripIterator

class	Signal

class	SkyBoxShader

class	Slot
	Slot. More...

class	Snapshot

class	SnapshotRenderTarget

class	SpawnedEntityInstance

class	SphereMesh

class	SpotLightComponent

class	SpotLightComponentInstance

class	StructBuffer

struct	StructBufferDescriptor

class	StructFillPolicy

struct	SurfaceDescriptor

class	TargetAttribute

class	TaskQueue

class	TextInputEvent

class	Texture

class	Texture2D

class	TextureCube

class	TextureShader

class	ThreadPool

class	Timer

class	TimeStamp

class	TorusMesh

class	TouchEvent

class	TouchInputComponent

class	TouchInputComponentInstance

class	TouchMoveEvent

class	TouchPressEvent

class	TouchReleaseEvent

class	TransformComponent

class	TransformComponentInstance

struct	TransformInstanceProperties

struct	TransformProperties

class	Triangle

class	TriangleData

class	TriangleIterator

class	TriangleLine

class	TriangleMesh

class	TypedBufferBindingNumeric

class	TypedBufferBindingNumericInstance

class	TypedGPUBufferNumeric

class	TypedInstancePropertyValue

class	TypedUniformValue

class	TypedUniformValueArray

class	TypedUniformValueArrayInstance

class	TypedUniformValueInstance

class	UDPAdapter

class	UDPClient

struct	UDPPacket

class	UDPServer

class	UDPService

class	UDPThread

class	Uniform

class	UniformBufferObject

class	UniformContainer

class	UniformInstance

class	UniformLeafInstance

class	UniformStruct

class	UniformStructArray

class	UniformStructArrayInstance

class	UniformStructInstance

class	UniformValue

class	UniformValueArray

class	UniformValueArrayInstance

class	UniformValueInstance

class	UniqueCalendarItem

class	VertexAttribute

class	VertexAttributeDeclaration

class	VertexBuffer

class	Video

class	VideoFile

class	VideoPlayer

class	VideoService

class	VideoShader

class	VisualizeNormalsMesh

class	WebSocketClient

class	WebSocketClientEndPointSetup

class	WebSocketClientWrapper

class	WebSocketComponent

class	WebSocketComponentInstance

class	WebSocketConnection

class	WebSocketConnectionClosedEvent

class	WebSocketConnectionEvent

class	WebSocketConnectionFailedEvent

class	WebSocketConnectionOpenedEvent

class	WebSocketEvent

class	WebSocketInterface

class	WebSocketMessage

class	WebSocketMessageReceivedEvent

class	WebSocketServer

class	WebSocketServerEndPointSetup

class	WebSocketService

class	WebSocketTicket

struct	WebSocketTicketHash

class	WeeklyCalendarItem

class	Window

class	WindowCloseEvent

class	WindowEnterEvent

class	WindowEvent

class	WindowExposedEvent

class	WindowFocusGainedEvent

class	WindowFocusLostEvent

class	WindowHiddenEvent

class	WindowInputEvent

class	WindowLeaveEvent

class	WindowMaximizedEvent

class	WindowMinimizedEvent

class	WindowMovedEvent

class	WindowResizedEvent

class	WindowRestoredEvent

class	WindowShownEvent

class	WindowTakeFocusEvent

class	WorkerThread

class	YearlyCalendarItem

class	ZComparer

Typedefs
using	ServiceConfigMap = std::unordered_map< rtti::TypeInfo, ServiceConfiguration * >

using	SystemClock = std::chrono::system_clock
	System clock, able to convert time points in to days, seconds etc. More...

using	HighResolutionClock = std::chrono::high_resolution_clock
	High resolution clock, works with the highest possible precision. Can't convert time points in to days, seconds etc. More...

using	SteadyClock = std::chrono::steady_clock
	Monotonic clock. The time points of this clock cannot decrease as time moves forward and the time between ticks of this clock is constant. This clock is not related to wall clock time (for example, it can be time since last reboot), and is most suitable for measuring intervals. More...

using	Milliseconds = std::chrono::milliseconds
	Milliseconds type definition. More...

using	MicroSeconds = std::chrono::microseconds
	Microseconds type definition. More...

using	NanoSeconds = std::chrono::nanoseconds
	Nanoseconds type definition. More...

using	Seconds = std::chrono::seconds
	Seconds type definition. More...

using	Minutes = std::chrono::minutes
	Minutes type definition. More...

using	Hours = std::chrono::hours
	Hours type definition. More...

using	SystemTimeStamp = std::chrono::time_point< SystemClock >
	Point in time associated with the SystemClock. More...

using	HighResTimeStamp = std::chrono::time_point< HighResolutionClock >
	Point in time associated with the HighResolutionClock. More...

using	SteadyTimeStamp = std::chrono::time_point< SteadyClock >
	Point in time associated with the SteadyClock. More...

using	EventPtr = std::unique_ptr< nap::Event >

using	ResourceGroup = Group< Resource >

using	LogMessageFormatter = std::function< std::string(const LogMessage &msg)>

using	int8 = int8_t

using	uint8 = uint8_t

using	int16 = int16_t

using	uint16 = uint16_t

using	int32 = int32_t

using	uint32 = uint32_t

using	int64 = int64_t

using	uint64 = uint64_t

using	uint = unsigned int

using	RTTIObjectGraph = ObjectGraph< RTTIObjectGraphItem >

template<typename T >
using	ResourcePtr = rtti::ObjectPtr< T >

using	SystemTimer = Timer< SystemClock >

using	HighResolutionTimer = Timer< HighResolutionClock >

using	SteadyTimer = Timer< SteadyClock >

using	APIArgumentList = std::vector< std::unique_ptr< APIArgument > >

using	APIEventPtr = std::unique_ptr< nap::APIEvent >

using	APIMessagePtr = std::unique_ptr< nap::APIMessage >

using	APIFloat = APIValue< float >

using	APIBool = APIValue< bool >

using	APIInt = APIValue< int >

using	APIChar = APIValue< char >

using	APIByte = APIValue< uint8_t >

using	APIString = APIValue< std::string >

using	APIDouble = APIValue< double >

using	APILong = APIValue< int64_t >

using	APIFloatArray = APIValue< std::vector< float > >

using	APIBoolArray = APIValue< std::vector< bool > >

using	APIIntArray = APIValue< std::vector< int > >

using	APICharArray = APIValue< std::vector< char > >

using	APIByteArray = APIValue< std::vector< uint8_t > >

using	APIStringArray = APIValue< std::vector< std::string > >

using	APIDoubleArray = APIValue< std::vector< double > >

using	APILongArray = APIValue< std::vector< int64_t > >

using	APIWebSocketClientObjectCreator = rtti::ObjectCreator< APIWebSocketClient, APIWebSocketService >

using	APIWebSocketEventPtr = std::unique_ptr< APIWebSocketEvent >

using	APIWebSocketServerObjectCreator = rtti::ObjectCreator< APIWebSocketServer, APIWebSocketService >

using	ArtNetNode = void *

using	ArtNetNodeCreator = rtti::ObjectCreator< ArtNetController, ArtNetService >

using	ArtNetEventPtr = std::unique_ptr< nap::ArtNetEvent >

using	ArtNetReceiverCreator = rtti::ObjectCreator< ArtNetReceiver, ArtNetService >

using	CalendarItemList = std::vector< nap::ResourcePtr< CalendarItem > >

using	OwnedCalendarItemList = std::vector< std::unique_ptr< CalendarItem > >

template<typename T >
using	RGBColorBase = Color< T, 3 >

template<typename T >
using	RGBAColorBase = Color< T, 4 >

template<typename T >
using	RColorBase = Color< T, 1 >

using	RGBColor8 = RGBColor< uint8 >

using	RGBColor16 = RGBColor< uint16 >

using	RGBColorFloat = RGBColor< float >

using	RGBAColor8 = RGBAColor< uint8 >

using	RGBAColor16 = RGBAColor< uint16 >

using	RGBAColorFloat = RGBAColor< float >

using	RColor8 = RColor< uint8 >

using	RColor16 = RColor< uint16 >

using	RColorFloat = RColor< float >

using	RGBColorData8 = RGBColor< uint8 * >

using	RGBColorData16 = RGBColor< uint16 * >

using	RGBColorDataFloat = RGBColor< float * >

using	RGBAColorData8 = RGBAColor< uint8 * >

using	RGBAColorData16 = RGBAColor< uint16 * >

using	RGBAColorDataFloat = RGBAColor< float * >

using	RColorData8 = RColor< uint8 * >

using	RColorData16 = RColor< uint16 * >

using	RColorDataFloat = RColor< float * >

using	FontObjectCreator = rtti::ObjectCreator< Font, FontService >

using	IconObjectCreator = rtti::ObjectCreator< Icon, IMGuiService >

using	InputEventPtr = std::unique_ptr< nap::InputEvent >

using	InputEventPtrList = std::vector< InputEventPtr >

using	WindowEventPtr = std::unique_ptr< WindowEvent >

using	WindowEventPtrList = std::vector< WindowEventPtr >

using	MidiValue = short

using	MidiInputPortObjectCreator = rtti::ObjectCreator< MidiInputPort, MidiService >

using	MidiOutputPortObjectCreator = rtti::ObjectCreator< MidiOutputPort, MidiService >

using	OSCValuePtr = std::unique_ptr< OSCBaseValue >

using	OSCFloat = OSCValue< float >

using	OSCBool = OSCValue< bool >

using	OSCInt = OSCValue< int >

using	OSCDouble = OSCValue< double >

using	OSCChar = OSCValue< char >

using	OSCArgumentList = std::vector< std::unique_ptr< OSCArgument > >

using	OSCEventPtr = std::unique_ptr< nap::OSCEvent >

using	OSCReceiverObjectCreator = rtti::ObjectCreator< OSCReceiver, OSCService >

using	ParameterFloatBlender = ParameterBlender< ParameterFloat, float >

using	ParameterDoubleBlender = ParameterBlender< ParameterDouble, double >

using	ParameterVec2Blender = ParameterBlender< ParameterVec2, glm::vec2 >

using	ParameterVec3Blender = ParameterBlender< ParameterVec3, glm::vec3 >

using	ParameterVec4Blender = ParameterBlender< ParameterVec4, glm::vec4 >

using	ParameterRGBAFloatBlender = ParameterBlender< ParameterRGBAColorFloat, RGBAColorFloat >

using	ParameterRGBFloatBlender = ParameterBlender< ParameterRGBColorFloat, RGBColorFloat >

using	ParameterRGBA8Blender = ParameterBlender< ParameterRGBAColor8, RGBAColor8 >

using	ParameterRGB8Blender = ParameterBlender< ParameterRGBColor8, RGBColor8 >

using	ParameterBoolBlender = ParameterBlender< ParameterBool, bool >

using	ParameterQuatBlender = ParameterBlender< ParameterQuat, glm::quat >

using	ParameterRGBColorFloat = ParameterSimple< RGBColorFloat >

using	ParameterRGBAColorFloat = ParameterSimple< RGBAColorFloat >

using	ParameterRGBColor8 = ParameterSimple< RGBColor8 >

using	ParameterRGBAColor8 = ParameterSimple< RGBAColor8 >

using	ParameterGroup = Group< Parameter >

using	ParameterMat3 = ParameterMat< glm::mat3 >

using	ParameterMat4 = ParameterMat< glm::mat4 >

using	ParameterFloat = ParameterNumeric< float >

using	ParameterInt = ParameterNumeric< int >

using	ParameterUInt = ParameterNumeric< uint >

using	ParameterByte = ParameterNumeric< uint8_t >

using	ParameterDouble = ParameterNumeric< double >

using	ParameterLong = ParameterNumeric< int64_t >

using	ParameterQuat = ParameterSimple< glm::quat >

using	ParameterBool = ParameterSimple< bool >

using	ParameterString = ParameterSimple< std::string >

using	ParameterVec2 = ParameterVec< glm::vec2 >

using	ParameterVec3 = ParameterVec< glm::vec3 >

using	ParameterVec4 = ParameterVec< glm::vec4 >

using	ParameterIVec2 = ParameterVec< glm::ivec2 >

using	ParameterIVec3 = ParameterVec< glm::ivec3 >

using	ParameterIVec4 = ParameterVec< glm::ivec4 >

using	PortalEventPtr = std::unique_ptr< PortalEvent >

using	PortalItemRGBColor8 = PortalItemColor< RGBColor8 >

using	PortalItemRGBAColor8 = PortalItemColor< RGBAColor8 >

using	PortalItemRGBColorFloat = PortalItemColor< RGBColorFloat >

using	PortalItemRGBAColorFloat = PortalItemColor< RGBAColorFloat >

using	PortalItemSliderByte = PortalItemNumeric< uint8_t >

using	PortalItemSliderInt = PortalItemNumeric< int >

using	PortalItemSliderLong = PortalItemNumeric< int64_t >

using	PortalItemSliderFloat = PortalItemNumeric< float >

using	PortalItemSliderDouble = PortalItemNumeric< double >

using	PortalItemToggle = PortalItemSimple< bool >

using	PortalItemTextField = PortalItemSimple< std::string >

using	PortalItemVec2 = PortalItemVec< glm::vec2 >

using	PortalItemVec3 = PortalItemVec< glm::vec3 >

using	PortalItemIVec2 = PortalItemVec< glm::ivec2 >

using	PortalItemIVec3 = PortalItemVec< glm::ivec3 >

using	PortalWebSocketServerObjectCreator = rtti::ObjectCreator< PortalWebSocketServer, PortalService >

using	PythonScriptObjectCreator = rtti::ObjectCreator< PythonScript, PythonScriptService >

using	Blur5x5Shader = BlurShader< EBlurSamples::X5 >

using	Blur9x9Shader = BlurShader< EBlurSamples::X9 >

using	Blur13x13Shader = BlurShader< EBlurSamples::X13 >

using	BufferBindingUInt = TypedBufferBindingNumeric< uint >

using	BufferBindingInt = TypedBufferBindingNumeric< int >

using	BufferBindingFloat = TypedBufferBindingNumeric< float >

using	BufferBindingVec2 = TypedBufferBindingNumeric< glm::vec2 >

using	BufferBindingVec3 = TypedBufferBindingNumeric< glm::vec3 >

using	BufferBindingVec4 = TypedBufferBindingNumeric< glm::vec4 >

using	BufferBindingIVec4 = TypedBufferBindingNumeric< glm::ivec4 >

using	BufferBindingUVec4 = TypedBufferBindingNumeric< glm::uvec4 >

using	BufferBindingMat4 = TypedBufferBindingNumeric< glm::mat4 >

using	BufferBindingChangedCallback = std::function< void(BufferBindingInstance &)>

using	BufferBindingUIntInstance = TypedBufferBindingNumericInstance< uint >

using	BufferBindingIntInstance = TypedBufferBindingNumericInstance< int >

using	BufferBindingFloatInstance = TypedBufferBindingNumericInstance< float >

using	BufferBindingVec2Instance = TypedBufferBindingNumericInstance< glm::vec2 >

using	BufferBindingVec3Instance = TypedBufferBindingNumericInstance< glm::vec3 >

using	BufferBindingVec4Instance = TypedBufferBindingNumericInstance< glm::vec4 >

using	BufferBindingIVec4Instance = TypedBufferBindingNumericInstance< glm::ivec4 >

using	BufferBindingUVec4Instance = TypedBufferBindingNumericInstance< glm::uvec4 >

using	BufferBindingMat4Instance = TypedBufferBindingNumericInstance< glm::mat4 >

using	FillPolicyUInt = FillPolicy< uint >

using	FillPolicyInt = FillPolicy< int >

using	FillPolicyFloat = FillPolicy< float >

using	FillPolicyVec2 = FillPolicy< glm::vec2 >

using	FillPolicyVec3 = FillPolicy< glm::vec3 >

using	FillPolicyVec4 = FillPolicy< glm::vec4 >

using	FillPolicyMat4 = FillPolicy< glm::mat4 >

using	ConstantFillPolicyUInt = ConstantFillPolicy< uint >

using	ConstantFillPolicyInt = ConstantFillPolicy< int >

using	ConstantFillPolicyFloat = ConstantFillPolicy< float >

using	ConstantFillPolicyVec2 = ConstantFillPolicy< glm::vec2 >

using	ConstantFillPolicyVec3 = ConstantFillPolicy< glm::vec3 >

using	ConstantFillPolicyVec4 = ConstantFillPolicy< glm::vec4 >

using	ConstantFillPolicyMat4 = ConstantFillPolicy< glm::mat4 >

using	GPUBufferUInt = TypedGPUBufferNumeric< uint >

using	GPUBufferInt = TypedGPUBufferNumeric< int >

using	GPUBufferFloat = TypedGPUBufferNumeric< float >

using	GPUBufferVec2 = TypedGPUBufferNumeric< glm::vec2 >

using	GPUBufferVec3 = TypedGPUBufferNumeric< glm::vec3 >

using	GPUBufferVec4 = TypedGPUBufferNumeric< glm::vec4 >

using	GPUBufferMat4 = TypedGPUBufferNumeric< glm::mat4 >

using	VertexBufferUInt = VertexBuffer< uint >

using	VertexBufferInt = VertexBuffer< int >

using	VertexBufferFloat = VertexBuffer< float >

using	VertexBufferVec2 = VertexBuffer< glm::vec2 >

using	VertexBufferVec3 = VertexBuffer< glm::vec3 >

using	VertexBufferVec4 = VertexBuffer< glm::vec4 >

using	ShaderConstantHash = uint

using	RTTIMeshProperties = MeshProperties< rtti::ObjectPtr< BaseVertexAttribute > >

using	RandomFillPolicyUInt = RandomFillPolicy< uint >

using	RandomFillPolicyInt = RandomFillPolicy< int >

using	RandomFillPolicyFloat = RandomFillPolicy< float >

using	RandomFillPolicyVec2 = RandomFillPolicy< glm::vec2 >

using	RandomFillPolicyVec3 = RandomFillPolicy< glm::vec3 >

using	RandomFillPolicyVec4 = RandomFillPolicy< glm::vec4 >

using	RandomFillPolicyMat4 = RandomFillPolicy< glm::mat4 >

using	DisplayList = std::vector< Display >

using	RenderMask = uint64

using	RenderTagGroup = Group< RenderTag >

using	SamplerDeclarations = std::vector< SamplerDeclaration >

using	SamplerChangedCallback = std::function< void(SamplerInstance &, int)>

using	ShaderConstantID = uint

using	ShaderConstantMap = std::map< ShaderConstantID, uint >

using	ShaderStageConstantMap = std::map< VkShaderStageFlagBits, ShaderConstantMap >

using	ShaderConstantDeclarations = std::vector< ShaderConstantDeclaration >

using	BufferObjectDeclarationList = std::vector< nap::BufferObjectDeclaration >

using	StructFillPolicyUInt = StructFillPolicy::Entry< uint >

using	StructFillPolicyInt = StructFillPolicy::Entry< int >

using	StructFillPolicyFloat = StructFillPolicy::Entry< float >

using	StructFillPolicyVec2 = StructFillPolicy::Entry< glm::vec2 >

using	StructFillPolicyVec3 = StructFillPolicy::Entry< glm::vec3 >

using	StructFillPolicyVec4 = StructFillPolicy::Entry< glm::vec4 >

using	StructFillPolicyMat4 = StructFillPolicy::Entry< glm::mat4 >

using	UniformCreatedCallback = std::function< void()>

using	UniformUInt = TypedUniformValue< uint >

using	UniformInt = TypedUniformValue< int >

using	UniformFloat = TypedUniformValue< float >

using	UniformVec2 = TypedUniformValue< glm::vec2 >

using	UniformVec3 = TypedUniformValue< glm::vec3 >

using	UniformVec4 = TypedUniformValue< glm::vec4 >

using	UniformIVec4 = TypedUniformValue< glm::ivec4 >

using	UniformUVec4 = TypedUniformValue< glm::uvec4 >

using	UniformMat4 = TypedUniformValue< glm::mat4 >

using	UniformUIntArray = TypedUniformValueArray< uint >

using	UniformIntArray = TypedUniformValueArray< int >

using	UniformFloatArray = TypedUniformValueArray< float >

using	UniformVec2Array = TypedUniformValueArray< glm::vec2 >

using	UniformVec3Array = TypedUniformValueArray< glm::vec3 >

using	UniformVec4Array = TypedUniformValueArray< glm::vec4 >

using	UniformIVec4Array = TypedUniformValueArray< glm::ivec4 >

using	UniformUVec4Array = TypedUniformValueArray< glm::uvec4 >

using	UniformMat4Array = TypedUniformValueArray< glm::mat4 >

using	UniformUIntInstance = TypedUniformValueInstance< uint >

using	UniformIntInstance = TypedUniformValueInstance< int >

using	UniformFloatInstance = TypedUniformValueInstance< float >

using	UniformVec2Instance = TypedUniformValueInstance< glm::vec2 >

using	UniformVec3Instance = TypedUniformValueInstance< glm::vec3 >

using	UniformVec4Instance = TypedUniformValueInstance< glm::vec4 >

using	UniformIVec4Instance = TypedUniformValueInstance< glm::ivec4 >

using	UniformUVec4Instance = TypedUniformValueInstance< glm::uvec4 >

using	UniformMat4Instance = TypedUniformValueInstance< glm::mat4 >

using	UniformUIntArrayInstance = TypedUniformValueArrayInstance< uint >

using	UniformIntArrayInstance = TypedUniformValueArrayInstance< int >

using	UniformFloatArrayInstance = TypedUniformValueArrayInstance< float >

using	UniformVec2ArrayInstance = TypedUniformValueArrayInstance< glm::vec2 >

using	UniformVec3ArrayInstance = TypedUniformValueArrayInstance< glm::vec3 >

using	UniformVec4ArrayInstance = TypedUniformValueArrayInstance< glm::vec4 >

using	UniformIVec4ArrayInstance = TypedUniformValueArrayInstance< glm::ivec4 >

using	UniformUVec4ArrayInstance = TypedUniformValueArrayInstance< glm::uvec4 >

using	UniformMat4ArrayInstance = TypedUniformValueArrayInstance< glm::mat4 >

using	UIntVertexAttribute = VertexAttribute< uint >

using	IntVertexAttribute = VertexAttribute< int >

using	FloatVertexAttribute = VertexAttribute< float >

using	Vec2VertexAttribute = VertexAttribute< glm::vec2 >

using	Vec3VertexAttribute = VertexAttribute< glm::vec3 >

using	Vec4VertexAttribute = VertexAttribute< glm::vec4 >

using	VertexAttributeDeclarations = std::unordered_map< std::string, std::unique_ptr< VertexAttributeDeclaration > >

using	CubeDepthRenderTargetCallback = std::function< void(CubeDepthRenderTarget &target, const glm::mat4 &projection, const glm::mat4 &view)>

using	CubeRenderTargetCallback = std::function< void(CubeRenderTarget &target, const glm::mat4 &projection, const glm::mat4 &view)>

using	LightFlags = uint

using	ShadowFlags = uint

using	EntityList = std::vector< EntityInstance * >

using	EntityObjectGraph = ObjectGraph< EntityObjectGraphItem >

using	ClonedComponentResourceList = std::vector< ClonedComponentResource >

using	BoolInstancePropertyValue = TypedInstancePropertyValue< bool >

using	CharInstancePropertyValue = TypedInstancePropertyValue< char >

using	Int8InstancePropertyValue = TypedInstancePropertyValue< int8_t >

using	Int16InstancePropertyValue = TypedInstancePropertyValue< int16_t >

using	Int32InstancePropertyValue = TypedInstancePropertyValue< int32_t >

using	Int64InstancePropertyValue = TypedInstancePropertyValue< int64_t >

using	UInt8InstancePropertyValue = TypedInstancePropertyValue< uint8_t >

using	UInt16InstancePropertyValue = TypedInstancePropertyValue< uint16_t >

using	UInt32InstancePropertyValue = TypedInstancePropertyValue< uint32_t >

using	UInt64InstancePropertyValue = TypedInstancePropertyValue< uint64_t >

using	FloatInstancePropertyValue = TypedInstancePropertyValue< float >

using	DoubleInstancePropertyValue = TypedInstancePropertyValue< double >

using	Vec2InstancePropertyValue = TypedInstancePropertyValue< glm::vec2 >

using	Vec3InstancePropertyValue = TypedInstancePropertyValue< glm::vec3 >

using	Vec4InstancePropertyValue = TypedInstancePropertyValue< glm::vec4 >

using	IVec2InstancePropertyValue = TypedInstancePropertyValue< glm::ivec2 >

using	IVec3InstancePropertyValue = TypedInstancePropertyValue< glm::ivec3 >

using	QuatInstancePropertyValue = TypedInstancePropertyValue< glm::quat >

using	StringInstancePropertyValue = TypedInstancePropertyValue< std::string >

using	SceneCreator = rtti::ObjectCreator< Scene, Core >

using	SequenceEditorObjectCreator = rtti::ObjectCreator< SequenceEditor, SequenceService >

using	SequenceEventPtr = std::unique_ptr< SequenceEventBase >

using	SequenceEventString = SequenceEvent< std::string >

using	SequenceEventFloat = SequenceEvent< float >

using	SequenceEventInt = SequenceEvent< int >

using	SequenceEventVec2 = SequenceEvent< glm::vec2 >

using	SequenceEventVec3 = SequenceEvent< glm::vec3 >

using	SequencePlayerObjectCreator = rtti::ObjectCreator< SequencePlayer, SequenceService >

using	SequencePlayerStandClockObjectCreator = rtti::ObjectCreator< SequencePlayerStandardClock, SequenceService >

using	SequencePlayerCurveOutputObjectCreator = rtti::ObjectCreator< SequencePlayerCurveOutput, SequenceService >

using	SequencePlayerEventOutputObjectCreator = rtti::ObjectCreator< SequencePlayerEventOutput, SequenceService >

using	SequenceControllerFactoryFunc = std::function< std::unique_ptr< SequenceController >(SequencePlayer &, SequenceEditor &)>

using	SequenceControllerFactoryMap = std::unordered_map< rtti::TypeInfo, SequenceControllerFactoryFunc >

using	DefaultSequenceTrackFactoryMap = std::unordered_map< rtti::TypeInfo, std::function< std::unique_ptr< SequenceTrack >(const SequencePlayerOutput *)> >

using	SequencePlayerAdapterFactoryFunc = std::function< std::unique_ptr< SequencePlayerAdapter >(const SequenceTrack &, SequencePlayerOutput &, const SequencePlayer &)>

using	SequencePlayerAdapterFactoryMap = std::unordered_map< rtti::TypeInfo, SequencePlayerAdapterFactoryFunc >

using	SequenceTrackCurveFloat = SequenceTrackCurve< float >

using	SequenceTrackCurveVec2 = SequenceTrackCurve< glm::vec2 >

using	SequenceTrackCurveVec3 = SequenceTrackCurve< glm::vec3 >

using	SequenceTrackCurveVec4 = SequenceTrackCurve< glm::vec4 >

using	SequenceTrackSegmentCurveFloat = SequenceTrackSegmentCurve< float >

using	SequenceTrackSegmentCurveVec2 = SequenceTrackSegmentCurve< glm::vec2 >

using	SequenceTrackSegmentCurveVec3 = SequenceTrackSegmentCurve< glm::vec3 >

using	SequenceTrackSegmentCurveVec4 = SequenceTrackSegmentCurve< glm::vec4 >

using	SequenceTrackSegmentEventString = SequenceTrackSegmentEvent< std::string >

using	SequenceTrackSegmentEventFloat = SequenceTrackSegmentEvent< float >

using	SequenceTrackSegmentEventInt = SequenceTrackSegmentEvent< int >

using	SequenceTrackSegmentEventVec2 = SequenceTrackSegmentEvent< glm::vec2 >

using	SequenceTrackSegmentEventVec3 = SequenceTrackSegmentEvent< glm::vec3 >

using	SequenceTrackSegmentEventVec4 = SequenceTrackSegmentEvent< glm::vec4 >

using	SequencePlayerAudioClockObjectCreator = rtti::ObjectCreator< SequencePlayerAudioClock, SequenceServiceAudio >

using	BufferPlayerMap = std::unordered_map< std::string, audio::SafeOwner< audio::MultiSampleBufferPlayerNode > >

using	SequencePlayerAudioOutputObjectCreator = rtti::ObjectCreator< SequencePlayerAudioOutput, SequenceService >

using	SequenceEditorGUIObjectCreator = rtti::ObjectCreator< SequenceEditorGUI, SequenceGUIService >

using	SequenceEventTrackSegmentViewFactoryFunc = std::function< std::unique_ptr< SequenceEventTrackSegmentViewBase >()>

using	SequenceEventTrackSegmentViewFactoryMap = std::unordered_map< rtti::TypeInfo, SequenceEventTrackSegmentViewFactoryFunc >

using	SequenceTrackViewFactoryFunc = std::function< std::unique_ptr< SequenceTrackView >(SequenceGUIService &, SequenceEditorGUIView &, SequenceEditorGUIState &)>

using	SequenceTrackViewFactoryMap = std::unordered_map< rtti::TypeInfo, SequenceTrackViewFactoryFunc >

using	SequenceTrackTypeForViewTypeMap = std::unordered_map< rtti::TypeInfo, rtti::TypeInfo >

using	SequenceEventTrackPasteFunc = std::function< void(SequenceEventTrackView &, const std::string &, const SequenceTrackSegmentEventBase &, double)>

using	SequenceEventTrackEditFunc = std::function< void(SequenceEventTrackView &)>

using	UDPThreadObjectCreator = rtti::ObjectCreator< UDPThread, UDPService >

using	VideoPlayerObjectCreator = rtti::ObjectCreator< VideoPlayer, VideoService >

using	WebSocketClientObjectCreator = rtti::ObjectCreator< WebSocketClient, WebSocketService >

using	WebSocketClientEndPoint = WebSocketClientEndPointSetup< wspp::Config >

using	WebSocketConnectionPtr = std::unique_ptr< WebSocketConnection >

using	WebSocketEventPtr = std::unique_ptr< nap::WebSocketEvent >

using	WebSocketServerObjectCreator = rtti::ObjectCreator< WebSocketServer, WebSocketService >

using	WebSocketServerEndPoint = WebSocketServerEndPointSetup< wspp::Config >

Enumerations
enum	EDay : int { Monday = 1, Tuesday = 2, Wednesday = 3, Thursday = 4, Friday = 5, Saturday = 6, Sunday = 0, Unknown = -1 }

enum	EMonth : int { January = 1, February = 2, March = 3, April = 4, May = 5, June = 6, July = 7, August = 8, September = 9, October = 10, November = 11, December = 12, Unknown = -1 }

enum	EArtnetMode : int { Broadcast = 0, Unicast = 1 }

enum	ECameraMode : uint8_t { None = 0x00, FirstPerson = 0x01, Orbit = 0x02, OrthographicTop = 0x04, OrthographicBottom = 0x08, OrthographicLeft = 0x10, OrthographicRight = 0x20, OrthographicFront = 0x40, OrthographicBack = 0x80, Perspective = FirstPerson \| Orbit, Orthographic = OrthographicTop \| OrthographicBottom \| OrthographicLeft \| OrthographicRight \| OrthographicFront \| OrthographicBack }

enum	EColorChannel : int { Red = 0, Green = 1, Blue = 2, Alpha = 3 }

enum	EControllerButton : int { UNKNOWN = -1, A, B, X, Y, BACK, GUIDE, START, LEFT_STICK, RIGHT_STICK, LEFT_SHOULDER, RIGHT_SHOULDER, DPAD_UP, DPAD_DOWN, DPAD_LEFT, DPAD_RIGHT }

enum	EControllerAxis : int { UNKNOWN = -1, LEFT_X, LEFT_Y, RIGHT_X, RIGHT_Y, TRIGGER_LEFT, TRIGGER_RIGHT }

enum	EKeyCode : int { KEY_UNKNOWN = -1, KEY_RETURN, KEY_ESCAPE, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_EXCLAIM, KEY_QUOTEDBL, KEY_HASH, KEY_PERCENT, KEY_DOLLAR, KEY_AMPERSAND, KEY_QUOTE, KEY_LEFTPAREN, KEY_RIGHTPAREN, KEY_ASTERISK, KEY_PLUS, KEY_COMMA, KEY_MINUS, KEY_PERIOD, KEY_SLASH, KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_COLON, KEY_SEMICOLON, KEY_LESS, KEY_EQUALS, KEY_GREATER, KEY_QUESTION, KEY_AT, KEY_LEFTBRACKET, KEY_BACKSLASH, KEY_RIGHTBRACKET, KEY_CARET, KEY_UNDERSCORE, KEY_BACKQUOTE, KEY_a, KEY_b, KEY_c, KEY_d, KEY_e, KEY_f, KEY_g, KEY_h, KEY_i, KEY_j, KEY_k, KEY_l, KEY_m, KEY_n, KEY_o, KEY_p, KEY_q, KEY_r, KEY_s, KEY_t, KEY_u, KEY_v, KEY_w, KEY_x, KEY_y, KEY_z, KEY_CAPSLOCK, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12, KEY_PRINTSCREEN, KEY_SCROLLLOCK, KEY_PAUSE, KEY_INSERT, KEY_HOME, KEY_PAGEUP, KEY_DELETE, KEY_END, KEY_PAGEDOWN, KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP, KEY_NUMLOCKCLEAR, KEY_KP_DIVIDE, KEY_KP_MULTIPLY, KEY_KP_MINUS, KEY_KP_PLUS, KEY_KP_ENTER, KEY_KP_1, KEY_KP_2, KEY_KP_3, KEY_KP_4, KEY_KP_5, KEY_KP_6, KEY_KP_7, KEY_KP_8, KEY_KP_9, KEY_KP_0, KEY_KP_PERIOD, KEY_APPLICATION, KEY_POWER, KEY_KP_EQUALS, KEY_F13, KEY_F14, KEY_F15, KEY_F16, KEY_F17, KEY_F18, KEY_F19, KEY_F20, KEY_F21, KEY_F22, KEY_F23, KEY_F24, KEY_EXECUTE, KEY_HELP, KEY_MENU, KEY_SELECT, KEY_STOP, KEY_AGAIN, KEY_UNDO, KEY_CUT, KEY_COPY, KEY_PASTE, KEY_FIND, KEY_MUTE, KEY_VOLUMEUP, KEY_VOLUMEDOWN, KEY_KP_COMMA, KEY_KP_EQUALSAS400, KEY_ALTERASE, KEY_SYSREQ, KEY_CANCEL, KEY_CLEAR, KEY_PRIOR, KEY_RETURN2, KEY_SEPARATOR, KEY_OUT, KEY_OPER, KEY_CLEARAGAIN, KEY_CRSEL, KEY_EXSEL, KEY_KP_00, KEY_KP_000, KEY_THOUSANDSSEPARATOR, KEY_DECIMALSEPARATOR, KEY_CURRENCYUNIT, KEY_CURRENCYSUBUNIT, KEY_KP_LEFTPAREN, KEY_KP_RIGHTPAREN, KEY_KP_LEFTBRACE, KEY_KP_RIGHTBRACE, KEY_KP_TAB, KEY_KP_BACKSPACE, KEY_KP_A, KEY_KP_B, KEY_KP_C, KEY_KP_D, KEY_KP_E, KEY_KP_F, KEY_KP_XOR, KEY_KP_POWER, KEY_KP_PERCENT, KEY_KP_LESS, KEY_KP_GREATER, KEY_KP_AMPERSAND, KEY_KP_DBLAMPERSAND, KEY_KP_VERTICALBAR, KEY_KP_DBLVERTICALBAR, KEY_KP_COLON, KEY_KP_HASH, KEY_KP_SPACE, KEY_KP_AT, KEY_KP_EXCLAM, KEY_KP_MEMSTORE, KEY_KP_MEMRECALL, KEY_KP_MEMCLEAR, KEY_KP_MEMADD, KEY_KP_MEMSUBTRACT, KEY_KP_MEMMULTIPLY, KEY_KP_MEMDIVIDE, KEY_KP_PLUSMINUS, KEY_KP_CLEAR, KEY_KP_CLEARENTRY, KEY_KP_BINARY, KEY_KP_OCTAL, KEY_KP_DECIMAL, KEY_KP_HEXADECIMAL, KEY_LCTRL, KEY_LSHIFT, KEY_LALT, KEY_LGUI, KEY_RCTRL, KEY_RSHIFT, KEY_RALT, KEY_RGUI, KEY_MODE, KEY_AUDIONEXT, KEY_AUDIOPREV, KEY_AUDIOSTOP, KEY_AUDIOPLAY, KEY_AUDIOMUTE, KEY_MEDIASELECT, KEY_WWW, KEY_MAIL, KEY_CALCULATOR, KEY_COMPUTER, KEY_AC_SEARCH, KEY_AC_HOME, KEY_AC_BACK, KEY_AC_FORWARD, KEY_AC_STOP, KEY_AC_REFRESH, KEY_AC_BOOKMARKS, KEY_BRIGHTNESSDOWN, KEY_BRIGHTNESSUP, KEY_DISPLAYSWITCH, KEY_KBDILLUMTOGGLE, KEY_KBDILLUMDOWN, KEY_KBDILLUMUP, KEY_EJECT, KEY_SLEEP }

enum	EMouseButton : int { UNKNOWN = -1, LEFT = 0, MIDDLE = 1, RIGHT = 2 }

enum	ESigningScheme : int { SHA1 = 0, SHA224 = 1, SHA256 = 2, SHA384 = 3, SHA512 = 4 }

enum	EPortalEventType : int { Request = 0, Response = 1, Update = 2, Invalid = -1 }

enum	EPortalItemButtonEvent : int { Click = 0, Press = 1, Release = 2, Invalid = -1 }

enum	EBlurSamples : uint { X5 = 0, X9 = 1, X13 = 2 }

enum	EFBXConversionOptions { CONVERT_ALWAYS, CONVERT_IF_NEWER }

enum	EMemoryUsage : uint { Static, DynamicRead, DynamicWrite }

enum	EBlendMode : int { NotSet = 0, Opaque, AlphaBlend, Additive }

enum	ECullWindingOrder : int { Clockwise = 0, CounterClockwise }

enum	EDepthMode : int { NotSet = 0, InheritFromBlendMode, ReadWrite, ReadOnly, WriteOnly, NoReadWrite }

enum	EDepthCompareMode : int { NotSet = 0, Never, Less, Equal, LessOrEqual, Greater, NotEqual, GreaterOrEqual, Always }

enum	EDrawMode : int32 { Points = 0, Lines = 1, LineStrip = 2, Triangles = 3, TriangleStrip = 4, TriangleFan = 5, Unknown = 0x7FFFFFFF }

enum	ECullMode : int32 { None = 0, Front = 1, Back = 2, FrontAndBack = 3 }

enum	EPolygonMode : int32 { Fill = 0, Line = 1, Point = 2 }

enum	EOrthoCameraMode : nap::uint8 { PixelSpace = 0, CorrectAspectRatio, Custom }

enum	ERasterizationSamples : int { One = 0x00000001, Two = 0x00000002, Four = 0x00000004, Eight = 0x00000008, Sixteen = 0x00000010, Max = 0x00000000 }

enum	EFilterMode : uint32 { Nearest = 0, Linear }

enum	EAddressMode : uint32 { Repeat = 0, MirroredRepeat, ClampToEdge, ClampToBorder }

enum	EAnisotropicSamples : uint32 { Default = 0, Four = 4, Eight = 8, Sixteen = 16 }

enum	EBorderColor : uint32 { FloatTransparentBlack = 0, IntTransparentBlack, FloatOpaqueBlack, IntOpaqueBlack, FloatOpaqueWhite, IntOpaqueWhite }

enum	EDescriptorType : uint { Uniform, Storage }

enum	EShaderVariableValueType : uint8 { Unknown = 0, Float, Int, UInt, Vec2, Vec3, Vec4, IVec4, UVec4, Mat2, Mat3, Mat4 }

enum	ESurfaceDataType : int { BYTE = 0, USHORT = 1, FLOAT = 2 }

enum	ESurfaceChannels : int { R = 0, RGBA = 1, BGRA = 2, D = 3 }

enum	EColorSpace : int { Linear, sRGB }

enum	ELightType : uint8 { Custom = 0, Directional = 1, Point = 2, Spot = 3 }

enum	EShadowMapType : uint8 { Quad = 0, Cube = 1 }

enum	ESerialByteSize : int { Five = 5, Six = 6, Seven = 7, Eight = 8 }

enum	ESerialStopBits : int { One = 1, Two = 2, OnePointFive = 3 }

enum	ESerialFlowControl : int { None = 0, Software = 1, Hardware = 2 }

enum	ESerialParity : int { None = 0, Odd = 1, Even = 2, Mark = 3, Space = 4 }

enum	ESVGUnits : int { PX = 0, PT, PC, MM, CM, DPI }

enum	EUDPThreadUpdateMethod : int { UDP_MAIN_THREAD = 0, UDP_SPAWN_OWN_THREAD = 1, UDP_MANUAL = 2 }

enum	EWebSocketLogLevel : uint32 { None = 0x0, Debug = 0x1, Library = 0x2, Info = 0x4, Warning = 0x8, Error = 0x10, Fatal = 0x20, All = 0xffffffff }

enum	EWebSocketOPCode : uint32 { Continuation = 0x0, Text = 0x1, Binary = 0x2, RSV3 = 0x3, RSV4 = 0x4, RSV5 = 0x5, RSV6 = 0x6, RSV7 = 0x7, Close = 0x8, Ping = 0x9, Pong = 0xA, ControlRSVB = 0xB, ControlRSVC = 0xC, ControlRSVD = 0xD, ControlRSVE = 0xE, ControlRSVF = 0xF }

Functions
void NAPAPI	_assert (const char exprs, bool expr, const char file, int line)

void NAPAPI	_assertMsg (const char exprs, bool expr, const char file, int line, const char *message)

NAPAPI SystemTimeStamp	getCurrentTime ()

NAPAPI DateTime	getCurrentDateTime ()

NAPAPI void	getCurrentDateTime (DateTime &outDateTime)

NAPAPI std::string	timeFormat (const SystemTimeStamp &time, const std::string &format="%Y-%m-%d %H:%M:%S.%ms")

NAPAPI SystemTimeStamp	createTimestamp (int year, int month, int day, int hour, int minute, int second=0, int millisecond=0, bool daylightSaving=true)

const NAPAPI std::array< EDay, 7 > &	getDaysInWeek ()

NAPAPI std::string	toString (EDay day)

NAPAPI EDay	toDay (const std::string &string)

NAPAPI std::string	toString (EMonth month)

NAPAPI EMonth	toMonth (const std::string &string)

std::string	basicLogMessageFormatter (const LogMessage &msg)

std::string	timestampLogMessageFormatter (const LogMessage &msg)

NAPAPI void	initModules ()

NAPAPI void *	loadModule (const nap::ModuleInfo &modInfo, const std::string &modulePath, std::string &errorString)

NAPAPI void	unloadModule (void *module)

NAPAPI void *	findSymbolInModule (void module, const char symbolName)

NAPAPI std::string	getModuleExtension ()

NAPAPI bool	extractMessages (const std::string &json, rtti::DeserializeResult &result, rtti::Factory &factory, std::vector< APIMessage * > &outMessages, utility::ErrorState &error)

ECameraMode	operator& (ECameraMode a, ECameraMode b)

ECameraMode	operator\| (ECameraMode a, ECameraMode b)

std::unique_ptr< BaseParameterBlender > NAPAPI	getParameterBlender (nap::Parameter &param)

bool NAPAPI	registerParameterBlender (rtti::TypeInfo inParameterType, rtti::TypeInfo inBlenderType)

NAPAPI std::string	getPortalEventTypeString (const EPortalEventType &type)

NAPAPI EPortalEventType	getPortalEventType (const std::string &type)

NAPAPI std::string	getPortalItemButtonEventString (const EPortalItemButtonEvent &event)

NAPAPI EPortalItemButtonEvent	getPortalItemButtonEvent (const std::string &event)

NAPAPI bool	extractPortalEventHeader (const APIEventPtr &event, PortalEventHeader &outHeader, utility::ErrorState &error)

NAPAPI APIEventPtr	createPortalEventHeader (const PortalEventHeader &header)

NAPAPI void	copyImageData (const uint8_t source, unsigned int sourcePitch, ESurfaceChannels sourceChannels, uint8_t target, unsigned int targetPitch, ESurfaceChannels targetChannels, int width, int height)

NAPAPI bool	convertFBX (const std::string &fbxPath, const std::string &outputDirectory, EFBXConversionOptions convertOptions, std::vector< std::string > &convertedFiles, utility::ErrorState &errorState)

NAPAPI std::unique_ptr< MeshInstance >	loadMesh (RenderService &renderService, const std::string &meshPath, utility::ErrorState &errorState)

NAPAPI VkBufferUsageFlags	getVulkanBufferUsage (nap::EDescriptorType descriptorType)

NAPAPI VkDescriptorType	getVulkanDescriptorType (nap::EDescriptorType descriptorType)

NAPAPI VkFormat	getVulkanFormat (nap::rtti::TypeInfo type)

template<typename ELEMENTTYPE >
VkFormat	getVulkanFormat ()

template<class T >
const Uniform *	findUniformStructMember (const std::vector< T > &members, const ShaderVariableDeclaration &declaration)

size_t NAPAPI	getUniformStructSizeRecursive (const UniformStruct &uniformStruct)

int NAPAPI	getUniformStructDepth (const UniformStruct &uniformStruct)

bool NAPAPI	isLightEnabled (LightFlags flags)

bool NAPAPI	isShadowEnabled (LightFlags flags)

bool NAPAPI	isShadowSupported (LightFlags flags)

uint NAPAPI	getLightType (LightFlags flags)

uint NAPAPI	getShadowMapType (LightFlags flags)

uint NAPAPI	getLightIndex (LightFlags flags)

LightFlags NAPAPI	getLightFlags (const LightComponentInstance &light, uint index)

void NAPAPI	updateLightFlags (const LightComponentInstance &light, LightFlags &outFlags)

ShadowFlags NAPAPI	getShadowFlags (const std::vector< LightComponentInstance * > lights)

template<typename TargetComponentType , typename SourceComponentType >
ComponentInstancePtrInitProxy< TargetComponentType, SourceComponentType >	initComponentInstancePtr (ComponentInstance sourceComponentInstance, ComponentPtr< TargetComponentType >(SourceComponentType::componentMemberPointer))

template<typename TargetComponentType , typename SourceComponentType >
std::vector< ComponentInstancePtr< TargetComponentType > >	initComponentInstancePtr (ComponentInstance sourceComponentInstance, std::vector< ComponentPtr< TargetComponentType >>(SourceComponentType::componentMemberPointer))

template<typename TargetComponentType , typename SourceComponentType >
nap::ComponentInstancePtrInitProxy< TargetComponentType, SourceComponentType >	initComponentInstancePtr (ComponentInstance sourceComponentInstance, ComponentPtr< TargetComponentType >(SourceComponentType::componentMemberPointer))

template<typename TargetComponentType , typename SourceComponentType >
std::vector< nap::ComponentInstancePtr< TargetComponentType > >	initComponentInstancePtr (ComponentInstance sourceComponentInstance, std::vector< ComponentPtr< TargetComponentType >>(SourceComponentType::componentMemberPointer))

template<typename T >
void	getComponentsOfTypeRecursive (nap::EntityInstance &entity, std::vector< T * > &outComponents)

template<typename SourceComponentType >
EntityInstancePtrInitProxy< SourceComponentType >	initEntityInstancePtr (ComponentInstance sourceComponentInstance, EntityPtr(SourceComponentType::entityMemberPointer))

template<typename SourceComponentType >
std::vector< EntityInstancePtr >	initEntityInstancePtr (ComponentInstance sourceComponentInstance, std::vector< EntityPtr >(SourceComponentType::entityMemberPointer))

template<typename SourceComponentType >
nap::EntityInstancePtrInitProxy< SourceComponentType >	initEntityInstancePtr (ComponentInstance sourceComponentInstance, EntityPtr(SourceComponentType::entityMemberPointer))

template<typename SourceComponentType >
std::vector< nap::EntityInstancePtr >	initEntityInstancePtr (ComponentInstance sourceComponentInstance, std::vector< EntityPtr >(SourceComponentType::entityMemberPointer))

template<>
void	SequenceCurveTrackView::showValue< glm::vec2 > (const SequenceTrack &track, const SequenceTrackSegmentCurve< glm::vec2 > &segment, float x, double time, int curveIndex)

template<>
void	SequenceCurveTrackView::showValue< glm::vec3 > (const SequenceTrack &track, const SequenceTrackSegmentCurve< glm::vec3 > &segment, float x, double time, int curveIndex)

template<>
void	SequenceCurveTrackView::showValue< glm::vec4 > (const SequenceTrack &track, const SequenceTrackSegmentCurve< glm::vec4 > &segment, float x, double time, int curveIndex)

template<>
bool	SequenceCurveTrackView::inputFloat< glm::vec2 > (glm::vec2 &v, int precision)

template<>
bool	SequenceCurveTrackView::inputFloat< glm::vec3 > (glm::vec3 &v, int precision)

template<>
bool	SequenceCurveTrackView::inputFloat< glm::vec4 > (glm::vec4 &v, int precision)

std::vector< int > NAPAPI	convertTimeToMMSSMSArray (double time)

double NAPAPI	convertMMSSMSArrayToTime (const std::vector< int > &timeArray)

NAPAPI uint32	computeWebSocketLogLevel (EWebSocketLogLevel level)

Variables
constexpr const char *	calendarDirectory = "calendar"
	Directory where all calendars are stored. More...

constexpr uint	manropeMediumSize = 80368

const uint	manropeMediumData [manropeMediumSize/4]

constexpr int	moduleAPIVersion = 1
	Current module API version. More...

Detailed Description

This file contains the macros necessary to register types and their attributes with the RTTI system. When registering into the RTTI system, properties and functions are also automatically exposed to Python.

There are only a few macros important for the user of the RTTI system:

RTTI_OF - This is a convenience macro used to get the underlying TypeInfo of the named type. Usage example: RTTI_OF(rtti::RTTIObject).
RTTI_ENABLE - This macro must be used when you have a class that is part of an inheritance hierarchy. The argument to the macro is a comma-separated list of base classes (empty if the macro is being used in the base class itself).
RTTI_BEGIN_CLASS, RTTI_BEGIN_STRUCT, RTTI_END_CLASS, RTTI_END_STRUCT, RTTI_PROPERTY, RTTI_FUNCTION - These macros are used to register a type or function in the RTTI system and must be placed in a .cpp file.
RTTI_BEGIN_ENUM/RTTI_END_ENUM - These macros are used to register an enum in the RTTI system and must be placed in a .cpp file

See the following example for a typical usage scenario of these macros:

    enum class ETestEnum
{
    One,
    Two,
    Three,
    Four
};

// RTTIClasses.h
struct DataStruct
{
    float       mFloatProperty;
    std::string mStringProperty;
    ETestEnum   mEnumProperty;
};

class BaseClass
{
    RTTI_ENABLE()
private:
    float       mFloatProperty;

};

class DerivedClass : public BaseClass
{
    RTTI_ENABLE(SomeBaseClass)

    DerivedClass() = default;
    DerivedClass(int value) :
        mIntProperty(value)
    {
    }

    int getValue() const { return mIntProperty; }

private:
    int         mIntProperty;
};

The above code defines four new types:

ETestEnum An enum that will be used in one of the other RTTI classes
DataStruct: A class without base or derived classes. Note that the RTTI_ENABLED macro is not used for this class. The fact that the RTTI_ENABLED macro is optional (it's only required when the class is part of an inheritance hierarchy) makes it possible to add RTTI to third party classes, since no modification of the class itself is required. This is also very efficient, because when RTTI_ENABLED is not used, no vtable is required in the class. A good example of this is adding RTTI support to classes such as glm::vec2, glm::vec3, etc; types that we have no control over, but we want to add RTTI to, without adding a vtable to them.
BaseClass This class is designed to be the base-class of an inheritance hierarchy. Because of this, a RTTI_ENABLED macro is required in the class definition in order for RTTI to properly work Note that because this is the base class, no arguments to the RTTI_ENABLED macro are needed
DerivedClass This class is part of an inheritance hierarchy and in this case inherits from BaseClass. Again, this means a RTTI_ENABLED macro is required in the class definition. Note that because this class derives from another RTTI class (BaseClass), the class it derives from must be specified as argument to the RTTI_ENABLE macro. The class has two constructors: the default constructor (which will be registered by default) and another constructor that we will have to register manually. GetValue is a function that we are going to expose as well.

Note that the code in the header does not actually register these types with the RTTI system; the RTTI_ENABLED macro is only used to add some plumbing (virtual calls) to the class, not to do actual registration. In order to actually register the types with the RTTI system, the following code must be added to the cpp file:

// RTTIClasses.cpp
RTTI_BEGIN_ENUM(ETestEnum)
    RTTI_ENUM_VALUE(ETestEnum::One,     "One"),
    RTTI_ENUM_VALUE(ETestEnum::Two,     "Two"),
    RTTI_ENUM_VALUE(ETestEnum::Three,   "Three"),
    RTTI_ENUM_VALUE(ETestEnum::Four,    "Four")
RTTI_END_ENUM

RTTI_BEGIN_CLASS(DataStruct)
        RTTI_PROPERTY("FloatProperty",  &DataStruct::mFloatProperty,    nap::rtti::EPropertyMetaData::None,         "Property description");
        RTTI_PROPERTY("StringProperty", &DataStruct::mStringProperty,   nap::rtti::EPropertyMetaData::Required,     "Property description");
        RTTI_PROPERTY("EnumProperty",   &DataStruct::mEnumProperty,     nap::rtti::EPropertyMetaData::Required,     "Property description");
RTTI_END_CLASS

RTTI_BEGIN_CLASS(BaseClass)
        RTTI_PROPERTY("FloatProperty",  &BaseClass::mFloatProperty, nap::rtti::EPropertyMetaData::None);
RTTI_END_CLASS

RTTI_BEGIN_CLASS(DerivedClass, "Type description")
        RTTI_CONSTRUCTOR(int)
        RTTI_PROPERTY("IntProperty",    &DerivedClass::mIntProperty, nap::rtti::EPropertyMetaData::None)
        RTTI_FUNCTION("getValue",       &DerivedClass::getValue)
RTTI_END_CLASS

The above code, which must be located in the cpp, is responsible for the registration. In general, to register a type and its attributes with the RTTI system, you simply use the RTTI_BEGIN_CLASS/RTTI_END_CLASS pair and add RTTI_PROPERTY, RTTI_CONSTRUCTOR and RTTI_FUNCTION calls to register the properties you need.

Once registered, the type can be looked up in the RTTI system and can be inspected for properties etc. A simple example that prints out the names of all properties of an RTTI class:

template<class T>
void printProperties()
{
    rtti::TypeInfo type = RTTI_OF(T); // Could also be rtti::TypeInfo::get<T>()

    std::cout << "Properties of " << type.get_name().data() << std::endl;
    for (const rtti::Property& property : type.get_properties())
    {
        std::cout << " -- " << property.get_name().data() << std::endl;
    }
}

printProperties<DataStruct>();

This namespace is only used to redefine some RTTR types to our own types so that the rttr:: namespace does not leak out everywhere

From https://github.com/jesusgollonet/ofpennereasing

All Photoshop blend modes. taken from http://www.deepskycolors.com/archivo/2010/04/21/formulas-for-Photoshop-blending-modes.html Operations should be done on normalized values. Some of these functions are just included for completeness (multiply anyone?)

Typedef Documentation

◆ APIArgumentList

using APIArgumentList = std::vector<std::unique_ptr<APIArgument> >

◆ APIBool

using APIBool = APIValue<bool>

◆ APIBoolArray

using APIBoolArray = APIValue<std::vector<bool> >

◆ APIByte

using APIByte = APIValue<uint8_t>

◆ APIByteArray

using APIByteArray = APIValue<std::vector<uint8_t> >

◆ APIChar

using APIChar = APIValue<char>

◆ APICharArray

using APICharArray = APIValue<std::vector<char> >

◆ APIDouble

using APIDouble = APIValue<double>

◆ APIDoubleArray

using APIDoubleArray = APIValue<std::vector<double> >

◆ APIEventPtr

using APIEventPtr = std::unique_ptr<nap::APIEvent>

◆ APIFloat

using APIFloat = APIValue<float>

◆ APIFloatArray

using APIFloatArray = APIValue<std::vector<float> >

◆ APIInt

using APIInt = APIValue<int>

◆ APIIntArray

using APIIntArray = APIValue<std::vector<int> >

◆ APILong

using APILong = APIValue<int64_t>

◆ APILongArray

using APILongArray = APIValue<std::vector<int64_t> >

◆ APIMessagePtr

using APIMessagePtr = std::unique_ptr<nap::APIMessage>

◆ APIString

using APIString = APIValue<std::string>

◆ APIStringArray

using APIStringArray = APIValue<std::vector<std::string> >

◆ APIWebSocketClientObjectCreator

using APIWebSocketClientObjectCreator = rtti::ObjectCreator<APIWebSocketClient, APIWebSocketService>

◆ APIWebSocketEventPtr

using APIWebSocketEventPtr = std::unique_ptr<APIWebSocketEvent>

◆ APIWebSocketServerObjectCreator

using APIWebSocketServerObjectCreator = rtti::ObjectCreator<APIWebSocketServer, APIWebSocketService>

◆ ArtNetEventPtr

using ArtNetEventPtr = std::unique_ptr<nap::ArtNetEvent>

◆ ArtNetNode

using ArtNetNode = void*

◆ ArtNetNodeCreator

using ArtNetNodeCreator = rtti::ObjectCreator<ArtNetController, ArtNetService>

◆ ArtNetReceiverCreator

using ArtNetReceiverCreator = rtti::ObjectCreator<ArtNetReceiver, ArtNetService>

◆ Blur13x13Shader

using Blur13x13Shader = BlurShader<EBlurSamples::X13>

◆ Blur5x5Shader

using Blur5x5Shader = BlurShader<EBlurSamples::X5>

◆ Blur9x9Shader

using Blur9x9Shader = BlurShader<EBlurSamples::X9>

◆ BoolInstancePropertyValue

using BoolInstancePropertyValue = TypedInstancePropertyValue<bool>

Instance property types for all the POD types

◆ BufferBindingChangedCallback

using BufferBindingChangedCallback = std::function<void(BufferBindingInstance&)>

◆ BufferBindingFloat

using BufferBindingFloat = TypedBufferBindingNumeric<float>

◆ BufferBindingFloatInstance

using BufferBindingFloatInstance = TypedBufferBindingNumericInstance<float>

◆ BufferBindingInt

using BufferBindingInt = TypedBufferBindingNumeric<int>

◆ BufferBindingIntInstance

using BufferBindingIntInstance = TypedBufferBindingNumericInstance<int>

◆ BufferBindingIVec4

using BufferBindingIVec4 = TypedBufferBindingNumeric<glm::ivec4>

◆ BufferBindingIVec4Instance

using BufferBindingIVec4Instance = TypedBufferBindingNumericInstance<glm::ivec4>

◆ BufferBindingMat4

using BufferBindingMat4 = TypedBufferBindingNumeric<glm::mat4>

◆ BufferBindingMat4Instance

using BufferBindingMat4Instance = TypedBufferBindingNumericInstance<glm::mat4>

◆ BufferBindingUInt

using BufferBindingUInt = TypedBufferBindingNumeric<uint>

◆ BufferBindingUIntInstance

using BufferBindingUIntInstance = TypedBufferBindingNumericInstance<uint>

◆ BufferBindingUVec4

using BufferBindingUVec4 = TypedBufferBindingNumeric<glm::uvec4>

◆ BufferBindingUVec4Instance

using BufferBindingUVec4Instance = TypedBufferBindingNumericInstance<glm::uvec4>

◆ BufferBindingVec2

using BufferBindingVec2 = TypedBufferBindingNumeric<glm::vec2>

◆ BufferBindingVec2Instance

using BufferBindingVec2Instance = TypedBufferBindingNumericInstance<glm::vec2>

◆ BufferBindingVec3

using BufferBindingVec3 = TypedBufferBindingNumeric<glm::vec3>

◆ BufferBindingVec3Instance

using BufferBindingVec3Instance = TypedBufferBindingNumericInstance<glm::vec3>

◆ BufferBindingVec4

using BufferBindingVec4 = TypedBufferBindingNumeric<glm::vec4>

◆ BufferBindingVec4Instance

using BufferBindingVec4Instance = TypedBufferBindingNumericInstance<glm::vec4>

◆ BufferObjectDeclarationList

using BufferObjectDeclarationList = std::vector<nap::BufferObjectDeclaration>

◆ BufferPlayerMap

using BufferPlayerMap = std::unordered_map<std::string, audio::SafeOwner<audio::MultiSampleBufferPlayerNode> >

◆ CalendarItemList

using CalendarItemList = std::vector<nap::ResourcePtr<CalendarItem> >

◆ CharInstancePropertyValue

using CharInstancePropertyValue = TypedInstancePropertyValue<char>

◆ ClonedComponentResourceList

using ClonedComponentResourceList = std::vector<ClonedComponentResource>

◆ ConstantFillPolicyFloat

using ConstantFillPolicyFloat = ConstantFillPolicy<float>

◆ ConstantFillPolicyInt

using ConstantFillPolicyInt = ConstantFillPolicy<int>

◆ ConstantFillPolicyMat4

using ConstantFillPolicyMat4 = ConstantFillPolicy<glm::mat4>

◆ ConstantFillPolicyUInt

using ConstantFillPolicyUInt = ConstantFillPolicy<uint>

◆ ConstantFillPolicyVec2

using ConstantFillPolicyVec2 = ConstantFillPolicy<glm::vec2>

◆ ConstantFillPolicyVec3

using ConstantFillPolicyVec3 = ConstantFillPolicy<glm::vec3>

◆ ConstantFillPolicyVec4

using ConstantFillPolicyVec4 = ConstantFillPolicy<glm::vec4>

◆ CubeDepthRenderTargetCallback

using CubeDepthRenderTargetCallback = std::function<void(CubeDepthRenderTarget& target, const glm::mat4& projection, const glm::mat4& view)>

◆ CubeRenderTargetCallback

using CubeRenderTargetCallback = std::function<void(CubeRenderTarget& target, const glm::mat4& projection, const glm::mat4& view)>

◆ DefaultSequenceTrackFactoryMap

using DefaultSequenceTrackFactoryMap = std::unordered_map<rtti::TypeInfo, std::function<std::unique_ptr<SequenceTrack>(const SequencePlayerOutput*)> >

◆ DisplayList

using DisplayList = std::vector<Display>

◆ DoubleInstancePropertyValue

using DoubleInstancePropertyValue = TypedInstancePropertyValue<double>

◆ EntityList

using EntityList = std::vector<EntityInstance*>

◆ EntityObjectGraph

typedef ObjectGraph< EntityObjectGraphItem > EntityObjectGraph

◆ EventPtr

using EventPtr = std::unique_ptr<nap::Event>

Most events are wrapped in a unique pointer to manage lifetime automatically

◆ FillPolicyFloat

using FillPolicyFloat = FillPolicy<float>

◆ FillPolicyInt

using FillPolicyInt = FillPolicy<int>

◆ FillPolicyMat4

using FillPolicyMat4 = FillPolicy<glm::mat4>

◆ FillPolicyUInt

using FillPolicyUInt = FillPolicy<uint>

◆ FillPolicyVec2

using FillPolicyVec2 = FillPolicy<glm::vec2>

◆ FillPolicyVec3

using FillPolicyVec3 = FillPolicy<glm::vec3>

◆ FillPolicyVec4

using FillPolicyVec4 = FillPolicy<glm::vec4>

◆ FloatInstancePropertyValue

using FloatInstancePropertyValue = TypedInstancePropertyValue<float>

◆ FloatVertexAttribute

using FloatVertexAttribute = VertexAttribute<float>

◆ FontObjectCreator

using FontObjectCreator = rtti::ObjectCreator<Font, FontService>

◆ GPUBufferFloat

using GPUBufferFloat = TypedGPUBufferNumeric<float>

◆ GPUBufferInt

using GPUBufferInt = TypedGPUBufferNumeric<int>

◆ GPUBufferMat4

using GPUBufferMat4 = TypedGPUBufferNumeric<glm::mat4>

◆ GPUBufferUInt

using GPUBufferUInt = TypedGPUBufferNumeric<uint>

◆ GPUBufferVec2

using GPUBufferVec2 = TypedGPUBufferNumeric<glm::vec2>

◆ GPUBufferVec3

using GPUBufferVec3 = TypedGPUBufferNumeric<glm::vec3>

◆ GPUBufferVec4

using GPUBufferVec4 = TypedGPUBufferNumeric<glm::vec4>

◆ HighResolutionClock

using HighResolutionClock = std::chrono::high_resolution_clock

High resolution clock, works with the highest possible precision. Can't convert time points in to days, seconds etc.

◆ HighResolutionTimer

using HighResolutionTimer = Timer<HighResolutionClock>

Keeps track of time from the moment the timer is started. This timer uses the chrono HighResolutionClock and should be used when extreme accuracy is important. The timestamp associated with a HighResolutionTime can not be converted to days, seconds, weeks etc.

◆ HighResTimeStamp

using HighResTimeStamp = std::chrono::time_point<HighResolutionClock>

Point in time associated with the HighResolutionClock.

◆ Hours

using Hours = std::chrono::hours

Hours type definition.

◆ IconObjectCreator

using IconObjectCreator = rtti::ObjectCreator<Icon, IMGuiService>

◆ InputEventPtr

using InputEventPtr = std::unique_ptr<nap::InputEvent>

◆ InputEventPtrList

using InputEventPtrList = std::vector<InputEventPtr>

◆ int16

using int16 = int16_t

◆ Int16InstancePropertyValue

using Int16InstancePropertyValue = TypedInstancePropertyValue<int16_t>

◆ int32

using int32 = int32_t

◆ Int32InstancePropertyValue

using Int32InstancePropertyValue = TypedInstancePropertyValue<int32_t>

◆ int64

using int64 = int64_t

◆ Int64InstancePropertyValue

using Int64InstancePropertyValue = TypedInstancePropertyValue<int64_t>

◆ int8

using int8 = int8_t

◆ Int8InstancePropertyValue

using Int8InstancePropertyValue = TypedInstancePropertyValue<int8_t>

◆ IntVertexAttribute

using IntVertexAttribute = VertexAttribute<int>

◆ IVec2InstancePropertyValue

using IVec2InstancePropertyValue = TypedInstancePropertyValue<glm::ivec2>

◆ IVec3InstancePropertyValue

using IVec3InstancePropertyValue = TypedInstancePropertyValue<glm::ivec3>

◆ LightFlags

using LightFlags = uint

Persistent light information coded in a uint32 (msb)[index : 8bit][map id : 8bit][type : 8bit][padding : 5bit][shadow supported : 1bit][shadow enabled : 1bit][light enabled : 1bit](lsb)

◆ LogMessageFormatter

using LogMessageFormatter = std::function<std::string(const LogMessage& msg)>

◆ MicroSeconds

using MicroSeconds = std::chrono::microseconds

Microseconds type definition.

◆ MidiInputPortObjectCreator

using MidiInputPortObjectCreator = rtti::ObjectCreator<MidiInputPort, MidiService>

◆ MidiOutputPortObjectCreator

using MidiOutputPortObjectCreator = rtti::ObjectCreator<MidiOutputPort, MidiService>

◆ MidiValue

using MidiValue = short

a midi value between 0 an 128

◆ Milliseconds

using Milliseconds = std::chrono::milliseconds

Milliseconds type definition.

◆ Minutes

using Minutes = std::chrono::minutes

Minutes type definition.

◆ NanoSeconds

using NanoSeconds = std::chrono::nanoseconds

Nanoseconds type definition.

◆ OSCArgumentList

using OSCArgumentList = std::vector<std::unique_ptr<OSCArgument> >

◆ OSCBool

using OSCBool = OSCValue<bool>

◆ OSCChar

using OSCChar = OSCValue<char>

◆ OSCDouble

using OSCDouble = OSCValue<double>

◆ OSCEventPtr

using OSCEventPtr = std::unique_ptr<nap::OSCEvent>

◆ OSCFloat

using OSCFloat = OSCValue<float>

◆ OSCInt

using OSCInt = OSCValue<int>

◆ OSCReceiverObjectCreator

using OSCReceiverObjectCreator = rtti::ObjectCreator<OSCReceiver, OSCService>

◆ OSCValuePtr

using OSCValuePtr = std::unique_ptr<OSCBaseValue>

◆ OwnedCalendarItemList

using OwnedCalendarItemList = std::vector<std::unique_ptr<CalendarItem> >

◆ ParameterBool

using ParameterBool = ParameterSimple<bool>

◆ ParameterBoolBlender

using ParameterBoolBlender = ParameterBlender<ParameterBool, bool>

◆ ParameterByte

using ParameterByte = ParameterNumeric<uint8_t>

◆ ParameterDouble

using ParameterDouble = ParameterNumeric<double>

◆ ParameterDoubleBlender

using ParameterDoubleBlender = ParameterBlender<ParameterDouble, double>

◆ ParameterFloat

using ParameterFloat = ParameterNumeric<float>

◆ ParameterFloatBlender

using ParameterFloatBlender = ParameterBlender<ParameterFloat, float>

◆ ParameterGroup

using ParameterGroup = Group<Parameter>

◆ ParameterInt

using ParameterInt = ParameterNumeric<int>

◆ ParameterIVec2

using ParameterIVec2 = ParameterVec<glm::ivec2>

◆ ParameterIVec3

using ParameterIVec3 = ParameterVec<glm::ivec3>

◆ ParameterIVec4

using ParameterIVec4 = ParameterVec<glm::ivec4>

◆ ParameterLong

using ParameterLong = ParameterNumeric<int64_t>

◆ ParameterMat3

using ParameterMat3 = ParameterMat<glm::mat3>

◆ ParameterMat4

using ParameterMat4 = ParameterMat<glm::mat4>

◆ ParameterQuat

using ParameterQuat = ParameterSimple<glm::quat>

◆ ParameterQuatBlender

using ParameterQuatBlender = ParameterBlender<ParameterQuat, glm::quat>

◆ ParameterRGB8Blender

using ParameterRGB8Blender = ParameterBlender<ParameterRGBColor8, RGBColor8>

◆ ParameterRGBA8Blender

using ParameterRGBA8Blender = ParameterBlender<ParameterRGBAColor8, RGBAColor8>

◆ ParameterRGBAColor8

using ParameterRGBAColor8 = ParameterSimple<RGBAColor8>

◆ ParameterRGBAColorFloat

using ParameterRGBAColorFloat = ParameterSimple<RGBAColorFloat>

◆ ParameterRGBAFloatBlender

using ParameterRGBAFloatBlender = ParameterBlender<ParameterRGBAColorFloat, RGBAColorFloat>

◆ ParameterRGBColor8

using ParameterRGBColor8 = ParameterSimple<RGBColor8>

◆ ParameterRGBColorFloat

using ParameterRGBColorFloat = ParameterSimple<RGBColorFloat>

◆ ParameterRGBFloatBlender

using ParameterRGBFloatBlender = ParameterBlender<ParameterRGBColorFloat, RGBColorFloat>

◆ ParameterString

using ParameterString = ParameterSimple<std::string>

◆ ParameterUInt

using ParameterUInt = ParameterNumeric<uint>

◆ ParameterVec2

using ParameterVec2 = ParameterVec<glm::vec2>

◆ ParameterVec2Blender

using ParameterVec2Blender = ParameterBlender<ParameterVec2, glm::vec2>

◆ ParameterVec3

using ParameterVec3 = ParameterVec<glm::vec3>

◆ ParameterVec3Blender

using ParameterVec3Blender = ParameterBlender<ParameterVec3, glm::vec3>

◆ ParameterVec4

using ParameterVec4 = ParameterVec<glm::vec4>

◆ ParameterVec4Blender

using ParameterVec4Blender = ParameterBlender<ParameterVec4, glm::vec4>

◆ PortalEventPtr

using PortalEventPtr = std::unique_ptr<PortalEvent>

◆ PortalItemIVec2

using PortalItemIVec2 = PortalItemVec<glm::ivec2>

◆ PortalItemIVec3

using PortalItemIVec3 = PortalItemVec<glm::ivec3>

◆ PortalItemRGBAColor8

using PortalItemRGBAColor8 = PortalItemColor<RGBAColor8>

◆ PortalItemRGBAColorFloat

using PortalItemRGBAColorFloat = PortalItemColor<RGBAColorFloat>

◆ PortalItemRGBColor8

using PortalItemRGBColor8 = PortalItemColor<RGBColor8>

◆ PortalItemRGBColorFloat

using PortalItemRGBColorFloat = PortalItemColor<RGBColorFloat>

◆ PortalItemSliderByte

using PortalItemSliderByte = PortalItemNumeric<uint8_t>

◆ PortalItemSliderDouble

using PortalItemSliderDouble = PortalItemNumeric<double>

◆ PortalItemSliderFloat

using PortalItemSliderFloat = PortalItemNumeric<float>

◆ PortalItemSliderInt

using PortalItemSliderInt = PortalItemNumeric<int>

◆ PortalItemSliderLong

using PortalItemSliderLong = PortalItemNumeric<int64_t>

◆ PortalItemTextField

using PortalItemTextField = PortalItemSimple<std::string>

◆ PortalItemToggle

using PortalItemToggle = PortalItemSimple<bool>

◆ PortalItemVec2

using PortalItemVec2 = PortalItemVec<glm::vec2>

◆ PortalItemVec3

using PortalItemVec3 = PortalItemVec<glm::vec3>

◆ PortalWebSocketServerObjectCreator

using PortalWebSocketServerObjectCreator = rtti::ObjectCreator<PortalWebSocketServer, PortalService>

◆ PythonScriptObjectCreator

using PythonScriptObjectCreator = rtti::ObjectCreator<PythonScript, PythonScriptService>

◆ QuatInstancePropertyValue

using QuatInstancePropertyValue = TypedInstancePropertyValue<glm::quat>

◆ RandomFillPolicyFloat

using RandomFillPolicyFloat = RandomFillPolicy<float>

◆ RandomFillPolicyInt

using RandomFillPolicyInt = RandomFillPolicy<int>

◆ RandomFillPolicyMat4

using RandomFillPolicyMat4 = RandomFillPolicy<glm::mat4>

◆ RandomFillPolicyUInt

using RandomFillPolicyUInt = RandomFillPolicy<uint>

◆ RandomFillPolicyVec2

using RandomFillPolicyVec2 = RandomFillPolicy<glm::vec2>

◆ RandomFillPolicyVec3

using RandomFillPolicyVec3 = RandomFillPolicy<glm::vec3>

◆ RandomFillPolicyVec4

using RandomFillPolicyVec4 = RandomFillPolicy<glm::vec4>

◆ RColor16

using RColor16 = RColor<uint16>

◆ RColor8

using RColor8 = RColor<uint8>

◆ RColorBase

using RColorBase = Color<T,1>

◆ RColorData16

using RColorData16 = RColor<uint16*>

◆ RColorData8

using RColorData8 = RColor<uint8*>

◆ RColorDataFloat

using RColorDataFloat = RColor<float*>

◆ RColorFloat

using RColorFloat = RColor<float>

◆ RenderMask

using RenderMask = uint64

◆ RenderTagGroup

using RenderTagGroup = Group<RenderTag>

◆ ResourceGroup

using ResourceGroup = Group<Resource>

◆ ResourcePtr

using ResourcePtr = rtti::ObjectPtr<T>

Can be used to point to other resources in a json file This is just a regular object ptr but allows for a more explicit definition of a link

◆ RGBAColor16

using RGBAColor16 = RGBAColor<uint16>

◆ RGBAColor8

using RGBAColor8 = RGBAColor<uint8>

◆ RGBAColorBase

using RGBAColorBase = Color<T,4>

◆ RGBAColorData16

using RGBAColorData16 = RGBAColor<uint16*>

◆ RGBAColorData8

using RGBAColorData8 = RGBAColor<uint8*>

◆ RGBAColorDataFloat

using RGBAColorDataFloat = RGBAColor<float*>

◆ RGBAColorFloat

using RGBAColorFloat = RGBAColor<float>

◆ RGBColor16

using RGBColor16 = RGBColor<uint16>

◆ RGBColor8

using RGBColor8 = RGBColor<uint8>

◆ RGBColorBase

using RGBColorBase = Color<T,3>

◆ RGBColorData16

using RGBColorData16 = RGBColor<uint16*>

◆ RGBColorData8

using RGBColorData8 = RGBColor<uint8*>

◆ RGBColorDataFloat

using RGBColorDataFloat = RGBColor<float*>

◆ RGBColorFloat

using RGBColorFloat = RGBColor<float>

◆ RTTIMeshProperties

using RTTIMeshProperties = MeshProperties<rtti::ObjectPtr<BaseVertexAttribute> >

◆ RTTIObjectGraph

typedef ObjectGraph< RTTIObjectGraphItem > RTTIObjectGraph

◆ SamplerChangedCallback

using SamplerChangedCallback = std::function<void(SamplerInstance&, int)>

◆ SamplerDeclarations

using SamplerDeclarations = std::vector<SamplerDeclaration>

◆ SceneCreator

using SceneCreator = rtti::ObjectCreator<Scene, Core>

◆ Seconds

using Seconds = std::chrono::seconds

Seconds type definition.

◆ SequenceControllerFactoryFunc

using SequenceControllerFactoryFunc = std::function<std::unique_ptr<SequenceController>(SequencePlayer&, SequenceEditor &)>

◆ SequenceControllerFactoryMap

using SequenceControllerFactoryMap = std::unordered_map<rtti::TypeInfo, SequenceControllerFactoryFunc>

◆ SequenceEditorGUIObjectCreator

using SequenceEditorGUIObjectCreator = rtti::ObjectCreator<SequenceEditorGUI, SequenceGUIService>

◆ SequenceEditorObjectCreator

using SequenceEditorObjectCreator = rtti::ObjectCreator<SequenceEditor, SequenceService>

◆ SequenceEventFloat

using SequenceEventFloat = SequenceEvent<float>

◆ SequenceEventInt

using SequenceEventInt = SequenceEvent<int>

◆ SequenceEventPtr

using SequenceEventPtr = std::unique_ptr<SequenceEventBase>

◆ SequenceEventString

using SequenceEventString = SequenceEvent<std::string>

◆ SequenceEventTrackEditFunc

using SequenceEventTrackEditFunc = std::function<void(SequenceEventTrackView &)>

◆ SequenceEventTrackPasteFunc

using SequenceEventTrackPasteFunc = std::function<void(SequenceEventTrackView &, const std::string &, const SequenceTrackSegmentEventBase &, double)>

◆ SequenceEventTrackSegmentViewFactoryFunc

using SequenceEventTrackSegmentViewFactoryFunc = std::function<std::unique_ptr<SequenceEventTrackSegmentViewBase>()>

◆ SequenceEventTrackSegmentViewFactoryMap

using SequenceEventTrackSegmentViewFactoryMap = std::unordered_map<rtti::TypeInfo, SequenceEventTrackSegmentViewFactoryFunc>

◆ SequenceEventVec2

using SequenceEventVec2 = SequenceEvent<glm::vec2>

◆ SequenceEventVec3

using SequenceEventVec3 = SequenceEvent<glm::vec3>

◆ SequencePlayerAdapterFactoryFunc

using SequencePlayerAdapterFactoryFunc = std::function<std::unique_ptr<SequencePlayerAdapter>(const SequenceTrack&, SequencePlayerOutput&, const SequencePlayer&)>

◆ SequencePlayerAdapterFactoryMap

using SequencePlayerAdapterFactoryMap = std::unordered_map<rtti::TypeInfo, SequencePlayerAdapterFactoryFunc>

◆ SequencePlayerAudioClockObjectCreator

using SequencePlayerAudioClockObjectCreator = rtti::ObjectCreator<SequencePlayerAudioClock, SequenceServiceAudio>

◆ SequencePlayerAudioOutputObjectCreator

using SequencePlayerAudioOutputObjectCreator = rtti::ObjectCreator<SequencePlayerAudioOutput, SequenceService>

◆ SequencePlayerCurveOutputObjectCreator

using SequencePlayerCurveOutputObjectCreator = rtti::ObjectCreator<SequencePlayerCurveOutput, SequenceService>

◆ SequencePlayerEventOutputObjectCreator

using SequencePlayerEventOutputObjectCreator = rtti::ObjectCreator<SequencePlayerEventOutput, SequenceService>

◆ SequencePlayerObjectCreator

using SequencePlayerObjectCreator = rtti::ObjectCreator<SequencePlayer, SequenceService>

◆ SequencePlayerStandClockObjectCreator

using SequencePlayerStandClockObjectCreator = rtti::ObjectCreator<SequencePlayerStandardClock, SequenceService>

◆ SequenceTrackCurveFloat

using SequenceTrackCurveFloat = SequenceTrackCurve<float>

◆ SequenceTrackCurveVec2

using SequenceTrackCurveVec2 = SequenceTrackCurve<glm::vec2>

◆ SequenceTrackCurveVec3

using SequenceTrackCurveVec3 = SequenceTrackCurve<glm::vec3>

◆ SequenceTrackCurveVec4

using SequenceTrackCurveVec4 = SequenceTrackCurve<glm::vec4>

◆ SequenceTrackSegmentCurveFloat

using SequenceTrackSegmentCurveFloat = SequenceTrackSegmentCurve<float>

◆ SequenceTrackSegmentCurveVec2

using SequenceTrackSegmentCurveVec2 = SequenceTrackSegmentCurve<glm::vec2>

◆ SequenceTrackSegmentCurveVec3

using SequenceTrackSegmentCurveVec3 = SequenceTrackSegmentCurve<glm::vec3>

◆ SequenceTrackSegmentCurveVec4

using SequenceTrackSegmentCurveVec4 = SequenceTrackSegmentCurve<glm::vec4>

◆ SequenceTrackSegmentEventFloat

using SequenceTrackSegmentEventFloat = SequenceTrackSegmentEvent<float>

◆ SequenceTrackSegmentEventInt

using SequenceTrackSegmentEventInt = SequenceTrackSegmentEvent<int>

◆ SequenceTrackSegmentEventString

using SequenceTrackSegmentEventString = SequenceTrackSegmentEvent<std::string>

◆ SequenceTrackSegmentEventVec2

using SequenceTrackSegmentEventVec2 = SequenceTrackSegmentEvent<glm::vec2>

◆ SequenceTrackSegmentEventVec3

using SequenceTrackSegmentEventVec3 = SequenceTrackSegmentEvent<glm::vec3>

◆ SequenceTrackSegmentEventVec4

using SequenceTrackSegmentEventVec4 = SequenceTrackSegmentEvent<glm::vec4>

◆ SequenceTrackTypeForViewTypeMap

using SequenceTrackTypeForViewTypeMap = std::unordered_map<rtti::TypeInfo, rtti::TypeInfo>

◆ SequenceTrackViewFactoryFunc

using SequenceTrackViewFactoryFunc = std::function<std::unique_ptr<SequenceTrackView>(SequenceGUIService &, SequenceEditorGUIView &, SequenceEditorGUIState &)>

◆ SequenceTrackViewFactoryMap

using SequenceTrackViewFactoryMap = std::unordered_map<rtti::TypeInfo, SequenceTrackViewFactoryFunc>

◆ ServiceConfigMap

using ServiceConfigMap = std::unordered_map<rtti::TypeInfo, ServiceConfiguration*>

◆ ShaderConstantDeclarations

using ShaderConstantDeclarations = std::vector<ShaderConstantDeclaration>

◆ ShaderConstantHash

using ShaderConstantHash = uint

Hash value for shader specialization constants

◆ ShaderConstantID

using ShaderConstantID = uint

◆ ShaderConstantMap

using ShaderConstantMap = std::map<ShaderConstantID, uint>

◆ ShaderStageConstantMap

using ShaderStageConstantMap = std::map<VkShaderStageFlagBits, ShaderConstantMap>

◆ ShadowFlags

using ShadowFlags = uint

Persistent shadow toggle information coded in a uint32 (index:32)[shadow enabled per light : 32bit](index:0)

◆ SteadyClock

using SteadyClock = std::chrono::steady_clock

Monotonic clock. The time points of this clock cannot decrease as time moves forward and the time between ticks of this clock is constant. This clock is not related to wall clock time (for example, it can be time since last reboot), and is most suitable for measuring intervals.

◆ SteadyTimer

using SteadyTimer = Timer<SteadyClock>

Keeps track of time from the moment the timer is started. This timer uses the chrono SteadyClock. This clock cannot move back in time and the time in between ticks is guaranteed to be constant.

◆ SteadyTimeStamp

using SteadyTimeStamp = std::chrono::time_point<SteadyClock>

Point in time associated with the SteadyClock.

◆ StringInstancePropertyValue

using StringInstancePropertyValue = TypedInstancePropertyValue<std::string>

◆ StructFillPolicyFloat

using StructFillPolicyFloat = StructFillPolicy::Entry<float>

◆ StructFillPolicyInt

using StructFillPolicyInt = StructFillPolicy::Entry<int>

◆ StructFillPolicyMat4

using StructFillPolicyMat4 = StructFillPolicy::Entry<glm::mat4>

◆ StructFillPolicyUInt

using StructFillPolicyUInt = StructFillPolicy::Entry<uint>

◆ StructFillPolicyVec2

using StructFillPolicyVec2 = StructFillPolicy::Entry<glm::vec2>

◆ StructFillPolicyVec3

using StructFillPolicyVec3 = StructFillPolicy::Entry<glm::vec3>

◆ StructFillPolicyVec4

using StructFillPolicyVec4 = StructFillPolicy::Entry<glm::vec4>

◆ SystemClock

using SystemClock = std::chrono::system_clock

System clock, able to convert time points in to days, seconds etc.

◆ SystemTimer

using SystemTimer = Timer<SystemClock>

Keeps track of time from the moment the timer is started. This timer uses the chrono SystemClock and should be sufficient for most time based operations. The timestamp associated with a SystemTimer can be converted to days, seconds, weeks etc.

◆ SystemTimeStamp

using SystemTimeStamp = std::chrono::time_point<SystemClock>

Point in time associated with the SystemClock.

◆ UDPThreadObjectCreator

using UDPThreadObjectCreator = rtti::ObjectCreator<UDPThread, UDPService>

◆ uint

using uint = unsigned int

◆ uint16

using uint16 = uint16_t

◆ UInt16InstancePropertyValue

using UInt16InstancePropertyValue = TypedInstancePropertyValue<uint16_t>

◆ uint32

using uint32 = uint32_t

◆ UInt32InstancePropertyValue

using UInt32InstancePropertyValue = TypedInstancePropertyValue<uint32_t>

◆ uint64

using uint64 = uint64_t

◆ UInt64InstancePropertyValue

using UInt64InstancePropertyValue = TypedInstancePropertyValue<uint64_t>

◆ uint8

using uint8 = uint8_t

◆ UInt8InstancePropertyValue

using UInt8InstancePropertyValue = TypedInstancePropertyValue<uint8_t>

◆ UIntVertexAttribute

using UIntVertexAttribute = VertexAttribute<uint>

◆ UniformCreatedCallback

typedef std::function< void()> UniformCreatedCallback

◆ UniformFloat

using UniformFloat = TypedUniformValue<float>

◆ UniformFloatArray

using UniformFloatArray = TypedUniformValueArray<float>

◆ UniformFloatArrayInstance

using UniformFloatArrayInstance = TypedUniformValueArrayInstance<float>

◆ UniformFloatInstance

using UniformFloatInstance = TypedUniformValueInstance<float>

◆ UniformInt

using UniformInt = TypedUniformValue<int>

◆ UniformIntArray

using UniformIntArray = TypedUniformValueArray<int>

◆ UniformIntArrayInstance

using UniformIntArrayInstance = TypedUniformValueArrayInstance<int>

◆ UniformIntInstance

using UniformIntInstance = TypedUniformValueInstance<int>

◆ UniformIVec4

using UniformIVec4 = TypedUniformValue<glm::ivec4>

◆ UniformIVec4Array

using UniformIVec4Array = TypedUniformValueArray<glm::ivec4>

◆ UniformIVec4ArrayInstance

using UniformIVec4ArrayInstance = TypedUniformValueArrayInstance<glm::ivec4>

◆ UniformIVec4Instance

using UniformIVec4Instance = TypedUniformValueInstance<glm::ivec4>

◆ UniformMat4

using UniformMat4 = TypedUniformValue<glm::mat4>

◆ UniformMat4Array

using UniformMat4Array = TypedUniformValueArray<glm::mat4>

◆ UniformMat4ArrayInstance

using UniformMat4ArrayInstance = TypedUniformValueArrayInstance<glm::mat4>

◆ UniformMat4Instance

using UniformMat4Instance = TypedUniformValueInstance<glm::mat4>

◆ UniformUInt

using UniformUInt = TypedUniformValue<uint>

◆ UniformUIntArray

using UniformUIntArray = TypedUniformValueArray<uint>

◆ UniformUIntArrayInstance

using UniformUIntArrayInstance = TypedUniformValueArrayInstance<uint>

◆ UniformUIntInstance

using UniformUIntInstance = TypedUniformValueInstance<uint>

◆ UniformUVec4

using UniformUVec4 = TypedUniformValue<glm::uvec4>

◆ UniformUVec4Array

using UniformUVec4Array = TypedUniformValueArray<glm::uvec4>

◆ UniformUVec4ArrayInstance

using UniformUVec4ArrayInstance = TypedUniformValueArrayInstance<glm::uvec4>

◆ UniformUVec4Instance

using UniformUVec4Instance = TypedUniformValueInstance<glm::uvec4>

◆ UniformVec2

using UniformVec2 = TypedUniformValue<glm::vec2>

◆ UniformVec2Array

using UniformVec2Array = TypedUniformValueArray<glm::vec2>

◆ UniformVec2ArrayInstance

using UniformVec2ArrayInstance = TypedUniformValueArrayInstance<glm::vec2>

◆ UniformVec2Instance

using UniformVec2Instance = TypedUniformValueInstance<glm::vec2>

◆ UniformVec3

using UniformVec3 = TypedUniformValue<glm::vec3>

◆ UniformVec3Array

using UniformVec3Array = TypedUniformValueArray<glm::vec3>

◆ UniformVec3ArrayInstance

using UniformVec3ArrayInstance = TypedUniformValueArrayInstance<glm::vec3>

◆ UniformVec3Instance

using UniformVec3Instance = TypedUniformValueInstance<glm::vec3>

◆ UniformVec4

using UniformVec4 = TypedUniformValue<glm::vec4>

◆ UniformVec4Array

using UniformVec4Array = TypedUniformValueArray<glm::vec4>

◆ UniformVec4ArrayInstance

using UniformVec4ArrayInstance = TypedUniformValueArrayInstance<glm::vec4>

◆ UniformVec4Instance

using UniformVec4Instance = TypedUniformValueInstance<glm::vec4>

◆ Vec2InstancePropertyValue

using Vec2InstancePropertyValue = TypedInstancePropertyValue<glm::vec2>

◆ Vec2VertexAttribute

using Vec2VertexAttribute = VertexAttribute<glm::vec2>

◆ Vec3InstancePropertyValue

using Vec3InstancePropertyValue = TypedInstancePropertyValue<glm::vec3>

◆ Vec3VertexAttribute

using Vec3VertexAttribute = VertexAttribute<glm::vec3>

◆ Vec4InstancePropertyValue

using Vec4InstancePropertyValue = TypedInstancePropertyValue<glm::vec4>

◆ Vec4VertexAttribute

using Vec4VertexAttribute = VertexAttribute<glm::vec4>

◆ VertexAttributeDeclarations

using VertexAttributeDeclarations = std::unordered_map<std::string, std::unique_ptr<VertexAttributeDeclaration> >

◆ VertexBufferFloat

using VertexBufferFloat = VertexBuffer<float>

◆ VertexBufferInt

using VertexBufferInt = VertexBuffer<int>

◆ VertexBufferUInt

using VertexBufferUInt = VertexBuffer<uint>

◆ VertexBufferVec2

using VertexBufferVec2 = VertexBuffer<glm::vec2>

◆ VertexBufferVec3

using VertexBufferVec3 = VertexBuffer<glm::vec3>

◆ VertexBufferVec4

using VertexBufferVec4 = VertexBuffer<glm::vec4>

◆ VideoPlayerObjectCreator

using VideoPlayerObjectCreator = rtti::ObjectCreator<VideoPlayer, VideoService>

◆ WebSocketClientEndPoint

using WebSocketClientEndPoint = WebSocketClientEndPointSetup<wspp::Config>

◆ WebSocketClientObjectCreator

using WebSocketClientObjectCreator = rtti::ObjectCreator<WebSocketClient, WebSocketService>

◆ WebSocketConnectionPtr

using WebSocketConnectionPtr = std::unique_ptr<WebSocketConnection>

◆ WebSocketEventPtr

using WebSocketEventPtr = std::unique_ptr<nap::WebSocketEvent>

◆ WebSocketServerEndPoint

using WebSocketServerEndPoint = WebSocketServerEndPointSetup<wspp::Config>

◆ WebSocketServerObjectCreator

using WebSocketServerObjectCreator = rtti::ObjectCreator<WebSocketServer, WebSocketService>

◆ WindowEventPtr

using WindowEventPtr = std::unique_ptr<WindowEvent>

◆ WindowEventPtrList

using WindowEventPtrList = std::vector<WindowEventPtr>

Enumeration Type Documentation

◆ EAddressMode

enum EAddressMode : uint32

strong

Supported sampler wrap modes

Enumerator
Repeat	Repeat.
MirroredRepeat	MirroredRepeat.
ClampToEdge	ClampToEdge.
ClampToBorder	ClampToBorder.

◆ EAnisotropicSamples

enum EAnisotropicSamples : uint32

strong

Supported number of anisotropic sample overrides

Enumerator
Default	Pick system default, as defined by the render service configuration.
Four	Four samples.
Eight	Eight samples.
Sixteen	Sixteen samples.

◆ EArtnetMode

enum EArtnetMode : int

strong

Mode used by an artnet controller to send data. When set to broadcast the message is broadcasted over the network. When set to unicast the message is only sent to compatible nodes. Compatible nodes match the subnet and universe of the controller.

Enumerator
Broadcast	Artnet data is broadcasted over the network.
Unicast	Artnet data is sent only to compatible nodes that share the same universe and subnet.

◆ EBlendMode

enum EBlendMode : int

strong

Blend mode for Materials.

Enumerator
NotSet	Default value for MaterialInstances, means that the Material's blend mode is used instead.
Opaque	Regular opaque, similar to (One, Zero) blend.
AlphaBlend	Transparent object (SrcAlpha, InvSrcAlpha) blend.
Additive	Additive, (One, One) blend.

◆ EBlurSamples

enum EBlurSamples : uint

strong

Supported blur kernels

Enumerator
X5	5x5 kernel, linear sampling
X9	9x9 kernel, linear sampling
X13	13x13 kernel, linear sampling

◆ EBorderColor

enum EBorderColor : uint32

strong

Supported predefined sampler border colors

Enumerator
FloatTransparentBlack	Float transparent black.
IntTransparentBlack	Integer transparent black.
FloatOpaqueBlack	Float opaque black.
IntOpaqueBlack	Integer opaque black, sampler default.
FloatOpaqueWhite	Float opaque white.
IntOpaqueWhite	Integer opaque white.

◆ ECameraMode

enum ECameraMode : uint8_t

strong

Mode that the CameraController is currently operating in.

Enumerator
None
FirstPerson
Orbit
OrthographicTop
OrthographicBottom
OrthographicLeft
OrthographicRight
OrthographicFront
OrthographicBack
Perspective
Orthographic

◆ EColorChannel

enum EColorChannel : int

strong

Used by the various color classes to map a channel to an index

Enumerator
Red	Red Color Channel: 0.
Green	Green Color Channel: 1.
Blue	Blue Color Channel: 2.
Alpha	Alpha Color Channel: 3.

◆ EColorSpace

enum EColorSpace : int

strong

Supported surface color spaces

Enumerator
Linear	Linear color space.
sRGB	Non-linear, sRGB color space.

◆ EControllerAxis

enum EControllerAxis : int

strong

List of axis available from a controller

Enumerator
UNKNOWN
LEFT_X
LEFT_Y
RIGHT_X
RIGHT_Y
TRIGGER_LEFT
TRIGGER_RIGHT

◆ EControllerButton

enum EControllerButton : int

strong

The most common game-controller buttons

Enumerator
UNKNOWN
A
B
X
Y
BACK
GUIDE
START
LEFT_STICK
RIGHT_STICK
LEFT_SHOULDER
RIGHT_SHOULDER
DPAD_UP
DPAD_DOWN
DPAD_LEFT
DPAD_RIGHT

◆ ECullMode

enum ECullMode : int32

strong

Triangle cull modes

Enumerator
None	No culling.
Front	Cull front facing triangles.
Back	Cull back facing triangles.
FrontAndBack	Cull front and back facing triangles.

◆ ECullWindingOrder

enum ECullWindingOrder : int

strong

Denotes the cull winding order of a mesh.

Enumerator
Clockwise
CounterClockwise

◆ EDay

enum EDay : int

strong

Convenience enum that describes the day of the week. This enum is serializable.

Enumerator
Monday	Monday.
Tuesday	Tuesday.
Wednesday	Wednesday.
Thursday	Thursday.
Friday	Friday.
Saturday	Saturday.
Sunday	Sunday.
Unknown	Unknown.

◆ EDepthCompareMode

enum EDepthCompareMode : int

strong

Supported depth compare modes for shadow texture samplers e.g. sampler2DShadow.

Enumerator
NotSet
Never
Less
Equal
LessOrEqual
Greater
NotEqual
GreaterOrEqual
Always

◆ EDepthMode

enum EDepthMode : int

strong

Determines how the z-buffer is used for reading and writing.

Enumerator
NotSet	Default value for MaterialInstances, means that the Material's blend is used instead.
InheritFromBlendMode	Transparent objects do not write depth, but do read depth. Opaque objects read and write depth.
ReadWrite	Read and write depth.
ReadOnly	Only read depth.
WriteOnly	Only write depth.
NoReadWrite	Neither read or write depth.

◆ EDescriptorType

enum EDescriptorType : uint

strong

Flag that determines the descriptor type of a shader resource. Regards the type of data access on the device (GPU) inside a shader program.

Uniform buffers are typically small blocks of data that are updated very frequently from CPU to GPU (each frame), but immutable in a shader program. Storage buffers are typically large blocks of data that are bound/unbound to an SSBO and frequently read and written in a compute shader program. The Default option is used for buffers that are not bound to descriptorsets, e.g. vertex and index buffers.

Enumerator
Uniform	Specifies a uniform buffer descriptor. device readonly.
Storage	Specifies a storage buffer descriptor. device read/write.

◆ EDrawMode

enum EDrawMode : int32

strong

Topology of the mesh

Enumerator
Points	Interpret the vertex data as single points.
Lines	Interpret the vertex data as individual lines.
LineStrip	Interpret the vertex data as a single connected line.
Triangles	Interpret the vertex data as a set of triangles.
TriangleStrip	Interpret the vertex data as a strip of triangles.
TriangleFan	Interpret the vertex data as a fan of triangles.
Unknown	Invalid vertex interpretation.

◆ EFBXConversionOptions

enum EFBXConversionOptions

strong

Options to specify when converting FBX

Enumerator
CONVERT_ALWAYS	Always convert FBX.
CONVERT_IF_NEWER	Only convert FBX if the destination does not exist or is older.

◆ EFilterMode

enum EFilterMode : uint32

strong

Supported sampler filter modes.

Enumerator
Nearest	Nearest sampling.
Linear	Linear sampling.

◆ EKeyCode

enum EKeyCode : int

strong

Enum describing a list of all possible keys that are supported

Enumerator
KEY_UNKNOWN
KEY_RETURN
KEY_ESCAPE
KEY_BACKSPACE
KEY_TAB
KEY_SPACE
KEY_EXCLAIM
KEY_QUOTEDBL
KEY_HASH
KEY_PERCENT
KEY_DOLLAR
KEY_AMPERSAND
KEY_QUOTE
KEY_LEFTPAREN
KEY_RIGHTPAREN
KEY_ASTERISK
KEY_PLUS
KEY_COMMA
KEY_MINUS
KEY_PERIOD
KEY_SLASH
KEY_0
KEY_1
KEY_2
KEY_3
KEY_4
KEY_5
KEY_6
KEY_7
KEY_8
KEY_9
KEY_COLON
KEY_SEMICOLON
KEY_LESS
KEY_EQUALS
KEY_GREATER
KEY_QUESTION
KEY_AT
KEY_LEFTBRACKET
KEY_BACKSLASH
KEY_RIGHTBRACKET
KEY_CARET
KEY_UNDERSCORE
KEY_BACKQUOTE
KEY_a
KEY_b
KEY_c
KEY_d
KEY_e
KEY_f
KEY_g
KEY_h
KEY_i
KEY_j
KEY_k
KEY_l
KEY_m
KEY_n
KEY_o
KEY_p
KEY_q
KEY_r
KEY_s
KEY_t
KEY_u
KEY_v
KEY_w
KEY_x
KEY_y
KEY_z
KEY_CAPSLOCK
KEY_F1
KEY_F2
KEY_F3
KEY_F4
KEY_F5
KEY_F6
KEY_F7
KEY_F8
KEY_F9
KEY_F10
KEY_F11
KEY_F12
KEY_PRINTSCREEN
KEY_SCROLLLOCK
KEY_PAUSE
KEY_INSERT
KEY_HOME
KEY_PAGEUP
KEY_DELETE
KEY_END
KEY_PAGEDOWN
KEY_RIGHT
KEY_LEFT
KEY_DOWN
KEY_UP
KEY_NUMLOCKCLEAR
KEY_KP_DIVIDE
KEY_KP_MULTIPLY
KEY_KP_MINUS
KEY_KP_PLUS
KEY_KP_ENTER
KEY_KP_1
KEY_KP_2
KEY_KP_3
KEY_KP_4
KEY_KP_5
KEY_KP_6
KEY_KP_7
KEY_KP_8
KEY_KP_9
KEY_KP_0
KEY_KP_PERIOD
KEY_APPLICATION
KEY_POWER
KEY_KP_EQUALS
KEY_F13
KEY_F14
KEY_F15
KEY_F16
KEY_F17
KEY_F18
KEY_F19
KEY_F20
KEY_F21
KEY_F22
KEY_F23
KEY_F24
KEY_EXECUTE
KEY_HELP
KEY_MENU
KEY_SELECT
KEY_STOP
KEY_AGAIN
KEY_UNDO
KEY_CUT
KEY_COPY
KEY_PASTE
KEY_FIND
KEY_MUTE
KEY_VOLUMEUP
KEY_VOLUMEDOWN
KEY_KP_COMMA
KEY_KP_EQUALSAS400
KEY_ALTERASE
KEY_SYSREQ
KEY_CANCEL
KEY_CLEAR
KEY_PRIOR
KEY_RETURN2
KEY_SEPARATOR
KEY_OUT
KEY_OPER
KEY_CLEARAGAIN
KEY_CRSEL
KEY_EXSEL
KEY_KP_00
KEY_KP_000
KEY_THOUSANDSSEPARATOR
KEY_DECIMALSEPARATOR
KEY_CURRENCYUNIT
KEY_CURRENCYSUBUNIT
KEY_KP_LEFTPAREN
KEY_KP_RIGHTPAREN
KEY_KP_LEFTBRACE
KEY_KP_RIGHTBRACE
KEY_KP_TAB
KEY_KP_BACKSPACE
KEY_KP_A
KEY_KP_B
KEY_KP_C
KEY_KP_D
KEY_KP_E
KEY_KP_F
KEY_KP_XOR
KEY_KP_POWER
KEY_KP_PERCENT
KEY_KP_LESS
KEY_KP_GREATER
KEY_KP_AMPERSAND
KEY_KP_DBLAMPERSAND
KEY_KP_VERTICALBAR
KEY_KP_DBLVERTICALBAR
KEY_KP_COLON
KEY_KP_HASH
KEY_KP_SPACE
KEY_KP_AT
KEY_KP_EXCLAM
KEY_KP_MEMSTORE
KEY_KP_MEMRECALL
KEY_KP_MEMCLEAR
KEY_KP_MEMADD
KEY_KP_MEMSUBTRACT
KEY_KP_MEMMULTIPLY
KEY_KP_MEMDIVIDE
KEY_KP_PLUSMINUS
KEY_KP_CLEAR
KEY_KP_CLEARENTRY
KEY_KP_BINARY
KEY_KP_OCTAL
KEY_KP_DECIMAL
KEY_KP_HEXADECIMAL
KEY_LCTRL
KEY_LSHIFT
KEY_LALT
KEY_LGUI
KEY_RCTRL
KEY_RSHIFT
KEY_RALT
KEY_RGUI
KEY_MODE
KEY_AUDIONEXT
KEY_AUDIOPREV
KEY_AUDIOSTOP
KEY_AUDIOPLAY
KEY_AUDIOMUTE
KEY_MEDIASELECT
KEY_WWW
KEY_MAIL
KEY_CALCULATOR
KEY_COMPUTER
KEY_AC_SEARCH
KEY_AC_HOME
KEY_AC_BACK
KEY_AC_FORWARD
KEY_AC_STOP
KEY_AC_REFRESH
KEY_AC_BOOKMARKS
KEY_BRIGHTNESSDOWN
KEY_BRIGHTNESSUP
KEY_DISPLAYSWITCH
KEY_KBDILLUMTOGGLE
KEY_KBDILLUMDOWN
KEY_KBDILLUMUP
KEY_EJECT
KEY_SLEEP

◆ ELightType

enum ELightType : uint8

strong

Light Type Flag

Enumerator
Custom
Directional
Point
Spot

◆ EMemoryUsage

enum EMemoryUsage : uint

strong

Flag that determines how GPU data, typically nap::GPUBuffer, is used at runtime. Regards the type of data access between host (CPU) and device (GPU).

For instance, a 'Static' buffer (i.e. containing a mesh) is uploaded from the CPU to the GPU exactly once. This allows the system to remove unused buffers after the upload is complete. If there is the need to update a buffer more frequently, even once after upload, it is required the usage is set to 'DynamicWrite'.

Note that static data is often placed in a different cache on the GPU, not accessible by the CPU, which allows for faster drawing times. 'DynamicWrite' buffers are uploaded into shared CPU / GPU memory and are therefore slower to access. Keep this in mind when selecting the appropriate memory usage.

Enumerator
Static	Buffer data is uploaded only once from the CPU to the GPU.
DynamicRead	Buffer data is uploaded only once from the CPU to the GPU, and frequently read from GPU to CPU.
DynamicWrite	Buffer data is updated more than once from the CPU to the GPU.

◆ EMonth

enum EMonth : int

strong

Convenience enum that describes the month in a year. This enum is serializable.

Enumerator
January	January.
February	February.
March	March.
April	April.
May	May.
June	June.
July	July.
August	August.
September	September.
October	October.
November	November.
December	December.
Unknown	Unknown.

◆ EMouseButton

enum EMouseButton : int

strong

Enum describing a list of all possible mouse buttons

Enumerator
UNKNOWN
LEFT
MIDDLE
RIGHT

◆ EOrthoCameraMode

enum EOrthoCameraMode : nap::uint8

strong

Orthographic camera space operation mode

Enumerator
PixelSpace	Planes are scaled automatically to pixel coordinates. Near/Far is retrieved from properties.
CorrectAspectRatio	User provides all planes, but height is recalculated for correct aspect ratio.
Custom	All planes are retrieved from properties.

◆ EPolygonMode

enum EPolygonMode : int32

strong

Polygon modes

Enumerator
Fill	Polygons are interpreted and rendered using the specified 'EDrawMode'.
Line	Polygon edges are drawn as line segments.
Point	Polygon vertices are drawn as points.

◆ EPortalEventType

enum EPortalEventType : int

strong

Enum that describes the type of portal event, which determines the effect of the event

Enumerator
Request	Request a descriptor of all the portal items in a portal (from client to server)
Response	Respond with a descriptor of all the portal items in a portal (from server to client)
Update	Update current values of portal items in a portal (bi-directional between client and server)
Invalid	Not recognized as a valid portal event type.

◆ EPortalItemButtonEvent

enum EPortalItemButtonEvent : int

strong

Enum that contains the different events that can be triggered from a portal item button

Enumerator
Click	Triggered from a portal item button when it registers a click event.
Press	Triggered from a portal item button when it registers a press event.
Release	Triggered from a portal item button when it registers a release event.
Invalid	Not recognized as a valid portal item button event.

◆ ERasterizationSamples

enum ERasterizationSamples : int

strong

Number of rasterization samples

Enumerator
One
Two
Four
Eight
Sixteen
Max	Request max available number of rasterization samples.

◆ ESerialByteSize

enum ESerialByteSize : int

strong

Defines the possible byte sizes for the serial port

Enumerator
Five
Six
Seven
Eight

◆ ESerialFlowControl

enum ESerialFlowControl : int

strong

Defines the possible flow control types for the serial port

Enumerator
None
Software
Hardware

◆ ESerialParity

enum ESerialParity : int

strong

Defubes the possible parity types for the serial port

Enumerator
None
Odd
Even
Mark
Space

◆ ESerialStopBits

enum ESerialStopBits : int

strong

Defines the possible stop bit types for the serial port

Enumerator
One
Two
OnePointFive

◆ EShaderVariableValueType

enum EShaderVariableValueType : uint8

strong

All available shader variable value types

Enumerator
Unknown	unknown or invalid shader uniform
Float	float
Int	int
UInt	unsigned int
Vec2	2 float vector
Vec3	3 float vector
Vec4	4 float vector
IVec4	4 int vector
UVec4	4 uint vector
Mat2	2x2 float matrix
Mat3	3x3 float matrix
Mat4	4x4 float matrix

◆ EShadowMapType

enum EShadowMapType : uint8

strong

Shadow Map Type

Enumerator
Quad
Cube

◆ ESigningScheme

enum ESigningScheme : int

strong

Signing schemes. Used by the nap::LicenseService to validate a license.
Signing scheme used to generate a license with the 'licensegenerator' tool must match the signing scheme passed to the nap::LicenseService.

Enumerator
SHA1
SHA224
SHA256
SHA384
SHA512

◆ ESurfaceChannels

enum ESurfaceChannels : int

strong

Supported number of surface channels

Enumerator
R	R red component.
RGBA	RGBA red, green, blue and alpha component.
BGRA	BGRA blue, green, red and alpha component.
D	D component, for depth-only textures.

◆ ESurfaceDataType

enum ESurfaceDataType : int

strong

Supported surface data types

Enumerator
BYTE	08 bit bitmap
USHORT	16 bit bitmap
FLOAT	32 bit bitmap

◆ ESVGUnits

enum ESVGUnits : int

strong

Units associated with an svg file These units are used when loading an svg file

Enumerator
PX	'px' Pixels
PT	'pt' Points
PC	'pc' Points Centimeter
MM	'mm' Millimeter
CM	'cm' Centimeter
DPI	'dpi' Dots per inch

◆ EUDPThreadUpdateMethod

enum EUDPThreadUpdateMethod : int

Different update methods of an UDPThread.

Enumerator
UDP_MAIN_THREAD	process UDPAdapters on main thread
UDP_SPAWN_OWN_THREAD	process UDPAdapters in newly spawned thread
UDP_MANUAL	only process UDPAdapters when the user explicitly calls manualProcess on the UDPThread

◆ EWebSocketLogLevel

enum EWebSocketLogLevel : uint32

strong

Enum that describes the web-socket log level. The levels can be bit-masked together.

Enumerator
None	Log nothing.
Debug	Low level debugging information.
Library	Usual system states or small internal library problems.
Info	Minor configuration problems or additional warning information.
Warning	Information about important problems not severe enough to close connection.
Error	Recoverable error. Solution might be closing the connection with an appropiate error code.
Fatal	Unrecoverable error. Will cause endpoint to be terminated unclean.
All	Log all levels.

◆ EWebSocketOPCode

enum EWebSocketOPCode : uint32

strong

Enumerator
Continuation
Text
Binary
RSV3
RSV4
RSV5
RSV6
RSV7
Close
Ping
Pong
ControlRSVB
ControlRSVC
ControlRSVD
ControlRSVE
ControlRSVF

Function Documentation

◆ _assert()

void NAPAPI nap::_assert	(	const char *	exprs,
		bool	expr,
		const char *	file,
		int	line
	)

Called by NAP_ASSERT in debug mode, aborts program execution if expression evaluates to false. Do not call this function directly in your application, use the NAP_ASSERT macro instead. The expression, file and line number are printed to console.

Parameters

exprs	expression as string
expr	the expression to evaluate
file	the document the assert originates from
line	line number in file

◆ _assertMsg()

void NAPAPI nap::_assertMsg	(	const char *	exprs,
		bool	expr,
		const char *	file,
		int	line,
		const char *	message
	)

Called by NAP_ASSERT in debug mode, aborts program execution if expression evaluates to false. Do not call this function directly in your application, use the NAP_ASSERT_MSG macro instead. The expression, file, line number and additional message are printed to console.

Parameters

exprs	expression as string
expr	the expression to evaluate
file	the document the assert originates from
line	line number in file
message	the message to print

◆ basicLogMessageFormatter()

std::string nap::basicLogMessageFormatter ( const LogMessage & msg )

Minimal log message formatter, containing only the level and the message

Parameters

msg	the LogMessage to format

Returns: string into which to write the formatted message

◆ computeWebSocketLogLevel()

NAPAPI uint32 nap::computeWebSocketLogLevel ( EWebSocketLogLevel level )

Utility function that combines the various log levels into a single bitmasked value. All log levels equal to and above the given level are logged.

Parameters

level the lowest log level to combine into a single field.

Returns: the bitmasked (combined) log level

◆ convertFBX()

NAPAPI bool nap::convertFBX	(	const std::string &	fbxPath,
		const std::string &	outputDirectory,
		EFBXConversionOptions	convertOptions,
		std::vector< std::string > &	convertedFiles,
		utility::ErrorState &	errorState
	)

Converts (splits) an .fbx file into multiple .mesh parts. Only the geometry is extracted. Vertex, Normal, Color, UV and Tangent information is extracted. Up to 8 Color and UV channels are supported. Tangents and bi-tangents are automatically computed when normals are present.

Parameters

fbxPath	The FBX file to convert
outputDirectory	Absolute or relative directory that the converted files should be placed in
convertOptions	Options for the convert
convertedFiles	List of files that were converted from the FBX
errorState	The error state

Returns: Whether the conversion succeeded or not

◆ convertMMSSMSArrayToTime()

double NAPAPI nap::convertMMSSMSArrayToTime ( const std::vector< int > & timeArray )

Converts an array containing 3 integers representing minutes, seconds and milliseconds in that specific order into a time double representing that time in seconds. Asserts when time array size is different then 3

Parameters

timeArray reference to the time array

Returns: the time value in seconds

◆ convertTimeToMMSSMSArray()

std::vector<int> NAPAPI nap::convertTimeToMMSSMSArray ( double time )

Converts a double time value (in seconds) into an array containing 3 integers representing minutes, seconds and milliseconds in that specific order.

Parameters

time	the time value in seconds

Returns: array containing converted time values

◆ copyImageData()

NAPAPI void nap::copyImageData	(	const uint8_t *	source,
		unsigned int	sourcePitch,
		ESurfaceChannels	sourceChannels,
		uint8_t *	target,
		unsigned int	targetPitch,
		ESurfaceChannels	targetChannels,
		int	width,
		int	height
	)

Copies pixel data from source to target, using the given parameters. Note that the target pitch needs to be less or equal to source pitch.

Parameters

source	pointer to source data
sourcePitch	source number of bytes in a row
sourceChannels	number of channels per pixel
target	pointer to the target memory
targetPitch	target number of bytes per row
targetChannels	number of channels per pixel
width	width of the image in pixels
height	height of the image in pixels

◆ createPortalEventHeader()

NAPAPI APIEventPtr nap::createPortalEventHeader ( const PortalEventHeader & header )

Creates an API event that functions as event header in a portal event

Parameters

header the portal event header to be converted to API event

Returns: an API event that functions as event header in a portal event

◆ createTimestamp()

NAPAPI SystemTimeStamp nap::createTimestamp	(	int	year,
		int	month,
		int	day,
		int	hour,
		int	minute,
		int	second = `0`,
		int	millisecond = `0`,
		bool	daylightSaving = `true`
	)

Converts local calendar time to system time

Parameters

year	the year as number (eg. 1970)
month	the month as 1-based number (3 == march)
day	the day of the month ranging from 1 to 31
hour	the hour of the day from 0 to 23
minute	the minute of the hour from 0 to 59
second	the second of the minute from 0 to 60
millisecond	additional milliseconds
daylightSaving	attempts to determine if Daylight Saving Time was in effect.

Returns: the complete timestamp

◆ extractMessages()

NAPAPI bool nap::extractMessages	(	const std::string &	json,
		rtti::DeserializeResult &	result,
		rtti::Factory &	factory,
		std::vector< APIMessage * > &	outMessages,
		utility::ErrorState &	error
	)

Extracts APIMessage objects from a json string.

Parameters

json	the json string to extract messages from
result	contains the de-serialized result, owner of the messages
factory	contains information on how to construct a message
outMessages	list of messages extracted from json, can be empty
error	contains the error if extraction fails

Returns: if extraction succeeded or not.

◆ extractPortalEventHeader()

NAPAPI bool nap::extractPortalEventHeader	(	const APIEventPtr &	event,
		PortalEventHeader &	outHeader,
		utility::ErrorState &	error
	)

Attempts to extract a portal event header from a portal event header API event

Parameters

event	the API event to extract the portal event header information from
outHeader	the portal event header to write the information to
error	contains information when the extraction fails

Returns: whether the portal event header extraction succeeded

◆ findSymbolInModule()

NAPAPI void* nap::findSymbolInModule	(	void *	module,
		const char *	symbolName
	)

Platform-wrapper function to find the address of a symbol in the specified shared library

Parameters

module	Handle to the module to find the symbol in
symbolName	Name of the symbol to find

Returns: The pointer to the symbol if found, nullptr if not

◆ findUniformStructMember()

const Uniform* nap::findUniformStructMember	(	const std::vector< T > &	members,
		const ShaderVariableDeclaration &	declaration
	)

Find a shader uniform based on the given shader variable declaration.

Parameters

members	uniforms of type nap::Uniform to search through.
declaration	uniform declaration to match

Returns: uniform that matches with the given shader declaration, nullptr if not found.

◆ getComponentsOfTypeRecursive()

void nap::getComponentsOfTypeRecursive	(	nap::EntityInstance &	entity,
		std::vector< T * > &	outComponents
	)

◆ getCurrentDateTime() [1/2]

NAPAPI DateTime nap::getCurrentDateTime ( )

Returns the current system data / time. Note that the time will be Local to this computer and includes daylight savings.

Returns: a structure that contains the current date and time.

◆ getCurrentDateTime() [2/2]

NAPAPI void nap::getCurrentDateTime ( DateTime & outDateTime )

Populates a DateTime structure that contains the current date and time Note that the time will be Local to this computer and includes daylight savings

Parameters

outDateTime the time structure to populate with the current date and time

◆ getCurrentTime()

NAPAPI SystemTimeStamp nap::getCurrentTime ( )

Returns: the current time as a system time stamp, this time is acquired using the system clock. This time can be converted in days, minutes etc using a nap::DateTime object.

◆ getDaysInWeek()

const NAPAPI std::array<EDay,7>& nap::getDaysInWeek ( )

Returns: days of the week as a list, from Monday to Sunday.

◆ getLightFlags()

LightFlags NAPAPI nap::getLightFlags	(	const LightComponentInstance &	light,
		uint	index
	)

Returns: the light flags of the specified light

◆ getLightIndex()

uint NAPAPI nap::getLightIndex ( LightFlags flags )

Returns: the light index

◆ getLightType()

uint NAPAPI nap::getLightType ( LightFlags flags )

Returns: the light type

◆ getModuleExtension()

NAPAPI std::string nap::getModuleExtension ( )

Returns: Module filename extension for platform

◆ getParameterBlender()

std::unique_ptr<BaseParameterBlender> NAPAPI nap::getParameterBlender ( nap::Parameter & param )

Returns: a blender for the given parameter, nullptr if no blender is available.

◆ getPortalEventType()

NAPAPI EPortalEventType nap::getPortalEventType ( const std::string & type )

Converts a string representation to a portal event type

Parameters

type	the string to convert to a portal event type

Returns: The portal event type derived from the string

◆ getPortalEventTypeString()

NAPAPI std::string nap::getPortalEventTypeString ( const EPortalEventType & type )

Converts a portal event type to a string representation

Parameters

type	the portal event type to convert to a string

Returns: A string representing the provided portal event type

◆ getPortalItemButtonEvent()

NAPAPI EPortalItemButtonEvent nap::getPortalItemButtonEvent ( const std::string & event )

Converts a string representation to a portal item button event

Parameters

event the string to convert to a portal item button event

Returns: The portal item button event derived from the string

◆ getPortalItemButtonEventString()

NAPAPI std::string nap::getPortalItemButtonEventString ( const EPortalItemButtonEvent & event )

Converts a portal item button event to a string representation

Parameters

event the portal item button event to convert to a string

Returns: A string representing the provided portal item button event

◆ getShadowFlags()

ShadowFlags NAPAPI nap::getShadowFlags ( const std::vector< LightComponentInstance * > lights )

Returns: The shadow flags for the given lights

◆ getShadowMapType()

uint NAPAPI nap::getShadowMapType ( LightFlags flags )

Returns: the shadow map type

◆ getUniformStructDepth()

int NAPAPI nap::getUniformStructDepth ( const UniformStruct & uniformStruct )

Returns the maximum depth of the shader variable

Parameters

uniformStruct the uniform struct to determine the depth of

Returns: the depth of uniform struct

◆ getUniformStructSizeRecursive()

size_t NAPAPI nap::getUniformStructSizeRecursive ( const UniformStruct & uniformStruct )

Returns the total size of the shader variable

Parameters

uniformStruct the uniform struct used to calculate the shader variable size

Returns: the size of the shader variable in bytes

◆ getVulkanBufferUsage()

NAPAPI VkBufferUsageFlags nap::getVulkanBufferUsage ( nap::EDescriptorType descriptorType )

Returns the vulkan buffer usage flags for a given buffer type.

Parameters

descriptorType the descriptor type to get the associated usage flags of.

Returns: the vulkan buffer usage flags for a given buffer type.

◆ getVulkanDescriptorType()

NAPAPI VkDescriptorType nap::getVulkanDescriptorType ( nap::EDescriptorType descriptorType )

Converts nap::EDescriptorType to VkDescriptorType.

Parameters

descriptorType the descriptor type to convert.

Returns: the vulkan descriptor type for a given buffer object type, asserts if descriptorType is not 'Uniform' or 'Storage'.

◆ getVulkanFormat() [1/2]

VkFormat nap::getVulkanFormat ( )

Returns the vulkan format associated with ELEMENTTYPE

Template Parameters

ELEMENTTYPE the requested element type

Returns: the VkFormat associated with the specified element type, otherwise VK_FORMAT_UNDEFINED

◆ getVulkanFormat() [2/2]

NAPAPI VkFormat nap::getVulkanFormat ( nap::rtti::TypeInfo type )

Returns the vulkan format associated with the given numeric rtti type

Template Parameters

type	the requested element type

Returns: the VkFormat associated with the specified element type, otherwise VK_FORMAT_UNDEFINED

◆ initComponentInstancePtr() [1/4]

ComponentInstancePtrInitProxy<TargetComponentType, SourceComponentType> nap::initComponentInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		ComponentPtr< TargetComponentType >SourceComponentType::*	componentMemberPointer
	)

Init a regular ComponentInstancePtr. Returns a ComponentInstancePtrInitProxy which is a simple wrapper around the function arguments. The return value is passed directly to the corresponding constructor on ComponentInstancePtr, which does the actual initialization.

Parameters

sourceComponentInstance	The ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointer	Member pointer to the ComponentPtr member of the Component

Returns: A ComponentInstancePtrInitProxy which can be passed to the ComponentInstancePtr constructor

◆ initComponentInstancePtr() [2/4]

nap::ComponentInstancePtrInitProxy<TargetComponentType, SourceComponentType> nap::initComponentInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		ComponentPtr< TargetComponentType >SourceComponentType::*	componentMemberPointer
	)

Init a regular ComponentInstancePtr. Returns a ComponentInstancePtrInitProxy which is a simple wrapper around the function arguments. The return value is passed directly to the corresponding constructor on ComponentInstancePtr, which does the actual initialization.

Parameters

sourceComponentInstance	The ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointer	Member pointer to the ComponentPtr member of the Component

Returns: A ComponentInstancePtrInitProxy which can be passed to the ComponentInstancePtr constructor

◆ initComponentInstancePtr() [3/4]

std::vector<ComponentInstancePtr<TargetComponentType> > nap::initComponentInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		std::vector< ComponentPtr< TargetComponentType >>SourceComponentType::*	componentMemberPointer
	)

Init a std::vector of ComponentInstancePtrs. Returns a std::vector which is then used to initialize the target std::vector of ComponentInstancePtrs

Parameters

sourceComponentInstance	The ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointer	Member pointer to the ComponentPtr member of the Component

Returns: std::vector of initialized ComponentInstancePtrs

◆ initComponentInstancePtr() [4/4]

std::vector<nap::ComponentInstancePtr<TargetComponentType> > nap::initComponentInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		std::vector< ComponentPtr< TargetComponentType >>SourceComponentType::*	componentMemberPointer
	)

Init a std::vector of ComponentInstancePtrs. Returns a std::vector which is then used to initialize the target std::vector of ComponentInstancePtrs

Parameters

sourceComponentInstance	The ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointer	Member pointer to the ComponentPtr member of the Component

Returns: std::vector of initialized ComponentInstancePtrs

◆ initEntityInstancePtr() [1/4]

EntityInstancePtrInitProxy<SourceComponentType> nap::initEntityInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		EntityPtrSourceComponentType::*	entityMemberPointer
	)

Init a regular EntityInstancePtr. Returns a EntityInstancePtrInitProxy which is a simple wrapper around the function arguments. The return value is passed directly to the corresponding constructor on EntityInstancePtr, which does the actual initialization.

Parameters

sourceComponentInstance	The ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointer	Member pointer to the EntityPtr member of the Component

Returns: A EntityInstancePtrInitProxy which can be passed to the EntityInstancePtr constructor

◆ initEntityInstancePtr() [2/4]

nap::EntityInstancePtrInitProxy<SourceComponentType> nap::initEntityInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		EntityPtrSourceComponentType::*	entityMemberPointer
	)

Init a regular EntityInstancePtr. Returns a EntityInstancePtrInitProxy which is a simple wrapper around the function arguments. The return value is passed directly to the corresponding constructor on EntityInstancePtr, which does the actual initialization.

Parameters

sourceComponentInstance	The ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointer	Member pointer to the EntityPtr member of the Component

Returns: A EntityInstancePtrInitProxy which can be passed to the EntityInstancePtr constructor

◆ initEntityInstancePtr() [3/4]

std::vector<EntityInstancePtr> nap::initEntityInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		std::vector< EntityPtr >SourceComponentType::*	entityMemberPointer
	)

Init a std::vector of EntityInstancePtrs. Returns a std::vector which is then used to initialize the target std::vector of EntityInstancePtrs

Parameters

sourceComponentInstance	The ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointer	Member pointer to the EntityPtr member of the Component

Returns: std::vector of initialized EntityInstancePtrs

◆ initEntityInstancePtr() [4/4]

std::vector<nap::EntityInstancePtr> nap::initEntityInstancePtr	(	ComponentInstance *	sourceComponentInstance,
		std::vector< EntityPtr >SourceComponentType::*	entityMemberPointer
	)

Init a std::vector of EntityInstancePtrs. Returns a std::vector which is then used to initialize the target std::vector of EntityInstancePtrs

Parameters

sourceComponentInstance	The ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointer	Member pointer to the EntityPtr member of the Component

Returns: std::vector of initialized EntityInstancePtrs

◆ initModules()

NAPAPI void nap::initModules ( )

Performs any platform specific module initialization.

◆ isLightEnabled()

bool NAPAPI nap::isLightEnabled ( LightFlags flags )

Returns: whether the light is marked as enabled

◆ isShadowEnabled()

bool NAPAPI nap::isShadowEnabled ( LightFlags flags )

Returns: whether shadows are marked as enabled

◆ isShadowSupported()

bool NAPAPI nap::isShadowSupported ( LightFlags flags )

Returns: whether shadows are marked as supported

◆ loadMesh()

NAPAPI std::unique_ptr<MeshInstance> nap::loadMesh	(	RenderService &	renderService,
		const std::string &	meshPath,
		utility::ErrorState &	errorState
	)

Load a mesh from the specified mesh. The mesh is expected to be our own mesh format as converted by convertFBX The mesh is not yet initialized. Call init() to upload all the mesh data to the GPU. This gives the user the option to add additional vertex attributes

Parameters

renderService	the render engine
meshPath	Path to the .mesh file to load
errorState	The error state if the function fails

Returns: The loaded mesh if successful, nullptr on failure

◆ loadModule()

NAPAPI void* nap::loadModule	(	const nap::ModuleInfo &	modInfo,
		const std::string &	modulePath,
		std::string &	errorString
	)

Platform-wrapper function to load a shared library

Parameters

modInfo	The moduleInfo, used to add additional dll search paths
modulePath	The path to the shared library to load
errorString	If the module failed to load, the error string

Returns: Handle to the loaded module

◆ operator&()

ECameraMode nap::operator&	(	ECameraMode	a,
		ECameraMode	b
	)

◆ operator|()

ECameraMode nap::operator\|	(	ECameraMode	a,
		ECameraMode	b
	)

◆ registerParameterBlender()

bool NAPAPI nap::registerParameterBlender	(	rtti::TypeInfo	inParameterType,
		rtti::TypeInfo	inBlenderType
	)

Register a new blender for a specific type of parameter. Note that the parameter type needs to be derived from nap::Parameter and the blender type from nap::BaseParameterBlender.

Parameters

inParameterType	the type of parameter that is blended.
inBlenderType	the blender type.

Returns: if the blender for the given parameter registered.

◆ SequenceCurveTrackView::inputFloat< glm::vec2 >()

bool nap::SequenceCurveTrackView::inputFloat< glm::vec2 >	(	glm::vec2 &	v,
		int	precision
	)

◆ SequenceCurveTrackView::inputFloat< glm::vec3 >()

bool nap::SequenceCurveTrackView::inputFloat< glm::vec3 >	(	glm::vec3 &	v,
		int	precision
	)

◆ SequenceCurveTrackView::inputFloat< glm::vec4 >()

bool nap::SequenceCurveTrackView::inputFloat< glm::vec4 >	(	glm::vec4 &	v,
		int	precision
	)

◆ SequenceCurveTrackView::showValue< glm::vec2 >()

void nap::SequenceCurveTrackView::showValue< glm::vec2 >	(	const SequenceTrack &	track,
		const SequenceTrackSegmentCurve< glm::vec2 > &	segment,
		float	x,
		double	time,
		int	curveIndex
	)

◆ SequenceCurveTrackView::showValue< glm::vec3 >()

void nap::SequenceCurveTrackView::showValue< glm::vec3 >	(	const SequenceTrack &	track,
		const SequenceTrackSegmentCurve< glm::vec3 > &	segment,
		float	x,
		double	time,
		int	curveIndex
	)

◆ SequenceCurveTrackView::showValue< glm::vec4 >()

void nap::SequenceCurveTrackView::showValue< glm::vec4 >	(	const SequenceTrack &	track,
		const SequenceTrackSegmentCurve< glm::vec4 > &	segment,
		float	x,
		double	time,
		int	curveIndex
	)

◆ timeFormat()

NAPAPI std::string nap::timeFormat	(	const SystemTimeStamp &	time,
		const std::string &	format = `"%Y-%m-%d %H:%M:%S.%ms"`
	)

Convert a timestamp to string using a string format simlar to strftime. Also takes care of milliseconds using ms

Parameters

time	the timestamp to format into a string
format	the strftime-like format string

Returns: the formatted date / time string

◆ timestampLogMessageFormatter()

std::string nap::timestampLogMessageFormatter ( const LogMessage & msg )

LogMessage string formatter that includes a timestamp in ISO format

Parameters

msg	the LogMessage to format

Returns: string into which to write the formatted message

◆ toDay()

NAPAPI EDay nap::toDay ( const std::string & string )

Converts a string in to a day. This call is case-sensitive

Parameters

string the name of the day, see EDay comments for string representation

Returns: the converted month, Unknown if not valid match is found.

◆ toMonth()

NAPAPI EMonth nap::toMonth ( const std::string & string )

Converts a string in to a month. This call is case-sensitive

Parameters

string the name of the month, see EMonth comments for string representation

Returns: the converted month, Unknown if not valid match is found.

◆ toString() [1/2]

NAPAPI std::string nap::toString ( EDay day )

Converts a day in to a string

Parameters

day	the day to convert in to a string

Returns: the day as a string

◆ toString() [2/2]

NAPAPI std::string nap::toString ( EMonth month )

Converts a month in to a string

Parameters

month the month to convert in to a string

Returns: the month as a string

◆ unloadModule()

NAPAPI void nap::unloadModule ( void * module )

Platform-wrapper function to unload a shared library

Parameters

module The module to load

◆ updateLightFlags()

void NAPAPI nap::updateLightFlags	(	const LightComponentInstance &	light,
		LightFlags &	outFlags
	)

Update light flags from given light.

Parameters

light	to push
outFlags	flags to update

Variable Documentation

◆ calendarDirectory

constexpr const char* calendarDirectory = "calendar"

constexpr

Directory where all calendars are stored.

◆ manropeMediumData

const uint manropeMediumData[manropeMediumSize/4]

The compressed font data used by IMGui

◆ manropeMediumSize

constexpr uint manropeMediumSize = 80368

constexpr

Size of the font data buffer

◆ moduleAPIVersion

constexpr int moduleAPIVersion = 1

constexpr

Current module API version.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ APIArgumentList

◆ APIBool

◆ APIBoolArray

◆ APIByte

◆ APIByteArray

◆ APIChar

◆ APICharArray

◆ APIDouble

◆ APIDoubleArray

◆ APIEventPtr

◆ APIFloat

◆ APIFloatArray

◆ APIInt

◆ APIIntArray

◆ APILong

◆ APILongArray

◆ APIMessagePtr

◆ APIString

◆ APIStringArray

◆ APIWebSocketClientObjectCreator

◆ APIWebSocketEventPtr

◆ APIWebSocketServerObjectCreator

◆ ArtNetEventPtr

◆ ArtNetNode

◆ ArtNetNodeCreator

◆ ArtNetReceiverCreator

◆ Blur13x13Shader

◆ Blur5x5Shader

◆ Blur9x9Shader

◆ BoolInstancePropertyValue

◆ BufferBindingChangedCallback

◆ BufferBindingFloat

◆ BufferBindingFloatInstance

◆ BufferBindingInt

◆ BufferBindingIntInstance

◆ BufferBindingIVec4

◆ BufferBindingIVec4Instance

◆ BufferBindingMat4

◆ BufferBindingMat4Instance

◆ BufferBindingUInt

◆ BufferBindingUIntInstance

◆ BufferBindingUVec4

◆ BufferBindingUVec4Instance

◆ BufferBindingVec2

◆ BufferBindingVec2Instance

◆ BufferBindingVec3

◆ BufferBindingVec3Instance

◆ BufferBindingVec4

◆ BufferBindingVec4Instance

◆ BufferObjectDeclarationList

◆ BufferPlayerMap

◆ CalendarItemList

◆ CharInstancePropertyValue

◆ ClonedComponentResourceList

◆ ConstantFillPolicyFloat

◆ ConstantFillPolicyInt

◆ ConstantFillPolicyMat4

◆ ConstantFillPolicyUInt

◆ ConstantFillPolicyVec2

◆ ConstantFillPolicyVec3

◆ ConstantFillPolicyVec4

◆ CubeDepthRenderTargetCallback

◆ CubeRenderTargetCallback

◆ DefaultSequenceTrackFactoryMap

◆ DisplayList

◆ DoubleInstancePropertyValue

◆ EntityList

◆ EntityObjectGraph

◆ EventPtr

◆ FillPolicyFloat

◆ FillPolicyInt

◆ FillPolicyMat4