interlacer.hpp

Go to the documentation of this file.

#ifndef CNSDK_LEIA_CORE_CXX_INTERLACER_HPP
#define CNSDK_LEIA_CORE_CXX_INTERLACER_HPP
 
#include "leia/core/cxx/core.hpp"
#include "leia/core/cxx/experimental.hpp"
#include "leia/core/interlacer.h"
 
namespace leia {
 
using InterlacerDebugMenuConfiguration = leia_interlacer_debug_menu_configuration;
using FitMode                          = leia_fit_mode;
using TileLayout                       = leia_tile_layout;
using CalibrationPattern               = leia_calibration_pattern;
using InterlacerSingleViewModeListener = leia_interlacer_single_view_mode_listener;
using GraphicsAPI                      = leia_graphics_api;
using GuiInputState                    = leia_interlacer_gui_input_state;
 
class Interlacer {
public:
    Interlacer() : Interlacer(nullptr, false)
    {
    }
    ~Interlacer()
    {
        if (_isInterlacerOwned)
        {
            leia_interlacer_release(_interlacer);
        }
    }
    Interlacer(Interlacer const&) = delete;
    Interlacer& operator=(Interlacer const&) = delete;
    Interlacer(Interlacer&& other) : Interlacer()
    {
        *this = std::move(other);
    }
    Interlacer& operator=(Interlacer&& other)
    {
        std::swap(_interlacer, other._interlacer);
        std::swap(_isInterlacerOwned, other._isInterlacerOwned);
        return *this;
    }
    explicit operator bool() const
    {
        return _interlacer != nullptr;
    }
 
    void SetLayerCount(int layerCount)
    {
        leia_interlacer_set_layer_count(_interlacer, layerCount);
    }
 
    LEIA_NODISCARD
    int GetLayerCount() const
    {
        return leia_interlacer_get_layer_count(_interlacer);
    }
 
    void SetNumTiles(int32_t tx, int32_t ty)
    {
        leia_interlacer_set_num_tiles(_interlacer, tx, ty);
    }
    void GetNumTiles(int32_t* tx, int32_t* ty) const
    {
        leia_interlacer_get_num_tiles(_interlacer, tx, ty);
    }
 
    void SetTileLayout(TileLayout tileLayout)
    {
        leia_interlacer_set_tile_layout(_interlacer, tileLayout);
    }
 
    void SetOutputAsTiles(bool enable)
    {
        leia_interlacer_output_as_tiles(_interlacer, enable);
    }
 
    void SetBaselineScaling(float baseline)
    {
        leia_interlacer_set_baseline_scaling(_interlacer, baseline);
    }
    LEIA_NODISCARD
    float GetBaselineScaling()
    {
        return leia_interlacer_get_baseline_scaling(_interlacer);
    }
    LEIA_NODISCARD
    float GetConvergenceDistance()
    {
        return leia_interlacer_get_convergence_distance(_interlacer);
    }
    void SetConvergenceDistance(float distance)
    {
        leia_interlacer_set_convergence_distance(_interlacer, distance);
    }
    float GetPhc()
    {
        return leia_interlacer_get_phc(_interlacer);
    }
    void SetPhc(float phase)
    {
        leia_interlacer_set_phc(_interlacer, phase);
    }
    // TODO: Port to struct?
    void GetConvergedOrthographicViewInfo(int32_t viewIndex,
                                          LEIA_CONST_FLOAT_SLICE(3) cameraPos,
                                          LEIA_CONST_FLOAT_SLICE(3) cameraDir,
                                          LEIA_CONST_FLOAT_SLICE(3) cameraUp,
                                          float width,
                                          float height,
                                          float nearPlane,
                                          float farPlane,
                                          LEIA_FLOAT_SLICE(3) viewPos,
                                          LEIA_FLOAT_SLICE(16) viewProjectionMatrix,
                                          float* viewShearX,
                                          float* viewShearY)
    {
        leia_interlacer_get_converged_orthographic_view_info(
            _interlacer, viewIndex, cameraPos, cameraDir, cameraUp, width, height, nearPlane, farPlane, viewPos, viewProjectionMatrix, viewShearX, viewShearY);
    }
    // TODO: Port to struct?
    void GetConvergedPerspectiveViewInfo(int32_t viewIndex,
                                         LEIA_CONST_FLOAT_SLICE(3) cameraPos,
                                         LEIA_CONST_FLOAT_SLICE(3) cameraDir,
                                         LEIA_CONST_FLOAT_SLICE(3) cameraUp,
                                         float fieldOfView,
                                         float aspectRatio,
                                         float nearPlane,
                                         float farPlane,
                                         LEIA_FLOAT_SLICE(3) viewPos,
                                         LEIA_FLOAT_SLICE(16) viewProjectionMatrix,
                                         float* viewFieldOfView,
                                         float* viewShearX,
                                         float* viewShearY)
    {
        leia_interlacer_get_converged_perspective_view_info(_interlacer,
                                                            viewIndex,
                                                            cameraPos,
                                                            cameraDir,
                                                            cameraUp,
                                                            fieldOfView,
                                                            aspectRatio,
                                                            nearPlane,
                                                            farPlane,
                                                            viewPos,
                                                            viewProjectionMatrix,
                                                            viewFieldOfView,
                                                            viewShearX,
                                                            viewShearY);
    }
    void SetFitMode(FitMode mode)
    {
        leia_interlacer_set_fit_mode(_interlacer, mode);
    }
    LEIA_NODISCARD
    FitMode GetFitMode()
    {
        return leia_interlacer_get_fit_mode(_interlacer);
    }
    void GetRectMatrix(LEIA_FLOAT_SLICE(16) transformMatrix)
    {
        leia_interlacer_get_rect_matrix(_interlacer, transformMatrix);
    }
    void SetLocalMatrix(LEIA_CONST_FLOAT_SLICE(16) transformMatrix)
    {
        leia_interlacer_set_local_matrix(_interlacer, transformMatrix);
    }
    void SetCustomTextureMatrix(LEIA_CONST_FLOAT_SLICE(16) textureTransform)
    {
        leia_interlacer_set_custom_texture_matrix(_interlacer, textureTransform);
    }
    void EnableUserMatrix(bool enabled)
    {
        leia_interlacer_set_enable_user_matrix(_interlacer, enabled);
    }
    void GetUserMatrix(LEIA_FLOAT_SLICE(16) transformMatrix)
    {
        leia_interlacer_get_user_matrix(_interlacer, transformMatrix);
    }
    void SetUserMatrix(LEIA_CONST_FLOAT_SLICE(16) transformMatrix)
    {
        leia_interlacer_set_user_matrix(_interlacer, transformMatrix);
    }
    void SetAlpha(float alpha)
    {
        leia_interlacer_set_alpha(_interlacer, alpha);
    }
    void SetFlipInputUvVertical(bool flip)
    {
        leia_interlacer_set_flip_input_uv_vertical(_interlacer, leia_bool(flip));
    }
    void SetSingleViewMode(bool setSingleView, int32_t singleViewIndex)
    {
        leia_interlacer_set_single_view_mode(_interlacer, setSingleView, singleViewIndex);
    }
    void SetSingleViewModeListener(InterlacerSingleViewModeListener const* listener)
    {
        leia_interlacer_set_single_view_mode_listener(_interlacer, listener);
    }
    void SetSourceViewsSize(int32_t sourceWidth, int32_t sourceHeight, bool isHorizontalViews)
    {
        leia_interlacer_set_source_views_size(_interlacer, sourceWidth, sourceHeight, isHorizontalViews);
    }
    void GetSourceViewsSize(int32_t* sourceWidth, int32_t* sourceHeight, bool* isHorizontalViews)
    {
        leia_bool _isHorizontalViews;
        leia_interlacer_get_source_views_size(_interlacer, sourceWidth, sourceHeight, &_isHorizontalViews);
        *isHorizontalViews = bool(_isHorizontalViews);
    }
    void SetSourceMediaIsVideo(bool isVideo)
    {
        leia_interlacer_set_source_media_is_video(_interlacer, isVideo);
    }
    void SetSourceMediaScale(float scaleX, float scaleY)
    {
        leia_interlacer_set_source_media_scale(_interlacer, scaleX, scaleY);
    }
    void SetSourceViewsSRGB(bool isSRGB)
    {
        leia_interlacer_set_source_views_srgb(_interlacer, isSRGB);
    }
    void SetInShaderSRGBConversion(bool sRGBRead, bool sRGBWrite)
    {
        leia_interlacer_set_in_shader_srgb_conversion(_interlacer, sRGBRead, sRGBWrite);
    }
    void SetViewportScreenPosition(int32_t posX, int32_t posY)
    {
        leia_interlacer_set_viewport_screen_position(_interlacer, posX, posY);
    }
    void SetViewport(int32_t posX, int32_t posY, int32_t width, int32_t height)
    {
        leia_interlacer_set_viewport(_interlacer, posX, posY, width, height);
    }
    void EnableReconvergence(bool enable)
    {
        leia_interlacer_enable_reconvergence(_interlacer, enable);
    }
    LEIA_NODISCARD
    bool IsReconvergenceEnabled()
    {
        return bool(leia_interlacer_is_reconvergence_enabled(_interlacer));
    }
 
    LEIA_NODISCARD
    float GetReconvergence(int layer = 0)
    {
        return leia_interlacer_get_reconvergence(_interlacer, layer);
    }
 
    void SetReconvergence(float value, int layer = 0)
    {
        leia_interlacer_set_reconvergence(_interlacer, value, layer);
    }
 
    void SetReconvergenceZoom(bool zoomX, bool zoomXY, int layer = 0)
    {
        leia_interlacer_set_reconvergence_zoom(_interlacer, zoomX, zoomXY, layer);
    }
    void SetUseAtlasForViews(bool useAtlasForViews)
    {
        leia_interlacer_set_use_atlas_for_views(_interlacer, useAtlasForViews);
    }
    LEIA_NODISCARD
    bool GetUseAtlasForViews()
    {
        return bool(leia_interlacer_get_use_atlas_for_views(_interlacer));
    }
    void GetViewOffset(int32_t view, LEIA_FLOAT_SLICE(3) offset)
    {
        leia_interlacer_get_view_offset(_interlacer, view, offset);
    }
    void SetInvertScreenTextureCoordinates(bool invert)
    {
        leia_interlacer_set_invert_screen_texture_coordinates(_interlacer, invert);
    }
 
    LEIA_NODISCARD
    GraphicsAPI GetGraphicsAPI()
    {
        return leia_interlacer_get_graphics_api(_interlacer);
    }
 
    LEIA_NODISCARD
    leia_interlacer* GetHandle() const
    {
        return _interlacer;
    }
 
protected:
    Interlacer(leia_interlacer* interlacer, bool isInterlacerOwned) : _interlacer(interlacer), _isInterlacerOwned(isInterlacerOwned)
    {
#if !defined(LEIA_WRAPPER_DISABLE_EXCEPTION)
        if (!_interlacer)
        {
            throw CoreInitFailed();
        }
#endif // !LEIA_WRAPPER_DISABLE_EXCEPTION
    }
 
protected:
    leia_interlacer* _interlacer;
    bool             _isInterlacerOwned;
};
 
/* See @ref leia_get_experimental_api */
class InterlacerExperimental {
public:
    InterlacerExperimental() : _interlacer(nullptr)
    {
    }
    InterlacerExperimental(leia_core_library* coreLibPtr, Interlacer const& interlacer) : _interlacer(interlacer.GetHandle())
    {
        leia_interlacer_retain(_interlacer);
 
        leia_interlacer_set_calibration_pattern.Load(coreLibPtr);
        leia_interlacer_set_gamma.Load(coreLibPtr);
        leia_interlacer_enable_act.Load(coreLibPtr);
        leia_interlacer_is_act_enabled.Load(coreLibPtr);
        leia_interlacer_init_zone_plate.Load(coreLibPtr);
        leia_interlacer_set_zone_plate.Load(coreLibPtr);
        leia_interlacer_get_zone_plate_results.Load(coreLibPtr);
        leia_interlacer_set_support_circle_phase.Load(coreLibPtr);
        leia_interlacer_write_zone_plate_results.Load(coreLibPtr);
        leia_interlacer_set_camera_rectification_parameters.Load(coreLibPtr);
        leia_interlacer_set_camera_angles.Load(coreLibPtr);
        leia_interlacer_set_dovern.Load(coreLibPtr);
        leia_interlacer_set_n.Load(coreLibPtr);
        leia_interlacer_enable_phase_correction.Load(coreLibPtr);
        leia_interlacer_invert_phase_correction.Load(coreLibPtr);
        leia_interlacer_set_act_coef.Load(coreLibPtr);
        leia_interlacer_get_act_coef.Load(coreLibPtr);
        leia_interlacer_enable_don_correction.Load(coreLibPtr);
        leia_interlacer_initialize_gui.Load(coreLibPtr);
        leia_interlacer_set_gui_visibility.Load(coreLibPtr);
        leia_interlacer_is_gui_visible.Load(coreLibPtr);
        leia_interlacer_process_gui_input_wndproc.Load(coreLibPtr);
        leia_interlacer_process_gui_input_ndk.Load(coreLibPtr);
        leia_interlacer_process_gui_motion_input.Load(coreLibPtr);
        leia_interlacer_shutdown_gui.Load(coreLibPtr);
    }
    InterlacerExperimental(CoreLibrary const& coreLibrary, Interlacer const& interlacer) : InterlacerExperimental(coreLibrary.GetHandle(), interlacer)
    {
    }
    ~InterlacerExperimental()
    {
        if (_interlacer)
            leia_interlacer_release(_interlacer);
    }
    InterlacerExperimental(InterlacerExperimental&& other) : InterlacerExperimental()
    {
        *this = std::move(other);
    }
    InterlacerExperimental& operator=(InterlacerExperimental&& other)
    {
        std::swap(_interlacer, other._interlacer);
        return *this;
    }
    explicit operator bool() const
    {
        return _interlacer != nullptr;
    }
 
    void SetCalibrationPattern(CalibrationPattern pattern)
    {
        if (leia_interlacer_set_calibration_pattern)
            leia_interlacer_set_calibration_pattern(_interlacer, pattern);
    }
    void SetGamma(float rGamma, float gGamma, float bGamma)
    {
        if (leia_interlacer_set_gamma)
            leia_interlacer_set_gamma(_interlacer, rGamma, gGamma, bGamma);
    }
 
    void EnableACT(bool enable)
    {
        if (leia_interlacer_enable_act)
            leia_interlacer_enable_act(_interlacer, enable);
    }
    LEIA_NODISCARD
    bool IsACTEnabled() const
    {
        if (leia_interlacer_is_act_enabled)
            return bool(leia_interlacer_is_act_enabled(_interlacer));
        return true;
    }
 
    bool InitZonePlate(int viewportWidth, int viewportHeight, float* posX, float* posY, float* scaleX, float* scaleY, float* overrideSupportCirclePhase)
    {
        if (leia_interlacer_init_zone_plate)
            return bool(leia_interlacer_init_zone_plate(_interlacer, viewportWidth, viewportHeight, posX, posY, scaleX, scaleY, overrideSupportCirclePhase));
        return false;
    }
    void SetZonePlate(float posX, float posY, float scaleX, float scaleY, float overrideSupportCirclePhase)
    {
        if (leia_interlacer_set_zone_plate)
            leia_interlacer_set_zone_plate(_interlacer, posX, posY, scaleX, scaleY, overrideSupportCirclePhase);
    }
    bool GetZonePlateResults(float* slant, float* pitch, float* phc, float* dOverN, float* n)
    {
        if (leia_interlacer_get_zone_plate_results)
            return bool(leia_interlacer_get_zone_plate_results(_interlacer, slant, pitch, phc, dOverN, n));
        return false;
    }
    void SetSupportCirclePhase(float phase)
    {
        if (leia_interlacer_set_support_circle_phase)
            leia_interlacer_set_support_circle_phase(_interlacer, phase);
    }
    bool WriteZonePlateResults(float slant, float pitch, float phc, float dOverN, float n)
    {
        if (leia_interlacer_write_zone_plate_results)
            return bool(leia_interlacer_write_zone_plate_results(_interlacer, slant, pitch, phc, dOverN, n));
        return false;
    }
    void SetCameraRectificationParameters(bool isFront, float deltaThetaX, float deltaThetaY, float deltaThetaZ, float calibrationTargetDistanceMm)
    {
        if (leia_interlacer_set_camera_rectification_parameters)
            leia_interlacer_set_camera_rectification_parameters(_interlacer, isFront, deltaThetaX, deltaThetaY, deltaThetaZ, calibrationTargetDistanceMm);
    }
    void SetCameraAngles(bool isLeft, float thetaXFpc, float thetaYFpc, float thetaZFpc)
    {
        if (leia_interlacer_set_camera_angles)
            leia_interlacer_set_camera_angles(_interlacer, isLeft, thetaXFpc, thetaYFpc, thetaZFpc);
    }
    void SetDOverN(float dOverN)
    {
        if (leia_interlacer_set_dovern)
            leia_interlacer_set_dovern(_interlacer, dOverN);
    }
    void SetN(float n)
    {
        if (leia_interlacer_set_n)
            leia_interlacer_set_n(_interlacer, n);
    }
    void EnablePhaseCorrection(bool enable)
    {
        if (leia_interlacer_enable_phase_correction)
            leia_interlacer_enable_phase_correction(_interlacer, enable);
    }
    void InvertPhaseCorrection(bool invert)
    {
        if (leia_interlacer_invert_phase_correction)
            leia_interlacer_invert_phase_correction(_interlacer, invert);
    }
    void SetActCoef(float actCoef)
    {
        if (leia_interlacer_set_act_coef)
            leia_interlacer_set_act_coef(_interlacer, actCoef);
    }
    float GetActCoef()
    {
        if (leia_interlacer_get_act_coef)
            return leia_interlacer_get_act_coef(_interlacer);
        return -1;
    }
    void EnableDoNCorrection(bool enable)
    {
        if (leia_interlacer_enable_don_correction)
            leia_interlacer_enable_don_correction(_interlacer, enable);
    }
    void InitializeGui(InterlacerDebugMenuConfiguration const* config, bool sRGB)
    {
        if (leia_interlacer_initialize_gui)
            leia_interlacer_initialize_gui(_interlacer, config, sRGB);
    }
    void SetGuiVisibility(bool isVisible)
    {
        if (leia_interlacer_set_gui_visibility)
            leia_interlacer_set_gui_visibility(_interlacer, isVisible);
    }
    LEIA_NODISCARD
    bool IsGuiVisible()
    {
        if (leia_interlacer_is_gui_visible)
            return bool(leia_interlacer_is_gui_visible(_interlacer));
        return false;
    }
#if defined(LEIA_OS_WINDOWS)
    GuiInputState ProcessGuiInput(void* surface, uint32_t msg, uint64_t wparam, int64_t lparam)
    {
        if (leia_interlacer_process_gui_input_wndproc)
            return leia_interlacer_process_gui_input_wndproc(_interlacer, surface, msg, wparam, lparam);
        return {};
    }
#elif defined(LEIA_OS_ANDROID)
    GuiInputState ProcessGuiInput(AInputEvent const* inputEvent)
    {
        if (leia_interlacer_process_gui_input_ndk)
            return leia_interlacer_process_gui_input_ndk(_interlacer, inputEvent);
        return {};
    }
    GuiInputState ProcessGuiMotionInput(JNIEnv* jni, jobject motionInput)
    {
        if (leia_interlacer_process_gui_motion_input)
            return leia_interlacer_process_gui_motion_input(_interlacer, jni, motionInput);
        return {};
    }
#endif // LEIA_OS_WINDOWS
    void ShutdownGui()
    {
        if (leia_interlacer_shutdown_gui)
            leia_interlacer_shutdown_gui(_interlacer);
    }
 
private:
    leia_interlacer* _interlacer;
 
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_calibration_pattern);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_gamma);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_enable_act);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_is_act_enabled);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_init_zone_plate);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_zone_plate);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_get_zone_plate_results);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_support_circle_phase);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_write_zone_plate_results);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_camera_rectification_parameters);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_camera_angles);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_dovern);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_n);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_enable_phase_correction);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_invert_phase_correction);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_act_coef);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_get_act_coef);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_enable_don_correction);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_initialize_gui);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_set_gui_visibility);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_is_gui_visible);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_process_gui_input_wndproc);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_process_gui_input_ndk);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_process_gui_motion_input);
    LEIA_CXX_DECLARE_EXPERIMENTAL_API_ENTRY(leia_interlacer_shutdown_gui);
};
 
class InterlacerInitConfiguration {
public:
    InterlacerInitConfiguration() : _ptr(leia_interlacer_init_configuration_alloc())
    {
    }
    ~InterlacerInitConfiguration()
    {
        leia_interlacer_init_configuration_free(_ptr);
    }
    InterlacerInitConfiguration(InterlacerInitConfiguration&& other) : _ptr(nullptr)
    {
        *this = std::move(other);
    }
    InterlacerInitConfiguration& operator=(InterlacerInitConfiguration&& other)
    {
        std::swap(_ptr, other._ptr);
        return *this;
    }
    explicit operator bool() const
    {
        return _ptr != nullptr;
    }
 
    void SetIsProtected(bool isProtected)
    {
        leia_interlacer_init_configuration_set_is_protected(_ptr, isProtected);
    }
    void SetUseAtlasForViews(bool useAtlasForViews)
    {
        leia_interlacer_init_configuration_set_use_atlas_for_views(_ptr, useAtlasForViews);
    }
    LEIA_NODISCARD
    leia_interlacer_init_configuration* GetHandle() const
    {
        return _ptr;
    }
 
private:
    leia_interlacer_init_configuration* _ptr;
};
 
using ViewInfoMode = leia_view_info_mode;
 
LEIA_FORCE_INLINE
void GetViewComfortZone(ViewInfoMode mode,
                        float        baselineScaling,
                        float        convergencePlaneDistance,
                        float        nearPlane,
                        float        farPlane,
                        float*       viewComfortZoneNear,
                        float*       viewComfortZoneFar)
{
    leia_get_view_comfort_zone(mode, baselineScaling, convergencePlaneDistance, nearPlane, farPlane, viewComfortZoneNear, viewComfortZoneFar);
}
 
LEIA_FORCE_INLINE
void GetViewInfo(ViewInfoMode mode,
                 LEIA_CONST_FLOAT_SLICE(3) viewOffset,
                 LEIA_CONST_FLOAT_SLICE(3) cameraPos,
                 LEIA_CONST_FLOAT_SLICE(3) cameraDir,
                 LEIA_CONST_FLOAT_SLICE(3) cameraUp,
                 float perspectiveFieldOfView,
                 float perspectiveAspectRatio,
                 float orthoWidth,
                 float orthoHeight,
                 float nearPlane,
                 float farPlane,
                 float convergencePlaneDistance,
                 float convergencePlaneHeight,
                 LEIA_FLOAT_SLICE(3) viewPos,
                 LEIA_FLOAT_SLICE(16) viewProjectionMatrix,
                 float* viewFieldOfView,
                 float* viewShearX,
                 float* viewShearY)
{
    leia_get_view_info(mode,
                       viewOffset,
                       cameraPos,
                       cameraDir,
                       cameraUp,
                       perspectiveFieldOfView,
                       perspectiveAspectRatio,
                       orthoWidth,
                       orthoHeight,
                       nearPlane,
                       farPlane,
                       convergencePlaneDistance,
                       convergencePlaneHeight,
                       viewPos,
                       viewProjectionMatrix,
                       viewFieldOfView,
                       viewShearX,
                       viewShearY);
}
 
} // namespace leia
 
#endif // CNSDK_LEIA_CORE_CXX_INTERLACER_HPP