Unigine::VRMixedReality Class

Разделы:

Header:

#include <UnigineVRMixedReality.h>

The class is used for mixed reality management in Varjo devices.The class is used for mixed reality management in Varjo devices.

Методы:

Имя	Описание View: Сортировать по:
setChromaKeyEnabled	Методы, получающие и устанавливающие value indicating if chroma keying is enabled.
isChromaKeyEnabled
setDepthTestEnabled	Методы, получающие и устанавливающие value indicating if depth buffer submission is enabled.
isDepthTestEnabled
setAlphaBlendEnabled	Методы, получающие и устанавливающие value indicating if alpha blending is enabled.
isAlphaBlendEnabled
setVideoEnabled	Методы, получающие и устанавливающие value indicating if the video signal from the real-world view from the front-facing HMD-mounted cameras is enabled.
isVideoEnabled
setDepthTestRangeEnabled	Методы, получающие и устанавливающие value indicating if the depth test range usage is enabled.
isDepthTestRangeEnabled
setDepthTestRange	Методы, получающие и устанавливающие depth test range as a two-component vector (the near and far planes).
getDepthTestRange
getChromaKeyConfigNum	Возвращает number of chroma key config indices supported.
setBlendMaskingMode	Методы, получающие и устанавливающие mode of the Blend Control Mask that can be used to extend or restrict the chroma key mask or to control the depth testing against the estimated video depth.
getBlendMaskingMode
setBlendMaskingDebugEnabled	Методы, получающие и устанавливающие value indicating if blend masking debug visualization is enabled.
isBlendMaskingDebugEnabled
isBlendMaskingUsed	Возвращает value indicating if the Blend Control Mask is used to extend or restrict the chroma key mask or to control the depth testing against the estimated video depth.
getCurrentBlendMaskColorBuffer	Возвращает image representing the current color buffer of the Blend Control Mask.
setCameraExposureTimeRaw	Методы, получающие и устанавливающие exposure time value for the camera.
getCameraExposureTimeRaw
setCameraExposureTime	Методы, получающие и устанавливающие exposure time value that is valid for the connected device.
getCameraExposureTime
setCameraExposureTimeMode	Методы, получающие и устанавливающие exposure adjustment mode for the camera.
getCameraExposureTimeMode
setCameraWhiteBalanceRaw	Методы, получающие и устанавливающие white balance correction value that is valid for the connected device.
getCameraWhiteBalanceRaw
setCameraWhiteBalance	Методы, получающие и устанавливающие white balance correction value that is valid for the connected device.
getCameraWhiteBalance
setCameraWhiteBalanceMode	Методы, получающие и устанавливающие white balance adjustment mode for the camera.
getCameraWhiteBalanceMode
setCameraISORaw	Методы, получающие и устанавливающие ISO value that is valid for the connected device.
getCameraISORaw
setCameraISO	Методы, получающие и устанавливающие ISO value for the camera.
getCameraISO
setCameraISOMode	Методы, получающие и устанавливающие ISO adjustment mode for the camera.
getCameraISOMode
setCameraFlickerCompensationRaw	Методы, получающие и устанавливающие flicker compensation value for the camera.
getCameraFlickerCompensationRaw
setCameraFlickerCompensation	Методы, получающие и устанавливающие flicker compensation value for the camera.
getCameraFlickerCompensation
getCameraMinSharpness	Возвращает minimum possible value for the camera sharpness.
getCameraMaxSharpness	Возвращает maximum possible value for the camera sharpness.
setCameraSharpness	Методы, получающие и устанавливающие sharpness filter power value for the camera.
getCameraSharpness
setViewOffset	Методы, получающие и устанавливающие .
getViewOffset	Методы, получающие и устанавливающие .
setMarkerTrackingEnabled	Методы, получающие и устанавливающие value indicating if marker tracking is enabled.
isMarkerTrackingEnabled
getNumMarkerObjectVisible	Возвращает number of visible marker objects.
setCubemapMode	Методы, получающие и устанавливающие mode defining the way the AR texture is set for the environment.
getCubemapMode
setCubemapGGXQuality	Методы, получающие и устанавливающие quality of the generated GGX mips for the AR cubemap.
getCubemapGGXQuality
setOverrideColorCorrectionMode	Методы, получающие и устанавливающие color correction mode for the stream from the AR cameras.
getOverrideColorCorrectionMode
getEventCameraPropertyUpdateSharpness	The Event triggered when the sharpness value is changed in Varjo Base.
getEventCameraPropertyUpdateFlickerCompensation	The Event triggered when the flicker compensation value of the camera is changed in Varjo Base.
getEventCameraPropertyUpdateISO	The Event triggered when the camera ISO value and/or the ISO adjustment mode are changed in Varjo Base.
getEventCameraPropertyUpdateWhiteBalance	The Event triggered when the white balance correction value of the camera and/or the white balance adjustment mode are changed in Varjo Base.
getEventCameraPropertyUpdateExposureTime	The Event triggered when the exposure time value of the camera and/or the exposure adjustment mode are changed in Varjo Base.
getEventChromakeyUpdate	The Event triggered when the chroma keying settings are changed in Varjo Base.
getEventDeviceDisconnected	The Event triggered when the Varjo device is disconnected.
getEventDeviceConnected	The Event triggered when the Varjo device is connected.
applySettings	Updates the mixed reality settings to the current settings.
isChromaKeyConfigEnabled	Returns the current value indicating if the chroma key configuration with the specified index is enabled.
setChromaKeyConfigEnabled	Sets a new value indicating if the chroma key configuration with the specified index is enabled.
getChromaKeyConfigFalloff	Returns the current tolerance falloff values for HSV components of the chroma key target color.
setChromaKeyConfigFalloff	Sets new tolerance falloff values for HSV components of the chroma key target color.
getChromaKeyConfigTargetColor	Returns the current chroma key target color.
setChromaKeyConfigTargetColor	Sets a new chroma key target color.
getChromaKeyConfigTolerance	Returns the current tolerance values for HSV components of the chroma key target color.
setChromaKeyConfigTolerance	Sets new tolerance values for HSV components of the chroma key target color.
applyChromaKeySettings	Updates the settings of the chroma key configuration with the specified index to the current settings.
getCameraSupportedRawExposureTimes	Returns a vector containing the exposure time values that are set as valid for the connected device.
getCameraSupportedRawWhiteBalances	Returns a vector containing the white balance values that are set as valid for the connected device.
getCameraSupportedRawISO	Returns a vector containing the ISO values that are set as valid for the connected device.
getCameraSupportedRawFlickerCompensations	Returns a vector containing the flicker compensation values that are set as valid for the connected device.
getMarkerObject	Returns the marker object with the specified index.
getMarkerObjectByID	Returns the marker object with the specified ID.

VRMixedReality Class

Enums

BLEND_MASKING_MODE#

Имя	Описание
BLEND_MASKING_MODE_BEGIN = 0	The first element to be used for iteration.The first element to be used for iteration.
BLEND_MASKING_MODE_DISABLED = 0	Masking mode is disabled.Masking mode is disabled.
BLEND_MASKING_MODE_RESTRICT_VIDEO_TO_MASK = 1	Show the video pass-through image (VST) in the mask. Can be used with chroma key.Show the video pass-through image (VST) in the mask. Can be used with chroma key.
BLEND_MASKING_MODE_RESTRICT_VR_TO_MASK = 2	Show VR in the mask. Can be used with chroma key.Show VR in the mask. Can be used with chroma key.
BLEND_MASKING_MODE_RESTRICT_VR_TO_CHROMAKEY_REDUCED_BY_MASK = 3	Show VR in the mask and chroma elsewhere. Requires chroma key.Show VR in the mask and chroma elsewhere. Requires chroma key.
BLEND_MASKING_MODE_END = 3	The last element to be used for iteration.The last element to be used for iteration.

CAMERA_PROPERTY_MODE#

Имя	Описание
CAMERA_PROPERTY_MODE_DISABLED = 0	The camera property adjustment is disabled.The camera property adjustment is disabled.
CAMERA_PROPERTY_MODE_AUTO = 1	Automatic property adjustment for the camera.Automatic property adjustment for the camera.
CAMERA_PROPERTY_MODE_MANUAL = 2	Manual property adjustment for the camera. In this mode you can set the desired property value (exposure time correction, white balance correction, ISO) manually via the corresponding methods.Manual property adjustment for the camera. In this mode you can set the desired property value (exposure time correction, white balance correction, ISO) manually via the corresponding methods.

CAMERA_EXPOSURE_TIME#

Имя	Описание
CAMERA_EXPOSURE_TIME_UNKNWON = 0	The camera exposure time is not specified.The camera exposure time is not specified.
CAMERA_EXPOSURE_TIME_BEGIN = 1	The first element to be used for iteration.The first element to be used for iteration.
CAMERA_EXPOSURE_TIME_VALUE_91_MS = 1	The camera exposure time value equal to 91 K.The camera exposure time value equal to 91 K.
CAMERA_EXPOSURE_TIME_VALUE_125_MS = 2	The camera exposure time value equal to 125 K.The camera exposure time value equal to 125 K.
CAMERA_EXPOSURE_TIME_VALUE_250_MS = 3	The camera exposure time value equal to 250 K.The camera exposure time value equal to 250 K.
CAMERA_EXPOSURE_TIME_VALUE_500_MS = 4	The camera exposure time value equal to 500 K.The camera exposure time value equal to 500 K.
CAMERA_EXPOSURE_TIME_VALUE_1000_MS = 5	The camera exposure time value equal to 1000 K.The camera exposure time value equal to 1000 K.
CAMERA_EXPOSURE_TIME_VALUE_2000_MS = 6	The camera exposure time value equal to 2000 K.The camera exposure time value equal to 2000 K.
CAMERA_EXPOSURE_TIME_VALUE_4000_MS = 7	The camera exposure time value equal to 4000 K.The camera exposure time value equal to 4000 K.
CAMERA_EXPOSURE_TIME_VALUE_8000_MS = 8	The camera exposure time value equal to 8000 K.The camera exposure time value equal to 8000 K.
CAMERA_EXPOSURE_TIME_END = 8	The last element to be used for iteration.The last element to be used for iteration.

CAMERA_WHITE_BALANCE#

Имя	Описание
CAMERA_WHITE_BALANCE_UNKNWON = 0	The camera white balance value is not specified.The camera white balance value is not specified.
CAMERA_WHITE_BALANCE_BEGIN = 1	The first element to be used for iteration.The first element to be used for iteration.
CAMERA_WHITE_BALANCE_VALUE_2000_K = 1	The camera white balance value equal to 2000 K.The camera white balance value equal to 2000 K.
CAMERA_WHITE_BALANCE_VALUE_3000_K = 2	The camera white balance value equal to 3000 K.The camera white balance value equal to 3000 K.
CAMERA_WHITE_BALANCE_VALUE_3500_K = 3	The camera white balance value equal to 3500 K.The camera white balance value equal to 3500 K.
CAMERA_WHITE_BALANCE_VALUE_4200_K = 4	The camera white balance value equal to 4200 K.The camera white balance value equal to 4200 K.
CAMERA_WHITE_BALANCE_VALUE_5000_K = 5	The camera white balance value equal to 5000 K.The camera white balance value equal to 5000 K.
CAMERA_WHITE_BALANCE_VALUE_5400_K = 6	The camera white balance value equal to 5400 K.The camera white balance value equal to 5400 K.
CAMERA_WHITE_BALANCE_VALUE_6500_K = 7	The camera white balance value equal to 6500 K.The camera white balance value equal to 6500 K.
CAMERA_WHITE_BALANCE_VALUE_8000_K = 8	The camera white balance value equal to 8000 K.The camera white balance value equal to 8000 K.
CAMERA_WHITE_BALANCE_VALUE_12000_K = 9	The camera white balance value equal to 12000 K.The camera white balance value equal to 12000 K.
CAMERA_WHITE_BALANCE_END = 9	The last element to be used for iteration.The last element to be used for iteration.

CAMERA_ISO#

Имя	Описание
CAMERA_ISO_UNKNWON = 0	The camera ISO value is not specified.The camera ISO value is not specified.
CAMERA_ISO_BEGIN = 1	The first element to be used for iteration.The first element to be used for iteration.
CAMERA_ISO_GAIN_100 = 1	The camera ISO value equal to 100.The camera ISO value equal to 100.
CAMERA_ISO_GAIN_200 = 2	The camera ISO value equal to 200.The camera ISO value equal to 200.
CAMERA_ISO_GAIN_400 = 3	The camera ISO value equal to 400.The camera ISO value equal to 400.
CAMERA_ISO_GAIN_800 = 4	The camera ISO value equal to 800.The camera ISO value equal to 800.
CAMERA_ISO_GAIN_1600 = 5	The camera ISO value equal to 1600.The camera ISO value equal to 1600.
CAMERA_ISO_GAIN_3200 = 6	The camera ISO value equal to 3200.The camera ISO value equal to 3200.
CAMERA_ISO_GAIN_6400 = 7	The camera ISO value equal to 6400.The camera ISO value equal to 6400.
CAMERA_ISO_END = 7	The last element to be used for iteration.The last element to be used for iteration.

CAMERA_FLICKER_COMPENSATION#

Имя	Описание
CAMERA_FLICKER_COMPENSATION_UNKNWON = 0	The camera flicker compensation value is not specified.The camera flicker compensation value is not specified.
CAMERA_FLICKER_COMPENSATION_BEGIN = 1	The first element to be used for iteration.The first element to be used for iteration.
CAMERA_FLICKER_COMPENSATION_FREQ_50_HZ = 1	The camera flicker compensation value equal to 50 Hz.The camera flicker compensation value equal to 50 Hz.
CAMERA_FLICKER_COMPENSATION_FREQ_60_HZ = 2	The camera flicker compensation value equal to 60 Hz.The camera flicker compensation value equal to 60 Hz.
CAMERA_FLICKER_COMPENSATION_END = 2	The last element to be used for iteration.The last element to be used for iteration.

CUBEMAP_MODE#

Имя	Описание
CUBEMAP_MODE_BEGIN = 0	The first element to be used for iteration.The first element to be used for iteration.
CUBEMAP_MODE_DISABLED = 0	The cubemap streaming from AR cameras is disabled.The cubemap streaming from AR cameras is disabled.
CUBEMAP_MODE_ENVIRONMENT_OVERLAP = 1	The environment texture substitutes the sky.The environment texture substitutes the sky.
CUBEMAP_MODE_ENVIRONMENT_PRESET_0 = 2	The first environment preset defines the way the AR texture is set for the environment.The first environment preset defines the way the AR texture is set for the environment.
CUBEMAP_MODE_ENVIRONMENT_PRESET_1 = 3	The second environment preset defines the way the AR texture is set for the environment.The second environment preset defines the way the AR texture is set for the environment.
CUBEMAP_MODE_ENVIRONMENT_PRESET_2 = 4	The third environment preset defines the way the AR texture is set for the environment.The third environment preset defines the way the AR texture is set for the environment.
CUBEMAP_MODE_END = 4	The last element to be used for iteration.The last element to be used for iteration.

OVERRIDE_COLOR_CORRECTION_MODE#

Имя	Описание
OVERRIDE_COLOR_CORRECTION_MODE_BEGIN = 0	The first element to be used for iteration.The first element to be used for iteration.
OVERRIDE_COLOR_CORRECTION_MODE_DISABLED = 0	The color correction is disabled.The color correction is disabled.
OVERRIDE_COLOR_CORRECTION_MODE_EXPOSURE = 1	Exposure correction for the stream from the AR cameras.Exposure correction for the stream from the AR cameras.
OVERRIDE_COLOR_CORRECTION_MODE_EXPOSURE_WHITE_BALANCE = 2	Exposure and white balance correction for the stream.Exposure and white balance correction for the stream.
OVERRIDE_COLOR_CORRECTION_MODE_END = 2	The last element to be used for iteration.The last element to be used for iteration.

Члены класса

void setChromaKeyEnabled ( bool enabled ) #

Console: vr_mixed_reality_chroma_key_enabled

Устанавливает value indicating if chroma keying is enabled. VST capturing from HMD cameras must be enabled.

Аргументы

bool enabled - Set true to enable chroma keying; false - to disable it. Значение по умолчанию false.

bool isChromaKeyEnabled() const#

Console: vr_mixed_reality_chroma_key_enabled

Возвращает value indicating if chroma keying is enabled. VST capturing from HMD cameras must be enabled.

Возвращаемое значение

true if chroma keying is enabled; otherwise false. Значение по умолчанию false.

void setDepthTestEnabled ( bool enabled ) #

Console: vr_mixed_reality_depth_test_enabled

Устанавливает value indicating if depth buffer submission is enabled. VST capturing from HMD cameras must be enabled.

Аргументы

bool enabled - Set true to enable depth testing; false - to disable it. Значение по умолчанию false.

bool isDepthTestEnabled() const#

Console: vr_mixed_reality_depth_test_enabled

Возвращает value indicating if depth buffer submission is enabled. VST capturing from HMD cameras must be enabled.

Возвращаемое значение

true if depth testing is enabled; otherwise false. Значение по умолчанию false.

void setAlphaBlendEnabled ( bool enabled ) #

Console: vr_mixed_reality_alpha_blend_enabled

Устанавливает value indicating if alpha blending is enabled. This option is used for blending VR and AR images using the alpha channel. VST capturing from HMD cameras must be enabled and the screen precision must be 1.

Аргументы

bool enabled - Set true to enable alpha blending; false - to disable it. Значение по умолчанию false.

bool isAlphaBlendEnabled() const#

Console: vr_mixed_reality_alpha_blend_enabled

Возвращает value indicating if alpha blending is enabled. This option is used for blending VR and AR images using the alpha channel. VST capturing from HMD cameras must be enabled and the screen precision must be 1.

Возвращаемое значение

true if alpha blending is enabled; otherwise false. Значение по умолчанию false.

void setVideoEnabled ( bool enabled ) #

Console: vr_mixed_reality_video_enabled

Устанавливает value indicating if the video signal from the real-world view from the front-facing HMD-mounted cameras is enabled. The real-world view is used for combining virtual and real-world elements to create an immersive experience in mixed reality.

Аргументы

bool enabled - Set true to enable the real-world view from the front-facing HMD-mounted cameras; false - to disable it. Значение по умолчанию false.

bool isVideoEnabled() const#

Console: vr_mixed_reality_video_enabled

Возвращает value indicating if the video signal from the real-world view from the front-facing HMD-mounted cameras is enabled. The real-world view is used for combining virtual and real-world elements to create an immersive experience in mixed reality.

Возвращаемое значение

true if the real-world view from the front-facing HMD-mounted cameras is enabled; otherwise false. Значение по умолчанию false.

void setDepthTestRangeEnabled ( bool enabled ) #

Console: vr_mixed_reality_depth_test_range_enabled

Устанавливает value indicating if the depth test range usage is enabled. Use the depth test range (Depth Test Near Z, Depth Test Far Z) to control the range for which the depth test is evaluated.

Аргументы

bool enabled - Set true to enable the depth test range; false - to disable it. Значение по умолчанию false.

bool isDepthTestRangeEnabled() const#

Console: vr_mixed_reality_depth_test_range_enabled

Возвращает value indicating if the depth test range usage is enabled. Use the depth test range (Depth Test Near Z, Depth Test Far Z) to control the range for which the depth test is evaluated.

Возвращаемое значение

true if the depth test range is enabled; otherwise false. Значение по умолчанию false.

void setDepthTestRange ( const Math::vec2& range ) #

Console: vr_mixed_reality_depth_test_range

Устанавливает depth test range as a two-component vector (the near and far planes). The depth test range usage must be enabled.

Аргументы

const Math::vec2& range - depth test range.
vec2(0.0f, 1.0f) - default value

Math::vec2 getDepthTestRange() const#

Console: vr_mixed_reality_depth_test_range

Возвращает depth test range as a two-component vector (the near and far planes). The depth test range usage must be enabled.

Возвращаемое значение

depth test range.
vec2(0.0f, 1.0f) - default value

getChromaKeyConfigNum() const#

Возвращает number of chroma key config indices supported. The maximum index will be count-1.

Возвращаемое значение

number of chroma key config indices.

void setBlendMaskingMode ( VRMixedReality::BLEND_MASKING_MODE mode ) #

Console: vr_mixed_reality_blend_masking_mode

Устанавливает mode of the Blend Control Mask that can be used to extend or restrict the chroma key mask or to control the depth testing against the estimated video depth.

Аргументы

VRMixedReality::BLEND_MASKING_MODE mode - masking mode. Одно из следующих значений:
- 0 - Disabled (masking mode is disabled). (по умолчанию)
- 1 - Restrict Video to Mask (show the video pass-through image (VST) in the mask; can be used with chroma key)
- 2 - Restrict VR to Mask (show VR in the mask; can be used with chroma key)
- 3 - Restrict VR to Chromakey reduced by Mask (show VR in the mask and chroma elsewhere; requires chroma key)

VRMixedReality::BLEND_MASKING_MODE getBlendMaskingMode() const#

Console: vr_mixed_reality_blend_masking_mode

Возвращает mode of the Blend Control Mask that can be used to extend or restrict the chroma key mask or to control the depth testing against the estimated video depth.

Возвращаемое значение

masking mode. Одно из следующих значений:

0 - Disabled (masking mode is disabled). (по умолчанию)
1 - Restrict Video to Mask (show the video pass-through image (VST) in the mask; can be used with chroma key)
2 - Restrict VR to Mask (show VR in the mask; can be used with chroma key)
3 - Restrict VR to Chromakey reduced by Mask (show VR in the mask and chroma elsewhere; requires chroma key)

void setBlendMaskingDebugEnabled ( bool enabled ) #

Console: vr_mixed_reality_blend_masking_debug_enabled

Устанавливает value indicating if blend masking debug visualization is enabled. The blend masking mode must be enabled.

Аргументы

bool enabled - Set true to enable blend masking debug visualization; false - to disable it. Значение по умолчанию false.

bool isBlendMaskingDebugEnabled() const#

Console: vr_mixed_reality_blend_masking_debug_enabled

Возвращает value indicating if blend masking debug visualization is enabled. The blend masking mode must be enabled.

Возвращаемое значение

true if blend masking debug visualization is enabled; otherwise false. Значение по умолчанию false.

bool isBlendMaskingUsed() const#

Возвращает value indicating if the Blend Control Mask is used to extend or restrict the chroma key mask or to control the depth testing against the estimated video depth.

Возвращаемое значение

true if the blend mask is used; otherwise false.

Ptr<Texture> getCurrentBlendMaskColorBuffer() const#

Возвращает image representing the current color buffer of the Blend Control Mask.

Возвращаемое значение

color buffer.

void setCameraExposureTimeRaw ( ) #

Устанавливает exposure time value for the camera.

Аргументы

raw - exposure time, in frames per second (e.g. 90.0 -> ~11ms).

getCameraExposureTimeRaw() const#

Возвращает exposure time value for the camera.

Возвращаемое значение

exposure time, in frames per second (e.g. 90.0 -> ~11ms).

void setCameraExposureTime ( VRMixedReality::CAMERA_EXPOSURE_TIME time ) #

Console: vr_mixed_reality_camera_exposure_time

Устанавливает exposure time value that is valid for the connected device.

Аргументы

VRMixedReality::CAMERA_EXPOSURE_TIME time - valid exposure time value for the connected device.

VRMixedReality::CAMERA_EXPOSURE_TIME getCameraExposureTime() const#

Console: vr_mixed_reality_camera_exposure_time

Возвращает exposure time value that is valid for the connected device.

Возвращаемое значение

valid exposure time value for the connected device.

void setCameraExposureTimeMode ( VRMixedReality::CAMERA_PROPERTY_MODE mode ) #

Console: vr_mixed_reality_camera_exposure_time_mode

Устанавливает exposure adjustment mode for the camera.

Аргументы

VRMixedReality::CAMERA_PROPERTY_MODE mode - exposure adjustment mode. Одно из следующих значений:
- 0 - exposure adjustment is disabled
- 1 - automatic exposure adjustment (по умолчанию)
- 2 - manual exposure adjustment

VRMixedReality::CAMERA_PROPERTY_MODE getCameraExposureTimeMode() const#

Console: vr_mixed_reality_camera_exposure_time_mode

Возвращает exposure adjustment mode for the camera.

Возвращаемое значение

exposure adjustment mode. Одно из следующих значений:

0 - exposure adjustment is disabled
1 - automatic exposure adjustment (по умолчанию)
2 - manual exposure adjustment

void setCameraWhiteBalanceRaw ( ) #

Устанавливает white balance correction value that is valid for the connected device.

Аргументы

raw - color temperature value.

getCameraWhiteBalanceRaw() const#

Возвращает white balance correction value that is valid for the connected device.

Возвращаемое значение

color temperature value.

void setCameraWhiteBalance ( VRMixedReality::CAMERA_WHITE_BALANCE balance ) #

Console: vr_mixed_reality_camera_white_balance

Устанавливает white balance correction value that is valid for the connected device.

Аргументы

VRMixedReality::CAMERA_WHITE_BALANCE balance - color temperature value.

VRMixedReality::CAMERA_WHITE_BALANCE getCameraWhiteBalance() const#

Console: vr_mixed_reality_camera_white_balance

Возвращает white balance correction value that is valid for the connected device.

Возвращаемое значение

color temperature value.

void setCameraWhiteBalanceMode ( VRMixedReality::CAMERA_PROPERTY_MODE mode ) #

Console: vr_mixed_reality_camera_white_balance_mode

Устанавливает white balance adjustment mode for the camera.

Аргументы

VRMixedReality::CAMERA_PROPERTY_MODE mode - white balance adjustment mode. Одно из следующих значений:
- 0 - white balance adjustment is disabled
- 1 - automatic white balance adjustment (по умолчанию)
- 2 - manual white balance adjustment

VRMixedReality::CAMERA_PROPERTY_MODE getCameraWhiteBalanceMode() const#

Console: vr_mixed_reality_camera_white_balance_mode

Возвращает white balance adjustment mode for the camera.

Возвращаемое значение

white balance adjustment mode. Одно из следующих значений:

0 - white balance adjustment is disabled
1 - automatic white balance adjustment (по умолчанию)
2 - manual white balance adjustment

void setCameraISORaw ( ) #

Устанавливает ISO value that is valid for the connected device.

Аргументы

isoraw - ISO value (e.g., "200" -> ISO200).

getCameraISORaw() const#

Возвращает ISO value that is valid for the connected device.

Возвращаемое значение

ISO value (e.g., "200" -> ISO200).

void setCameraISO ( VRMixedReality::CAMERA_ISO iso ) #

Console: vr_mixed_reality_camera_iso

Устанавливает ISO value for the camera.

Аргументы

VRMixedReality::CAMERA_ISO iso - ISO value.

VRMixedReality::CAMERA_ISO getCameraISO() const#

Console: vr_mixed_reality_camera_iso

Возвращает ISO value for the camera.

Возвращаемое значение

ISO value.

void setCameraISOMode ( VRMixedReality::CAMERA_PROPERTY_MODE isomode ) #

Console: vr_mixed_reality_camera_iso_mode

Устанавливает ISO adjustment mode for the camera.

Аргументы

VRMixedReality::CAMERA_PROPERTY_MODE isomode - ISO adjustment mode. Одно из следующих значений:
- 0 - ISO adjustment is disabled
- 1 - automatic ISO adjustment (по умолчанию)
- 2 - manual ISO adjustment

VRMixedReality::CAMERA_PROPERTY_MODE getCameraISOMode() const#

Console: vr_mixed_reality_camera_iso_mode

Возвращает ISO adjustment mode for the camera.

Возвращаемое значение

ISO adjustment mode. Одно из следующих значений:

0 - ISO adjustment is disabled
1 - automatic ISO adjustment (по умолчанию)
2 - manual ISO adjustment

void setCameraFlickerCompensationRaw ( ) #

Устанавливает flicker compensation value for the camera. This is useful when using the HMD indoors with mostly artificial light bulbs, which flicker at the frequency of 50Hz or 60Hz and can cause visual flicker artifacts on the video see through image. The correct setting depends on the underlying power grid's frequency. For example, in most parts of Africa/Asia/Australia/Europe the frequency is 50 Hz and in most parts of North and South America 60 Hz.

Аргументы

raw - flicker compensation, in Hz.

getCameraFlickerCompensationRaw() const#

Возвращает flicker compensation value for the camera. This is useful when using the HMD indoors with mostly artificial light bulbs, which flicker at the frequency of 50Hz or 60Hz and can cause visual flicker artifacts on the video see through image. The correct setting depends on the underlying power grid's frequency. For example, in most parts of Africa/Asia/Australia/Europe the frequency is 50 Hz and in most parts of North and South America 60 Hz.

Возвращаемое значение

flicker compensation, in Hz.

void setCameraFlickerCompensation ( VRMixedReality::CAMERA_FLICKER_COMPENSATION compensation ) #

Console: vr_mixed_reality_camera_flicker_compensation

Аргументы

VRMixedReality::CAMERA_FLICKER_COMPENSATION compensation - flicker compensation.

VRMixedReality::CAMERA_FLICKER_COMPENSATION getCameraFlickerCompensation() const#

Console: vr_mixed_reality_camera_flicker_compensation

Возвращаемое значение

flicker compensation.

getCameraMinSharpness() const#

Возвращает minimum possible value for the camera sharpness.

Возвращаемое значение

minimum possible value for the camera sharpness.

getCameraMaxSharpness() const#

Возвращает maximum possible value for the camera sharpness.

Возвращаемое значение

maximum possible value for the camera sharpness.

void setCameraSharpness ( ) #

Console: vr_mixed_reality_camera_sharpness

Устанавливает sharpness filter power value for the camera.

Аргументы

sharpness - sharpness filter power value: lowest value corresponds to small amount of filtering and the highest value corresponds to the largest amount of filtering.
Диапазон значений: [0, 10]. Значение по умолчанию : 0.

getCameraSharpness() const#

Console: vr_mixed_reality_camera_sharpness

Возвращает sharpness filter power value for the camera.

Возвращаемое значение

sharpness filter power value: lowest value corresponds to small amount of filtering and the highest value corresponds to the largest amount of filtering.
Диапазон значений: [0, 10]. Значение по умолчанию : 0.

void setViewOffset ( ) #

Console: vr_mixed_reality_view_offset

Устанавливает eyes view offset (where eye camera should be positioned when using Mixed Reality):

0 for physical eye position0 for physical eye position
1 for VST camera position1 for VST camera position

Аргументы

offset - view offset.
Диапазон значений: [0.0, 1.0]. Значение по умолчанию : 0.0.

getViewOffset() const#

Console: vr_mixed_reality_view_offset

Возвращает eyes view offset (where eye camera should be positioned when using Mixed Reality):

0 for physical eye position0 for physical eye position
1 for VST camera position1 for VST camera position

Возвращаемое значение

view offset.
Диапазон значений: [0.0, 1.0]. Значение по умолчанию : 0.0.

void setMarkerTrackingEnabled ( bool enabled ) #

Console: vr_mixed_reality_marker_tracking_enabled

Устанавливает value indicating if marker tracking is enabled.

Аргументы

bool enabled - Set true to enable marker tracking; false - to disable it. Значение по умолчанию false.

bool isMarkerTrackingEnabled() const#

Console: vr_mixed_reality_marker_tracking_enabled

Возвращает value indicating if marker tracking is enabled.

Возвращаемое значение

true if marker tracking is enabled; otherwise false. Значение по умолчанию false.

getNumMarkerObjectVisible() const#

Возвращает number of visible marker objects.

Возвращаемое значение

number of visible marker objects.

void setCubemapMode ( VRMixedReality::CUBEMAP_MODE mode ) #

Console: vr_mixed_reality_cubemap_mode

Устанавливает mode defining the way the AR texture is set for the environment.

Аргументы

VRMixedReality::CUBEMAP_MODE mode - cubemap mode. Одно из следующих значений:
- 0 - cubemap streaming from AR cameras is disabled.
- 1 - environment texture substitutes the sky.
- 2 - the first environment preset defines the way the AR texture is set for the environment. (по умолчанию)
- 3 - the second environment preset defines the way the AR texture is set for the environment.
- 4 - the third environment preset defines the way the AR texture is set for the environment.

VRMixedReality::CUBEMAP_MODE getCubemapMode() const#

Console: vr_mixed_reality_cubemap_mode

Возвращает mode defining the way the AR texture is set for the environment.

Возвращаемое значение

cubemap mode. Одно из следующих значений:

0 - cubemap streaming from AR cameras is disabled.
1 - environment texture substitutes the sky.
2 - the first environment preset defines the way the AR texture is set for the environment. (по умолчанию)
3 - the second environment preset defines the way the AR texture is set for the environment.
4 - the third environment preset defines the way the AR texture is set for the environment.

void setCubemapGGXQuality ( Render::GGX_MIPMAPS_QUALITY ggxquality ) #

Console: vr_mixed_reality_cubemap_ggx_quality

Устанавливает quality of the generated GGX mips for the AR cubemap.

Аргументы

Render::GGX_MIPMAPS_QUALITY ggxquality - quality of the GGX mipmaps. Одно из следующих значений:
- 0 - low
- 1 - medium (по умолчанию)
- 2 - high
- 3 - ultra

Render::GGX_MIPMAPS_QUALITY getCubemapGGXQuality() const#

Console: vr_mixed_reality_cubemap_ggx_quality

Возвращает quality of the generated GGX mips for the AR cubemap.

Возвращаемое значение

quality of the GGX mipmaps. Одно из следующих значений:

0 - low
1 - medium (по умолчанию)
2 - high
3 - ultra

void setOverrideColorCorrectionMode ( VRMixedReality::OVERRIDE_COLOR_CORRECTION_MODE mode ) #

Console: vr_mixed_reality_override_color_correction_mode

Устанавливает color correction mode for the stream from the AR cameras.

Аргументы

VRMixedReality::OVERRIDE_COLOR_CORRECTION_MODE mode - color correction mode. Одно из следующих значений:
- 0 - correction is disabled. (по умолчанию)
- 1 - exposure correction for the stream from the AR cameras.
- 2 - exposure and white balance correction for the stream.

VRMixedReality::OVERRIDE_COLOR_CORRECTION_MODE getOverrideColorCorrectionMode() const#

Console: vr_mixed_reality_override_color_correction_mode

Возвращает color correction mode for the stream from the AR cameras.

Возвращаемое значение

color correction mode. Одно из следующих значений:

0 - correction is disabled. (по умолчанию)
1 - exposure correction for the stream from the AR cameras.
2 - exposure and white balance correction for the stream.

Event<> getEventCameraPropertyUpdateSharpness() const#

Event triggered when the sharpness value of the camera is changed in Varjo Base. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the CameraPropertyUpdateSharpness event handler
void camerapropertyupdatesharpness_event_handler()
{
	Log::message("\Handling CameraPropertyUpdateSharpness event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections camerapropertyupdatesharpness_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventCameraPropertyUpdateSharpness().connect(camerapropertyupdatesharpness_event_connections, camerapropertyupdatesharpness_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventCameraPropertyUpdateSharpness().connect(camerapropertyupdatesharpness_event_connections, []() { 
		Log::message("\Handling CameraPropertyUpdateSharpness event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
camerapropertyupdatesharpness_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection camerapropertyupdatesharpness_event_connection;

// subscribe to the CameraPropertyUpdateSharpness event with a handler function keeping the connection
VRMixedReality::getEventCameraPropertyUpdateSharpness().connect(camerapropertyupdatesharpness_event_connection, camerapropertyupdatesharpness_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
camerapropertyupdatesharpness_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
camerapropertyupdatesharpness_event_connection.setEnabled(true);

// ...

// remove subscription to the CameraPropertyUpdateSharpness event via the connection
camerapropertyupdatesharpness_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A CameraPropertyUpdateSharpness event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling CameraPropertyUpdateSharpness event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventCameraPropertyUpdateSharpness().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the CameraPropertyUpdateSharpness event with a handler function
VRMixedReality::getEventCameraPropertyUpdateSharpness().connect(camerapropertyupdatesharpness_event_handler);


// remove subscription to the CameraPropertyUpdateSharpness event later by the handler function
VRMixedReality::getEventCameraPropertyUpdateSharpness().disconnect(camerapropertyupdatesharpness_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId camerapropertyupdatesharpness_handler_id;

// subscribe to the CameraPropertyUpdateSharpness event with a lambda handler function and keeping connection ID
camerapropertyupdatesharpness_handler_id = VRMixedReality::getEventCameraPropertyUpdateSharpness().connect([]() { 
		Log::message("\Handling CameraPropertyUpdateSharpness event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventCameraPropertyUpdateSharpness().disconnect(camerapropertyupdatesharpness_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all CameraPropertyUpdateSharpness events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventCameraPropertyUpdateSharpness().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventCameraPropertyUpdateSharpness().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventCameraPropertyUpdateFlickerCompensation() const#

Event triggered when the flicker compensation value of the camera is changed in Varjo Base. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the CameraPropertyUpdateFlickerCompensation event handler
void camerapropertyupdateflickercompensation_event_handler()
{
	Log::message("\Handling CameraPropertyUpdateFlickerCompensation event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections camerapropertyupdateflickercompensation_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().connect(camerapropertyupdateflickercompensation_event_connections, camerapropertyupdateflickercompensation_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().connect(camerapropertyupdateflickercompensation_event_connections, []() { 
		Log::message("\Handling CameraPropertyUpdateFlickerCompensation event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
camerapropertyupdateflickercompensation_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection camerapropertyupdateflickercompensation_event_connection;

// subscribe to the CameraPropertyUpdateFlickerCompensation event with a handler function keeping the connection
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().connect(camerapropertyupdateflickercompensation_event_connection, camerapropertyupdateflickercompensation_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
camerapropertyupdateflickercompensation_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
camerapropertyupdateflickercompensation_event_connection.setEnabled(true);

// ...

// remove subscription to the CameraPropertyUpdateFlickerCompensation event via the connection
camerapropertyupdateflickercompensation_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A CameraPropertyUpdateFlickerCompensation event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling CameraPropertyUpdateFlickerCompensation event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the CameraPropertyUpdateFlickerCompensation event with a handler function
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().connect(camerapropertyupdateflickercompensation_event_handler);


// remove subscription to the CameraPropertyUpdateFlickerCompensation event later by the handler function
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().disconnect(camerapropertyupdateflickercompensation_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId camerapropertyupdateflickercompensation_handler_id;

// subscribe to the CameraPropertyUpdateFlickerCompensation event with a lambda handler function and keeping connection ID
camerapropertyupdateflickercompensation_handler_id = VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().connect([]() { 
		Log::message("\Handling CameraPropertyUpdateFlickerCompensation event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().disconnect(camerapropertyupdateflickercompensation_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all CameraPropertyUpdateFlickerCompensation events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventCameraPropertyUpdateFlickerCompensation().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventCameraPropertyUpdateISO() const#

Event triggered when the camera ISO value and/or the ISO adjustment mode are changed in Varjo Base. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the CameraPropertyUpdateISO event handler
void camerapropertyupdateiso_event_handler()
{
	Log::message("\Handling CameraPropertyUpdateISO event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections camerapropertyupdateiso_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventCameraPropertyUpdateISO().connect(camerapropertyupdateiso_event_connections, camerapropertyupdateiso_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventCameraPropertyUpdateISO().connect(camerapropertyupdateiso_event_connections, []() { 
		Log::message("\Handling CameraPropertyUpdateISO event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
camerapropertyupdateiso_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection camerapropertyupdateiso_event_connection;

// subscribe to the CameraPropertyUpdateISO event with a handler function keeping the connection
VRMixedReality::getEventCameraPropertyUpdateISO().connect(camerapropertyupdateiso_event_connection, camerapropertyupdateiso_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
camerapropertyupdateiso_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
camerapropertyupdateiso_event_connection.setEnabled(true);

// ...

// remove subscription to the CameraPropertyUpdateISO event via the connection
camerapropertyupdateiso_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A CameraPropertyUpdateISO event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling CameraPropertyUpdateISO event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventCameraPropertyUpdateISO().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the CameraPropertyUpdateISO event with a handler function
VRMixedReality::getEventCameraPropertyUpdateISO().connect(camerapropertyupdateiso_event_handler);


// remove subscription to the CameraPropertyUpdateISO event later by the handler function
VRMixedReality::getEventCameraPropertyUpdateISO().disconnect(camerapropertyupdateiso_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId camerapropertyupdateiso_handler_id;

// subscribe to the CameraPropertyUpdateISO event with a lambda handler function and keeping connection ID
camerapropertyupdateiso_handler_id = VRMixedReality::getEventCameraPropertyUpdateISO().connect([]() { 
		Log::message("\Handling CameraPropertyUpdateISO event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventCameraPropertyUpdateISO().disconnect(camerapropertyupdateiso_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all CameraPropertyUpdateISO events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventCameraPropertyUpdateISO().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventCameraPropertyUpdateISO().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventCameraPropertyUpdateWhiteBalance() const#

Event triggered when the white balance correction value of the camera and/or the white balance adjustment mode are changed in Varjo Base. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the CameraPropertyUpdateWhiteBalance event handler
void camerapropertyupdatewhitebalance_event_handler()
{
	Log::message("\Handling CameraPropertyUpdateWhiteBalance event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections camerapropertyupdatewhitebalance_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().connect(camerapropertyupdatewhitebalance_event_connections, camerapropertyupdatewhitebalance_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().connect(camerapropertyupdatewhitebalance_event_connections, []() { 
		Log::message("\Handling CameraPropertyUpdateWhiteBalance event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
camerapropertyupdatewhitebalance_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection camerapropertyupdatewhitebalance_event_connection;

// subscribe to the CameraPropertyUpdateWhiteBalance event with a handler function keeping the connection
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().connect(camerapropertyupdatewhitebalance_event_connection, camerapropertyupdatewhitebalance_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
camerapropertyupdatewhitebalance_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
camerapropertyupdatewhitebalance_event_connection.setEnabled(true);

// ...

// remove subscription to the CameraPropertyUpdateWhiteBalance event via the connection
camerapropertyupdatewhitebalance_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A CameraPropertyUpdateWhiteBalance event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling CameraPropertyUpdateWhiteBalance event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the CameraPropertyUpdateWhiteBalance event with a handler function
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().connect(camerapropertyupdatewhitebalance_event_handler);


// remove subscription to the CameraPropertyUpdateWhiteBalance event later by the handler function
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().disconnect(camerapropertyupdatewhitebalance_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId camerapropertyupdatewhitebalance_handler_id;

// subscribe to the CameraPropertyUpdateWhiteBalance event with a lambda handler function and keeping connection ID
camerapropertyupdatewhitebalance_handler_id = VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().connect([]() { 
		Log::message("\Handling CameraPropertyUpdateWhiteBalance event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().disconnect(camerapropertyupdatewhitebalance_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all CameraPropertyUpdateWhiteBalance events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventCameraPropertyUpdateWhiteBalance().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventCameraPropertyUpdateExposureTime() const#

Event triggered when the exposure time value of the camera and/or the exposure adjustment mode are changed in Varjo Base. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the CameraPropertyUpdateExposureTime event handler
void camerapropertyupdateexposuretime_event_handler()
{
	Log::message("\Handling CameraPropertyUpdateExposureTime event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections camerapropertyupdateexposuretime_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventCameraPropertyUpdateExposureTime().connect(camerapropertyupdateexposuretime_event_connections, camerapropertyupdateexposuretime_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventCameraPropertyUpdateExposureTime().connect(camerapropertyupdateexposuretime_event_connections, []() { 
		Log::message("\Handling CameraPropertyUpdateExposureTime event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
camerapropertyupdateexposuretime_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection camerapropertyupdateexposuretime_event_connection;

// subscribe to the CameraPropertyUpdateExposureTime event with a handler function keeping the connection
VRMixedReality::getEventCameraPropertyUpdateExposureTime().connect(camerapropertyupdateexposuretime_event_connection, camerapropertyupdateexposuretime_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
camerapropertyupdateexposuretime_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
camerapropertyupdateexposuretime_event_connection.setEnabled(true);

// ...

// remove subscription to the CameraPropertyUpdateExposureTime event via the connection
camerapropertyupdateexposuretime_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A CameraPropertyUpdateExposureTime event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling CameraPropertyUpdateExposureTime event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventCameraPropertyUpdateExposureTime().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the CameraPropertyUpdateExposureTime event with a handler function
VRMixedReality::getEventCameraPropertyUpdateExposureTime().connect(camerapropertyupdateexposuretime_event_handler);


// remove subscription to the CameraPropertyUpdateExposureTime event later by the handler function
VRMixedReality::getEventCameraPropertyUpdateExposureTime().disconnect(camerapropertyupdateexposuretime_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId camerapropertyupdateexposuretime_handler_id;

// subscribe to the CameraPropertyUpdateExposureTime event with a lambda handler function and keeping connection ID
camerapropertyupdateexposuretime_handler_id = VRMixedReality::getEventCameraPropertyUpdateExposureTime().connect([]() { 
		Log::message("\Handling CameraPropertyUpdateExposureTime event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventCameraPropertyUpdateExposureTime().disconnect(camerapropertyupdateexposuretime_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all CameraPropertyUpdateExposureTime events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventCameraPropertyUpdateExposureTime().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventCameraPropertyUpdateExposureTime().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventChromakeyUpdate() const#

Event triggered when the chroma keying settings are changed in Varjo Base. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the ChromakeyUpdate event handler
void chromakeyupdate_event_handler()
{
	Log::message("\Handling ChromakeyUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections chromakeyupdate_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventChromakeyUpdate().connect(chromakeyupdate_event_connections, chromakeyupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventChromakeyUpdate().connect(chromakeyupdate_event_connections, []() { 
		Log::message("\Handling ChromakeyUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
chromakeyupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection chromakeyupdate_event_connection;

// subscribe to the ChromakeyUpdate event with a handler function keeping the connection
VRMixedReality::getEventChromakeyUpdate().connect(chromakeyupdate_event_connection, chromakeyupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
chromakeyupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
chromakeyupdate_event_connection.setEnabled(true);

// ...

// remove subscription to the ChromakeyUpdate event via the connection
chromakeyupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A ChromakeyUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling ChromakeyUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventChromakeyUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the ChromakeyUpdate event with a handler function
VRMixedReality::getEventChromakeyUpdate().connect(chromakeyupdate_event_handler);


// remove subscription to the ChromakeyUpdate event later by the handler function
VRMixedReality::getEventChromakeyUpdate().disconnect(chromakeyupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId chromakeyupdate_handler_id;

// subscribe to the ChromakeyUpdate event with a lambda handler function and keeping connection ID
chromakeyupdate_handler_id = VRMixedReality::getEventChromakeyUpdate().connect([]() { 
		Log::message("\Handling ChromakeyUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventChromakeyUpdate().disconnect(chromakeyupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all ChromakeyUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventChromakeyUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventChromakeyUpdate().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventDeviceDisconnected() const#

Event triggered when the Varjo device is disconnected. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the DeviceDisconnected event handler
void devicedisconnected_event_handler()
{
	Log::message("\Handling DeviceDisconnected event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections devicedisconnected_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventDeviceDisconnected().connect(devicedisconnected_event_connections, devicedisconnected_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventDeviceDisconnected().connect(devicedisconnected_event_connections, []() { 
		Log::message("\Handling DeviceDisconnected event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
devicedisconnected_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection devicedisconnected_event_connection;

// subscribe to the DeviceDisconnected event with a handler function keeping the connection
VRMixedReality::getEventDeviceDisconnected().connect(devicedisconnected_event_connection, devicedisconnected_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
devicedisconnected_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
devicedisconnected_event_connection.setEnabled(true);

// ...

// remove subscription to the DeviceDisconnected event via the connection
devicedisconnected_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A DeviceDisconnected event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling DeviceDisconnected event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventDeviceDisconnected().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the DeviceDisconnected event with a handler function
VRMixedReality::getEventDeviceDisconnected().connect(devicedisconnected_event_handler);


// remove subscription to the DeviceDisconnected event later by the handler function
VRMixedReality::getEventDeviceDisconnected().disconnect(devicedisconnected_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId devicedisconnected_handler_id;

// subscribe to the DeviceDisconnected event with a lambda handler function and keeping connection ID
devicedisconnected_handler_id = VRMixedReality::getEventDeviceDisconnected().connect([]() { 
		Log::message("\Handling DeviceDisconnected event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventDeviceDisconnected().disconnect(devicedisconnected_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all DeviceDisconnected events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventDeviceDisconnected().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventDeviceDisconnected().setEnabled(true);

Возвращаемое значение

Event reference.

Event<> getEventDeviceConnected() const#

Event triggered when the Varjo device is connected. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Примечание

For more details see the Event Handling article.

The event handler signature is as follows: myhandler()

Usage Example

Исходный код (C++)

// implement the DeviceConnected event handler
void deviceconnected_event_handler()
{
	Log::message("\Handling DeviceConnected event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections deviceconnected_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
VRMixedReality::getEventDeviceConnected().connect(deviceconnected_event_connections, deviceconnected_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
VRMixedReality::getEventDeviceConnected().connect(deviceconnected_event_connections, []() { 
		Log::message("\Handling DeviceConnected event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
deviceconnected_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection deviceconnected_event_connection;

// subscribe to the DeviceConnected event with a handler function keeping the connection
VRMixedReality::getEventDeviceConnected().connect(deviceconnected_event_connection, deviceconnected_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
deviceconnected_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
deviceconnected_event_connection.setEnabled(true);

// ...

// remove subscription to the DeviceConnected event via the connection
deviceconnected_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A DeviceConnected event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling DeviceConnected event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
VRMixedReality::getEventDeviceConnected().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the DeviceConnected event with a handler function
VRMixedReality::getEventDeviceConnected().connect(deviceconnected_event_handler);


// remove subscription to the DeviceConnected event later by the handler function
VRMixedReality::getEventDeviceConnected().disconnect(deviceconnected_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId deviceconnected_handler_id;

// subscribe to the DeviceConnected event with a lambda handler function and keeping connection ID
deviceconnected_handler_id = VRMixedReality::getEventDeviceConnected().connect([]() { 
		Log::message("\Handling DeviceConnected event (lambda).\n");
	}
);

// remove the subscription later using the ID
VRMixedReality::getEventDeviceConnected().disconnect(deviceconnected_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all DeviceConnected events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
VRMixedReality::getEventDeviceConnected().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
VRMixedReality::getEventDeviceConnected().setEnabled(true);

Возвращаемое значение

Event reference.

void applySettings ( ) #

Updates the mixed reality settings to the current settings.

bool isChromaKeyConfigEnabled ( int index ) const#

Returns the current value indicating if the chroma key configuration with the specified index is enabled.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.

Возвращаемое значение

1 the chroma key configuration is enabled; otherwise, 0.

void setChromaKeyConfigEnabled ( int index, bool enabled ) #

Sets a new value indicating if the chroma key configuration with the specified index is enabled.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.
bool enabled - 1 to enable the chroma key configuration; 0 to disable it.1 to enable the chroma key configuration; 0 to disable it.

Math::vec3 getChromaKeyConfigFalloff ( int index ) const#

Returns the current tolerance falloff values for HSV components of the chroma key target color.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.

Возвращаемое значение

Current tolerance falloff values for HSV components of the chroma key target color. The range for each component is [0.0; 1.0].

void setChromaKeyConfigFalloff ( int index, const Math::vec3 & falloff ) #

Sets new tolerance falloff values for HSV components of the chroma key target color.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.
const Math::vec3 & falloff - New tolerance falloff values to be set for HSV components of the chroma key target color. The range for each component is [0.0; 1.0].New tolerance falloff values to be set for HSV components of the chroma key target color. The range for each component is [0.0; 1.0].

Math::vec3 getChromaKeyConfigTargetColor ( int index ) const#

Returns the current chroma key target color.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.

Возвращаемое значение

Current chroma key target color in HSV colorspace. The range for each component is [0.0; 1.0].

void setChromaKeyConfigTargetColor ( int index, const Math::vec3 & target_color ) #

Sets a new chroma key target color.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.
const Math::vec3 & target_color - New chroma key target color to be set in HSV colorspace. The range for each component is [0.0; 1.0].New chroma key target color to be set in HSV colorspace. The range for each component is [0.0; 1.0].

Math::vec3 getChromaKeyConfigTolerance ( int index ) const#

Returns the current tolerance values for HSV components of the chroma key target color.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.

Возвращаемое значение

Current tolerance values for HSV components of the chroma key target color. The range for each component is [0.0; 1.0].

void setChromaKeyConfigTolerance ( int index, const Math::vec3 & tolerance ) #

Sets new tolerance values for HSV components of the chroma key target color.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.
const Math::vec3 & tolerance - New tolerance values for HSV components of the chroma key target color to be set. The range for each component is [0.0; 1.0].New tolerance values for HSV components of the chroma key target color to be set. The range for each component is [0.0; 1.0].

void applyChromaKeySettings ( int index ) const#

Updates the settings of the chroma key configuration with the specified index to the current settings.

Аргументы

int index - Chroma key config index in the range from 0 to config count - 1.Chroma key config index in the range from 0 to config count - 1.

Vector<int> getCameraSupportedRawExposureTimes ( ) const#

Returns a vector containing the exposure time values that are set as valid for the connected device.

Возвращаемое значение

The vector containing the exposure time values.

Vector<int> getCameraSupportedRawWhiteBalances ( ) const#

Returns a vector containing the white balance values that are set as valid for the connected device.

Возвращаемое значение

The vector containing the white balance values.

Vector<int> getCameraSupportedRawISO ( ) const#

Returns a vector containing the ISO values that are set as valid for the connected device.

Возвращаемое значение

The vector containing the ISO values.

Vector<int> getCameraSupportedRawFlickerCompensations ( ) const#

Returns a vector containing the flicker compensation values that are set as valid for the connected device.

Возвращаемое значение

The vector containing the flicker compensation values.

Ptr<VRMarkerObject> getMarkerObject ( short index ) const#

Returns the marker object with the specified index.

Аргументы

short index - Marker object index.Marker object index.

Возвращаемое значение

Marker object.

Ptr<VRMarkerObject> getMarkerObjectByID ( short marker_id ) const#

Returns the marker object with the specified ID.

Аргументы

short marker_id - Marker object ID.Marker object ID.

Возвращаемое значение

Marker object.

Последнее обновление: 06.02.2024

Помогите сделать статью лучше

Была ли эта статья полезной?

Сообщить о проблеме в этой статье

(или выберите слово/фразу и нажмите Ctrl+Enter