NAP
nap Namespace Reference

Namespaces

 audio
 
 math
 
 rtti
 
 utility
 
 VertexAttributeIDs
 
 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  ArtNetService
 
class  AudioFormat
 
class  AVState
 
class  BaseApp
 
class  BaseColor
 
class  BaseVertexAttribute
 
class  Bitmap
 
class  BitmapFromFile
 
class  BoxMesh
 
class  CameraComponentInstance
 
class  CameraController
 
class  CameraControllerInstance
 
class  Circle
 
class  ClonedComponentResource
 
class  Color
 
class  Component
 
class  ComponentInstance
 
class  ComponentInstanceProperties
 
class  ComponentInstancePtr
 
struct  ComponentInstancePtrInitProxy
 
class  ComponentPtr
 
class  ComponentPtrBase
 
class  ComponentPtrInstancePropertyValue
 
class  ComponentResourcePath
 
class  ConsoleLogHandler
 
class  ControllerAxisEvent
 
class  ControllerButtonEvent
 
class  ControllerButtonPressEvent
 
class  ControllerButtonReleaseEvent
 
class  ControllerConnectionEvent
 
class  ControllerEvent
 
class  ControllerInputComponent
 
class  ControllerInputComponentInstance
 
class  Core
 
class  CoreExtension
 
class  Database
 
class  DatabasePropertyPath
 
class  DatabaseTable
 
class  Date
 
class  DateTime
 
class  DefaultInputRouter
 
class  DefaultInputRouterComponent
 
class  DefaultInputRouterComponentInstance
 
class  DepthSorter
 
class  Device
 
class  DirectoryWatcher
 
class  Entity
 
struct  EntityCreationParameters
 
class  EntityInstance
 
class  EntityInstancePtr
 
struct  EntityInstancePtrInitProxy
 
class  EntityObjectGraphItem
 
class  EntityPtr
 
class  EtherDreamDac
 
class  EtherDreamInterface
 
struct  EtherDreamPoint
 
class  EtherDreamService
 
class  Event
 
class  FileLogHandler
 
class  FirstPersonController
 
class  FirstPersonControllerInstance
 
class  Font
 
class  FontInstance
 
struct  FontProperties
 
class  FontService
 
struct  Frame
 
class  GLWindow
 
class  Glyph
 
class  GlyphCache
 
class  GUIAppEventHandler
 
class  Hexagon
 
class  IGlyphRepresentation
 
class  Image
 
class  ImageFromFile
 
class  IMesh
 
class  IMGuiService
 
class  InputComponent
 
class  InputComponentInstance
 
class  InputEvent
 
class  InputRouter
 
class  InputService
 
class  InstancePropertyValue
 
class  IWebSocketClient
 
class  IWebSocketServer
 
class  KeyEvent
 
class  KeyInputComponent
 
class  KeyInputComponentInstance
 
class  KeyPressEvent
 
class  KeyReleaseEvent
 
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
 
struct  ModuleDescriptor
 
class  ModuleManager
 
class  MouseWheelEvent
 
class  ObjectGraph
 
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  ParameterEnum
 
class  ParameterEnumBase
 
class  ParameterGroup
 
class  ParameterGUI
 
class  ParameterizedWindowEvent
 
class  ParameterNumeric
 
class  ParameterService
 
class  ParameterServiceConfiguration
 
class  ParameterSimple
 
class  ParameterVec
 
struct  PerpCameraProperties
 
class  PerspCameraComponent
 
class  PerspCameraComponentInstance
 
class  PlaneMesh
 
class  PointerClickEvent
 
class  PointerEvent
 
class  PointerInputComponent
 
class  PointerInputComponentInstance
 
class  PointerInstancePropertyValue
 
class  PointerMoveEvent
 
class  PointerPressEvent
 
class  PointerReleaseEvent
 
class  PolyLine
 
struct  PolyLineProperties
 
struct  ProjectInfo
 
class  PythonScript
 
class  PythonScriptComponent
 
class  PythonScriptComponentInstance
 
class  PythonScriptService
 
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  Renderer
 
class  RendererSettings
 
class  RenderService
 
class  RenderServiceConfiguration
 
struct  RenderState
 
class  RenderTarget
 
class  RenderTexture2D
 
class  RenderToTextureComponent
 
class  RenderToTextureComponentInstance
 
class  RenderWindow
 
class  RenderWindowResourceCreator
 
struct  RenderWindowSettings
 
class  Resource
 
class  ResourceManager
 
class  RGBAColor
 
class  RGBColor
 
class  RootEntity
 
class  RotateComponent
 
class  RotateComponentInstance
 
struct  RotateProperties
 
class  RTTIObjectGraphItem
 
class  ScatterPointsMesh
 
class  Scene
 
class  SceneService
 
class  SDLAppEventHandler
 
class  SDLEventConverter
 
class  SDLInputService
 
class  SerialPort
 
class  SerialService
 
class  Service
 
class  ServiceConfiguration
 
class  ServiceObjectGraphItem
 
class  ServiceRunner
 
class  Shader
 
class  ShapeTriangle
 
class  ShapeTriangleFanIterator
 
class  ShapeTriangleIterator
 
class  ShapeTriangleListIterator
 
class  ShapeTriangleStripIterator
 
class  Signal
 
class  Slot
 Slot. More...
 
class  SpawnedEntityInstance
 
class  SphereMesh
 
class  TargetAttribute
 
class  TaskQueue
 
class  TextInputEvent
 
class  Texture2D
 
struct  TextureParameters
 
class  ThreadPool
 
class  Timer
 
class  TimeStamp
 
class  TransformComponent
 
class  TransformComponentInstance
 
struct  TransformProperties
 
class  Triangle
 
class  TriangleData
 
class  TriangleIterator
 
class  TriangleLine
 
class  TypedInstancePropertyValue
 
class  Uniform
 
struct  UniformBinding
 
class  UniformContainer
 
class  UniformFloat
 
class  UniformFloatArray
 
class  UniformInt
 
class  UniformIntArray
 
class  UniformMat4
 
class  UniformMat4Array
 
class  UniformStruct
 
class  UniformStructArray
 
class  UniformTexture
 
class  UniformTexture2D
 
class  UniformTexture2DArray
 
class  UniformTextureArray
 
class  UniformValue
 
class  UniformValueArray
 
class  UniformVec3
 
class  UniformVec3Array
 
class  UniformVec4
 
class  UniformVec4Array
 
class  VAOHandle
 
struct  VAOKey
 
class  VertexAttribute
 
class  Video
 
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  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  YoctoService
 

Typedefs

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 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 EventPtr = std::unique_ptr< nap::Event >
 
using LogMessageFormatter = std::function< std::string(const LogMessage &msg)>
 
using int8 = int8_t
 
using uint8 = uint8_t
 
using int16 = uint16_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 APIArgumentList = std::vector< std::unique_ptr< APIArgument > >
 
using APIEventPtr = std::unique_ptr< nap::APIEvent >
 
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 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 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 DacObjectCreator = rtti::ObjectCreator< EtherDreamDac, EtherDreamService >
 
using FontObjectCreator = rtti::ObjectCreator< Font, FontService >
 
using InputEventPtr = std::unique_ptr< nap::InputEvent >
 
using InputEventPtrList = std::vector< InputEventPtr >
 
using WindowEventPtr = std::unique_ptr< WindowEvent >
 
using WindowEventPtrList = std::vector< WindowEventPtr >
 
using MidiValue = short
 
using MidiInputPortObjectCreator = rtti::ObjectCreator< MidiInputPort, MidiService >
 
using MidiOutputPortObjectCreator = rtti::ObjectCreator< MidiOutputPort, MidiService >
 
using OSCValuePtr = std::unique_ptr< OSCBaseValue >
 
using OSCFloat = OSCValue< float >
 
using OSCBool = OSCValue< bool >
 
using OSCInt = OSCValue< int >
 
using OSCDouble = OSCValue< double >
 
using OSCChar = OSCValue< char >
 
using OSCArgumentList = std::vector< std::unique_ptr< OSCArgument > >
 
using OSCEventPtr = std::unique_ptr< nap::OSCEvent >
 
using OSCReceiverObjectCreator = rtti::ObjectCreator< OSCReceiver, OSCService >
 
using ParameterFloat = ParameterNumeric< float >
 
using ParameterInt = ParameterNumeric< int >
 
using ParameterChar = ParameterNumeric< char >
 
using ParameterByte = ParameterNumeric< uint8_t >
 
using ParameterDouble = ParameterNumeric< double >
 
using ParameterLong = ParameterNumeric< int64_t >
 
using ParameterQuat = ParameterSimple< glm::quat >
 
using ParameterBool = ParameterSimple< bool >
 
using ParameterVec2 = ParameterVec< glm::vec2 >
 
using ParameterVec3 = ParameterVec< glm::vec3 >
 
using ParameterIVec2 = ParameterVec< glm::ivec2 >
 
using ParameterIVec3 = ParameterVec< glm::ivec3 >
 
using PythonScriptObjectCreator = rtti::ObjectCreator< PythonScript, PythonScriptService >
 
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 RTTIMeshProperties = MeshProperties< rtti::ObjectPtr< BaseVertexAttribute > >
 
using ParameterRGBColorFloat = ParameterSimple< RGBColorFloat >
 
using ParameterRGBAColorFloat = ParameterSimple< RGBAColorFloat >
 
using ParameterRGBColor8 = ParameterSimple< RGBColor8 >
 
using ParameterRGBAColor8 = ParameterSimple< RGBAColor8 >
 
using UniformTextureBindings = std::unordered_map< std::string, UniformBinding >
 
using UniformValueBindings = std::unordered_map< std::string, UniformBinding >
 
using FloatVertexAttribute = VertexAttribute< float >
 
using IntVertexAttribute = VertexAttribute< int >
 
using ByteVertexAttribute = VertexAttribute< int8_t >
 
using DoubleVertexAttribute = VertexAttribute< double >
 
using Vec2VertexAttribute = VertexAttribute< glm::vec2 >
 
using Vec3VertexAttribute = VertexAttribute< glm::vec3 >
 
using Vec4VertexAttribute = VertexAttribute< glm::vec4 >
 
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 VideoObjectCreator = rtti::ObjectCreator< Video, VideoService >
 
using WebSocketClientObjectCreator = rtti::ObjectCreator< WebSocketClient, WebSocketService >
 
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  EWebSocketForwardMode : int { WebSocketEvent = 0, APIEvent = 1, Both = 2 }
 
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  EControllerButton : int {
  UNKNOWN = -1, A, B, X,
  Y, BACK, GUIDE, START,
  LEFT_STICK, RIGHT_STICK, LEFT_SHOULDER, RIGHT_SHOULDER,
  DPAD_UP, DPAD_DOWN, DPAD_LEFT, DPAD_RIGHT
}
 
enum  EControllerAxis : int {
  UNKNOWN = -1, LEFT_X, LEFT_Y, RIGHT_X,
  RIGHT_Y, TRIGGER_LEFT, TRIGGER_RIGHT
}
 
enum  EKeyCode : int {
  KEY_UNKNOWN = -1, KEY_RETURN, KEY_ESCAPE, KEY_BACKSPACE,
  KEY_TAB, KEY_SPACE, KEY_EXCLAIM, KEY_QUOTEDBL,
  KEY_HASH, KEY_PERCENT, KEY_DOLLAR, KEY_AMPERSAND,
  KEY_QUOTE, KEY_LEFTPAREN, KEY_RIGHTPAREN, KEY_ASTERISK,
  KEY_PLUS, KEY_COMMA, KEY_MINUS, KEY_PERIOD,
  KEY_SLASH, KEY_0, KEY_1, KEY_2,
  KEY_3, KEY_4, KEY_5, KEY_6,
  KEY_7, KEY_8, KEY_9, KEY_COLON,
  KEY_SEMICOLON, KEY_LESS, KEY_EQUALS, KEY_GREATER,
  KEY_QUESTION, KEY_AT, KEY_LEFTBRACKET, KEY_BACKSLASH,
  KEY_RIGHTBRACKET, KEY_CARET, KEY_UNDERSCORE, KEY_BACKQUOTE,
  KEY_a, KEY_b, KEY_c, KEY_d,
  KEY_e, KEY_f, KEY_g, KEY_h,
  KEY_i, KEY_j, KEY_k, KEY_l,
  KEY_m, KEY_n, KEY_o, KEY_p,
  KEY_q, KEY_r, KEY_s, KEY_t,
  KEY_u, KEY_v, KEY_w, KEY_x,
  KEY_y, KEY_z, KEY_CAPSLOCK, KEY_F1,
  KEY_F2, KEY_F3, KEY_F4, KEY_F5,
  KEY_F6, KEY_F7, KEY_F8, KEY_F9,
  KEY_F10, KEY_F11, KEY_F12, KEY_PRINTSCREEN,
  KEY_SCROLLLOCK, KEY_PAUSE, KEY_INSERT, KEY_HOME,
  KEY_PAGEUP, KEY_DELETE, KEY_END, KEY_PAGEDOWN,
  KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP,
  KEY_NUMLOCKCLEAR, KEY_KP_DIVIDE, KEY_KP_MULTIPLY, KEY_KP_MINUS,
  KEY_KP_PLUS, KEY_KP_ENTER, KEY_KP_1, KEY_KP_2,
  KEY_KP_3, KEY_KP_4, KEY_KP_5, KEY_KP_6,
  KEY_KP_7, KEY_KP_8, KEY_KP_9, KEY_KP_0,
  KEY_KP_PERIOD, KEY_APPLICATION, KEY_POWER, KEY_KP_EQUALS,
  KEY_F13, KEY_F14, KEY_F15, KEY_F16,
  KEY_F17, KEY_F18, KEY_F19, KEY_F20,
  KEY_F21, KEY_F22, KEY_F23, KEY_F24,
  KEY_EXECUTE, KEY_HELP, KEY_MENU, KEY_SELECT,
  KEY_STOP, KEY_AGAIN, KEY_UNDO, KEY_CUT,
  KEY_COPY, KEY_PASTE, KEY_FIND, KEY_MUTE,
  KEY_VOLUMEUP, KEY_VOLUMEDOWN, KEY_KP_COMMA, KEY_KP_EQUALSAS400,
  KEY_ALTERASE, KEY_SYSREQ, KEY_CANCEL, KEY_CLEAR,
  KEY_PRIOR, KEY_RETURN2, KEY_SEPARATOR, KEY_OUT,
  KEY_OPER, KEY_CLEARAGAIN, KEY_CRSEL, KEY_EXSEL,
  KEY_KP_00, KEY_KP_000, KEY_THOUSANDSSEPARATOR, KEY_DECIMALSEPARATOR,
  KEY_CURRENCYUNIT, KEY_CURRENCYSUBUNIT, KEY_KP_LEFTPAREN, KEY_KP_RIGHTPAREN,
  KEY_KP_LEFTBRACE, KEY_KP_RIGHTBRACE, KEY_KP_TAB, KEY_KP_BACKSPACE,
  KEY_KP_A, KEY_KP_B, KEY_KP_C, KEY_KP_D,
  KEY_KP_E, KEY_KP_F, KEY_KP_XOR, KEY_KP_POWER,
  KEY_KP_PERCENT, KEY_KP_LESS, KEY_KP_GREATER, KEY_KP_AMPERSAND,
  KEY_KP_DBLAMPERSAND, KEY_KP_VERTICALBAR, KEY_KP_DBLVERTICALBAR, KEY_KP_COLON,
  KEY_KP_HASH, KEY_KP_SPACE, KEY_KP_AT, KEY_KP_EXCLAM,
  KEY_KP_MEMSTORE, KEY_KP_MEMRECALL, KEY_KP_MEMCLEAR, KEY_KP_MEMADD,
  KEY_KP_MEMSUBTRACT, KEY_KP_MEMMULTIPLY, KEY_KP_MEMDIVIDE, KEY_KP_PLUSMINUS,
  KEY_KP_CLEAR, KEY_KP_CLEARENTRY, KEY_KP_BINARY, KEY_KP_OCTAL,
  KEY_KP_DECIMAL, KEY_KP_HEXADECIMAL, KEY_LCTRL, KEY_LSHIFT,
  KEY_LALT, KEY_LGUI, KEY_RCTRL, KEY_RSHIFT,
  KEY_RALT, KEY_RGUI, KEY_MODE, KEY_AUDIONEXT,
  KEY_AUDIOPREV, KEY_AUDIOSTOP, KEY_AUDIOPLAY, KEY_AUDIOMUTE,
  KEY_MEDIASELECT, KEY_WWW, KEY_MAIL, KEY_CALCULATOR,
  KEY_COMPUTER, KEY_AC_SEARCH, KEY_AC_HOME, KEY_AC_BACK,
  KEY_AC_FORWARD, KEY_AC_STOP, KEY_AC_REFRESH, KEY_AC_BOOKMARKS,
  KEY_BRIGHTNESSDOWN, KEY_BRIGHTNESSUP, KEY_DISPLAYSWITCH, KEY_KBDILLUMTOGGLE,
  KEY_KBDILLUMDOWN, KEY_KBDILLUMUP, KEY_EJECT, KEY_SLEEP
}
 
enum  EMouseButton : int { UNKNOWN = -1, LEFT = 0, MIDDLE = 1, RIGHT = 2 }
 
enum  EColorChannel : int { Red = 0, Green = 1, Blue = 2, Alpha = 3 }
 
enum  EFBXConversionOptions { CONVERT_ALWAYS, CONVERT_IF_NEWER }
 
enum  EBlendMode : int { NotSet = 0, Opaque, AlphaBlend, Additive }
 
enum  EDepthMode : int {
  NotSet = 0, InheritFromBlendMode, ReadWrite, ReadOnly,
  WriteOnly, NoReadWrite
}
 
enum  EMeshDataUsage { Static, DynamicRead, DynamicWrite }
 
enum  EOrthoCameraMode { PixelSpace = 0, CorrectAspectRatio, Custom }
 
enum  EFilterMode : int {
  Nearest = 0, Linear, NearestMipmapNearest, LinearMipmapNearest,
  NearestMipmapLinear, LinearMipmapLinear
}
 
enum  EWrapMode : int { Repeat = 0, MirroredRepeat, ClampToEdge, ClampToBorder }
 
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  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

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)
 
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 std::string &modulePath, std::string &errorString)
 
NAPAPI void unloadModule (void *module)
 
NAPAPI void * findSymbolInModule (void *module, const char *symbolName)
 
NAPAPI std::string getModuleNameFromPath (const std::string &path)
 
NAPAPI bool isModule (const std::string &path)
 
NAPAPI std::string getModuleExtension ()
 
bool NAPAPI deserializeProjectInfoJSON (const std::string &json, ProjectInfo &result, utility::ErrorState &errorState)
 
bool NAPAPI loadProjectInfoFromFile (const Core &core, ProjectInfo &result, utility::ErrorState &errorState)
 
bool NAPAPI loadProjectInfoFromStream (const Core &core, ProjectInfo &result, utility::ErrorState &errorState, std::istream &in)
 
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)
 
NAPAPI bool getTextureSettingsFromBitmap (const Bitmap &bitmap, bool compress, opengl::Texture2DSettings &settings, nap::utility::ErrorState &errorState)
 
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 (const std::string &meshPath, utility::ErrorState &errorState)
 
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))
 
NAPAPI uint32 computeWebSocketLogLevel (EWebSocketLogLevel level)
 

Variables

NAPAPI const uint nunitoSansSemiBoldSize
 
NAPAPI const uint nunitoSansSemiBoldData [15109]
 
NAPAPI const std::string projectionMatrixUniform
 
NAPAPI const std::string viewMatrixUniform
 
NAPAPI const std::string modelMatrixUniform
 
NAPAPI const glm::mat4x4 identityMatrix
 

Detailed Description

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

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

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

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

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

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

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

class BaseClass
{
    RTTI_ENABLE()
private:
    float       mFloatProperty;

};

class DerivedClass : public BaseClass
{
    RTTI_ENABLE(SomeBaseClass)

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

    int getValue() const { return mIntProperty; }

private:
    int         mIntProperty;
};

The above code defines four new types:

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

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

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

RTTI_BEGIN_CLASS(DataStruct)
        RTTI_PROPERTY("FloatProperty",  &DataStruct::mFloatProperty,    nap::rtti::EPropertyMetaData::None);
        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>

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

◆ APIString

using APIString = APIValue<std::string>

◆ APIStringArray

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

◆ APIWebSocketClientObjectCreator

◆ APIWebSocketEventPtr

using APIWebSocketEventPtr = std::unique_ptr<APIWebSocketEvent>

◆ APIWebSocketServerObjectCreator

◆ ArtNetNode

using ArtNetNode = void*

◆ ArtNetNodeCreator

◆ BoolInstancePropertyValue

Instance property types for all the POD types

◆ ByteVertexAttribute

◆ CharInstancePropertyValue

◆ ClonedComponentResourceList

◆ DacObjectCreator

◆ DoubleInstancePropertyValue

◆ DoubleVertexAttribute

◆ 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

◆ FloatInstancePropertyValue

◆ FloatVertexAttribute

◆ FontObjectCreator

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

◆ InputEventPtr

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

◆ InputEventPtrList

using InputEventPtrList = std::vector<InputEventPtr>

◆ int16

using int16 = uint16_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>

◆ ParameterBool

◆ ParameterByte

using ParameterByte = ParameterNumeric<uint8_t>

◆ ParameterChar

◆ ParameterDouble

◆ ParameterFloat

◆ ParameterInt

◆ ParameterIVec2

using ParameterIVec2 = ParameterVec<glm::ivec2>

◆ ParameterIVec3

using ParameterIVec3 = ParameterVec<glm::ivec3>

◆ ParameterLong

using ParameterLong = ParameterNumeric<int64_t>

◆ ParameterQuat

using ParameterQuat = ParameterSimple<glm::quat>

◆ ParameterRGBAColor8

◆ ParameterRGBAColorFloat

◆ ParameterRGBColor8

◆ ParameterRGBColorFloat

◆ ParameterVec2

using ParameterVec2 = ParameterVec<glm::vec2>

◆ ParameterVec3

using ParameterVec3 = ParameterVec<glm::vec3>

◆ PythonScriptObjectCreator

◆ QuatInstancePropertyValue

◆ RColor16

◆ RColor8

using RColor8 = RColor<uint8>

◆ RColorBase

using RColorBase = Color<T,1>

◆ RColorData16

◆ RColorData8

◆ RColorDataFloat

using RColorDataFloat = RColor<float*>

◆ RColorFloat

using RColorFloat = RColor<float>

◆ 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

◆ SceneCreator

◆ Seconds

using Seconds = std::chrono::seconds

Seconds type definition.

◆ StringInstancePropertyValue

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

◆ 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

◆ UniformTextureBindings

using UniformTextureBindings = std::unordered_map<std::string, UniformBinding>

◆ UniformValueBindings

using UniformValueBindings = std::unordered_map<std::string, UniformBinding>

◆ Vec2InstancePropertyValue

◆ Vec2VertexAttribute

◆ Vec3InstancePropertyValue

◆ Vec3VertexAttribute

◆ Vec4InstancePropertyValue

◆ Vec4VertexAttribute

◆ VideoObjectCreator

◆ WebSocketClientObjectCreator

◆ 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

◆ 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 

Transparant object (SrcAlpha, InvSrcAlpha) blend.

Additive 

Additive, (One, One) blend.

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

◆ 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 

◆ 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 to z-buffer is used for reading and writing. When inheriting from blend mode

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.

◆ 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 : int
strong

Texture min filter

Enumerator
Nearest 

Nearest.

Linear 

Linear.

NearestMipmapNearest 

NearestMipmapNearest.

LinearMipmapNearest 

LinearMipmapNearest.

NearestMipmapLinear 

NearestMipmapLinear.

LinearMipmapLinear 

LinearMipmapLinear.

◆ 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 

◆ EMeshDataUsage

enum EMeshDataUsage
strong

Flag that determines how the mesh data is used at runtime. Note that these are only potential performance improvements; they do not actually restrict the way you can use the mesh (i.e. you can still read data from a static mesh).

Enumerator
Static 

Data of the mesh does not change.

DynamicRead 

Data of the mesh is frequently read from GPU to CPU.

DynamicWrite 

Data of the mesh is frequently updated from CPU to GPU.

◆ EMonth

enum EMonth : int
strong

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

Enumerator
January 

January.

February 

February.

March 

March.

April 

April.

May 

May.

June 

June.

July 

July.

August 

August.

September 

September.

October 

October.

November 

November.

December 

December.

Unknown 

Unknown.

◆ EMouseButton

enum EMouseButton : int
strong

Enum describing a list of all possible mouse buttons

Enumerator
UNKNOWN 
LEFT 
MIDDLE 
RIGHT 

◆ EOrthoCameraMode

Orthographic camera space operation mode

Enumerator
PixelSpace 

left/right/top/bottom 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.

◆ 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 

◆ 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

◆ EWebSocketForwardMode

enum EWebSocketForwardMode : int
strong

Enum that describes how a nap::APIWebSocketClient and nap::APIWebSocketServer forward web-socket messages.

Enumerator
WebSocketEvent 

Create and forward web socket events only.

APIEvent 

Create and forward api events only.

Both 

Create and forward both web-socket and api events.

◆ 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 

◆ EWrapMode

enum EWrapMode : int
strong

Texture wrap mode

Enumerator
Repeat 

Repeat.

MirroredRepeat 

MirroredRepeat.

ClampToEdge 

ClampToEdge.

ClampToBorder 

ClampToBorder.

Function Documentation

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

Convert (split) a FBX into multiple parts. Currently only converts the meshes.

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

◆ createTimestamp()

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

Create a timestamp from the given data

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
Returns
the complete timestamp

◆ deserializeProjectInfoJSON()

bool NAPAPI nap::deserializeProjectInfoJSON ( const std::string &  json,
ProjectInfo result,
utility::ErrorState errorState 
)

Deserialize project information from the specified JSON string

Parameters
jsonThe JSON to deserialize from
resultThe resulting project information
errorStateThe error state of deserialization
Returns
True if deserialization succeeded, false if not. In case of failure, errorState contains detailed error info.

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

◆ 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

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

◆ getModuleExtension()

NAPAPI std::string nap::getModuleExtension ( )
Returns
Module filename extension for platform

◆ getModuleNameFromPath()

NAPAPI std::string nap::getModuleNameFromPath ( const std::string &  path)
Parameters
pathPath to the module
Returns
Name of the module

◆ getTextureSettingsFromBitmap()

NAPAPI bool nap::getTextureSettingsFromBitmap ( const Bitmap bitmap,
bool  compress,
opengl::Texture2DSettings settings,
nap::utility::ErrorState errorState 
)

Creates matching opengl texture settings based on the properties of a bitmap

Parameters
bitmapthe bitmap used to construct a set of opengl texture settings
compressif the opengl texture settings include a compressed format
settingsthe constructed opengl texture settings based on the bitmap
errorStatecontains the error when no settings could be derived from the bitmap
Returns
if the opengl texture settings could be constructed successfully

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

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() [3/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() [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]

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() [3/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() [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.

◆ isModule()

NAPAPI bool nap::isModule ( const std::string &  path)
Parameters
pathPath to the module
Returns
Whether the path points to a module for this platform.

◆ loadMesh()

NAPAPI std::unique_ptr<MeshInstance> nap::loadMesh ( 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
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 std::string &  modulePath,
std::string &  errorString 
)

Platform-wrapper function to load a shared library

Parameters
modulePathThe path to the shared library to load
errorStringIf the module failed to load, the error string
Returns
Handle to the loaded module

◆ loadProjectInfoFromFile()

bool NAPAPI nap::loadProjectInfoFromFile ( const Core core,
ProjectInfo result,
utility::ErrorState errorState 
)

Read and deserialize and project information from JSON file

Parameters
corethe core instance
resultThe resulting project information
errorStateThe error state of deserialization
Returns
True if read and deserialization succeeded, false if not. In case of failure, errorState contains detailed error info.

◆ loadProjectInfoFromStream()

bool NAPAPI nap::loadProjectInfoFromStream ( const Core core,
ProjectInfo result,
utility::ErrorState errorState,
std::istream &  in 
)

Read and deserialize and project information from JSON stream

Parameters
corethe core instance
resultThe resulting project information
errorStateThe error state of deserialization
inThe input stream to read from
Returns
True if read and deserialization succeeded, false if not. In case of failure, errorState contains detailed error info.

◆ operator &()

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

◆ operator|()

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

◆ 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

Variable Documentation

◆ identityMatrix

NAPAPI const glm::mat4x4 identityMatrix

GLM Identity Matrix

◆ modelMatrixUniform

NAPAPI const std::string modelMatrixUniform

GLSL uniform attribute name of model matrix

◆ nunitoSansSemiBoldData

NAPAPI const uint nunitoSansSemiBoldData[15109]

The compressed font data used by IMGui

◆ nunitoSansSemiBoldSize

NAPAPI const uint nunitoSansSemiBoldSize

Size of the font data buffer

◆ projectionMatrixUniform

NAPAPI const std::string projectionMatrixUniform

GLSL uniform attribute name for projection matrix

◆ viewMatrixUniform

NAPAPI const std::string viewMatrixUniform

GLSL uniform attribute name for view matrix