Mobile 1.19 Reference Guide

/************************************************************************************

Filename    :   VrApi_Types.h
Content     :   Types for minimum necessary API for mobile VR
Created     :   April 30, 2015
Authors     :   J.M.P. van Waveren
Language    :   C99

Copyright   :   Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.

*************************************************************************************/
#ifndef OVR_VrApi_Types_h
#define OVR_VrApi_Types_h

#include <stdbool.h>
#include <stdint.h>
#include "VrApi_Config.h"// needed for VRAPI_EXPORT

//-----------------------------------------------------------------
// Java
//-----------------------------------------------------------------

#if defined( ANDROID )
#include <jni.h>
#elif defined( __cplusplus )
typedefstruct _JNIEnv JNIEnv;
typedefstruct _JavaVM JavaVM;
typedefclass _jobject * jobject;
#else
typedefconststruct JNINativeInterface * JNIEnv;
typedefconststruct JNIInvokeInterface * JavaVM;
typedefvoid * jobject;
#endif

typedefstruct
{
    JavaVM *    Vm;                 //< Java Virtual Machine
    JNIEnv *    Env;                //< Thread specific environment
    jobject     ActivityObject;     //< Java activity object
} ovrJava;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrJava, 12 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrJava, 24 );

//-----------------------------------------------------------------
// Basic Types
//-----------------------------------------------------------------

typedefsignedint ovrResult;

typedefenum ovrSuccessResult_
{
    ovrSuccess                      = 0,
} ovrSuccessResult;

typedefenum ovrErrorResult_
{
    ovrError_MemoryAllocationFailure    = -1000,
    ovrError_NotInitialized             = -1004,
    ovrError_InvalidParameter           = -1005,
    ovrError_DeviceUnavailable          = -1010,    //< device is not connected, or not connected as input device
    ovrError_InvalidOperation           = -1015,

// enums not in CAPI
    ovrError_UnsupportedDeviceType      = -1050,    //< specified device type isn't supported on GearVR
    ovrError_NoDevice                   = -1051,    //< specified device ID does not map to any current device
    ovrError_NotImplemented             = -1052,    //< executed an incomplete code path - this should not be possible in public releases.

    ovrResult_EnumSize                  = 0x7fffffff
} ovrErrorResult;

typedefstruct ovrVector2f_
{
float x, y;
} ovrVector2f;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrVector2f, 8 );

typedefstruct ovrVector3f_
{
float x, y, z;
} ovrVector3f;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrVector3f, 12 );

typedefstruct ovrVector4f_
{
float x, y, z, w;
} ovrVector4f;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrVector4f, 16 );

typedefstruct ovrQuatf_
{
float x, y, z, w;
} ovrQuatf;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrQuatf, 16 );

typedefstruct ovrMatrix4f_
{
float M[4][4];
} ovrMatrix4f;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrMatrix4f, 64 );

typedefstruct ovrPosef_
{
    ovrQuatf    Orientation;
    ovrVector3f Position;
} ovrPosef;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrPosef, 28 );

typedefstruct ovrRectf_
{
float x;
float y;
float width;
float height;
} ovrRectf;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrRectf, 16 );

typedefenum
{
    VRAPI_FALSE = 0,
    VRAPI_TRUE  = 1
} ovrBooleanResult;

typedefenum
{
    VRAPI_EYE_LEFT  = 0,
    VRAPI_EYE_RIGHT = 1,
    VRAPI_EYE_COUNT = 2
} ovrEye;

//-----------------------------------------------------------------
// Structure Types
//-----------------------------------------------------------------

typedefenum
{
    VRAPI_STRUCTURE_TYPE_INIT_PARMS         = 1,
    VRAPI_STRUCTURE_TYPE_MODE_PARMS         = 2,
    VRAPI_STRUCTURE_TYPE_FRAME_PARMS        = 3,
    VRAPI_STRUCTURE_TYPE_MODE_PARMS_VULKAN  = 5,
} ovrStructureType;

//-----------------------------------------------------------------
// System Properties and Status
//-----------------------------------------------------------------

typedefenum
{
    VRAPI_DEVICE_TYPE_GEARVR_START          = 0,

    VRAPI_DEVICE_TYPE_NOTE4                 = VRAPI_DEVICE_TYPE_GEARVR_START,
    VRAPI_DEVICE_TYPE_NOTE5                 = 1,
    VRAPI_DEVICE_TYPE_S6                    = 2,
    VRAPI_DEVICE_TYPE_S7                    = 3,
    VRAPI_DEVICE_TYPE_NOTE7                 = 4,            //< No longer supported.
    VRAPI_DEVICE_TYPE_S8                    = 5,
    VRAPI_DEVICE_TYPE_NOTE8                 = 6,
    VRAPI_DEVICE_TYPE_NOTE7_FE              = 7,            //< Fan Edition
    VRAPI_DEVICE_TYPE_A5_2018               = 8,            //< A8
    VRAPI_DEVICE_TYPE_A7_2018               = 9,            //< A8 Plus
    VRAPI_DEVICE_TYPE_S9                    = 10,
    VRAPI_DEVICE_TYPE_S9_PLUS               = 11,
    VRAPI_DEVICE_TYPE_A8_STAR               = 12,           //< A8 Star
    VRAPI_DEVICE_TYPE_NOTE9                 = 13,

    VRAPI_DEVICE_TYPE_GEARVR_END            = 63,

// Standalone Devices
    VRAPI_DEVICE_TYPE_OCULUSGO_START        = 64,
    VRAPI_DEVICE_TYPE_OCULUSGO              = VRAPI_DEVICE_TYPE_OCULUSGO_START,
    VRAPI_DEVICE_TYPE_MIVR_STANDALONE       = VRAPI_DEVICE_TYPE_OCULUSGO_START + 1, //< China-only SKU
    VRAPI_DEVICE_TYPE_OCULUSGO_END          = 127,

    VRAPI_DEVICE_TYPE_OCULUSQUEST_START     = 256,
    VRAPI_DEVICE_TYPE_OCULUSQUEST           = VRAPI_DEVICE_TYPE_OCULUSQUEST_START + 3,
    VRAPI_DEVICE_TYPE_OCULUSQUEST_END       = 319,


    VRAPI_DEVICE_TYPE_UNKNOWN               = -1,
} ovrDeviceType;

typedefenum
{
    VRAPI_HEADSET_TYPE_R320                 = 0,            //< Note4 Innovator
    VRAPI_HEADSET_TYPE_R321                 = 1,            //< S6 Innovator
    VRAPI_HEADSET_TYPE_R322                 = 2,            //< Commercial 1
    VRAPI_HEADSET_TYPE_R323                 = 3,            //< Commercial 2 (USB Type C)
    VRAPI_HEADSET_TYPE_R324                 = 4,            //< Commercial 3 (USB Type C)
    VRAPI_HEADSET_TYPE_R325                 = 5,            //< Commercial 4 2017 (USB Type C)

// Standalone Headsets
    VRAPI_HEADSET_TYPE_OCULUSGO             = 64,           //< Oculus Go
    VRAPI_HEADSET_TYPE_MIVR_STANDALONE      = 65,           //< China-only SKU

    VRAPI_HEADSET_TYPE_OCULUSQUEST          = 256,

    VRAPI_HEADSET_TYPE_UNKNOWN              = -1,
} ovrHeadsetType;

typedefenum
{
    VRAPI_DEVICE_REGION_UNSPECIFIED = 0,
    VRAPI_DEVICE_REGION_JAPAN       = 1,
    VRAPI_DEVICE_REGION_CHINA       = 2,
} ovrDeviceRegion;

typedefenum
{
    VRAPI_VIDEO_DECODER_LIMIT_4K_30FPS  = 0,
    VRAPI_VIDEO_DECODER_LIMIT_4K_60FPS  = 1,
} ovrVideoDecoderLimit;

typedefenum
{
    VRAPI_SYS_PROP_DEVICE_TYPE                              = 0,
    VRAPI_SYS_PROP_MAX_FULLSPEED_FRAMEBUFFER_SAMPLES        = 1,
    VRAPI_SYS_PROP_DISPLAY_PIXELS_WIDE                      = 2,
    VRAPI_SYS_PROP_DISPLAY_PIXELS_HIGH                      = 3,
    VRAPI_SYS_PROP_DISPLAY_REFRESH_RATE                     = 4,
    VRAPI_SYS_PROP_SUGGESTED_EYE_TEXTURE_WIDTH              = 5,
    VRAPI_SYS_PROP_SUGGESTED_EYE_TEXTURE_HEIGHT             = 6,
    VRAPI_SYS_PROP_SUGGESTED_EYE_FOV_DEGREES_X              = 7,
    VRAPI_SYS_PROP_SUGGESTED_EYE_FOV_DEGREES_Y              = 8,
    VRAPI_SYS_PROP_EXT_SDCARD_PATH                          = 9,
    VRAPI_SYS_PROP_DEVICE_REGION                            = 10,
    VRAPI_SYS_PROP_VIDEO_DECODER_LIMIT                      = 11,
    VRAPI_SYS_PROP_HEADSET_TYPE                             = 12,

// enum 13 used to be VRAPI_SYS_PROP_BACK_BUTTON_SHORTPRESS_TIME
// enum 14 used to be VRAPI_SYS_PROP_BACK_BUTTON_DOUBLETAP_TIME

    VRAPI_SYS_PROP_DOMINANT_HAND                            = 15,

    VRAPI_SYS_PROP_NUM_SUPPORTED_DISPLAY_REFRESH_RATES      = 64,
    VRAPI_SYS_PROP_SUPPORTED_DISPLAY_REFRESH_RATES          = 65,

    VRAPI_SYS_PROP_NUM_SUPPORTED_SWAPCHAIN_FORMATS          = 66,
    VRAPI_SYS_PROP_SUPPORTED_SWAPCHAIN_FORMATS              = 67,

    VRAPI_SYS_PROP_MULTIVIEW_AVAILABLE                      = 128,
    VRAPI_SYS_PROP_SRGB_LAYER_SOURCE_AVAILABLE              = 129,

    VRAPI_SYS_PROP_FOVEATION_AVAILABLE                      = 130,
} ovrSystemProperty;

typedefenum
{
    VRAPI_FOVEATION_LEVEL               = 15,       //< Used by apps that want to control swapchain foveation levels.
    VRAPI_REORIENT_HMD_ON_CONTROLLER_RECENTER   = 17,       //< Used to determine if a controller recenter should also reorient the headset.
    VRAPI_LATCH_BACK_BUTTON_ENTIRE_FRAME        = 18,       //< Used to determine if the 'short press' back button should lasts an entire frame.
    VRAPI_BLOCK_REMOTE_BUTTONS_WHEN_NOT_EMULATING_HMT   =19,//< Used to not send the remote back button java events to the apps.
    VRAPI_EAT_NATIVE_GAMEPAD_EVENTS     = 20,               //< Used to tell the runtime not to eat gamepad events.  If this is false on a native app, the app must be listening for the events.
} ovrProperty;


typedefenum
{
    VRAPI_HAND_UNKNOWN  = 0,
    VRAPI_HAND_LEFT     = 1,
    VRAPI_HAND_RIGHT    = 2
} ovrHandedness;

typedefenum
{
    VRAPI_SYS_STATUS_DOCKED                         = 0,    //< Device is docked.
    VRAPI_SYS_STATUS_MOUNTED                        = 1,    //< Device is mounted.
    VRAPI_SYS_STATUS_THROTTLED                      = 2,    //< Device is in powersave mode.

// enum  3 used to be VRAPI_SYS_STATUS_THROTTLED2.

// enum  4 used to be VRAPI_SYS_STATUS_THROTTLED_WARNING_LEVEL.

    VRAPI_SYS_STATUS_RENDER_LATENCY_MILLISECONDS    = 5,    //< Average time between render tracking sample and scanout.
    VRAPI_SYS_STATUS_TIMEWARP_LATENCY_MILLISECONDS  = 6,    //< Average time between timewarp tracking sample and scanout.
    VRAPI_SYS_STATUS_SCANOUT_LATENCY_MILLISECONDS   = 7,    //< Average time between Vsync and scanout.
    VRAPI_SYS_STATUS_APP_FRAMES_PER_SECOND          = 8,    //< Number of frames per second delivered through vrapi_SubmitFrame.
    VRAPI_SYS_STATUS_SCREEN_TEARS_PER_SECOND        = 9,    //< Number of screen tears per second (per eye).
    VRAPI_SYS_STATUS_EARLY_FRAMES_PER_SECOND        = 10,   //< Number of frames per second delivered a whole display refresh early.
    VRAPI_SYS_STATUS_STALE_FRAMES_PER_SECOND        = 11,   //< Number of frames per second delivered late.

// enum 12 used to be VRAPI_SYS_STATUS_HEADPHONES_PLUGGED_IN

    VRAPI_SYS_STATUS_RECENTER_COUNT                 = 13,   //< Returns the current HMD recenter count. Defaults to 0.
    VRAPI_SYS_STATUS_SYSTEM_UX_ACTIVE               = 14,   //< Returns VRAPI_TRUE if a system UX layer is active

    VRAPI_SYS_STATUS_FRONT_BUFFER_PROTECTED         = 128,  //< VRAPI_TRUE if the front buffer is allocated in TrustZone memory.
    VRAPI_SYS_STATUS_FRONT_BUFFER_565               = 129,  //< VRAPI_TRUE if the front buffer is 16-bit 5:6:5
    VRAPI_SYS_STATUS_FRONT_BUFFER_SRGB              = 130,  //< VRAPI_TRUE if the front buffer uses the sRGB color space.

} ovrSystemStatus;

//-----------------------------------------------------------------
// Initialization
//-----------------------------------------------------------------

typedefenum
{
    VRAPI_INITIALIZE_SUCCESS                =  0,
    VRAPI_INITIALIZE_UNKNOWN_ERROR          = -1,
    VRAPI_INITIALIZE_PERMISSIONS_ERROR      = -2,
    VRAPI_INITIALIZE_ALREADY_INITIALIZED    = -3
} ovrInitializeStatus;

typedefenum
{
    VRAPI_GRAPHICS_API_TYPE_ES       = 0x10000,
    VRAPI_GRAPHICS_API_OPENGL_ES_2   = ( VRAPI_GRAPHICS_API_TYPE_ES | 0x0200 ),     //< OpenGL ES 2.x context
    VRAPI_GRAPHICS_API_OPENGL_ES_3   = ( VRAPI_GRAPHICS_API_TYPE_ES | 0x0300 ),     //< OpenGL ES 3.x context

    VRAPI_GRAPHICS_API_TYPE_OPENGL   = 0x20000,
    VRAPI_GRAPHICS_API_OPENGL_COMPAT = ( VRAPI_GRAPHICS_API_TYPE_OPENGL | 0x0100 ), //< OpenGL Compatibility Profile
    VRAPI_GRAPHICS_API_OPENGL_CORE_3 = ( VRAPI_GRAPHICS_API_TYPE_OPENGL | 0x0300 ), //< OpenGL Core Profile 3.x
    VRAPI_GRAPHICS_API_OPENGL_CORE_4 = ( VRAPI_GRAPHICS_API_TYPE_OPENGL | 0x0400 ), //< OpenGL Core Profile 4.x

    VRAPI_GRAPHICS_API_TYPE_VULKAN   = 0x40000,
    VRAPI_GRAPHICS_API_VULKAN_1      = ( VRAPI_GRAPHICS_API_TYPE_VULKAN | 0x0100 ), //< Vulkan 1.x
} ovrGraphicsAPI;

typedefstruct
{
    ovrStructureType    Type;
int                 ProductVersion;
int                 MajorVersion;
int                 MinorVersion;
int                 PatchVersion;
    ovrGraphicsAPI      GraphicsAPI;
    ovrJava             Java;
} ovrInitParms;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrInitParms, 36 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrInitParms, 48 );


//-----------------------------------------------------------------
// VR Mode
//-----------------------------------------------------------------

typedefenum
{
    VRAPI_MODE_FLAG_ALLOW_POWER_SAVE            = 0x000000FF,

    VRAPI_MODE_FLAG_RESET_WINDOW_FULLSCREEN     = 0x0000FF00,

    VRAPI_MODE_FLAG_NATIVE_WINDOW               = 0x00010000,

    VRAPI_MODE_FLAG_FRONT_BUFFER_PROTECTED      = 0x00020000,

    VRAPI_MODE_FLAG_FRONT_BUFFER_565            = 0x00040000,

    VRAPI_MODE_FLAG_FRONT_BUFFER_SRGB           = 0x00080000,

    VRAPI_MODE_FLAG_CREATE_CONTEXT_NO_ERROR     = 0x00100000
} ovrModeFlags;

typedefstruct
{
    ovrStructureType    Type;

unsignedint        Flags;

    ovrJava             Java;

    OVR_VRAPI_PADDING_32_BIT( 4 );

unsignedlonglong  Display;

unsignedlonglong  WindowSurface;

unsignedlonglong  ShareContext;
} ovrModeParms;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrModeParms, 48 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrModeParms, 56 );

typedefstruct
{
    ovrModeParms        ModeParms;

unsignedlonglong  SynchronizationQueue;
} ovrModeParmsVulkan;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrModeParmsVulkan, 56 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrModeParmsVulkan, 64 );

typedefstruct ovrMobile ovrMobile;

//-----------------------------------------------------------------
// Tracking
//-----------------------------------------------------------------

typedefstruct ovrRigidBodyPosef_
{
    ovrPosef        Pose;
    ovrVector3f     AngularVelocity;
    ovrVector3f     LinearVelocity;
    ovrVector3f     AngularAcceleration;
    ovrVector3f     LinearAcceleration;
    OVR_VRAPI_PADDING( 4 );
double          TimeInSeconds;          //< Absolute time of this pose.
double          PredictionInSeconds;    //< Seconds this pose was predicted ahead.
} ovrRigidBodyPosef;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrRigidBodyPosef, 96 );

typedefenum
{
    VRAPI_TRACKING_STATUS_ORIENTATION_TRACKED   = 1 << 0,   //< Orientation is currently tracked.
    VRAPI_TRACKING_STATUS_POSITION_TRACKED      = 1 << 1,   //< Position is currently tracked.
    VRAPI_TRACKING_STATUS_HMD_CONNECTED         = 1 << 7    //< HMD is available & connected.
} ovrTrackingStatus;

typedefstruct ovrTracking2_
{
unsignedint        Status;

    OVR_VRAPI_PADDING( 4 );

    ovrRigidBodyPosef   HeadPose;
struct
    {
        ovrMatrix4f         ProjectionMatrix;
        ovrMatrix4f         ViewMatrix;
    } Eye[ VRAPI_EYE_COUNT ];
} ovrTracking2;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrTracking2, 360 );

typedefstruct ovrTracking_
{
unsignedint        Status;

    OVR_VRAPI_PADDING( 4 );

    ovrRigidBodyPosef   HeadPose;
} ovrTracking;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrTracking, 104 );

typedefenum
{
    VRAPI_TRACKING_TRANSFORM_IDENTITY                   = 0,
    VRAPI_TRACKING_TRANSFORM_CURRENT                    = 1,
    VRAPI_TRACKING_TRANSFORM_SYSTEM_CENTER_EYE_LEVEL    = 2,
    VRAPI_TRACKING_TRANSFORM_SYSTEM_CENTER_FLOOR_LEVEL  = 3,
} ovrTrackingTransform;

typedefenum
{
    VRAPI_TRACKED_DEVICE_NONE           = -1,
    VRAPI_TRACKED_DEVICE_HMD            = 0,    //< Headset
    VRAPI_TRACKED_DEVICE_HAND_LEFT      = 1,    //< Left controller
    VRAPI_TRACKED_DEVICE_HAND_RIGHT     = 2,    //< Right controller
    VRAPI_NUM_TRACKED_DEVICES           = 3,
} ovrTrackedDeviceTypeId;

typedefstruct ovrBoundaryTriggerResult_
{
    ovrVector3f             closestPoint;

    ovrVector3f             closestPointNormal;

float                   closestDistance;

bool                    isTriggering;
} ovrBoundaryTriggerResult;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrBoundaryTriggerResult, 32 );

//-----------------------------------------------------------------
// Texture Swap Chain
//-----------------------------------------------------------------

typedefenum
{
    VRAPI_TEXTURE_TYPE_2D           = 0,    //< 2D textures.
    VRAPI_TEXTURE_TYPE_2D_ARRAY     = 2,    //< Texture array.
    VRAPI_TEXTURE_TYPE_CUBE         = 3,    //< Cube maps.
    VRAPI_TEXTURE_TYPE_MAX          = 4,
} ovrTextureType;

typedefenum
{
    VRAPI_TEXTURE_FORMAT_NONE               = 0,
    VRAPI_TEXTURE_FORMAT_565                = 1,
    VRAPI_TEXTURE_FORMAT_5551               = 2,
    VRAPI_TEXTURE_FORMAT_4444               = 3,
    VRAPI_TEXTURE_FORMAT_8888               = 4,
    VRAPI_TEXTURE_FORMAT_8888_sRGB          = 5,
    VRAPI_TEXTURE_FORMAT_RGBA16F            = 6,
    VRAPI_TEXTURE_FORMAT_DEPTH_16           = 7,
    VRAPI_TEXTURE_FORMAT_DEPTH_24           = 8,
    VRAPI_TEXTURE_FORMAT_DEPTH_24_STENCIL_8 = 9,

} ovrTextureFormat;

typedefenum
{
    VRAPI_DEFAULT_TEXTURE_SWAPCHAIN                 = 0x1,
    VRAPI_DEFAULT_TEXTURE_SWAPCHAIN_LOADING_ICON    = 0x2
} ovrDefaultTextureSwapChain;

typedefstruct ovrTextureSwapChain ovrTextureSwapChain;

//-----------------------------------------------------------------
// Frame Submission
//-----------------------------------------------------------------

typedefenum
{
// enum 1 << 0 used to be VRAPI_FRAME_FLAG_INHIBIT_SRGB_FRAMEBUFFER. See per-layer
// flag VRAPI_FRAME_LAYER_FLAG_INHIBIT_SRGB_FRAMEBUFFER.

    VRAPI_FRAME_FLAG_FLUSH                                                      = 1 << 1,
    VRAPI_FRAME_FLAG_FINAL                                                      = 1 << 2,




    VRAPI_FRAME_FLAG_INHIBIT_VOLUME_LAYER                                       = 1 << 6,



} ovrFrameFlags;

typedefenum
{

    VRAPI_FRAME_LAYER_FLAG_CHROMATIC_ABERRATION_CORRECTION                      = 1 << 1,
    VRAPI_FRAME_LAYER_FLAG_FIXED_TO_VIEW                                        = 1 << 2,
    VRAPI_FRAME_LAYER_FLAG_SPIN                                                 = 1 << 3,
    VRAPI_FRAME_LAYER_FLAG_CLIP_TO_TEXTURE_RECT                                 = 1 << 4,

    VRAPI_FRAME_LAYER_FLAG_INHIBIT_SRGB_FRAMEBUFFER                             = 1 << 8,


} ovrFrameLayerFlags;

typedefenum
{
    VRAPI_FRAME_LAYER_EYE_LEFT      = 0,
    VRAPI_FRAME_LAYER_EYE_RIGHT     = 1,
    VRAPI_FRAME_LAYER_EYE_MAX       = 2
} ovrFrameLayerEye;

typedefenum
{
    VRAPI_FRAME_LAYER_BLEND_ZERO                    = 0,
    VRAPI_FRAME_LAYER_BLEND_ONE                     = 1,
    VRAPI_FRAME_LAYER_BLEND_SRC_ALPHA               = 2,
    VRAPI_FRAME_LAYER_BLEND_ONE_MINUS_SRC_ALPHA     = 5
} ovrFrameLayerBlend;

typedefenum
{
    VRAPI_EXTRA_LATENCY_MODE_OFF        = 0,
    VRAPI_EXTRA_LATENCY_MODE_ON         = 1,
    VRAPI_EXTRA_LATENCY_MODE_DYNAMIC    = 2
} ovrExtraLatencyMode;

//-------------------------------------
// Legacy monolithic FrameParm submission structures for vrapi_SubmitFrame.
//-------------------------------------

typedefenum
{
    VRAPI_FRAME_LAYER_TYPE_MAX  = 4
} ovrFrameLayerType;

typedefstruct
{
    ovrTextureSwapChain *   ColorTextureSwapChain;

    ovrTextureSwapChain *   DepthTextureSwapChain;

int                     TextureSwapChainIndex;

    ovrMatrix4f             TexCoordsFromTanAngles;

    ovrRectf                TextureRect;

    OVR_VRAPI_PADDING( 4 );

    ovrRigidBodyPosef       HeadPose;

unsignedlonglong      CompletionFence_DEPRECATED;
} ovrFrameLayerTexture;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrFrameLayerTexture, 200 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrFrameLayerTexture, 208 );

typedefstruct
{
    ovrFrameLayerTexture    Textures[VRAPI_FRAME_LAYER_EYE_MAX];

float                   SpinSpeed;  //< Radians/Second
float                   SpinScale;

float                   ColorScale;

    OVR_VRAPI_PADDING( 4 );

    ovrFrameLayerBlend      SrcBlend;
    ovrFrameLayerBlend      DstBlend;

int                     Flags;
} ovrFrameLayer;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrFrameLayer, 432 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrFrameLayer, 448 );

typedefstruct
{
int                     CpuLevel;
int                     GpuLevel;

int                     MainThreadTid;
int                     RenderThreadTid;
} ovrPerformanceParms;

OVR_VRAPI_ASSERT_TYPE_SIZE( ovrPerformanceParms, 16 );

typedefstruct
{
    ovrStructureType        Type;

    OVR_VRAPI_PADDING( 4 );

    ovrFrameLayer           Layers[VRAPI_FRAME_LAYER_TYPE_MAX];
int                     LayerCount;

int                     Flags;

longlong               FrameIndex;

int                     SwapInterval;

    ovrExtraLatencyMode     ExtraLatencyMode;

    ovrMatrix4f             ExternalVelocity;

void *                  Reserved;

    ovrPerformanceParms     PerformanceParms;

    ovrJava                 Java;
} ovrFrameParms;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrFrameParms, 1856 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrFrameParms, 1936 );

//-------------------------------------
// Flexible Layer Type structures for vrapi_SubmitFrame2.
//-------------------------------------

enum
{
    ovrMaxLayerCount = 16
};

typedefenum ovrLayerType2_
{
    VRAPI_LAYER_TYPE_PROJECTION2            = 1,
    VRAPI_LAYER_TYPE_CYLINDER2              = 3,
    VRAPI_LAYER_TYPE_CUBE2                  = 4,
    VRAPI_LAYER_TYPE_EQUIRECT2              = 5,
    VRAPI_LAYER_TYPE_LOADING_ICON2          = 6,
} ovrLayerType2;

typedefstruct ovrLayerHeader2_
{
    ovrLayerType2       Type;
    uint32_t            Flags;

    ovrVector4f         ColorScale;
    ovrFrameLayerBlend  SrcBlend;
    ovrFrameLayerBlend  DstBlend;

void *              Reserved;
} ovrLayerHeader2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrLayerHeader2, 36 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrLayerHeader2, 40 );

typedefstruct
{
    ovrLayerHeader2         Header;

    ovrRigidBodyPosef       HeadPose;

struct
    {
        ovrTextureSwapChain * ColorSwapChain;
int                 SwapChainIndex;
        ovrMatrix4f         TexCoordsFromTanAngles;
        ovrRectf            TextureRect;
    } Textures[VRAPI_FRAME_LAYER_EYE_MAX];
} ovrLayerProjection2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrLayerProjection2, 312 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrLayerProjection2, 328 );

typedefstruct
{
    ovrLayerHeader2         Header;

    ovrRigidBodyPosef       HeadPose;

struct
    {
        ovrTextureSwapChain * ColorSwapChain;
int                 SwapChainIndex;
        ovrMatrix4f         TexCoordsFromTanAngles;
        ovrRectf            TextureRect;
        ovrMatrix4f         TextureMatrix;
    } Textures[VRAPI_FRAME_LAYER_EYE_MAX];
} ovrLayerCylinder2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrLayerCylinder2, 440 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrLayerCylinder2, 456 );

typedefstruct
{
    ovrLayerHeader2         Header;

    ovrRigidBodyPosef       HeadPose;
    ovrMatrix4f             TexCoordsFromTanAngles;

    ovrVector3f             Offset;

struct
    {
        ovrTextureSwapChain * ColorSwapChain;
int                 SwapChainIndex;
    } Textures[VRAPI_FRAME_LAYER_EYE_MAX];
} ovrLayerCube2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrLayerCube2, 232 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrLayerCube2, 248 );

typedefstruct
{
    ovrLayerHeader2         Header;

    ovrRigidBodyPosef       HeadPose;
    ovrMatrix4f             TexCoordsFromTanAngles;

struct
    {
        ovrTextureSwapChain * ColorSwapChain;
int                 SwapChainIndex;
        ovrRectf            TextureRect;
        ovrMatrix4f         TextureMatrix;
    } Textures[VRAPI_FRAME_LAYER_EYE_MAX];
} ovrLayerEquirect2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrLayerEquirect2, 376 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrLayerEquirect2, 392 );

typedefstruct
{
    ovrLayerHeader2         Header;

float                   SpinSpeed;              //< radians per second
float                   SpinScale;

    ovrTextureSwapChain *   ColorSwapChain;
int                     SwapChainIndex;
} ovrLayerLoadingIcon2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrLayerLoadingIcon2, 52 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrLayerLoadingIcon2, 64 );


typedefunion
{
    ovrLayerHeader2         Header;
    ovrLayerProjection2     Projection;
    ovrLayerCylinder2       Cylinder;
    ovrLayerCube2           Cube;
    ovrLayerEquirect2       Equirect;
    ovrLayerLoadingIcon2    LoadingIcon;
} ovrLayer_Union2;

typedefstruct ovrSubmitFrameDescription2_
{
    uint32_t            Flags;
    uint32_t            SwapInterval;
    uint64_t            FrameIndex;
double              DisplayTime;
unsignedlonglong  CompletionFence_DEPRECATED;
    uint32_t            LayerCount;
const ovrLayerHeader2 * const * Layers;
} ovrSubmitFrameDescription2;

OVR_VRAPI_ASSERT_TYPE_SIZE_32_BIT( ovrSubmitFrameDescription2, 40 );
OVR_VRAPI_ASSERT_TYPE_SIZE_64_BIT( ovrSubmitFrameDescription2, 48 );

//-----------------------------------------------------------------
// Performance
//-----------------------------------------------------------------

typedefenum
{
    VRAPI_PERF_THREAD_TYPE_MAIN         = 0,
    VRAPI_PERF_THREAD_TYPE_RENDERER     = 1,
} ovrPerfThreadType;

#endif  // OVR_VrApi_Types_h