core.hpp

Go to the documentation of this file.

#ifndef CNSDK_LEIA_CORE_CXX_CORE_HPP
#define CNSDK_LEIA_CORE_CXX_CORE_HPP
 
#include "leia/core/core.h"
#include "leia/core/cxx/library.hpp"
#include "leia/core/cxx/types.hpp"
#include "leia/core/cxx/exception.hpp"
#include "leia/core/cxx/experimental.hpp"
#include "leia/core/cxx/assetManager.hpp"
#include "leia/common/version.h"
 
namespace leia {
 
using Vector3 = leia_vector3;
using Vector4 = leia_vector4;
using Mat4    = leia_mat4;
 
using FloatSlice = leia_float_slice;
inline FloatSlice ToSlice(Vector3* v)
{
    return {v->v, 3};
}
inline FloatSlice ToSlice(Mat4* v)
{
    return {v->m, 16};
}
using ConstFloatSlice = leia_const_float_slice;
inline ConstFloatSlice ToConstSlice(leia_vector3 const* v)
{
    return {v->v, 3};
}
inline ConstFloatSlice ToConstSlice(Mat4* v)
{
    return {v->m, 16};
}
 
using SharedCameraSink = leia_shared_camera_sink;
 
class Core;
 
using CoreAndroidHandleType = leia_core_android_handle_type;
 
using FaceTrackingFrameListener = leia_headtracking_frame_listener;
using FaceTrackingFrame         = leia_headtracking_frame;
 
class CoreInitConfiguration {
public:
    CoreInitConfiguration() : _ptr(nullptr)
    {
    }
    CoreInitConfiguration(CoreLibrary const& coreLib) : _ptr(leia_core_init_configuration_alloc(coreLib.GetHandle(), CNSDK_VERSION))
    {
    }
    ~CoreInitConfiguration()
    {
        leia_core_init_configuration_free(_ptr);
    }
    CoreInitConfiguration(CoreInitConfiguration const&) = delete;
    CoreInitConfiguration& operator=(CoreInitConfiguration const&) = delete;
    CoreInitConfiguration(CoreInitConfiguration&& other) : CoreInitConfiguration()
    {
        *this = std::move(other);
    }
    CoreInitConfiguration& operator=(CoreInitConfiguration&& other)
    {
        std::swap(_ptr, other._ptr);
        return *this;
    }
    explicit operator bool() const
    {
        return _ptr != nullptr;
    }
 
    void SetLicenseKey(const char* licenseKey)
    {
        leia_core_init_configuration_set_license_key(_ptr, licenseKey);
    }
    void SetLicenseNetworkProxy(const char* networkProxy)
    {
        leia_core_init_configuration_set_license_network_proxy(_ptr, networkProxy);
    }
    void SetEnableValidation(bool enable)
    {
        leia_core_init_configuration_set_enable_validation(_ptr, enable);
    }
    void SetPlatformAndroidHandle(CoreAndroidHandleType handleType, jobject handle)
    {
        leia_core_init_configuration_set_platform_android_handle(_ptr, handleType, handle);
    }
    void SetPlatformLogLevel(leia_log_level logLevel)
    {
        leia_core_init_configuration_set_platform_log_level(_ptr, logLevel);
    }
    void SetFaceTrackingSharedCameraSink(leia_shared_camera_sink* sharedCameraSink)
    {
        leia_core_init_configuration_set_face_tracking_shared_camera_sink(_ptr, sharedCameraSink);
    }
    void SetFaceTrackingRuntime(leia_face_tracking_runtime_type runtime)
    {
        leia_core_init_configuration_set_face_tracking_runtime(_ptr, runtime);
    }
    void SetFaceTrackingEnable(bool enable)
    {
        leia_core_init_configuration_set_face_tracking_enable(_ptr, enable);
    }
    void SetFaceTrackingStart(bool start)
    {
        leia_core_init_configuration_set_face_tracking_start(_ptr, start);
    }
    void SetFaceTrackingCheckPermission(bool checkPermission)
    {
        leia_core_init_configuration_set_face_tracking_check_permission(_ptr, checkPermission);
    }
    void SetFaceTrackingPermissionDialogKillProcess(bool permissionDialogKillProcess)
    {
        leia_core_init_configuration_set_face_tracking_permission_dialog_kill_process(_ptr, permissionDialogKillProcess);
    }
    void SetFaceTrackingServerLogLevel(leia_log_level serverLogLevel)
    {
        leia_core_init_configuration_set_face_tracking_server_log_level(_ptr, serverLogLevel);
    }
    void SetFaceTrackingPreferredFps(int preferredFps)
    {
        leia_core_init_configuration_set_face_tracking_preferred_fps(_ptr, preferredFps);
    }
    void ResetDisplayConfig()
    {
        leia_core_init_configuration_set_hint(_ptr, LEIA_CORE_HINT_RESET_DISPLAY_CONFIG);
    }
 
    leia_core_init_configuration* GetHandle()
    {
        return _ptr;
    }
 
private:
    leia_core_init_configuration* _ptr;
};
 
class Core {
public:
    Core() : Core(nullptr)
    {
    }
    Core(leia_core* core) : _core(core), _isCoreOwned(false)
    {
    }
    Core(CoreInitConfiguration& config) : _core(leia_core_init_async(config.GetHandle())), _isCoreOwned(true)
    {
#if !defined(LEIA_WRAPPER_DISABLE_EXCEPTION)
        if (!_core)
        {
            throw CoreInitFailed();
        }
#endif // !LEIA_WRAPPER_DISABLE_EXCEPTION
    }
    ~Core()
    {
        if (_isCoreOwned)
        {
            leia_core_release(_core);
        }
    }
    Core(Core const&) = delete;
    Core& operator=(Core const&) = delete;
    Core(Core&& other) : Core()
    {
        *this = std::move(other);
    }
    Core& operator=(Core&& other)
    {
        std::swap(_core, other._core);
        std::swap(_isCoreOwned, other._isCoreOwned);
        return *this;
    }
    explicit operator bool() const
    {
        return _core != nullptr;
    }
 
    LEIA_NODISCARD
    bool IsInitialized() const
    {
        return bool(leia_core_is_initialized(_core));
    }
    LEIA_NODISCARD
    bool IsValidationEnabled() const
    {
        return bool(leia_core_is_validation_enabled(_core));
    }
 
    void OnResume()
    {
        leia_core_on_resume(_core);
    }
    void OnPause()
    {
        leia_core_on_pause(_core);
    }
    void Enable3D(bool enable)
    {
        leia_core_enable_3d(_core, enable);
    }
    LEIA_NODISCARD
    bool Is3DEnabled()
    {
        return bool(leia_core_is_3d_enabled(_core));
    }
    LEIA_NODISCARD
    enum leia_orientation GetOrientation()
    {
        return leia_orientation(leia_core_get_orientation(_core));
    }
    bool EnableFaceTracking(bool enable)
    {
        return bool(leia_core_enable_face_tracking(_core, enable));
    }
    LEIA_NODISCARD
    bool IsFaceTrackingEnabled()
    {
        return bool(leia_core_is_face_tracking_enabled(_core));
    }
    void StartFaceTracking(bool start)
    {
        leia_core_start_face_tracking(_core, start);
    }
    void SetFaceTrackerConfiguration(bool leftEye, bool rightEye)
    {
        leia_core_set_face_tracker_configuration(_core, leftEye, rightEye);
    }
    LEIA_NODISCARD
    bool IsFaceTrackingStarted()
    {
        return bool(leia_core_is_face_tracking_started(_core));
    }
    void SetFaceTrackingRuntime(FaceTrackingRuntimeType runtime)
    {
        leia_core_set_face_tracking_runtime(_core, runtime);
    }
    LEIA_NODISCARD
    FaceTrackingRuntimeType GetFaceTrackingRuntime()
    {
        return leia_core_get_face_tracking_runtime(_core);
    }
    void SetFaceTrackingSharedCameraSink(SharedCameraSink* sink)
    {
        leia_core_set_face_tracking_shared_camera_sink(_core, sink);
    }
    void SetDefaultFacePosition(ConstFloatSlice position)
    {
        leia_core_set_default_face_position(_core, position);
    }
    LEIA_NODISCARD
    bool GetPrimaryFace(FloatSlice position)
    {
        return bool(leia_core_get_primary_face(_core, position));
    }
    LEIA_NODISCARD
    bool GetNonPredictedPrimaryFace(FloatSlice position)
    {
        return bool(leia_core_get_non_predicted_primary_face(_core, position));
    }
    void SetFaceTrackingFrameListener(OWNING(FaceTrackingFrameListener*) listener)
    {
        leia_core_set_face_tracking_frame_listener(_core, listener);
    }
    void SetFaceTrackingCaptureLux(bool enable)
    {
        leia_core_set_face_tracking_capture_lux(_core, enable);
    }
    void EnableNoFaceMode(bool enable)
    {
        leia_core_enable_no_face_mode(_core, enable);
    }
    void SetNoFaceModeTimeThreshold(double timeThresholdSeconds)
    {
        leia_core_set_no_face_mode_time_threshold(_core, timeThresholdSeconds);
    }
    LEIA_NODISCARD
    AssetManager GetAssetManager()
    {
        return {leia_core_get_asset_manager(_core)};
    }
 
    LEIA_NODISCARD
    bool GetViewingDistance(float ipdMM, float* viewingDistance)
    {
        return bool(leia_core_get_viewing_distance(_core, ipdMM, viewingDistance));
    }
 
    LEIA_DEPRECATED
    void SetBacklight(bool enable)
    {
        Enable3D(enable);
    }
    LEIA_NODISCARD
    LEIA_DEPRECATED
    bool GetBacklight()
    {
        return Is3DEnabled();
    }
 
    LEIA_NODISCARD
    leia_core* GetHandle() const
    {
        return _core;
    }
 
private:
    leia_core* _core;
    bool       _isCoreOwned;
};
 
/* See @ref leia_get_experimental_api */
class CoreExperimental {
public:
    CoreExperimental() : _core(nullptr)
    {
    }
    CoreExperimental(CoreLibrary const& coreLibrary, Core const& core) : _core(core.GetHandle())
    {
        leia_core_retain(_core);
 
        leia_core_library* coreLibPtr = coreLibrary.GetHandle();
        leia_core_set_user_ipd.Load(coreLibPtr);
        leia_core_set_face_tracking_profiling.Load(coreLibPtr);
        leia_core_get_face_tracking_profiling.Load(coreLibPtr);
        leia_core_burn_display_config.Load(coreLibPtr);
        leia_core_burn_camera_extrinsics.Load(coreLibPtr);
        leia_core_set_tracking_camera_rotation.Load(coreLibPtr);
        leia_core_get_tracking_camera_rotation.Load(coreLibPtr);
        leia_core_get_non_predicted_eyes.Load(coreLibPtr);
        leia_core_get_lookaround_eyes.Load(coreLibPtr);
        leia_core_get_face_detector_version.Load(coreLibPtr);
    }
    ~CoreExperimental()
    {
        if (_core)
            leia_core_release(_core);
    }
    CoreExperimental(CoreExperimental const&) = delete;
    CoreExperimental& operator=(CoreExperimental const&) = delete;
    CoreExperimental(CoreExperimental&& other) : CoreExperimental()
    {
        *this = std::move(other);
    }
    CoreExperimental& operator=(CoreExperimental&& other)
    {
        std::swap(_core, other._core);
        return *this;
    }
    explicit operator bool() const
    {
        return _core != nullptr;
    }
 
    void SetUserIpd(float userIpd)
    {
        if (leia_core_set_user_ipd)
            leia_core_set_user_ipd(_core, userIpd);
    }
    void SetFaceTrackingProfiling(bool enable)
    {
        if (leia_core_set_face_tracking_profiling)
            leia_core_set_face_tracking_profiling(_core, enable);
    }
    bool GetFaceTrackingProfiling(leia_headtracking_frame_profiling* profiling, int32_t profilingSizeof)
    {
        if (leia_core_get_face_tracking_profiling)
            return bool(leia_core_get_face_tracking_profiling(_core, profiling, profilingSizeof));
        return false;
    }
    bool BurnDisplayConfig(float slant, float pitch, float phc, float dOverN, float n, float actCoef, float thetaX, float thetaY, float thetaZ)
    {
        if (leia_core_burn_display_config)
            return bool(leia_core_burn_display_config(_core, slant, pitch, phc, dOverN, n, actCoef, thetaX, thetaY, thetaZ));
        return false;
    }
    bool BurnCameraExtrinsics(int cameraId, float thetaXFpc, float thetaYFpc, float thetaZFpc)
    {
        if (leia_core_burn_camera_extrinsics)
            return bool(leia_core_burn_camera_extrinsics(_core, cameraId, thetaXFpc, thetaYFpc, thetaZFpc));
        return false;
    }
    void TrackingCameraRotation(float thetaX, float thetaY, float thetaZ)
    {
        if (leia_core_set_tracking_camera_rotation)
            leia_core_set_tracking_camera_rotation(_core, thetaX, thetaY, thetaZ);
    }
    bool TrackingCameraRotation(FloatSlice rotation)
    {
        if (leia_core_get_tracking_camera_rotation)
            return bool(leia_core_get_tracking_camera_rotation(_core, rotation));
        return false;
    }
    bool GetNonPredictedEyes(FloatSlice& leftEyePosition, FloatSlice& rightEyePosition)
    {
        if (leia_core_get_non_predicted_eyes)
            return bool(leia_core_get_non_predicted_eyes(_core, leftEyePosition, rightEyePosition));
        return false;
    }
    bool GetLookaroundEyes(FloatSlice& leftPosition, FloatSlice& rightPosition)
    {
        if (leia_core_get_lookaround_eyes)
            return bool(leia_core_get_lookaround_eyes(_core, leftPosition, rightPosition));
        return false;
    }
    std::string GetFaceDetectorVersion()
    {
        if (!leia_core_get_face_detector_version)
            return {};
 
        char   buffer[32];
        size_t actual_size;
        leia_core_get_face_detector_version(_core, buffer, sizeof(buffer), &actual_size);
        return {buffer, actual_size};
    }
 
private:
    leia_core* _core;
 
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_set_user_ipd);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_set_face_tracking_profiling);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_get_face_tracking_profiling);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_burn_display_config);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_burn_camera_extrinsics);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_set_tracking_camera_rotation);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_get_tracking_camera_rotation);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_get_non_predicted_eyes);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_get_lookaround_eyes);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_core_get_face_detector_version);
};
 
// using LeiaSDK = Core;
// using ILeiaSDK = Core;
 
LEIA_NODISCARD
inline bool IsFaceTrackingRuntimeSupported(CoreLibrary const& coreLibrary, FaceTrackingRuntimeType runtime)
{
    return bool(leia_is_face_tracking_runtime_supported(coreLibrary.GetHandle(), runtime));
}
 
LEIA_NODISCARD
inline bool IsLicenseRequired()
{
    return bool(leia_core_is_license_required());
}
 
LEIA_NODISCARD
inline bool GetLegalOrientations(CoreLibrary const& coreLibrary, leia_legal_orientations* legalOrientations)
{
    return bool(leia_core_get_legal_orientations(coreLibrary.GetHandle(), legalOrientations));
}
 
inline void LimitOrientations(CoreLibrary const& coreLibrary, jobject activity, leia_legal_orientations const* legalOrientations)
{
    leia_core_limit_orientations(coreLibrary.GetHandle(), activity, legalOrientations);
}
 
LEIA_NODISCARD
inline bool GetNaturalOrientation(CoreLibrary const& coreLibrary, leia_orientation* orientation)
{
    return bool(leia_core_get_natural_orientation(coreLibrary.GetHandle(), orientation));
}
 
static bool IsDeviceSupported(CoreLibrary const& coreLibrary)
{
    return bool(leia_is_device_supported(coreLibrary.GetHandle()));
}
 
} // namespace leia
 
#endif // CNSDK_LEIA_CORE_CXX_CORE_HPP