mirror of
https://github.com/DrBeef/Doom3Quest.git
synced 2025-02-24 12:51:18 +00:00
15f78d843b
Bringing all the changes done (mostly by baggyg) in the OVRPassToVR branch bringing over the major FP related changes to master. Please refer to that branch for the individual changes that have all been brought over in this single commit. Co-Authored-By: Grant Bagwell <general@grantbagwell.co.uk>
1143 lines
47 KiB
C++
1143 lines
47 KiB
C++
//#pragma hdrstop
|
|
|
|
//#include"precompiled.h"
|
|
|
|
#include "../sys/platform.h"
|
|
#include "../framework/CVarSystem.h"
|
|
#include "GameBase.h"
|
|
#include "MultiplayerGame.h"
|
|
#include "Vr.h"
|
|
//#include "Voice.h"
|
|
#include "Game_local.h"
|
|
#include "physics/Clip.h"
|
|
#include "../sys/sys_public.h"
|
|
#include "../framework/Game.h"
|
|
#include "../framework/Common.h"
|
|
#include "../renderer/tr_local.h"
|
|
#include "../idlib/Lib.h"
|
|
#include "gamesys/SysCvar.h"
|
|
#include "../cm/CollisionModel.h"
|
|
#include "../../../../../../../../VrApi/Include/VrApi_Types.h"
|
|
|
|
|
|
//#include "libs\LibOVR\Include\OVR_CAPI_GL.h"
|
|
//#include "../renderer/Framebuffer.h"
|
|
|
|
#define RADIANS_TO_DEGREES(rad) ((float) rad * (float) (180.0 / idMath::PI))
|
|
|
|
// *** Oculus HMD Variables
|
|
idCVar vr_scale( "vr_scale", "1.0", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "World scale. Everything virtual is this times as big." );
|
|
idCVar vr_useFloorHeight( "vr_useFloorHeight", "0", CVAR_INTEGER | CVAR_ARCHIVE | CVAR_GAME, "0 = Custom eye height. 1 = Marine Eye Height. 2 = Normal View Height. 3 = make floor line up by Doomguy crouching. 4 = make everything line up by scaling world to your height.", 0, 4 );
|
|
idCVar vr_normalViewHeight( "vr_normalViewHeight", "73", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Height of player's view while standing, in real world inches." );
|
|
|
|
idCVar vr_weaponHand( "vr_weaponHand", "0", CVAR_INTEGER | CVAR_ARCHIVE | CVAR_GAME, "Which hand holds weapon.\n 0 = Right hand\n 1 = Left Hand\n", 0, 1 );
|
|
|
|
//flashlight cvars
|
|
idCVar vr_flashlightMode( "vr_flashlightMode", "3", CVAR_INTEGER | CVAR_ARCHIVE | CVAR_GAME, "Flashlight mount.\n0 = Body\n1 = Head\n2 = Gun\n3= Hand ( if motion controls available.)" );
|
|
idCVar vr_flashlightStrict( "vr_flashlightStrict", "0", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, "Flashlight location should be strictly enforced." ); // Carl
|
|
|
|
idCVar vr_flashlightBodyPosX( "vr_flashlightBodyPosX", "0", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Flashlight vertical offset for body mount." );
|
|
idCVar vr_flashlightBodyPosY( "vr_flashlightBodyPosY", "0", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Flashlight horizontal offset for body mount." );
|
|
idCVar vr_flashlightBodyPosZ( "vr_flashlightBodyPosZ", "0", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Flashlight forward offset for body mount." );
|
|
|
|
idCVar vr_flashlightHelmetPosX( "vr_flashlightHelmetPosX", "6", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Flashlight vertical offset for helmet mount." );
|
|
idCVar vr_flashlightHelmetPosY( "vr_flashlightHelmetPosY", "-6", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Flashlight horizontal offset for helmet mount." );
|
|
idCVar vr_flashlightHelmetPosZ( "vr_flashlightHelmetPosZ", "-20", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Flashlight forward offset for helmet mount." );
|
|
|
|
idCVar vr_forward_keyhole( "vr_forward_keyhole", "11.25", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Forward movement keyhole in deg. If view is inside body direction +/- this value, forward movement is in view direction, not body direction" );
|
|
|
|
idCVar vr_PDAfixLocation( "vr_PDAfixLocation", "0", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, "Fix PDA position in space in front of player\n instead of holding in hand." );
|
|
|
|
idCVar vr_weaponPivotOffsetForward( "vr_weaponPivotOffsetForward", "3", CVAR_GAME | CVAR_ARCHIVE | CVAR_FLOAT, "" );
|
|
idCVar vr_weaponPivotOffsetHorizontal( "vr_weaponPivotOffsetHorizontal", "0", CVAR_GAME | CVAR_ARCHIVE | CVAR_FLOAT, "" );
|
|
idCVar vr_weaponPivotOffsetVertical( "vr_weaponPivotOffsetVertical", "0", CVAR_GAME | CVAR_ARCHIVE | CVAR_FLOAT, "" );
|
|
idCVar vr_weaponPivotForearmLength( "vr_weaponPivotForearmLength", "16", CVAR_GAME | CVAR_ARCHIVE | CVAR_FLOAT, "" );
|
|
|
|
idCVar vr_guiScale( "vr_guiScale", "1", CVAR_FLOAT | CVAR_RENDERER | CVAR_ARCHIVE, "scale reduction factor for full screen menu/pda scale in VR", 0.0001f, 1.0f ); // Koz allow scaling of full screen guis/pda
|
|
idCVar vr_guiSeparation( "vr_guiSeparation", ".01", CVAR_FLOAT | CVAR_ARCHIVE, " Screen separation value for fullscreen guis." );
|
|
|
|
idCVar vr_guiMode( "vr_guiMode", "2", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Gui interaction mode.\n 0 = Weapon aim as cursor\n 1 = Look direction as cursor\n 2 = Touch screen\n" );
|
|
|
|
idCVar vr_hudScale( "vr_hudScale", "1.3", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Hud scale", 0.1f, 2.0f );
|
|
idCVar vr_hudPosHor( "vr_hudPosHor", "-8", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Hud Horizontal offset in inches" );
|
|
idCVar vr_hudPosVer( "vr_hudPosVer", "7", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Hud Vertical offset in inches" );
|
|
idCVar vr_hudPosDis( "vr_hudPosDis", "32", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Hud Distance from view in inches" );
|
|
idCVar vr_hudPosAngle( "vr_hudPosAngle", "30", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Hud View Angle" );
|
|
idCVar vr_hudPosLock( "vr_hudPosLock", "1", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Lock Hud to: 0 = Face, 1 = Body" );
|
|
idCVar vr_hudType( "vr_hudType", "1", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "VR Hud Type. 0 = Disable.\n1 = Full\n2=Look Activate", 0, 2 );
|
|
idCVar vr_hudRevealAngle( "vr_hudRevealAngle", "40", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "HMD pitch to reveal HUD in look activate mode." );
|
|
idCVar vr_hudTransparency( "vr_hudTransparency", "1", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, " Hud transparency. 0.0 = Invisible thru 1.0 = full", 0.0, 100.0 );
|
|
idCVar vr_hudOcclusion( "vr_hudOcclusion", "1", CVAR_BOOL | CVAR_GAME | CVAR_ARCHIVE, " Hud occlusion. 0 = Objects occlude HUD, 1 = No occlusion " );
|
|
idCVar vr_hudLowHealth( "vr_hudLowHealth", "20", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, " 0 = Disable, otherwise force hud if heath below this value." );
|
|
|
|
//GB Why is this never used?!
|
|
idCVar vr_wristStatMon( "vr_wristStatMon", "2", CVAR_INTEGER | CVAR_ARCHIVE, "Use wrist status monitor. 0 = Disable 1 = Right Wrist 2 = Left Wrist " );
|
|
|
|
// Koz display windows monitor name in the resolution selection menu, helpful to ID which is the rift if using extended mode
|
|
idCVar vr_listMonitorName( "vr_listMonitorName", "0", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, "List monitor name with resolution." );
|
|
|
|
idCVar vr_disableWeaponAnimation( "vr_disableWeaponAnimation", "1", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, "Disable weapon animations in VR. ( 1 = disabled )" );
|
|
idCVar vr_headKick( "vr_headKick", "0", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, "Damage can 'kick' the players view. 0 = Disabled in VR." );
|
|
idCVar vr_joystickMenuMapping( "vr_joystickMenuMapping", "1", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, " Use alternate joy mapping\n in menus/PDA.\n 0 = D3 Standard\n 1 = VR Mode.\n(Both joys can nav menus,\n joy r/l to change\nselect area in PDA." );
|
|
|
|
idCVar vr_deadzonePitch( "vr_deadzonePitch", "90", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Vertical Aim Deadzone", 0, 180 );
|
|
idCVar vr_deadzoneYaw( "vr_deadzoneYaw", "30", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Horizontal Aim Deadzone", 0, 180 );
|
|
idCVar vr_comfortDelta( "vr_comfortDelta", "10", CVAR_FLOAT | CVAR_GAME | CVAR_ARCHIVE, "Comfort Mode turning angle ", 0, 180 );
|
|
|
|
idCVar vr_headingBeamMode( "vr_headingBeamMode", "1", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "0 = disabled, 1 = solid, 2 = arrows, 3 = scrolling arrows" );
|
|
|
|
idCVar vr_weaponSight( "vr_weaponSight", "3", CVAR_INTEGER | CVAR_ARCHIVE, "Weapon Sight.\n 0 = Lasersight\n 1 = Red dot\n 2 = Circle dot\n 3 = Crosshair\n 4 = Beam + Dot\n" );
|
|
idCVar vr_weaponSightToSurface( "vr_weaponSightToSurface", "1", CVAR_INTEGER | CVAR_ARCHIVE, "Map sight to surface. 0 = Disabled 1 = Enabled\n" );
|
|
|
|
idCVar vr_motionWeaponPitchAdj( "vr_motionWeaponPitchAdj", "40", CVAR_FLOAT | CVAR_ARCHIVE, "Weapon controller pitch adjust" );
|
|
idCVar vr_motionFlashPitchAdj( "vr_motionFlashPitchAdj", "40", CVAR_FLOAT | CVAR_ARCHIVE, "Flashlight controller pitch adjust" );
|
|
|
|
idCVar vr_nodalX( "vr_nodalX", "-3", CVAR_FLOAT | CVAR_ARCHIVE, "Forward offset from eyes to neck" );
|
|
idCVar vr_nodalZ( "vr_nodalZ", "-6", CVAR_FLOAT | CVAR_ARCHIVE, "Vertical offset from neck to eye height" );
|
|
|
|
idCVar vr_vcx( "vr_vcx", "0", CVAR_FLOAT | CVAR_ARCHIVE, "Controller X offset to handle center" ); // these values work for steam
|
|
idCVar vr_vcy( "vr_vcy", "0", CVAR_FLOAT | CVAR_ARCHIVE, "Controller Y offset to handle center" );
|
|
idCVar vr_vcz( "vr_vcz", "0", CVAR_FLOAT | CVAR_ARCHIVE, "Controller Z offset to handle center" );
|
|
//idCVar vr_vcx( "vr_vcx", "-3.5", CVAR_FLOAT | CVAR_ARCHIVE, "Controller X offset to handle center" ); // these values work for steam
|
|
//idCVar vr_vcy( "vr_vcy", "0", CVAR_FLOAT | CVAR_ARCHIVE, "Controller Y offset to handle center" );
|
|
//idCVar vr_vcz( "vr_vcz", "-.5", CVAR_FLOAT | CVAR_ARCHIVE, "Controller Z offset to handle center" );
|
|
|
|
idCVar vr_mountx( "vr_mountx", "0", CVAR_FLOAT | CVAR_ARCHIVE, "If motion controller mounted on object, X offset from controller to object handle.\n (Eg controller mounted on Topshot)" );
|
|
idCVar vr_mounty( "vr_mounty", "0", CVAR_FLOAT | CVAR_ARCHIVE, "If motion controller mounted on object, Y offset from controller to object handle.\n (Eg controller mounted on Topshot)" );
|
|
idCVar vr_mountz( "vr_mountz", "0", CVAR_FLOAT | CVAR_ARCHIVE, "If motion controller mounted on object, Z offset from controller to object handle.\n (Eg controller mounted on Topshot)" );
|
|
|
|
idCVar vr_mountedWeaponController( "vr_mountedWeaponController", "0", CVAR_BOOL | CVAR_ARCHIVE, "If physical controller mounted on object (eg topshot), enable this to apply mounting offsets\n0=disabled 1 = enabled" );
|
|
|
|
idCVar vr_3dgui( "vr_3dgui", "1", CVAR_BOOL | CVAR_ARCHIVE, "3d effects for in game guis. 0 = disabled 1 = enabled\n" );
|
|
idCVar vr_shakeAmplitude( "vr_shakeAmplitude", "1.0", CVAR_FLOAT | CVAR_ARCHIVE, "Screen shake amplitude 0.0 = disabled to 1.0 = full\n", 0.0f, 1.0f );
|
|
|
|
idCVar vr_padDeadzone("vr_padDeadzone", ".25", CVAR_FLOAT | CVAR_ARCHIVE, "Deadzone for steam pads.\n 0.0 = no deadzone 1.0 = dead\n");
|
|
idCVar vr_jsDeadzone("vr_jsDeadzone", ".25", CVAR_FLOAT | CVAR_ARCHIVE, "Deadzone for steam joysticks.\n 0.0 = no deadzone 1.0 = dead\n");
|
|
idCVar vr_padToButtonThreshold( "vr_padToButtonThreshold", ".7", CVAR_FLOAT | CVAR_ARCHIVE, "Threshold value for pad contact\n to register as button press\n .1 high sensitiveity thru\n .99 low sensitivity" );
|
|
idCVar vr_knockBack( "vr_knockBack", "0", CVAR_BOOL | CVAR_ARCHIVE | CVAR_GAME, "Enable damage knockback in VR. 0 = Disabled, 1 = Enabled" );
|
|
idCVar vr_jumpBounce( "vr_jumpBounce", "0", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Enable view bounce after jumping. 0 = Disabled, 1 = Full", 0.0f, 1.0f ); // Carl
|
|
|
|
idCVar vr_stepSmooth( "vr_stepSmooth", "1", CVAR_FLOAT | CVAR_ARCHIVE | CVAR_GAME, "Enable smoothing when climbing stairs. 0 = Disabled, 1 = Full", 0.0f, 1.0f ); // Carl
|
|
idCVar vr_walkSpeedAdjust( "vr_walkSpeedAdjust", "-20", CVAR_FLOAT | CVAR_ARCHIVE, "Player walk speed adjustment in VR. (slow down default movement)" );
|
|
|
|
idCVar vr_wipPeriodMin( "vr_wipPeriodMin", "10.0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
idCVar vr_wipPeriodMax( "vr_wipPeriodMax", "2000.0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
|
|
idCVar vr_wipVelocityMin( "vr_wipVelocityMin", ".05", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
idCVar vr_wipVelocityMax( "vr_wipVelocityMax", "2.0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
|
|
idCVar vr_headbbox( "vr_headbbox", "10.0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
|
|
//idCVar vr_pdaPosX( "vr_pdaPosX", "20", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
//idCVar vr_pdaPosY( "vr_pdaPosY", "0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
//idCVar vr_pdaPosZ( "vr_pdaPosZ", "-11", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
|
|
idCVar vr_pdaPosX( "vr_pdaPosX", "-0.5", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
idCVar vr_pdaPosY( "vr_pdaPosY", "0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
idCVar vr_pdaPosZ( "vr_pdaPosZ", "3.0", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
|
|
idCVar vr_pdaPitch( "vr_pdaPitch", "30", CVAR_FLOAT | CVAR_ARCHIVE, "" );
|
|
idCVar vr_comfortRepeat( "vr_comfortRepeat", "100", CVAR_ARCHIVE | CVAR_INTEGER, "Delay in MS between repeating comfort snap turns." );
|
|
idCVar vr_movePoint( "vr_movePoint", "1", CVAR_INTEGER | CVAR_ARCHIVE, "0: Standard Stick Move, 1: Off Hand = Forward, 2: Look = forward, 3: Weapon Hand = Forward, 4: Left Hand = Forward, 5: Right Hand = Forward", 0, 5 );
|
|
idCVar vr_moveClick( "vr_moveClick", "0", CVAR_INTEGER | CVAR_ARCHIVE, " 0 = Normal movement.\n 1 = Click and hold to walk, run button to run.\n 2 = Click to start walking, then touch only. Run btn to run.\n 3 = Click to start walking, hold click to run.\n 4 = Click to start walking, then click toggles run\n" );
|
|
idCVar vr_playerBodyMode( "vr_playerBodyMode", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Player body mode:\n0 = Display full body\n1 = Just Hands \n2 = Weapons only\n" );
|
|
|
|
//GB This is active in FP, and seems to only move body when pushing forward!
|
|
idCVar vr_bodyToMove( "vr_bodyToMove", "1", CVAR_BOOL | CVAR_GAME | CVAR_ARCHIVE, "Lock body orientaion to movement direction." );
|
|
|
|
idCVar vr_moveThirdPerson( "vr_moveThirdPerson", "1", CVAR_BOOL | CVAR_GAME | CVAR_ARCHIVE, "Artifical movement will user 3rd person perspective." );
|
|
|
|
idCVar vr_crouchMode( "vr_crouchMode", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Crouch Mode:\n 0 = Full motion crouch (In game matches real life)\n 1 = Crouch anim triggered by smaller movement." );
|
|
idCVar vr_crouchTriggerDist( "vr_crouchTriggerDist", "7", CVAR_FLOAT | CVAR_ARCHIVE, " Distance ( in real-world inches ) player must crouch in real life to toggle crouch\n" );
|
|
idCVar vr_crouchHideBody( "vr_crouchHideBody", "0", CVAR_FLOAT | CVAR_ARCHIVE, "Hide body ( if displayed ) when crouching. 0 = Dont hide, 1 = hide." );
|
|
idCVar vr_frameCheck( "vr_frameCheck", "0", CVAR_INTEGER | CVAR_ARCHIVE, "0 = bypass frame check" );
|
|
|
|
idCVar vr_teleportSkipHandrails( "vr_teleportSkipHandrails", "0", CVAR_INTEGER | CVAR_ARCHIVE, "Teleport aim ingnores handrails. 1 = true" );
|
|
idCVar vr_teleportShowAimAssist( "vr_teleportShowAimAssist", "0", CVAR_INTEGER | CVAR_ARCHIVE, "Move telepad target to reflect aim assist. 1 = true" );
|
|
idCVar vr_teleportButtonMode( "vr_teleportButtonMode", "0", CVAR_BOOL | CVAR_ARCHIVE, "0 = Press aim, release teleport.\n1 = 1st press aim, 2nd press teleport" );
|
|
idCVar vr_teleportHint( "vr_teleportHint", "0", CVAR_BOOL | CVAR_ARCHIVE, "" ); // Koz blech hack - used for now to keep track if the game has issued the player the hint about ducking when the teleport target is red.
|
|
|
|
//GB See if we can get this from the API
|
|
idCVar vr_useHandPoses( "vr_useHandPoses", "0", CVAR_BOOL | CVAR_ARCHIVE, "If using oculus touch, enable finger poses when hands are empty or in guis" );
|
|
// Koz end
|
|
// Carl
|
|
idCVar vr_teleport( "vr_teleport", "2", CVAR_INTEGER | CVAR_ARCHIVE, "Player can teleport at will. 0 = disabled, 1 = gun sight, 2 = right hand, 3 = left hand, 4 = head", 0, 4 );
|
|
idCVar vr_teleportMode("vr_teleportMode", "0", CVAR_INTEGER | CVAR_ARCHIVE, "Teleport Mode. 0 = Blink (default), 1 = Doom VFR style (slow time and warp speed), 2 = Doom VFR style + jet strafe)", 0, 2);
|
|
idCVar vr_teleportMaxTravel( "vr_teleportMaxTravel", "950", CVAR_INTEGER | CVAR_ARCHIVE, "Maximum teleport path length/complexity/time. About 250 or 500 are good choices, but must be >= about 950 to use tightrope in MC Underground.", 150, 5000 );
|
|
idCVar vr_teleportThroughDoors( "vr_teleportThroughDoors", "0", CVAR_BOOL | CVAR_ARCHIVE, "Player can teleport somewhere visible even if the path to get there takes them through closed (but not locked) doors." );
|
|
|
|
//GB Check these
|
|
idCVar vr_motionSickness( "vr_motionSickness", "0", CVAR_INTEGER | CVAR_ARCHIVE, "Motion sickness prevention aids. 0 = None, 1 = Chaperone, 2 = Reduce FOV, 3 = Black Screen, 4 = Black & Chaperone, 5 = Reduce FOV & Chaperone, 6 = Slow Mo, 7 = Slow Mo & Chaperone, 8 = Slow Mo & Reduce FOV, 9 = Slow Mo, Chaperone, Reduce FOV, 10 = Third Person, 11 = Particles, 12 = Particles & Chaperone", 0, 12 );
|
|
|
|
idCVar vr_strobeTime( "vr_strobeTime", "500", CVAR_INTEGER | CVAR_ARCHIVE, "Time in ms between flashes when blacking screen. 0 = no strobe" );
|
|
idCVar vr_chaperone( "vr_chaperone", "2", CVAR_INTEGER | CVAR_ARCHIVE, "Chaperone/Guardian mode. 0 = when near, 1 = when throwing, 2 = when melee, 3 = when dodging, 4 = always", 0, 4 );
|
|
idCVar vr_chaperoneColor( "vr_chaperoneColor", "0", CVAR_INTEGER | CVAR_ARCHIVE, "Chaperone colour. 0 = default, 1 = black, 2 = grey, 3 = white, 4 = red, 5 = green, 6 = blue, 7 = yellow, 8 = cyan, 9 = magenta, 10 = purple", 0, 10 );
|
|
|
|
idCVar vr_handSwapsAnalogs( "vr_handSwapsAnalogs", "0", CVAR_BOOL | CVAR_ARCHIVE, "Should swapping the weapon hand affect analog controls (stick or touchpad) or just buttons/triggers? 0 = only swap buttons, 1 = swap all controls" );
|
|
idCVar vr_autoSwitchControllers( "vr_autoSwitchControllers", "1", CVAR_BOOL | CVAR_ARCHIVE, "Automatically switch to/from gamepad mode when using gamepad/motion controller. Should be true unless you're trying to use both together, or you get false detections. 0 = no, 1 = yes." );
|
|
|
|
//GB Remember that thing about cuts - cant find that now at all (Show camera at cut position rather than 1st person)
|
|
idCVar vr_cinematics("vr_cinematics", "0", CVAR_INTEGER | CVAR_ARCHIVE, "Cinematic type. 0 = Immersive, 1 = Cropped, 2 = Projected");
|
|
|
|
idCVar vr_instantAccel( "vr_instantAccel", "1", CVAR_BOOL | CVAR_ARCHIVE, "Instant Movement Acceleration. 0 = Disabled 1 = Enabled" );
|
|
idCVar vr_shotgunChoke( "vr_shotgunChoke", "60", CVAR_FLOAT | CVAR_ARCHIVE, "% To choke shotgun. 0 = None, 100 = Full Choke\n" );
|
|
idCVar vr_headshotMultiplier( "vr_headshotMultiplier", "2.5", CVAR_FLOAT | CVAR_ARCHIVE, "Damage multiplier for headshots when using Fists,Pistol,Shotgun,Chaingun or Plasmagun.", 1, 5 );
|
|
|
|
// Carl
|
|
idCVar vr_weaponCycleMode( "vr_weaponCycleMode", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "When cycling through weapons\n0 = skip holstered weapons, 1 = include holstered weapons, 2 = flashlight but not holstered, 3 = holstered+flashlight, 4 = holstered+flashlight+pda" );
|
|
idCVar vr_gripMode( "vr_gripMode", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "How the grip button works\n0 = context sensitive toggle, 1 = context sensitive toggle no surface, 2 = toggle for weapons/items hold for physics objects, 3 = toggle for weapons hold for physics/items, 4 = always toggle (can drop), 5 = Dead and Burried, 6 = hold to hold, 7 = hold to hold squeeze for action" );
|
|
idCVar vr_doubleClickGrip( "vr_doubleClickGrip", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Double-clicking grip 0 = does nothing, 1 = drops or does action (depending on grip mode). Not implemented!" );
|
|
idCVar vr_pickUpMode( "vr_pickUpMode", "1", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "How to pick up/collect/use items and powerups 0 = walk over, 1 = walk/touch, 2 = touch, 3 = manual grip, 4 = put in body, 5 = put in properly, 6 = hold and press trigger" );
|
|
idCVar vr_reloadMode( "vr_reloadMode", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "How to reload your weapon\n0 = button, 1 = with other hand, 2 = with other empty hand, 3 = Dead and Burried" );
|
|
idCVar vr_mustEmptyHands( "vr_mustEmptyHands", "0", CVAR_BOOL | CVAR_GAME | CVAR_ARCHIVE, "Do you need to have an empty hand to interact with things?\n0 = no, it works automatically; 1 = yes, your hand must be empty" );
|
|
idCVar vr_contextSensitive( "vr_contextSensitive", "1", CVAR_BOOL | CVAR_GAME | CVAR_ARCHIVE, "Are buttons context sensitive?\n0 = no just map the buttons in the binding window, 1 = yes, context sensitive buttons (default)" );
|
|
idCVar vr_dualWield( "vr_dualWield", "2", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Can you use two weapons at once?\n0 = not even fists, 1 = nothing, 2 = only flashlight, 3 = only grenades (VFR), 4 = only grenades/flashlight, 5 = only pistols, 6 = only pistols/flashlight, 7 = only pistols/grenades/flashlight, 8 = yes" );
|
|
idCVar vr_voiceMicLocation( "vr_voiceMicLocation", "0", CVAR_INTEGER | CVAR_GAME | CVAR_ARCHIVE, "Where is the virtual VR microphone you need to hold up to your mouth to speak into for voice commands to work?\n0 = helmet (always works), 1 = StatWatch, 2 = left hand, 3 = right hand, 4 = either hand, 5 = push-to-talk hand, 6 = weapon, 7 = flashlight, 8 = PDA" );
|
|
idCVar vr_debugHands( "vr_debugHands", "0", CVAR_BOOL | CVAR_GAME, "Enable hand/weapon/dual wielding debugging" );
|
|
idCVar vr_rumbleChainsaw( "vr_rumbleChainsaw", "1", CVAR_BOOL | CVAR_GAME | CVAR_ARCHIVE, "Enable weapon (currently chainsaw only) constant haptic feedback in VR. Not recommended for wireless VR controllers." );
|
|
|
|
//===================================================================
|
|
|
|
int fboWidth;
|
|
int fboHeight;
|
|
|
|
iVr vrCom;
|
|
iVr* commonVr = &vrCom;
|
|
|
|
//iVoice _voice; //avoid nameclash with timidity
|
|
//iVoice* commonVoice = &_voice;
|
|
|
|
void SwapBinding(int Old, int New)
|
|
{
|
|
/*idStr s = idKeyInput::GetBinding(New);
|
|
idKeyInput::SetBinding(New, idKeyInput::GetBinding(Old));
|
|
idKeyInput::SetBinding(Old, s.c_str());*/
|
|
}
|
|
|
|
|
|
void SwapWeaponHand()
|
|
{
|
|
vr_weaponHand.SetInteger(1 - vr_weaponHand.GetInteger());
|
|
// swap teleport hand
|
|
if (vr_teleport.GetInteger() == 2)
|
|
vr_teleport.SetInteger( 3 );
|
|
else if (vr_teleport.GetInteger() == 3)
|
|
vr_teleport.SetInteger( 2 );
|
|
// swap motion controller bindings to other hand
|
|
//GBCHANGE
|
|
/*for (int k = K_JOY17; k <= K_JOY18; k++)
|
|
SwapBinding(k, k + 7);
|
|
// JOY19 is the Touch menu button, which only exists on the left hand
|
|
for (int k = K_JOY20; k <= K_JOY23; k++)
|
|
SwapBinding(k, k + 7);
|
|
for (int k = K_JOY31; k <= K_JOY48; k++)
|
|
SwapBinding(k, k + 18);
|
|
SwapBinding(K_L_TOUCHTRIG, K_R_TOUCHTRIG);
|
|
SwapBinding(K_L_STEAMVRTRIG, K_R_STEAMVRTRIG);*/
|
|
/*
|
|
if (vr_handSwapsAnalogs.GetBool())
|
|
{
|
|
for (int k = K_TOUCH_LEFT_STICK_UP; k <= K_TOUCH_LEFT_STICK_RIGHT; k++)
|
|
SwapBinding(k, k + 4);
|
|
for (int k = K_STEAMVR_LEFT_PAD_UP; k <= K_STEAMVR_LEFT_PAD_RIGHT; k++)
|
|
SwapBinding(k, k + 4);
|
|
for (int k = K_STEAMVR_LEFT_JS_UP; k <= K_STEAMVR_LEFT_JS_RIGHT; k++)
|
|
SwapBinding(k, k + 4);
|
|
}*/
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::iVr()
|
|
==============
|
|
*/
|
|
iVr::iVr()
|
|
{
|
|
lastComfortTime = 0;
|
|
lastFrame = -1;
|
|
initialResetPerformed = false;
|
|
hasHMD = true;
|
|
hasOculusRift = true;
|
|
VR_GAME_PAUSED = false;
|
|
PDAforcetoggle = false;
|
|
PDAforced = false;
|
|
PDArising = false;
|
|
gameSavingLoading = false;
|
|
showingIntroVideo = true;
|
|
forceLeftStick = true; // start the PDA in the left menu.
|
|
pdaToggleTime = 0;
|
|
lastSaveTime = 0;
|
|
wasSaved = false;
|
|
wasLoaded = false;
|
|
shouldRecenter = false;
|
|
|
|
PDAclipModelSet = false;
|
|
useFBO = false;
|
|
|
|
VR_USE_MOTION_CONTROLS = true;
|
|
motionControlType = MOTION_OCULUS;
|
|
|
|
scanningPDA = false;
|
|
|
|
vrIsBackgroundSaving = false;
|
|
|
|
VRScreenSeparation = 0.0f;
|
|
|
|
officialIPD = 64.0f;
|
|
officialHeight = 72.0f;
|
|
|
|
manualIPD = 64.0f;
|
|
manualHeight = 72.0f;
|
|
|
|
hmdPositionTracked = false;
|
|
|
|
vrFrameNumber = 0;
|
|
lastPostFrame = 0;
|
|
|
|
|
|
lastViewOrigin = vec3_zero;
|
|
lastViewAxis = mat3_identity;
|
|
|
|
lastCenterEyeOrigin = vec3_zero;
|
|
lastCenterEyeAxis = mat3_identity;
|
|
|
|
bodyYawOffset = 0.0f;
|
|
lastHMDYaw = 0.0f;
|
|
lastHMDPitch = 0.0f;
|
|
lastHMDRoll = 0.0f;
|
|
lastHMDViewOrigin = vec3_zero;
|
|
lastHMDViewAxis = mat3_identity;
|
|
headHeightDiff = 0;
|
|
|
|
motionMoveDelta = vec3_zero;
|
|
motionMoveVelocity = vec3_zero;
|
|
leanOffset = vec3_zero;
|
|
leanBlankOffset = vec3_zero;
|
|
leanBlankOffsetLengthSqr = 0.0f;
|
|
leanBlank = false;
|
|
isLeaning = false;
|
|
|
|
thirdPersonMovement = false;
|
|
thirdPersonDelta = 0.0f;
|
|
thirdPersonHudAxis = mat3_identity;
|
|
thirdPersonHudPos = vec3_zero;
|
|
|
|
chestDefaultDefined = false;
|
|
|
|
currentFlashlightPosition = FLASHLIGHT_BODY;
|
|
|
|
handInGui = false;
|
|
|
|
handRoll[0] = 0.0f;
|
|
handRoll[1] = 0.0f;
|
|
|
|
fingerPose[0] = 0;
|
|
fingerPose[1] = 0;
|
|
|
|
angles[3] = { 0.0f };
|
|
|
|
swfRenderMode = RENDERING_NORMAL;
|
|
|
|
isWalking = false;
|
|
|
|
forceRun = false;
|
|
|
|
hmdBodyTranslation = vec3_zero;
|
|
|
|
VR_AAmode = 0;
|
|
|
|
independentWeaponYaw = 0;
|
|
independentWeaponPitch = 0;
|
|
|
|
playerDead = false;
|
|
|
|
hmdWidth = 0;
|
|
hmdHeight = 0;
|
|
|
|
primaryFBOWidth = 0;
|
|
primaryFBOHeight = 0;
|
|
hmdHz = 90;
|
|
|
|
hmdFovX = 0.0f;
|
|
hmdFovY = 0.0f;
|
|
|
|
hmdPixelScale = 1.0f;
|
|
hmdAspect = 1.0f;
|
|
|
|
|
|
/*
|
|
hmdSession = nullptr;
|
|
ovrLuid.Reserved[0] = { 0 };
|
|
|
|
oculusSwapChain[0] = nullptr;
|
|
oculusSwapChain[1] = nullptr;
|
|
oculusFboId = 0;
|
|
ocululsDepthTexID = 0;
|
|
oculusMirrorFboId = 0;
|
|
oculusMirrorTexture = 0;
|
|
mirrorTexId = 0;
|
|
mirrorW = 0;
|
|
mirrorH = 0;
|
|
*/
|
|
|
|
|
|
hmdEyeImage[0] = 0;
|
|
hmdEyeImage[1] = 0;
|
|
hmdCurrentRender[0] = 0;
|
|
hmdCurrentRender[1] = 0;
|
|
|
|
// wip stuff
|
|
// wip stuff
|
|
wipNumSteps = 0;
|
|
wipStepState = 0;
|
|
wipLastPeriod = 0;
|
|
wipCurrentDelta = 0.0f;
|
|
wipCurrentVelocity = 0.0f;
|
|
|
|
wipTotalDelta = 0.0f;
|
|
wipLastAcces = 0.0f;
|
|
wipAvgPeriod = 0.0f;
|
|
wipTotalDeltaAvg = 0.0f;
|
|
|
|
hmdFrameTime = 0;
|
|
|
|
lastRead = 0;
|
|
currentRead = 0;
|
|
updateScreen = false;
|
|
|
|
bodyMoveAng = 0.0f;
|
|
teleportButtonCount = 0;
|
|
|
|
|
|
currentFlashlightMode = vr_flashlightMode.GetInteger();
|
|
renderingSplash = true;
|
|
|
|
currentBindingDisplay = "";
|
|
|
|
cinematicStartViewYaw = 0.0f;
|
|
cinematicStartPosition = vec3_zero;
|
|
|
|
didTeleport = false;
|
|
teleportDir = 0.0f;
|
|
|
|
currentHandWorldPosition[0] = vec3_zero;
|
|
currentHandWorldPosition[1] = vec3_zero;
|
|
|
|
|
|
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::HMDInit
|
|
==============
|
|
*/
|
|
|
|
void iVr::HMDInit( void )
|
|
{
|
|
hasHMD = false;
|
|
game->isVR = false;
|
|
common->Printf( "\n\n HMD Initialized\n" );
|
|
hasHMD = true;
|
|
game->isVR = true;
|
|
common->Printf( "VR_USE_MOTION_CONTROLS Final = %d\n", VR_USE_MOTION_CONTROLS );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
==============
|
|
iVr::HMDShutdown
|
|
==============
|
|
*/
|
|
|
|
void iVr::HMDShutdown( void )
|
|
{
|
|
#ifdef USE_OVR
|
|
if ( hasOculusRift )
|
|
{
|
|
ovr_DestroyTextureSwapChain( hmdSession, oculusSwapChain[0] );
|
|
ovr_DestroyTextureSwapChain( hmdSession, oculusSwapChain[1] );
|
|
|
|
ovr_Destroy( hmdSession );
|
|
ovr_Shutdown();
|
|
hmdSession = NULL;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
//vr::VR_Shutdown();
|
|
}
|
|
//m_pHMD = NULL;
|
|
return;
|
|
}
|
|
|
|
void iVr::HMDGetOrientation( idAngles &hmdAngles, idVec3 &headPositionDelta, idVec3 &bodyPositionDelta, idVec3 &absolutePosition, bool resetTrackingOffset )
|
|
{
|
|
static double time = 0.0;
|
|
static int currentlyTracked;
|
|
static int lastFrameReturned = -1;
|
|
static uint lastIdFrame = -1;
|
|
static float lastRoll = 0.0f;
|
|
static float lastPitch = 0.0f;
|
|
static float lastYaw = 0.0f;
|
|
static idVec3 lastHmdPosition = vec3_zero;
|
|
|
|
static idVec3 hmdPosition;
|
|
static idVec3 lastHmdPos2 = vec3_zero;
|
|
static idMat3 hmdAxis = mat3_identity;
|
|
|
|
static bool neckInitialized = false;
|
|
static idVec3 initialNeckPosition = vec3_zero;
|
|
static idVec3 currentNeckPosition = vec3_zero;
|
|
static idVec3 lastNeckPosition = vec3_zero;
|
|
|
|
static idVec3 currentChestPosition = vec3_zero;
|
|
static idVec3 lastChestPosition = vec3_zero;
|
|
|
|
static float chestLength = 0;
|
|
static bool chestInitialized = false;
|
|
|
|
idVec3 neckToChestVec = vec3_zero;
|
|
idMat3 neckToChestMat = mat3_identity;
|
|
idAngles neckToChestAng = ang_zero;
|
|
|
|
static idVec3 lastHeadPositionDelta = vec3_zero;
|
|
static idVec3 lastBodyPositionDelta = vec3_zero;
|
|
static idVec3 lastAbsolutePosition = vec3_zero;
|
|
|
|
//static vr::TrackedDevicePose_t lastTrackedPoseOpenVR = { 0.0f };
|
|
|
|
|
|
if ( !pVRClientInfo )
|
|
{
|
|
hmdAngles.roll = 0.0f;
|
|
hmdAngles.pitch = 0.0f;
|
|
hmdAngles.yaw = 0.0f;
|
|
headPositionDelta = vec3_zero;
|
|
bodyPositionDelta = vec3_zero;
|
|
absolutePosition = vec3_zero;
|
|
return;
|
|
}
|
|
|
|
lastBodyYawOffset = bodyYawOffset;
|
|
poseLastHmdAngles = poseHmdAngles;
|
|
poseLastHmdHeadPositionDelta = poseHmdHeadPositionDelta;
|
|
poseLastHmdBodyPositionDelta = poseHmdBodyPositionDelta;
|
|
poseLastHmdAbsolutePosition = poseHmdAbsolutePosition;
|
|
|
|
|
|
if ( vr_frameCheck.GetInteger() == 1 && idLib::frameNumber == lastFrame )//&& !commonVr->renderingSplash )
|
|
{
|
|
//make sure to return the same values for this frame.
|
|
hmdAngles.roll = lastRoll;
|
|
hmdAngles.pitch = lastPitch;
|
|
hmdAngles.yaw = lastYaw;
|
|
headPositionDelta = lastHeadPositionDelta;
|
|
bodyPositionDelta = lastBodyPositionDelta;
|
|
|
|
if ( resetTrackingOffset == true )
|
|
{
|
|
|
|
trackingOriginOffset = lastHmdPosition;
|
|
trackingOriginHeight = trackingOriginOffset.z;
|
|
if (vr_useFloorHeight.GetInteger() == 0)
|
|
trackingOriginOffset.z += pm_normalviewheight.GetFloat() + 5 + CM_CLIP_EPSILON - vr_normalViewHeight.GetFloat() / vr_scale.GetFloat();
|
|
else if (vr_useFloorHeight.GetInteger() == 2)
|
|
trackingOriginOffset.z += 5;
|
|
else if (vr_useFloorHeight.GetInteger() == 3)
|
|
trackingOriginOffset.z = pm_normalviewheight.GetFloat() + 5 + CM_CLIP_EPSILON;
|
|
else if (vr_useFloorHeight.GetInteger() == 4)
|
|
{
|
|
float oldScale = vr_scale.GetFloat();
|
|
float h = trackingOriginHeight * oldScale;
|
|
float newScale = h / 73.0f;
|
|
trackingOriginHeight *= oldScale / newScale;
|
|
trackingOriginOffset *= oldScale / newScale;
|
|
vr_scale.SetFloat( newScale );
|
|
}
|
|
common->Printf( "Resetting tracking yaw offset.\n Yaw = %f old offset = %f ", hmdAngles.yaw, trackingOriginYawOffset );
|
|
trackingOriginYawOffset = hmdAngles.yaw;
|
|
common->Printf( "New Tracking yaw offset %f\n", hmdAngles.yaw, trackingOriginYawOffset );
|
|
neckInitialized = false;
|
|
|
|
cinematicStartViewYaw = trackingOriginYawOffset;
|
|
|
|
}
|
|
common->Printf( "HMDGetOrientation FramCheck Bail == idLib:: framenumber lf %d ilfn %d rendersplash = %d\n", lastFrame, idLib::frameNumber, commonVr->renderingSplash );
|
|
return;
|
|
}
|
|
|
|
lastFrame = idLib::frameNumber;
|
|
|
|
|
|
static idPosef translationPose;
|
|
static idPosef orientationPose;
|
|
static idPosef cameraPose;
|
|
static idPosef lastTrackedPoseOculus;
|
|
lastTrackedPoseOculus.Position = idVec3(0.0,0.0,0.0);
|
|
lastTrackedPoseOculus.Orientation = idQuat(0.0,0.0,0.0,0.0);
|
|
|
|
if ( hasOculusRift )
|
|
{
|
|
//hmdFrameTime = ovr_GetPredictedDisplayTime( hmdSession, lastFrame );
|
|
//common->Printf( "HMDGetOrientation lastframe idLib::framenumber = %d\n", lastFrame );
|
|
//time = hmdFrameTime;
|
|
|
|
//hmdTrackingState = ovr_GetTrackingState( hmdSession, time, false );
|
|
|
|
//currentlyTracked = hmdTrackingState.StatusFlags & ( ovrStatus_PositionTracked );
|
|
//GBCHANGE
|
|
currentlyTracked = true;
|
|
|
|
if (currentlyTracked)
|
|
{
|
|
idVec3 _hmdPosition = idVec3(pVRClientInfo->hmdposition[0],pVRClientInfo->hmdposition[1],pVRClientInfo->hmdposition[2]);
|
|
//static idVec3 _hmdTranslation = idVec3(pVRClientInfo->hmdtranslation[0],pVRClientInfo->hmdtranslation[1],pVRClientInfo->hmdtranslation[2]);
|
|
idQuat _hmdOrientation = idQuat(pVRClientInfo->hmdorientation_quat[0],pVRClientInfo->hmdorientation_quat[1],pVRClientInfo->hmdorientation_quat[2],pVRClientInfo->hmdorientation_quat[3]);
|
|
translationPose.Position = _hmdPosition;
|
|
translationPose.Orientation = _hmdOrientation;
|
|
//translationPose.Translation = _hmdTranslation;
|
|
//translationPose = hmdTrackingState.HeadPose.ThePose;
|
|
lastTrackedPoseOculus = translationPose;
|
|
}
|
|
else
|
|
{
|
|
translationPose = lastTrackedPoseOculus;
|
|
}
|
|
|
|
//GB Get all hand poses
|
|
idQuat weaponAdjust = idAngles(0, 0, -20).ToQuat();
|
|
idQuat flashlightAdjust = idAngles(0, 0, -35).ToQuat();
|
|
idVec3 _lhandPosition = idVec3(pVRClientInfo->lhandposition[0],pVRClientInfo->lhandposition[1],pVRClientInfo->lhandposition[2]);
|
|
idQuat _lhandOrientation = idQuat(pVRClientInfo->lhand_orientation_quat[0],pVRClientInfo->lhand_orientation_quat[1],pVRClientInfo->lhand_orientation_quat[2],pVRClientInfo->lhand_orientation_quat[3]) *
|
|
(pVRClientInfo->right_handed ? flashlightAdjust : weaponAdjust);
|
|
idVec3 _rhandPosition = idVec3(pVRClientInfo->rhandposition[0],pVRClientInfo->rhandposition[1],pVRClientInfo->rhandposition[2]);
|
|
idQuat _rhandOrientation = idQuat(pVRClientInfo->rhand_orientation_quat[0],pVRClientInfo->rhand_orientation_quat[1],pVRClientInfo->rhand_orientation_quat[2],pVRClientInfo->rhand_orientation_quat[3]) *
|
|
(!pVRClientInfo->right_handed ? flashlightAdjust : weaponAdjust);
|
|
|
|
|
|
|
|
commonVr->handPose[1].Orientation = _lhandOrientation;
|
|
commonVr->handPose[1].Position = _lhandPosition;
|
|
commonVr->handPose[0].Orientation = _rhandOrientation;
|
|
commonVr->handPose[0].Position = _rhandPosition;
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
MotionControlGetHand(i, poseHandPos[i], poseHandRotationQuat[i]);
|
|
poseHandRotationMat3[i] = poseHandRotationQuat[i].ToMat3();
|
|
poseHandRotationAngles[i] = poseHandRotationQuat[i].ToAngles();
|
|
}
|
|
}
|
|
|
|
if (hasOculusRift)
|
|
{
|
|
hmdPosition.x = -translationPose.Position.z * (100.0f / 2.54f) / vr_scale.GetFloat(); // Koz convert position (in meters) to inch (1 id unit = 1 inch).
|
|
hmdPosition.y = -translationPose.Position.x * (100.0f / 2.54f) / vr_scale.GetFloat();
|
|
hmdPosition.z = translationPose.Position.y * (100.0f / 2.54f) / vr_scale.GetFloat();
|
|
}
|
|
|
|
lastHmdPosition = hmdPosition;
|
|
|
|
static idQuat poseRot;// = idQuat_zero;
|
|
static idAngles poseAngles = ang_zero;
|
|
|
|
if (hasOculusRift)
|
|
{
|
|
static idPosef orientationPose;
|
|
orientationPose.Orientation = idQuat(pVRClientInfo->hmdorientation_quat[0],pVRClientInfo->hmdorientation_quat[1],pVRClientInfo->hmdorientation_quat[2],pVRClientInfo->hmdorientation_quat[3]);
|
|
|
|
poseRot.x = orientationPose.Orientation.z; // x;
|
|
poseRot.y = orientationPose.Orientation.x; // y;
|
|
poseRot.z = -orientationPose.Orientation.y; // z;
|
|
poseRot.w = orientationPose.Orientation.w;
|
|
}
|
|
|
|
poseAngles = poseRot.ToAngles();
|
|
|
|
hmdAngles.yaw = poseAngles.yaw;
|
|
hmdAngles.roll = poseAngles.roll;
|
|
hmdAngles.pitch = poseAngles.pitch;
|
|
|
|
lastRoll = hmdAngles.roll;
|
|
lastPitch = hmdAngles.pitch;
|
|
lastYaw = hmdAngles.yaw;
|
|
|
|
hmdPosition += hmdForwardOffset * poseAngles.ToMat3()[0];
|
|
|
|
if ( resetTrackingOffset == true )
|
|
{
|
|
|
|
trackingOriginOffset = lastHmdPosition;
|
|
trackingOriginHeight = trackingOriginOffset.z;
|
|
if (vr_useFloorHeight.GetInteger() == 0)
|
|
trackingOriginOffset.z += pm_normalviewheight.GetFloat() + 5 + CM_CLIP_EPSILON - vr_normalViewHeight.GetFloat() / vr_scale.GetFloat();
|
|
else if (vr_useFloorHeight.GetInteger() == 2)
|
|
trackingOriginOffset.z += 5;
|
|
else if (vr_useFloorHeight.GetInteger() == 3)
|
|
trackingOriginOffset.z = pm_normalviewheight.GetFloat() + 5 + CM_CLIP_EPSILON;
|
|
else if (vr_useFloorHeight.GetInteger() == 4)
|
|
{
|
|
float oldScale = vr_scale.GetFloat();
|
|
float h = trackingOriginHeight * oldScale;
|
|
float newScale = h / (pm_normalviewheight.GetFloat() + 5 + CM_CLIP_EPSILON);
|
|
trackingOriginHeight *= oldScale / newScale;
|
|
trackingOriginOffset *= oldScale / newScale;
|
|
vr_scale.SetFloat(newScale);
|
|
}
|
|
common->Printf("Resetting tracking yaw offset.\n Yaw = %f old offset = %f ", hmdAngles.yaw, trackingOriginYawOffset);
|
|
trackingOriginYawOffset = hmdAngles.yaw;
|
|
common->Printf( "New Tracking yaw offset %f\n", hmdAngles.yaw, trackingOriginYawOffset );
|
|
neckInitialized = false;
|
|
cinematicStartViewYaw = trackingOriginYawOffset;
|
|
initialResetPerformed = true;
|
|
return;
|
|
}
|
|
|
|
hmdPosition -= trackingOriginOffset;
|
|
|
|
hmdPosition *= idAngles( 0.0f, -trackingOriginYawOffset, 0.0f ).ToMat3();
|
|
|
|
absolutePosition = hmdPosition;
|
|
|
|
hmdAngles.yaw -= trackingOriginYawOffset;
|
|
hmdAngles.Normalize360();
|
|
|
|
// common->Printf( "Hmdangles yaw = %f pitch = %f roll = %f\n", poseAngles.yaw, poseAngles.pitch, poseAngles.roll );
|
|
// common->Printf( "Trans x = %f y = %f z = %f\n", hmdPosition.x, hmdPosition.y, hmdPosition.z );
|
|
|
|
lastRoll = hmdAngles.roll;
|
|
lastPitch = hmdAngles.pitch;
|
|
lastYaw = hmdAngles.yaw;
|
|
lastAbsolutePosition = absolutePosition;
|
|
hmdPositionTracked = true;
|
|
|
|
commonVr->hmdBodyTranslation = absolutePosition;
|
|
|
|
idAngles hmd2 = hmdAngles;
|
|
hmd2.yaw -= commonVr->bodyYawOffset;
|
|
|
|
//hmdAxis = hmd2.ToMat3();
|
|
hmdAxis = hmdAngles.ToMat3();
|
|
|
|
currentNeckPosition = hmdPosition + hmdAxis[0] * vr_nodalX.GetFloat() / vr_scale.GetFloat() /*+ hmdAxis[1] * 0.0f */ + hmdAxis[2] * vr_nodalZ.GetFloat() / vr_scale.GetFloat();
|
|
|
|
// currentNeckPosition.z = pm_normalviewheight.GetFloat() - (vr_nodalZ.GetFloat() + currentNeckPosition.z);
|
|
|
|
/*
|
|
if ( !chestInitialized )
|
|
{
|
|
if ( chestDefaultDefined )
|
|
{
|
|
|
|
neckToChestVec = currentNeckPosition - gameLocal.GetLocalPlayer()->chestPivotDefaultPos;
|
|
chestLength = neckToChestVec.Length();
|
|
chestInitialized = true;
|
|
common->Printf( "Chest Initialized, length %f\n", chestLength );
|
|
common->Printf( "Chest default position = %s\n", gameLocal.GetLocalPlayer()->chestPivotDefaultPos.ToString() );
|
|
}
|
|
}
|
|
|
|
if ( chestInitialized )
|
|
{
|
|
neckToChestVec = currentNeckPosition - gameLocal.GetLocalPlayer()->chestPivotDefaultPos;
|
|
neckToChestVec.Normalize();
|
|
|
|
idVec3 chesMove = chestLength * neckToChestVec;
|
|
currentChestPosition = currentNeckPosition - chesMove;
|
|
|
|
common->Printf( "Chest length %f angles roll %f pitch %f yaw %f \n", chestLength, neckToChestVec.ToAngles().roll, neckToChestVec.ToAngles().pitch, neckToChestVec.ToAngles().yaw );
|
|
common->Printf( "CurrentNeckPos = %s\n", currentNeckPosition.ToString() );
|
|
common->Printf( "CurrentChestPos = %s\n", currentChestPosition.ToString() );
|
|
common->Printf( "ChestMove = %s\n", chesMove.ToString() );
|
|
|
|
idAngles chestAngles = ang_zero;
|
|
chestAngles.roll = neckToChestVec.ToAngles().yaw + 90.0f;
|
|
chestAngles.pitch = 0;// neckToChestVec.ToAngles().yaw; //chest angles.pitch rotates the chest.
|
|
chestAngles.yaw = 0;
|
|
|
|
|
|
//lastView = commonVr->lastHMDViewAxis.ToAngles();
|
|
//headAngles.roll = lastView.pitch;
|
|
//headAngles.pitch = commonVr->lastHMDYaw - commonVr->bodyYawOffset;
|
|
//headAngles.yaw = lastView.roll;
|
|
//headAngles.Normalize360();
|
|
//gameLocal.GetLocalPlayer()->GetAnimator()->SetJointAxis( gameLocal.GetLocalPlayer()->chestPivotJoint, JOINTMOD_LOCAL, chestAngles.ToMat3() );
|
|
}
|
|
*/
|
|
if ( !neckInitialized )
|
|
{
|
|
lastNeckPosition = currentNeckPosition;
|
|
initialNeckPosition = currentNeckPosition;
|
|
if ( vr_useFloorHeight.GetInteger() != 1 )
|
|
initialNeckPosition.z = vr_nodalZ.GetFloat() / vr_scale.GetFloat();
|
|
neckInitialized = true;
|
|
}
|
|
|
|
bodyPositionDelta = currentNeckPosition - lastNeckPosition; // use this to base movement on neck model
|
|
bodyPositionDelta.z = currentNeckPosition.z - initialNeckPosition.z;
|
|
|
|
//bodyPositionDelta = currentChestPosition - lastChestPosition;
|
|
lastBodyPositionDelta = bodyPositionDelta;
|
|
|
|
lastNeckPosition = currentNeckPosition;
|
|
lastChestPosition = currentChestPosition;
|
|
|
|
headPositionDelta = hmdPosition - currentNeckPosition; // use this to base movement on neck model
|
|
//headPositionDelta = hmdPosition - currentChestPosition;
|
|
headPositionDelta.z = hmdPosition.z;
|
|
//bodyPositionDelta.z = 0;
|
|
// how many game units the user has physically ducked in real life from their calibrated position
|
|
userDuckingAmount = (trackingOriginHeight - trackingOriginOffset.z) - hmdPosition.z;
|
|
|
|
lastBodyPositionDelta = bodyPositionDelta;
|
|
lastHeadPositionDelta = headPositionDelta;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::HMDGetOrientation
|
|
==============
|
|
*/
|
|
|
|
void iVr::HMDGetOrientationAbsolute( idAngles &hmdAngles, idVec3 &position )
|
|
{
|
|
|
|
}
|
|
|
|
int iVr::Sys_Milliseconds( void ) {
|
|
struct timeval tp;
|
|
struct timezone tzp;
|
|
|
|
gettimeofday( &tp, &tzp );
|
|
|
|
if ( !sys_timeBase ) {
|
|
sys_timeBase = tp.tv_sec;
|
|
return tp.tv_usec / 1000;
|
|
}
|
|
|
|
curtime = ( tp.tv_sec - sys_timeBase ) * 1000 + tp.tv_usec / 1000;
|
|
|
|
return curtime;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::HMDResetTrackingOriginOffset
|
|
==============
|
|
*/
|
|
void iVr::HMDResetTrackingOriginOffset( void )
|
|
{
|
|
static idVec3 body = vec3_zero;
|
|
static idVec3 head = vec3_zero;
|
|
static idVec3 absPos = vec3_zero;
|
|
static idAngles rot = ang_zero;
|
|
|
|
common->Printf( "HMDResetTrackingOriginOffset called\n " );
|
|
|
|
HMDGetOrientation( rot, head, body, absPos, true );
|
|
|
|
common->Printf( "New Yaw offset = %f\n", commonVr->trackingOriginYawOffset );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::MotionControllSetRotationOffset;
|
|
==============
|
|
*/
|
|
void iVr::MotionControlSetRotationOffset()
|
|
{
|
|
|
|
/*
|
|
switch ( motionControlType )
|
|
{
|
|
|
|
default:
|
|
break;
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::MotionControllSetOffset;
|
|
==============
|
|
*/
|
|
void iVr::MotionControlSetOffset()
|
|
{
|
|
/*
|
|
switch ( motionControlType )
|
|
{
|
|
|
|
default:
|
|
break;
|
|
}
|
|
*/
|
|
return;
|
|
}
|
|
|
|
void iVr::MotionControlGetTouchController( int hand, idVec3 &motionPosition, idQuat &motionRotation )
|
|
{
|
|
static idQuat poseRot;
|
|
static idAngles poseAngles = ang_zero;
|
|
static idAngles angTemp = ang_zero;
|
|
|
|
motionPosition.x = -handPose[hand].Position.z * (100.0f / 2.54f) / vr_scale.GetFloat();// Koz convert position (in meters) to inch (1 id unit = 1 inch).
|
|
motionPosition.y = -handPose[hand].Position.x * (100.0f / 2.54f) / vr_scale.GetFloat();
|
|
motionPosition.z = handPose[hand].Position.y * (100.0f / 2.54f) / vr_scale.GetFloat();
|
|
//motionPosition.x = -handPose[hand].Position.z;
|
|
//motionPosition.y = -handPose[hand].Position.x;
|
|
//motionPosition.z = handPose[hand].Position.y;
|
|
|
|
motionPosition -= trackingOriginOffset;
|
|
|
|
motionPosition *= idAngles( 0.0f, (-trackingOriginYawOffset), 0.0f ).ToMat3();
|
|
|
|
poseRot.x = handPose[hand].Orientation.z; // x;
|
|
poseRot.y = handPose[hand].Orientation.x; // y;
|
|
poseRot.z = -handPose[hand].Orientation.y; // z;
|
|
poseRot.w = handPose[hand].Orientation.w;
|
|
|
|
poseAngles = poseRot.ToAngles();
|
|
|
|
angTemp.yaw = poseAngles.yaw;
|
|
angTemp.roll = poseAngles.roll;
|
|
angTemp.pitch = poseAngles.pitch;
|
|
|
|
motionPosition -= commonVr->hmdBodyTranslation;
|
|
|
|
angTemp.yaw -= trackingOriginYawOffset;// + bodyYawOffset;
|
|
angTemp.Normalize360();
|
|
|
|
motionRotation = angTemp.ToQuat();
|
|
|
|
}
|
|
/*
|
|
==============
|
|
iVr::MotionControllGetHand;
|
|
==============
|
|
*/
|
|
void iVr::MotionControlGetHand( int hand, idVec3 &motionPosition, idQuat &motionRotation )
|
|
{
|
|
if ( hand == HAND_LEFT )
|
|
{
|
|
MotionControlGetLeftHand( motionPosition, motionRotation );
|
|
}
|
|
else
|
|
{
|
|
MotionControlGetRightHand( motionPosition, motionRotation );
|
|
}
|
|
|
|
// apply weapon mount offsets
|
|
|
|
if ( hand == vr_weaponHand.GetInteger() && vr_mountedWeaponController.GetBool() )
|
|
{
|
|
idVec3 controlToHand = idVec3( vr_mountx.GetFloat() / vr_scale.GetFloat(), vr_mounty.GetFloat() / vr_scale.GetFloat(), vr_mountz.GetFloat() / vr_scale.GetFloat() );
|
|
idVec3 controlCenter = idVec3( vr_vcx.GetFloat() / vr_scale.GetFloat(), vr_vcy.GetFloat() / vr_scale.GetFloat(), vr_vcz.GetFloat() / vr_scale.GetFloat() );
|
|
|
|
motionPosition += ( controlToHand - controlCenter ) * motionRotation; // pivot around the new point
|
|
}
|
|
else
|
|
{
|
|
motionPosition += idVec3( vr_vcx.GetFloat() / vr_scale.GetFloat(), vr_vcy.GetFloat() / vr_scale.GetFloat(), vr_vcz.GetFloat() / vr_scale.GetFloat() ) * motionRotation;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
==============
|
|
iVr::MotionControllGetLeftHand;
|
|
==============
|
|
*/
|
|
void iVr::MotionControlGetLeftHand( idVec3 &motionPosition, idQuat &motionRotation )
|
|
{
|
|
static idAngles angles = ang_zero;
|
|
MotionControlGetTouchController(1, motionPosition, motionRotation);
|
|
/*switch ( motionControlType )
|
|
{
|
|
case MOTION_OCULUS:
|
|
{
|
|
|
|
MotionControlGetTouchController(1, motionPosition, motionRotation);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}*/
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::MotionControllGetRightHand;
|
|
==============
|
|
*/
|
|
void iVr::MotionControlGetRightHand( idVec3 &motionPosition, idQuat &motionRotation )
|
|
{
|
|
static idAngles angles = ang_zero;
|
|
MotionControlGetTouchController(0, motionPosition, motionRotation);
|
|
/*switch ( motionControlType )
|
|
{
|
|
|
|
case MOTION_OCULUS:
|
|
{
|
|
|
|
MotionControlGetTouchController(0, motionPosition, motionRotation);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}*/
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::MotionControllSetHaptic
|
|
==============
|
|
*/
|
|
void iVr::MotionControllerSetHapticOculus( float low, float hi )
|
|
{
|
|
|
|
float beat;
|
|
float enable;
|
|
|
|
beat = fabs( low - hi ) / 65535;
|
|
|
|
enable = ( beat > 0.0f) ? 1.0f : 0.0f;
|
|
|
|
if ( vr_weaponHand.GetInteger() == HAND_RIGHT )
|
|
{
|
|
//ovr_SetControllerVibration( hmdSession, ovrControllerType_RTouch, beat, enable );
|
|
}
|
|
else
|
|
{
|
|
//ovr_SetControllerVibration( hmdSession, ovrControllerType_LTouch, beat, enable );
|
|
}
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::CalcAimMove
|
|
Pass the controller yaw & pitch changes.
|
|
Indepent weapon view angles will be updated,
|
|
and the correct yaw & pitch movement values will
|
|
be returned based on the current user aim mode.
|
|
==============
|
|
*/
|
|
|
|
void iVr::CalcAimMove( float &yawDelta, float &pitchDelta )
|
|
{
|
|
|
|
if ( commonVr->VR_USE_MOTION_CONTROLS ) // no independent aim or joystick pitch when using motion controllers.
|
|
{
|
|
pitchDelta = 0.0f;
|
|
return;
|
|
}
|
|
|
|
|
|
float pitchDeadzone = vr_deadzonePitch.GetFloat();
|
|
float yawDeadzone = vr_deadzoneYaw.GetFloat();
|
|
|
|
commonVr->independentWeaponPitch += pitchDelta;
|
|
|
|
if ( commonVr->independentWeaponPitch >= pitchDeadzone ) commonVr->independentWeaponPitch = pitchDeadzone;
|
|
if ( commonVr->independentWeaponPitch < -pitchDeadzone ) commonVr->independentWeaponPitch = -pitchDeadzone;
|
|
pitchDelta = 0;
|
|
|
|
// if moving the character in third person, just turn immediately, no deadzones.
|
|
if ( commonVr->thirdPersonMovement ) return;
|
|
|
|
|
|
commonVr->independentWeaponYaw += yawDelta;
|
|
|
|
if ( commonVr->independentWeaponYaw >= yawDeadzone )
|
|
{
|
|
yawDelta = commonVr->independentWeaponYaw - yawDeadzone;
|
|
commonVr->independentWeaponYaw = yawDeadzone;
|
|
return;
|
|
}
|
|
|
|
if ( commonVr->independentWeaponYaw < -yawDeadzone )
|
|
{
|
|
yawDelta = commonVr->independentWeaponYaw + yawDeadzone;
|
|
commonVr->independentWeaponYaw = -yawDeadzone;
|
|
return;
|
|
}
|
|
|
|
yawDelta = 0.0f;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
==============
|
|
iVr::FrameStart
|
|
==============
|
|
*/
|
|
void iVr::FrameStart( void )
|
|
{
|
|
//common->Printf( "Framestart called from frame %d\n", idLib::frameNumber );
|
|
HMDGetOrientation( poseHmdAngles, poseHmdHeadPositionDelta, poseHmdBodyPositionDelta, poseHmdAbsolutePosition, false );
|
|
remainingMoveHmdBodyPositionDelta = poseHmdBodyPositionDelta;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::GetCurrentFlashlightMode();
|
|
==============
|
|
*/
|
|
|
|
int iVr::GetCurrentFlashlightMode()
|
|
{
|
|
//common->Printf( "Returning flashlightmode %d\n", currentFlashlightMode );
|
|
return currentFlashlightMode;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
iVr::GetCurrentFlashlightMode();
|
|
==============
|
|
*/
|
|
void iVr::NextFlashlightMode()
|
|
{
|
|
currentFlashlightMode++;
|
|
if ( currentFlashlightMode >= FLASHLIGHT_MAX ) currentFlashlightMode = 0;
|
|
}
|
|
|
|
bool iVr::ShouldQuit()
|
|
{
|
|
/*
|
|
if (hasOculusRift)
|
|
{
|
|
ovrSessionStatus ss;
|
|
ovrResult result = ovr_GetSessionStatus(hmdSession, &ss);
|
|
if (ss.ShouldQuit)
|
|
return true;
|
|
if (ss.ShouldRecenter)
|
|
shouldRecenter = true;
|
|
}
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
void iVr::ForceChaperone(int which, bool force)
|
|
{
|
|
static bool chaperones[2] = {};
|
|
chaperones[which] = force;
|
|
force = chaperones[0] || chaperones[1];
|
|
|
|
if (hasOculusRift)
|
|
{
|
|
//ovr_RequestBoundaryVisible(hmdSession, force);
|
|
}
|
|
}
|
|
|