NAP
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
nap Namespace Reference

Namespaces

 artnet
 
 audio
 
 font
 
 group
 
 gui
 
 icon
 
 input
 
 math
 
 pipins
 
 portal
 
 projectinfo
 
 rtti
 
 SDL
 
 sequencecurveenums
 
 sequenceguiactions
 
 sequenceguiclipboard
 
 shader
 
 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  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  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  CVAdapter
 
class  CVCamera
 
struct  CVCameraSettings
 
class  CVCaptureComponent
 
class  CVCaptureComponentInstance
 
class  CVCaptureDevice
 
class  CVClassifyComponent
 
class  CVClassifyComponentInstance
 
class  CVFrame
 
class  CVFrameEvent
 
class  CVNetworkStream
 
class  CVService
 
class  CVServiceConfiguration
 
class  CVVideo
 
class  DailyCalendarItem
 
class  Database
 
class  DatabasePropertyPath
 
class  DatabaseTable
 
class  Date
 
class  DateTime
 
class  DefaultInputRouter
 
class  DefaultInputRouterComponent
 
class  DefaultInputRouterComponentInstance
 
class  DepthSorter
 
struct  DescriptorSet
 
class  DescriptorSetAllocator
 
class  DescriptorSetCache
 
class  Device
 
class  DirectoryWatcher
 
class  Display
 
class  Entity
 
struct  EntityCreationParameters
 
class  EntityInstance
 
class  EntityInstancePtr
 
struct  EntityInstancePtrInitProxy
 
class  EntityObjectGraphItem
 
class  EntityPtr
 
class  EtherCATMaster
 
class  EtherDreamDac
 
class  EtherDreamInterface
 
struct  EtherDreamPoint
 
class  EtherDreamService
 
class  Event
 
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  IWebSocketServer
 
class  KeyEvent
 
class  KeyInputComponent
 
class  KeyInputComponentInstance
 
class  KeyPressEvent
 
class  KeyReleaseEvent
 
class  LicenseConfiguration
 
struct  LicenseInformation
 
class  LicenseService
 
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
 
class  MeshShape
 
class  MidiEvent
 
class  MidiInputComponent
 
class  MidiInputComponentInstance
 
class  MidiInputPort
 
class  MidiOutputPort
 
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  ParameterEnum
 
class  ParameterEnumBase
 
class  ParameterGUI
 
class  ParameterGUIService
 
class  ParameterizedWindowEvent
 
class  ParameterNumeric
 
class  ParameterService
 
class  ParameterServiceConfiguration
 
class  ParameterSimple
 
class  ParameterVec
 
class  PathMapping
 
struct  PerpCameraProperties
 
class  PerspCameraComponent
 
class  PerspCameraComponentInstance
 
class  PhysicalDevice
 
struct  PipelineKey
 
class  PlaneMesh
 
class  PointerClickEvent
 
class  PointerEvent
 
class  PointerInputComponent
 
class  PointerInputComponentInstance
 
class  PointerInstancePropertyValue
 
class  PointerMoveEvent
 
class  PointerPressEvent
 
class  PointerReleaseEvent
 
class  PolyLine
 
struct  PolyLineProperties
 
class  PortalComponent
 
class  PortalComponentInstance
 
class  PortalEvent
 
struct  PortalEventHeader
 
class  PortalItem
 
class  PortalItemButton
 
class  PortalItemColor
 
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  RenderBloomComponent
 
class  RenderBloomComponentInstance
 
class  RenderGnomonComponent
 
class  RenderGnomonComponentInstance
 
class  RenderService
 
class  RenderServiceConfiguration
 
class  RenderTarget
 
class  RenderTexture2D
 
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  SamplerDeclaration
 
class  SamplerInstance
 
class  ScatterPointsMesh
 
class  Scene
 
class  SceneService
 
class  SDLAppEventHandler
 
class  SDLEventConverter
 
class  SDLInputService
 
class  SDOArgument
 
class  SDOGroup
 
class  SDOValue
 
struct  SemaphoreWaitInfo
 
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  ShaderFromFile
 
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  Slot
 Slot. More...
 
class  Snapshot
 
class  SnapshotRenderTarget
 
class  SOEMService
 
class  SpawnedEntityInstance
 
class  SphereMesh
 
class  StructBuffer
 
struct  StructBufferDescriptor
 
class  StructFillPolicy
 
struct  SurfaceDescriptor
 
class  TargetAttribute
 
class  TaskQueue
 
class  TextInputEvent
 
class  Texture2D
 
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  TransformProperties
 
class  Triangle
 
class  TriangleData
 
class  TriangleIterator
 
class  TriangleLine
 
class  TriangleMesh
 
class  Tween
 
class  TweenBase
 
class  TweenEaseBase
 
class  TweenEaseInBack
 
class  TweenEaseInBounce
 
class  TweenEaseInCirc
 
class  TweenEaseInCubic
 
class  TweenEaseInElastic
 
class  TweenEaseInExpo
 
class  TweenEaseInOutBack
 
class  TweenEaseInOutBounce
 
class  TweenEaseInOutCirc
 
class  TweenEaseInOutCubic
 
class  TweenEaseInOutElastic
 
class  TweenEaseInOutExpo
 
class  TweenEaseInOutQuad
 
class  TweenEaseInOutQuart
 
class  TweenEaseInOutQuint
 
class  TweenEaseInOutSine
 
class  TweenEaseInQuad
 
class  TweenEaseInQuart
 
class  TweenEaseInQuint
 
class  TweenEaseInSine
 
class  TweenEaseLinear
 
class  TweenEaseOutBack
 
class  TweenEaseOutBounce
 
class  TweenEaseOutCirc
 
class  TweenEaseOutCubic
 
class  TweenEaseOutElastic
 
class  TweenEaseOutExpo
 
class  TweenEaseOutQuad
 
class  TweenEaseOutQuart
 
class  TweenEaseOutQuint
 
class  TweenEaseOutSine
 
class  TweenHandle
 
class  TweenHandleBase
 
class  TweenService
 
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  VisualizeNormalsMesh
 
class  WebSocketClient
 
class  WebSocketClientEndPoint
 
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  WebSocketServerEndPoint
 
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  YoctoService
 

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 DacObjectCreator = rtti::ObjectCreator< EtherDreamDac, EtherDreamService >
 
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 CVCaptureDeviceObjectCreator = rtti::ObjectCreator< CVCaptureDevice, CVService >
 
using CVCaptureErrorMap = std::unordered_map< CVCaptureError, std::string >
 
using CVFrameEventPtr = std::unique_ptr< CVFrameEvent >
 
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 ParameterFloat = ParameterNumeric< float >
 
using ParameterInt = ParameterNumeric< int >
 
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 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 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 SamplerDeclarations = std::vector< SamplerDeclaration >
 
using SamplerChangedCallback = std::function< void(SamplerInstance &)>
 
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 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 SDO_int8 = SDOValue< nap::int8 >
 
using SDO_uint8 = SDOValue< nap::uint8 >
 
using SDO_int16 = SDOValue< nap::int16 >
 
using SDO_uint16 = SDOValue< nap::uint16 >
 
using SDO_int32 = SDOValue< nap::int32 >
 
using SDO_uint32 = SDOValue< nap::uint32 >
 
using SDO_float = SDOValue< float >
 
using SDO_double = SDOValue< double >
 
using SDO_int64 = SDOValue< nap::int64 >
 
using SDO_uint64 = SDOValue< nap::uint64 >
 
using TweenFloat = Tween< float >
 
using TweenDouble = Tween< double >
 
using TweenVec2 = Tween< glm::vec2 >
 
using TweenVec3 = Tween< glm::vec3 >
 
using TweenHandleFloat = TweenHandle< float >
 
using TweenHandleDouble = TweenHandle< double >
 
using TweenHandleVec2 = TweenHandle< glm::vec2 >
 
using TweenHandleVec3 = TweenHandle< glm::vec3 >
 
using UDPThreadObjectCreator = rtti::ObjectCreator< UDPThread, UDPService >
 
using VideoPlayerObjectCreator = rtti::ObjectCreator< VideoPlayer, VideoService >
 
using WebSocketClientObjectCreator = rtti::ObjectCreator< WebSocketClient, WebSocketService >
 
using WebSocketConnectionPtr = std::unique_ptr< WebSocketConnection >
 
using WebSocketEventPtr = std::unique_ptr< nap::WebSocketEvent >
 
using WebSocketServerObjectCreator = rtti::ObjectCreator< WebSocketServer, WebSocketService >
 

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  ESigningScheme : int {
  RSASS_PKCS1v15_SHA1 = 0, RSASS_PKCS1v15_SHA224 = 1, RSASS_PKCS1v15_SHA256 = 2, RSASS_PKCS1v15_SHA384 = 3,
  RSASS_PKCS1v15_SHA512 = 4
}
 
enum  ECVCaptureAPI : int {
  Auto = 0, V4L = 200, FireWire = 300, DirectShow = 700,
  PvAPI = 800, OpenNNI = 900, OpenNNIAsus = 910, Android = 1000,
  XIMEA = 1100, AVFoundation = 1200, Giganetix = 1300, MicrosoftMF = 1400,
  WindowsRT = 1410, RealSense = 1500, OpenNNI2 = 1600, OpenNNI2Asus = 1610,
  GPhoto = 1700, GStreamer = 1800, FFMPEG = 1900, ImageSequence = 2000,
  Aravis = 2100, MotionJPEG = 2200, IntelMFX = 2300, XINE = 2400
}
 
enum  CVCaptureError : int { OpenError = 0, PropertyError = 1, GrabError = 2, DecodeError = 3 }
 
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, CounterClockwise }
 
enum  EDepthMode : int {
  NotSet = 0, InheritFromBlendMode, ReadWrite, ReadOnly,
  WriteOnly, NoReadWrite
}
 
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 { 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  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 }
 
enum  EColorSpace : int { Linear, sRGB }
 
enum  ETextureUsage { Static, DynamicRead, DynamicWrite }
 
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  ETweenEaseType : int {
  LINEAR = 0, CUBIC_IN = 1, CUBIC_INOUT = 2, CUBIC_OUT = 3,
  BACK_IN = 4, BACK_INOUT = 5, BACK_OUT = 6, BOUNCE_IN = 7,
  BOUNCE_INOUT = 8, BOUNCE_OUT = 9, CIRC_IN = 10, CIRC_INOUT = 11,
  CIRC_OUT = 12, ELASTIC_IN = 13, ELASTIC_INOUT = 14, ELASTIC_OUT = 15,
  EXPO_IN = 16, EXPO_INOUT = 17, EXPO_OUT = 18, QUAD_IN = 19,
  QUAD_INOUT = 20, QUAD_OUT = 21, QUART_IN = 22, QUART_INOUT = 23,
  QUART_OUT = 24, QUINT_IN = 25, QUINT_INOUT = 26, QUINT_OUT = 27,
  SINE_IN = 28, SINE_INOUT = 29, SINE_OUT = 30
}
 
enum  ETweenMode : int { NORMAL = 0, LOOP = 1, PING_PONG = 2, REVERSE = 3 }
 
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< MeshInstanceloadMesh (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 ()
 
bool NAPAPI createRenderPass (VkDevice device, VkFormat colorFormat, VkFormat depthFormat, VkSampleCountFlagBits samples, VkImageLayout targetLayout, VkRenderPass &renderPass, utility::ErrorState &errorState)
 
bool NAPAPI create2DImage (VmaAllocator allocator, uint32 width, uint32 height, VkFormat format, uint32 mipLevels, VkSampleCountFlagBits samples, VkImageTiling tiling, VkImageUsageFlags imageUsage, VmaMemoryUsage memoryUsage, VkImage &outImage, VmaAllocation &outAllocation, VmaAllocationInfo &outAllocationInfo, utility::ErrorState &errorState)
 
bool NAPAPI create2DImageView (VkDevice device, VkImage image, VkFormat format, uint32 mipLevels, VkImageAspectFlags aspectFlags, VkImageView &outImageView, utility::ErrorState &errorState)
 
void NAPAPI destroyImageAndView (ImageData &data, VkDevice device, VmaAllocator allocator)
 
bool NAPAPI createBuffer (VmaAllocator allocator, uint32 size, VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocationFlags, BufferData &outBuffer, utility::ErrorState &error)
 
void NAPAPI destroyBuffer (VmaAllocator allocator, BufferData &buffer)
 
bool NAPAPI uploadToBuffer (VmaAllocator allocator, uint32 size, const void *data, BufferData &buffer)
 
template<class T >
const UniformfindUniformStructMember (const std::vector< T > &members, const ShaderVariableDeclaration &declaration)
 
size_t NAPAPI getUniformStructSizeRecursive (const UniformStruct &uniformStruct)
 
int NAPAPI getUniformStructDepth (const UniformStruct &uniformStruct)
 
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< EntityInstancePtrinitEntityInstancePtr (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::EntityInstancePtrinitEntityInstancePtr (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:

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:

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);
        RTTI_PROPERTY("StringProperty", &DataStruct::mStringProperty,   nap::rtti::EPropertyMetaData::Required);
        RTTI_PROPERTY("EnumProperty",   &DataStruct::mEnumProperty,     nap::rtti::EPropertyMetaData::Required);
RTTI_END_CLASS

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

RTTI_BEGIN_CLASS(DerivedClass)
        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. As you can see, it is very straightforward. 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

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

◆ APIWebSocketEventPtr

using APIWebSocketEventPtr = std::unique_ptr<APIWebSocketEvent>

◆ APIWebSocketServerObjectCreator

◆ ArtNetEventPtr

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

◆ ArtNetNode

using ArtNetNode = void*

◆ ArtNetNodeCreator

◆ ArtNetReceiverCreator

◆ BoolInstancePropertyValue

Instance property types for all the POD types

◆ BufferBindingChangedCallback

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

◆ BufferBindingFloat

◆ BufferBindingFloatInstance

◆ BufferBindingInt

◆ BufferBindingIntInstance

◆ BufferBindingIVec4

◆ BufferBindingIVec4Instance

◆ BufferBindingMat4

◆ BufferBindingMat4Instance

◆ BufferBindingUInt

◆ BufferBindingUIntInstance

◆ BufferBindingUVec4

◆ BufferBindingUVec4Instance

◆ BufferBindingVec2

◆ BufferBindingVec2Instance

◆ BufferBindingVec3

◆ BufferBindingVec3Instance

◆ BufferBindingVec4

◆ BufferBindingVec4Instance

◆ BufferObjectDeclarationList

◆ BufferPlayerMap

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

◆ CalendarItemList

◆ CharInstancePropertyValue

◆ ClonedComponentResourceList

◆ ConstantFillPolicyFloat

◆ ConstantFillPolicyInt

◆ ConstantFillPolicyMat4

◆ ConstantFillPolicyUInt

◆ ConstantFillPolicyVec2

◆ ConstantFillPolicyVec3

◆ ConstantFillPolicyVec4

◆ CVCaptureDeviceObjectCreator

◆ CVCaptureErrorMap

using CVCaptureErrorMap = std::unordered_map<CVCaptureError, std::string>

◆ CVFrameEventPtr

using CVFrameEventPtr = std::unique_ptr<CVFrameEvent>

◆ DacObjectCreator

◆ DefaultSequenceTrackFactoryMap

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

◆ DisplayList

using DisplayList = std::vector<Display>

◆ DoubleInstancePropertyValue

◆ EntityList

using EntityList = std::vector<EntityInstance*>

◆ 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

◆ FillPolicyVec2

using FillPolicyVec2 = FillPolicy<glm::vec2>

◆ FillPolicyVec3

using FillPolicyVec3 = FillPolicy<glm::vec3>

◆ FillPolicyVec4

using FillPolicyVec4 = FillPolicy<glm::vec4>

◆ FloatInstancePropertyValue

◆ FloatVertexAttribute

◆ FontObjectCreator

◆ GPUBufferFloat

◆ GPUBufferInt

◆ GPUBufferMat4

◆ GPUBufferUInt

◆ GPUBufferVec2

◆ GPUBufferVec3

◆ GPUBufferVec4

◆ 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

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

◆ InputEventPtr

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

◆ InputEventPtrList

using InputEventPtrList = std::vector<InputEventPtr>

◆ int16

using int16 = int16_t

◆ Int16InstancePropertyValue

◆ int32

using int32 = int32_t

◆ Int32InstancePropertyValue

◆ int64

using int64 = int64_t

◆ Int64InstancePropertyValue

◆ int8

using int8 = int8_t

◆ Int8InstancePropertyValue

◆ IntVertexAttribute

◆ IVec2InstancePropertyValue

◆ IVec3InstancePropertyValue

◆ LogMessageFormatter

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

◆ MicroSeconds

using MicroSeconds = std::chrono::microseconds

Microseconds type definition.

◆ MidiInputPortObjectCreator

◆ MidiOutputPortObjectCreator

◆ 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

◆ OSCValuePtr

using OSCValuePtr = std::unique_ptr<OSCBaseValue>

◆ OwnedCalendarItemList

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

◆ ParameterBool

◆ ParameterBoolBlender

◆ ParameterByte

using ParameterByte = ParameterNumeric<uint8_t>

◆ ParameterDouble

◆ ParameterDoubleBlender

◆ ParameterFloat

◆ ParameterFloatBlender

◆ ParameterGroup

◆ ParameterInt

◆ ParameterIVec2

using ParameterIVec2 = ParameterVec<glm::ivec2>

◆ ParameterIVec3

using ParameterIVec3 = ParameterVec<glm::ivec3>

◆ ParameterIVec4

using ParameterIVec4 = ParameterVec<glm::ivec4>

◆ ParameterLong

using ParameterLong = ParameterNumeric<int64_t>

◆ ParameterQuat

using ParameterQuat = ParameterSimple<glm::quat>

◆ ParameterQuatBlender

◆ ParameterRGB8Blender

◆ ParameterRGBA8Blender

◆ ParameterRGBAColor8

◆ ParameterRGBAColorFloat

◆ ParameterRGBAFloatBlender

◆ ParameterRGBColor8

◆ ParameterRGBColorFloat

◆ ParameterRGBFloatBlender

◆ ParameterString

using ParameterString = ParameterSimple<std::string>

◆ ParameterVec2

using ParameterVec2 = ParameterVec<glm::vec2>

◆ ParameterVec2Blender

◆ ParameterVec3

using ParameterVec3 = ParameterVec<glm::vec3>

◆ ParameterVec3Blender

◆ ParameterVec4

using ParameterVec4 = ParameterVec<glm::vec4>

◆ ParameterVec4Blender

◆ PortalEventPtr

using PortalEventPtr = std::unique_ptr<PortalEvent>

◆ PortalItemIVec2

using PortalItemIVec2 = PortalItemVec<glm::ivec2>

◆ PortalItemIVec3

using PortalItemIVec3 = PortalItemVec<glm::ivec3>

◆ PortalItemRGBAColor8

◆ PortalItemRGBAColorFloat

◆ PortalItemRGBColor8

◆ PortalItemRGBColorFloat

◆ PortalItemSliderByte

◆ PortalItemSliderDouble

◆ PortalItemSliderFloat

◆ PortalItemSliderInt

◆ PortalItemSliderLong

◆ PortalItemTextField

using PortalItemTextField = PortalItemSimple<std::string>

◆ PortalItemToggle

◆ PortalItemVec2

using PortalItemVec2 = PortalItemVec<glm::vec2>

◆ PortalItemVec3

using PortalItemVec3 = PortalItemVec<glm::vec3>

◆ PortalWebSocketServerObjectCreator

◆ PythonScriptObjectCreator

◆ QuatInstancePropertyValue

◆ RandomFillPolicyFloat

◆ RandomFillPolicyInt

◆ RandomFillPolicyMat4

◆ RandomFillPolicyUInt

◆ RandomFillPolicyVec2

◆ RandomFillPolicyVec3

◆ RandomFillPolicyVec4

◆ RColor16

◆ RColor8

using RColor8 = RColor<uint8>

◆ RColorBase

using RColorBase = Color<T,1>

◆ RColorData16

◆ RColorData8

◆ RColorDataFloat

using RColorDataFloat = RColor<float*>

◆ RColorFloat

using RColorFloat = RColor<float>

◆ ResourceGroup

◆ ResourcePtr

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

◆ RGBAColor8

◆ RGBAColorBase

using RGBAColorBase = Color<T,4>

◆ RGBAColorData16

◆ RGBAColorData8

◆ RGBAColorDataFloat

using RGBAColorDataFloat = RGBAColor<float*>

◆ RGBAColorFloat

using RGBAColorFloat = RGBAColor<float>

◆ RGBColor16

◆ RGBColor8

◆ RGBColorBase

using RGBColorBase = Color<T,3>

◆ RGBColorData16

◆ RGBColorData8

◆ RGBColorDataFloat

using RGBColorDataFloat = RGBColor<float*>

◆ RGBColorFloat

using RGBColorFloat = RGBColor<float>

◆ RTTIMeshProperties

◆ RTTIObjectGraph

◆ SamplerChangedCallback

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

◆ SamplerDeclarations

◆ SceneCreator

◆ SDO_double

using SDO_double = SDOValue<double>

◆ SDO_float

using SDO_float = SDOValue<float>

◆ SDO_int16

◆ SDO_int32

◆ SDO_int64

◆ SDO_int8

◆ SDO_uint16

◆ SDO_uint32

◆ SDO_uint64

◆ SDO_uint8

◆ Seconds

using Seconds = std::chrono::seconds

Seconds type definition.

◆ SequenceControllerFactoryFunc

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

◆ SequenceControllerFactoryMap

◆ SequenceEditorGUIObjectCreator

◆ SequenceEditorObjectCreator

◆ SequenceEventFloat

◆ SequenceEventInt

◆ 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

◆ SequenceEventTrackSegmentViewFactoryMap

◆ SequenceEventVec2

using SequenceEventVec2 = SequenceEvent<glm::vec2>

◆ SequenceEventVec3

using SequenceEventVec3 = SequenceEvent<glm::vec3>

◆ SequencePlayerAdapterFactoryFunc

◆ SequencePlayerAdapterFactoryMap

◆ SequencePlayerAudioClockObjectCreator

◆ SequencePlayerAudioOutputObjectCreator

◆ SequencePlayerCurveOutputObjectCreator

◆ SequencePlayerEventOutputObjectCreator

◆ SequencePlayerObjectCreator

◆ SequencePlayerStandClockObjectCreator

◆ SequenceTrackCurveFloat

◆ SequenceTrackCurveVec2

◆ SequenceTrackCurveVec3

◆ SequenceTrackCurveVec4

◆ SequenceTrackSegmentCurveFloat

◆ SequenceTrackSegmentCurveVec2

◆ SequenceTrackSegmentCurveVec3

◆ SequenceTrackSegmentCurveVec4

◆ SequenceTrackSegmentEventFloat

◆ SequenceTrackSegmentEventInt

◆ SequenceTrackSegmentEventString

◆ SequenceTrackSegmentEventVec2

◆ SequenceTrackSegmentEventVec3

◆ SequenceTrackSegmentEventVec4

◆ SequenceTrackTypeForViewTypeMap

◆ SequenceTrackViewFactoryFunc

◆ SequenceTrackViewFactoryMap

◆ ServiceConfigMap

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

◆ 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

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

◆ StructFillPolicyFloat

◆ StructFillPolicyInt

◆ StructFillPolicyMat4

◆ StructFillPolicyUInt

◆ StructFillPolicyVec2

◆ StructFillPolicyVec3

◆ StructFillPolicyVec4

◆ SystemClock

using SystemClock = std::chrono::system_clock

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

◆ SystemTimer

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.

◆ TweenDouble

using TweenDouble = Tween<double>

◆ TweenFloat

using TweenFloat = Tween<float>

◆ TweenHandleDouble

using TweenHandleDouble = TweenHandle<double>

◆ TweenHandleFloat

using TweenHandleFloat = TweenHandle<float>

◆ TweenHandleVec2

using TweenHandleVec2 = TweenHandle<glm::vec2>

◆ TweenHandleVec3

using TweenHandleVec3 = TweenHandle<glm::vec3>

◆ TweenVec2

using TweenVec2 = Tween<glm::vec2>

◆ TweenVec3

using TweenVec3 = Tween<glm::vec3>

◆ UDPThreadObjectCreator

◆ uint

using uint = unsigned int

◆ uint16

using uint16 = uint16_t

◆ UInt16InstancePropertyValue

◆ uint32

using uint32 = uint32_t

◆ UInt32InstancePropertyValue

◆ uint64

using uint64 = uint64_t

◆ UInt64InstancePropertyValue

◆ uint8

using uint8 = uint8_t

◆ UInt8InstancePropertyValue

◆ UIntVertexAttribute

◆ UniformCreatedCallback

typedef std::function< void()> UniformCreatedCallback

◆ UniformFloat

◆ UniformFloatArray

◆ UniformFloatArrayInstance

◆ UniformFloatInstance

◆ UniformInt

◆ UniformIntArray

◆ UniformIntArrayInstance

◆ UniformIntInstance

◆ UniformIVec4

using UniformIVec4 = TypedUniformValue<glm::ivec4>

◆ UniformIVec4Array

◆ UniformIVec4ArrayInstance

◆ UniformIVec4Instance

◆ UniformMat4

using UniformMat4 = TypedUniformValue<glm::mat4>

◆ UniformMat4Array

◆ UniformMat4ArrayInstance

◆ UniformMat4Instance

◆ UniformUInt

◆ UniformUIntArray

◆ UniformUIntArrayInstance

◆ UniformUIntInstance

◆ UniformUVec4

using UniformUVec4 = TypedUniformValue<glm::uvec4>

◆ UniformUVec4Array

◆ UniformUVec4ArrayInstance

◆ UniformUVec4Instance

◆ UniformVec2

using UniformVec2 = TypedUniformValue<glm::vec2>

◆ UniformVec2Array

◆ UniformVec2ArrayInstance

◆ UniformVec2Instance

◆ UniformVec3

using UniformVec3 = TypedUniformValue<glm::vec3>

◆ UniformVec3Array

◆ UniformVec3ArrayInstance

◆ UniformVec3Instance

◆ UniformVec4

using UniformVec4 = TypedUniformValue<glm::vec4>

◆ UniformVec4Array

◆ UniformVec4ArrayInstance

◆ UniformVec4Instance

◆ Vec2InstancePropertyValue

◆ Vec2VertexAttribute

◆ Vec3InstancePropertyValue

◆ Vec3VertexAttribute

◆ Vec4InstancePropertyValue

◆ Vec4VertexAttribute

◆ VertexAttributeDeclarations

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

◆ VertexBufferFloat

◆ VertexBufferInt

◆ VertexBufferUInt

◆ VertexBufferVec2

using VertexBufferVec2 = VertexBuffer<glm::vec2>

◆ VertexBufferVec3

using VertexBufferVec3 = VertexBuffer<glm::vec3>

◆ VertexBufferVec4

using VertexBufferVec4 = VertexBuffer<glm::vec4>

◆ VideoPlayerObjectCreator

◆ WebSocketClientObjectCreator

◆ WebSocketConnectionPtr

using WebSocketConnectionPtr = std::unique_ptr<WebSocketConnection>

◆ WebSocketEventPtr

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

◆ WebSocketServerObjectCreator

◆ WindowEventPtr

using WindowEventPtr = std::unique_ptr<WindowEvent>

◆ WindowEventPtrList

using WindowEventPtrList = std::vector<WindowEventPtr>

Enumeration Type Documentation

◆ CVCaptureError

enum CVCaptureError : int
strong

All available OpenCV capture related errors.

Enumerator
OpenError 

Capture device could not be opened.

PropertyError 

Capture Property could not be set.

GrabError 

Next frame could not be grabbed, device disconnected or end of stream.

DecodeError 

Grabbed frame could not be decoded.

◆ 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

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

◆ ECVCaptureAPI

enum ECVCaptureAPI : int
strong

All available OpenCV video capture backends.

Enumerator
Auto 

Auto detect == 0.

V4L 

V4L/V4L2 capturing support};.

FireWire 

IEEE 1394 drivers.

DirectShow 

DirectShow (via videoInput)

PvAPI 

PvAPI, Prosilica GigE SDK.

OpenNNI 

OpenNI (for Kinect)

OpenNNIAsus 

OpenNI (for Asus Xtion)

Android 

Android - not used.

XIMEA 

XIMEA Camera API.

AVFoundation 

AVFoundation framework for iOS (OS X Lion will have the same API)

Giganetix 

Smartek Giganetix GigEVisionSDK.

MicrosoftMF 

Microsoft Media Foundation (via videoInput)

WindowsRT 

Microsoft Windows Runtime using Media Foundation.

RealSense 

RealSense (former Intel Perceptual Computing SDK)

OpenNNI2 

OpenNI2 (for Kinect)

OpenNNI2Asus 

OpenNI2 (for Asus Xtion and Occipital Structure sensors)

GPhoto 

gPhoto2 connection

GStreamer 

GStreamer.

FFMPEG 

Open and record video file or stream using the FFMPEG library.

ImageSequence 

OpenCV Image Sequence (e.g. img_%02d.jpg)

Aravis 

Aravis SDK.

MotionJPEG 

Built-in OpenCV MotionJPEG codec.

IntelMFX 

Intel MediaSDK.

XINE 

XINE engine (Linux)

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

◆ 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 

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

◆ EOrthoCameraMode

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

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

◆ 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
RSASS_PKCS1v15_SHA1 
RSASS_PKCS1v15_SHA224 
RSASS_PKCS1v15_SHA256 
RSASS_PKCS1v15_SHA384 
RSASS_PKCS1v15_SHA512 

◆ ESurfaceChannels

enum ESurfaceChannels : int
strong

Supported number of surface channels

Enumerator

R red component.

RGBA 

RGBA red, green, blue and alpha component.

BGRA 

BGRA blue, green, red and alpha component.

◆ 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

◆ ETextureUsage

enum ETextureUsage
strong

Flag that determines how the texture is used at runtime.

Enumerator
Static 

Texture does not change, uploaded to once.

DynamicRead 

Texture is frequently read from GPU to CPU.

DynamicWrite 

Texture is frequently updated from CPU to GPU.

◆ ETweenEaseType

enum ETweenEaseType : int

Every possible tween ease type (serializable)

Enumerator
LINEAR 
CUBIC_IN 
CUBIC_INOUT 
CUBIC_OUT 
BACK_IN 
BACK_INOUT 
BACK_OUT 
BOUNCE_IN 
BOUNCE_INOUT 
BOUNCE_OUT 
CIRC_IN 
CIRC_INOUT 
CIRC_OUT 
ELASTIC_IN 
ELASTIC_INOUT 
ELASTIC_OUT 
EXPO_IN 
EXPO_INOUT 
EXPO_OUT 
QUAD_IN 
QUAD_INOUT 
QUAD_OUT 
QUART_IN 
QUART_INOUT 
QUART_OUT 
QUINT_IN 
QUINT_INOUT 
QUINT_OUT 
SINE_IN 
SINE_INOUT 
SINE_OUT 

◆ ETweenMode

enum ETweenMode : int

All available tween modes (serializable)

Enumerator
NORMAL 
LOOP 
PING_PONG 
REVERSE 

◆ EUDPThreadUpdateMethod

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
exprsexpression as string
exprthe expression to evaluate
filethe document the assert originates from
lineline 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
exprsexpression as string
exprthe expression to evaluate
filethe document the assert originates from
lineline number in file
messagethe message to print

◆ basicLogMessageFormatter()

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

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

Parameters
msgthe 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
levelthe 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
fbxPathThe FBX file to convert
outputDirectoryAbsolute or relative directory that the converted files should be placed in
convertOptionsOptions for the convert
convertedFilesList of files that were converted from the FBX
errorStateThe 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
timeArrayreference 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
timethe 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
sourcepointer to source data
sourcePitchsource number of bytes in a row
sourceChannelsnumber of channels per pixel
targetpointer to the target memory
targetPitchtarget number of bytes per row
targetChannelsnumber of channels per pixel
widthwidth of the image in pixels
heightheight of the image in pixels

◆ create2DImage()

bool NAPAPI nap::create2DImage ( VmaAllocator  allocator,
uint32  width,
uint32  height,
VkFormat  format,
uint32  mipLevels,
VkSampleCountFlagBits  samples,
VkImageTiling  tiling,
VkImageUsageFlags  imageUsage,
VmaMemoryUsage  memoryUsage,
VkImage &  outImage,
VmaAllocation &  outAllocation,
VmaAllocationInfo &  outAllocationInfo,
utility::ErrorState errorState 
)

Creates a Vulkan image based on the described image usage and given properties.

◆ create2DImageView()

bool NAPAPI nap::create2DImageView ( VkDevice  device,
VkImage  image,
VkFormat  format,
uint32  mipLevels,
VkImageAspectFlags  aspectFlags,
VkImageView &  outImageView,
utility::ErrorState errorState 
)

Creates a Vulkan image view based.

◆ createBuffer()

bool NAPAPI nap::createBuffer ( VmaAllocator  allocator,
uint32  size,
VkBufferUsageFlags  bufferUsage,
VmaMemoryUsage  memoryUsage,
VmaAllocationCreateFlags  allocationFlags,
BufferData outBuffer,
utility::ErrorState error 
)

Creates a Vulkan buffer

◆ createPortalEventHeader()

NAPAPI APIEventPtr nap::createPortalEventHeader ( const PortalEventHeader header)

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

Parameters
headerthe portal event header to be converted to API event
Returns
an API event that functions as event header in a portal event

◆ createRenderPass()

bool NAPAPI nap::createRenderPass ( VkDevice  device,
VkFormat  colorFormat,
VkFormat  depthFormat,
VkSampleCountFlagBits  samples,
VkImageLayout  targetLayout,
VkRenderPass &  renderPass,
utility::ErrorState errorState 
)

Creates a single or multi-sample renderpass based on rasterization samples and color/depth formats.

◆ 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
yearthe year as number (eg. 1970)
monththe month as 1-based number (3 == march)
daythe day of the month ranging from 1 to 31
hourthe hour of the day from 0 to 23
minutethe minute of the hour from 0 to 59
secondthe second of the minute from 0 to 60
millisecondadditional milliseconds
daylightSavingattempts to determine if Daylight Saving Time was in effect.
Returns
the complete timestamp

◆ destroyBuffer()

void NAPAPI nap::destroyBuffer ( VmaAllocator  allocator,
BufferData buffer 
)

Destroys a Vulkan buffer

◆ destroyImageAndView()

void NAPAPI nap::destroyImageAndView ( ImageData data,
VkDevice  device,
VmaAllocator  allocator 
)

Destroys a Vulkan image and Vulkan ImageView if present in data

◆ 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
jsonthe json string to extract messages from
resultcontains the de-serialized result, owner of the messages
factorycontains information on how to construct a message
outMessageslist of messages extracted from json, can be empty
errorcontains 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
eventthe API event to extract the portal event header information from
outHeaderthe portal event header to write the information to
errorcontains 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
moduleHandle to the module to find the symbol in
symbolNameName 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
membersuniforms of type nap::Uniform to search through.
declarationuniform 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
outDateTimethe 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.

◆ 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
typethe 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
typethe 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
eventthe 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
eventthe portal item button event to convert to a string
Returns
A string representing the provided portal item button event

◆ getUniformStructDepth()

int NAPAPI nap::getUniformStructDepth ( const UniformStruct uniformStruct)

Returns the maximum depth of the shader variable

Parameters
uniformStructthe 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
uniformStructthe 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
descriptorTypethe 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
descriptorTypethe 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
ELEMENTTYPEthe 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
typethe 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
sourceComponentInstanceThe ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the ComponentInstancePtr being initialized is a member of
componentMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointerMember 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
sourceComponentInstanceThe ComponentInstance that the EntityInstancePtr being initialized is a member of
entityMemberPointerMember 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.

◆ 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
renderServicethe render engine
meshPathPath to the .mesh file to load
errorStateThe 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
modInfoThe moduleInfo, used to add additional dll search paths
modulePathThe path to the shared library to load
errorStringIf 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
inParameterTypethe type of parameter that is blended.
inBlenderTypethe 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
timethe timestamp to format into a string
formatthe 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
msgthe 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
stringthe 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
stringthe 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
daythe 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
monththe 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
moduleThe module to load

◆ uploadToBuffer()

bool NAPAPI nap::uploadToBuffer ( VmaAllocator  allocator,
uint32  size,
const void *  data,
BufferData buffer 
)

Uploads data into a staging buffer

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.