• New apps must use OpenXR unless a waiver is granted.
• New apps will not have access to Meta Native Mobile APIs, but existing apps can continue using them.
• No assistance will be provided for creating new apps with Meta Native APIs. You will find recommendations for migrating existing apps to OpenXR in the developer guides.
• Only critical security, privacy, or safety issues in Meta Native APIs will be addressed.
• Any testing of Meta Native Mobile will be restricted to automated QA tests, only to ensure core features remain functional.

Note: This archive covers up to Mobile SDK 1.22.0. For later releases, see Mobile Native Migration.

• A new ovrProperty, VRAPI_ACTIVE_INPUT_DEVICE_ID, was added to query the device ID of the primary or most active input device.
• A new ovrTrackingSpace, VRAPI_TRACKING_SPACE_LOCAL_TILTED, was added for applications that support “bed mode.”” This space defines the tilted orientation a user would like their content displayed in.
• A new ovrTrackingSpace, VRAPI_TRACKING_SPACE_STAGE, was added. This space has its origin on the floor at the center of the play area with its forward direction pointed towards one of the edges of the bounding box.
• A new ovrTrackingSpace, VRAPI_TRACKING_SPACE_LOCAL_FIXED_YAW, was added. In this space, the origin is the same as local space, however the yaw remains fixed to the physical environment. This space may be useful for swivel-chair roaming games.
• Deprecated ovrFrameParms parameter ExternalVelocity has been removed from the API.

• Added new Tracking Space API consisting of vrapi_GetTrackingSpace, vrapi_SetTrackingSpace, and vrapi_LocateTrackingSpace.
• vrapi_GetTrackingTransform and vrapi_SetTrackingTransform are marked deprecated and should no longer be used. Instead, the application should use the new Tracking Space API.
• vrapi_RecenterPose has been marked deprecated and should no longer be used.
• For applications built with VrApi 1.21.0 or higher, all Guardian boundary-related API queries (for example, vrapi_GetBoundaryGeometry, vrapi_GetBoundaryOrientedBoundingBox, and so on) now return boundary status that can include ovrSuccess_BoundaryInvalid when no boundary is available.

ovrPosef trackingTransform = vrapi_GetTrackingTransform( ovr, VRAPI_TRACKING_TRANFORM_SYSTEM_CENTER_EYE_LEVEL );
vrapi_SetTrackingTransform( ovr, trackingTransform );

vrapi_SetTrackingSpace( ovr, VRAPI_TRACKING_SPACE_LOCAL );

vrapi_SetTrackingSpace( ovr, VRAPI_TRACKING_SPACE_LOCAL_FLOOR );

• vrapi_DefaultLayerEquirect2 and vrapi_DefaultLayerCube2 helper functions now return an identity TexCoordFromTanAngles matrix by default.
• Deprecated Completion Fence has been removed from the API.
• Deprecated ovrButton_Menu has been removed from the API.

• There are no developer-facing changes in this release.

• This release provides support for the Samsung Galaxy Note 9 smartphone.

• Added Samsung Galaxy Note 9 Device Type to the API.
• Explicit completion fences are now marked deprecated and will be removed in a future SDK.
• Deprecated vrapi_SetTextureSwapchainHandle has been removed from the API.
• Deprecated ovrTextureSwapChain type VRAPI_TEXTURE_TYPE_2D_EXTERNAL has been removed from the API.
• Deprecated ovrLayerHeader parameter SurfaceTextureObject_DEPRECATED has been removed from the API.

• There are no developer-facing changes in this release.

• Android gamepad events will now be eaten in the lower level system, since they are exposed through the Input API. This behavior can be changed by setting the ovrProperty VRAPI_EAT_NATIVE_GAMEPAD_EVENTS to false. If this property is set to false on native activity apps, they must handle the events.
• The default behavior for recenter is to additionally recenter the headset for applications built with 1.16.0 and higher. This behavior can be disabled by setting the ovrProperty VRAPI_REORIENT_HMD_ON_CONTROLLER_RECENTER to false.
• VrApi Vulkan entry points and structure types are now exposed. See the new VrCubeWorld_Vulkan sample for example API usage.

• Added Samsung A8 Star Device Type to the API.
• Added a new entry point, vrapi_SetTextureSwapChain3, for creating a texture SwapChain by passing a platform specific texture format instead of the ovrTextureFormat type. The available formats may be queried by passing VRAPI_SYS_PROP_SUPPORTED_SWAPCHAIN_FORMATS to vrapi_GetSystemPropertyInt64Array.
• vrapi_SetTextureSwapChainHandle has been marked deprecated and should no longer be used.
• Deprecated ovrFrameLayerFlags flag, VRAPI_FRAME_LAYER_FLAG_WRITE_ALPHA, and corresponding ovrFrameLayerBlend blend modes, VRAPI_FRAME_LAYER_BLEND_DST_ALPHA and VRAPI_FRAME_LAYER_BLEND_ONE_MINUS_DST_ALPHA, have been removed from the API.
• Added new entry points for creating and obtaining a cross-process friendly Android Surface SwapChain, vrapi_CreateAndroidSurfaceSwapChain and vrapi_GetTextureSwapChainAndroidSurface.
• ovrTextureTypeVRAPI_TEXTURE_TYPE_2D_EXTERNAL and corresponding ovrLayerHeader2SurfaceTextureObject are marked deprecated and should no longer be used. Instead the application should use the new cross-process friendly Android Surface texture SwapChain creation method, vrapi_CreateAndroidSurfaceSwapChain.
• ovrSystemPropertyVRAPI_SYS_PROP_BACK_BUTTON_SHORTPRESS_TIME has been removed as it should no longer be necessary when using the Input API.
• Emulation of the remote controllers as a headset now defaults to false for applications built with 1.15.0 and higher, as applications are expected to use the Input API for querying remote and headset input. To maintain the old behavior, pass false to vrapi_SetRemoteEmulation.
• Remote controllers will no longer send Java input events when headset emulation is off. This behavior can be changed by setting the ovrPropertyVRAPI_BLOCK_REMOTE_BUTTONS_WHEN_NOT_EMULATING_HMT to true.
• When a back button press is detected, the Input API now reports the back button as down for an entire frame instead of only for the next input query. This behavior can be changed by setting the ovrPropertyVRAPI_LATCH_BACK_BUTTON_ENTIRE_FRAME to false.

• Instead of an event-based Java input system, the VrApi Input API is a C-based polling input system.
• Similar to the way the tracking pose of the remote and headset are queried per frame, the button states of the input devices can be queried per frame.

• vrapi_Initialize can now return a new error code on failure, VRAPI_INITIALIZE_ALREADY_INITIALIZED.
• Added Samsung s9 Device Types to the API.
• VRAPI_FRAME_FLAG_INHIBIT_SRGB_FRAMEBUFFER has been deprecated in favor of using the per-layer flag VRAPI_FRAME_LAYER_FLAG_INHIBIT_SRGB_FRAMEBUFFER.
• Input API now exposes and enumerates Gamepads.
• vrapi_ReturnToHome has been removed.
• vrapi_ShowSystemUIWithExtra is marked deprecated and should no longer be used.
• VRAPI_REORIENT_HMD_ON_CONTROLLER_RECENTER property provided to allow apps the ability to opt into a behavior that combines the controller re-center action with reorienting the headset. To enable this, set the property to 1 using vrapi_SetPropertyInt. This feature is disabled by default.

• The new enumeration for the gamepad is ovrControllerType_Gamepad.
• The capabilities struct is ovrInputGamepadCapabilities.
• The input state struct is ovrInputStateGamepad.
• The queries are handled in the same way as the tracked remote, and the headset, using:
  • vrapi_enumerateInputDevices
  • vrapi_GetInputDeviceCapabilities
  • vrapi_GetCurrentInputState

for ( int i = 0; ; i++ )
{
  ovrInputCapabilityHeader cap;
  ovrResult result = vrapi_EnumerateInputDevices( app->Ovr, i, &cap );
  if ( result < 0 )
  {
    Break;
  }

  if ( cap.Type == ovrControllerType_Gamepad )
  {
    ovrInputStateGamepad gamepadState;
    gamepadState.Header.ControllerType = ovrControllerType_Gamepad;
    result = vrapi_GetCurrentInputState( app->Ovr, i, &gamepadState.Header );
    if ( result == ovrSuccess )
    {
      backButtonDownThisFrame |= gamepadState.Buttons & ovrButton_Back;
      aButtonDownThisFrame |= gamepadState.Buttons & ovrButton_A;
      rightTriggerValueThisFrame = gamepadState.RightTrigger;
      leftJoystickValueThisFrame = gamepadState.LeftJoyStick;
    }
    break;
  }
}

• Android NDK r16b
• Gradle 4.3.1
• Android Plugin for Gradle 3.0.1
• Android SDK Build-Tools 26.0.2

• Added a mechanism to specify the Foveation Level for the Eye-Buffer SwapChain Textures.
• Added a new ovrModeFlags flag, VRAPI_MODE_FLAG_CREATE_CONTEXT_NO_ERROR, to support applications which want to create a no-error GL context.
• VRAPI_TEXTURE_SWAPCHAIN_FULL_MIP_CHAIN has been removed. Applications will need to explicitly pass in the number of mipLevels on SwapChain creation.
• Controllers are now affected by the application-specified tracking transform.
• The SwapChain represented by VRAPI_DEFAULT_TEXTURE_SWAPCHAIN now defaults to white instead of black. This is to support solid color frames of more than just black. The application layer’s ColorScale parameter will determine the solid color used.
• The ovrMobile structure will now always be freed on vrapi_LeaveVrMode.
• Applications are now required to pass through explicit EGL objects (Display, ShareContext, NativeWindow) to vrapi_EnterVrMode, otherwise the call will fail.
• VRAPI_SYS_PROP_BACK_BUTTON_DOUBLETAP_TIME has been removed. If applications implement double-tap logic, they can still detect this by checking if the time is less than the VRAPI_SYS_PROP_BACK_BUTTON_SHORTPRESS_TIME.

vrapi_SetPropertyInt( &Java, VRAPI_FOVEATION_LEVEL, level );

• Level = 0 disables multi-resolution
• Level = 1 low setting (good image quality, not as good performance gains)
• Level = 2 medium setting
• Level = 3 maximum setting

• We recommend NDK version r15c. With NDK r15, app_dummy is now deprecated in favor of force exporting ANativeActivity_onCreate.
• Pre-built libraries are no longer provided by default for the VrAppFramework and VrAppSupport libraries. If your application build files are relying on the pre-built libraries, you will need to change your build files to reference the library’s build path as Projects/Android instead of Projects/AndroidPrebuilt.

• This version adds a new entry point, vrapi_SubmitFrame2, which adds support for flexible layer lists, new layer types, and a single fence to signal completion for the frame. This new frame submission API no longer takes performance parameters as input, and therefore, the new performance API should be used when moving to this path.
• New entry points were added for specifying performance parameters:
  • vrapi_SetClockLevels
  • vrapi_SetPerfThread
  • vrapi_SetExtraLatencyMode
• ovrHeadModelParms and corresponding helper functions were removed from the API. Applications should no longer apply the head model to the tracking head pose as this is done by the VrApi runtime.
• New entry points for specifying a user-defined tracking transform have been added. The default tracking transform is Eye-Level.
• vrapi_RecenterInputPose has been marked deprecated and should not be used.
• VRAPI_SYS_STATUS_HEADPHONES_PLUGGED_IN is no longer provided on the API. For an example of how to query the headphone plugged state, see VrFrameBuilder in the native SDK library, VrAppFramework.
• The default SwapChain provided by VrApi has been renamed to VRAPI_DEFAULT_TEXTURE_SWAPCHAIN. Note that if you want an application to create a frame of solid black, the ColorScale parameter on the layer must be set to { 0.0f, 0.0f, 0.0f, 0.0f } to prevent any compatibility issues with newer runtimes which expect the ColorScale to be set.

ovrLayerProjection2 & worldLayer = Layers[LayerCount++ ].Projection;
worldLayer = vrapi_DefaultLayerProjection2();

worldLayer.HeadPose = Tracking.HeadPose;
for ( int eye = 0; eye < VRAPI_FRAME_LAYER_EYE_MAX; eye++ )
{
worldLayer.Textures[eye].ColorSwapChain =ColorTextureSwapChain[eye];
worldLayer.Textures[eye].SwapChainIndex = TextureSwapChainIndex;
worldLayer.Textures[eye].TexCoordsFromTanAngles = TexCoordsFromTanAngles;
}

ovrLayerHeader2 * LayerHeaderList[ovrMaxLayerCount] = {};
for ( int i = 0; i < LayerCount; i++ )
{
LayerHeaderList[i] = &Layers[i].Header;
}

ovrSubmitFrameDescription2 frameDesc = {};
frameDesc.Flags = 0;
frameDesc.SwapInterval = 1;
frameDesc.FrameIndex = FrameIndex;
frameDesc.CompletionFence = (size_t)Fence->Sync;
frameDesc.DisplayTime = PredictedDisplayTime;
frameDesc.LayerCount = LayerCount;
frameDesc.Layers = LayerHeaderList;

vrapi_SubmitFrame2( OvrMobile, &frameDesc );

vrapi_SetClockLevels( ovr, PerformanceParms.CpuLevel, PerformanceParms.GpuLevel );

vrapi_SetPerfThread( ovr, VRAPI_PERF_THREAD_TYPE_MAIN,PerformanceParms.MainThreadTid );

vrapi_SetPerfThread( ovr, VRAPI_PERF_THREAD_TYPE_RENDERER,PerformanceParms.RenderThreadTid );

vrapi_SetExtraLatencyMode( ovr, VRAPI_EXTRA_LATENCY_MODE_OFF );

vrapi_SetTrackingTransform( ovr, vrapi_GetTrackingTransform( ovr, VRAPI_TRACKING_TRANSFORM_SYSTEM_CENTER_FLOOR_LEVEL ) );

vrapi_SetTrackingTransform( ovr, vrapi_GetTrackingTransform( ovr, VRAPI_TRACKING_TRANSFORM_SYSTEM_CENTER_FLOOR_LEVEL ) );

• The SDK now uses externalNativeBuild for ndkBuild instead of the deprecated ndkCompile path. externalNativeBuild provides a more robust Native Debugging mechanism that works out of the box and allows for stepping seamlessly between Java and Native code. Ensure you set the ANDROID_NDK_HOME environment variable to your ndk path location.
• Android KitKat support has been deprecated. The minSdkVersion must now be 21 (Lollipop 5.0) or later.
• The build tools have been updated to the following versions:
  • Android SDK Build Tools Revision 25.0.1
  • Android Plugin for Gradle 2.3.2
  • Gradle 3.3
• We recommend NDK version r14b.

• A new entry point, vrapi_GetPredictedTracking2(), was added for querying the predicted tracking info along with corresponding view and projection matrices for each eye.
• The default head model is now applied in vrapi_GetPredictedTracking() and vrapi_GetPredictedTracking2() for apps targeting SDK 1.7.0 and higher. Apps should no longer apply the head model themselves.
• For apps targeting SDK 1.7.0 and higher, the head pose Y translation will now include eye height above floor.
• The vrapi_GetCenterEye() helper functions have been removed and replaced with vrapi_GetFromPose()* helper functions to remove the notion of a ‘center eye’.
• VrApi_LocalPrefs.h has been removed. Applications can use android system properties for any development debug needs.
• VRAPI_FRAME_LAYER_FLAG_WRITE_ALPHA and DST_ALPHA layer blend modes have been deprecated.
• vrapi_Initialize now returns an error code when the system driver is not found on the device instead of forcing the app to exit.

• const ovrHeadModelParms & GetHeadModelParms() const;
• void SetHeadModelParms( const ovrHeadModelParms & parms );

• ModelFile now has additional data structures that describe a full scene of data, instead of just a single ModelDef with a list of draw surfaces.
• LoadModelFile now returns nullptr if the system failed to load the file.
• OvrSceneView.GetWorldModel now returns a pointer instead of a reference.
• ModelState.modelMatrix is now private and must be accessed through the Get and Set commands.
• The correct way to iterate over all the draw surfaces in a model file is now:

for ( int i = 0; i < modelFile->Models.GetSizeI(); i++ ) { for ( int j = 0; j < modelFile->Models[i].surfaces.GetSizeI(); j++ ) { // work } }

• VrApi Input API for Gear VR Controller and Gear VR headset
• Experimental 64-bit SDK libraries
• Removal of deprecated DrawEyeView render path.
• Removal of deprecated VrApi layer types.
• Removal of deprecated VrApi frame flags.

frameParms.FrameIndex = vrFrame.FrameNumber;
frameParms.MinimumVsyncs = app->GetMinimumVsyncs();
frameParms.PerformanceParms = app->GetPerformanceParms();

• System Utilities Library Dependency is removed and functionality is handled directly within VrApi.
• Long-press back button handling (including gaze timer rendering) is now detected and handled directly within VrApi. Applications should no longer implement this logic.
• VrApi Loader is now Java free.
• The VrApi implementation is now distributed through the System Driver application.

• Libs/Android/armeabi-v7a/Release/
• Libs/Android/aar/Release/

int32_t initResult = vrapi_Initialize( &initParms );
if ( initResult != VRAPI_INITIALIZE_SUCCESS )
{
// As of 1.0.4, vrapi directly triggers the display of Fatal Errors in vrapi_Initialize.
vrapi_Shutdown();
exit( 0 );
}

float doubleTapTimeInSeconds = vrapi_GetSystemPropertyFloat( &app->Java, VRAPI_SYS_PROP_BACK_BUTTON_DOUBLETAP_TIME );

float shortPressTimeInSeconds = vrapi_GetSystemPropertyFloat( &app->Java, VRAPI_SYS_PROP_BACK_BUTTON_SHORTPRESS_TIME );

• SystemActivities_Init
• SystemActivities_Shutdown
• SystemActivities_Update
• SystemActivities_PostUpdate

Note: Recenter-on-mount is now handled directly within VrApi. Apps do not need to implement this logic any longer. If an application needs to detect that a re-center has occurred, they can now do so through checking a re-center count through VrApi, eg:

const int currentRecenterCount = vrapi_GetSystemStatusInt( &Java, VRAPI_SYS_STATUS_RECENTER_COUNT );
// Determine if the recenter count has changed since last frame
if ( currentRecenterCount != RecenterCount )
{
// reset menu orientations
RecenterCount = currentRecenterCount;
}

Note: The DrawEyeView render path is deprecated and will be removed in a future SDK update.

1. In the project-level build.gradle (e.g. VrCubeWorld_NativeActivity/Projects/Android/build.gradle), add the following lines to the top of the file: apply from: "${rootProject.projectDir}/VrApp.gradle".
2. Delete the brace-enclosed sections beginning with project.afterEvaluate and android.applicationVariants.all.

1. In the brace-enclosed section marked android, add the following line: project.archivesBaseName = "<your project name>"
2. Make sure the brace-enclosed section marked android also contains the following: defaultConfig { applicationId "<your project app ID>" }
3. In the brace-enclosed section marked dependencies, replace the line: compile name: 'VrAppFramework', ext: 'aar' with the line: compile project(':VrAppFramework:Projects:AndroidPrebuilt') and add the following path to your settings.gradle include list: 'VrAppFramework:Projects:AndroidPrebuilt'

parms.Flags |= VRAPI_MODE_FLAG_NATIVE_WINDOW;

Note: While the VrApi currently continues to support the old behavior of not passing EGL objects explicitly with threading restrictions, this functionality will be removed in a future version of VrApi.

parms.Flags |= VRAPI_MODEL_FLAG_ALLOW_POWER_SAVE

ovrFrameResult res;
res.FrameMatrices.CenterView = Scene.GetCenterEyeViewMatrix();
return res;

• When intentType is INTENT_LAUNCH, call OneTimeInit(), then NewIntent().
• When intentType is INTENT_NEW, call NewIntent() only.
• When intentType is INTENT_OLD, do not call OneTimeInit() or NewIntent().

	// process input events first because this mirrors the behavior when OnKeyEvent was
	// a virtual function on VrAppInterface and was called by VrAppFramework.
	for ( int i = 0; i < vrFrame.Input.NumKeyEvents; i++ )
	{
		const int keyCode = vrFrame.Input.KeyEvents[i].KeyCode;
		const int repeatCount = vrFrame.Input.KeyEvents[i].RepeatCount;
		const KeyEventType eventType = vrFrame.Input.KeyEvents[i].EventType;

		if ( OnKeyEvent( keyCode, repeatCount, eventType ) )
		{
			continue;   // consumed the event
		}
		// If nothing consumed the key and it is a short-press of the back key, then exit the application to Home.
		if ( keyCode == OVR_KEY_BACK & eventType == KEY_EVENT_SHORT_PRESS )
		{
			app->StartSystemActivity( PUI_CONFIRM_QUIT );
			continue;
		}
	}

#extension GL_OES_EGL_image_external : require

#extension GL_OES_EGL_image_external : enable

#extension GL_OES_EGL_image_external_essl3 : enable

gl_Position = TransformVertex( Position );

Note: The TransformVertex function is provided in a default system header block which is added to every GlProgram.

GuiSys->RenderEyeView( Scene.GetCenterEyeViewMatrix(), viewMatrix, projectionMatrix
     );

GuiSys->RenderEyeView( Scene.GetCenterEyeViewMatrix(), viewMatrix, projectionMatrix, app->GetSurfaceRender() );

Note: This functionality is specific to the DrawEyeView render path and will be removed in a future SDK.

GuiSys->AppendSurfaceList( Scene.GetCenterEyeViewMatrix(), &res.Surfaces );

Locale = ovrLocale::Create( *app, "default" );

Locale = ovrLocale::Create( *java->Env, java->ActivityObject, "default" );

Scene.DrawEyeView( eye, fovDegreesX, fovDegreesY );

Scene.DrawEyeView( eye, fovDegreesX, fovDegreesY, app->GetSurfaceRender() );

1. Set up the ovrFrameParms - storage for which should be maintained by the application.
2. Set up the FrameMatrices - this includes the CenterEye and View and Projection matrices for each eye.
3. Generate a list of render surfaces and append to the frame result surfaces list.
   1. Note: The surface draw order will be the order of the list, from lowest index (0) to highest index.
   2. Note: Do not free any resources which surfaces in list rely on while Frame render is in flight.
4. Optionally, specify whether to clear the color or depth buffer with clear color.

ovrFrameResult OvrApp::Frame( const ovrFrameInput & vrFrame )
{
...

// fill in the frameresult info for the frame.
ovrFrameResult res;

// Let scene construct the view and projection matrices needed for the frame.
Scene.GetFrameMatrices( vrFrame.FovX, vrFrame.FovY, res.FrameMatrices );

// Let scene generate the surface list for the frame.
Scene.GenerateFrameSurfaceList( res.FrameMatrices, res.Surfaces );

// Initialize the FrameParms.
FrameParms = vrapi_DefaultFrameParms( app->GetJava(), VRAPI_FRAME_INIT_DEFAULT, vrapi_GetTimeInSeconds(), NULL );
for ( int eye = 0; eye < VRAPI_FRAME_LAYER_EYE_MAX; eye++ )
{
FrameParms.Layers[0].Textures[eye].ColorTextureSwapChain = vrFrame.ColorTextureSwapChain[eye];
	FrameParms.Layers[0].Textures[eye].DepthTextureSwapChain = vrFrame.DepthTextureSwapChain[eye];
	FrameParms.Layers[0].Textures[eye].TextureSwapChainIndex = vrFrame.TextureSwapChainIndex;

	FrameParms.Layers[0].Textures[eye].TexCoordsFromTanAngles = vrFrame.TexCoordsFromTanAngles;
	FrameParms.Layers[0].Textures[eye].HeadPose = vrFrame.Tracking.HeadPose;
}

FrameParms.ExternalVelocity = Scene.GetExternalVelocity();
FrameParms.Layers[0].Flags = VRAPI_FRAME_LAYER_FLAG_CHROMATIC_ABERRATION_CORRECTION;

res.FrameParms = (ovrFrameParmsExtBase *) & FrameParms;
return res;
}

 glActiveTexture( GL_TEXTURE0 );
	glBindTexture( GL_TEXTURE_2D, BackgroundTexId );

	glDisable( GL_DEPTH_TEST );
	glDisable( GL_CULL_FACE );

 GlProgram & prog = BgTexProgram;
	glUseProgram( prog.Program );
	glUniform4f( prog.uColor, 1.0f, 1.0f, 1.0f, 1.0f );
	globeGeometry.Draw();
	glUseProgram( 0 );

	glActiveTexture( GL_TEXTURE0 );
	glBindTexture( GL_TEXTURE_2D, 0 );

static ovrProgramParm BgTexProgParms[] =
{
{ "Texm",		ovrProgramParmType::FLOAT_MATRIX4		},
		{ "UniformColor",	ovrProgramParmType::FLOAT_VECTOR4		},
		{ "Texture0",	ovrProgramParmType::TEXTURE_SAMPLED	},
};
BgTexProgram= GlProgram::Build( BgTexVertexShaderSrc, BgTexFragmentShaderSrc, BgTexProgParms, sizeof( BgTexProgParms) / sizeof( ovrProgramParm ) );

	GlobeSurfaceDef.surfaceName = "Globe";
	GlobeSurfaceDef.geo = BuildGlobe();
	GlobeSurfaceDef.graphicsCommand.Program = BgTexProgram;
	GlobeSurfaceDef.graphicsCommand.GpuState.depthEnable = false;
	GlobeSurfaceDef.graphicsCommand.GpuState.cullEnable = false;
	GlobeSurfaceDef.graphicsCommand.UniformData[0].Data = &BackGroundTexture;
	GlobeSurfaceDef.graphicsCommand.UniformData[1].Data = &GlobeProgramColor;

Note: This manner of uniform parm setting requires the application to maintain storage for the uniform data. Future SDKs will provide helper functions for setting up uniform parms and materials.

ovrFrameResult OvrApp::Frame( const ovrFrameInput & vrFrame )
{
...

// fill in the frameresult info for the frame.
ovrFrameResult res;

// calculate the scene matrices for the frame.
res.FrameMatrices.CenterView = vrapi_GetCenterEyeViewMatrix( &app->GetHeadModelParms(), &vrFrame.Tracking, NULL );
for ( int eye = 0; eye < VRAPI_FRAME_LAYER_EYE_MAX; eye++ )
{
res.FrameMatrices.EyeView[eye] = vrapi_GetEyeViewMatrix( &app->GetHeadModelParms(), &CenterEyeViewMatrix, eye );
	res.FrameMatrices.EyeProjection[eye] = ovrMatrix4f_CreateProjectionFov( vrFrame.FovX, vrFrame.FovY, 0.0f, 0.0f, 1.0f, 0.0f );
}

// Update uniform variables and add needed surfaces to the surface list.
BackGroundTexture = GlTexture( BackgroundTexId, 0, 0 );
GlobeProgramColor = Vector4f( 1.0f, 1.0f, 1.0f, 1.0f );
res.Surfaces.PushBack( ovrDrawSurface( &GlobeSurfaceDef ) );

// Initialize the FrameParms.
FrameParms = vrapi_DefaultFrameParms( app->GetJava(), VRAPI_FRAME_INIT_DEFAULT, vrapi_GetTimeInSeconds(), NULL );
for ( int eye = 0; eye < VRAPI_FRAME_LAYER_EYE_MAX; eye++ )
{
FrameParms.Layers[0].Textures[eye].ColorTextureSwapChain = vrFrame.ColorTextureSwapChain[eye];
	FrameParms.Layers[0].Textures[eye].DepthTextureSwapChain = vrFrame.DepthTextureSwapChain[eye];
	FrameParms.Layers[0].Textures[eye].TextureSwapChainIndex = vrFrame.TextureSwapChainIndex;

	FrameParms.Layers[0].Textures[eye].TexCoordsFromTanAngles = vrFrame.TexCoordsFromTanAngles;
	FrameParms.Layers[0].Textures[eye].HeadPose = vrFrame.Tracking.HeadPose;
}

FrameParms.ExternalVelocity = Scene.GetExternalVelocity();
FrameParms.Layers[0].Flags = VRAPI_FRAME_LAYER_FLAG_CHROMATIC_ABERRATION_CORRECTION;

res.FrameParms = (ovrFrameParmsExtBase *) & FrameParms;
return res;
}

settings.RenderMode = RENDERMODE_STEREO;

Note: A debug render mode option has been provided which alternates rendering between the deprecated DrawEyeView path and the new path for returning a render surface list from Frame. This aides the conversion process so it is easier to spot discrepancies between the two paths.

settings.RenderMode = RENDERMODE_DEBUG_ALTERNATE_STEREO;

Note: Due to a driver issue with the Adreno 420, KitKat, and version 300 programs, uniform array of matrices should be contained inside a uniform buffer object.

settings.RenderMode = RENDERMODE_MULTIVIEW;

$(call import-module,VrAppSupport/SystemUtils/Projects/AndroidPrebuilt/jni)

• Call SystemActivites_Init() when the application initializes.
• Call SystemActivities_Update() to retrieve a list of pending System Activities events.
• The application may then handle any events in this list that it wishes to process. The application is expected to call SystemActivities_RemoveAppEvent() to remove any events that it handled.
• Call SystemActivities_PostUpdate() during the application’s frame update.
• Call SystemActivities_Shutdown() when the application is being destroyed.

1. The user long-presses the Back button.
2. The application detects the long-press and launches System Activities with SystemActivities_StartSystemActivity and the PUI_GLOBAL_MENU command.
3. In the Universal Menu, the user selects Reorient.
4. System Activities sends a launch intent to the application that launched the Universal Menu.
5. System Activities sends a reorient message to the application that launched it.
6. The application receives the message and adds it to the System Activities event queue.
7. The application resumes.
8. The application calls SystemActivities_Update() to get a list of pending events.
9. If the application has special reorient logic, e.g., to re-align UI elements to be in front of the user after reorienting, it can call vrapi_RecenterPose(), reposition its UI, and then remove the event from list of events.
10. The application calls SystemActivities_PostUpdate(). If the reorient event was not handled by the application, it is handled inside of PostUpdate.