Fove SDK  v1.1.0
Classes | Macros | Typedefs | Enumerations | Functions | Variables
FoveAPI.h File Reference

This file contains the entire FOVE API, no other headers are needed. More...

#include <exception>
#include <string>
#include <utility>
#include <vector>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
Include dependency graph for FoveAPI.h:

Classes

class  Fove::Compositor
 Compositor API. More...
 
struct  Fove::Details::ConfigHelperStruct< T >
 
struct  Fove::Details::ConfigHelperStruct< bool >
 
struct  Fove::Details::ConfigHelperStruct< float >
 
struct  Fove::Details::ConfigHelperStruct< int >
 
struct  Fove::Exception
 Exception type that is thrown when an error is ignored in the FOVE API. More...
 
class  Fove::Headset
 Main API for using headsets. More...
 
struct  Fove::HeadsetHardwareInfo
 Struct Contains hardware information for the headset. More...
 
class  Fove::Object< CType >
 Base class for classes in the FOVE C++ API. More...
 
class  Fove::Result< Value >
 Class for return values from the C++ API. More...
 
struct  Fove::Stereo< Type >
 Class to hold two copies of something, one for each left and right respectively. More...
 
struct  Fove_AdapterId
 Struct used to identify a GPU adapter (Windows only) More...
 
struct  Fove_BitmapImage
 A 2D bitmap image. More...
 
struct  Fove_BoundingBox
 A bounding box. More...
 
struct  Fove_Buffer
 A generic memory buffer. More...
 
struct  Fove_CalibrationData
 Provide all the calibration data needed to render the current state of the calibration process. More...
 
struct  Fove_CalibrationOptions
 Parameters specifying how to run a calibration process. More...
 
struct  Fove_CalibrationTarget
 Represent a calibration target of the calibration process. More...
 
struct  Fove_CameraObject
 Represents a camera in a 3D world. More...
 
struct  Fove_ColliderCube
 Define a cube collider shape. More...
 
struct  Fove_ColliderMesh
 Define a mesh collider shape. More...
 
struct  Fove_ColliderSphere
 Define a sphere collider shape. More...
 
struct  Fove_CompositorLayer
 Struct used to store information about an existing compositor layer (after it is created) More...
 
struct  Fove_CompositorLayerCreateInfo
 Struct used to define the settings for a compositor client. More...
 
struct  Fove_CompositorLayerEyeSubmitInfo
 Struct used to conglomerate the texture settings for a single eye, when submitting a given layer. More...
 
struct  Fove_CompositorLayerSubmitInfo
 Struct used to conglomerate the texture settings when submitting a given layer. More...
 
struct  Fove_CompositorTexture
 Base class of API-specific texture classes. More...
 
struct  Fove_DX11Texture
 Struct used to submit a DirectX 11 texture. More...
 
struct  Fove_EyeShape
 Specify the shape of an eye. More...
 
struct  Fove_FrameTimestamp
 A frame timestamp information. More...
 
struct  Fove_GazableObject
 Represents an object in a 3D world. More...
 
struct  Fove_GLTexture
 Struct used to submit an OpenGL texture. More...
 
struct  Fove_HeadsetHardwareInfo
 Struct Contains hardware information for the headset. More...
 
struct  Fove_Matrix44
 Struct to hold a rectangular array. More...
 
struct  Fove_MetalTexture
 Struct used to submit a texture using the Apple Metal API. More...
 
struct  Fove_ObjectCollider
 Represents a colliding part of a gazable object. More...
 
struct  Fove_ObjectPose
 Represents the pose of an object of the scene. More...
 
struct  Fove_Pose
 Struct to represent a combination of position and orientation of Fove Headset. More...
 
struct  Fove_ProjectionParams
 Struct holding information about projection frustum planes. More...
 
struct  Fove_PupilShape
 Specity the shape of a pupil as an ellipse. More...
 
struct  Fove_Quaternion
 Struct representation on a quaternion. More...
 
struct  Fove_Ray
 Struct to represent a Ray. More...
 
struct  Fove_TextureBounds
 Specify a region of a texture in normalized space. More...
 
struct  Fove_Vec2
 Struct to represent a 2D-vector. More...
 
struct  Fove_Vec2i
 Struct to represent a 2D-vector of integers. More...
 
struct  Fove_Vec3
 Struct to represent a 3D-vector. More...
 
struct  Fove_Versions
 Struct to list various version info about the FOVE software. More...
 
struct  Fove_VulkanContext
 Struct to represent a suite of vulkan components to be used for texture submission. More...
 
struct  Fove_VulkanTexture
 
struct  Fove_VulkanTextureResources
 Struct to hold handles to resources for a texture. More...
 

Macros

#define FOVE_CALLBACK
 Defines any needed modifiers to function pointers for callbacks, e.g. to use a different calling convention.
 
#define FOVE_CONSTEXPR   const
 Helper for declaring a compile time constant.
 
#define FOVE_CXX_NAMESPACE   Fove
 
#define FOVE_DEFINE_CXX_API   0
 Macro that controls whether the C++ API will be defined. More...
 
#define FOVE_DEPRECATED(func, rem)   func
 Helper for declaring deprecated functions.
 
#define FOVE_ENUM(enumName)   enum class Fove_ ## enumName
 Helper to start an API enum.
 
#define FOVE_ENUM_END(enumName)   ; namespace FOVE_CXX_NAMESPACE { using enumName = Fove_ ## enumName; }
 Helper to finish an API enum.
 
#define FOVE_ENUM_VAL(enumName, valueName)   valueName
 Helper to add a value to an API enum.
 
#define FOVE_EXCEPTIONS   1
 
#define FOVE_EXPORT   FOVE_EXTERN_C
 Helper for declaring the public visibility of a function.
 
#define FOVE_EXTERN_C
 Helper for disabling name mangling, etc.
 
#define FOVE_NOEXCEPT
 Define this to empty to remove noexcept specifiers from the API.
 
#define FOVE_STRUCT(structName)   struct Fove_ ## structName
 Helper to start an API struct.
 
#define FOVE_STRUCT_END(structName)   ; namespace FOVE_CXX_NAMESPACE { using structName = Fove_ ## structName; }
 Helper to complete an API struct.
 
#define FOVE_STRUCT_END_NO_CXX_ALIAS(structName)
 Helper to complete an API struct without aliasing it in C++.
 
#define FOVE_STRUCT_VAL(memberName, defaultVal)   memberName = defaultVal
 Helper to add a member to an API struct.
 

Typedefs

using Fove::AdapterId = Fove_AdapterId
 
using Fove::AlphaMode = Fove_AlphaMode
 
using Fove::BitmapImage = Fove_BitmapImage
 
using Fove::BoundingBox = Fove_BoundingBox
 
using Fove::Buffer = Fove_Buffer
 
using Fove::CalibrationData = Fove_CalibrationData
 
using Fove::CalibrationMethod = Fove_CalibrationMethod
 
using Fove::CalibrationOptions = Fove_CalibrationOptions
 
using Fove::CalibrationState = Fove_CalibrationState
 
using Fove::CalibrationTarget = Fove_CalibrationTarget
 
using Fove::CameraObject = Fove_CameraObject
 
using Fove::ClientCapabilities = Fove_ClientCapabilities
 
using Fove::ColliderCube = Fove_ColliderCube
 
using Fove::ColliderMesh = Fove_ColliderMesh
 
using Fove::ColliderSphere = Fove_ColliderSphere
 
using Fove::ColliderType = Fove_ColliderType
 
using Fove::CompositorLayer = Fove_CompositorLayer
 
using Fove::CompositorLayerCreateInfo = Fove_CompositorLayerCreateInfo
 
using Fove::CompositorLayerEyeSubmitInfo = Fove_CompositorLayerEyeSubmitInfo
 
using Fove::CompositorLayerSubmitInfo = Fove_CompositorLayerSubmitInfo
 
using Fove::CompositorLayerType = Fove_CompositorLayerType
 
using Fove::CompositorTexture = Fove_CompositorTexture
 
using Fove::DX11Texture = Fove_DX11Texture
 
using Fove::ErrorCode = Fove_ErrorCode
 
using Fove::Eye = Fove_Eye
 
using Fove::EyeByEyeCalibration = Fove_EyeByEyeCalibration
 
using Fove::EyeShape = Fove_EyeShape
 
using Fove::EyeState = Fove_EyeState
 
typedef struct Fove_Compositor_ * Fove_Compositor
 Opaque type representing a compositor connection.
 
typedef struct Fove_Headset_ * Fove_Headset
 Opaque type representing a headset object.
 
typedef struct VkDevice_T * Fove_VkDevice
 Opaque type representing a vulkan logical device (It must have VK_KHR_external_memory and VK_KHR_external_memory_fd enabled)
 
typedef struct VkDeviceMemory_T * Fove_VkDeviceMemory
 Opaque type representing a vulkan device memory region.
 
typedef struct VkImage_T * Fove_VkImage
 Opaque type representing a vulkan image.
 
typedef struct VkImageView_T * Fove_VkImageView
 Opaque type representing a vulkan image view.
 
typedef struct VkInstance_T * Fove_VkInstance
 Opaque type representing a vulkan instance.
 
typedef struct VkPhysicalDevice_T * Fove_VkPhysicalDevice
 Opaque type representing a vulkan physical device.
 
typedef struct VkQueue_T * Fove_VkQueue
 Opaque type representing a vulkan queue.
 
using Fove::FrameTimestamp = Fove_FrameTimestamp
 
using Fove::GazableObject = Fove_GazableObject
 
using Fove::GazeCastPolicy = Fove_GazeCastPolicy
 
using Fove::GLTexture = Fove_GLTexture
 
using Fove::GraphicsAPI = Fove_GraphicsAPI
 
using Fove::LogLevel = Fove_LogLevel
 
using Fove::Matrix44 = Fove_Matrix44
 
using Fove::MetalTexture = Fove_MetalTexture
 
using Fove::ObjectCollider = Fove_ObjectCollider
 
using Fove::ObjectGroup = Fove_ObjectGroup
 
using Fove::ObjectPose = Fove_ObjectPose
 
using Fove::Pose = Fove_Pose
 
using Fove::ProjectionParams = Fove_ProjectionParams
 
using Fove::PupilShape = Fove_PupilShape
 
using Fove::Quaternion = Fove_Quaternion
 
using Fove::Ray = Fove_Ray
 
using Fove::TextureBounds = Fove_TextureBounds
 
using Fove::Vec2 = Fove_Vec2
 
using Fove::Vec2i = Fove_Vec2i
 
using Fove::Vec3 = Fove_Vec3
 
using Fove::Versions = Fove_Versions
 
using Fove::VulkanContext = Fove_VulkanContext
 
using Fove::VulkanTexture = Fove_VulkanTexture
 
using Fove::VulkanTextureResources = Fove_VulkanTextureResources
 

Enumerations

enum  Fove_AlphaMode { Fove_AlphaMode::Auto = 0, Fove_AlphaMode::One = 1, Fove_AlphaMode::Sample = 2 }
 Enum to help interpret the alpha of texture. More...
 
enum  Fove_CalibrationMethod {
  Fove_CalibrationMethod::Default, Fove_CalibrationMethod::OnePoint, Fove_CalibrationMethod::Spiral, Fove_CalibrationMethod::OnePointWithNoGlassesSpiralWithGlasses,
  Fove_CalibrationMethod::ZeroPoint
}
 Indicate the calibration method to use. More...
 
enum  Fove_CalibrationState {
  Fove_CalibrationState::NotStarted, Fove_CalibrationState::HeadsetAdjustment, Fove_CalibrationState::WaitingForUser, Fove_CalibrationState::CollectingData,
  Fove_CalibrationState::ProcessingData, Fove_CalibrationState::Successful_HighQuality, Fove_CalibrationState::Successful_MediumQuality, Fove_CalibrationState::Successful_LowQuality,
  Fove_CalibrationState::Failed_Unknown, Fove_CalibrationState::Failed_InaccurateData, Fove_CalibrationState::Failed_NoRenderer, Fove_CalibrationState::Failed_NoUser,
  Fove_CalibrationState::Failed_Aborted
}
 Indicate the state of a calibration process. More...
 
enum  Fove_ClientCapabilities {
  Fove_ClientCapabilities::None = 0, Fove_ClientCapabilities::OrientationTracking = 1 << 0, Fove_ClientCapabilities::PositionTracking = 1 << 1, Fove_ClientCapabilities::PositionImage = 1 << 2,
  Fove_ClientCapabilities::EyeTracking = 1 << 3, Fove_ClientCapabilities::GazeDepth = 1 << 4, Fove_ClientCapabilities::UserPresence = 1 << 5, Fove_ClientCapabilities::UserAttentionShift = 1 << 6,
  Fove_ClientCapabilities::UserIOD = 1 << 7, Fove_ClientCapabilities::UserIPD = 1 << 8, Fove_ClientCapabilities::EyeTorsion = 1 << 9, Fove_ClientCapabilities::EyeShape = 1 << 10,
  Fove_ClientCapabilities::EyesImage = 1 << 11, Fove_ClientCapabilities::EyeballRadius = 1 << 12, Fove_ClientCapabilities::IrisRadius = 1 << 13, Fove_ClientCapabilities::PupilRadius = 1 << 14,
  Fove_ClientCapabilities::GazedObjectDetection = 1 << 15, Fove_ClientCapabilities::DirectScreenAccess = 1 << 16, Fove_ClientCapabilities::PupilShape = 1 << 17
}
 List of capabilities usable by clients. More...
 
enum  Fove_ColliderType { Fove_ColliderType::Cube = 0, Fove_ColliderType::Sphere = 1, Fove_ColliderType::Mesh = 2 }
 Specify the different collider shape types. More...
 
enum  Fove_CompositorLayerType { Fove_CompositorLayerType::Base = 0, Fove_CompositorLayerType::Overlay = 0x10000, Fove_CompositorLayerType::Diagnostic = 0x20000 }
 Compositor layer type, which defines how clients are composited. More...
 
enum  Fove_ErrorCode {
  Fove_ErrorCode::None = 0, Fove_ErrorCode::Connect_NotConnected = 7, Fove_ErrorCode::Connect_RuntimeVersionTooOld = 4, Fove_ErrorCode::Connect_ClientVersionTooOld = 6,
  Fove_ErrorCode::API_InvalidArgument = 103, Fove_ErrorCode::API_NotRegistered = 104, Fove_ErrorCode::API_NullInPointer = 110, Fove_ErrorCode::API_InvalidEnumValue = 111,
  Fove_ErrorCode::API_NullOutPointersOnly = 120, Fove_ErrorCode::API_OverlappingOutPointers = 121, Fove_ErrorCode::API_MissingArgument = 123, Fove_ErrorCode::API_Timeout = 130,
  Fove_ErrorCode::Data_Unreadable = 1002, Fove_ErrorCode::Data_NoUpdate = 1003, Fove_ErrorCode::Data_Uncalibrated = 1004, Fove_ErrorCode::Data_Unreliable = 1006,
  Fove_ErrorCode::Data_LowAccuracy = 1007, Hardware_Disconnected = 2006, Fove_ErrorCode::Hardware_WrongFirmwareVersion = 2007, Fove_ErrorCode::Code_NotImplementedYet = 4000,
  Fove_ErrorCode::Code_FunctionDeprecated = 4001, Fove_ErrorCode::Position_ObjectNotTracked = 5008, Fove_ErrorCode::Compositor_NotSwapped = 122, Fove_ErrorCode::Compositor_UnableToCreateDeviceAndContext = 8000,
  Fove_ErrorCode::Compositor_UnableToUseTexture = 8001, Fove_ErrorCode::Compositor_DeviceMismatch = 8002, Fove_ErrorCode::Compositor_DisconnectedFromRuntime = 8006, Fove_ErrorCode::Compositor_ErrorCreatingTexturesOnDevice = 8008,
  Fove_ErrorCode::Compositor_NoEyeSpecifiedForSubmit = 8009, Fove_ErrorCode::UnknownError = 9000, Fove_ErrorCode::Object_AlreadyRegistered = 10000, Fove_ErrorCode::Calibration_OtherRendererPrioritized = 11000,
  Fove_ErrorCode::License_FeatureAccessDenied = 12000, Fove_ErrorCode::Profile_DoesntExist = 13000, Fove_ErrorCode::Profile_NotAvailable = 13001, Fove_ErrorCode::Profile_InvalidName = 13002,
  Fove_ErrorCode::Config_DoesntExist = 14000, Fove_ErrorCode::Config_TypeMismatch = 14001
}
 The error codes that the Fove system may return. More...
 
enum  Fove_Eye { Fove_Eye::Left = 0, Fove_Eye::Right = 1 }
 Enum specifying the left or right eye. More...
 
enum  Fove_EyeByEyeCalibration { Fove_EyeByEyeCalibration::Default, Fove_EyeByEyeCalibration::Disabled, Fove_EyeByEyeCalibration::Enabled }
 Indicate whether each eye should be calibrated separately or not. More...
 
enum  Fove_EyeState { Fove_EyeState::NotDetected = 0, Fove_EyeState::Opened = 1, Fove_EyeState::Closed = 2 }
 Enum specifying the state of an eye. More...
 
enum  Fove_GazeCastPolicy { Fove_GazeCastPolicy::DismissBothEyeClosed, Fove_GazeCastPolicy::DismissOneEyeClosed, Fove_GazeCastPolicy::NeverDismiss }
 Specify when user gaze casts should be dismissed based on his eyes openness. More...
 
enum  Fove_GraphicsAPI { Fove_GraphicsAPI::DirectX = 0, Fove_GraphicsAPI::OpenGL = 1, Fove_GraphicsAPI::Metal = 2, Fove_GraphicsAPI::Vulkan = 3 }
 Enum for type of Graphics API. More...
 
enum  Fove_LogLevel { Fove_LogLevel::Debug = 0, Fove_LogLevel::Warning = 1, Fove_LogLevel::Error = 2 }
 Severity level of log messages. More...
 
enum  Fove_ObjectGroup {
  Group0 = 1 << 0, Group1 = 1 << 1, Group2 = 1 << 2, Group3 = 1 << 3,
  Group4 = 1 << 4, Group5 = 1 << 5, Group6 = 1 << 6, Group7 = 1 << 7,
  Group8 = 1 << 8, Group9 = 1 << 9, Group10 = 1 << 10, Group11 = 1 << 11,
  Group12 = 1 << 12, Group13 = 1 << 13, Group14 = 1 << 14, Group15 = 1 << 15,
  Group16 = 1 << 16, Group17 = 1 << 17, Group18 = 1 << 18, Group19 = 1 << 19,
  Group20 = 1 << 20, Group21 = 1 << 21, Group22 = 1 << 22, Group23 = 1 << 23,
  Group24 = 1 << 24, Group25 = 1 << 25, Group26 = 1 << 26, Group27 = 1 << 27,
  Group28 = 1 << 28, Group29 = 1 << 29, Group30 = 1 << 30, Group31 = 1 << 31
}
 The groups of objects of the scene.
 

Functions

Result Fove::clearConfigValue (const std::string &key)
 
Fove_ErrorCode fove_Compositor_createLayer (Fove_Compositor *, const Fove_CompositorLayerCreateInfo *layerInfo, Fove_CompositorLayer *outLayer)
 Creates a new layer within the compositor. More...
 
Fove_ErrorCode fove_Compositor_destroy (Fove_Compositor *)
 Frees resources used by the compositor object, including memory and sockets. More...
 
Fove_ErrorCode fove_Compositor_getAdapterId (Fove_Compositor *, Fove_AdapterId *outAdapterId)
 Returns the ID of the GPU currently attached to the headset. More...
 
Fove_ErrorCode fove_Compositor_getLastRenderPose (Fove_Compositor *, Fove_Pose *outPose)
 Get the last cached pose for rendering purposes.
 
Fove_ErrorCode fove_Compositor_isReady (Fove_Compositor *, bool *outIsReady)
 Returns true if we are connected to a running compositor and ready to submit frames for compositing.
 
Fove_ErrorCode fove_Compositor_submit (Fove_Compositor *, const Fove_CompositorLayerSubmitInfo *submitInfo, size_t layerCount)
 Submit a frame to the compositor. More...
 
Fove_ErrorCode fove_Compositor_waitForRenderPose (Fove_Compositor *, Fove_Pose *outPose)
 Wait for the most recent pose for rendering purposes. More...
 
Fove_ErrorCode fove_Config_clearValue (const char *key)
 Reset the value of the provided key to its default value. More...
 
Fove_ErrorCode fove_Config_getValue_bool (const char *key, bool *outValue)
 Get the value of the provided key from the FOVE config. More...
 
Fove_ErrorCode fove_Config_getValue_float (const char *key, float *outValue)
 Get the value of the provided key from the FOVE config. More...
 
Fove_ErrorCode fove_Config_getValue_int (const char *key, int *outValue)
 Get the value of the provided key from the FOVE config. More...
 
Fove_ErrorCode fove_Config_getValue_string (const char *key, void(*callback)(const char *value, void *callbackData), void *callbackData)
 Get the value of the provided key from the FOVE config. More...
 
Fove_ErrorCode fove_Config_setValue_bool (const char *key, bool value)
 Set the value of the provided key to the FOVE config. More...
 
Fove_ErrorCode fove_Config_setValue_float (const char *key, float value)
 Set the value of the provided key to the FOVE config. More...
 
Fove_ErrorCode fove_Config_setValue_int (const char *key, int value)
 Set the value of the provided key to the FOVE config. More...
 
Fove_ErrorCode fove_Config_setValue_string (const char *key, const char *value)
 Set the value of the provided key to the FOVE config. More...
 
Fove_ErrorCode fove_createHeadset (Fove_ClientCapabilities capabilities, Fove_Headset **outHeadset)
 Creates and returns an Fove_Headset object, which is the entry point to the entire API. More...
 
Fove_ErrorCode fove_Headset_checkSoftwareVersions (Fove_Headset *)
 Checks whether the client can run against the installed version of the FOVE SDK. More...
 
Fove_ErrorCode fove_Headset_createCompositor (Fove_Headset *, Fove_Compositor **outCompositor)
 Returns a compositor interface from the given headset. More...
 
Fove_ErrorCode fove_Headset_createProfile (Fove_Headset *, const char *newName)
 Creates a new profile. More...
 
Fove_ErrorCode fove_Headset_deleteProfile (Fove_Headset *, const char *profileName)
 Deletes an existing profile. More...
 
Fove_ErrorCode fove_Headset_destroy (Fove_Headset *)
 Frees resources used by a headset object, including memory and sockets. More...
 
Fove_ErrorCode fove_Headset_fetchEyeTrackingData (Fove_Headset *, Fove_FrameTimestamp *outTimestamp)
 Fetch the latest eye tracking related data from runtime service. More...
 
Fove_ErrorCode fove_Headset_fetchPoseData (Fove_Headset *, Fove_FrameTimestamp *outTimestamp)
 Fetch the latest headset pose related data from runtime service. More...
 
Fove_ErrorCode fove_Headset_getCombinedGazeDepth (Fove_Headset *, float *outDepth)
 Writes out eyes gaze depth resulting from the two eye gazes combined together. More...
 
Fove_ErrorCode fove_Headset_getCombinedGazeRay (Fove_Headset *, Fove_Ray *outRay)
 Writes out eyes gaze ray resulting from the two eye gazes combined together. More...
 
Fove_ErrorCode fove_Headset_getCurrentProfile (Fove_Headset *, void(*callback)(const char *callbackProfileName, void *callbackData), void *callbackData)
 Gets the current profile. More...
 
Fove_ErrorCode fove_Headset_getEyeballRadius (Fove_Headset *, Fove_Eye eye, float *outRadius)
 Returns the user eyeballs radius, in meters. More...
 
Fove_ErrorCode fove_Headset_getEyeShape (Fove_Headset *, Fove_Eye eye, Fove_EyeShape *outShape)
 Returns the outline shape of the specified user eye in the Eyes camera image. More...
 
Fove_ErrorCode fove_Headset_getEyesImage (Fove_Headset *, Fove_BitmapImage *outImage)
 Returns the eyes camera image. More...
 
Fove_ErrorCode fove_Headset_getEyeState (Fove_Headset *, Fove_Eye eye, Fove_EyeState *outState)
 Writes out the state of an individual eye. More...
 
Fove_ErrorCode fove_Headset_getEyeToHeadMatrices (Fove_Headset *, Fove_Matrix44 *outLeft, Fove_Matrix44 *outRight)
 Writes out the matrices to convert from eye to head space coordinates. More...
 
Fove_ErrorCode fove_Headset_getEyeTorsion (Fove_Headset *, Fove_Eye eye, float *outAngle)
 Returns the user eye torsion, in degrees. More...
 
Fove_ErrorCode fove_Headset_getEyeTrackingCalibrationState (Fove_Headset *, Fove_CalibrationState *outCalibrationState)
 Get the state of the currently running calibration process.
 
Fove_ErrorCode fove_Headset_getGazeCastPolicy (Fove_Headset *, Fove_GazeCastPolicy *policy)
 Get the current gaze cast policy. More...
 
Fove_ErrorCode fove_Headset_getGazedObjectId (Fove_Headset *, int *const outObjectId)
 Get the id of the object gazed by the user. More...
 
Fove_ErrorCode fove_Headset_getGazeScreenPosition (Fove_Headset *, Fove_Eye eye, Fove_Vec2 *outPos)
 Writes out the user's 2D gaze position on the screens seen through the HMD's lenses. More...
 
Fove_ErrorCode fove_Headset_getGazeVector (Fove_Headset *, Fove_Eye eye, Fove_Vec3 *outVector)
 Writes out the gaze vector of an individual eye. More...
 
Fove_ErrorCode fove_Headset_getHardwareInfo (Fove_Headset *, Fove_HeadsetHardwareInfo *outHardwareInfo)
 Writes out the hardware information. More...
 
Fove_ErrorCode fove_Headset_getIrisRadius (Fove_Headset *, Fove_Eye eye, float *outRadius)
 Returns the user iris radius, in meters. More...
 
Fove_ErrorCode fove_Headset_getPose (Fove_Headset *, Fove_Pose *outPose)
 Writes out the pose of the head-mounted display. More...
 
Fove_ErrorCode fove_Headset_getPositionImage (Fove_Headset *, Fove_BitmapImage *outImage)
 Returns the position camera image. More...
 
Fove_ErrorCode fove_Headset_getProfileDataPath (Fove_Headset *, const char *profileName, void(*callback)(const char *callbackProfileName, void *callbackData), void *callbackData)
 Gets the data folder for a given profile. More...
 
Fove_ErrorCode fove_Headset_getProjectionMatricesLH (Fove_Headset *, float zNear, float zFar, Fove_Matrix44 *outLeftMat, Fove_Matrix44 *outRightMat)
 Writes out the values of passed-in left-handed 4x4 projection matrices. More...
 
Fove_ErrorCode fove_Headset_getProjectionMatricesRH (Fove_Headset *, float zNear, float zFar, Fove_Matrix44 *outLeftMat, Fove_Matrix44 *outRightMat)
 Writes out the values of passed-in right-handed 4x4 projection matrices. More...
 
Fove_ErrorCode fove_Headset_getPupilRadius (Fove_Headset *, Fove_Eye eye, float *outRadius)
 Returns the user pupils radius, in meters. More...
 
Fove_ErrorCode fove_Headset_getPupilShape (Fove_Headset *, Fove_Eye eye, Fove_PupilShape *outShape)
 Returns the pupil shape of the specified user eye in the Eyes camera image. More...
 
Fove_ErrorCode fove_Headset_getRawProjectionValues (Fove_Headset *, Fove_ProjectionParams *outLeft, Fove_ProjectionParams *outRight)
 Writes out values for the view frustum of the specified eye at 1 unit away. More...
 
Fove_ErrorCode fove_Headset_getRenderIOD (Fove_Headset *, float *outIOD)
 Interocular distance to use for rendering in meters. More...
 
Fove_ErrorCode fove_Headset_getSoftwareVersions (Fove_Headset *, Fove_Versions *outSoftwareVersions)
 Writes out the current software versions. More...
 
Fove_ErrorCode fove_Headset_getUserIOD (Fove_Headset *, float *outIOD)
 Returns the user IOD (Inter Occular Distance), in meters. More...
 
Fove_ErrorCode fove_Headset_getUserIPD (Fove_Headset *, float *outIPD)
 Returns the user IPD (Inter Pupillary Distance), in meters. More...
 
Fove_ErrorCode fove_Headset_hasAccessToFeature (Fove_Headset *, const char *inFeatureName, bool *outHasAccess)
 Returns whether the Headset has access to the given feature. More...
 
Fove_ErrorCode fove_Headset_hasHmdAdjustmentGuiTimeout (Fove_Headset *, bool *outTimeout)
 Writes out whether the GUI that asks the user to adjust their headset was hidden by timeout. More...
 
Fove_ErrorCode fove_Headset_isEyeTrackingCalibrated (Fove_Headset *, bool *outEyeTrackingCalibrated)
 Writes out whether eye tracking has been calibrated. More...
 
Fove_ErrorCode fove_Headset_isEyeTrackingCalibratedForGlasses (Fove_Headset *, bool *outGlasses)
 Writes out whether the eye tracking system is currently calibrated for glasses. More...
 
Fove_ErrorCode fove_Headset_isEyeTrackingCalibrating (Fove_Headset *, bool *outEyeTrackingCalibrating)
 Writes out whether eye tracking is in the process of performing a calibration. More...
 
Fove_ErrorCode fove_Headset_isEyeTrackingEnabled (Fove_Headset *, bool *outEyeTrackingEnabled)
 Writes out whether the eye tracking hardware has started. More...
 
Fove_ErrorCode fove_Headset_isEyeTrackingReady (Fove_Headset *, bool *outEyeTrackingReady)
 Writes out whether eye tracking is actively tracking eyes. More...
 
Fove_ErrorCode fove_Headset_isHardwareConnected (Fove_Headset *, bool *outHardwareConnected)
 Writes out whether an HMD is connected or not. More...
 
Fove_ErrorCode fove_Headset_isHardwareReady (Fove_Headset *, bool *outIsReady)
 Writes out whether the hardware for the requested capabilities has started. More...
 
Fove_ErrorCode fove_Headset_isHmdAdjustmentGuiVisible (Fove_Headset *, bool *outHmdAdjustmentGuiVisible)
 Writes out whether or not the GUI that asks the user to adjust their headset is being displayed. More...
 
Fove_ErrorCode fove_Headset_isMotionReady (Fove_Headset *, bool *outMotionReady)
 Writes out whether motion tracking hardware has started. More...
 
Fove_ErrorCode fove_Headset_isPositionReady (Fove_Headset *, bool *outPositionReady)
 Writes out whether position tracking hardware has started and returns whether it was successful. More...
 
Fove_ErrorCode fove_Headset_isUserPresent (Fove_Headset *, bool *outUserPresent)
 Writes out whether the user is wearing the headset or not. More...
 
Fove_ErrorCode fove_Headset_isUserShiftingAttention (Fove_Headset *, bool *outIsShiftingAttention)
 Writes out whether the user is shifting its attention between objects or looking at something specific (fixation or pursuit). More...
 
Fove_ErrorCode fove_Headset_listProfiles (Fove_Headset *, void(*callback)(const char *callbackProfileName, void *callbackData), void *callbackData)
 Lists all existing profiles. More...
 
Fove_ErrorCode fove_Headset_registerCameraObject (Fove_Headset *, const Fove_CameraObject *camera)
 Registers an camera in the 3D world. More...
 
Fove_ErrorCode fove_Headset_registerCapabilities (Fove_Headset *, Fove_ClientCapabilities caps)
 Registers a client capability, enabling the required hardware as needed. More...
 
Fove_ErrorCode fove_Headset_registerGazableObject (Fove_Headset *, const Fove_GazableObject *object)
 Registers an object in the 3D world. More...
 
Fove_ErrorCode fove_Headset_removeCameraObject (Fove_Headset *, int cameraId)
 Removes a previously registered camera from the scene. More...
 
Fove_ErrorCode fove_Headset_removeGazableObject (Fove_Headset *, int objectId)
 Removes a previously registered 3D object from the scene. More...
 
Fove_ErrorCode fove_Headset_renameProfile (Fove_Headset *, const char *oldName, const char *newName)
 Renames an existing profile. More...
 
Fove_ErrorCode fove_Headset_setCurrentProfile (Fove_Headset *, const char *profileName)
 Sets the current profile. More...
 
Fove_ErrorCode fove_Headset_setGazeCastPolicy (Fove_Headset *, Fove_GazeCastPolicy policy)
 Set the current gaze cast policy. More...
 
Fove_ErrorCode fove_Headset_startEyeTrackingCalibration (Fove_Headset *, const Fove_CalibrationOptions *options)
 Starts eye tracking calibration. More...
 
Fove_ErrorCode fove_Headset_stopEyeTrackingCalibration (Fove_Headset *)
 Stops eye tracking calibration if it's running, does nothing if it's not running.
 
Fove_ErrorCode fove_Headset_tareOrientationSensor (Fove_Headset *)
 Tares the orientation of the headset. More...
 
Fove_ErrorCode fove_Headset_tarePositionSensors (Fove_Headset *)
 Tares the position of the headset. More...
 
Fove_ErrorCode fove_Headset_tickEyeTrackingCalibration (Fove_Headset *, float deltaTime, bool isVisible, Fove_CalibrationData *outCalibrationData)
 Tick the current calibration process and retrieve data information to render the current calibration state. More...
 
Fove_ErrorCode fove_Headset_unregisterCapabilities (Fove_Headset *, Fove_ClientCapabilities caps)
 Unregisters a client capability previously registered. More...
 
Fove_ErrorCode fove_Headset_updateCameraObject (Fove_Headset *, int cameraId, const Fove_ObjectPose *pose)
 Update the pose of a registered camera. More...
 
Fove_ErrorCode fove_Headset_updateGazableObject (Fove_Headset *, int objectId, const Fove_ObjectPose *pose)
 Update a previously registered 3D object pose. More...
 
Fove_ErrorCode fove_Headset_waitAndFetchNextEyeTrackingData (Fove_Headset *, Fove_FrameTimestamp *outTimestamp)
 Waits for next eye camera frame to be processed and fetch the updated eye tracking data. More...
 
Fove_ErrorCode fove_logText (Fove_LogLevel level, const char *utf8Text)
 Writes some text to the FOVE log. More...
 
template<typename T >
Result< T > Fove::getConfigValue (const std::string &key)
 
template<>
Result< std::string > Fove::getConfigValue (const std::string &key)
 
bool Fove::isValid (const ErrorCode err)
 Helper function to determine which errors can coexist with values.
 
Result Fove::logText (const LogLevel level, const std::string &utf8Text)
 Wraps fove_logText()
 
template<typename T >
Result Fove::setConfigValue (const std::string &key, const T &value)
 
template<>
Result Fove::setConfigValue (const std::string &key, const std::string &value)
 

Variables

const int fove_ObjectIdInvalid = -1
 Predefined object ID to signify "no object".
 

Detailed Description

This file contains the entire FOVE API, no other headers are needed.

Macro Definition Documentation

◆ FOVE_CXX_NAMESPACE

#define FOVE_CXX_NAMESPACE   Fove

Since the C++ API is header-only, the functions in it do not need to be in any particular namespace.

By default, everything is put in the Fove namespace, but this can be customized if the user prefers.

◆ FOVE_DEFINE_CXX_API

#define FOVE_DEFINE_CXX_API   0

Macro that controls whether the C++ API will be defined.

The C API is always defined after including this header, but the C++ API is optional. In C++ mode, the C API is extended (for example, with default values for struct members) automatically.

User can set this macro to 0 or 1, either in code before including this, or via compile-flag to choose.

Defaults to 0 if the compiler is a C compiler, 1 if the compiler is a C++ compiler.

◆ FOVE_EXCEPTIONS

#define FOVE_EXCEPTIONS   1

Exceptions are enabled by default in the C++ API, because they are a core C++ feature. However, they are only used in specific functions, not everywhere. If you are working in a code base that bans exceptions, define FOVE_EXCEPTIONS to zero. Exceptions are automatically disabled for the unreal engine.

Enumeration Type Documentation

◆ Fove_AlphaMode

enum Fove_AlphaMode
strong

Enum to help interpret the alpha of texture.

Determines how to interpret the alpha of a compositor client texture

Enumerator
Auto 

Base layers will use One, overlay layers will use Sample.

One 

Alpha will always be one (fully opaque)

Sample 

Alpha fill be sampled from the alpha channel of the buffer.

◆ Fove_CalibrationMethod

Indicate the calibration method to use.

Enumerator
Default 

Use the calibration method specified in the configuration file (default: single point)

OnePoint 

Use the simple point calibration method (Requires license)

Spiral 

Use the spiral calibration method.

OnePointWithNoGlassesSpiralWithGlasses 

Use the 1-point calibration method for user without eyeglasses, and the spiral calibration method if user has eyeglasses.

ZeroPoint 

Use the zero point calibration method (Requires license)

◆ Fove_CalibrationState

enum Fove_CalibrationState
strong

Indicate the state of a calibration process.

A calibration process always starts from the NotStarted state, then it can go back and forth between the WaitingForUser & CollectingData states, then it goes to the ProcessingData state and finishes with the Successful state.

A failure can happen any time during the process, and stops the process where it was.

From the ProcessingData state the calibration process do not require any rendering and gameplay can be started if wanted but new calibration won't be effective before reaching the Successful state.

Enumerator
NotStarted 

No calibration process haven't been started yet.

HeadsetAdjustment 

The calibration process is waiting for the user to adjust the headset.

WaitingForUser 

The calibration process is waiting for the user to get ready.

CollectingData 

The calibration process is currently collecting calibration data.

ProcessingData 

The calibration process is currently processing the collected data.

Successful_HighQuality 

The calibration is successful and of high quality.

Successful_MediumQuality 

The calibration is successful and of medium quality.

Successful_LowQuality 

The calibration is successful but of low quality.

Failed_Unknown 

The calibration process failed due to an unknown issue.

Failed_InaccurateData 

The calibration process failed because of inaccurate or flawed data.

Failed_NoRenderer 

The calibration process failed after timeout because it couldn't find a renderer.

Failed_NoUser 

The calibration process failed after timeout because it couldn't detect the user.

Failed_Aborted 

The calibration process was manually aborted by the user.

◆ Fove_ClientCapabilities

List of capabilities usable by clients.

Most features require registering for the relevant capability. If a client queries data related to a capability it has not registered API_NotRegistered will be returned. After a new capability registration the Data_NoUpdate error may be returned for a few frames while the service is bootstrapping the new capability.

This enum is designed to be used as a flag set, so items may be binary logic operators like |.

The FOVE runtime will keep any given set of hardware/software running so long as one client is registering a capability.

The registration of a capability does not necessarily mean that the capability is running. For example, if no position tracking camera is attached, no position tracking will occur regardless of how many clients registered for it.

Enumerator
None 

No capabilities requested.

OrientationTracking 

Enables headset orientation tracking.

PositionTracking 

Enables headset position tracking.

PositionImage 

Enables Position camera image transfer from the runtime service to the client.

EyeTracking 

Enables headset eye tracking.

GazeDepth 

Enables gaze depth computation.

UserPresence 

Enables user presence detection.

UserAttentionShift 

Enables user attention shift computation.

UserIOD 

Enables the calculation of the user IOD.

UserIPD 

Enables the calculation of the user IPD.

EyeTorsion 

Enables the calculation of the user eye torsion.

EyeShape 

Enables the detection of the eyes shape.

EyesImage 

Enables Eye camera image transfer from the runtime service to the client.

EyeballRadius 

Enables the calculation of the user eyeball radius.

IrisRadius 

Enables the calculation of the user iris radius.

PupilRadius 

Enables the calculation of the user pupil radius.

GazedObjectDetection 

Enables gazed object detection based on registered gazable objects.

DirectScreenAccess 

Give you direct access to the HMD screen and disable the Fove compositor.

PupilShape 

Enables the detection of the pupil shape.

◆ Fove_ColliderType

enum Fove_ColliderType
strong

Specify the different collider shape types.

Enumerator
Cube 

A cube shape.

Sphere 

A sphere shape.

Mesh 

A shape defined by a mesh.

◆ Fove_CompositorLayerType

Compositor layer type, which defines how clients are composited.

Enumerator
Base 

The first and main application layer.

Overlay 

Layer over the base layer.

Diagnostic 

Layer over Overlay layer.

◆ Fove_ErrorCode

enum Fove_ErrorCode
strong

The error codes that the Fove system may return.

Enumerator
None 

Indicates that no error occurred.

Connect_NotConnected 

The client lost the connection with the Fove service.

Connect_RuntimeVersionTooOld 

The FOVE runtime version is too old for this client.

Connect_ClientVersionTooOld 

The client version is too old for the installed runtime.

API_InvalidArgument 

An argument passed to an API function was invalid for a reason other than one of the below reasons.

API_NotRegistered 

Data was queried without first registering for that data.

API_NullInPointer 

An input argument passed to an API function was invalid for a reason other than the below reasons.

API_InvalidEnumValue 

An enum argument passed to an API function was invalid.

API_NullOutPointersOnly 

All output arguments were null on a function that requires at least one output (all getters that have no side effects)

API_OverlappingOutPointers 

Two (or more) output parameters passed to an API function overlap in memory. Each output parameter should be a unique, separate object.

API_MissingArgument 

The service was expecting extra arguments that the client didn't provide.

API_Timeout 

A call to an API could not be completed within a timeout.

Data_Unreadable 

The data couldn't be read properly from the shared memory and may be corrupted.

Data_NoUpdate 

The data has not been updated by the system yet and is invalid.

Data_Uncalibrated 

The data is invalid because the feature in question is not calibrated.

Data_Unreliable 

The data is unreliable because the eye tracking has been lost.

Data_LowAccuracy 

The accuracy of the data is low.

Hardware_WrongFirmwareVersion 

The hardware has been physically disconnected

Code_NotImplementedYet 

A wrong version of hardware firmware has been detected

Code_FunctionDeprecated 

The function hasn't been implemented yet

Position_ObjectNotTracked 

The function has been deprecated

Compositor_NotSwapped 

The object is inactive or currently not tracked

This comes from submitting without calling WaitForRenderPose after a complete submit

Compositor_UnableToCreateDeviceAndContext 

Compositor was unable to initialize its backend component.

Compositor_UnableToUseTexture 

Compositor was unable to use the given texture (likely due to mismatched client and data types or an incompatible format)

Compositor_DeviceMismatch 

Compositor was unable to match its device to the texture's, either because of multiple GPUs or a failure to get the device from the texture.

Compositor_DisconnectedFromRuntime 

Compositor was running and is no longer responding.

Compositor_ErrorCreatingTexturesOnDevice 

Failed to create shared textures for compositor.

Compositor_NoEyeSpecifiedForSubmit 

The supplied Fove_Eye for submit is invalid (i.e. is Both or Neither)

UnknownError 

Errors that are unknown or couldn't be classified. If possible, info will be logged about the nature of the issue.

Object_AlreadyRegistered 

The scene object that you attempted to register was already present in the object registry.

Calibration_OtherRendererPrioritized 

Another renderer registered to render the calibration process have a higher priority than current process.

License_FeatureAccessDenied 

You don't have the license rights to use the corresponding feature.

Profile_DoesntExist 

The profile doesn't exist.

Profile_NotAvailable 

The profile already exists when it shouldn't, or is otherwise taken or not available.

Profile_InvalidName 

The profile name is not a valid name.

Config_DoesntExist 

The provided key doesn't exist in the config.

Config_TypeMismatch 

The value type of the key doesn't match.

◆ Fove_Eye

enum Fove_Eye
strong

Enum specifying the left or right eye.

Enumerator
Left 

Left eye.

Right 

Right eye.

◆ Fove_EyeByEyeCalibration

Indicate whether each eye should be calibrated separately or not.

Enumerator
Default 

Use the settings coming from the configuration file (default: Disabled)

Disabled 

Calibrate both eye simultaneously.

Enabled 

Calibrate each eye separately, first the left, then the right. (Requires license)

◆ Fove_EyeState

enum Fove_EyeState
strong

Enum specifying the state of an eye.

Enumerator
NotDetected 

The eye is missing or the tracking was lost.

Opened 

The eye is present and opened.

Closed 

The eye is present and closed.

◆ Fove_GazeCastPolicy

enum Fove_GazeCastPolicy
strong

Specify when user gaze casts should be dismissed based on his eyes openness.

Enumerator
DismissBothEyeClosed 

Dismiss the gaze cast only if both eyes of the eye are closed.

DismissOneEyeClosed 

Dismiss the gaze cast as soon as one of the user's eye is closed.

NeverDismiss 

Never dismiss the user gaze cast. This can be useful especially for debugging.

◆ Fove_GraphicsAPI

enum Fove_GraphicsAPI
strong

Enum for type of Graphics API.

Type of Graphics API Note: We currently only support DirectX

Enumerator
DirectX 

DirectX (Windows only)

OpenGL 

OpenGL (All platforms, currently in BETA)

Metal 

Metal (Mac only)

Vulkan 

Vulkan (Currently Linux only)

◆ Fove_LogLevel

enum Fove_LogLevel
strong

Severity level of log messages.

Enumerator
Debug 

Debug information.

Warning 

An issue requiring attention.

Error 

An unexpected error.

Function Documentation

◆ fove_Compositor_createLayer()

Fove_ErrorCode fove_Compositor_createLayer ( Fove_Compositor ,
const Fove_CompositorLayerCreateInfo layerInfo,
Fove_CompositorLayer outLayer 
)

Creates a new layer within the compositor.

This function create a layer upon which frames may be submitted to the compositor by this client.

A connection to the compositor must exist for this to pass. This means you need to wait for fove_Compositor_isReady before calling this function. However, if connection to the compositor is lost and regained, this layer will persist. For this reason, you should not recreate your layers upon reconnection, simply create them once.

There is no way to delete a layer once created, other than to destroy the Fove_Compositor object. This is a feature we would like to add in the future.

Parameters
layerInfoThe settings for the layer to be created
outLayerA struct where the defaults of the newly created layer will be written
See also
fove_Compositor_submit
Here is the caller graph for this function:

◆ fove_Compositor_destroy()

Fove_ErrorCode fove_Compositor_destroy ( Fove_Compositor )

Frees resources used by the compositor object, including memory and sockets.

Upon return, this compositor pointer should no longer be used.

See also
fove_Headset_createCompositor
Here is the caller graph for this function:

◆ fove_Compositor_getAdapterId()

Fove_ErrorCode fove_Compositor_getAdapterId ( Fove_Compositor ,
Fove_AdapterId outAdapterId 
)

Returns the ID of the GPU currently attached to the headset.

For systems with multiple GPUs, submitted textures to the compositor must from the same GPU that the compositor is using

Here is the caller graph for this function:

◆ fove_Compositor_submit()

Fove_ErrorCode fove_Compositor_submit ( Fove_Compositor ,
const Fove_CompositorLayerSubmitInfo submitInfo,
size_t  layerCount 
)

Submit a frame to the compositor.

This function takes the feed from your game engine to the compositor for output.

Parameters
submitInfoAn array of layerCount Fove_CompositorLayerSubmitInfo structs, each of which provides texture data for a unique layer
layerCountThe number of layers you are submitting
See also
fove_Compositor_submit
Here is the caller graph for this function:

◆ fove_Compositor_waitForRenderPose()

Fove_ErrorCode fove_Compositor_waitForRenderPose ( Fove_Compositor ,
Fove_Pose outPose 
)

Wait for the most recent pose for rendering purposes.

All compositor clients should use this function as the sole means of limiting their frame rate. This allows the client to render at the correct frame rate for the HMD display. Upon this function returning, the client should proceed directly to rendering, to reduce the chance of missing the frame. If outPose is not null, this function will return the latest pose as a convenience to the caller. In general, a client's main loop should look like: { Update(); // Run AI, physics, etc, for the next frame compositor.WaitForRenderPose(&pose); // Wait for the next frame, and get the pose Draw(pose); // Render the scene using the new pose }

Parameters
outPoseThe latest pose of the headset.
Here is the caller graph for this function:

◆ fove_Config_clearValue()

Fove_ErrorCode fove_Config_clearValue ( const char *  key)

Reset the value of the provided key to its default value.

Parameters
keyThe key name of the value to reset, null-terminated and in UTF-8
Returns
#Fove_ErrorCode_None if the value was successfully reset
#Fove_ErrorCode_API_NullInPointer if key is null
#Fove_ErrorCode_Config_DoesntExist if the provided key doesn't exist

◆ fove_Config_getValue_bool()

Fove_ErrorCode fove_Config_getValue_bool ( const char *  key,
bool *  outValue 
)

Get the value of the provided key from the FOVE config.

Parameters
keyThe key name of the value to retrieve, null-terminated and in UTF-8
outValueThe value associated to the key if found.
Returns
#Fove_ErrorCode_None if the value was successfully retrieved
#Fove_ErrorCode_API_NullInPointer if key or outValue is null
#Fove_ErrorCode_Config_DoesntExist if the queried key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not a boolean

◆ fove_Config_getValue_float()

Fove_ErrorCode fove_Config_getValue_float ( const char *  key,
float *  outValue 
)

Get the value of the provided key from the FOVE config.

Parameters
keyThe key name of the value to retrieve, null-terminated and in UTF-8
outValueThe value associated to the key if found.
Returns
#Fove_ErrorCode_None if the value was successfully retrieved
#Fove_ErrorCode_API_NullInPointer if key or outValue is null
#Fove_ErrorCode_Config_DoesntExist if the queried key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not a float

◆ fove_Config_getValue_int()

Fove_ErrorCode fove_Config_getValue_int ( const char *  key,
int *  outValue 
)

Get the value of the provided key from the FOVE config.

Parameters
keyThe key name of the value to retrieve, null-terminated and in UTF-8
outValueThe value associated to the key if found.
Returns
#Fove_ErrorCode_None if the value was successfully retrieved
#Fove_ErrorCode_API_NullInPointer if key or outValue is null
#Fove_ErrorCode_Config_DoesntExist if the queried key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not an int

◆ fove_Config_getValue_string()

Fove_ErrorCode fove_Config_getValue_string ( const char *  key,
void(*)(const char *value, void *callbackData)  callback,
void *  callbackData 
)

Get the value of the provided key from the FOVE config.

Parameters
keyThe key name of the value to retrieve, null-terminated and in UTF-8
callbackA function pointer to a function that will be called once if the key is present
callbackDataAn arbitrary pointer passed to the callback
Returns
#Fove_ErrorCode_None if the value was successfully retrieved
#Fove_ErrorCode_API_NullInPointer if key or outValue is null
#Fove_ErrorCode_Config_DoesntExist if the queried key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not a string

◆ fove_Config_setValue_bool()

Fove_ErrorCode fove_Config_setValue_bool ( const char *  key,
bool  value 
)

Set the value of the provided key to the FOVE config.

Parameters
keyThe key name of the value to set, null-terminated and in UTF-8
valueThe new value to set as the key value.
Returns
#Fove_ErrorCode_None if the value was successfully set
#Fove_ErrorCode_API_NullInPointer if key is null
#Fove_ErrorCode_Config_DoesntExist if the provided key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not a boolean

◆ fove_Config_setValue_float()

Fove_ErrorCode fove_Config_setValue_float ( const char *  key,
float  value 
)

Set the value of the provided key to the FOVE config.

Parameters
keyThe key name of the value to set, null-terminated and in UTF-8
valueThe new value to set as the key value.
Returns
#Fove_ErrorCode_None if the value was successfully set
#Fove_ErrorCode_API_NullInPointer if key is null
#Fove_ErrorCode_Config_DoesntExist if the provided key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not a float

◆ fove_Config_setValue_int()

Fove_ErrorCode fove_Config_setValue_int ( const char *  key,
int  value 
)

Set the value of the provided key to the FOVE config.

Parameters
keyThe key name of the value to set, null-terminated and in UTF-8
valueThe new value to set as the key value.
Returns
#Fove_ErrorCode_None if the value was successfully set
#Fove_ErrorCode_API_NullInPointer if key is null
#Fove_ErrorCode_Config_DoesntExist if the provided key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not an int

◆ fove_Config_setValue_string()

Fove_ErrorCode fove_Config_setValue_string ( const char *  key,
const char *  value 
)

Set the value of the provided key to the FOVE config.

Parameters
keyThe key name of the value to set, null-terminated and in UTF-8
valueThe new value to set as the key value.
Returns
#Fove_ErrorCode_None if the value was successfully set
#Fove_ErrorCode_API_NullInPointer if key or value is null
#Fove_ErrorCode_Config_DoesntExist if the provided key doesn't exist
#Fove_ErrorCode_Config_TypeMismatch if the key exist but its value type is not a string

◆ fove_createHeadset()

Fove_ErrorCode fove_createHeadset ( Fove_ClientCapabilities  capabilities,
Fove_Headset **  outHeadset 
)

Creates and returns an Fove_Headset object, which is the entry point to the entire API.

The result headset should be destroyed using fove_Headset_destroy when no longer needed.

Parameters
capabilitiesThe desired capabilities (Gaze, Orientation, Position), for multiple capabilities, use bitwise-or input such as Fove_ClientCapabilities::Gaze | Fove_ClientCapabilities::Position
outHeadsetA pointer where the address of the newly created headset will be written upon success
See also
fove_Headset_destroy
Here is the caller graph for this function:

◆ fove_Headset_checkSoftwareVersions()

Fove_ErrorCode fove_Headset_checkSoftwareVersions ( Fove_Headset )

Checks whether the client can run against the installed version of the FOVE SDK.

Returns
#Fove_ErrorCode_None if this client is compatible with the currently running service
#Fove_ErrorCode_Connect_RuntimeVersionTooOld if not compatible with the currently running service
Otherwise returns an error representing why this can't be determined
Here is the caller graph for this function:

◆ fove_Headset_createCompositor()

Fove_ErrorCode fove_Headset_createCompositor ( Fove_Headset ,
Fove_Compositor **  outCompositor 
)

Returns a compositor interface from the given headset.

Each call to this function creates a new object. The object should be destroyed with fove_Compositor_destroy It is fine to call this function multiple times with the same headset, the same pointer will be returned. It is ok for the compositor to outlive the headset passed in.

See also
fove_Compositor_destroy
Here is the caller graph for this function:

◆ fove_Headset_createProfile()

Fove_ErrorCode fove_Headset_createProfile ( Fove_Headset ,
const char *  newName 
)

Creates a new profile.

The FOVE system keeps a set of profiles so that different users on the same system can store data, such as calibrations, separately. Profiles persist to disk and survive restart. Third party applications can control the profile system and store data within it.

This function creates a new profile, but does not add any data or switch to it.

Parameters
newNameNull-terminated UTF-8 unique name of the profile to create
Returns
#Fove_ErrorCode_None if the profile was successfully created
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Profile_InvalidName if newName was invalid
#Fove_ErrorCode_Profile_NotAvailable if the name is already taken
#Fove_ErrorCode_API_NullInPointer if newName is null
See also
fove_Headset_renameProfile
fove_Headset_deleteProfile
fove_Headset_listProfiles
fove_Headset_setCurrentProfile
fove_Headset_getCurrentProfile
fove_Headset_getProfileDataPath
Here is the caller graph for this function:

◆ fove_Headset_deleteProfile()

Fove_ErrorCode fove_Headset_deleteProfile ( Fove_Headset ,
const char *  profileName 
)

Deletes an existing profile.

This function deletes an existing profile.

If the deleted profile is the current profile, then no current profile is set after this returns. In such a case, it is undefined whether any existing profile data loaded into memory may be kept around.

Parameters
profileNameNull-terminated UTF-8 name of the profile to be deleted
Returns
#Fove_ErrorCode_None if the profile was successfully deleted
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Profile_DoesntExist if the requested profile at profileName doesn't exist
#Fove_ErrorCode_API_NullInPointer if profileName is null
See also
fove_Headset_createProfile
fove_Headset_renameProfile
fove_Headset_listProfiles
fove_Headset_setCurrentProfile
fove_Headset_getCurrentProfile
fove_Headset_getProfileDataPath
Here is the caller graph for this function:

◆ fove_Headset_destroy()

Fove_ErrorCode fove_Headset_destroy ( Fove_Headset )

Frees resources used by a headset object, including memory and sockets.

Upon return, this headset pointer should no longer be used.

See also
fove_createHeadset
Here is the caller graph for this function:

◆ fove_Headset_fetchEyeTrackingData()

Fove_ErrorCode fove_Headset_fetchEyeTrackingData ( Fove_Headset ,
Fove_FrameTimestamp outTimestamp 
)

Fetch the latest eye tracking related data from runtime service.

This function is never blocking, if the data is already up-to-date no operation is performed. It outputs the timestamp of the new gaze information. This can be used to know if data has been updated or not.

Eye tracking should be enabled by registering the Fove_ClientCapabilities_EyeTracking before calling this function.

Parameters
outTimestampA pointer to the timestamp of fetched data. If null, the timestamp is not written.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
Here is the caller graph for this function:

◆ fove_Headset_fetchPoseData()

Fove_ErrorCode fove_Headset_fetchPoseData ( Fove_Headset ,
Fove_FrameTimestamp outTimestamp 
)

Fetch the latest headset pose related data from runtime service.

This function is never blocking, if the data is already up-to-date no operation is performed. It outputs the timestamp of the new pose data. This can be used to know if data has been updated or not.

At least one of the following capabilities need to be registered to use this function: Fove_ClientCapabilities_PositionTracking, Fove_ClientCapabilities_OrientationTracking, Fove_ClientCapabilities_PositionImage

Parameters
outTimestampA pointer to the timestamp of fetched data. If null, the timestamp is not written.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
Here is the caller graph for this function:

◆ fove_Headset_getCombinedGazeDepth()

Fove_ErrorCode fove_Headset_getCombinedGazeDepth ( Fove_Headset ,
float *  outDepth 
)

Writes out eyes gaze depth resulting from the two eye gazes combined together.

Fove_ClientCapabilities_GazeDepth should be registered to use this function.

Parameters
outDepthA pointer to the gaze depth variable to write to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outDepth is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getCombinedGazeRay()

Fove_ErrorCode fove_Headset_getCombinedGazeRay ( Fove_Headset ,
Fove_Ray outRay 
)

Writes out eyes gaze ray resulting from the two eye gazes combined together.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

To get individual eye rays use fove_Headset_getGazeVector instead

Parameters
outRayA pointer to the gaze ray struct to write to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outRay is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getCurrentProfile()

Fove_ErrorCode fove_Headset_getCurrentProfile ( Fove_Headset ,
void(*)(const char *callbackProfileName, void *callbackData)  callback,
void *  callbackData 
)

Gets the current profile.

The callback is not invoked if there is no current profile.

callbackProfileName is a non-null, null-terminated UTF-8 string with the name of the current profile.

Invoking any other function on this headset from the callback will yield undefined behavior.

Parameters
callbackA function pointer to a function that will be called up to onces
callbackDataAn arbitrary pointer passed to the callback or an empty string if no profile is set)
Returns
#Fove_ErrorCode_None if the profile name was successfully retrieved
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NullInPointer if callback is null
See also
fove_Headset_createProfile
fove_Headset_renameProfile
fove_Headset_deleteProfile
fove_Headset_listProfiles
fove_Headset_setCurrentProfile
fove_Headset_getProfileDataPath
Here is the caller graph for this function:

◆ fove_Headset_getEyeballRadius()

Fove_ErrorCode fove_Headset_getEyeballRadius ( Fove_Headset ,
Fove_Eye  eye,
float *  outRadius 
)

Returns the user eyeballs radius, in meters.

Fove_ClientCapabilities_EyeballRadius should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outRadiusA pointer to the output variable to write the user eyeball radius to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outRadius is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getEyeShape()

Fove_ErrorCode fove_Headset_getEyeShape ( Fove_Headset ,
Fove_Eye  eye,
Fove_EyeShape outShape 
)

Returns the outline shape of the specified user eye in the Eyes camera image.

Fove_ClientCapabilities_EyeShape should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outShapeA pointer to the EyeShape struct to write eye shape to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outShape is nullptr
#Fove_ErrorCode_License_FeatureAccessDenied if the current license is not sufficient for this feature
Here is the caller graph for this function:

◆ fove_Headset_getEyesImage()

Fove_ErrorCode fove_Headset_getEyesImage ( Fove_Headset ,
Fove_BitmapImage outImage 
)

Returns the eyes camera image.

The eyes image is synchronized with and fetched at the same as the gaze during the call to fove_Headset_fetchEyeTrackingData.

The image data buffer is invalidated upon the next call to this function. Fove_ClientCapabilities_EyesImage should be registered to use this function.

Parameters
outImagethe raw image data buffer to write the eyes image data to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreadable if the data couldn't be read properly from memory #Fove_ErrorCode_API_NullInPointer if outImage is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getEyeState()

Fove_ErrorCode fove_Headset_getEyeState ( Fove_Headset ,
Fove_Eye  eye,
Fove_EyeState outState 
)

Writes out the state of an individual eye.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outStateA pointer to the output variable to write the eye state to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outState is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getEyeToHeadMatrices()

Fove_ErrorCode fove_Headset_getEyeToHeadMatrices ( Fove_Headset ,
Fove_Matrix44 outLeft,
Fove_Matrix44 outRight 
)

Writes out the matrices to convert from eye to head space coordinates.

This is simply a translation matrix that returns +/- IOD/2

Parameters
outLeftA pointer to the matrix where left-eye transform data will be written
outRightA pointer to the matrix where right-eye transform data will be written
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if both outLeft and outRight are nullptr
Here is the caller graph for this function:

◆ fove_Headset_getEyeTorsion()

Fove_ErrorCode fove_Headset_getEyeTorsion ( Fove_Headset ,
Fove_Eye  eye,
float *  outAngle 
)

Returns the user eye torsion, in degrees.

Fove_ClientCapabilities_EyeTorsion should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outAngleA pointer to the output variable to write the user eye torsion to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outAngle is nullptr
#Fove_ErrorCode_License_FeatureAccessDenied if the current license is not sufficient for this feature
Here is the caller graph for this function:

◆ fove_Headset_getGazeCastPolicy()

Fove_ErrorCode fove_Headset_getGazeCastPolicy ( Fove_Headset ,
Fove_GazeCastPolicy policy 
)

Get the current gaze cast policy.

Parameters
policyA pointer used to received the current gaze cast policy
Returns
#Fove_ErrorCode_None if the gaze cast policy was properly returned
#Fove_ErrorCode_API_NullInPointer if the given pointer was null
Here is the caller graph for this function:

◆ fove_Headset_getGazedObjectId()

Fove_ErrorCode fove_Headset_getGazedObjectId ( Fove_Headset ,
int *const  outObjectId 
)

Get the id of the object gazed by the user.

In order to be detected an object first need to be registered using the fove_Headset_registerGazableObject function. If the user is currently not looking at any specific object the fove_ObjectIdInvalid value is returned. To use this function, you need to register the Fove_ClientCapabilities_GazedObjectDetection first.

Parameters
outObjectIdA pointer to the output id identifying the object the user is currently looking at
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outObjectId is nullptr
See also
fove_Headset_updateGazableObject
fove_Headset_removeGazableObject
Here is the caller graph for this function:

◆ fove_Headset_getGazeScreenPosition()

Fove_ErrorCode fove_Headset_getGazeScreenPosition ( Fove_Headset ,
Fove_Eye  eye,
Fove_Vec2 outPos 
)

Writes out the user's 2D gaze position on the screens seen through the HMD's lenses.

The use of lenses and distortion correction creates a screen in front of each eye. This function returns 2D vectors representing where on each eye's screen the user is looking. The vectors are normalized in the range [-1, 1] along both X and Y axes such that the following points are true:

Center: (0, 0) Bottom-Left: (-1, -1) Top-Right: (1, 1)

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outPosA pointer to the eye gaze point in the HMD's virtual screen space
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outPos is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getGazeVector()

Fove_ErrorCode fove_Headset_getGazeVector ( Fove_Headset ,
Fove_Eye  eye,
Fove_Vec3 outVector 
)

Writes out the gaze vector of an individual eye.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outVectorA pointer to the eye gaze vector to write to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outVector is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getHardwareInfo()

Fove_ErrorCode fove_Headset_getHardwareInfo ( Fove_Headset ,
Fove_HeadsetHardwareInfo outHardwareInfo 
)

Writes out the hardware information.

Allows you to get serial number, manufacturer, and model name of the headset.

Here is the caller graph for this function:

◆ fove_Headset_getIrisRadius()

Fove_ErrorCode fove_Headset_getIrisRadius ( Fove_Headset ,
Fove_Eye  eye,
float *  outRadius 
)

Returns the user iris radius, in meters.

Fove_ClientCapabilities_IrisRadius should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outRadiusA pointer to the output variable to write the user iris radius to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outRadius is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getPose()

Fove_ErrorCode fove_Headset_getPose ( Fove_Headset ,
Fove_Pose outPose 
)

Writes out the pose of the head-mounted display.

Parameters
outPoseA pointer to the variable to be written
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outPose is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getPositionImage()

Fove_ErrorCode fove_Headset_getPositionImage ( Fove_Headset ,
Fove_BitmapImage outImage 
)

Returns the position camera image.

The position image is synchronized with and fetched at the same as the pose during the call to fove_Headset_fetchPoseData.

The image data buffer is invalidated upon the next call to this function. Fove_ClientCapabilities_PositionImage should be registered to use this function.

Parameters
outImagethe raw image data buffer to write the position image data to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreadable if the data couldn't be read properly from memory #Fove_ErrorCode_API_NullInPointer if outImage is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getProfileDataPath()

Fove_ErrorCode fove_Headset_getProfileDataPath ( Fove_Headset ,
const char *  profileName,
void(*)(const char *callbackProfileName, void *callbackData)  callback,
void *  callbackData 
)

Gets the data folder for a given profile.

Allows you to retrieve a filesytem directory where third party apps can write data associated with this profile. This directory will be created before return.

Since multiple applications may write stuff to a profile, please prefix any files you create with something unique to your application.

There are no special protections on profile data, and it may be accessible to any other app on the system. Do not write sensitive data here.

This is intended for simple uses. For advanced uses that have security concerns, or want to sync to a server, etc, third party applications are encouraged to use their own separate data store keyed by profile name. They will need to test for profile name changes and deletions manually in that case.

Invoking any other function on this headset from the callback will yield undefined behavior.

callbackProfileName is a non-null, null-terminated UTF-8 string with the path.

Parameters
callbackA function pointer to a function that will be called once if successful. Not invoked in the event of error
callbackDataAn arbitrary pointer passed to the callback
profileNameA null-terminated UTF-8 string with the name of the profile to be queried, or an empty string if no profile is set
Returns
#Fove_ErrorCode_None if the profile was successfully deleted
#Fove_ErrorCode_Profile_DoesntExist if there is no such profile
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NullInPointer if profileName or callback is null
See also
fove_Headset_createProfile
fove_Headset_renameProfile
fove_Headset_deleteProfile
fove_Headset_listProfiles
fove_Headset_setCurrentProfile
fove_Headset_getCurrentProfile
Here is the caller graph for this function:

◆ fove_Headset_getProjectionMatricesLH()

Fove_ErrorCode fove_Headset_getProjectionMatricesLH ( Fove_Headset ,
float  zNear,
float  zFar,
Fove_Matrix44 outLeftMat,
Fove_Matrix44 outRightMat 
)

Writes out the values of passed-in left-handed 4x4 projection matrices.

Writes 4x4 projection matrices for both eyes using near and far planes in a left-handed coordinate system. Either outLeftMat or outRightMat may be nullptr to only write the other matrix, however setting both to nullptr is considered invalid and will return Fove_ErrorCode::API_NullOutPointersOnly.

Parameters
zNearThe near plane in float, Range: from 0 to zFar
zFarThe far plane in float, Range: from zNear to infinity
outLeftMatA pointer to the matrix you want written
outRightMatA pointer to the matrix you want written
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if both outLeftMat and outRightMat are nullptr
Here is the caller graph for this function:

◆ fove_Headset_getProjectionMatricesRH()

Fove_ErrorCode fove_Headset_getProjectionMatricesRH ( Fove_Headset ,
float  zNear,
float  zFar,
Fove_Matrix44 outLeftMat,
Fove_Matrix44 outRightMat 
)

Writes out the values of passed-in right-handed 4x4 projection matrices.

Writes 4x4 projection matrices for both eyes using near and far planes in a right-handed coordinate system. Either outLeftMat or outRightMat may be nullptr to only write the other matrix, however setting both to nullptr is considered invalid and will return Fove_ErrorCode::API_NullOutPointersOnly.

Parameters
zNearThe near plane in float, Range: from 0 to zFar
zFarThe far plane in float, Range: from zNear to infinity
outLeftMatA pointer to the matrix you want written
outRightMatA pointer to the matrix you want written
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if both outLeftMat and outRightMat are nullptr
Here is the caller graph for this function:

◆ fove_Headset_getPupilRadius()

Fove_ErrorCode fove_Headset_getPupilRadius ( Fove_Headset ,
Fove_Eye  eye,
float *  outRadius 
)

Returns the user pupils radius, in meters.

Fove_ClientCapabilities_PupilRadius should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outRadiusA pointer to the output variable to write the user pupil radius to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if both outRadius is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getPupilShape()

Fove_ErrorCode fove_Headset_getPupilShape ( Fove_Headset ,
Fove_Eye  eye,
Fove_PupilShape outShape 
)

Returns the pupil shape of the specified user eye in the Eyes camera image.

Fove_ClientCapabilities_PupilShape should be registered to use this function.

Parameters
eyeSpecify which eye to get the value for
outShapeA pointer to the PupilShape struct to write pupil shape to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outShape is nullptr
#Fove_ErrorCode_License_FeatureAccessDenied if the current license is not sufficient for this feature
Here is the caller graph for this function:

◆ fove_Headset_getRawProjectionValues()

Fove_ErrorCode fove_Headset_getRawProjectionValues ( Fove_Headset ,
Fove_ProjectionParams outLeft,
Fove_ProjectionParams outRight 
)

Writes out values for the view frustum of the specified eye at 1 unit away.

Writes out values for the view frustum of the specified eye at 1 unit away. Please multiply them by zNear to convert to your correct frustum near-plane. Either outLeft or outRight may be nullptr to only write the other struct, however setting both to nullptr is considered and error and the function will return Fove_ErrorCode::API_NullOutPointersOnly.

Parameters
outLeftA pointer to the struct describing the left camera projection parameters
outRightA pointer to the struct describing the right camera projection parameters
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if both outLeft and outRight are nullptr
Here is the caller graph for this function:

◆ fove_Headset_getRenderIOD()

Fove_ErrorCode fove_Headset_getRenderIOD ( Fove_Headset ,
float *  outIOD 
)

Interocular distance to use for rendering in meters.

This may or may not reflect the actual IOD of the user (see getUserIOD), but is the value used by the rendering system for the distance to split the left/right cameras for stereoscopic rendering. We recommend calling this each frame when doing stereoscopic rendering.

Parameters
outIODA pointer to the render IOD variable to write to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outIOD is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getSoftwareVersions()

Fove_ErrorCode fove_Headset_getSoftwareVersions ( Fove_Headset ,
Fove_Versions outSoftwareVersions 
)

Writes out the current software versions.

Allows you to get detailed information about the client and runtime versions. Instead of comparing software versions directly, you should simply call CheckSoftwareVersions to ensure that the client and runtime are compatible.

Here is the caller graph for this function:

◆ fove_Headset_getUserIOD()

Fove_ErrorCode fove_Headset_getUserIOD ( Fove_Headset ,
float *  outIOD 
)

Returns the user IOD (Inter Occular Distance), in meters.

Fove_ClientCapabilities_UserIOD should be registered to use this function.

Parameters
outIODA pointer to the output variable to write the user IOD to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outIOD is nullptr
Here is the caller graph for this function:

◆ fove_Headset_getUserIPD()

Fove_ErrorCode fove_Headset_getUserIPD ( Fove_Headset ,
float *  outIPD 
)

Returns the user IPD (Inter Pupillary Distance), in meters.

Fove_ClientCapabilities_UserIPD should be registered to use this function.

Parameters
outIPDA pointer to the output variable to write the user IPD to.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outIPD is nullptr
Here is the caller graph for this function:

◆ fove_Headset_hasAccessToFeature()

Fove_ErrorCode fove_Headset_hasAccessToFeature ( Fove_Headset ,
const char *  inFeatureName,
bool *  outHasAccess 
)

Returns whether the Headset has access to the given feature.

If the provided feature name doesn't exist, then false and #Fove_ErrorCode_None are returned.

Parameters
inFeatureNameA null-terminated UTF-8 string with the name of the feature to query
outHasAccessOutput variable set to true if the headset can access the given feature
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NullInPointer if inFeatureName is null
#Fove_ErrorCode_API_NullOutPointersOnly if outHasAccess is null
Here is the caller graph for this function:

◆ fove_Headset_hasHmdAdjustmentGuiTimeout()

Fove_ErrorCode fove_Headset_hasHmdAdjustmentGuiTimeout ( Fove_Headset ,
bool *  outTimeout 
)

Writes out whether the GUI that asks the user to adjust their headset was hidden by timeout.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
outTimeoutA pointer to the output variable to write the timeout status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outTimeout is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isEyeTrackingCalibrated()

Fove_ErrorCode fove_Headset_isEyeTrackingCalibrated ( Fove_Headset ,
bool *  outEyeTrackingCalibrated 
)

Writes out whether eye tracking has been calibrated.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
outEyeTrackingCalibratedA pointer to the output variable to write the eye tracking calibrated status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outEyeTrackingCalibrated is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isEyeTrackingCalibratedForGlasses()

Fove_ErrorCode fove_Headset_isEyeTrackingCalibratedForGlasses ( Fove_Headset ,
bool *  outGlasses 
)

Writes out whether the eye tracking system is currently calibrated for glasses.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

This basically indicates if the user was wearing glasses during the calibration or not. This function returns 'Data_Uncalibrated' if the eye tracking system has not been calibrated yet

Parameters
outGlassesA pointer to the variable to be written
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Uncalibrated if the eye tracking system is currently uncalibrated
#Fove_ErrorCode_API_NullInPointer if outGlasses is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isEyeTrackingCalibrating()

Fove_ErrorCode fove_Headset_isEyeTrackingCalibrating ( Fove_Headset ,
bool *  outEyeTrackingCalibrating 
)

Writes out whether eye tracking is in the process of performing a calibration.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
outEyeTrackingCalibratingA pointer to the output variable to write the eye tracking calibrating status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outEyeTrackingCalibrating is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isEyeTrackingEnabled()

Fove_ErrorCode fove_Headset_isEyeTrackingEnabled ( Fove_Headset ,
bool *  outEyeTrackingEnabled 
)

Writes out whether the eye tracking hardware has started.

Parameters
outEyeTrackingEnabledA pointer to the output variable to write the eye tracking status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outEyeTrackingEnabled is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isEyeTrackingReady()

Fove_ErrorCode fove_Headset_isEyeTrackingReady ( Fove_Headset ,
bool *  outEyeTrackingReady 
)

Writes out whether eye tracking is actively tracking eyes.

In other words, it returns true only when the hardware is ready and eye tracking is calibrated.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
outEyeTrackingReadyA pointer to the output variable to write the eye tracking ready status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outEyeTrackingReady is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isHardwareConnected()

Fove_ErrorCode fove_Headset_isHardwareConnected ( Fove_Headset ,
bool *  outHardwareConnected 
)

Writes out whether an HMD is connected or not.

Parameters
outHardwareConnectedA pointer to the value to be written
Returns
Any error detected that might make the out data unreliable
See also
fove_createHeadset
Here is the caller graph for this function:

◆ fove_Headset_isHardwareReady()

Fove_ErrorCode fove_Headset_isHardwareReady ( Fove_Headset ,
bool *  outIsReady 
)

Writes out whether the hardware for the requested capabilities has started.

Returns
Any error detected that might make the out data unreliable
Here is the caller graph for this function:

◆ fove_Headset_isHmdAdjustmentGuiVisible()

Fove_ErrorCode fove_Headset_isHmdAdjustmentGuiVisible ( Fove_Headset ,
bool *  outHmdAdjustmentGuiVisible 
)

Writes out whether or not the GUI that asks the user to adjust their headset is being displayed.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
outHmdAdjustmentGuiVisibleA pointer to the output variable to write the GUI visibility status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outHmdAdjustmentGuiVisible is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isMotionReady()

Fove_ErrorCode fove_Headset_isMotionReady ( Fove_Headset ,
bool *  outMotionReady 
)

Writes out whether motion tracking hardware has started.

Parameters
outMotionReadyA pointer to the variable to be written
Returns
Any error detected while fetching and writing the data
Here is the caller graph for this function:

◆ fove_Headset_isPositionReady()

Fove_ErrorCode fove_Headset_isPositionReady ( Fove_Headset ,
bool *  outPositionReady 
)

Writes out whether position tracking hardware has started and returns whether it was successful.

Fove_ClientCapabilities_PositionTracking should be registered to use this function.

Parameters
outPositionReadyA pointer to the variable to be written
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if no valid data has been returned by the service yet
#Fove_ErrorCode_API_NullInPointer if outPositionReady is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isUserPresent()

Fove_ErrorCode fove_Headset_isUserPresent ( Fove_Headset ,
bool *  outUserPresent 
)

Writes out whether the user is wearing the headset or not.

When user is not present Eye tracking values shouldn't be used, as invalid.

Fove_ClientCapabilities_UserPresence should be registered to use this function.

Parameters
outUserPresentA pointer to the output variable to write the user presence status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outUserPresent is nullptr
Here is the caller graph for this function:

◆ fove_Headset_isUserShiftingAttention()

Fove_ErrorCode fove_Headset_isUserShiftingAttention ( Fove_Headset ,
bool *  outIsShiftingAttention 
)

Writes out whether the user is shifting its attention between objects or looking at something specific (fixation or pursuit).

This can be used to ignore eye data during large eye motions when the user is not looking at anything specific.

Fove_ClientCapabilities_UserAttentionShift should be registered to use this function.

Parameters
outIsShiftingAttentionA pointer to a output variable to write the user attention shift status to
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Data_NoUpdate if the capability is registered but no valid data has been returned by the service yet
#Fove_ErrorCode_Data_Unreliable if the returned data is too unreliable to be used
#Fove_ErrorCode_Data_LowAccuracy if the returned data is of low accuracy
#Fove_ErrorCode_API_NullInPointer if outIsShiftingAttention is nullptr
Here is the caller graph for this function:

◆ fove_Headset_listProfiles()

Fove_ErrorCode fove_Headset_listProfiles ( Fove_Headset ,
void(*)(const char *callbackProfileName, void *callbackData)  callback,
void *  callbackData 
)

Lists all existing profiles.

Invoking any other function on this headset from the callback will yield undefined behavior.

callbackProfileName is a non-null, null-terminated UTF-8 string containing the name of a profile.

Parameters
callbackA function pointer to a function that will be called once for each profile, in no particular order
callbackDataAn arbitrary pointer passed to the callback
Returns
#Fove_ErrorCode_None if the profile names were successfully listed
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NullInPointer if callback is null
See also
fove_Headset_createProfile
fove_Headset_renameProfile
fove_Headset_deleteProfile
fove_Headset_setCurrentProfile
fove_Headset_getCurrentProfile
fove_Headset_getProfileDataPath
Here is the caller graph for this function:

◆ fove_Headset_registerCameraObject()

Fove_ErrorCode fove_Headset_registerCameraObject ( Fove_Headset ,
const Fove_CameraObject camera 
)

Registers an camera in the 3D world.

Registering 3D world objects and camera allows FOVE software to identify which objects are being gazed at. We recommend that clients opt-in to this functionality rather than doing it themselves, as our algorithm may improve over time. Clients of course may do their own detection if they have special needs, such as performance needs, or just want to use their own algorithm.

At least 1 camera needs to be registered for automatic object gaze recognition to work. Use the object group mask of the camera to specify which objects the camera is capturing. The camera view pose determine the gaze raycast direction and position. The camera view pose should include any and all offsets from position tracking. No transforms from the headset are added in automatically.

Connection to the service is not required for object registration, thus you can register your world objects at will and not worry about connection or reconnection status.

Parameters
cameraA description of the camera. Data is copied and no reference is kept to this memory after return.
Returns
#Fove_ErrorCode_None if the camera is successfully added or updated
#Fove_ErrorCode_API_NullInPointer if either parameter is null
#Fove_ErrorCode_API_InvalidArgument if the object is invalid in any way (such as an invalid object id)
#Fove_ErrorCode_Object_AlreadyRegistered if an object with same id is already registered
See also
fove_Headset_updateCameraObject
fove_Headset_removeCameraObject
Here is the caller graph for this function:

◆ fove_Headset_registerCapabilities()

Fove_ErrorCode fove_Headset_registerCapabilities ( Fove_Headset ,
Fove_ClientCapabilities  caps 
)

Registers a client capability, enabling the required hardware as needed.

Usually you provide the required capabilities at the creation of the headset But you can add and remove capabilities anytime while the object is alive.

Parameters
capsA set of capabilities to register. Registering an existing capability is a no-op
Returns
#Fove_ErrorCode_None if the capability has been properly registered
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_License_FeatureAccessDenied if your license doesn't offer access to this capability
Here is the caller graph for this function:

◆ fove_Headset_registerGazableObject()

Fove_ErrorCode fove_Headset_registerGazableObject ( Fove_Headset ,
const Fove_GazableObject object 
)

Registers an object in the 3D world.

Registering 3D world objects allows FOVE software to identify which objects are being gazed at. We recommend that clients opt-in to this functionality rather than doing it themselves, as our algorithm may improve over time. Clients of course may do their own detection if they have special needs, such as performance needs, or just want to use their own algorithm.

Use fove_Headset_registerCameraObject to set the pose of the corresponding camera in the 3D world.

Connection to the service is not required for object registration, thus you can register your world objects at will and not worry about connection or reconnection status.

Parameters
objectA description of the object in the 3D world. Data is copied and no reference is kept to this memory after return.
Returns
#Fove_ErrorCode_None if the object is successfully added or updated
#Fove_ErrorCode_API_NullInPointer if either parameter is null
#Fove_ErrorCode_API_InvalidArgument if the object is invalid in any way (such as an invalid object id)
#Fove_ErrorCode_Object_AlreadyRegistered if an object with same id is already registered
See also
fove_Headset_updateGazableObject
fove_Headset_removeGazableObject
Here is the caller graph for this function:

◆ fove_Headset_removeCameraObject()

Fove_ErrorCode fove_Headset_removeCameraObject ( Fove_Headset ,
int  cameraId 
)

Removes a previously registered camera from the scene.

Parameters
cameraIdId of the camera passed to fove_Headset_registerCameraObject()
Returns
#Fove_ErrorCode_None if the object was in the scene and is now removed
#Fove_ErrorCode_API_InvalidArgument is returned if the object was not already registered
See also
fove_Headset_registerCameraObject
fove_Headset_updateCameraObject
Here is the caller graph for this function:

◆ fove_Headset_removeGazableObject()

Fove_ErrorCode fove_Headset_removeGazableObject ( Fove_Headset ,
int  objectId 
)

Removes a previously registered 3D object from the scene.

Because of the asynchronous nature of the FOVE system, this object may still be referenced in future frames for a very short period of time.

Parameters
objectIdId of the object passed to fove_Headset_registerGazableObject()
Returns
#Fove_ErrorCode_None if the object was in the scene and is now removed
#Fove_ErrorCode_API_InvalidArgument if the object was not already registered
See also
fove_Headset_registerGazableObject
fove_Headset_updateGazableObject
Here is the caller graph for this function:

◆ fove_Headset_renameProfile()

Fove_ErrorCode fove_Headset_renameProfile ( Fove_Headset ,
const char *  oldName,
const char *  newName 
)

Renames an existing profile.

This function renames an existing profile. This works on the current profile as well.

Parameters
oldNameNull-terminated UTF-8 name of the profile to be renamed
newNameNull-terminated UTF-8 unique new name of the profile
Returns
#Fove_ErrorCode_None if the profile was successfully renamed
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Profile_DoesntExist if the requested profile at oldName doesn't exist
#Fove_ErrorCode_Profile_NotAvailable If the new named is already taken
#Fove_ErrorCode_API_InvalidArgument If the old name and new name are the same
#Fove_ErrorCode_API_NullInPointer if oldName or newName is null
See also
fove_Headset_createProfile
fove_Headset_deleteProfile
fove_Headset_listProfiles
fove_Headset_setCurrentProfile
fove_Headset_getCurrentProfile
fove_Headset_getProfileDataPath
Here is the caller graph for this function:

◆ fove_Headset_setCurrentProfile()

Fove_ErrorCode fove_Headset_setCurrentProfile ( Fove_Headset ,
const char *  profileName 
)

Sets the current profile.

When changing profile, the FOVE system will load up data, such as calibration data, if it is available. If loading a profile with no calibration data, whether or not the FOVE system keeps old data loaded into memory is undefined.

Please note that no-ops are OK but you should check for #Fove_ErrorCode_Profile_NotAvailable.

Parameters
profileNameName of the profile to make current, in UTF-8
Returns
#Fove_ErrorCode_None if the profile was successfully set as the current profile
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_Profile_DoesntExist if there is no such profile
#Fove_ErrorCode_Profile_NotAvailable if the requested profile is the current profile
#Fove_ErrorCode_API_NullInPointer if profileName is null
See also
fove_Headset_createProfile
fove_Headset_renameProfile
fove_Headset_deleteProfile
fove_Headset_listProfiles
fove_Headset_getCurrentProfile
fove_Headset_getProfileDataPath
Here is the caller graph for this function:

◆ fove_Headset_setGazeCastPolicy()

Fove_ErrorCode fove_Headset_setGazeCastPolicy ( Fove_Headset ,
Fove_GazeCastPolicy  policy 
)

Set the current gaze cast policy.

Parameters
policyThe new gaze cast policy
Returns
#Fove_ErrorCode_None if the gaze cast policy was properly updated
#Fove_ErrorCode_API_InvalidArgument if policy is not pointing to a valid Fove_GazeCastPolicy value
Here is the caller graph for this function:

◆ fove_Headset_startEyeTrackingCalibration()

Fove_ErrorCode fove_Headset_startEyeTrackingCalibration ( Fove_Headset ,
const Fove_CalibrationOptions options 
)

Starts eye tracking calibration.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Parameters
optionsThe calibration options to use, or null to use default options
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_License_FeatureAccessDenied if any of the enabled options require a license beyond what is active on this machine
Here is the caller graph for this function:

◆ fove_Headset_tareOrientationSensor()

Fove_ErrorCode fove_Headset_tareOrientationSensor ( Fove_Headset )

Tares the orientation of the headset.

Any or both of Fove_ClientCapabilities_OrientationTracking and Fove_ClientCapabilities_PositionTracking should be registered to use this function.

Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
Here is the caller graph for this function:

◆ fove_Headset_tarePositionSensors()

Fove_ErrorCode fove_Headset_tarePositionSensors ( Fove_Headset )

Tares the position of the headset.

Fove_ClientCapabilities_PositionTracking should be registered to use this function.

Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
Here is the caller graph for this function:

◆ fove_Headset_tickEyeTrackingCalibration()

Fove_ErrorCode fove_Headset_tickEyeTrackingCalibration ( Fove_Headset ,
float  deltaTime,
bool  isVisible,
Fove_CalibrationData outCalibrationData 
)

Tick the current calibration process and retrieve data information to render the current calibration state.

Parameters
deltaTimeThe time elapsed since the last rendered frame
isVisibleIndicate to the calibration system that something is being drawn to the screen. This allows the calibration renderer to take as much time as it wants to display success/failure messages and animate away before the calibration processes is marked as completed by the IsEyeTrackingCalibrating function.
outCalibrationDataThe calibration current state information

This function is how the client declares to the calibration system that is available to render calibration. The calibration system determines which of the available renderers has the highest priority, and returns to that render the information needed to render calibration via the outTarget parameter. Even while ticking this, you may get no result because either no calibration is running, or a calibration is running but some other higher priority renderer is doing the rendering.

Fove_ClientCapabilities_EyeTracking should be registered to use this function.

Note that it is perfectly fine not to call this function, in which case the Fove service will automatically render the calibration process for you.

Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_License_FeatureAccessDenied if a sufficient license is not registered on this machine
#Fove_ErrorCode_Calibration_OtherRendererPrioritized if another process has currently the priority for rendering calibration process
Here is the caller graph for this function:

◆ fove_Headset_unregisterCapabilities()

Fove_ErrorCode fove_Headset_unregisterCapabilities ( Fove_Headset ,
Fove_ClientCapabilities  caps 
)

Unregisters a client capability previously registered.

Parameters
capsA set of capabilities to unregister. Unregistering an not-existing capability is a no-op
Returns
#Fove_ErrorCode_None if the capability has been properly unregistered
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
Here is the caller graph for this function:

◆ fove_Headset_updateCameraObject()

Fove_ErrorCode fove_Headset_updateCameraObject ( Fove_Headset ,
int  cameraId,
const Fove_ObjectPose pose 
)

Update the pose of a registered camera.

Parameters
cameraIdId of the camera passed to fove_Headset_registerCameraObject()
posethe updated pose of the camera
Returns
#Fove_ErrorCode_None if the object was in the scene and is now removed
#Fove_ErrorCode_API_InvalidArgument if the object was not already registered
See also
fove_Headset_registerCameraObject
fove_Headset_removeCameraObject
Here is the caller graph for this function:

◆ fove_Headset_updateGazableObject()

Fove_ErrorCode fove_Headset_updateGazableObject ( Fove_Headset ,
int  objectId,
const Fove_ObjectPose pose 
)

Update a previously registered 3D object pose.

Parameters
objectIdId of the object passed to fove_Headset_registerGazableObject()
posethe updated pose of the object
Returns
#Fove_ErrorCode_None if the object was in the scene and is now updated
#Fove_ErrorCode_API_NullInPointer if either parameter is null
#Fove_ErrorCode_API_InvalidArgument if the object was not already registered
See also
fove_Headset_registerCameraObject
fove_Headset_removeGazableObject
Here is the caller graph for this function:

◆ fove_Headset_waitAndFetchNextEyeTrackingData()

Fove_ErrorCode fove_Headset_waitAndFetchNextEyeTrackingData ( Fove_Headset ,
Fove_FrameTimestamp outTimestamp 
)

Waits for next eye camera frame to be processed and fetch the updated eye tracking data.

Allows you to sync your eye tracking loop to the actual eye-camera loop. On each loop, you would first call this blocking function to wait for a new frame and then read the eye tracking info associated with the frame.

Eye tracking should be enabled by registering the Fove_ClientCapabilities_EyeTracking before calling this function.

Parameters
outTimestampA pointer to the timestamp of fetched data. If null, the timestamp is not written.
Returns
#Fove_ErrorCode_None if the call succeeded
#Fove_ErrorCode_Connect_NotConnected if not connected to the service
#Fove_ErrorCode_API_NotRegistered if the required capability has not been registered prior to this call
Here is the caller graph for this function:

◆ fove_logText()

Fove_ErrorCode fove_logText ( Fove_LogLevel  level,
const char *  utf8Text 
)

Writes some text to the FOVE log.

Parameters
levelWhat severity level the log will use
utf8TextNull-terminated text string in UTF-8
Returns
An error code, usually discarded since nothing critical should depend on logging
Here is the caller graph for this function: