diff --git a/Projects/Android/jni/JKVR/JKVR_SurfaceView.cpp b/Projects/Android/jni/JKVR/JKVR_SurfaceView.cpp index 0eb2a10..88a43c9 100644 --- a/Projects/Android/jni/JKVR/JKVR_SurfaceView.cpp +++ b/Projects/Android/jni/JKVR/JKVR_SurfaceView.cpp @@ -34,18 +34,10 @@ Copyright : Copyright 2015 Oculus VR, LLC. All Rights reserved. #define GL_GLEXT_PROTOTYPES #include -#include "VrApi.h" -#include "VrApi_Helpers.h" -#include "VrApi_SystemUtils.h" -#include "VrApi_Input.h" -#include "VrApi_Types.h" - extern "C" { #include "src/gl/loader.h" } -//#include -//#include #include #include "VrCompositor.h" @@ -111,8 +103,16 @@ struct arg_end *end; char **argv; int argc=0; -extern cvar_t *r_lefthand; -extern cvar_t *cl_paused; + +const char* const requiredExtensionNames[] = { + XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME, + XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME, + XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME, + XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME, + XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME}; +const uint32_t numRequiredExtensions = + sizeof(requiredExtensionNames) / sizeof(requiredExtensionNames[0]); + /* ================================================================================ @@ -486,26 +486,25 @@ ovrFramebuffer */ -static void ovrFramebuffer_Clear( ovrFramebuffer * frameBuffer ) -{ +static void ovrFramebuffer_Clear(ovrFramebuffer* frameBuffer) { frameBuffer->Width = 0; frameBuffer->Height = 0; - frameBuffer->Multisamples = 0; frameBuffer->TextureSwapChainLength = 0; frameBuffer->TextureSwapChainIndex = 0; - frameBuffer->ColorTextureSwapChain = NULL; + frameBuffer->ColorSwapChain.Handle = XR_NULL_HANDLE; + frameBuffer->ColorSwapChain.Width = 0; + frameBuffer->ColorSwapChain.Height = 0; + frameBuffer->ColorSwapChainImage = NULL; frameBuffer->DepthBuffers = NULL; frameBuffer->FrameBuffers = NULL; } -static bool ovrFramebuffer_Create( ovrFramebuffer * frameBuffer, const GLenum colorFormat, const int width, const int height, const int multisamples ) +static bool ovrFramebuffer_Create( XrSession session, + ovrFramebuffer * frameBuffer, const GLenum colorFormat, const int width, const int height ) { frameBuffer->Width = width; frameBuffer->Height = height; - frameBuffer->Multisamples = multisamples; - frameBuffer->ColorTextureSwapChain = vrapi_CreateTextureSwapChain3( VRAPI_TEXTURE_TYPE_2D, colorFormat, frameBuffer->Width, frameBuffer->Height, 1, 3 ); - frameBuffer->TextureSwapChainLength = vrapi_GetTextureSwapChainLength( frameBuffer->ColorTextureSwapChain ); frameBuffer->DepthBuffers = (GLuint *)malloc( frameBuffer->TextureSwapChainLength * sizeof( GLuint ) ); frameBuffer->FrameBuffers = (GLuint *)malloc( frameBuffer->TextureSwapChainLength * sizeof( GLuint ) ); @@ -514,20 +513,56 @@ static bool ovrFramebuffer_Create( ovrFramebuffer * frameBuffer, const GLenum co PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC glFramebufferTexture2DMultisampleEXT = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC)eglGetProcAddress("glFramebufferTexture2DMultisampleEXT"); + XrSwapchainCreateInfo swapChainCreateInfo; + memset(&swapChainCreateInfo, 0, sizeof(swapChainCreateInfo)); + swapChainCreateInfo.type = XR_TYPE_SWAPCHAIN_CREATE_INFO; + swapChainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT; + swapChainCreateInfo.format = GL_RGBA8; + swapChainCreateInfo.sampleCount = 1; + swapChainCreateInfo.width = width; + swapChainCreateInfo.height = height; + swapChainCreateInfo.faceCount = 1; + swapChainCreateInfo.arraySize = 2; + swapChainCreateInfo.mipCount = 1; + + frameBuffer->ColorSwapChain.Width = swapChainCreateInfo.width; + frameBuffer->ColorSwapChain.Height = swapChainCreateInfo.height; + + // Create the swapchain. + OXR(xrCreateSwapchain(session, &swapChainCreateInfo, &frameBuffer->ColorSwapChain.Handle)); + // Get the number of swapchain images. + OXR(xrEnumerateSwapchainImages( + frameBuffer->ColorSwapChain.Handle, 0, &frameBuffer->TextureSwapChainLength, NULL)); + // Allocate the swapchain images array. + frameBuffer->ColorSwapChainImage = (XrSwapchainImageOpenGLESKHR*)malloc( + frameBuffer->TextureSwapChainLength * sizeof(XrSwapchainImageOpenGLESKHR)); + + // Populate the swapchain image array. + for (uint32_t i = 0; i < frameBuffer->TextureSwapChainLength; i++) { + frameBuffer->ColorSwapChainImage[i].type = XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR; + frameBuffer->ColorSwapChainImage[i].next = NULL; + } + OXR(xrEnumerateSwapchainImages( + frameBuffer->ColorSwapChain.Handle, + frameBuffer->TextureSwapChainLength, + &frameBuffer->TextureSwapChainLength, + (XrSwapchainImageBaseHeader*)frameBuffer->ColorSwapChainImage)); + + for ( int i = 0; i < frameBuffer->TextureSwapChainLength; i++ ) { // Create the color buffer texture. - const GLuint colorTexture = vrapi_GetTextureSwapChainHandle( frameBuffer->ColorTextureSwapChain, i ); + const GLuint colorTexture = frameBuffer->ColorSwapChainImage[i].image; GL(glGenRenderbuffers(1, &frameBuffer->DepthBuffers[i])); GL(glBindRenderbuffer(GL_RENDERBUFFER, frameBuffer->DepthBuffers[i])); - GL(glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, multisamples, GL_DEPTH_COMPONENT24, width, height)); + GL(glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, 1, GL_DEPTH_COMPONENT24, width, height)); GL(glBindRenderbuffer(GL_RENDERBUFFER, 0)); // Create the frame buffer. GL(glGenFramebuffers(1, &frameBuffer->FrameBuffers[i])); GL(glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer->FrameBuffers[i])); - GL(glFramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0, multisamples)); + GL(glFramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0, 1)); GL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, frameBuffer->DepthBuffers[i])); GL(GLenum renderFramebufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER)); @@ -653,13 +688,10 @@ void ovrRenderer_Clear( ovrRenderer * renderer ) } -void ovrRenderer_Create( int width, int height, ovrRenderer * renderer, const ovrJava * java ) +void ovrRenderer_Create( int width, int height, ovrRenderer * renderer ) { renderer->NumBuffers = VRAPI_FRAME_LAYER_EYE_MAX; - //Now using a symmetrical render target, based on the horizontal FOV - vr.fov = vrapi_GetSystemPropertyInt( java, VRAPI_SYS_PROP_SUGGESTED_EYE_FOV_DEGREES_Y); - // Create the render Textures. for ( int eye = 0; eye < VRAPI_FRAME_LAYER_EYE_MAX; eye++ ) { @@ -669,11 +701,6 @@ void ovrRenderer_Create( int width, int height, ovrRenderer * renderer, const ov height, NUM_MULTI_SAMPLES ); } - - // Setup the projection matrix. - renderer->ProjectionMatrix = ovrMatrix4f_CreateProjectionFov( - vr.fov, vr.fov, 0.0f, 0.0f, 1.0f, 0.0f ); - } void ovrRenderer_Destroy( ovrRenderer * renderer ) @@ -766,34 +793,33 @@ void GetAnglesFromVectors(const ovrVector3f forward, const ovrVector3f right, co } -void QuatToYawPitchRoll(ovrQuatf q, vec3_t rotation, vec3_t out) { +void QuatToYawPitchRoll(XrQuaternionf q, vec3_t rotation, vec3_t out) { - ovrMatrix4f mat = ovrMatrix4f_CreateFromQuaternion( &q ); + ovrMatrix4f mat = ovrMatrix4f_CreateFromQuaternion( &q ); - if (rotation[0] != 0.0f || rotation[1] != 0.0f || rotation[2] != 0.0f) - { - ovrMatrix4f rot = ovrMatrix4f_CreateRotation(radians(rotation[0]), radians(rotation[1]), radians(rotation[2])); - mat = ovrMatrix4f_Multiply(&mat, &rot); - } + if (rotation[0] != 0.0f || rotation[1] != 0.0f || rotation[2] != 0.0f) + { + ovrMatrix4f rot = ovrMatrix4f_CreateRotation(radians(rotation[0]), radians(rotation[1]), radians(rotation[2])); + mat = ovrMatrix4f_Multiply(&mat, &rot); + } - ovrVector4f v1 = {0, 0, -1, 0}; - ovrVector4f v2 = {1, 0, 0, 0}; - ovrVector4f v3 = {0, 1, 0, 0}; + XrVector4f v1 = {0, 0, -1, 0}; + XrVector4f v2 = {1, 0, 0, 0}; + XrVector4f v3 = {0, 1, 0, 0}; - ovrVector4f forwardInVRSpace = ovrVector4f_MultiplyMatrix4f(&mat, &v1); - ovrVector4f rightInVRSpace = ovrVector4f_MultiplyMatrix4f(&mat, &v2); - ovrVector4f upInVRSpace = ovrVector4f_MultiplyMatrix4f(&mat, &v3); + XrVector4f forwardInVRSpace = XrVector4f_MultiplyMatrix4f(&mat, &v1); + XrVector4f rightInVRSpace = XrVector4f_MultiplyMatrix4f(&mat, &v2); + XrVector4f upInVRSpace = XrVector4f_MultiplyMatrix4f(&mat, &v3); - ovrVector3f forward = {-forwardInVRSpace.z, -forwardInVRSpace.x, forwardInVRSpace.y}; - ovrVector3f right = {-rightInVRSpace.z, -rightInVRSpace.x, rightInVRSpace.y}; - ovrVector3f up = {-upInVRSpace.z, -upInVRSpace.x, upInVRSpace.y}; + XrVector3f forward = {-forwardInVRSpace.z, -forwardInVRSpace.x, forwardInVRSpace.y}; + XrVector3f right = {-rightInVRSpace.z, -rightInVRSpace.x, rightInVRSpace.y}; + XrVector3f up = {-upInVRSpace.z, -upInVRSpace.x, upInVRSpace.y}; - ovrVector3f forwardNormal = normalizeVec(forward); - ovrVector3f rightNormal = normalizeVec(right); - ovrVector3f upNormal = normalizeVec(up); + XrVector3f forwardNormal = normalizeVec(forward); + XrVector3f rightNormal = normalizeVec(right); + XrVector3f upNormal = normalizeVec(up); - GetAnglesFromVectors(forwardNormal, rightNormal, upNormal, out); - return; + GetAnglesFromVectors(forwardNormal, rightNormal, upNormal, out); } void updateHMDOrientation() @@ -938,52 +964,32 @@ ovrRenderThread */ -/* -================================================================================ -ovrApp - -================================================================================ -*/ - -typedef struct -{ - ovrJava Java; - ovrEgl Egl; - ANativeWindow * NativeWindow; - bool Resumed; - ovrMobile * Ovr; - ovrScene Scene; - long long FrameIndex; - double DisplayTime; - int SwapInterval; - int CpuLevel; - int GpuLevel; - int MainThreadTid; - int RenderThreadTid; - ovrLayer_Union2 Layers[ovrMaxLayerCount]; - int LayerCount; - ovrRenderer Renderer; -} ovrApp; - -static void ovrApp_Clear( ovrApp * app ) -{ - app->Java.Vm = NULL; - app->Java.Env = NULL; - app->Java.ActivityObject = NULL; - app->Ovr = NULL; - app->FrameIndex = 1; - app->DisplayTime = 0; +void ovrApp_Clear(ovrApp* app) { + app->Focused = false; + app->Instance = XR_NULL_HANDLE; + app->Session = XR_NULL_HANDLE; + memset(&app->ViewportConfig, 0, sizeof(XrViewConfigurationProperties)); + memset(&app->ViewConfigurationView, 0, ovrMaxNumEyes * sizeof(XrViewConfigurationView)); + app->SystemId = XR_NULL_SYSTEM_ID; + app->HeadSpace = XR_NULL_HANDLE; + app->StageSpace = XR_NULL_HANDLE; + app->FakeStageSpace = XR_NULL_HANDLE; + app->CurrentSpace = XR_NULL_HANDLE; + app->SessionActive = false; + app->SupportedDisplayRefreshRates = NULL; + app->RequestedDisplayRefreshRateIndex = 0; + app->NumSupportedDisplayRefreshRates = 0; + app->pfnGetDisplayRefreshRate = NULL; + app->pfnRequestDisplayRefreshRate = NULL; app->SwapInterval = 1; - app->CpuLevel = 3; - app->GpuLevel = 3; + memset(app->Layers, 0, sizeof(ovrCompositorLayer_Union) * ovrMaxLayerCount); + app->LayerCount = 0; app->MainThreadTid = 0; app->RenderThreadTid = 0; - ovrEgl_Clear( &app->Egl ); - ovrScene_Clear( &app->Scene ); - ovrRenderer_Clear( &app->Renderer ); + ovrRenderer_Clear(&app->Renderer); } static void ovrApp_PushBlackFinal( ovrApp * app ) @@ -1010,74 +1016,145 @@ static void ovrApp_PushBlackFinal( ovrApp * app ) vrapi_SubmitFrame2( app->Ovr, &frameDesc ); } -static void ovrApp_HandleVrModeChanges( ovrApp * app ) -{ - if ( app->Resumed != false && app->NativeWindow != NULL ) - { - if ( app->Ovr == NULL ) - { - ovrModeParms parms = vrapi_DefaultModeParms( &app->Java ); - // Must reset the FLAG_FULLSCREEN window flag when using a SurfaceView - parms.Flags |= VRAPI_MODE_FLAG_RESET_WINDOW_FULLSCREEN; - parms.Flags |= VRAPI_MODE_FLAG_NATIVE_WINDOW; - parms.Display = (size_t)app->Egl.Display; - parms.WindowSurface = (size_t)app->NativeWindow; - parms.ShareContext = (size_t)app->Egl.Context; - ALOGV( " eglGetCurrentSurface( EGL_DRAW ) = %p", eglGetCurrentSurface( EGL_DRAW ) ); +void ovrApp_HandleSessionStateChanges(ovrApp* app, XrSessionState state) { + if (state == XR_SESSION_STATE_READY) { + assert(app->SessionActive == false); - ALOGV( " vrapi_EnterVrMode()" ); + XrSessionBeginInfo sessionBeginInfo; + memset(&sessionBeginInfo, 0, sizeof(sessionBeginInfo)); + sessionBeginInfo.type = XR_TYPE_SESSION_BEGIN_INFO; + sessionBeginInfo.next = NULL; + sessionBeginInfo.primaryViewConfigurationType = app->ViewportConfig.viewConfigurationType; - app->Ovr = vrapi_EnterVrMode( &parms ); + XrResult result; + OXR(result = xrBeginSession(app->Session, &sessionBeginInfo)); - ALOGV( " eglGetCurrentSurface( EGL_DRAW ) = %p", eglGetCurrentSurface( EGL_DRAW ) ); + app->SessionActive = (result == XR_SUCCESS); - // If entering VR mode failed then the ANativeWindow was not valid. - if ( app->Ovr == NULL ) - { - ALOGE( "Invalid ANativeWindow!" ); - app->NativeWindow = NULL; - } + // Set session state once we have entered VR mode and have a valid session object. + if (app->SessionActive) { + XrPerfSettingsLevelEXT cpuPerfLevel = XR_PERF_SETTINGS_LEVEL_BOOST_EXT; + XrPerfSettingsLevelEXT gpuPerfLevel = XR_PERF_SETTINGS_LEVEL_BOOST_EXT; - // Set performance parameters once we have entered VR mode and have a valid ovrMobile. - if ( app->Ovr != NULL ) - { - //AmmarkoV : Set our refresh rate..! - ovrResult result = vrapi_SetDisplayRefreshRate(app->Ovr, REFRESH); - if (result == ovrSuccess) { ALOGV("Changed refresh rate. %f Hz", REFRESH); } else - { ALOGV("Failed to change refresh rate to 90Hz Result=%d",result); } + PFN_xrPerfSettingsSetPerformanceLevelEXT pfnPerfSettingsSetPerformanceLevelEXT = NULL; + OXR(xrGetInstanceProcAddr( + app->Instance, + "xrPerfSettingsSetPerformanceLevelEXT", + (PFN_xrVoidFunction*)(&pfnPerfSettingsSetPerformanceLevelEXT))); - vrapi_SetClockLevels( app->Ovr, app->CpuLevel, app->GpuLevel ); - ALOGV( " vrapi_SetClockLevels( %d, %d )", app->CpuLevel, app->GpuLevel ); + OXR(pfnPerfSettingsSetPerformanceLevelEXT( + app->Session, XR_PERF_SETTINGS_DOMAIN_CPU_EXT, cpuPerfLevel)); + OXR(pfnPerfSettingsSetPerformanceLevelEXT( + app->Session, XR_PERF_SETTINGS_DOMAIN_GPU_EXT, gpuPerfLevel)); - vrapi_SetExtraLatencyMode(app->Ovr, VRAPI_EXTRA_LATENCY_MODE_ON); - ALOGV( " vrapi_SetExtraLatencyMode( %d )", VRAPI_EXTRA_LATENCY_MODE_ON ); + PFN_xrSetAndroidApplicationThreadKHR pfnSetAndroidApplicationThreadKHR = NULL; + OXR(xrGetInstanceProcAddr( + app->Instance, + "xrSetAndroidApplicationThreadKHR", + (PFN_xrVoidFunction*)(&pfnSetAndroidApplicationThreadKHR))); - vrapi_SetPerfThread( app->Ovr, VRAPI_PERF_THREAD_TYPE_MAIN, app->MainThreadTid ); + OXR(pfnSetAndroidApplicationThreadKHR( + app->Session, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, app->MainThreadTid)); + OXR(pfnSetAndroidApplicationThreadKHR( + app->Session, XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR, app->RenderThreadTid)); + } + } else if (state == XR_SESSION_STATE_STOPPING) { + assert(app->SessionActive); - ALOGV( " vrapi_SetPerfThread( MAIN, %d )", app->MainThreadTid ); + OXR(xrEndSession(app->Session)); + app->SessionActive = false; + } +} - vrapi_SetPerfThread( app->Ovr, VRAPI_PERF_THREAD_TYPE_RENDERER, app->RenderThreadTid ); +GLboolean ovrApp_HandleXrEvents(ovrApp* app) { + XrEventDataBuffer eventDataBuffer = {}; + GLboolean recenter = GL_FALSE; - ALOGV( " vrapi_SetPerfThread( RENDERER, %d )", app->RenderThreadTid ); - } - } - } - else - { - if ( app->Ovr != NULL ) - { - ALOGV( " eglGetCurrentSurface( EGL_DRAW ) = %p", eglGetCurrentSurface( EGL_DRAW ) ); - - ALOGV( " vrapi_LeaveVrMode()" ); - - vrapi_LeaveVrMode( app->Ovr ); - app->Ovr = NULL; - - ALOGV( " eglGetCurrentSurface( EGL_DRAW ) = %p", eglGetCurrentSurface( EGL_DRAW ) ); + // Poll for events + for (;;) { + XrEventDataBaseHeader* baseEventHeader = (XrEventDataBaseHeader*)(&eventDataBuffer); + baseEventHeader->type = XR_TYPE_EVENT_DATA_BUFFER; + baseEventHeader->next = NULL; + XrResult r; + OXR(r = xrPollEvent(app->Instance, &eventDataBuffer)); + if (r != XR_SUCCESS) { + break; + } + + switch (baseEventHeader->type) { + case XR_TYPE_EVENT_DATA_EVENTS_LOST: + ALOGV("xrPollEvent: received XR_TYPE_EVENT_DATA_EVENTS_LOST event"); + break; + case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING: { + const XrEventDataInstanceLossPending* instance_loss_pending_event = + (XrEventDataInstanceLossPending*)(baseEventHeader); + ALOGV( + "xrPollEvent: received XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING event: time %f", + FromXrTime(instance_loss_pending_event->lossTime)); + } break; + case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED: + ALOGV("xrPollEvent: received XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED event"); + break; + case XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT: { + const XrEventDataPerfSettingsEXT* perf_settings_event = + (XrEventDataPerfSettingsEXT*)(baseEventHeader); + ALOGV( + "xrPollEvent: received XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT event: type %d subdomain %d : level %d -> level %d", + perf_settings_event->type, + perf_settings_event->subDomain, + perf_settings_event->fromLevel, + perf_settings_event->toLevel); + } break; + case XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB: { + const XrEventDataDisplayRefreshRateChangedFB* refresh_rate_changed_event = + (XrEventDataDisplayRefreshRateChangedFB*)(baseEventHeader); + ALOGV( + "xrPollEvent: received XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB event: fromRate %f -> toRate %f", + refresh_rate_changed_event->fromDisplayRefreshRate, + refresh_rate_changed_event->toDisplayRefreshRate); + } break; + case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING: { + XrEventDataReferenceSpaceChangePending* ref_space_change_event = + (XrEventDataReferenceSpaceChangePending*)(baseEventHeader); + ALOGV( + "xrPollEvent: received XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING event: changed space: %d for session %p at time %f", + ref_space_change_event->referenceSpaceType, + (void*)ref_space_change_event->session, + FromXrTime(ref_space_change_event->changeTime)); + recenter = GL_TRUE; + } break; + case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: { + const XrEventDataSessionStateChanged* session_state_changed_event = + (XrEventDataSessionStateChanged*)(baseEventHeader); + ALOGV( + "xrPollEvent: received XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: %d for session %p at time %f", + session_state_changed_event->state, + (void*)session_state_changed_event->session, + FromXrTime(session_state_changed_event->time)); + + switch (session_state_changed_event->state) { + case XR_SESSION_STATE_FOCUSED: + app->Focused = true; + break; + case XR_SESSION_STATE_VISIBLE: + app->Focused = false; + break; + case XR_SESSION_STATE_READY: + case XR_SESSION_STATE_STOPPING: + ovrApp_HandleSessionStateChanges(app, session_state_changed_event->state); + break; + default: + break; + } + } break; + default: + ALOGV("xrPollEvent: Unknown event"); + break; } } + return recenter; } @@ -1448,7 +1525,7 @@ void JKVR_processMessageQueue() { case MESSAGE_ON_SURFACE_DESTROYED: { gAppState.NativeWindow = NULL; break; } } - ovrApp_HandleVrModeChanges( &gAppState ); + ovrApp_HandleXrEvents(&gAppState); } } @@ -1492,6 +1569,226 @@ void GL_APIENTRYP VR_GLDebugLog(GLenum source,GLenum type,GLuint id,GLenum sever } } +void VR_GetResolution(int *pWidth, int *pHeight) +{ + static int width = 0; + static int height = 0; + + // Enumerate the viewport configurations. + uint32_t viewportConfigTypeCount = 0; + OXR(xrEnumerateViewConfigurations( + gAppState.Instance, gAppState.SystemId, 0, &viewportConfigTypeCount, NULL)); + + XrViewConfigurationType* viewportConfigurationTypes = + (XrViewConfigurationType*)malloc(viewportConfigTypeCount * sizeof(XrViewConfigurationType)); + + OXR(xrEnumerateViewConfigurations( + gAppState.Instance, + gAppState.SystemId, + viewportConfigTypeCount, + &viewportConfigTypeCount, + viewportConfigurationTypes)); + + ALOGV("Available Viewport Configuration Types: %d", viewportConfigTypeCount); + + for (uint32_t i = 0; i < viewportConfigTypeCount; i++) { + const XrViewConfigurationType viewportConfigType = viewportConfigurationTypes[i]; + + ALOGV( + "Viewport configuration type %d : %s", + viewportConfigType, + viewportConfigType == XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO ? "Selected" : ""); + + XrViewConfigurationProperties viewportConfig; + viewportConfig.type = XR_TYPE_VIEW_CONFIGURATION_PROPERTIES; + OXR(xrGetViewConfigurationProperties( + gAppState.Instance, gAppState.SystemId, viewportConfigType, &viewportConfig)); + ALOGV( + "FovMutable=%s ConfigurationType %d", + viewportConfig.fovMutable ? "true" : "false", + viewportConfig.viewConfigurationType); + + uint32_t viewCount; + OXR(xrEnumerateViewConfigurationViews( + gAppState.Instance, gAppState.SystemId, viewportConfigType, 0, &viewCount, NULL)); + + if (viewCount > 0) { + XrViewConfigurationView* elements = + (XrViewConfigurationView*)malloc(viewCount * sizeof(XrViewConfigurationView)); + + for (uint32_t e = 0; e < viewCount; e++) { + elements[e].type = XR_TYPE_VIEW_CONFIGURATION_VIEW; + elements[e].next = NULL; + } + + OXR(xrEnumerateViewConfigurationViews( + gAppState.Instance, + gAppState.SystemId, + viewportConfigType, + viewCount, + &viewCount, + elements)); + + // Cache the view config properties for the selected config type. + if (viewportConfigType == XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO) { + assert(viewCount == ovrMaxNumEyes); + for (uint32_t e = 0; e < viewCount; e++) { + gAppState.ViewConfigurationView[e] = elements[e]; + } + } + + free(elements); + } else { + ALOGE("Empty viewport configuration type: %d", viewCount); + } + } + + free(viewportConfigurationTypes); + + *pWidth = width = gAppState.ViewConfigurationView[0].recommendedImageRectWidth; + *pHeight = height = gAppState.ViewConfigurationView[0].recommendedImageRectHeight; +} + +void VR_EnterVR( ) { + + if (gAppState.Session) { + Com_Printf("VR_EnterVR called with existing session"); + return; + } + + // Create the OpenXR Session. + XrGraphicsBindingOpenGLESAndroidKHR graphicsBindingAndroidGLES = {}; + graphicsBindingAndroidGLES.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR; + graphicsBindingAndroidGLES.next = NULL; + graphicsBindingAndroidGLES.display = eglGetCurrentDisplay(); + graphicsBindingAndroidGLES.config = eglGetCurrentSurface(EGL_DRAW); + graphicsBindingAndroidGLES.context = eglGetCurrentContext(); + + XrSessionCreateInfo sessionCreateInfo = {}; + memset(&sessionCreateInfo, 0, sizeof(sessionCreateInfo)); + sessionCreateInfo.type = XR_TYPE_SESSION_CREATE_INFO; + sessionCreateInfo.next = &graphicsBindingAndroidGLES; + sessionCreateInfo.createFlags = 0; + sessionCreateInfo.systemId = gAppState.SystemId; + + XrResult initResult; + OXR(initResult = xrCreateSession(gAppState.Instance, &sessionCreateInfo, &gAppState.Session)); + if (initResult != XR_SUCCESS) { + ALOGE("Failed to create XR session: %d.", initResult); + exit(1); + } + + // Create a space to the first path + XrReferenceSpaceCreateInfo spaceCreateInfo = {}; + spaceCreateInfo.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO; + spaceCreateInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_VIEW; + spaceCreateInfo.poseInReferenceSpace.orientation.w = 1.0f; + OXR(xrCreateReferenceSpace(gAppState.Session, &spaceCreateInfo, &gAppState.HeadSpace)); +} + +void VR_LeaveVR( ) { + if (gAppState.Session) { + OXR(xrDestroySpace(gAppState.HeadSpace)); + // StageSpace is optional. + if (gAppState.StageSpace != XR_NULL_HANDLE) { + OXR(xrDestroySpace(gAppState.StageSpace)); + } + OXR(xrDestroySpace(gAppState.FakeStageSpace)); + gAppState.CurrentSpace = XR_NULL_HANDLE; + OXR(xrDestroySession(gAppState.Session)); + gAppState.Session = NULL; + } +} + +void VR_InitRenderer( ) { + int eyeW, eyeH; + VR_GetResolution(&eyeW, &eyeH); + + // Get the viewport configuration info for the chosen viewport configuration type. + gAppState.ViewportConfig.type = XR_TYPE_VIEW_CONFIGURATION_PROPERTIES; + + OXR(xrGetViewConfigurationProperties( + gAppState.Instance, gAppState.SystemId, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, &gAppState.ViewportConfig)); + + // Get the supported display refresh rates for the system. + { + PFN_xrEnumerateDisplayRefreshRatesFB pfnxrEnumerateDisplayRefreshRatesFB = NULL; + OXR(xrGetInstanceProcAddr( + gAppState.Instance, + "xrEnumerateDisplayRefreshRatesFB", + (PFN_xrVoidFunction*)(&pfnxrEnumerateDisplayRefreshRatesFB))); + + OXR(pfnxrEnumerateDisplayRefreshRatesFB( + gAppState.Session, 0, &gAppState.NumSupportedDisplayRefreshRates, NULL)); + + gAppState.SupportedDisplayRefreshRates = + (float*)malloc(gAppState.NumSupportedDisplayRefreshRates * sizeof(float)); + OXR(pfnxrEnumerateDisplayRefreshRatesFB( + gAppState.Session, + gAppState.NumSupportedDisplayRefreshRates, + &gAppState.NumSupportedDisplayRefreshRates, + gAppState.SupportedDisplayRefreshRates)); + ALOGV("Supported Refresh Rates:"); + for (uint32_t i = 0; i < gAppState.NumSupportedDisplayRefreshRates; i++) { + ALOGV("%d:%f", i, gAppState.SupportedDisplayRefreshRates[i]); + } + + OXR(xrGetInstanceProcAddr( + gAppState.Instance, + "xrGetDisplayRefreshRateFB", + (PFN_xrVoidFunction*)(&gAppState.pfnGetDisplayRefreshRate))); + + float currentDisplayRefreshRate = 0.0f; + OXR(gAppState.pfnGetDisplayRefreshRate(gAppState.Session, ¤tDisplayRefreshRate)); + ALOGV("Current System Display Refresh Rate: %f", currentDisplayRefreshRate); + + OXR(xrGetInstanceProcAddr( + gAppState.Instance, + "xrRequestDisplayRefreshRateFB", + (PFN_xrVoidFunction*)(&gAppState.pfnRequestDisplayRefreshRate))); + + // Test requesting the system default. + OXR(gAppState.pfnRequestDisplayRefreshRate(gAppState.Session, 0.0f)); + ALOGV("Requesting system default display refresh rate"); + } + + uint32_t numOutputSpaces = 0; + OXR(xrEnumerateReferenceSpaces(gAppState.Session, 0, &numOutputSpaces, NULL)); + + XrReferenceSpaceType* referenceSpaces = + (XrReferenceSpaceType*)malloc(numOutputSpaces * sizeof(XrReferenceSpaceType)); + + OXR(xrEnumerateReferenceSpaces( + gAppState.Session, numOutputSpaces, &numOutputSpaces, referenceSpaces)); + + for (uint32_t i = 0; i < numOutputSpaces; i++) { + if (referenceSpaces[i] == XR_REFERENCE_SPACE_TYPE_STAGE) { + stageSupported = GL_TRUE; + break; + } + } + + free(referenceSpaces); + + if (gAppState.CurrentSpace == XR_NULL_HANDLE) { + VR_Recenter(engine); + } + + projections = (XrView*)(malloc(ovrMaxNumEyes * sizeof(XrView))); + + ovrRenderer_Create( + gAppState.Session, + &gAppState.Renderer, + gAppState.ViewConfigurationView[0].recommendedImageRectWidth, + gAppState.ViewConfigurationView[0].recommendedImageRectHeight); +} + +void VR_DestroyRenderer( ) +{ + ovrRenderer_Destroy(&gAppState.Renderer); + free(projections); +} + void * AppThreadFunction(void * parm ) { gAppThread = (ovrAppThread *) parm; @@ -1507,45 +1804,99 @@ void * AppThreadFunction(void * parm ) { openjk_initialised = false; vr_screen_dist = NULL; - const ovrInitParms initParms = vrapi_DefaultInitParms(&java); - int32_t initResult = vrapi_Initialize(&initParms); - if (initResult != VRAPI_INITIALIZE_SUCCESS) { - // If intialization failed, vrapi_* function calls will not be available. - exit(0); - } - ovrApp_Clear(&gAppState); gAppState.Java = java; - // This app will handle android gamepad events itself. - vrapi_SetPropertyInt(&gAppState.Java, VRAPI_EAT_NATIVE_GAMEPAD_EVENTS, 0); + + PFN_xrInitializeLoaderKHR xrInitializeLoaderKHR; + xrGetInstanceProcAddr( + XR_NULL_HANDLE, "xrInitializeLoaderKHR", (PFN_xrVoidFunction*)&xrInitializeLoaderKHR); + if (xrInitializeLoaderKHR != NULL) { + XrLoaderInitInfoAndroidKHR loaderInitializeInfoAndroid; + memset(&loaderInitializeInfoAndroid, 0, sizeof(loaderInitializeInfoAndroid)); + loaderInitializeInfoAndroid.type = XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR; + loaderInitializeInfoAndroid.next = NULL; + loaderInitializeInfoAndroid.applicationVM = java.Vm; + loaderInitializeInfoAndroid.applicationContext = java.ActivityObject; + xrInitializeLoaderKHR((XrLoaderInitInfoBaseHeaderKHR*)&loaderInitializeInfoAndroid); + } + + // Create the OpenXR instance. + XrApplicationInfo appInfo; + memset(&appInfo, 0, sizeof(appInfo)); + strcpy(appInfo.applicationName, "JKQUest"); + appInfo.applicationVersion = 0; + strcpy(appInfo.engineName, "JKQuest"); + appInfo.engineVersion = 0; + appInfo.apiVersion = XR_CURRENT_API_VERSION; + + XrInstanceCreateInfo instanceCreateInfo; + memset(&instanceCreateInfo, 0, sizeof(instanceCreateInfo)); + instanceCreateInfo.type = XR_TYPE_INSTANCE_CREATE_INFO; + instanceCreateInfo.next = NULL; + instanceCreateInfo.createFlags = 0; + instanceCreateInfo.applicationInfo = appInfo; + instanceCreateInfo.enabledApiLayerCount = 0; + instanceCreateInfo.enabledApiLayerNames = NULL; + instanceCreateInfo.enabledExtensionCount = numRequiredExtensions; + instanceCreateInfo.enabledExtensionNames = requiredExtensionNames; + + XrResult initResult; + OXR(initResult = xrCreateInstance(&instanceCreateInfo, &gAppState.Instance)); + if (initResult != XR_SUCCESS) { + ALOGE("Failed to create XR instance: %d.", initResult); + exit(1); + } + + XrInstanceProperties instanceInfo; + instanceInfo.type = XR_TYPE_INSTANCE_PROPERTIES; + instanceInfo.next = NULL; + OXR(xrGetInstanceProperties(gAppState.Instance, &instanceInfo)); + ALOGV( + "Runtime %s: Version : %u.%u.%u", + instanceInfo.runtimeName, + XR_VERSION_MAJOR(instanceInfo.runtimeVersion), + XR_VERSION_MINOR(instanceInfo.runtimeVersion), + XR_VERSION_PATCH(instanceInfo.runtimeVersion)); + + XrSystemGetInfo systemGetInfo; + memset(&systemGetInfo, 0, sizeof(systemGetInfo)); + systemGetInfo.type = XR_TYPE_SYSTEM_GET_INFO; + systemGetInfo.next = NULL; + systemGetInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY; + + OXR(initResult = xrGetSystem(gAppState.Instance, &systemGetInfo, &gAppState.SystemId)); + if (initResult != XR_SUCCESS) { + ALOGE("Failed to get system."); + exit(1); + } + + // Get the graphics requirements. + PFN_xrGetOpenGLESGraphicsRequirementsKHR pfnGetOpenGLESGraphicsRequirementsKHR = NULL; + OXR(xrGetInstanceProcAddr( + vr_engine.appState.Instance, + "xrGetOpenGLESGraphicsRequirementsKHR", + (PFN_xrVoidFunction*)(&pfnGetOpenGLESGraphicsRequirementsKHR))); + + XrGraphicsRequirementsOpenGLESKHR graphicsRequirements = {}; + graphicsRequirements.type = XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR; + OXR(pfnGetOpenGLESGraphicsRequirementsKHR(gAppState.Instance, gAppState.SystemId, &graphicsRequirements)); + + //Set device defaults - if (vrapi_GetSystemPropertyInt(&java, VRAPI_SYS_PROP_DEVICE_TYPE) == VRAPI_DEVICE_TYPE_OCULUSQUEST) - { - if (SS_MULTIPLIER == 0.0f) - { - SS_MULTIPLIER = 1.0f; - } - } - else if (vrapi_GetSystemPropertyInt(&java, VRAPI_SYS_PROP_DEVICE_TYPE) == VRAPI_DEVICE_TYPE_OCULUSQUEST2) - { - if (SS_MULTIPLIER == 0.0f) - { - //GB Override as refresh is now 72 by default as we decided a higher res is better as 90hz has stutters - SS_MULTIPLIER = 1.25f; - } - else if (SS_MULTIPLIER > 1.5f) - { - SS_MULTIPLIER = 1.5f; - } - } else { - //Don't know what headset this is!? abort - return NULL; - } + if (SS_MULTIPLIER == 0.0f) + { + //GB Override as refresh is now 72 by default as we decided a higher res is better as 90hz has stutters + SS_MULTIPLIER = 1.25f; + } + else if (SS_MULTIPLIER > 1.5f) + { + SS_MULTIPLIER = 1.5f; + } //Using a symmetrical render target - m_height = m_width = (int)(vrapi_GetSystemPropertyInt(&java, VRAPI_SYS_PROP_SUGGESTED_EYE_TEXTURE_WIDTH) * SS_MULTIPLIER); + VR_GetResolution(m_height, m_width); gAppState.CpuLevel = CPU_LEVEL; gAppState.GpuLevel = GPU_LEVEL; @@ -1560,17 +1911,9 @@ void * AppThreadFunction(void * parm ) { JKVR_processMessageQueue(); } -#ifdef ENABLE_GL_DEBUG - glEnable(GL_DEBUG_OUTPUT); - glDebugMessageCallback(reinterpret_cast(VR_GLDebugLog), 0); -#endif - + VR_EnterVR(); ovrRenderer_Create(m_width, m_height, &gAppState.Renderer, &java); - if ( gAppState.Ovr == NULL ) - { - return NULL; - } // Create the scene if not yet created. ovrScene_Create( m_width, m_height, &gAppState.Scene, &java ); @@ -1823,8 +2166,8 @@ void JKVR_getHMDOrientation() {//Get orientation // We extract Yaw, Pitch, Roll instead of directly using the orientation // to allow "additional" yaw manipulation with mouse/controller. - const ovrQuatf quatHmd = tracking.HeadPose.Pose.Orientation; - const ovrVector3f positionHmd = tracking.HeadPose.Pose.Position; + const ovrQuatf quatHmd = tracking.Pose.orientation; + const ovrVector3f positionHmd = tracking.Pose.position; vec3_t rotation = {0, 0, 0}; QuatToYawPitchRoll(quatHmd, rotation, vr.hmdorientation); setHMDPosition(positionHmd.x, positionHmd.y, positionHmd.z); @@ -1869,22 +2212,21 @@ void JKVR_getTrackedRemotesOrientation() {//Get info for tracked remotes switch (vr_control_scheme->integer) { case RIGHT_HANDED_DEFAULT: - HandleInput_Default(&footTrackedRemoteState_new, &footTrackedRemoteState_old, - &rightTrackedRemoteState_new, &rightTrackedRemoteState_old, &rightRemoteTracking_new, + HandleInput_Default(&rightTrackedRemoteState_new, &rightTrackedRemoteState_old, &rightRemoteTracking_new, &leftTrackedRemoteState_new, &leftTrackedRemoteState_old, &leftRemoteTracking_new, - ovrButton_A, ovrButton_B, ovrButton_X, ovrButton_Y); + xrButton_A, xrButton_B, xrButton_X, xrButton_Y); break; case LEFT_HANDED_DEFAULT: - HandleInput_Default(&footTrackedRemoteState_new, &footTrackedRemoteState_old, - &leftTrackedRemoteState_new, &leftTrackedRemoteState_old, &leftRemoteTracking_new, + HandleInput_Default(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, &leftRemoteTracking_new, &rightTrackedRemoteState_new, &rightTrackedRemoteState_old, &rightRemoteTracking_new, - ovrButton_X, ovrButton_Y, ovrButton_A, ovrButton_B); + xrButton_X, xrButton_Y, xrButton_A, xrButton_B); break; - case WEAPON_ALIGN: +/* case WEAPON_ALIGN: HandleInput_WeaponAlign(&rightTrackedRemoteState_new, &rightTrackedRemoteState_old, &rightRemoteTracking_new, &leftTrackedRemoteState_new, &leftTrackedRemoteState_old, &leftRemoteTracking_new, - ovrButton_A, ovrButton_B, ovrButton_X, ovrButton_Y); + xrButton_A, xrButton_B, xrButton_X, xrButton_Y); break; + */ } } diff --git a/Projects/Android/jni/JKVR/VrCommon.h b/Projects/Android/jni/JKVR/VrCommon.h index c81ec63..60fb438 100644 --- a/Projects/Android/jni/JKVR/VrCommon.h +++ b/Projects/Android/jni/JKVR/VrCommon.h @@ -1,7 +1,18 @@ #if !defined(vrcommon_h) #define vrcommon_h -#include +//OpenXR +#define XR_USE_GRAPHICS_API_OPENGL_ES 1 +#define XR_USE_PLATFORM_ANDROID 1 +#include +#include +#include +#include +#include +#include +#include +#include +#include #include @@ -25,23 +36,158 @@ #endif +enum { ovrMaxLayerCount = 1 }; +enum { ovrMaxNumEyes = 2 }; + +typedef enum xrButton_ { + xrButton_A = 0x00000001, // Set for trigger pulled on the Gear VR and Go Controllers + xrButton_B = 0x00000002, + xrButton_RThumb = 0x00000004, + xrButton_RShoulder = 0x00000008, + xrButton_X = 0x00000100, + xrButton_Y = 0x00000200, + xrButton_LThumb = 0x00000400, + xrButton_LShoulder = 0x00000800, + xrButton_Up = 0x00010000, + xrButton_Down = 0x00020000, + xrButton_Left = 0x00040000, + xrButton_Right = 0x00080000, + xrButton_Enter = 0x00100000, + xrButton_Back = 0x00200000, + xrButton_GripTrigger = 0x04000000, + xrButton_Trigger = 0x20000000, + xrButton_Joystick = 0x80000000, + xrButton_EnumSize = 0x7fffffff +} xrButton; + +typedef struct ovrInputStateTrackedRemote_ { + uint32_t Buttons; + float IndexTrigger; + float GripTrigger; + XrVector2f Joystick; +} ovrInputStateTrackedRemote; + +typedef struct { + GLboolean Active; + XrPosef Pose; + XrSpaceVelocity Velocity; +} ovrTrackedController; + typedef enum control_scheme { RIGHT_HANDED_DEFAULT = 0, LEFT_HANDED_DEFAULT = 10, WEAPON_ALIGN = 99 } control_scheme_t; +typedef struct { + float M[4][4]; +} ovrMatrix4f; + + +typedef struct { + XrSwapchain Handle; + uint32_t Width; + uint32_t Height; +} ovrSwapChain; + +typedef struct { + int Width; + int Height; + uint32_t TextureSwapChainLength; + uint32_t TextureSwapChainIndex; + ovrSwapChain ColorSwapChain; + XrSwapchainImageOpenGLESKHR* ColorSwapChainImage; + GLuint* DepthBuffers; + GLuint* FrameBuffers; +} ovrFramebuffer; + + +/* +================================================================================ + +ovrRenderer + +================================================================================ +*/ + +typedef struct +{ + ovrFramebuffer FrameBuffer[ovrMaxNumEyes]; + ovrMatrix4f ProjectionMatrix; + int NumBuffers; +} ovrRenderer; + +/* +================================================================================ + +ovrApp + +================================================================================ +*/ + +typedef union { + XrCompositionLayerProjection Projection; + XrCompositionLayerCylinderKHR Cylinder; +} ovrCompositorLayer_Union; + +#define GL(func) func; +#define OXR(func) func; + +typedef struct +{ + bool Resumed; + bool Focused; + + XrInstance Instance; + XrSession Session; + XrViewConfigurationProperties ViewportConfig; + XrViewConfigurationView ViewConfigurationView[ovrMaxNumEyes]; + XrSystemId SystemId; + XrSpace HeadSpace; + XrSpace StageSpace; + XrSpace FakeStageSpace; + XrSpace CurrentSpace; + GLboolean SessionActive; + + float* SupportedDisplayRefreshRates; + uint32_t RequestedDisplayRefreshRateIndex; + uint32_t NumSupportedDisplayRefreshRates; + PFN_xrGetDisplayRefreshRateFB pfnGetDisplayRefreshRate; + PFN_xrRequestDisplayRefreshRateFB pfnRequestDisplayRefreshRate; + + long long FrameIndex; + double DisplayTime; + int SwapInterval; + int CpuLevel; + int GpuLevel; + int MainThreadTid; + int RenderThreadTid; + ovrCompositorLayer_Union Layers[ovrMaxLayerCount]; + int LayerCount; + ovrRenderer Renderer; + ovrTrackedController TrackedController[2]; +} ovrApp; + + extern bool openjk_initialised; extern long long global_time; -extern ovrTracking2 tracking; extern int ducked; extern vr_client_info_t vr; -#define DUCK_NOTDUCKED 0 -#define DUCK_BUTTON 1 -#define DUCK_CROUCHED 2 +void ovrTrackedController_Clear(ovrTrackedController* controller); +ovrMatrix4f ovrMatrix4f_Multiply(const ovrMatrix4f* a, const ovrMatrix4f* b); +ovrMatrix4f ovrMatrix4f_CreateRotation(const float radiansX, const float radiansY, const float radiansZ); +ovrMatrix4f ovrMatrix4f_CreateFromQuaternion(const XrQuaternionf* q); +ovrMatrix4f ovrMatrix4f_CreateProjectionFov( + const float fovDegreesX, + const float fovDegreesY, + const float offsetX, + const float offsetY, + const float nearZ, + const float farZ); +XrVector4f XrVector4f_MultiplyMatrix4f(const ovrMatrix4f* a, const XrVector4f* v); float radians(float deg); float degrees(float rad); @@ -51,7 +197,7 @@ float length(float x, float y); float nonLinearFilter(float in); bool between(float min, float val, float max); void rotateAboutOrigin(float v1, float v2, float rotation, vec2_t out); -void QuatToYawPitchRoll(ovrQuatf q, vec3_t rotation, vec3_t out); +void QuatToYawPitchRoll(XrQuaternionf q, vec3_t rotation, vec3_t out); void handleTrackedControllerButton(ovrInputStateTrackedRemote * trackedRemoteState, ovrInputStateTrackedRemote * prevTrackedRemoteState, uint32_t button, int key); void interactWithTouchScreen(bool reset, ovrInputStateTrackedRemote *newState, ovrInputStateTrackedRemote *oldState); int GetRefresh(); diff --git a/Projects/Android/jni/JKVR/VrCompositor.cpp b/Projects/Android/jni/JKVR/VrCompositor.cpp index e67cfa6..d97ef01 100644 --- a/Projects/Android/jni/JKVR/VrCompositor.cpp +++ b/Projects/Android/jni/JKVR/VrCompositor.cpp @@ -14,52 +14,22 @@ Filename : VrCompositor.c #include #include // for AWINDOW_FLAG_KEEP_SCREEN_ON + +//OpenXR +#define XR_USE_GRAPHICS_API_OPENGL_ES 1 +#define XR_USE_PLATFORM_ANDROID 1 #include #include #include #include -#include - - - -#include -#include +#include +#include +#include +#include +#include #include "VrCompositor.h" - - -/* -================================================================================ - -renderState - -================================================================================ -*/ - - -void getCurrentRenderState( renderState * state) -{ - state->VertexBuffer = 0; - state->IndexBuffer = 0; - state->VertexArrayObject = 0; - state->Program = 0; - - glGetIntegerv(GL_ARRAY_BUFFER, &state->VertexBuffer ); - glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER, &state->IndexBuffer ); - glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &state->VertexArrayObject ); - glGetIntegerv(GL_CURRENT_PROGRAM, &state->Program ); -} - -void restoreRenderState( renderState * state ) -{ - GL( glUseProgram( state->Program ) ); - GL( glBindVertexArray( state->VertexArrayObject ) ); - GL( glBindBuffer( GL_ARRAY_BUFFER, state->VertexBuffer ) ); - GL( glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, state->IndexBuffer ) ); -} - - /* ================================================================================ @@ -82,7 +52,7 @@ bool ovrScene_IsCreated( ovrScene * scene ) return scene->CreatedScene; } -void ovrScene_Create( int width, int height, ovrScene * scene, const ovrJava * java ) +void ovrScene_Create( int width, int height, ovrScene * scene ) { // Create Cylinder renderer { @@ -90,7 +60,7 @@ void ovrScene_Create( int width, int height, ovrScene * scene, const ovrJava * j scene->CylinderHeight = height; //Create cylinder renderer - ovrRenderer_Create( width, height, &scene->CylinderRenderer, java ); + ovrRenderer_Create( width, height, &scene->CylinderRenderer ); } scene->CreatedScene = true; diff --git a/Projects/Android/jni/JKVR/VrCompositor.h b/Projects/Android/jni/JKVR/VrCompositor.h index be86ba6..78e0cb6 100644 --- a/Projects/Android/jni/JKVR/VrCompositor.h +++ b/Projects/Android/jni/JKVR/VrCompositor.h @@ -53,17 +53,6 @@ ovrFramebuffer ================================================================================ */ -typedef struct -{ - int Width; - int Height; - int Multisamples; - int TextureSwapChainLength; - int TextureSwapChainIndex; - ovrTextureSwapChain * ColorTextureSwapChain; - GLuint * DepthBuffers; - GLuint * FrameBuffers; -} ovrFramebuffer; void ovrFramebuffer_SetCurrent( ovrFramebuffer * frameBuffer ); void ovrFramebuffer_Destroy( ovrFramebuffer * frameBuffer ); @@ -72,48 +61,32 @@ void ovrFramebuffer_Resolve( ovrFramebuffer * frameBuffer ); void ovrFramebuffer_Advance( ovrFramebuffer * frameBuffer ); void ovrFramebuffer_ClearEdgeTexels( ovrFramebuffer * frameBuffer ); -/* -================================================================================ -ovrRenderer +XrView* projections; +GLboolean stageSupported = GL_FALSE; -================================================================================ -*/ +void VR_UpdateStageBounds(ovrApp* pappState) { + XrExtent2Df stageBounds = {}; -typedef struct -{ - ovrFramebuffer FrameBuffer[VRAPI_FRAME_LAYER_EYE_MAX]; - ovrMatrix4f ProjectionMatrix; - int NumBuffers; -} ovrRenderer; + XrResult result; + OXR(result = xrGetReferenceSpaceBoundsRect( + pappState->Session, XR_REFERENCE_SPACE_TYPE_STAGE, &stageBounds)); + if (result != XR_SUCCESS) { + ALOGV("Stage bounds query failed: using small defaults"); + stageBounds.width = 1.0f; + stageBounds.height = 1.0f; + pappState->CurrentSpace = pappState->FakeStageSpace; + } + + ALOGV("Stage bounds: width = %f, depth %f", stageBounds.width, stageBounds.height); +} void ovrRenderer_Clear( ovrRenderer * renderer ); -void ovrRenderer_Create( int width, int height, ovrRenderer * renderer, const ovrJava * java ); +void ovrRenderer_Create(XrSession session, int width, int height, ovrRenderer * renderer ); void ovrRenderer_Destroy( ovrRenderer * renderer ); -/* -================================================================================ - -renderState - -================================================================================ -*/ - -typedef struct -{ - GLint VertexBuffer; - GLint IndexBuffer; - GLint VertexArrayObject; - GLint Program; - GLint VertexShader; - GLint FragmentShader; -} renderState; - -void getCurrentRenderState( renderState * state); -void restoreRenderState( renderState * state ); - /* ================================================================================ @@ -186,26 +159,8 @@ typedef struct } ovrScene; void ovrScene_Clear( ovrScene * scene ); -void ovrScene_Create( int width, int height, ovrScene * scene, const ovrJava * java ); +void ovrScene_Create( int width, int height, ovrScene * scene ); void ovrScene_Destroy( ovrScene * scene ); -/* -================================================================================ - -ovrRenderer - -================================================================================ -*/ - -ovrLayerProjection2 ovrRenderer_RenderGroundPlaneToEyeBuffer( ovrRenderer * renderer, const ovrJava * java, - const ovrScene * scene, const ovrTracking2 * tracking ); - -ovrLayerProjection2 ovrRenderer_RenderToEyeBuffer( ovrRenderer * renderer, const ovrJava * java, - const ovrTracking2 * tracking ); - -ovrLayerCylinder2 BuildCylinderLayer( ovrRenderer * cylinderRenderer, - const int textureWidth, const int textureHeight, - const ovrTracking2 * tracking, float rotateYaw ); -; diff --git a/Projects/Android/jni/JKVR/VrInput.h b/Projects/Android/jni/JKVR/VrInput.h index 399a8a7..50813ee 100644 --- a/Projects/Android/jni/JKVR/VrInput.h +++ b/Projects/Android/jni/JKVR/VrInput.h @@ -6,15 +6,13 @@ #define STABILISATION_DISTANCE 0.28 + extern ovrInputStateTrackedRemote leftTrackedRemoteState_old; extern ovrInputStateTrackedRemote leftTrackedRemoteState_new; -extern ovrTracking leftRemoteTracking_new; +extern ovrTrackedController leftRemoteTracking_new; extern ovrInputStateTrackedRemote rightTrackedRemoteState_old; extern ovrInputStateTrackedRemote rightTrackedRemoteState_new; -extern ovrTracking rightRemoteTracking_new; -extern ovrInputStateGamepad footTrackedRemoteState_old; -extern ovrInputStateGamepad footTrackedRemoteState_new; -extern ovrDeviceID controllerIDs[2]; +extern ovrTrackedController rightRemoteTracking_new; extern float remote_movementSideways; extern float remote_movementForward; @@ -25,15 +23,12 @@ extern float positional_movementForward; void sendButtonAction(const char* action, long buttonDown); void sendButtonActionSimple(const char* action); -void acquireTrackedRemotesData(ovrMobile *Ovr, double displayTime); - -void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateGamepad *pFootTrackingOld, - ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTracking* pDominantTracking, - ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTracking* pOffTracking, +void HandleInput_Default( ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTrackedController* pDominantTracking, + ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTrackedController* pOffTracking, int domButton1, int domButton2, int offButton1, int offButton2 ); -void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTracking* pDominantTracking, - ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTracking* pOffTracking, +void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTrackedController* pDominantTracking, + ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTrackedController* pOffTracking, int domButton1, int domButton2, int offButton1, int offButton2 ); diff --git a/Projects/Android/jni/JKVR/VrInputCommon.cpp b/Projects/Android/jni/JKVR/VrInputCommon.cpp index 336c13e..019463a 100644 --- a/Projects/Android/jni/JKVR/VrInputCommon.cpp +++ b/Projects/Android/jni/JKVR/VrInputCommon.cpp @@ -7,12 +7,6 @@ Authors : Simon Brown *************************************************************************************/ -#include -#include -#include -#include -#include - #include "VrInput.h" #include @@ -45,13 +39,10 @@ cvar_t *vr_use_gesture_boundary; ovrInputStateTrackedRemote leftTrackedRemoteState_old; ovrInputStateTrackedRemote leftTrackedRemoteState_new; -ovrTracking leftRemoteTracking_new; +ovrTrackedController leftRemoteTracking_new; ovrInputStateTrackedRemote rightTrackedRemoteState_old; ovrInputStateTrackedRemote rightTrackedRemoteState_new; -ovrTracking rightRemoteTracking_new; -ovrInputStateGamepad footTrackedRemoteState_old; -ovrInputStateGamepad footTrackedRemoteState_new; -ovrDeviceID controllerIDs[2]; +ovrTrackedController rightRemoteTracking_new; float remote_movementSideways; float remote_movementForward; @@ -60,7 +51,6 @@ float positional_movementSideways; float positional_movementForward; bool openjk_initialised; long long global_time; -ovrTracking2 tracking; int ducked; vr_client_info_t vr; @@ -133,58 +123,6 @@ void sendButtonAction(const char* action, long buttonDown) Cbuf_AddText( command ); } -void acquireTrackedRemotesData(ovrMobile *Ovr, double displayTime) {//The amount of yaw changed by controller - - for ( uint32_t i = 0; ; i++ ) { - ovrInputCapabilityHeader cap; - ovrResult result = vrapi_EnumerateInputDevices(Ovr, i, &cap); - if (result < 0) { - break; - } - - if (cap.Type == ovrControllerType_Gamepad) { - - ovrInputGamepadCapabilities remoteCaps; - remoteCaps.Header = cap; - if (vrapi_GetInputDeviceCapabilities(Ovr, &remoteCaps.Header) >= 0) { - // remote is connected - ovrInputStateGamepad remoteState; - remoteState.Header.ControllerType = ovrControllerType_Gamepad; - if ( vrapi_GetCurrentInputState( Ovr, cap.DeviceID, &remoteState.Header ) >= 0 ) - { - // act on device state returned in remoteState - footTrackedRemoteState_new = remoteState; - } - } - } - else if (cap.Type == ovrControllerType_TrackedRemote) { - ovrTracking remoteTracking; - ovrInputStateTrackedRemote trackedRemoteState; - trackedRemoteState.Header.ControllerType = ovrControllerType_TrackedRemote; - result = vrapi_GetCurrentInputState(Ovr, cap.DeviceID, &trackedRemoteState.Header); - - if (result == ovrSuccess) { - ovrInputTrackedRemoteCapabilities remoteCapabilities; - remoteCapabilities.Header = cap; - result = vrapi_GetInputDeviceCapabilities(Ovr, &remoteCapabilities.Header); - - result = vrapi_GetInputTrackingState(Ovr, cap.DeviceID, displayTime, - &remoteTracking); - - if (remoteCapabilities.ControllerCapabilities & ovrControllerCaps_RightHand) { - rightTrackedRemoteState_new = trackedRemoteState; - rightRemoteTracking_new = remoteTracking; - controllerIDs[1] = cap.DeviceID; - } else{ - leftTrackedRemoteState_new = trackedRemoteState; - leftRemoteTracking_new = remoteTracking; - controllerIDs[0] = cap.DeviceID; - } - } - } - } -} - void PortableMouseAbs(float x,float y); float clamp(float _min, float _val, float _max) { @@ -202,4 +140,195 @@ void interactWithTouchScreen(bool reset, ovrInputStateTrackedRemote *newState, o float cursorY = (float)(vr.weaponangles[PITCH] / 90.0) + 0.5f; PortableMouseAbs(cursorX, cursorY); -} \ No newline at end of file +} + + +/* +================================================================================ + +ovrMatrix4f + +================================================================================ +*/ + +ovrMatrix4f ovrMatrix4f_CreateProjectionFov( + const float angleLeft, + const float angleRight, + const float angleUp, + const float angleDown, + const float nearZ, + const float farZ) { + + const float tanAngleLeft = tanf(angleLeft); + const float tanAngleRight = tanf(angleRight); + + const float tanAngleDown = tanf(angleDown); + const float tanAngleUp = tanf(angleUp); + + const float tanAngleWidth = tanAngleRight - tanAngleLeft; + + // Set to tanAngleDown - tanAngleUp for a clip space with positive Y + // down (Vulkan). Set to tanAngleUp - tanAngleDown for a clip space with + // positive Y up (OpenGL / D3D / Metal). + const float tanAngleHeight = tanAngleUp - tanAngleDown; + + // Set to nearZ for a [-1,1] Z clip space (OpenGL / OpenGL ES). + // Set to zero for a [0,1] Z clip space (Vulkan / D3D / Metal). + const float offsetZ = nearZ; + + ovrMatrix4f result; + if (farZ <= nearZ) { + // place the far plane at infinity + result.M[0][0] = 2 / tanAngleWidth; + result.M[0][1] = 0; + result.M[0][2] = (tanAngleRight + tanAngleLeft) / tanAngleWidth; + result.M[0][3] = 0; + + result.M[1][0] = 0; + result.M[1][1] = 2 / tanAngleHeight; + result.M[1][2] = (tanAngleUp + tanAngleDown) / tanAngleHeight; + result.M[1][3] = 0; + + result.M[2][0] = 0; + result.M[2][1] = 0; + result.M[2][2] = -1; + result.M[2][3] = -(nearZ + offsetZ); + + result.M[3][0] = 0; + result.M[3][1] = 0; + result.M[3][2] = -1; + result.M[3][3] = 0; + } else { + // normal projection + result.M[0][0] = 2 / tanAngleWidth; + result.M[0][1] = 0; + result.M[0][2] = (tanAngleRight + tanAngleLeft) / tanAngleWidth; + result.M[0][3] = 0; + + result.M[1][0] = 0; + result.M[1][1] = 2 / tanAngleHeight; + result.M[1][2] = (tanAngleUp + tanAngleDown) / tanAngleHeight; + result.M[1][3] = 0; + + result.M[2][0] = 0; + result.M[2][1] = 0; + result.M[2][2] = -(farZ + offsetZ) / (farZ - nearZ); + result.M[2][3] = -(farZ * (nearZ + offsetZ)) / (farZ - nearZ); + + result.M[3][0] = 0; + result.M[3][1] = 0; + result.M[3][2] = -1; + result.M[3][3] = 0; + } + return result; +} + +ovrMatrix4f ovrMatrix4f_CreateFromQuaternion(const XrQuaternionf* q) { + const float ww = q->w * q->w; + const float xx = q->x * q->x; + const float yy = q->y * q->y; + const float zz = q->z * q->z; + + ovrMatrix4f out; + out.M[0][0] = ww + xx - yy - zz; + out.M[0][1] = 2 * (q->x * q->y - q->w * q->z); + out.M[0][2] = 2 * (q->x * q->z + q->w * q->y); + out.M[0][3] = 0; + + out.M[1][0] = 2 * (q->x * q->y + q->w * q->z); + out.M[1][1] = ww - xx + yy - zz; + out.M[1][2] = 2 * (q->y * q->z - q->w * q->x); + out.M[1][3] = 0; + + out.M[2][0] = 2 * (q->x * q->z - q->w * q->y); + out.M[2][1] = 2 * (q->y * q->z + q->w * q->x); + out.M[2][2] = ww - xx - yy + zz; + out.M[2][3] = 0; + + out.M[3][0] = 0; + out.M[3][1] = 0; + out.M[3][2] = 0; + out.M[3][3] = 1; + return out; +} + + +/// Use left-multiplication to accumulate transformations. +ovrMatrix4f ovrMatrix4f_Multiply(const ovrMatrix4f* a, const ovrMatrix4f* b) { + ovrMatrix4f out; + out.M[0][0] = a->M[0][0] * b->M[0][0] + a->M[0][1] * b->M[1][0] + a->M[0][2] * b->M[2][0] + + a->M[0][3] * b->M[3][0]; + out.M[1][0] = a->M[1][0] * b->M[0][0] + a->M[1][1] * b->M[1][0] + a->M[1][2] * b->M[2][0] + + a->M[1][3] * b->M[3][0]; + out.M[2][0] = a->M[2][0] * b->M[0][0] + a->M[2][1] * b->M[1][0] + a->M[2][2] * b->M[2][0] + + a->M[2][3] * b->M[3][0]; + out.M[3][0] = a->M[3][0] * b->M[0][0] + a->M[3][1] * b->M[1][0] + a->M[3][2] * b->M[2][0] + + a->M[3][3] * b->M[3][0]; + + out.M[0][1] = a->M[0][0] * b->M[0][1] + a->M[0][1] * b->M[1][1] + a->M[0][2] * b->M[2][1] + + a->M[0][3] * b->M[3][1]; + out.M[1][1] = a->M[1][0] * b->M[0][1] + a->M[1][1] * b->M[1][1] + a->M[1][2] * b->M[2][1] + + a->M[1][3] * b->M[3][1]; + out.M[2][1] = a->M[2][0] * b->M[0][1] + a->M[2][1] * b->M[1][1] + a->M[2][2] * b->M[2][1] + + a->M[2][3] * b->M[3][1]; + out.M[3][1] = a->M[3][0] * b->M[0][1] + a->M[3][1] * b->M[1][1] + a->M[3][2] * b->M[2][1] + + a->M[3][3] * b->M[3][1]; + + out.M[0][2] = a->M[0][0] * b->M[0][2] + a->M[0][1] * b->M[1][2] + a->M[0][2] * b->M[2][2] + + a->M[0][3] * b->M[3][2]; + out.M[1][2] = a->M[1][0] * b->M[0][2] + a->M[1][1] * b->M[1][2] + a->M[1][2] * b->M[2][2] + + a->M[1][3] * b->M[3][2]; + out.M[2][2] = a->M[2][0] * b->M[0][2] + a->M[2][1] * b->M[1][2] + a->M[2][2] * b->M[2][2] + + a->M[2][3] * b->M[3][2]; + out.M[3][2] = a->M[3][0] * b->M[0][2] + a->M[3][1] * b->M[1][2] + a->M[3][2] * b->M[2][2] + + a->M[3][3] * b->M[3][2]; + + out.M[0][3] = a->M[0][0] * b->M[0][3] + a->M[0][1] * b->M[1][3] + a->M[0][2] * b->M[2][3] + + a->M[0][3] * b->M[3][3]; + out.M[1][3] = a->M[1][0] * b->M[0][3] + a->M[1][1] * b->M[1][3] + a->M[1][2] * b->M[2][3] + + a->M[1][3] * b->M[3][3]; + out.M[2][3] = a->M[2][0] * b->M[0][3] + a->M[2][1] * b->M[1][3] + a->M[2][2] * b->M[2][3] + + a->M[2][3] * b->M[3][3]; + out.M[3][3] = a->M[3][0] * b->M[0][3] + a->M[3][1] * b->M[1][3] + a->M[3][2] * b->M[2][3] + + a->M[3][3] * b->M[3][3]; + return out; +} + +ovrMatrix4f ovrMatrix4f_CreateRotation(const float radiansX, const float radiansY, const float radiansZ) { + const float sinX = sinf(radiansX); + const float cosX = cosf(radiansX); + const ovrMatrix4f rotationX = { + {{1, 0, 0, 0}, {0, cosX, -sinX, 0}, {0, sinX, cosX, 0}, {0, 0, 0, 1}}}; + const float sinY = sinf(radiansY); + const float cosY = cosf(radiansY); + const ovrMatrix4f rotationY = { + {{cosY, 0, sinY, 0}, {0, 1, 0, 0}, {-sinY, 0, cosY, 0}, {0, 0, 0, 1}}}; + const float sinZ = sinf(radiansZ); + const float cosZ = cosf(radiansZ); + const ovrMatrix4f rotationZ = { + {{cosZ, -sinZ, 0, 0}, {sinZ, cosZ, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}}; + const ovrMatrix4f rotationXY = ovrMatrix4f_Multiply(&rotationY, &rotationX); + return ovrMatrix4f_Multiply(&rotationZ, &rotationXY); +} + +XrVector4f XrVector4f_MultiplyMatrix4f(const ovrMatrix4f* a, const XrVector4f* v) { + XrVector4f out; + out.x = a->M[0][0] * v->x + a->M[0][1] * v->y + a->M[0][2] * v->z + a->M[0][3] * v->w; + out.y = a->M[1][0] * v->x + a->M[1][1] * v->y + a->M[1][2] * v->z + a->M[1][3] * v->w; + out.z = a->M[2][0] * v->x + a->M[2][1] * v->y + a->M[2][2] * v->z + a->M[2][3] * v->w; + out.w = a->M[3][0] * v->x + a->M[3][1] * v->y + a->M[3][2] * v->z + a->M[3][3] * v->w; + return out; +} + +/* +================================================================================ + +ovrTrackedController + +================================================================================ +*/ + +void ovrTrackedController_Clear(ovrTrackedController* controller) { + controller->Active = false; + controller->Pose = XrPosef_Identity(); +} diff --git a/Projects/Android/jni/JKVR/VrInputDefault.cpp b/Projects/Android/jni/JKVR/VrInputDefault.cpp index 1226404..587d213 100644 --- a/Projects/Android/jni/JKVR/VrInputDefault.cpp +++ b/Projects/Android/jni/JKVR/VrInputDefault.cpp @@ -7,12 +7,6 @@ Authors : Simon Brown *************************************************************************************/ -#include -#include -#include -#include -#include - #include #include "VrInput.h" @@ -35,9 +29,8 @@ static inline float AngleBetweenVectors(const vec3_t a, const vec3_t b) return degrees(acosf(DotProduct(a, b)/(VectorLength(a) * VectorLength(b)))); } -void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateGamepad *pFootTrackingOld, - ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTracking* pDominantTracking, - ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTracking* pOffTracking, +void HandleInput_Default( ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTrackedController* pDominantTracking, + ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTrackedController* pOffTracking, int domButton1, int domButton2, int offButton1, int offButton2 ) { @@ -50,12 +43,12 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG static bool canUseQuickSave = false; //Need this for the touch screen - ovrTracking * pWeapon = pDominantTracking; - ovrTracking * pOff = pOffTracking; + ovrTrackedController * pWeapon = pDominantTracking; + ovrTrackedController * pOff = pOffTracking; //All this to allow stick and button switching! - ovrVector2f *pPrimaryJoystick; - ovrVector2f *pSecondaryJoystick; + XrVector2f *pPrimaryJoystick; + XrVector2f *pSecondaryJoystick; uint32_t primaryButtonsNew; uint32_t primaryButtonsOld; uint32_t secondaryButtonsNew; @@ -64,8 +57,8 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG int primaryButton2; int secondaryButton1; int secondaryButton2; - int primaryThumb = (vr_control_scheme->integer == RIGHT_HANDED_DEFAULT || vr_switch_sticks->integer) ? ovrButton_RThumb : ovrButton_LThumb; - int secondaryThumb = (vr_control_scheme->integer == RIGHT_HANDED_DEFAULT || vr_switch_sticks->integer) ? ovrButton_LThumb : ovrButton_RThumb; + int primaryThumb = (vr_control_scheme->integer == RIGHT_HANDED_DEFAULT || vr_switch_sticks->integer) ? xrButton_RThumb : xrButton_LThumb; + int secondaryThumb = (vr_control_scheme->integer == RIGHT_HANDED_DEFAULT || vr_switch_sticks->integer) ? xrButton_LThumb : xrButton_RThumb; if (vr_switch_sticks->integer) { // @@ -105,10 +98,10 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG //if we are in saber block debounce, don't update the angles if (vr.saberBlockDebounce < cl.serverTime) { rotation[PITCH] = 45; - QuatToYawPitchRoll(pWeapon->HeadPose.Pose.Orientation, rotation, vr.weaponangles_saber); + QuatToYawPitchRoll(pWeapon->Pose.orientation, rotation, vr.weaponangles_saber); } rotation[PITCH] = vr_weapon_pitchadjust->value; - QuatToYawPitchRoll(pWeapon->HeadPose.Pose.Orientation, rotation, vr.weaponangles); + QuatToYawPitchRoll(pWeapon->Pose.orientation, rotation, vr.weaponangles); VectorSubtract(vr.weaponangles_last, vr.weaponangles, vr.weaponangles_delta); VectorCopy(vr.weaponangles, vr.weaponangles_last); @@ -119,14 +112,14 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG //GB Also set offhand angles just in case we want to use those. vec3_t rotation_off = {0}; rotation_off[PITCH] = vr_weapon_pitchadjust->value; - QuatToYawPitchRoll(pOff->HeadPose.Pose.Orientation, rotation_off, vr.offhandangles); + QuatToYawPitchRoll(pOff->Pose.orientation, rotation_off, vr.offhandangles); VectorSubtract(vr.offhandangles_last, vr.offhandangles, vr.offhandangles_delta); VectorCopy(vr.offhandangles, vr.offhandangles_last); } //Menu button - handleTrackedControllerButton(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, ovrButton_Enter, A_ESCAPE); + handleTrackedControllerButton(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, xrButton_Enter, A_ESCAPE); static bool resetCursor = qtrue; if ( JKVR_useScreenLayer() && !vr.misc_camera /*bit of a fiddle, but if we are in a misc camera, we are in the game and shouldn't be in here*/) @@ -135,7 +128,7 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG resetCursor = qfalse; handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, domButton1, A_MOUSE1); - handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, ovrButton_Trigger, A_MOUSE1); + handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, xrButton_Trigger, A_MOUSE1); handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, domButton2, A_ESCAPE); //To skip flatscreen cinematic @@ -148,22 +141,22 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG { resetCursor = qtrue; - float distance = sqrtf(powf(pOff->HeadPose.Pose.Position.x - pWeapon->HeadPose.Pose.Position.x, 2) + - powf(pOff->HeadPose.Pose.Position.y - pWeapon->HeadPose.Pose.Position.y, 2) + - powf(pOff->HeadPose.Pose.Position.z - pWeapon->HeadPose.Pose.Position.z, 2)); + float distance = sqrtf(powf(pOff->Pose.position.x - pWeapon->Pose.position.x, 2) + + powf(pOff->Pose.position.y - pWeapon->Pose.position.y, 2) + + powf(pOff->Pose.position.z - pWeapon->Pose.position.z, 2)); - float distanceToHMD = sqrtf(powf(vr.hmdposition[0] - pWeapon->HeadPose.Pose.Position.x, 2) + - powf(vr.hmdposition[1] - pWeapon->HeadPose.Pose.Position.y, 2) + - powf(vr.hmdposition[2] - pWeapon->HeadPose.Pose.Position.z, 2)); + float distanceToHMD = sqrtf(powf(vr.hmdposition[0] - pWeapon->Pose.position.x, 2) + + powf(vr.hmdposition[1] - pWeapon->Pose.position.y, 2) + + powf(vr.hmdposition[2] - pWeapon->Pose.position.z, 2)); - float distanceToHMDOff = sqrtf(powf(vr.hmdposition[0] - pOff->HeadPose.Pose.Position.x, 2) + - powf(vr.hmdposition[1] - pOff->HeadPose.Pose.Position.y, 2) + - powf(vr.hmdposition[2] - pOff->HeadPose.Pose.Position.z, 2)); + float distanceToHMDOff = sqrtf(powf(vr.hmdposition[0] - pOff->Pose.position.x, 2) + + powf(vr.hmdposition[1] - pOff->Pose.position.y, 2) + + powf(vr.hmdposition[2] - pOff->Pose.position.z, 2)); float controllerYawHeading = 0.0f; //Turn on weapon stabilisation? - bool offhandGripPushed = (pOffTrackedRemoteNew->Buttons & ovrButton_GripTrigger); + bool offhandGripPushed = (pOffTrackedRemoteNew->Buttons & xrButton_GripTrigger); if (offhandGripPushed) { if (!vr.weapon_stabilised && vr.item_selector == 0 && @@ -189,7 +182,7 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG } dominantGripPushed = (pDominantTrackedRemoteNew->Buttons & - ovrButton_GripTrigger) != 0; + xrButton_GripTrigger) != 0; //Do this early so we can suppress other button actions when item selector is up if (dominantGripPushed) { @@ -315,23 +308,23 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG vr.weaponoffset_history_timestamp[0] = vr.weaponoffset_timestamp; if (vr.saberBlockDebounce < cl.serverTime) { - VectorSet(vr.weaponposition, pWeapon->HeadPose.Pose.Position.x, - pWeapon->HeadPose.Pose.Position.y, pWeapon->HeadPose.Pose.Position.z); + VectorSet(vr.weaponposition, pWeapon->Pose.position.x, + pWeapon->Pose.position.y, pWeapon->Pose.position.z); ///Weapon location relative to view - VectorSet(vr.weaponoffset, pWeapon->HeadPose.Pose.Position.x, - pWeapon->HeadPose.Pose.Position.y, pWeapon->HeadPose.Pose.Position.z); + VectorSet(vr.weaponoffset, pWeapon->Pose.position.x, + pWeapon->Pose.position.y, pWeapon->Pose.position.z); VectorSubtract(vr.weaponoffset, vr.hmdposition, vr.weaponoffset); vr.weaponoffset_timestamp = Sys_Milliseconds(); } vec3_t velocity; - VectorSet(velocity, pWeapon->HeadPose.LinearVelocity.x, - pWeapon->HeadPose.LinearVelocity.y, pWeapon->HeadPose.LinearVelocity.z); + VectorSet(velocity, pWeapon->Velocity.linearVelocity.x, + pWeapon->Velocity.linearVelocity.y, pWeapon->Velocity.linearVelocity.z); vr.primaryswingvelocity = VectorLength(velocity); - VectorSet(velocity, pOff->HeadPose.LinearVelocity.x, - pOff->HeadPose.LinearVelocity.y, pOff->HeadPose.LinearVelocity.z); + VectorSet(velocity, pOff->Velocity.linearVelocity.x, + pOff->Velocity.linearVelocity.y, pOff->Velocity.linearVelocity.z); vr.secondaryswingvelocity = VectorLength(velocity); @@ -444,11 +437,11 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG else { float x = - pOff->HeadPose.Pose.Position.x - pWeapon->HeadPose.Pose.Position.x; + pOff->Pose.position.x - pWeapon->Pose.position.x; float y = - pOff->HeadPose.Pose.Position.y - pWeapon->HeadPose.Pose.Position.y; + pOff->Pose.position.y - pWeapon->Pose.position.y; float z = - pOff->HeadPose.Pose.Position.z - pWeapon->HeadPose.Pose.Position.z; + pOff->Pose.position.z - pWeapon->Pose.position.z; float zxDist = length(x, z); if (zxDist != 0.0f && z != 0.0f) { @@ -466,9 +459,7 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG float weaponToDownAngle = 0, hmdToWeaponDotProduct = 0; static vec3_t downVector = {0.0, 0.0, -1.0}; - bool bpTrackOk = pOffTracking->Status & - VRAPI_TRACKING_STATUS_POSITION_TRACKED; // 1) Position must be tracked - if (bpTrackOk && (bpDistToHMDOk = distanceToHMD >= 0.2 && distanceToHMD <= + if ((bpDistToHMDOk = distanceToHMD >= 0.2 && distanceToHMD <= 0.35) // 2) Weapon-to-HMD distance must be within <0.2-0.35> range && (bpWeaponHeightOk = vr.weaponoffset[1] >= -0.10 && vr.weaponoffset[1] <= 0.10)) // 3) Weapon height in relation to HMD must be within <-0.10, 0.10> range @@ -497,16 +488,16 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG { VectorCopy(vr.offhandposition[i-1], vr.offhandposition[i]); } - vr.offhandposition[0][0] = pOff->HeadPose.Pose.Position.x; - vr.offhandposition[0][1] = pOff->HeadPose.Pose.Position.y; - vr.offhandposition[0][2] = pOff->HeadPose.Pose.Position.z; + vr.offhandposition[0][0] = pOff->Pose.position.x; + vr.offhandposition[0][1] = pOff->Pose.position.y; + vr.offhandposition[0][2] = pOff->Pose.position.z; - vr.offhandoffset[0] = pOff->HeadPose.Pose.Position.x - vr.hmdposition[0]; - vr.offhandoffset[1] = pOff->HeadPose.Pose.Position.y - vr.hmdposition[1]; - vr.offhandoffset[2] = pOff->HeadPose.Pose.Position.z - vr.hmdposition[2]; + vr.offhandoffset[0] = pOff->Pose.position.x - vr.hmdposition[0]; + vr.offhandoffset[1] = pOff->Pose.position.y - vr.hmdposition[1]; + vr.offhandoffset[2] = pOff->Pose.position.z - vr.hmdposition[2]; vec3_t rotation = {0}; - QuatToYawPitchRoll(pOff->HeadPose.Pose.Orientation, rotation, vr.offhandangles); + QuatToYawPitchRoll(pOff->Pose.orientation, rotation, vr.offhandangles); if (vr_walkdirection->value == 0) { controllerYawHeading = vr.offhandangles[YAW] - vr.hmdorientation[YAW]; @@ -521,7 +512,7 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG vec3_t offhandForwardXY = {}; float hmdToOffhandDotProduct = 0; float offhandToDownAngle = 0; - if (bpTrackOk && (bpOffhandDistToHMDOk = distanceToHMDOff >= 0.2 && + if ((bpOffhandDistToHMDOk = distanceToHMDOff >= 0.2 && distanceToHMDOff <= 0.35) // 2) Off-to-HMD distance must be within <0.2-0.35> range && (bpOffhandHeightOk = vr.offhandoffset[1] >= -0.10 && vr.offhandoffset[1] <= @@ -641,11 +632,11 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG previous_throwing = throwing; if (!throwing && vr.primaryVelocityTriggeredAttack && - (pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger)) + (pDominantTrackedRemoteNew->Buttons & xrButton_Trigger)) { throwing = true; } - else if (throwing && !(pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger)) + else if (throwing && !(pDominantTrackedRemoteNew->Buttons & xrButton_Trigger)) { throwing = false; } @@ -657,10 +648,10 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG else if (!vr.velocitytriggered) // Don't fire velocity triggered weapons { //Fire Primary - Doesn't trigger the saber - if ((pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger) != - (pDominantTrackedRemoteOld->Buttons & ovrButton_Trigger)) { + if ((pDominantTrackedRemoteNew->Buttons & xrButton_Trigger) != + (pDominantTrackedRemoteOld->Buttons & xrButton_Trigger)) { - firing = (pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger) && + firing = (pDominantTrackedRemoteNew->Buttons & xrButton_Trigger) && !vr.item_selector; sendButtonAction("+attack", firing); } @@ -706,8 +697,8 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG //Apply a filter and quadratic scaler so small movements are easier to make float dist = length(pSecondaryJoystick->x, pSecondaryJoystick->y); float nlf = nonLinearFilter(dist); - float x = (nlf * pSecondaryJoystick->x) + pFootTrackingNew->LeftJoystick.x; - float y = (nlf * pSecondaryJoystick->y) - pFootTrackingNew->LeftJoystick.y; + float x = (nlf * pSecondaryJoystick->x); + float y = (nlf * pSecondaryJoystick->y); vr.player_moving = (fabs(x) + fabs(y)) > 0.05f; @@ -745,10 +736,10 @@ void HandleInput_Default( ovrInputStateGamepad *pFootTrackingNew, ovrInputStateG //Use Force - off hand trigger { - if ((pOffTrackedRemoteNew->Buttons & ovrButton_Trigger) != - (pOffTrackedRemoteOld->Buttons & ovrButton_Trigger)) + if ((pOffTrackedRemoteNew->Buttons & xrButton_Trigger) != + (pOffTrackedRemoteOld->Buttons & xrButton_Trigger)) { - sendButtonAction("+useforce", (pOffTrackedRemoteNew->Buttons & ovrButton_Trigger)); + sendButtonAction("+useforce", (pOffTrackedRemoteNew->Buttons & xrButton_Trigger)); } } diff --git a/Projects/Android/jni/JKVR/VrInputWeaponAlign.cpp b/Projects/Android/jni/JKVR/VrInputWeaponAlign.cpp index efad098..c83dd67 100644 --- a/Projects/Android/jni/JKVR/VrInputWeaponAlign.cpp +++ b/Projects/Android/jni/JKVR/VrInputWeaponAlign.cpp @@ -23,8 +23,8 @@ cvar_t *sv_cheats; void CG_CenterPrint( const char *str, int y, int charWidth ); -void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTracking* pDominantTracking, - ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTracking* pOffTracking, +void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemoteNew, ovrInputStateTrackedRemote *pDominantTrackedRemoteOld, ovrTrackedController* pDominantTracking, + ovrInputStateTrackedRemote *pOffTrackedRemoteNew, ovrInputStateTrackedRemote *pOffTrackedRemoteOld, ovrTrackedController* pOffTracking, int domButton1, int domButton2, int offButton1, int offButton2 ) { @@ -49,9 +49,9 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote //Set gun angles - We need to calculate all those we might need (including adjustments) for the client to then take its pick vec3_t rotation = {0}; rotation[PITCH] = 10; - QuatToYawPitchRoll(pDominantTracking->HeadPose.Pose.Orientation, rotation, vr.weaponangles_saber); + QuatToYawPitchRoll(pDominantTracking->Pose.orientation, rotation, vr.weaponangles_saber); rotation[PITCH] = vr_weapon_pitchadjust->value; - QuatToYawPitchRoll(pDominantTracking->HeadPose.Pose.Orientation, rotation, vr.weaponangles); + QuatToYawPitchRoll(pDominantTracking->Pose.orientation, rotation, vr.weaponangles); VectorSubtract(vr.weaponangles_last, vr.weaponangles, vr.weaponangles_delta); VectorCopy(vr.weaponangles, vr.weaponangles_last); @@ -62,7 +62,7 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote } //Menu button - handleTrackedControllerButton(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, ovrButton_Enter, A_ESCAPE); + handleTrackedControllerButton(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, xrButton_Enter, A_ESCAPE); static bool resetCursor = qtrue; if ( JKVR_useScreenLayer() ) @@ -71,7 +71,7 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote resetCursor = qfalse; handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, domButton1, A_MOUSE1); - handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, ovrButton_Trigger, A_MOUSE1); + handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, xrButton_Trigger, A_MOUSE1); handleTrackedControllerButton(pDominantTrackedRemoteNew, pDominantTrackedRemoteOld, domButton2, A_ESCAPE); } else @@ -80,36 +80,36 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote //dominant hand stuff first { - vr.weaponposition[0] = pDominantTracking->HeadPose.Pose.Position.x; - vr.weaponposition[1] = pDominantTracking->HeadPose.Pose.Position.y; - vr.weaponposition[2] = pDominantTracking->HeadPose.Pose.Position.z; + vr.weaponposition[0] = pDominantTracking->Pose.position.x; + vr.weaponposition[1] = pDominantTracking->Pose.position.y; + vr.weaponposition[2] = pDominantTracking->Pose.position.z; ///Weapon location relative to view - vr.weaponoffset[0] = pDominantTracking->HeadPose.Pose.Position.x - vr.hmdposition[0]; - vr.weaponoffset[1] = pDominantTracking->HeadPose.Pose.Position.y - vr.hmdposition[1]; - vr.weaponoffset[2] = pDominantTracking->HeadPose.Pose.Position.z - vr.hmdposition[2]; + vr.weaponoffset[0] = pDominantTracking->Pose.position.x - vr.hmdposition[0]; + vr.weaponoffset[1] = pDominantTracking->Pose.position.y - vr.hmdposition[1]; + vr.weaponoffset[2] = pDominantTracking->Pose.position.z - vr.hmdposition[2]; vr.weaponoffset_timestamp = Sys_Milliseconds( ); } float controllerYawHeading = 0.0f; //off-hand stuff { - vr.offhandposition[0][0] = pOffTracking->HeadPose.Pose.Position.x; - vr.offhandposition[0][1] = pOffTracking->HeadPose.Pose.Position.y; - vr.offhandposition[0][2] = pOffTracking->HeadPose.Pose.Position.z; + vr.offhandposition[0][0] = pOffTracking->Pose.position.x; + vr.offhandposition[0][1] = pOffTracking->Pose.position.y; + vr.offhandposition[0][2] = pOffTracking->Pose.position.z; - vr.offhandoffset[0] = pOffTracking->HeadPose.Pose.Position.x - vr.hmdposition[0]; - vr.offhandoffset[1] = pOffTracking->HeadPose.Pose.Position.y - vr.hmdposition[1]; - vr.offhandoffset[2] = pOffTracking->HeadPose.Pose.Position.z - vr.hmdposition[2]; + vr.offhandoffset[0] = pOffTracking->Pose.position.x - vr.hmdposition[0]; + vr.offhandoffset[1] = pOffTracking->Pose.position.y - vr.hmdposition[1]; + vr.offhandoffset[2] = pOffTracking->Pose.position.z - vr.hmdposition[2]; vec3_t rotation = {0}; - QuatToYawPitchRoll(pOffTracking->HeadPose.Pose.Orientation, rotation, vr.offhandangles); + QuatToYawPitchRoll(pOffTracking->Pose.orientation, rotation, vr.offhandangles); } ALOGV(" Right-Controller-Position: %f, %f, %f", - pDominantTracking->HeadPose.Pose.Position.x, - pDominantTracking->HeadPose.Pose.Position.y, - pDominantTracking->HeadPose.Pose.Position.z); + pDominantTracking->Pose.position.x, + pDominantTracking->Pose.position.y, + pDominantTracking->Pose.position.z); //This section corrects for the fact that the controller actually controls direction of movement, but we want to move relative to the direction the //player is facing for positional tracking @@ -124,16 +124,16 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote positional_movementForward); dominantGripPushed = (pDominantTrackedRemoteNew->Buttons & - ovrButton_GripTrigger) != 0; + xrButton_GripTrigger) != 0; //We need to record if we have started firing primary so that releasing trigger will stop firing, if user has pushed grip //in meantime, then it wouldn't stop the gun firing and it would get stuck if (dominantGripPushed) { //Fire Secondary - if (((pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger) != - (pDominantTrackedRemoteOld->Buttons & ovrButton_Trigger)) - && (pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger)) + if (((pDominantTrackedRemoteNew->Buttons & xrButton_Trigger) != + (pDominantTrackedRemoteOld->Buttons & xrButton_Trigger)) + && (pDominantTrackedRemoteNew->Buttons & xrButton_Trigger)) { sendButtonActionSimple("weapalt"); } @@ -142,15 +142,15 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote { //Fire Primary if (!vr.velocitytriggered && // Don't fire velocity triggered weapons - (pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger) != - (pDominantTrackedRemoteOld->Buttons & ovrButton_Trigger)) { + (pDominantTrackedRemoteNew->Buttons & xrButton_Trigger) != + (pDominantTrackedRemoteOld->Buttons & xrButton_Trigger)) { - sendButtonAction("+attack", (pDominantTrackedRemoteNew->Buttons & ovrButton_Trigger)); + sendButtonAction("+attack", (pDominantTrackedRemoteNew->Buttons & xrButton_Trigger)); } } - bool offhandGripPushed = (pOffTrackedRemoteNew->Buttons & ovrButton_GripTrigger); - if ( (offhandGripPushed != (pOffTrackedRemoteOld->Buttons & ovrButton_GripTrigger)) && + bool offhandGripPushed = (pOffTrackedRemoteNew->Buttons & xrButton_GripTrigger); + if ( (offhandGripPushed != (pOffTrackedRemoteOld->Buttons & xrButton_GripTrigger)) && offhandGripPushed) #ifndef DEBUG { @@ -218,9 +218,9 @@ void HandleInput_WeaponAlign( ovrInputStateTrackedRemote *pDominantTrackedRemote itemSwitched = false; } - if (((pDominantTrackedRemoteNew->Buttons & ovrButton_Joystick) != - (pDominantTrackedRemoteOld->Buttons & ovrButton_Joystick)) && - (pDominantTrackedRemoteOld->Buttons & ovrButton_Joystick)) + if (((pDominantTrackedRemoteNew->Buttons & xrButton_Joystick) != + (pDominantTrackedRemoteOld->Buttons & xrButton_Joystick)) && + (pDominantTrackedRemoteOld->Buttons & xrButton_Joystick)) { *(items[item_index]) = 0.0; } diff --git a/Projects/Android/jni/OpenJK/Android.mk b/Projects/Android/jni/OpenJK/Android.mk index de25ccd..ee71e6f 100644 --- a/Projects/Android/jni/OpenJK/Android.mk +++ b/Projects/Android/jni/OpenJK/Android.mk @@ -11,6 +11,8 @@ JK3_BASE_LDLIBS = JK3_BASE_LDLIBS += -Wl JK3_BASE_C_INCLUDES := $(OPENJK_PATH)/lib $(JK3_CODE_PATH)/client $(JK3_CODE_PATH)/server $(JK3_CODE_PATH)/libs/freetype2/include $(JK3_CODE_PATH)/common $(JK3_CODE_PATH)/gl +JK3_BASE_C_INCLUDES += $(LOCAL_PATH)/../../../../../../OpenXR/Include +JK3_BASE_C_INCLUDES += $(LOCAL_PATH)/../../../../../../3rdParty/khronos/openxr/OpenXR-SDK/include JK3_BASE_C_INCLUDES += $(JK3_CODE_PATH)/ $(OPENJK_PATH)/code/ $(OPENJK_PATH)/shared/ $(JK3_CODE_PATH)/ui $(OPENJK_PATH)/lib/gsl-lite/include # Jedi Outcast diff --git a/Projects/Android/jni/OpenJK/Android_client_ja.mk b/Projects/Android/jni/OpenJK/Android_client_ja.mk index 3872eb9..3a8ad59 100644 --- a/Projects/Android/jni/OpenJK/Android_client_ja.mk +++ b/Projects/Android/jni/OpenJK/Android_client_ja.mk @@ -20,10 +20,10 @@ LOCAL_LDLIBS += -lGLESv3 -landroid -lEGL -llog -lz -lOpenSLES LOCAL_LDLIBS += -fuse-ld=bfd LOCAL_STATIC_LIBRARIES := sigc libzip libpng libminizip -LOCAL_SHARED_LIBRARIES := vrapi gl4es +LOCAL_SHARED_LIBRARIES := openxr_loader gl4es -LOCAL_C_INCLUDES := $(JK3_BASE_C_INCLUDES) $(TOP_DIR) $(TOP_DIR)/JKVR $(GL4ES_PATH) $(GL4ES_PATH)/include $(JK3_CODE_PATH)/game $(SUPPORT_LIBS)/minizip/include $(JK3_CODE_PATH)/rd-gles $(JK3_CODE_PATH)/rd-common +LOCAL_C_INCLUDES := $(JK3_BASE_C_INCLUDES) $(TOP_DIR) $(TOP_DIR)/JKVR $(GL4ES_PATH) $(GL4ES_PATH)/include $(JK3_CODE_PATH)/game $(SUPPORT_LIBS)/minizip/include $(JK3_CODE_PATH)/rd-gles $(JK3_CODE_PATH)/rd-common ############################################################################# @@ -124,11 +124,11 @@ JK3_SRC = \ JKVR_SRC_FILES := ${TOP_DIR}/JKVR/JKVR_SurfaceView.cpp \ - ${TOP_DIR}/JKVR/VrCompositor.cpp \ ${TOP_DIR}/JKVR/VrInputCommon.cpp \ - ${TOP_DIR}/JKVR/VrInputWeaponAlign.cpp \ ${TOP_DIR}/JKVR/VrInputDefault.cpp \ ${TOP_DIR}/JKVR/argtable3.c +# ${TOP_DIR}/JKVR/VrCompositor.cpp \ +# ${TOP_DIR}/JKVR/VrInputWeaponAlign.cpp \ LOCAL_SRC_FILES += $(JK3_SRC) $(JKVR_SRC_FILES) @@ -137,7 +137,7 @@ include $(BUILD_SHARED_LIBRARY) -$(call import-module,VrApi/Projects/AndroidPrebuilt/jni) +$(call import-module,OpenXR/Projects/AndroidPrebuilt/jni) diff --git a/Projects/Android/jni/OpenJK/Android_client_jo.mk b/Projects/Android/jni/OpenJK/Android_client_jo.mk index 15fcec7..cc3aae5 100644 --- a/Projects/Android/jni/OpenJK/Android_client_jo.mk +++ b/Projects/Android/jni/OpenJK/Android_client_jo.mk @@ -20,7 +20,7 @@ LOCAL_LDLIBS += -lGLESv3 -landroid -lEGL -llog -lz -lOpenSLES LOCAL_LDLIBS += -fuse-ld=bfd LOCAL_STATIC_LIBRARIES := sigc libzip libpng libminizip -LOCAL_SHARED_LIBRARIES := vrapi gl4es +LOCAL_SHARED_LIBRARIES := openxr_loader gl4es LOCAL_C_INCLUDES := $(JK3_BASE_C_INCLUDES) $(TOP_DIR) $(TOP_DIR)/JKVR $(GL4ES_PATH) $(GL4ES_PATH)/include $(JK3_CODE_PATH)/game $(SUPPORT_LIBS)/minizip/include $(JK3_CODE_PATH)/rd-gles $(JK3_CODE_PATH)/rd-common @@ -124,11 +124,11 @@ JK3_SRC = \ JKVR_SRC_FILES := ${TOP_DIR}/JKVR/JKVR_SurfaceView.cpp \ - ${TOP_DIR}/JKVR/VrCompositor.cpp \ ${TOP_DIR}/JKVR/VrInputCommon.cpp \ - ${TOP_DIR}/JKVR/VrInputWeaponAlign.cpp \ ${TOP_DIR}/JKVR/VrInputDefault.cpp \ ${TOP_DIR}/JKVR/argtable3.c +# ${TOP_DIR}/JKVR/VrCompositor.cpp \ +# ${TOP_DIR}/JKVR/VrInputWeaponAlign.cpp \ LOCAL_SRC_FILES += $(JK3_SRC) $(JKVR_SRC_FILES) @@ -137,7 +137,7 @@ include $(BUILD_SHARED_LIBRARY) -$(call import-module,VrApi/Projects/AndroidPrebuilt/jni) +$(call import-module,OpenXR/Projects/AndroidPrebuilt/jni) diff --git a/Projects/Android/settings.gradle b/Projects/Android/settings.gradle index 3734b37..e4d8c36 100644 --- a/Projects/Android/settings.gradle +++ b/Projects/Android/settings.gradle @@ -1,4 +1,4 @@ rootProject.projectDir = new File(settingsDir, '../../../..') rootProject.name = "JKQuest" -include ':', 'VrSamples:JKQuest:Projects:Android' +include ':', ':XrSamples:JKQuest:Projects:Android' diff --git a/VrSamples-JKQuest.iml b/XrSamples-JKQuest.iml similarity index 87% rename from VrSamples-JKQuest.iml rename to XrSamples-JKQuest.iml index 6179cc7..f080023 100644 --- a/VrSamples-JKQuest.iml +++ b/XrSamples-JKQuest.iml @@ -1,15 +1,15 @@ - -