From a234123486fd1169664974f5c6b5b9835f1f32b2 Mon Sep 17 00:00:00 2001 From: Simon Date: Fri, 30 Aug 2019 13:54:20 +0100 Subject: [PATCH 1/9] Update hlsdk-xash3d --- Projects/Android/jni/src/hlsdk-xash3d | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Projects/Android/jni/src/hlsdk-xash3d b/Projects/Android/jni/src/hlsdk-xash3d index a2c8aae..cf37f32 160000 --- a/Projects/Android/jni/src/hlsdk-xash3d +++ b/Projects/Android/jni/src/hlsdk-xash3d @@ -1 +1 @@ -Subproject commit a2c8aae4888d1907413ad4a3d15bd24812b26792 +Subproject commit cf37f32a00e38e6f365b2d704f73acd7c433e98c From 84d113618eac57de8265a0c3bd56894ab7548f1d Mon Sep 17 00:00:00 2001 From: Simon Date: Tue, 3 Sep 2019 21:52:33 +0100 Subject: [PATCH 2/9] Added placeholder for alt control scheme Created alt control schemes (currently identical to default) for left and right, placeholders for VRTinker's implementation. Refactored some of the common functionality. --- .../jni/src/Lambda1VR/L1VR_SurfaceView.c | 103 +---- Projects/Android/jni/src/Lambda1VR/VrInput.h | 10 +- .../Android/jni/src/Lambda1VR/VrInputCommon.c | 182 ++++++++ .../Android/jni/src/Lambda1VR/VrInputLeft.c | 67 +-- .../jni/src/Lambda1VR/VrInputLeftAlt.c | 394 +++++++++++++++++ .../Android/jni/src/Lambda1VR/VrInputRight.c | 74 +--- .../jni/src/Lambda1VR/VrInputRightAlt.c | 399 ++++++++++++++++++ .../jni/src/Xash3D/xash3d/engine/Android.mk | 10 +- 8 files changed, 1012 insertions(+), 227 deletions(-) create mode 100644 Projects/Android/jni/src/Lambda1VR/VrInputCommon.c create mode 100644 Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c create mode 100644 Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c diff --git a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c index 98ee315..c116b44 100644 --- a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c +++ b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c @@ -106,7 +106,10 @@ extern convar_t *r_lefthand; enum control_scheme { RIGHT_HANDED_DEFAULT = 0, - LEFT_HANDED_DEFAULT = 10 + RIGHT_HANDED_ALT = 1, + LEFT_HANDED_DEFAULT = 10, + LEFT_HANDED_ALT = 11, + GAMEPAD = 20 //Not implemented, someone else can do this! }; /* @@ -1033,93 +1036,6 @@ static void ovrApp_HandleVrModeChanges( ovrApp * app ) } } -void handleTrackedControllerButton(ovrInputStateTrackedRemote * trackedRemoteState, ovrInputStateTrackedRemote * prevTrackedRemoteState, uint32_t button, int key) -{ - if ((trackedRemoteState->Buttons & button) != (prevTrackedRemoteState->Buttons & button)) - { - Key_Event(key, (trackedRemoteState->Buttons & button) != 0); - } -} - - -static void Matrix4x4_Transform (const matrix4x4 *in, const float v[3], float out[3]) -{ - out[0] = v[0] * (*in)[0][0] + v[1] * (*in)[0][1] + v[2] * (*in)[0][2] + (*in)[0][3]; - out[1] = v[0] * (*in)[1][0] + v[1] * (*in)[1][1] + v[2] * (*in)[1][2] + (*in)[1][3]; - out[2] = v[0] * (*in)[2][0] + v[1] * (*in)[2][1] + v[2] * (*in)[2][2] + (*in)[2][3]; -} - -void rotateAboutOrigin(float v1, float v2, float rotation, vec2_t out) -{ - vec3_t temp = {0.0f, 0.0f, 0.0f}; - temp[0] = v1; - temp[1] = v2; - - vec3_t v = {0.0f, 0.0f, 0.0f}; - matrix4x4 matrix; - vec3_t angles = {0.0f, rotation, 0.0f}; - vec3_t origin = {0.0f, 0.0f, 0.0f}; - Matrix4x4_CreateFromEntity(matrix, angles, origin, 1.0f); - Matrix4x4_Transform(&matrix, temp, v); - - out[0] = v[0]; - out[1] = v[1]; -} - -void sendButtonAction(const char* action, long buttonDown) -{ - char command[256]; - Q_snprintf( command, sizeof( command ), "%s\n", action ); - if (!buttonDown) - { - command[0] = '-'; - } - Cbuf_AddText( command ); - -} - -float length(float x, float y) -{ - return sqrtf(powf(x, 2.0f) + powf(y, 2.0f)); -} - -#define NLF_DEADZONE 0.1 -#define NLF_POWER 2.2 - -float nonLinearFilter(float in) -{ - float val = 0.0f; - if (in > NLF_DEADZONE) - { - val = in; - val -= NLF_DEADZONE; - val /= (1.0f - NLF_DEADZONE); - val = powf(val, NLF_POWER); - } - else if (in < -NLF_DEADZONE) - { - val = in; - val += NLF_DEADZONE; - val /= (1.0f - NLF_DEADZONE); - val = -powf(fabsf(val), NLF_POWER); - } - - return val; -} - -void sendButtonActionSimple(const char* action) -{ - char command[256]; - Q_snprintf( command, sizeof( command ), "%s\n", action ); - Cbuf_AddText( command ); -} - -bool between(float min, float val, float max) -{ - return (min < val) && (val < max); -} - - /* ================================================================================ @@ -1368,7 +1284,7 @@ void VR_Init() //Create Cvars vr_snapturn_angle = Cvar_Get( "vr_snapturn_angle", "45", CVAR_ARCHIVE, "Sets the angle for snap-turn, set to < 10.0 to enable smooth turning" ); vr_reloadtimeoutms = Cvar_Get( "vr_reloadtimeoutms", "200", CVAR_ARCHIVE, "How quickly the grip trigger needs to be release to initiate a reload" ); - vr_positional_factor = Cvar_Get( "vr_positional_factor", "2600", CVAR_ARCHIVE, "Arbitrary number that makes positional tracking work" ); + vr_positional_factor = Cvar_Get( "vr_positional_factor", "2800", CVAR_ARCHIVE, "Arbitrary number that makes positional tracking work" ); vr_walkdirection = Cvar_Get( "vr_walkdirection", "0", CVAR_ARCHIVE, "1 - Use HMD for direction, 0 - Use off-hand controller for direction" ); vr_weapon_pitchadjust = Cvar_Get( "vr_weapon_pitchadjust", "-20.0", CVAR_ARCHIVE, "gun pitch angle adjust" ); vr_weapon_recoil = Cvar_Get( "vr_weapon_recoil", "0", CVAR_ARCHIVE, "Enables weapon recoil in VR, default is disabled, warning could make you sick" ); @@ -1584,9 +1500,18 @@ void * AppThreadFunction( void * parm ) case RIGHT_HANDED_DEFAULT: HandleInput_Right(appState.Ovr, appState.DisplayTime); break; + case RIGHT_HANDED_ALT: + HandleInput_RightAlt(appState.Ovr, appState.DisplayTime); + break; case LEFT_HANDED_DEFAULT: HandleInput_Left(appState.Ovr, appState.DisplayTime); break; + case LEFT_HANDED_ALT: + HandleInput_LeftAlt(appState.Ovr, appState.DisplayTime); + break; + case GAMEPAD: + //HandleInput_Gamepad(appState.Ovr, appState.DisplayTime); // Someone else can implement this + break; } static usingScreenLayer = true; //Starts off using the screen layer diff --git a/Projects/Android/jni/src/Lambda1VR/VrInput.h b/Projects/Android/jni/src/Lambda1VR/VrInput.h index b90c4d7..077857a 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInput.h +++ b/Projects/Android/jni/src/Lambda1VR/VrInput.h @@ -1,17 +1,15 @@ #include "VrCommon.h" -//New scheme definitions to be added here +//New control scheme definitions to be defined L1VR_SurfaceView.c enumeration enum control_scheme; ovrInputStateTrackedRemote leftTrackedRemoteState_old; ovrInputStateTrackedRemote leftTrackedRemoteState_new; -ovrTracking leftRemoteTracking_old; ovrTracking leftRemoteTracking_new; ovrInputStateTrackedRemote rightTrackedRemoteState_old; ovrInputStateTrackedRemote rightTrackedRemoteState_new; -ovrTracking rightRemoteTracking_old; ovrTracking rightRemoteTracking_new; float remote_movementSideways; @@ -23,7 +21,13 @@ float snapTurn; void sendButtonAction(const char* action, long buttonDown); void sendButtonActionSimple(const char* action); +void interactWithTouchScreen(ovrTracking *tracking, ovrInputStateTrackedRemote *newState, ovrInputStateTrackedRemote *oldState); + +void acquireTrackedRemotesData(const ovrMobile *Ovr, double displayTime); + void HandleInput_Right( ovrMobile * Ovr, double displayTime ); +void HandleInput_RightAlt( ovrMobile * Ovr, double displayTime ); void HandleInput_Left( ovrMobile * Ovr, double displayTime ); +void HandleInput_LeftAlt( ovrMobile * Ovr, double displayTime ); diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputCommon.c b/Projects/Android/jni/src/Lambda1VR/VrInputCommon.c new file mode 100644 index 0000000..7bb6325 --- /dev/null +++ b/Projects/Android/jni/src/Lambda1VR/VrInputCommon.c @@ -0,0 +1,182 @@ +/************************************************************************************ + +Filename : VrInputRight.c +Content : Handles common controller input functionality +Created : September 2019 +Authors : Simon Brown + +*************************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "VrInput.h" + + +void handleTrackedControllerButton(ovrInputStateTrackedRemote * trackedRemoteState, ovrInputStateTrackedRemote * prevTrackedRemoteState, uint32_t button, int key) +{ + if ((trackedRemoteState->Buttons & button) != (prevTrackedRemoteState->Buttons & button)) + { + Key_Event(key, (trackedRemoteState->Buttons & button) != 0); + } +} + + +static void Matrix4x4_Transform (const matrix4x4 *in, const float v[3], float out[3]) +{ + out[0] = v[0] * (*in)[0][0] + v[1] * (*in)[0][1] + v[2] * (*in)[0][2] + (*in)[0][3]; + out[1] = v[0] * (*in)[1][0] + v[1] * (*in)[1][1] + v[2] * (*in)[1][2] + (*in)[1][3]; + out[2] = v[0] * (*in)[2][0] + v[1] * (*in)[2][1] + v[2] * (*in)[2][2] + (*in)[2][3]; +} + +void rotateAboutOrigin(float v1, float v2, float rotation, vec2_t out) +{ + vec3_t temp = {0.0f, 0.0f, 0.0f}; + temp[0] = v1; + temp[1] = v2; + + vec3_t v = {0.0f, 0.0f, 0.0f}; + matrix4x4 matrix; + vec3_t angles = {0.0f, rotation, 0.0f}; + vec3_t origin = {0.0f, 0.0f, 0.0f}; + Matrix4x4_CreateFromEntity(matrix, angles, origin, 1.0f); + Matrix4x4_Transform(&matrix, temp, v); + + out[0] = v[0]; + out[1] = v[1]; +} + +float length(float x, float y) +{ + return sqrtf(powf(x, 2.0f) + powf(y, 2.0f)); +} + +#define NLF_DEADZONE 0.1 +#define NLF_POWER 2.2 + +float nonLinearFilter(float in) +{ + float val = 0.0f; + if (in > NLF_DEADZONE) + { + val = in; + val -= NLF_DEADZONE; + val /= (1.0f - NLF_DEADZONE); + val = powf(val, NLF_POWER); + } + else if (in < -NLF_DEADZONE) + { + val = in; + val += NLF_DEADZONE; + val /= (1.0f - NLF_DEADZONE); + val = -powf(fabsf(val), NLF_POWER); + } + + return val; +} + +void sendButtonActionSimple(const char* action) +{ + char command[256]; + Q_snprintf( command, sizeof( command ), "%s\n", action ); + Cbuf_AddText( command ); +} + +bool between(float min, float val, float max) +{ + return (min < val) && (val < max); +} + +void sendButtonAction(const char* action, long buttonDown) +{ + char command[256]; + Q_snprintf( command, sizeof( command ), "%s\n", action ); + if (!buttonDown) + { + command[0] = '-'; + } + Cbuf_AddText( command ); + +} + +void acquireTrackedRemotesData(const ovrMobile *Ovr, double displayTime) {//The amount of yaw changed by controller + for ( int i = 0; ; i++ ) { + ovrInputCapabilityHeader cap; + ovrResult result = vrapi_EnumerateInputDevices(Ovr, i, &cap); + if (result < 0) { + break; + } + + 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; + } else{ + leftTrackedRemoteState_new = trackedRemoteState; + leftRemoteTracking_new = remoteTracking; + } + } + } + } +} + +int IN_TouchEvent( touchEventType type, int fingerID, float x, float y, float dx, float dy ); + +float initialTouchX, initialTouchY; + +void interactWithTouchScreen(ovrTracking *tracking, ovrInputStateTrackedRemote *newState, ovrInputStateTrackedRemote *oldState) { + float remoteAngles[3]; + QuatToYawPitchRoll(tracking->HeadPose.Pose.Orientation, 0.0f, remoteAngles); + float yaw = remoteAngles[YAW] - playerYaw; + + //Adjust for maximum yaw values + if (yaw >= 180.0f) yaw -= 180.0f; + if (yaw <= -180.0f) yaw += 180.0f; + + if (yaw > -40.0f && yaw < 40.0f && + remoteAngles[PITCH] > -22.5f && remoteAngles[PITCH] < 22.5f) { + + int newRemoteTrigState = (newState->Buttons & ovrButton_Trigger) != 0; + int prevRemoteTrigState = (oldState->Buttons & ovrButton_Trigger) != 0; + + touchEventType t = event_motion; + + float touchX = (-yaw + 40.0f) / 80.0f; + float touchY = (remoteAngles[PITCH] + 22.5f) / 45.0f; + if (newRemoteTrigState != prevRemoteTrigState) + { + t = newRemoteTrigState ? event_down : event_up; + if (newRemoteTrigState) + { + initialTouchX = touchX; + initialTouchY = touchY; + } + } + + IN_TouchEvent(t, 0, touchX, touchY, initialTouchX - touchX, initialTouchY - touchY); + } +} \ No newline at end of file diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c b/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c index 1fd98d3..3b09614 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c @@ -27,7 +27,6 @@ Authors : Simon Brown extern cvar_t *cl_forwardspeed; extern cvar_t *cl_movespeedkey; -int IN_TouchEvent( touchEventType type, int fingerID, float x, float y, float dx, float dy ); void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx, float dy ); float initialTouchX, initialTouchY; @@ -38,39 +37,8 @@ void HandleInput_Left( ovrMobile * Ovr, double displayTime ) //Ensure handedness is set to left Cvar_Set("r_lefthand", "1"); - //The amount of yaw changed by controller - //TODO: fixme - for ( int i = 0; ; i++ ) { - ovrInputCapabilityHeader cap; - ovrResult result = vrapi_EnumerateInputDevices(Ovr, i, &cap); - if (result < 0) { - break; - } - - 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; - } else{ - leftTrackedRemoteState_new = trackedRemoteState; - leftRemoteTracking_new = remoteTracking; - } - } - } - } + //Get info for tracked remotes + acquireTrackedRemotesData(Ovr, displayTime); static bool dominantGripPushed = false; static float dominantGripPushTime = 0.0f; @@ -94,36 +62,7 @@ void HandleInput_Left( ovrMobile * Ovr, double displayTime ) //Menu control - Uses "touch" if (useScreenLayer()) { - float remoteAngles[3]; - QuatToYawPitchRoll(leftRemoteTracking_new.HeadPose.Pose.Orientation, 0.0f, remoteAngles); - float yaw = remoteAngles[YAW] - playerYaw; - - //Adjust for maximum yaw values - if (yaw >= 180.0f) yaw -= 180.0f; - if (yaw <= -180.0f) yaw += 180.0f; - - if (yaw > -40.0f && yaw < 40.0f && - remoteAngles[PITCH] > -22.5f && remoteAngles[PITCH] < 22.5f) { - - int newRemoteTrigState = (leftTrackedRemoteState_new.Buttons & ovrButton_Trigger) != 0; - int prevRemoteTrigState = (leftTrackedRemoteState_old.Buttons & ovrButton_Trigger) != 0; - - touchEventType t = event_motion; - - float touchX = (-yaw + 40.0f) / 80.0f; - float touchY = (remoteAngles[PITCH] + 22.5f) / 45.0f; - if (newRemoteTrigState != prevRemoteTrigState) - { - t = newRemoteTrigState ? event_down : event_up; - if (newRemoteTrigState) - { - initialTouchX = touchX; - initialTouchY = touchY; - } - } - - IN_TouchEvent(t, 0, touchX, touchY, initialTouchX - touchX, initialTouchY - touchY); - } + interactWithTouchScreen(&leftRemoteTracking_new, &leftTrackedRemoteState_new, &leftTrackedRemoteState_old); } else { diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c b/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c new file mode 100644 index 0000000..2a911b0 --- /dev/null +++ b/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c @@ -0,0 +1,394 @@ +/************************************************************************************ + +Filename : VrInputRightAlt.c +Content : Handles controller input for the left-handed alternative configuration #1 +Created : August 2019 +Authors : Simon Brown + +*************************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "VrInput.h" +#include "VrCvars.h" + +extern cvar_t *cl_forwardspeed; +extern cvar_t *cl_movespeedkey; + +void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx, float dy ); + +void HandleInput_LeftAlt( ovrMobile * Ovr, double displayTime ) +{ + //Ensure handedness is set to left + Cvar_Set("r_lefthand", "1"); + + //Get info for tracked remotes + acquireTrackedRemotesData(Ovr, displayTime); + + static bool dominantGripPushed = false; + static float dominantGripPushTime = 0.0f; + + //Show screen view (if in multiplayer toggle scoreboard) + if (((rightTrackedRemoteState_new.Buttons & ovrButton_B) != + (rightTrackedRemoteState_old.Buttons & ovrButton_B)) && + (rightTrackedRemoteState_new.Buttons & ovrButton_B)) { + + showingScreenLayer = !showingScreenLayer; + + //Check we are in multiplayer + if (isMultiplayer()) { + sendButtonAction("+showscores", showingScreenLayer); + } + } + + //Menu button + handleTrackedControllerButton(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, ovrButton_Enter, K_ESCAPE); + + //Menu control - Uses "touch" + if (useScreenLayer()) + { + interactWithTouchScreen(&leftRemoteTracking_new, &leftTrackedRemoteState_new, &leftTrackedRemoteState_old); + } + else + { + //If distance to off-hand remote is less than 35cm and user pushes grip, then we enable weapon stabilisation + float distance = sqrtf(powf(rightRemoteTracking_new.HeadPose.Pose.Position.x - leftRemoteTracking_new.HeadPose.Pose.Position.x, 2) + + powf(rightRemoteTracking_new.HeadPose.Pose.Position.y - leftRemoteTracking_new.HeadPose.Pose.Position.y, 2) + + powf(rightRemoteTracking_new.HeadPose.Pose.Position.z - leftRemoteTracking_new.HeadPose.Pose.Position.z, 2)); + + //Turn on weapon stabilisation? + if ((rightTrackedRemoteState_new.Buttons & ovrButton_GripTrigger) != + (rightTrackedRemoteState_old.Buttons & ovrButton_GripTrigger)) { + + if (rightTrackedRemoteState_new.Buttons & ovrButton_GripTrigger) + { + if (distance < 0.50f) + { + Cvar_Set2("vr_weapon_stabilised", "1", true); + } + } + else + { + Cvar_Set2("vr_weapon_stabilised", "0", true); + } + } + + //dominant hand stuff first + { + ///Weapon location relative to view + weaponoffset[0] = leftRemoteTracking_new.HeadPose.Pose.Position.x - hmdPosition[0]; + weaponoffset[1] = leftRemoteTracking_new.HeadPose.Pose.Position.y - hmdPosition[1]; + weaponoffset[2] = leftRemoteTracking_new.HeadPose.Pose.Position.z - hmdPosition[2]; + + { + vec2_t v; + rotateAboutOrigin(weaponoffset[0], weaponoffset[2], -(cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]), v); + weaponoffset[0] = v[0]; + weaponoffset[2] = v[1]; + + ALOGV(" Weapon Offset: %f, %f, %f", + weaponoffset[0], + weaponoffset[1], + weaponoffset[2]); + } + + //Weapon velocity + weaponvelocity[0] = leftRemoteTracking_new.HeadPose.LinearVelocity.x; + weaponvelocity[1] = leftRemoteTracking_new.HeadPose.LinearVelocity.y; + weaponvelocity[2] = leftRemoteTracking_new.HeadPose.LinearVelocity.z; + + { + vec2_t v; + rotateAboutOrigin(weaponvelocity[0], weaponvelocity[2], -cl.refdef.cl_viewangles[YAW], v); + weaponvelocity[0] = v[0]; + weaponvelocity[2] = v[1]; + + ALOGV(" Weapon Velocity: %f, %f, %f", + weaponvelocity[0], + weaponvelocity[1], + weaponvelocity[2]); + } + + + //Set gun angles + const ovrQuatf quatRemote = leftRemoteTracking_new.HeadPose.Pose.Orientation; + QuatToYawPitchRoll(quatRemote, vr_weapon_pitchadjust->value, weaponangles[ADJUSTED]); + QuatToYawPitchRoll(quatRemote, 0.0f, weaponangles[UNADJUSTED]); + QuatToYawPitchRoll(quatRemote, -30.0f, weaponangles[MELEE]); + + + if (vr_weapon_stabilised->integer && + //Don't trigger stabilisation if controllers are close together (holding Glock for example) + (distance > 0.15f)) + { + float z = rightRemoteTracking_new.HeadPose.Pose.Position.z - leftRemoteTracking_new.HeadPose.Pose.Position.z; + float x = rightRemoteTracking_new.HeadPose.Pose.Position.x - leftRemoteTracking_new.HeadPose.Pose.Position.x; + float y = rightRemoteTracking_new.HeadPose.Pose.Position.y - leftRemoteTracking_new.HeadPose.Pose.Position.y; + float zxDist = length(x, z); + + if (zxDist != 0.0f && z != 0.0f) { + VectorSet(weaponangles[ADJUSTED], degrees(atanf(y / zxDist)), (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]) - degrees(atan2f(x, -z)), weaponangles[ADJUSTED][ROLL]); + VectorSet(weaponangles[UNADJUSTED], degrees(atanf(y / zxDist)), (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]) - degrees(atan2f(x, -z)), weaponangles[UNADJUSTED][ROLL]); + VectorSet(weaponangles[MELEE], degrees(atanf(y / zxDist)), (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]) - degrees(atan2f(x, -z)), weaponangles[MELEE][ROLL]); + } + } + else + { + weaponangles[ADJUSTED][YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + weaponangles[ADJUSTED][PITCH] *= -1.0f; + + weaponangles[UNADJUSTED][YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + weaponangles[UNADJUSTED][PITCH] *= -1.0f; + + weaponangles[MELEE][YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + weaponangles[MELEE][PITCH] *= -1.0f; + } + + //Use (Action) + if ((leftTrackedRemoteState_new.Buttons & ovrButton_Joystick) != + (leftTrackedRemoteState_old.Buttons & ovrButton_Joystick)) { + + sendButtonAction("+use", (leftTrackedRemoteState_new.Buttons & ovrButton_Joystick)); + } + + static bool finishReloadNextFrame = false; + if (finishReloadNextFrame) + { + sendButtonActionSimple("-reload"); + finishReloadNextFrame = false; + } + + if ((leftTrackedRemoteState_new.Buttons & ovrButton_GripTrigger) != + (leftTrackedRemoteState_old.Buttons & ovrButton_GripTrigger)) { + + dominantGripPushed = (leftTrackedRemoteState_new.Buttons & ovrButton_GripTrigger); + + if (dominantGripPushed) + { + dominantGripPushTime = GetTimeInMilliSeconds(); + } + else + { + if ((GetTimeInMilliSeconds() - dominantGripPushTime) < vr_reloadtimeoutms->integer) + { + sendButtonActionSimple("+reload"); + finishReloadNextFrame = true; + } + } + } + } + + float controllerYawHeading = 0.0f; + //off-hand stuff + { + flashlightoffset[0] = rightRemoteTracking_new.HeadPose.Pose.Position.x - hmdPosition[0]; + flashlightoffset[1] = rightRemoteTracking_new.HeadPose.Pose.Position.y - hmdPosition[1]; + flashlightoffset[2] = rightRemoteTracking_new.HeadPose.Pose.Position.z - hmdPosition[2]; + + vec2_t v; + rotateAboutOrigin(flashlightoffset[0], flashlightoffset[2], -(cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]), v); + flashlightoffset[0] = v[0]; + flashlightoffset[2] = v[1]; + + QuatToYawPitchRoll(rightRemoteTracking_new.HeadPose.Pose.Orientation, 15.0f, flashlightangles); + + flashlightangles[YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + + if (vr_walkdirection->integer == 0) { + controllerYawHeading = -cl.refdef.cl_viewangles[YAW] + flashlightangles[YAW]; + } + else + { + controllerYawHeading = 0.0f; + } + } + + //Right-hand specific stuff + { + ALOGV(" Right-Controller-Position: %f, %f, %f", + leftRemoteTracking_new.HeadPose.Pose.Position.x, + leftRemoteTracking_new.HeadPose.Pose.Position.y, + leftRemoteTracking_new.HeadPose.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 + float multiplier = vr_positional_factor->value / (cl_forwardspeed->value * + ((rightTrackedRemoteState_new.Buttons & ovrButton_Trigger) ? cl_movespeedkey->value : 1.0f)); + + vec2_t v; + rotateAboutOrigin(-positionDeltaThisFrame[0] * multiplier, + positionDeltaThisFrame[2] * multiplier, -hmdorientation[YAW], v); + positional_movementSideways = v[0]; + positional_movementForward = v[1]; + + ALOGV(" positional_movementSideways: %f, positional_movementForward: %f", + positional_movementSideways, + positional_movementForward); + + //Jump (Y Button) + handleTrackedControllerButton(&leftTrackedRemoteState_new, + &leftTrackedRemoteState_old, ovrButton_Y, K_SPACE); + + //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 + static bool firingPrimary = false; + + if (!firingPrimary && dominantGripPushed && (GetTimeInMilliSeconds() - dominantGripPushTime) > vr_reloadtimeoutms->integer) + { + //Fire Secondary + if ((leftTrackedRemoteState_new.Buttons & ovrButton_Trigger) != + (leftTrackedRemoteState_old.Buttons & ovrButton_Trigger)) { + + sendButtonAction("+attack2", (leftTrackedRemoteState_new.Buttons & ovrButton_Trigger)); + } + } + else + { + //Fire Primary + if ((leftTrackedRemoteState_new.Buttons & ovrButton_Trigger) != + (leftTrackedRemoteState_old.Buttons & ovrButton_Trigger)) { + + firingPrimary = (leftTrackedRemoteState_new.Buttons & ovrButton_Trigger); + sendButtonAction("+attack", firingPrimary); + } + } + + //Duck with X + if ((leftTrackedRemoteState_new.Buttons & ovrButton_X) != + (leftTrackedRemoteState_old.Buttons & ovrButton_X)) { + + sendButtonAction("+duck", (leftTrackedRemoteState_new.Buttons & ovrButton_X)); + } + + //Weapon Chooser + static bool weaponSwitched = false; + if (between(-0.2f, leftTrackedRemoteState_new.Joystick.x, 0.2f) && + (between(0.8f, leftTrackedRemoteState_new.Joystick.y, 1.0f) || + between(-1.0f, leftTrackedRemoteState_new.Joystick.y, -0.8f))) + { + if (!weaponSwitched) { + if (between(0.8f, leftTrackedRemoteState_new.Joystick.y, 1.0f)) + { + sendButtonActionSimple("invnext"); + } + else + { + sendButtonActionSimple("invprev"); + } + weaponSwitched = true; + } + } else { + weaponSwitched = false; + } + } + + //Left-hand specific stuff + { + ALOGV(" Left-Controller-Position: %f, %f, %f", + rightRemoteTracking_new.HeadPose.Pose.Position.x, + rightRemoteTracking_new.HeadPose.Pose.Position.y, + rightRemoteTracking_new.HeadPose.Pose.Position.z); + + //Use (Action) + if ((rightTrackedRemoteState_new.Buttons & ovrButton_Joystick) != + (rightTrackedRemoteState_old.Buttons & ovrButton_Joystick) + && (rightTrackedRemoteState_new.Buttons & ovrButton_Joystick)) { + + Cvar_SetFloat("vr_lasersight", 1.0f - vr_lasersight->value); + + } + + //Apply a filter and quadratic scaler so small movements are easier to make + float dist = length(rightTrackedRemoteState_new.Joystick.x, rightTrackedRemoteState_new.Joystick.y); + float nlf = nonLinearFilter(dist); + float x = nlf * rightTrackedRemoteState_new.Joystick.x; + float y = nlf * rightTrackedRemoteState_new.Joystick.y; + + //Adjust to be off-hand controller oriented + vec2_t v; + rotateAboutOrigin(x, y, controllerYawHeading,v); + + remote_movementSideways = v[0]; + remote_movementForward = v[1]; + + ALOGV(" remote_movementSideways: %f, remote_movementForward: %f", + remote_movementSideways, + remote_movementForward); + + + //flashlight on/off + if (((rightTrackedRemoteState_new.Buttons & ovrButton_A) != + (rightTrackedRemoteState_old.Buttons & ovrButton_A)) && + (rightTrackedRemoteState_old.Buttons & ovrButton_A)) { + sendButtonActionSimple("impulse 100"); + } + + + //We need to record if we have started firing primary so that releasing trigger will stop definitely firing, if user has pushed grip + //in meantime, then it wouldn't stop the gun firing and it would get stuck + static bool firingPrimary = false; + + //Run + handleTrackedControllerButton(&rightTrackedRemoteState_new, + &rightTrackedRemoteState_old, + ovrButton_Trigger, K_SHIFT); + + static increaseSnap = true; + if (leftTrackedRemoteState_new.Joystick.x > 0.6f) + { + if (increaseSnap) + { + snapTurn -= vr_snapturn_angle->value; + if (vr_snapturn_angle->value > 10.0f) { + increaseSnap = false; + } + + if (snapTurn < -180.0f) + { + snapTurn += 360.f; + } + } + } else if (leftTrackedRemoteState_new.Joystick.x < 0.4f) { + increaseSnap = true; + } + + static decreaseSnap = true; + if (leftTrackedRemoteState_new.Joystick.x < -0.6f) + { + if (decreaseSnap) + { + snapTurn += vr_snapturn_angle->value; + + //If snap turn configured for less than 10 degrees + if (vr_snapturn_angle->value > 10.0f) { + decreaseSnap = false; + } + + if (snapTurn > 180.0f) + { + snapTurn -= 360.f; + } + } + } else if (leftTrackedRemoteState_new.Joystick.x > -0.4f) + { + decreaseSnap = true; + } + } + } + + //Save state + leftTrackedRemoteState_old = leftTrackedRemoteState_new; + rightTrackedRemoteState_old = rightTrackedRemoteState_new; +} \ No newline at end of file diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputRight.c b/Projects/Android/jni/src/Lambda1VR/VrInputRight.c index 0d0ede9..0d0bc27 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputRight.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputRight.c @@ -27,52 +27,17 @@ Authors : Simon Brown extern cvar_t *cl_forwardspeed; extern cvar_t *cl_movespeedkey; -int IN_TouchEvent( touchEventType type, int fingerID, float x, float y, float dx, float dy ); void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx, float dy ); -float initialTouchX, initialTouchY; - - -void HandleInput_Right( ovrMobile * Ovr, double displayTime ) +void HandleInput_Right(ovrMobile * Ovr, double displayTime ) { //Ensure handedness is set to right Cvar_Set("r_lefthand", "0"); - //The amount of yaw changed by controller - //TODO: fixme - for ( int i = 0; ; i++ ) { - ovrInputCapabilityHeader cap; - ovrResult result = vrapi_EnumerateInputDevices(Ovr, i, &cap); - if (result < 0) { - break; - } + //Get info for tracked remotes + acquireTrackedRemotesData(Ovr, displayTime); - 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; - } else{ - leftTrackedRemoteState_new = trackedRemoteState; - leftRemoteTracking_new = remoteTracking; - } - } - } - } - - static bool dominantGripPushed = false; + static bool dominantGripPushed = false; static float dominantGripPushTime = 0.0f; //Show screen view (if in multiplayer toggle scoreboard) @@ -94,36 +59,7 @@ void HandleInput_Right( ovrMobile * Ovr, double displayTime ) //Menu control - Uses "touch" if (useScreenLayer()) { - float remoteAngles[3]; - QuatToYawPitchRoll(rightRemoteTracking_new.HeadPose.Pose.Orientation, 0.0f, remoteAngles); - float yaw = remoteAngles[YAW] - playerYaw; - - //Adjust for maximum yaw values - if (yaw >= 180.0f) yaw -= 180.0f; - if (yaw <= -180.0f) yaw += 180.0f; - - if (yaw > -40.0f && yaw < 40.0f && - remoteAngles[PITCH] > -22.5f && remoteAngles[PITCH] < 22.5f) { - - int newRemoteTrigState = (rightTrackedRemoteState_new.Buttons & ovrButton_Trigger) != 0; - int prevRemoteTrigState = (rightTrackedRemoteState_old.Buttons & ovrButton_Trigger) != 0; - - touchEventType t = event_motion; - - float touchX = (-yaw + 40.0f) / 80.0f; - float touchY = (remoteAngles[PITCH] + 22.5f) / 45.0f; - if (newRemoteTrigState != prevRemoteTrigState) - { - t = newRemoteTrigState ? event_down : event_up; - if (newRemoteTrigState) - { - initialTouchX = touchX; - initialTouchY = touchY; - } - } - - IN_TouchEvent(t, 0, touchX, touchY, initialTouchX - touchX, initialTouchY - touchY); - } + interactWithTouchScreen(&rightRemoteTracking_new, &rightTrackedRemoteState_new, &rightTrackedRemoteState_old); } else { diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c b/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c new file mode 100644 index 0000000..8201365 --- /dev/null +++ b/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c @@ -0,0 +1,399 @@ +/************************************************************************************ + +Filename : VrInputRightAlt.c +Content : Handles controller input for the right-handed alternative configuration #1 +Created : August 2019 +Authors : Simon Brown + +*************************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "VrInput.h" +#include "VrCvars.h" + +extern cvar_t *cl_forwardspeed; +extern cvar_t *cl_movespeedkey; + +void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx, float dy ); + +void HandleInput_RightAlt(ovrMobile * Ovr, double displayTime ) +{ + //Ensure handedness is set to right + Cvar_Set("r_lefthand", "0"); + + //Get info for tracked remotes + acquireTrackedRemotesData(Ovr, displayTime); + + static bool dominantGripPushed = false; + static float dominantGripPushTime = 0.0f; + + //Show screen view (if in multiplayer toggle scoreboard) + if (((leftTrackedRemoteState_new.Buttons & ovrButton_Y) != + (leftTrackedRemoteState_old.Buttons & ovrButton_Y)) && + (leftTrackedRemoteState_new.Buttons & ovrButton_Y)) { + + showingScreenLayer = !showingScreenLayer; + + //Check we are in multiplayer + if (isMultiplayer()) { + sendButtonAction("+showscores", showingScreenLayer); + } + } + + //Menu button + handleTrackedControllerButton(&leftTrackedRemoteState_new, &leftTrackedRemoteState_old, ovrButton_Enter, K_ESCAPE); + + //Menu control - Uses "touch" + if (useScreenLayer()) + { + interactWithTouchScreen(&rightRemoteTracking_new, &rightTrackedRemoteState_new, &rightTrackedRemoteState_old); + } + else + { + //If distance to off-hand remote is less than 35cm and user pushes grip, then we enable weapon stabilisation + float distance = sqrtf(powf(leftRemoteTracking_new.HeadPose.Pose.Position.x - rightRemoteTracking_new.HeadPose.Pose.Position.x, 2) + + powf(leftRemoteTracking_new.HeadPose.Pose.Position.y - rightRemoteTracking_new.HeadPose.Pose.Position.y, 2) + + powf(leftRemoteTracking_new.HeadPose.Pose.Position.z - rightRemoteTracking_new.HeadPose.Pose.Position.z, 2)); + + //Turn on weapon stabilisation? + if ((leftTrackedRemoteState_new.Buttons & ovrButton_GripTrigger) != + (leftTrackedRemoteState_old.Buttons & ovrButton_GripTrigger)) { + + if (leftTrackedRemoteState_new.Buttons & ovrButton_GripTrigger) + { + if (distance < 0.50f) + { + Cvar_Set2("vr_weapon_stabilised", "1", true); + } + } + else + { + Cvar_Set2("vr_weapon_stabilised", "0", true); + } + } + + //dominant hand stuff first + { + ///Weapon location relative to view + weaponoffset[0] = rightRemoteTracking_new.HeadPose.Pose.Position.x - hmdPosition[0]; + weaponoffset[1] = rightRemoteTracking_new.HeadPose.Pose.Position.y - hmdPosition[1]; + weaponoffset[2] = rightRemoteTracking_new.HeadPose.Pose.Position.z - hmdPosition[2]; + + { + vec2_t v; + rotateAboutOrigin(weaponoffset[0], weaponoffset[2], -(cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]), v); + weaponoffset[0] = v[0]; + weaponoffset[2] = v[1]; + + ALOGV(" Weapon Offset: %f, %f, %f", + weaponoffset[0], + weaponoffset[1], + weaponoffset[2]); + } + + //Weapon velocity + weaponvelocity[0] = rightRemoteTracking_new.HeadPose.LinearVelocity.x; + weaponvelocity[1] = rightRemoteTracking_new.HeadPose.LinearVelocity.y; + weaponvelocity[2] = rightRemoteTracking_new.HeadPose.LinearVelocity.z; + + { + vec2_t v; + rotateAboutOrigin(weaponvelocity[0], weaponvelocity[2], -cl.refdef.cl_viewangles[YAW], v); + weaponvelocity[0] = v[0]; + weaponvelocity[2] = v[1]; + + ALOGV(" Weapon Velocity: %f, %f, %f", + weaponvelocity[0], + weaponvelocity[1], + weaponvelocity[2]); + } + + + //Set gun angles - We need to calculate all those we might need (including adjustments) for the client to then take its pick + const ovrQuatf quatRemote = rightRemoteTracking_new.HeadPose.Pose.Orientation; + QuatToYawPitchRoll(quatRemote, vr_weapon_pitchadjust->value, weaponangles[ADJUSTED]); + QuatToYawPitchRoll(quatRemote, 0.0f, weaponangles[UNADJUSTED]); + QuatToYawPitchRoll(quatRemote, -30.0f, weaponangles[MELEE]); + + + if (vr_weapon_stabilised->integer && + //Don't trigger stabilisation if controllers are close together (holding Glock for example) + (distance > 0.15f)) + { + float z = leftRemoteTracking_new.HeadPose.Pose.Position.z - rightRemoteTracking_new.HeadPose.Pose.Position.z; + float x = leftRemoteTracking_new.HeadPose.Pose.Position.x - rightRemoteTracking_new.HeadPose.Pose.Position.x; + float y = leftRemoteTracking_new.HeadPose.Pose.Position.y - rightRemoteTracking_new.HeadPose.Pose.Position.y; + float zxDist = length(x, z); + + if (zxDist != 0.0f && z != 0.0f) { + VectorSet(weaponangles[ADJUSTED], degrees(atanf(y / zxDist)), (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]) - degrees(atan2f(x, -z)), weaponangles[ADJUSTED][ROLL]); + VectorSet(weaponangles[UNADJUSTED], degrees(atanf(y / zxDist)), (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]) - degrees(atan2f(x, -z)), weaponangles[UNADJUSTED][ROLL]); + VectorSet(weaponangles[MELEE], degrees(atanf(y / zxDist)), (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]) - degrees(atan2f(x, -z)), weaponangles[MELEE][ROLL]); + } + } + else + { + weaponangles[ADJUSTED][YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + weaponangles[ADJUSTED][PITCH] *= -1.0f; + + weaponangles[UNADJUSTED][YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + weaponangles[UNADJUSTED][PITCH] *= -1.0f; + + weaponangles[MELEE][YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + weaponangles[MELEE][PITCH] *= -1.0f; + } + + //Use (Action) + if ((rightTrackedRemoteState_new.Buttons & ovrButton_Joystick) != + (rightTrackedRemoteState_old.Buttons & ovrButton_Joystick)) { + + sendButtonAction("+use", (rightTrackedRemoteState_new.Buttons & ovrButton_Joystick)); + } + + static bool finishReloadNextFrame = false; + if (finishReloadNextFrame) + { + sendButtonActionSimple("-reload"); + finishReloadNextFrame = false; + } + + if ((rightTrackedRemoteState_new.Buttons & ovrButton_GripTrigger) != + (rightTrackedRemoteState_old.Buttons & ovrButton_GripTrigger)) { + + dominantGripPushed = (rightTrackedRemoteState_new.Buttons & ovrButton_GripTrigger); + + if (dominantGripPushed) + { + dominantGripPushTime = GetTimeInMilliSeconds(); + } + else + { + if ((GetTimeInMilliSeconds() - dominantGripPushTime) < vr_reloadtimeoutms->integer) + { + sendButtonActionSimple("+reload"); + finishReloadNextFrame = true; + } + } + } + } + + float controllerYawHeading = 0.0f; + //off-hand stuff + { + flashlightoffset[0] = leftRemoteTracking_new.HeadPose.Pose.Position.x - hmdPosition[0]; + flashlightoffset[1] = leftRemoteTracking_new.HeadPose.Pose.Position.y - hmdPosition[1]; + flashlightoffset[2] = leftRemoteTracking_new.HeadPose.Pose.Position.z - hmdPosition[2]; + + vec2_t v; + rotateAboutOrigin(flashlightoffset[0], flashlightoffset[2], -(cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]), v); + flashlightoffset[0] = v[0]; + flashlightoffset[2] = v[1]; + + QuatToYawPitchRoll(leftRemoteTracking_new.HeadPose.Pose.Orientation, 15.0f, flashlightangles); + + flashlightangles[YAW] += (cl.refdef.cl_viewangles[YAW] - hmdorientation[YAW]); + + if (vr_walkdirection->integer == 0) { + controllerYawHeading = -cl.refdef.cl_viewangles[YAW] + flashlightangles[YAW]; + } + else + { + controllerYawHeading = 0.0f;//-cl.refdef.cl_viewangles[YAW]; + } + } + + //Right-hand specific stuff + { + ALOGV(" Right-Controller-Position: %f, %f, %f", + rightRemoteTracking_new.HeadPose.Pose.Position.x, + rightRemoteTracking_new.HeadPose.Pose.Position.y, + rightRemoteTracking_new.HeadPose.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 + float multiplier = vr_positional_factor->value / (cl_forwardspeed->value * + ((leftTrackedRemoteState_new.Buttons & ovrButton_Trigger) ? cl_movespeedkey->value : 1.0f)); + + vec2_t v; + rotateAboutOrigin(-positionDeltaThisFrame[0] * multiplier, + positionDeltaThisFrame[2] * multiplier, -hmdorientation[YAW], v); + positional_movementSideways = v[0]; + positional_movementForward = v[1]; + + ALOGV(" positional_movementSideways: %f, positional_movementForward: %f", + positional_movementSideways, + positional_movementForward); + + //Jump (B Button) + handleTrackedControllerButton(&rightTrackedRemoteState_new, + &rightTrackedRemoteState_old, ovrButton_B, K_SPACE); + + //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 + static bool firingPrimary = false; + + if (!firingPrimary && dominantGripPushed && (GetTimeInMilliSeconds() - dominantGripPushTime) > vr_reloadtimeoutms->integer) + { + //Fire Secondary + if ((rightTrackedRemoteState_new.Buttons & ovrButton_Trigger) != + (rightTrackedRemoteState_old.Buttons & ovrButton_Trigger)) { + + sendButtonAction("+attack2", (rightTrackedRemoteState_new.Buttons & ovrButton_Trigger)); + } + } + else + { + //Fire Primary + if ((rightTrackedRemoteState_new.Buttons & ovrButton_Trigger) != + (rightTrackedRemoteState_old.Buttons & ovrButton_Trigger)) { + + firingPrimary = (rightTrackedRemoteState_new.Buttons & ovrButton_Trigger); + sendButtonAction("+attack", firingPrimary); + } + } + + //Duck with A + if ((rightTrackedRemoteState_new.Buttons & ovrButton_A) != + (rightTrackedRemoteState_old.Buttons & ovrButton_A)) { + + sendButtonAction("+duck", (rightTrackedRemoteState_new.Buttons & ovrButton_A)); + } + + //Weapon Chooser + static bool weaponSwitched = false; + if (between(-0.2f, rightTrackedRemoteState_new.Joystick.x, 0.2f) && + (between(0.8f, rightTrackedRemoteState_new.Joystick.y, 1.0f) || + between(-1.0f, rightTrackedRemoteState_new.Joystick.y, -0.8f))) + { + if (!weaponSwitched) { + if (between(0.8f, rightTrackedRemoteState_new.Joystick.y, 1.0f)) + { + sendButtonActionSimple("invnext"); + } + else + { + sendButtonActionSimple("invprev"); + } + weaponSwitched = true; + } + } else { + weaponSwitched = false; + } + } + + //Left-hand specific stuff + { + ALOGV(" Left-Controller-Position: %f, %f, %f", + leftRemoteTracking_new.HeadPose.Pose.Position.x, + leftRemoteTracking_new.HeadPose.Pose.Position.y, + leftRemoteTracking_new.HeadPose.Pose.Position.z); + + //Use (Action) + if ((leftTrackedRemoteState_new.Buttons & ovrButton_Joystick) != + (leftTrackedRemoteState_old.Buttons & ovrButton_Joystick) + && (leftTrackedRemoteState_new.Buttons & ovrButton_Joystick)) { + + Cvar_SetFloat("vr_lasersight", 1.0f - vr_lasersight->value); + + } + + //Apply a filter and quadratic scaler so small movements are easier to make + float dist = length(leftTrackedRemoteState_new.Joystick.x, leftTrackedRemoteState_new.Joystick.y); + float nlf = nonLinearFilter(dist); + float x = nlf * leftTrackedRemoteState_new.Joystick.x; + float y = nlf * leftTrackedRemoteState_new.Joystick.y; + + //Adjust to be off-hand controller oriented + vec2_t v; + rotateAboutOrigin(x, y, controllerYawHeading, v); + + remote_movementSideways = v[0]; + remote_movementForward = v[1]; + + ALOGV(" remote_movementSideways: %f, remote_movementForward: %f", + remote_movementSideways, + remote_movementForward); + + + //flashlight on/off + if (((leftTrackedRemoteState_new.Buttons & ovrButton_X) != + (leftTrackedRemoteState_old.Buttons & ovrButton_X)) && + (leftTrackedRemoteState_old.Buttons & ovrButton_X)) { + sendButtonActionSimple("impulse 100"); +/* +#ifndef NDEBUG + Cbuf_AddText( "sv_cheats 1\n" ); + Cbuf_AddText( "impulse 101\n" ); +#endif +*/ } + + + //We need to record if we have started firing primary so that releasing trigger will stop definitely firing, if user has pushed grip + //in meantime, then it wouldn't stop the gun firing and it would get stuck + static bool firingPrimary = false; + + //Run + handleTrackedControllerButton(&leftTrackedRemoteState_new, + &leftTrackedRemoteState_old, + ovrButton_Trigger, K_SHIFT); + + static increaseSnap = true; + if (rightTrackedRemoteState_new.Joystick.x > 0.6f) + { + if (increaseSnap) + { + snapTurn -= vr_snapturn_angle->value; + if (vr_snapturn_angle->value > 10.0f) { + increaseSnap = false; + } + + if (snapTurn < -180.0f) + { + snapTurn += 360.f; + } + } + } else if (rightTrackedRemoteState_new.Joystick.x < 0.4f) { + increaseSnap = true; + } + + static decreaseSnap = true; + if (rightTrackedRemoteState_new.Joystick.x < -0.6f) + { + if (decreaseSnap) + { + snapTurn += vr_snapturn_angle->value; + + //If snap turn configured for less than 10 degrees + if (vr_snapturn_angle->value > 10.0f) { + decreaseSnap = false; + } + + if (snapTurn > 180.0f) + { + snapTurn -= 360.f; + } + } + } else if (rightTrackedRemoteState_new.Joystick.x > -0.4f) + { + decreaseSnap = true; + } + } + } + + //Save state + rightTrackedRemoteState_old = rightTrackedRemoteState_new; + leftTrackedRemoteState_old = leftTrackedRemoteState_new; +} \ No newline at end of file diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/Android.mk b/Projects/Android/jni/src/Xash3D/xash3d/engine/Android.mk index 81c140a..e531c2b 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/Android.mk +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/Android.mk @@ -38,12 +38,18 @@ LOCAL_C_INCLUDES := \ LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES) -LOCAL_SRC_FILES := \ +LAMBDA1VR_SRC_FILES := \ $(LOCAL_PATH)/../../../Lambda1VR/L1VR_SurfaceView.c \ $(LOCAL_PATH)/../../../Lambda1VR/VrCompositor.c \ + $(LOCAL_PATH)/../../../Lambda1VR/VrInputCommon.c \ + $(LOCAL_PATH)/../../../Lambda1VR/VrInputRightAlt.c \ $(LOCAL_PATH)/../../../Lambda1VR/VrInputRight.c \ $(LOCAL_PATH)/../../../Lambda1VR/VrInputLeft.c \ - $(LOCAL_PATH)/../../../Lambda1VR/argtable3.c \ + $(LOCAL_PATH)/../../../Lambda1VR/VrInputLeftAlt.c \ + $(LOCAL_PATH)/../../../Lambda1VR/argtable3.c + +LOCAL_SRC_FILES := \ + $(LAMBDA1VR_SRC_FILES) \ client/cl_cmds.c \ client/cl_demo.c \ client/cl_events.c \ From ec414fa09933c55fe631651b389accf8826bfcfd Mon Sep 17 00:00:00 2001 From: Simon Date: Wed, 4 Sep 2019 22:39:06 +0100 Subject: [PATCH 3/9] Revert "Set World Scale to correct for Engine" This reverts commit 72c3f390b632193b1170071e5df969291474f838. --- .../Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c index 2dab79b..d0e5f3b 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c @@ -878,7 +878,7 @@ void GL_InitCommands( void ) mp_decals = Cvar_Get( "mp_decals", "300", CVAR_ARCHIVE, "sets the maximum number of decals in multiplayer" ); #ifdef VR - vr_worldscale = Cvar_Get( "vr_worldscale", "26.2467", CVAR_ARCHIVE, "Sets the world scale for stereo separation" ); + vr_worldscale = Cvar_Get( "vr_worldscale", "40", CVAR_ARCHIVE, "Sets the world scale for stereo separation" ); #endif gl_picmip = Cvar_Get( "gl_picmip", "0", CVAR_GLCONFIG, "reduces resolution of textures by powers of 2" ); From f09702003f12ce356f06dabd21f25e2d7c38af31 Mon Sep 17 00:00:00 2001 From: Simon Date: Wed, 4 Sep 2019 22:42:04 +0100 Subject: [PATCH 4/9] Mirror gun model for left handed --- Projects/Android/jni/src/Lambda1VR/VrInputLeft.c | 2 +- Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c | 2 +- Projects/Android/jni/src/Lambda1VR/VrInputRight.c | 2 +- Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c | 2 +- Projects/Android/jni/src/Xash3D/xash3d/common/com_model.h | 3 +++ .../jni/src/Xash3D/xash3d/engine/client/gl_studio.c | 7 +++++-- Projects/Android/jni/src/hlsdk-xash3d | 2 +- 7 files changed, 13 insertions(+), 7 deletions(-) diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c b/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c index 3b09614..734cd75 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c @@ -35,7 +35,7 @@ float initialTouchX, initialTouchY; void HandleInput_Left( ovrMobile * Ovr, double displayTime ) { //Ensure handedness is set to left - Cvar_Set("r_lefthand", "1"); + Cvar_Set("hand", "1"); //Get info for tracked remotes acquireTrackedRemotesData(Ovr, displayTime); diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c b/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c index 2a911b0..03ec81b 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c @@ -32,7 +32,7 @@ void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx void HandleInput_LeftAlt( ovrMobile * Ovr, double displayTime ) { //Ensure handedness is set to left - Cvar_Set("r_lefthand", "1"); + Cvar_Set("hand", "1"); //Get info for tracked remotes acquireTrackedRemotesData(Ovr, displayTime); diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputRight.c b/Projects/Android/jni/src/Lambda1VR/VrInputRight.c index 0d0bc27..e107bb9 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputRight.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputRight.c @@ -32,7 +32,7 @@ void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx void HandleInput_Right(ovrMobile * Ovr, double displayTime ) { //Ensure handedness is set to right - Cvar_Set("r_lefthand", "0"); + Cvar_Set("hand", "0"); //Get info for tracked remotes acquireTrackedRemotesData(Ovr, displayTime); diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c b/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c index 8201365..75a0b46 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c @@ -32,7 +32,7 @@ void Touch_Motion( touchEventType type, int fingerID, float x, float y, float dx void HandleInput_RightAlt(ovrMobile * Ovr, double displayTime ) { //Ensure handedness is set to right - Cvar_Set("r_lefthand", "0"); + Cvar_Set("hand", "0"); //Get info for tracked remotes acquireTrackedRemotesData(Ovr, displayTime); diff --git a/Projects/Android/jni/src/Xash3D/xash3d/common/com_model.h b/Projects/Android/jni/src/Xash3D/xash3d/common/com_model.h index 731fb55..5474432 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/common/com_model.h +++ b/Projects/Android/jni/src/Xash3D/xash3d/common/com_model.h @@ -27,6 +27,9 @@ GNU General Public License for more details. #define STUDIO_RENDER 1 #define STUDIO_EVENTS 2 +//Probably shouldn't do this.. but adding a flag to indicate we are rendering the weapon +#define STUDIO_VIEWMODEL 4 + #define ZISCALE ((float)0x8000) #define MIPLEVELS 4 diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c index 885f6f1..5e8d6ff 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c @@ -171,6 +171,9 @@ void R_StudioInit( void ) Matrix3x4_LoadIdentity( g_aliastransform ); Matrix3x4_LoadIdentity( g_rotationmatrix ); + //Probably not needed as it is overwritten anyway + g_rotationmatrix[2][2] = -g_rotationmatrix[2][2]; + g_nStudioCount = 0; m_fDoRemap = false; } @@ -3751,7 +3754,7 @@ void R_DrawViewModel( void ) pglDepthRange( gldepthmin, gldepthmin + 0.3f * ( gldepthmax - gldepthmin )); // backface culling for left-handed weapons - g_iBackFaceCull = R_LeftHand(); // GL_FrontFace is called in SetupStudioRenderer + g_iBackFaceCull = r_lefthand->integer == 1;//R_LeftHand(); // GL_FrontFace is called in SetupStudioRenderer RI.currententity->curstate.scale = 1.0f; RI.currententity->curstate.frame = 0; RI.currententity->curstate.framerate = 1.0f; @@ -3759,7 +3762,7 @@ void R_DrawViewModel( void ) cl.weaponstarttime = cl.time; RI.currententity->curstate.animtime = cl.weaponstarttime; RI.currententity->curstate.sequence = cl.weaponseq; - pStudioDraw->StudioDrawModel( STUDIO_RENDER ); + pStudioDraw->StudioDrawModel( STUDIO_RENDER | STUDIO_VIEWMODEL ); // restore depth range pglDepthRange( gldepthmin, gldepthmax ); diff --git a/Projects/Android/jni/src/hlsdk-xash3d b/Projects/Android/jni/src/hlsdk-xash3d index cf37f32..eff8c57 160000 --- a/Projects/Android/jni/src/hlsdk-xash3d +++ b/Projects/Android/jni/src/hlsdk-xash3d @@ -1 +1 @@ -Subproject commit cf37f32a00e38e6f365b2d704f73acd7c433e98c +Subproject commit eff8c579a1796845c6f48f28ed9e13d36a0de1e4 From f8eccaf2b0702858c7a9b1a10596a5b2cd2a9f9c Mon Sep 17 00:00:00 2001 From: Simon Date: Sun, 8 Sep 2019 17:06:15 +0100 Subject: [PATCH 5/9] Physical Crouching based Duck Crouch to less than 75% of your standing height and you will trigger in-game ducking mechanic. --- .../jni/src/Lambda1VR/L1VR_SurfaceView.c | 18 +++++++++++++++++- Projects/Android/jni/src/Lambda1VR/VrCommon.h | 5 +++++ .../Android/jni/src/Lambda1VR/VrCompositor.c | 2 +- .../Android/jni/src/Lambda1VR/VrInputLeft.c | 5 +++-- .../Android/jni/src/Lambda1VR/VrInputLeftAlt.c | 5 +++-- .../Android/jni/src/Lambda1VR/VrInputRight.c | 5 +++-- .../jni/src/Lambda1VR/VrInputRightAlt.c | 5 +++-- .../jni/src/Xash3D/xash3d/common/const.h | 2 +- .../src/Xash3D/xash3d/engine/client/cl_view.c | 2 +- .../Xash3D/xash3d/engine/client/gl_studio.c | 3 --- Projects/Android/jni/src/hlsdk-xash3d | 2 +- 11 files changed, 38 insertions(+), 16 deletions(-) diff --git a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c index c116b44..81cbe79 100644 --- a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c +++ b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c @@ -816,7 +816,19 @@ void setHMDPosition( float x, float y, float z, float yaw ) playerHeight = y; } else{ playerYaw = yaw; - } + + //Do we trigger crouching based on player height? + if (hmdPosition[1] < (playerHeight * 0.75f) && + ducked == DUCK_NOTDUCKED) { + ducked = DUCK_CROUCHED; + sendButtonAction("+crouch", 1); + } + else if (hmdPosition[1] > (playerHeight * 0.85f) && + ducked == DUCK_CROUCHED) { + ducked = DUCK_NOTDUCKED; + sendButtonAction("+crouch", 0); + } + } hmdPosition[2] = z; } @@ -1280,6 +1292,7 @@ void VR_Init() positional_movementSideways = 0.0f; positional_movementForward = 0.0f; snapTurn = 0.0f; + ducked = DUCK_NOTDUCKED; //Create Cvars vr_snapturn_angle = Cvar_Get( "vr_snapturn_angle", "45", CVAR_ARCHIVE, "Sets the angle for snap-turn, set to < 10.0 to enable smooth turning" ); @@ -1419,6 +1432,9 @@ void * AppThreadFunction( void * parm ) continue; } + //Use floor based tracking space + vrapi_SetTrackingSpace(appState.Ovr, VRAPI_TRACKING_SPACE_LOCAL_FLOOR); + // Create the scene if not yet created. // The scene is created here to be able to show a loading icon. if ( !ovrScene_IsCreated( &appState.Scene ) ) diff --git a/Projects/Android/jni/src/Lambda1VR/VrCommon.h b/Projects/Android/jni/src/Lambda1VR/VrCommon.h index b9acc32..ae32457 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrCommon.h +++ b/Projects/Android/jni/src/Lambda1VR/VrCommon.h @@ -48,6 +48,11 @@ vec3_t weaponvelocity; vec3_t flashlightangles; vec3_t flashlightoffset; +#define DUCK_NOTDUCKED 0 +#define DUCK_BUTTON 1 +#define DUCK_CROUCHED 2 +int ducked; + float radians(float deg); float degrees(float rad); bool isMultiplayer(); diff --git a/Projects/Android/jni/src/Lambda1VR/VrCompositor.c b/Projects/Android/jni/src/Lambda1VR/VrCompositor.c index 9e03d4f..7ac3623 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrCompositor.c +++ b/Projects/Android/jni/src/Lambda1VR/VrCompositor.c @@ -604,7 +604,7 @@ ovrLayerCylinder2 BuildCylinderLayer( ovrRenderer * cylinderRenderer, const float density = 4500.0f; const float rotateYaw = 0.0f; const float radius = 2.0f; - const ovrVector3f translation = { 0.0f, 0.0f, -0.5f }; + const ovrVector3f translation = { 0.0f, playerHeight, -0.5f }; ovrMatrix4f cylinderTransform = CylinderModelMatrix( textureWidth, textureHeight, translation, diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c b/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c index 734cd75..431ad0d 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputLeft.c @@ -270,8 +270,9 @@ void HandleInput_Left( ovrMobile * Ovr, double displayTime ) //Duck with X if ((leftTrackedRemoteState_new.Buttons & ovrButton_X) != - (leftTrackedRemoteState_old.Buttons & ovrButton_X)) { - + (leftTrackedRemoteState_old.Buttons & ovrButton_X) && + ducked != DUCK_CROUCHED) { + ducked = (leftTrackedRemoteState_new.Buttons & ovrButton_X) ? DUCK_BUTTON : DUCK_NOTDUCKED; sendButtonAction("+duck", (leftTrackedRemoteState_new.Buttons & ovrButton_X)); } diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c b/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c index 03ec81b..413f5dc 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputLeftAlt.c @@ -267,8 +267,9 @@ void HandleInput_LeftAlt( ovrMobile * Ovr, double displayTime ) //Duck with X if ((leftTrackedRemoteState_new.Buttons & ovrButton_X) != - (leftTrackedRemoteState_old.Buttons & ovrButton_X)) { - + (leftTrackedRemoteState_old.Buttons & ovrButton_X) && + ducked != DUCK_CROUCHED) { + ducked = (leftTrackedRemoteState_new.Buttons & ovrButton_X) ? DUCK_BUTTON : DUCK_NOTDUCKED; sendButtonAction("+duck", (leftTrackedRemoteState_new.Buttons & ovrButton_X)); } diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputRight.c b/Projects/Android/jni/src/Lambda1VR/VrInputRight.c index e107bb9..28f8a50 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputRight.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputRight.c @@ -267,8 +267,9 @@ void HandleInput_Right(ovrMobile * Ovr, double displayTime ) //Duck with A if ((rightTrackedRemoteState_new.Buttons & ovrButton_A) != - (rightTrackedRemoteState_old.Buttons & ovrButton_A)) { - + (rightTrackedRemoteState_old.Buttons & ovrButton_A) && + ducked != DUCK_CROUCHED) { + ducked = (rightTrackedRemoteState_new.Buttons & ovrButton_A) ? DUCK_BUTTON : DUCK_NOTDUCKED; sendButtonAction("+duck", (rightTrackedRemoteState_new.Buttons & ovrButton_A)); } diff --git a/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c b/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c index 75a0b46..ba8a3c7 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c +++ b/Projects/Android/jni/src/Lambda1VR/VrInputRightAlt.c @@ -267,8 +267,9 @@ void HandleInput_RightAlt(ovrMobile * Ovr, double displayTime ) //Duck with A if ((rightTrackedRemoteState_new.Buttons & ovrButton_A) != - (rightTrackedRemoteState_old.Buttons & ovrButton_A)) { - + (rightTrackedRemoteState_old.Buttons & ovrButton_A) && + ducked != DUCK_CROUCHED) { + ducked = (rightTrackedRemoteState_new.Buttons & ovrButton_A) ? DUCK_BUTTON : DUCK_NOTDUCKED; sendButtonAction("+duck", (rightTrackedRemoteState_new.Buttons & ovrButton_A)); } diff --git a/Projects/Android/jni/src/Xash3D/xash3d/common/const.h b/Projects/Android/jni/src/Xash3D/xash3d/common/const.h index 2a2520d..ec18de9 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/common/const.h +++ b/Projects/Android/jni/src/Xash3D/xash3d/common/const.h @@ -666,7 +666,7 @@ #define IN_FORWARD (1U << 3) #define IN_BACK (1U << 4) #define IN_USE (1U << 5) -#define IN_CANCEL (1U << 6) +#define IN_CROUCH (1U << 6) #define IN_LEFT (1U << 7) #define IN_RIGHT (1U << 8) #define IN_MOVELEFT (1U << 9) diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c index 815b1b3..03836bc 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c @@ -140,7 +140,7 @@ void V_SetupRefDef( void ) #ifdef VR //Only reasonable place to do this - cl.refdef.viewheight[2] += ((hmdPosition[1] - playerHeight) * vr_worldscale->value); + cl.refdef.viewheight[2] += ((hmdPosition[1] - playerHeight) + 0.02) * vr_worldscale->value; // Add 20cm height as for some reason player is never quite tall enough cl.refdef.weapon.flags = 0; cl.refdef.weapon.flags |= vr_weapon_stabilised->integer; diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c index 5e8d6ff..ee8046f 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/gl_studio.c @@ -171,9 +171,6 @@ void R_StudioInit( void ) Matrix3x4_LoadIdentity( g_aliastransform ); Matrix3x4_LoadIdentity( g_rotationmatrix ); - //Probably not needed as it is overwritten anyway - g_rotationmatrix[2][2] = -g_rotationmatrix[2][2]; - g_nStudioCount = 0; m_fDoRemap = false; } diff --git a/Projects/Android/jni/src/hlsdk-xash3d b/Projects/Android/jni/src/hlsdk-xash3d index eff8c57..8bdca66 160000 --- a/Projects/Android/jni/src/hlsdk-xash3d +++ b/Projects/Android/jni/src/hlsdk-xash3d @@ -1 +1 @@ -Subproject commit eff8c579a1796845c6f48f28ed9e13d36a0de1e4 +Subproject commit 8bdca66602127accb3f71586e6f0184326a1b226 From c97dc06afdafcf7fcaf5dc2010494f501f0671d2 Mon Sep 17 00:00:00 2001 From: Simon Date: Sun, 8 Sep 2019 17:10:06 +0100 Subject: [PATCH 6/9] Update hlsdk-xash3d --- Projects/Android/jni/src/hlsdk-xash3d | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Projects/Android/jni/src/hlsdk-xash3d b/Projects/Android/jni/src/hlsdk-xash3d index 8bdca66..7d43e43 160000 --- a/Projects/Android/jni/src/hlsdk-xash3d +++ b/Projects/Android/jni/src/hlsdk-xash3d @@ -1 +1 @@ -Subproject commit 8bdca66602127accb3f71586e6f0184326a1b226 +Subproject commit 7d43e431bb739135318f9acdb331417dca3fee80 From 7eace8b030951eeae9520b5725c4c42d0a8b4a71 Mon Sep 17 00:00:00 2001 From: Simon Date: Sun, 8 Sep 2019 22:35:58 +0100 Subject: [PATCH 7/9] Update L1VR_SurfaceView.c Fixes bug with screen layer being stuck --- .../jni/src/Lambda1VR/L1VR_SurfaceView.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c index 81cbe79..f771a7e 100644 --- a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c +++ b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c @@ -809,16 +809,24 @@ void setWorldPosition( float x, float y, float z ) void setHMDPosition( float x, float y, float z, float yaw ) { - hmdPosition[0] = x; - hmdPosition[1] = y; - if (useScreenLayer()) + static bool s_useScreen = false; + + VectorSet(hmdPosition, x, y, z); + + if (s_useScreen != useScreenLayer()) { + s_useScreen = useScreenLayer(); + + //Record player height on transition playerHeight = y; - } else{ + } + + if (!useScreenLayer()) + { playerYaw = yaw; //Do we trigger crouching based on player height? - if (hmdPosition[1] < (playerHeight * 0.75f) && + if (hmdPosition[1] < (playerHeight * 0.8f) && ducked == DUCK_NOTDUCKED) { ducked = DUCK_CROUCHED; sendButtonAction("+crouch", 1); @@ -829,7 +837,6 @@ void setHMDPosition( float x, float y, float z, float yaw ) sendButtonAction("+crouch", 0); } } - hmdPosition[2] = z; } bool isMultiplayer() From 8ab4c2f006338a136005fa55f4c1fd3f2fe34341 Mon Sep 17 00:00:00 2001 From: Simon Date: Wed, 11 Sep 2019 00:10:50 +0100 Subject: [PATCH 8/9] Multiple Changes.. - HUD icon to show player crouched ("Stealth") - cvar to disable crouch mechanic - height adjustment cvar - flashlight model cvar - Player height in game is now player height irl - Reduce decal count for performance --- .../jni/src/Lambda1VR/L1VR_SurfaceView.c | 26 ++++++++++-------- Projects/Android/jni/src/Lambda1VR/VrCvars.h | 3 ++ .../Xash3D/xash3d/engine/client/cl_frame.c | 4 ++- .../src/Xash3D/xash3d/engine/client/cl_view.c | 6 +++- .../Xash3D/xash3d/engine/client/vid_common.c | 4 ++- .../src/Xash3D/xash3d/engine/server/sv_game.c | 3 +- .../Xash3D/xash3d/engine/server/sv_world.c | 5 ++-- .../xash3d/mainui/menus/Multiplayer.cpp | 4 ++- Projects/Android/jni/src/hlsdk-xash3d | 2 +- assets/sprites/s_stealth.spr | Bin 0 -> 4926 bytes .../drbeef/lambda1vr/GLES3JNIActivity.java | 3 ++ 11 files changed, 41 insertions(+), 19 deletions(-) create mode 100644 assets/sprites/s_stealth.spr diff --git a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c index f771a7e..f2b768d 100644 --- a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c +++ b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c @@ -825,17 +825,18 @@ void setHMDPosition( float x, float y, float z, float yaw ) { playerYaw = yaw; - //Do we trigger crouching based on player height? - if (hmdPosition[1] < (playerHeight * 0.8f) && - ducked == DUCK_NOTDUCKED) { - ducked = DUCK_CROUCHED; - sendButtonAction("+crouch", 1); - } - else if (hmdPosition[1] > (playerHeight * 0.85f) && - ducked == DUCK_CROUCHED) { - ducked = DUCK_NOTDUCKED; - sendButtonAction("+crouch", 0); - } + if (vr_enable_crouching->integer) { + //Do we trigger crouching based on player height? + if (hmdPosition[1] < (playerHeight * 0.8f) && + ducked == DUCK_NOTDUCKED) { + ducked = DUCK_CROUCHED; + sendButtonAction("+crouch", 1); + } else if (hmdPosition[1] > (playerHeight * 0.82f) && + ducked == DUCK_CROUCHED) { + ducked = DUCK_NOTDUCKED; + sendButtonAction("+crouch", 0); + } + } } } @@ -1312,6 +1313,9 @@ void VR_Init() vr_lasersight = Cvar_Get( "vr_lasersight", "0", CVAR_ARCHIVE, "Enables laser-sight" ); vr_fov = Cvar_Get( "vr_fov", "107", CVAR_ARCHIVE, "FOV for Lambda1VR" ); vr_control_scheme = Cvar_Get( "vr_control_scheme", "0", CVAR_ARCHIVE, "Controller Layout scheme" ); + vr_enable_crouching = Cvar_Get( "vr_enable_crouching", "1", CVAR_ARCHIVE, "Crouching irl triggers ducking in game" ); + vr_height_adjust = Cvar_Get( "vr_height_adjust", "0.0", CVAR_ARCHIVE, "Additional height adjustment for in-game player (in metres)" ); + vr_flashlight_model = Cvar_Get( "vr_flashlight_model", "1", CVAR_ARCHIVE, "Set to 0 to prevent drawing the flashlight model" ); //Not to be changed by users, as it will be overwritten anyway vr_stereo_side = Cvar_Get( "vr_stereo_side", "0", CVAR_READ_ONLY, "Eye being drawn" ); diff --git a/Projects/Android/jni/src/Lambda1VR/VrCvars.h b/Projects/Android/jni/src/Lambda1VR/VrCvars.h index 9d691c6..6f9783f 100644 --- a/Projects/Android/jni/src/Lambda1VR/VrCvars.h +++ b/Projects/Android/jni/src/Lambda1VR/VrCvars.h @@ -12,6 +12,9 @@ convar_t *vr_weapon_stabilised; convar_t *vr_lasersight; convar_t *vr_fov; convar_t *vr_control_scheme; +convar_t *vr_enable_crouching; +convar_t *vr_height_adjust; +convar_t *vr_flashlight_model; //Used and updated continuously during rendering convar_t *vr_stereo_side; \ No newline at end of file diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_frame.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_frame.c index fbd0085..297f918 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_frame.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_frame.c @@ -1299,6 +1299,7 @@ CL_AddEntities Emits all entities, particles, and lights to the refresh =============== */ +extern convar_t *vr_flashlight_model; void CL_AddEntities( void ) { if( cls.state != ca_active ) @@ -1315,7 +1316,8 @@ void CL_AddEntities( void ) // add flashlight model if required if( cl.frame.client.flags & FL_HAS_FLASHLIGHT && - cl.refdef.weapon.flags != 1) // Make sure weapon isn't being stabilised + cl.refdef.weapon.flags != 1 && // Make sure weapon isn't being stabilised + vr_flashlight_model->integer) { CL_AttachFlashlightEntityToPlayer( "models/v_torch.mdl", cl.refdef.flashlight.org, cl.refdef.flashlight.angles.adjusted); } diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c index 03836bc..8c8da17 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/cl_view.c @@ -37,6 +37,7 @@ update refdef values each frame #ifdef VR extern cvar_t *vr_worldscale; extern convar_t *vr_weapon_stabilised; +extern convar_t *vr_height_adjust; extern float playerHeight; extern float hmdPosition[3]; @@ -47,6 +48,8 @@ extern vec3_t weaponvelocity; extern vec3_t flashlightangles; extern vec3_t flashlightoffset; +#define GORDON_FREEMAN_HEIGHT 1.57 + static void convertFromVRtoHL(vec3_t in, vec3_t out) { vec3_t originInVRSpace; @@ -140,7 +143,8 @@ void V_SetupRefDef( void ) #ifdef VR //Only reasonable place to do this - cl.refdef.viewheight[2] += ((hmdPosition[1] - playerHeight) + 0.02) * vr_worldscale->value; // Add 20cm height as for some reason player is never quite tall enough + cl.refdef.viewheight[2] -= (GORDON_FREEMAN_HEIGHT * vr_worldscale->value); // subtract Gordon's default height + cl.refdef.viewheight[2] += (hmdPosition[1] + vr_height_adjust->value) * vr_worldscale->value; cl.refdef.weapon.flags = 0; cl.refdef.weapon.flags |= vr_weapon_stabilised->integer; diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c index d0e5f3b..664452f 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/client/vid_common.c @@ -871,7 +871,6 @@ void GL_InitCommands( void ) r_drawentities = Cvar_Get( "r_drawentities", "1", CVAR_CHEAT|CVAR_ARCHIVE, "render entities" ); r_flaresize = Cvar_Get( "r_flaresize", "200", CVAR_ARCHIVE, "set flares size" ); r_lefthand = Cvar_Get( "hand", "0", CVAR_ARCHIVE, "viewmodel handedness" ); - r_decals = Cvar_Get( "r_decals", "4096", 0, "sets the maximum number of decals" ); r_xpos = Cvar_Get( "r_xpos", "130", CVAR_GLCONFIG, "window position by horizontal" ); r_ypos = Cvar_Get( "r_ypos", "48", CVAR_GLCONFIG, "window position by vertical" ); r_underwater_distortion = Cvar_Get( "r_underwater_distortion", "0.4", CVAR_ARCHIVE, "underwater distortion speed" ); @@ -879,6 +878,9 @@ void GL_InitCommands( void ) #ifdef VR vr_worldscale = Cvar_Get( "vr_worldscale", "40", CVAR_ARCHIVE, "Sets the world scale for stereo separation" ); + r_decals = Cvar_Get( "r_decals", "256", 0, "sets the maximum number of decals" ); +#else + r_decals = Cvar_Get( "r_decals", "4096", 0, "sets the maximum number of decals" ); #endif gl_picmip = Cvar_Get( "gl_picmip", "0", CVAR_GLCONFIG, "reduces resolution of textures by powers of 2" ); diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_game.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_game.c index 93e245c..f0ec411 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_game.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_game.c @@ -4253,7 +4253,8 @@ byte *GAME_EXPORT pfnSetFatPVS( const float *org ) VectorSubtract( svgame.pmove->player_mins[0], svgame.pmove->player_mins[1], offset ); VectorSubtract( org, offset, viewPos ); } - else VectorCopy( org, viewPos ); + else + VectorCopy( org, viewPos ); // build a new PVS frame Q_memset( bitvector, 0, fatbytes ); diff --git a/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_world.c b/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_world.c index e6f44e8..110e59d 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_world.c +++ b/Projects/Android/jni/src/Xash3D/xash3d/engine/server/sv_world.c @@ -820,9 +820,10 @@ qboolean SV_TestEntityPosition( edict_t *ent, edict_t *blocker ) if( ent->v.flags & (FL_CLIENT|FL_FAKECLIENT)) { // to avoid falling through tracktrain update client mins\maxs here - if( ent->v.flags & FL_DUCKING ) + if( ent->v.flags & FL_DUCKING ) SV_SetMinMaxSize( ent, svgame.pmove->player_mins[1], svgame.pmove->player_maxs[1] ); - else SV_SetMinMaxSize( ent, svgame.pmove->player_mins[0], svgame.pmove->player_maxs[0] ); + else + SV_SetMinMaxSize( ent, svgame.pmove->player_mins[0], svgame.pmove->player_maxs[0] ); } trace = SV_Move( ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, MOVE_NORMAL|FMOVE_SIMPLEBOX, ent ); diff --git a/Projects/Android/jni/src/Xash3D/xash3d/mainui/menus/Multiplayer.cpp b/Projects/Android/jni/src/Xash3D/xash3d/mainui/menus/Multiplayer.cpp index 6cbbc28..f9f43ec 100644 --- a/Projects/Android/jni/src/Xash3D/xash3d/mainui/menus/Multiplayer.cpp +++ b/Projects/Android/jni/src/Xash3D/xash3d/mainui/menus/Multiplayer.cpp @@ -110,9 +110,11 @@ void UI_MultiPlayer_Menu( void ) { uiMultiPlayer.AskPredictEnable(); } - else if( !UI::Names::CheckIsNameValid( EngFuncs::GetCvarString( "name" ) ) ) + //Just use whatever is in the config.cfg +/* else if( !UI::Names::CheckIsNameValid( EngFuncs::GetCvarString( "name" ) ) ) { UI_PlayerIntroduceDialog_Show( &uiMultiPlayer ); } +*/ } ADD_MENU( menu_multiplayer, UI_MultiPlayer_Precache, UI_MultiPlayer_Menu ); diff --git a/Projects/Android/jni/src/hlsdk-xash3d b/Projects/Android/jni/src/hlsdk-xash3d index 7d43e43..b9f3370 160000 --- a/Projects/Android/jni/src/hlsdk-xash3d +++ b/Projects/Android/jni/src/hlsdk-xash3d @@ -1 +1 @@ -Subproject commit 7d43e431bb739135318f9acdb331417dca3fee80 +Subproject commit b9f337071c2c78662f0227226b0a105fbe7cec6b diff --git a/assets/sprites/s_stealth.spr b/assets/sprites/s_stealth.spr new file mode 100644 index 0000000000000000000000000000000000000000..fd87c694339cff4a38ce65017efb4465f5d979f5 GIT binary patch literal 4926 zcma)81zZ$O6kqbtI|29jjyOcH16vFf2{ABH6c7`;5Csbb6Gg!8#s&pZuv<{k|Y){q*2hZ0O|S1~c`e*3_V9>Mt@f z^2Li6_3PL7@$or)_^?u`EGa43v}x10apSIEzuu-zo87y24;V0@diCl{mMjSm5BK!+ z{P*u)K|#T(Q>Wx|d9!BC)M|A|NXYQv!}smm_xkng`}gmsr>C!8y}E1HuJ-o!4h|00 zs#ODcjT$v-)~s2pR;}8#YuBk$r*7T4_3G7weH|Sg8#HLpuwlbSjT$v>+_*`TCQX|* z1+~qaH+OP!YSE%a%a$!$wQAM6b!%s5XE;yWwryQpT-vp3=j!U}=H}+^?(X5?(Y}3q zI9P`c9XfXG*r`*e&Ye4Zd3kl|(gn`Yty{P5-Mjbb(W7V2p5ETxy?XWP-Mcqjwojiv zef#$H_4W1h^Yi!j@7J$iKtMqM{{7*y0|yQqG-%M^!Gnhk84?&6ICSXHVZ(;O1xJh+ zF>>U{QKLqU9zA-@m@#9=js+`?A3r`QC}_fj3Bkd^6DLlbG-(o8BQ!L0^5n@=rc9YS zb?UTf)22_K9u^ihW5$e`GiQPgBO)SZ&6+iP_Ut)x=FFWtciy~t^XJb8M=V&dVBx}r zQBhHg7A=a7j*f|miH(h2ym&EKe(BPs%a$!$zI^$L6)RS*T)Ar1DzNaHHEY(cUAu1G zy7lYVZ`iP5(;GtadF$WZQH(m`;HwucJAD{Yu7Gt<(@rz;^X5J z5)$_A-3$IoOiWBlO4`4Fe{yp2fddB)9z2+ml9HO5dg#z02!C&akmoHzra^>pP ztJkhwgAlrLl&d$ln$<57u_39Ob)|)qP^78WDzI~gYpa1UNyZ7(k zLmUCa=g*(Ne*OCW z`}dzee@aVB|Ni|8VN7L0Hq7=gyD>kQgu~Lxf+S5;LZpo!sAI@F{m7hw?;qcNTYa59Wkhw9e;iUiZ2&a@*j%g zX>%Sg2d*ipRO{Q?m}^O^4S5Vl8LLbo^w>dFYg^Km{;K3;G=#Z|E$qk#Lp8~HpHe~) z6-d%n&&Fc`cs zUJ%EX*(kK^Nf_ZIQJ&IVO)V?H&g_wqxiTs$p!MmDtODKyHq~OW!%Bcb7Z#?lssNyh zBx!-gQcNx5vnq^K)F;?oAABhaCq&N=JJWb@kJ4BiZ@}(Xc7`k@nmBj3cd}`f-CQh9bj~w6f&n5W?Dq zUFh>g3ZuiCRAQ5#tA$c=3;OIxBTkgvQ7}t4LX|)kw~)r89SeshNld9n%z($BT*=5I zkdA|b5Lzm6i1G_BDc#4#GoL*Iu2u2|z=b}G)Xb8h3+^v(@O$B?s-kcib2S_a;fXrH zSgBEs$l^$`&Z%OuvLX&7;9-lmF~M|n$>h`M!I%Jy&P2Af`zQt4H=y4;3|`uO6kf}M zCiMG2gO_NU6qX*s^II@GYKpp4*JAN#_g8b_PFDsQD&J11f=;HzLHmy|`JZe6qQPB8uiZ^{* Date: Wed, 11 Sep 2019 22:22:17 +0100 Subject: [PATCH 9/9] Electrical Arcing renders the same in both eyes.. ..Thank-you Max Vollmer for the fix! --- Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c index f2b768d..084dec2 100644 --- a/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c +++ b/Projects/Android/jni/src/Lambda1VR/L1VR_SurfaceView.c @@ -864,12 +864,17 @@ static inline bool isHostAlive() host.state != HOST_CRASHED); } +void COM_SetRandomSeed( int lSeed ); + void RenderFrame( ovrRenderer * renderer, const ovrJava * java, const ovrTracking2 * tracking, ovrMobile * ovr ) { //if we are now shutting down, drop out here if (isHostAlive()) { + //Seed the random number generator the same for each eye to ensure electricity is drawn the same + int lSeed = rand(); + //Set everything up Host_BeginFrame(); @@ -894,6 +899,10 @@ void RenderFrame( ovrRenderer * renderer, const ovrJava * java, //Now do the drawing for this eye - Force the set as it is a "read only" cvar Cvar_Set2("vr_stereo_side", eye == 0 ? "0" : "1", true); + + //Sow the seed + COM_SetRandomSeed(lSeed); + Host_Frame(); }