No announcement yet.

VR Expansion Plugin

  • Filter
  • Time
  • Show
Clear All
new posts

  • VR Expansion Plugin

    VR Expansion Plugin

    *Updated: 03/16/2018*

    10/10/2016 - No longer OpenVR specific, if platform does not support OpenVR the plugin no longer compiles out the OpenVR specific code.
    Also all OpenVR code is in a separate module that can be disabled.

    Playable Template Demo
    Template Packaged Download

    This plugin is intended to ease the creation of VR games/experiences in UE4. It is up to quite a few different additions now and has a fleshed out wiki to help ease into it (may be a version or two behind at times, I attempt to update it when I can, the template is generally the best informational tool). It is also intended to be compatible with multiplayer experiences without any direct changes from the end user, most of the relevant components / actors replicated themselves over the network with some customization included.

    *Note* I wouldn't always suggest using this plugin AS IS for a large project with experienced developers, in that situation you may be better off using code from it on a case by case example of how different systems could be achieved in engine. I can't support every possible interaction in VR and some things could be done cleaner in a less general way for projects that don't need to support uncommon interactions or want the features in already implemented systems, shoehorning the plugin into projects already in process might not be the best solution. That being said there are a decent amount of projects that switched over while already in development and are doing fine.

    For small projects as far as I am aware it should be a quick and easy way to get going with more advanced VR interactions.

    It is fully Blueprint implemented but can be manually linked to and used in c++ if needed.

    Consider Supporting Me On Patreon

    Some Games In progress or released that currently use the plugin (These are just ones I know about)
    Bartender VR Simulator
    Surv1v3 Early Access
    Dark Frontier Early Access
    Temple of Aluxes
    Run Of Mydan Early Access
    Gladius Early Access
    The_Nest - Ctrl Alt Del Multiplayer patch uses the plugin
    Island_359 Used at least some code from it, unsure as to how much integration.
    Unforgiven: Missing Memories - Child's Play Used a very early version of the plugin
    Until None Remain
    Unknightly - Early Access
    Hailstorm VR - Early Access
    Contagion VR Outbreak - Demo out only so far
    District Steel
    Honeypot Espionage
    Viar Warefare
    Timmy's Playhouse
    Plugin Pre-built Downloads
    Plugin Repository

    Plugin Example Template Repository

    Plugin Migration Guides

    Migration Guides

    Repository Wiki Page

    Auto Generated Node References (KantanDocGen)

    Feature Request Submission:
    Feature Request Trello Board

    To submit a request, send an e-mail to
    Feature Request E-mail
    With the subject being the Card title and the body being the card body.

    Repository Installation articles By Community Member kusogaki77

    Basic Installation Step-By-Step

    Specific Commit Download Tutorial

    Pre-built binary useage

    Template Note:

    I would like to note by the way that everything currently in the template is an example of what I think is best practices (though maybe not implemented as well as I would for an actual game), not everyone is going to need the same set up and not everyone is going to need a full VRcharacter. Custom pawns that just use the motion controllers and camera / parent relative component would be useful to people that don't want gravity / collision. It also has to give examples of far more things than an average game is likely to use, so there WILL be refactoring involved if it is used as a base for one (input bindings for one).

    Template Change Log
    4.19 Changes
    Secondary grips moved to client side and pre-checked, also secondary checked before primary.
    Many other BP changes and cleanups for the characters.
    Fixed some bad logic in the Vive_PawnCharacter that kept secondary grips from behaving correctly sometimes.
    Added example content for the new VRGestureComponent and GestureDatabase DataAsset.
    Added a new gameplay tag "Interactible.UsePerBoneGripping" and new blueprint changes to support it.
    Has to be specifically defined as we have to pass in a different transform with per bone, as well as only tracing
    being able to do it (overlaps do not return hit bones....).
    Converted grip trace/overlap to an array check and a MultiSphere trace. It now loops through all
    hit / overlapped components and checks for if they are grippable and if so, if they have a higher grip priority
    than the last. This lets you use the new grip priority setting and also makes grip detection more powerful.
    It also always prioritizes gripping something over climbing on something.
    The old method just took the first detected object (closest one) and went with it.
    Updated the template to clean up the gameplay tag usage a bit, it actually required extending the GameplayTag
    functionality in engine as well to get working correctly.
    (new commit to the plugin adds this, but its not a big deal unless you use this new template version).
    The new GripDropOrUseObject node looks like below, I am calling the new one from the old one so that hopefully it
    will remain backwards compatible for now for people.
    *Edit* The functionality I needed for this from gameplay tags is entirely missing both in c++ and blueprint currently, I am considering cleaning it up, expanding it, and pull requesting it to the engine itself eventually. If that happens the node names for the new gameplay tag functions would likely change at some point.
    Template updated to correct BP compilation errors due to the plugin changes below.  
    Also made some slight optimizations in the DropAllGrips function due to a new BP node (GetAllGrips).
    Fixed velocity clearing for tracked objects in character blueprints
    Changed the character grip check so that it can also grip simulating non root components.
    Before it failed out if it wasn't the root component.
    Added mesh slicer and slicing dummy
    Added "Simple_BaseVRCharacter_NotNetworked" (will be further simplified in the future)
    Removed the Simple_VivePawnCharacter, either the complex or Simple characters can be re-parented
    to a SimpleVRCharacter at any point and I don't really want to promote use of it as much anyway.
    Fixed some car bugs, had to add a root scene component to prevent the car
    from auto simulating the buttons and levers.
    Car also now correctly checking in the player controller for active HMD.
    How the car functions is now entirely overhauled to use the new SetSeatedMode for the BaseVRCharacters.
    Fixed a teleport controller bug with moving it too quickly and it ignoring the navigation mesh, this is a problem with Epics template setup that I copied over for people, so be warned if using their default teleport setup.
    Added an option to the laser beam on the teleport controller to use smoothed (wobbly) motion like the VREditor uses (see below in plugin notes)
    Added VRGameViewportClient class blueprint override to template and assigned it as the default GameViewportClient class.
    This is to show how to change the input parameters for it.  
    fixed door warning
    added offset to spawn logic so that player should arrive
    correctly regardless of HMD offset.
    Fixed car not using driver since I remade how it handles seats
    Set the VivePawnCharacter to default smooth the camera replication and to a 60htz rate instead
    of the 100htz default.
    Changed how out of body movement works
    Now I am spawning a camera actor locally instead of having an attached child actor component
    First this removes a component/actor from non local characters per character, so it is a slight perf savings.
    Secondly this removes the damned "vivepawncharacter needs to save" regardless of changes made to it.
    Child actor components are still largely bug ridden and messy.
     *Car has all 4 seats filled in now.*    
     I also went into the DropActor RPC in the blueprints for VivePawnCharacter and quantized the requested  
     angular and linear velocities as well as only passing in the object now instead of the grip (which grip  
     is now reconstituted on the other side by getting grip by object).  
     This cuts the bytes used to replicate this RPC to 1/5 of what it was.
    Stable enough for beta release on the car (is not entirely complete, please ignore half done parts)  
    Made the steering wheel of the car a lever now instead of a dial and added a new mesh for it  
    Added new template level section specifically for playing with the car
    Skeletal mesh fixed when it has a rotated root bone and is gripped with physics
    Still not as optimal as I would have liked, but having to deal with center of mass
    and the root bone rotational difference between physics body and main is aggravating.
    Also fixed the center of mass setting to an offset location when the object is scaled.
    Added ClientSideAuthoritive_NoRep grip replication mode, acts just like ClientSide_Authoritive
    except it doesn't tell the server about it. Basically it behaves like the old LocalGrip identifier.
    Added IsALocalGrip function to the blueprint characters to clean up checking BOTH of the modes
    instead of just the one in some spots now (IE: where it chooses to call grip on client or server
    Set all grippable components to auto replicate by default.
    Otherwise a lot of funky things can happen, I think I removed this setting a few patches ago but it
    has proved to be important in most cases in multiplayer so i'm forcing it to default true
    again. Can still be disabled if you want.
    *Note* Stereo layer widget components appear to be updating incorrectly all of the sudden, I think this has to do with
    the new steamVR patch. I haven't found a fix yet, I can't test on Rift to see if it is working as intended there at the moment.
    Changed up the VRCharacter so that gripping and using is also  gameplay tag defined now.
    Everything is now run off of one generic function that manages any button passed in
    by comparing gameplay tags. Falls back to default tag values where appropriate.
    *Note* Original character is now "VRCharacter_Legacy" and will be dropped at some point.
    This allowed me to delete many extra functions that were pretty much just re-implementing
    drop or grip logic for different buttons.
    Removed a bunch of functions from VR character that were not needed.
    Sorted all functions in VR character into categories.
    Unlinked all OpenVR specific code (except for the controller loading since it just fails when out of platform).
    Added an example StereoViewIndex post process material with a custom node that returns the eye index both in AND out of instanced stereo mode. This can be used for
    stereoscoptic textures.
    Added HadHandSpecificSlots to gameplay tags so that the GetCorrectSocketPrefix can return VRGripLP or VRGripRP / VRGripTouchLP / VRGripTouchRP.
    Added a button type enum to the button component and functionality for a press
    button instead of just toggle (button still needs a lot of cleanup).
    Made 3D keyboard a component now by using the new function I added to the
    Cleaned up 2D and 3D keyboard setups, 3D keyboards still need some work, 2D is pretty much fully functional.
    Added new prelim procedural VR keyboard
    Fixed a bug with the widget interaction components not releasing that was introduced with the BP overhaul.
    Moved more of the input mappings into the Inputconfig and out of being directly declared in the character.
    Added boolean to enable Thumb rotation of teleporting, shows a second
    teleportation arrow that shows your ending facing direction.
    (first trello listed feature request)
    Re-worked sliding motion slightly to use a rotator created from the
    thumb pad axis values for direction instead of forward + right
    vector directions added together. Should be cleaner.
    Changed rotate character function to work more logically.
    All booleans that control behavior now have their own category for easy access, including the new UseTeleportThumbRotation boolean.
    Fix to sessions plugin for 4.16, ported to template.
    Moved gameplay tags into a data table
    Made gun example a Client_Authoritive grip
    Fixed some gameplay tag nodes in the character, added a fallback secondary release
    with trigger release if an object doesn't have any secondary drop tags.
    Changed the RIP motion to have "with hands" and "without hands" influence.
    Also fixed the low end velocity, should have only been the head.
    Modified all template objects to use the gameplay tags for drop buttons and secondary grip
    drop buttons.
    Modified the blueprints in the vr character to support the gameplay tags and cleaned them
    up in general.
    Added DefaultGameplayTags.ini to repository, this contains the generic default tags currently
    in use in the template project.
    Cleaned up most of the character blueprints
    Now using the FTransform_NetQuantize in character RPC's that send a transform
    Gun grip location equality check is now checking within two decimals of precision
    due to the new NetQuantize transform.
    Now destroying teleport controllers when the character is destroyed.
    Started adding some additional interactive objects to the level (Lever, Button, Push dial). Will be iterating over them and adding more in order to think about if I need to change any of the plugins workflow to
    make creating such things easier or not.
    Plugin Change Log
    Fixed a crash Epic introduced with their new OnControllerUpdated event, they were calling it in the
    render thread as well causing a crash. This will effect all default motion controllers, need to report it.
    Also converted the motion controller tracking source to use the setter so that the Mixed Reality
    plugin is initialized correctly.
    Adding bSupports depth back to stereo layer widgets
    Added override for the grippable static mesh actor to allow turning off relative location
    repping on its root component.
    This lets you set the root component to replicates (fixes some issues with how they replicate
    attachment and the like) while avoiding the extra overhead of also replicating its relative locations.
    Also left the new component in so people can use it for their own uses (non grippable static mesh
    component overrides with movement rep off optional, ect).
    Setting sub component replicate movement to true by default for grippable actors.
    Added movement replication controllable component to the skeletal mesh actor as well.
    Fixing a problem with my floor offset for PhysFalling where it could slow down
    the ending floor detection when transitioning to walking.
    Now I am checking for a valid landing spot when the floor find is within that
    offset as well.
    Fixed movement base being set for climbing movement mode (grabbing on to something while on a moving platform could
    have you still follow the thing you are standing on, no longer happens).
    Updated stereo widget component a bit, problems in UE4 with orientation with stereo layers for steam
    are prevelent, unsure how to fix, pretty sure Epic is incorrectly converting the rotation from
    ue4 FTransform to OpenVR Matrix. May find the fault and submit a bug report some time.
    Set stereo widget to tick during physics (post movements) so that the player movement doesn't apply a
    visual stutter to it. Will transition entirely over to Epics world locked when it eventually works correctly...
    Added prelim slider snapping implementation
    Slider now auto sets parent if the parent attachment is a spline
    Slider also now has a "SetSliderProgress" node that will set the progress to whatever
    you pass in to it 0.0 - 1.0
    Simplified the spline following and made it follow scale "more" correctly than before.
    Added GetIKMesh function to VRBaseCharacter, lets us use epics new optimization during
    move combining with skeletal meshes.
    Entirely optional, but if there is an IK mesh, it would be best to override the function and
    pass in your IK mesh.
    Cleaned up teleport, moved the teleport grips to the TickGrip instead so we use the final transform.
    This also prevents multiple calls from breaking it and forces it to come in after all move actions and movement
    is performed.
    Added support for movement actions to be queued up with multiple in a frame instead of limited
    to 1. There is no longer a limitation on them.
    Changed it so that ClientSide_Authoritive grips pass up the objects velocities on release.
    They were not doing so before so throwing behavior could feel off.
    Added bRunControlRotationInMovementComponent If true will run the control rotation in the CMC instead of in the player controller
    This puts the player rotation into the scoped movement (perf savings) and also ensures it is properly rotated prior to movement.
    This is the prefeered setting currently, someday I may remove control rotation entirely from the movement system to fix a bunch
    of issues, but for now this helps.
    Added scoped movement to many more sections of the character, significantly saving perf (over and above default engine characters even).
    General 4.18-4.19 Changes  
     Corrected imprecision issue with inverse transforming of the interactibles I use the inverse of the grip transform to get the hands original location relative to the object on grip for the interactible calculations. I was getting precision errors when getting FTransform::Inverse if the interactible was unevenly scaled on any axis. Converting to a FMatrix, then inversing, then back to FTransform removed this precision issue. I am still uncertain why FTransform::Inverse was misbehaving in this situation.  Added some events to the SliderInteractible (OnHitEnd)  Started working on bEnforceSplineLinearity to keep a slider in line on a spline (Unfinished needs work).  Added bLerpAlongSpline to slider to smooth out the movement.  Added grip prio to all interactibles  Fixed teleport move grip node (one of the variables was output instead of input)  Added Re-calculate lever angle function to lever  Also made the ResetLever function re-calculate the angle as well.  Set character default rotation replication values to shorts  Changed how controllers copy a replicated relative grip from a deep copy to a shallow one. This is to avoid overriding important local only variables.
    4.19 Only Changes  
     Blueprint cleanup with pure/callable node choices, some nodes were returning multiple variables making it more likely that people would abuse them and multiple call them as pure, converted these to callable.  OpenVRExpansionLibrary added "GetOpenVRHmdType" node that breaks down to the specific headset connected in OpenVR. This is due to the module reporting as SteamVR type always. I will need to manually added headsets in here as new ones come out, its a shortcut service for my users.  Greatly reduced the characters CPU load when updating to the physics thread, removed one ticked update that I had caused and three that Epic had caused that were extra.  Moved the application of the Input data to the control rotation to the character movement component. This is so that I can have correct rotations prior to moving the character. Typical engine behavior is to have the rotation done in the player controller AFTER all movement is applied, this can cause issues due to our offset movements.  Converted the OpenVRExpansionLibrary device oriented nodes entirely over to index's and added some Getter nodes for type / specific devices. This brings my node library directly in line to being compatible with epics one as well as clears room for vive pro and devices where trackers and the like are activated out of normal order.  Changed bIgnoreSimulatingComponents to just ignore PhysicsBody channel objects for the floor check so I could avoid the multi sweep I was doing (slower) before. If you intend to use this functionality instead of just removing collision then be aware that the objects need to be on the PhysicsBody channel now.
    Added Controller profiles to the plugin.
    See Post: Controller Profiles
    Accepted Space Harry's VRMountComponent pull request (A turret like interactible component)
    Fixed VR Lever not responding when max of an axis is 0.0f
    Corrected a replication issue with client authoritive grips where
    since I don't replicate some variables when the secondary grip is being sent as removed
    the server would lerp incorrectly back to base position.
    Improved the Parent Relative attachments behavior when lerping with yaw tolerance
    Changed the additive transform for grips so that it applies seperately from the secondary grip rotation.
    This stops the addition rotation from being overidden by a secondary grip.
    Added new VRGestureComponent - allows you to record and detect gestures, also has some utility functions for  drawing and managing them.  Added GestureDatabase DataAsset to store gestures.
    Merged in the upcoming 4.19 movement replication changes.
    It simplifies and speeds up the movement system as well as moves the RPCS into the character itself to save on some bandwidth.
    Changed charactermovements default for MaxAcel and BrakingDeaccel to very high values.
    This effectively makes characters use no acceleration and de-acceleration when moving.
    I had this in BP before but it really should be defaulted like this in code so that people making new characters don't leave
    acceleration on with the characters.
    Re-setting these values back to 2048.f engine defaults will restore normal engine operation for them.
    Added per bone gripping to the physics grip styles.
    Using these correctly requires passing in the bone name and USING THE BONES WORLD TRANSFORM NOT THE ACTOR/COMPONENTS.
    If you do not pass in a bone name to the gripping function then it won't know what bone to grip at and will just grip it like a
    normal component.
    Also if you don't use the bones world transform then it will not be correctly positioned during gripping.
    Per bone gripping is only enabled for physics grips for obvious reasons.
    I left in the old hacked method of applying the root bone rotation when a bone name isn't given to keep backwards compatibility.
    Climbing no longer hitches on using it and dropping it right away while standing on the floor  
    Added 2.15f Z offset to VRRootCapsule by default to sink everything else (tracked objects) into the ground  
    a little bit and counteract the walking hover.  
    Adding the walking hover to falling mode (checking for floor during falling).  
    This removes most of the hitching when walking off of objects and entering into  
    falling directly out of climbing. (this appears to have been an Epic Games Bug  
    as it appears in all of their games using a character and in thier templates).  
    Zeroing out the velocity of the character if an auto step up is performed.  
    This keeps custom step up movement modes from receiving the last known movement  
    Fixed bWalkingCollisionOverride in multiplayer with the new movement system
    Also added another null set to the RootComponent to ensure parity
    Added GripPriority setting to AdvancedGripSettings, lets you perform logic on the priority of
    something using the interface.
    Could also be used to sort through currently held items.
    Updated documentation comments plugin wide so that auto generation and tooltips are both more useful.  
    Changed name of grip array in source to GrippedObjects instead of Gripped Actors.
    The original name was a holdover from the very early days of the plugin.  
    Migrating to this version will require change to the new name where it is used in blueprints and source.
    Sorry for the hassle but I had to do it at some point and 4.19 is going to be heavy.  
    Added function void GetAllGrips(TArray<FBPActorGripInformation> &GripArray).
    Returns a consolated list of grip structures, useful for avoiding checking local and normal grip arrays seperately.  
    GetGrippedActors/Components/Objects nodes converted to BluePrintPure (no longer have execution pins).
    They didn't need to be executable. Depending on what you use them for you may need to alter blueprints that were using them.  
    PostTeleportMoveGrippedActors renamed to PostTeleportMoveGrippedObjects, you will have to replace  the nodes / functions where you used them (if you did, template does not).  
    Added Axis_Z and Axis_XZ options to the lever (another SpaceHarry pull request) Axis_XZ may require further edits to get working perfectly.
    Moved view extension destruction in motion controller to BeginDestroy like the new controllers in 4.19
    Epic had it listed as a crash in the private bug tracker I guess.
    Added SG_Custom and SG_Scaling only to secondary grip types
    SG_Custom doesn't do anything, it just lets you apply a secondary grip
    and choose what happens based on its events yourself.
    SG_ScalingOnly doesn't rotate the object, it just scales it.
    Made it so that parent grippable components get the OnChild events for attached grippable components
    as well, not just the actor.
    Decoupled the OpenVRPlugin from the VRExpansionPlugin now that there is no TrackedDeviceController.
    Can be a stand alone plugin now.
    Made physics with sweep grip sweep sub components as well now (attached components to the root also get swept with movements)
    Set VRButtonComponent to overlap all by default, it doesn't need blocking collision anyway.
    Added SetSeatedModeFunctionality to the BaseCharacter. Comes with events that fire off to help do screen fade and
    manage things when a seat is taken. Is a base part of the charater now (documentation coming this week).
    It does NOT turn off movement replication, instead it paths in as a custom movement mode for the pawn and the server
    and owning client handle repositioning while remote simulating clients get it replicated by the server down.
    Supports automatic head radius and pushback and a threshold value that can be sampled to run fading of vision.
    Also has a Re-zero function that can be used for after the player chooses a new spot, sits down, or finds a chair.
    Re-zero could be set to a timer and auto set within a set countdown as well to allow automatic seat detection.
    Added SetActorRotationVR, AddActorRotationVR, SetActorLocationAndRotationVR nodes to the Basecharacter, these all
    automatically offset and rotate by the HMD. (IE: SetActorLocationAndRotationVR(Loc(100,0,0), Rot(0,0,45)) would place THE PLAYER (not the root)
    at 100,0,0 worldspace and facing 45 yaw in world space. These nodes should provide a lot of shortcutting for people, I should have made them
    as long time ago.
     Moved Grip type enum comments into the enum area so they show on hover  
     Added bIgnoreRotationFromParent to parent relative attachment, when true the  
     parent relative attachment no longer follows the parents rotation, only its position.  
     (SpaceHarry was using this for body meshes where he was IKing the rotation himself  
     in the animation graph.  
     (thanks to SpaceHarry for the original pull request that added both of these)  
     Overrode IsWithinEdgeTolerance and added VREdgeRejectDistance to the VRMovementComponent.  
     This allows for stepping up easier without very slow movements getting in the way  
     and causing wall sliding. Default engine value is 0.15f, new default plugin value  
     is 0.01f (rounded min for HMD movement in network). If you encounter issues you may  
     want to raise it.  
     Changing bIgnoreHandRotation to reconstruct and resolve the controller  
     instead of requiring it be modified prior to passing to the server.  
     Changed GetControllerRelativeTransform to no longer take an input object for  
     checking bIgnoreHandRotation, it is no longer needed. Kept the node around anyway  
     because the default in engine nodes variables are named silly and confusing.
    Changed the MoveAction system so that custom move actions can choose whether they use  
    the rotator or location or both or none. This can save massivly on replicating them.  
    Changed moveaction system so that it is a self contained struct now for ease of use and expansion.  
    Added MoveAction_StopAllMovement - calls StopAllMovementImmediately from the movement component  
    in line with the move action system (movement system).  
    Changed the interactibles so that they re-construct their initial location values on grip  
    from the Relative to controller grip transform. This corrects for the client to server delay  
    creating an offset on where the grip is on interactibles in high ping scenarios.  
    Also corrected the drop distance for slider components so that they run off of the correct  
    transforms (relative instead of parent).
    The great VRCharacter refactoring
    Added OnBeginWallPushback and OnEndWallPushback events to the characters so people can
    darken vision and set up things when pushback is happening.
    Added vr.ForceNoStereoWithVRWidgets so that users can globally force stereo widgets
    to use only normal widget rendering at will (Fantisfall).
    Major overhaul of how the VRcharacter handles movement, cleans up many many interactions
    and fixes the few broken features from the old system (bCanWalkOffLedges works now).
    Also wall sliding is far cleaner and nicer now.
    Basically instead of the old hacky method of adding a bit of movement input
    in the normal direction of HMD movement (that I hated and proved more stable than
    I had expected). Now during movement the movement mode rewinds the last delta of the
    HMD and plays it back as part of the current movement mode. This allows it to act
    as a true first party in the movement logic and keeps all of the normal character
    interactions largly as they would be in a 2D pawn.
    It is more accurate, smoother, and far more reliable in multiplayer (though will still go through some cleanup in the future).
    Changed VRRootComponent so that it manually attempts to verify overlaps now if it ends a
    scoped movement with detected overlaps but none on final position. This corrects the capsule
    1 frame on and off overlap events.
    Renamed camera transform replicated variable and RPC so that they show up
    more clearly in NetProfile (.nprof) readings (Just read as ReplicatedTransform before, now reads
    as ReplicatedCameraTransform).
    4.18 additions
    Moved secondary grip scaler into a new struct (AdvSecondaryGripSettings) along with several new features
    Added the 1 Euro Low Pass Filter that Epic has been using in the VR Editor for the laser beams as a native part of the plugin in both BP and c++.
    Secondary grip scaler now uses the 1 Euro Low Pass Filter on the back end to control the secondary grip smoothing(settings are now in project settings for
    the 1 Euro Low Pass that this uses).
    Add a Distance base influence option in the AdvSecondaryGripSettings, when the boolean is true it uses the combined values of the DistanceInfluenceDeadZone and DistanceInfluenceDistanceToZero to control how much effect the secondary hand has over the grip (see latest video for explanation).
    Added GripDistance and SecondaryGripDistance floats to the grip struct, they are calculated locally and are not replicated.
    Improved NetSerialization in general.
    For generic objects without all of the advanced new features, they should still be less overall replication cost, obviously replication cost will ramp up as more and more of the advanced settings are enabled.
    BUGFIX: Added in an UpdateComponentToWorld call on object drop to account for an issue with the new Late update that Epic is using.
    Added a global settings class that shows up in ProjectSettings|VRExpansionPlugin so that I can expose global variables there cleanly, I intend to move some magic numbers out of their classes and into that in the future, currently only has the 1 Euro settings for the motion controllers.
    4.18 interface changes & migration guide
    AdvancedPhysicsSettings() interface function removed
    Added AdvancedGripSettings() interface function so that the interface can return advanced physics AND secondarygrip settings.
    GripStiffness() and GripDamping() interface functions removed
    Added GetGripStiffnessAndDamping() function to replace them
    SlotGripType() and FreeGripType() interface functions removed
    Added GetPrimaryGripType(bool bIsSlot) to replace them
    ClosestSecondarySlotInRange() and ClosestPrimarySlotInRange() Interface functions removed
    Added ClosestGripSlotInRange() which takes a bool bSecondaryGrip so that it is a single function definition now instead of two
    *THIS REQUIRES BLUEPRINT CHANGES* You will need to replace your Closest Primary slot and Closest Secondary slot nodes with a ClosestGripSlotInRange node
    with the correct bSecondaryGrip setting. The template has already been updated to make this change.
    Added OnInput(FKey, EInputEvent) event to the interface so that you can pass in any generic input you want to the gripped object instead of just
    OnUsed and OnEndUsed (and secondary).
    Apex destructon auto detection of held object being destroyed has been removed, this is due to them moving Apex into its own plugin
    and disabling it by default.
    Anywhere you were manually overriding one of the removed interface functions you will need to correct for the changes.
    Added Epics world locked implementation as an option to the VRStereoWidgets   
    They are still buggy, but should be included anyway.
    Added check to ensure that we don't try to physically pick up an object that is using  
    bUseComplexAsSimple collision.  
    This will be more obvious as to why it is crashing out that the default Mass > 0.f  
    warning that is generated normally.  
    Moved netsmoother up higher in serialization.  
    Exposed levers bIsLerping to blueprint so things can use it (see new native lever actor  
    and how it checks it to turn off tick).
    Fixes an issue with the new late update method in 4.18 that I early updated to.    Since it is queuing the late update now to avoid thread racing in game and render,   it applies the final late update one frame later in render thread   after the object is no longer late updated so if you don't move or update the   component (or its parent) after releasing it then it never   loses the rendering offset.    
    I am just calling UpdateComponentToWorld now on release to correct for it.
    Fixed min distance clamping with the vr slider component (oops).  
    Also added CurrentSliderProgress variable that is calculated during movement.  
    Ranges from 0.0 - 1.0 with 1.0 being 100% and 0 being 0%, also works for along the spline  
    component it is following.  
    Added SetSplineComponentToFollow function to either add or clear the follow spline.  
    Fixed a bug with the VRStereoWidget where in packaged builds the compiler was resolving to the wrong namespace and not using my custom scene proxy.  
    Added Euro Low Pass Filter to the plugin (same on that Epic is using with the VR Editor  
    for their laser beam smoothing). It has ResetEuroFilter and RunEuroFilterSmoothing nodes  
    in the VR Expansion Library to control it (or in c++ you can directly call the functions)  
    Also added an auto arc calculation node to the VR Expansion Function Library so that the  
    arc calculation and setting is faster and clean and is the same as the VR Editor.  
    smoothed "wobble" beams.  I normally wouldn't directly port things over, however I know that people would want the  
    same behavior if possible so that they have consistancy.
    Also removed a silly check left over from copying code in the VRBaseCharacter.  
    It likely had no effect but it should be removed.
    Added VRGameViewportClient class  
    This class is intended to provide support for Local Mixed play between a mouse and keyboard player  
    and a VR player. It is not needed outside of that use.    
    There is a new wiki page under Misc Classes that covers its use 
    Added functionality for the ParentRelAttachVRComponent, it can now be attached to the bottom of the capsule at the foot location
    instead of at the HMD location. Only happens when bUseFeetLocation is checked. Thanks to SpaceHarry for the initial pull
    request, I had plans to do this but kept forgetting about it.
    Added a bunch of functions/nodes to the OpenVR library to control overlay skyboxs and loading systems. They are detailed in the wiki entry below.
    Corrected an issue that the Epic Motion Controllers have that was evident in my overrides of them, now removing the late update scene view if the motion
    controller is deactivated. Otherwise late updates would continue to be used and visually it would appear as if the controller was still active.
    Early implemented a new method of handling the controller late updates that Epic is
    using in the upcoming 4.18 patch.
    It utilizes a double buffer for the scene references in the render thread and effectivly
    solves the high velocity tracking issues that were very evident before (when moving fast
    the controllers late update would send them flying all over).
    also started adding some comments for incoming 4.18 changes to remind myself.
    There will be a lot of changes incoming due to OpenXR starting to be supported in engine.
    Added a NetSmoother component to the VRCharacters (a dummy root scene component), it takes advantage of the ClientSmoothPosition
    data that is already calculated for standard characters SkeletalMeshes and applies it to this tracked
    component root instead. This way there is a more smoothed lerp back to the correct position after
    the server finishes replicating a character move and the client already predicted it out farther.
    This only takes effect on simulated proxies. The root can be re-purposed in single player or locally controlled characters to handle things like simulated lean or other effects.
    I had considered adding a dummy root to the tracked devices for awhile now so people had some more flexibility without manually re-parenting but the network smoothing gave
    me an actual reason to do so.
    The smoothing effect can be turned off by turning off network smoothing on the character movement component, this still retains the sudden jump to the last replicated position when a simulated proxy stops being sent velocities and stops predicting position though.
    Added a AddDeltaAngle function to the VRDialComponent, can be used to set initial rotation / angle of the
    dial or to increment it later on. Also is now used for the GripTick tracking of the dial angle.
    Exposing bDenyGripping for the lever and dial components, forgot to provide a method to control this for them.
    Massive Header file cleanup to better support Non Unity Builds and Linux.
    Fixed TeleportMoveGrip teleporting NoTeleport and DropOnTeleport on initial
    !IsTeleport grip teleportation check. (ie: on initial grip could teleport things that don't want it)
    Motion controller is now only setting ReplicatesMovement on actor grips or when the held
    component is the root component. This is possible since I added the new movement replication bool
    to the grippable components.
    Made the new conditional replication system for saved movements more sane and extended it to
    the simple character. It costs...2 bits...more than before but is far cleaner and has less functions.
    Changed non post teleport teleportMoveGrip commands to ignore NoTeleport
    and DropOnTeleport objects and exit. *This is actually more serious than it sounds, it could cause static objects that
    aren't supposed to move to be able to slightly shift on initial grip*
    Added replication smoothing to the camera like the controllers have
    Made the first replication directly set the location instead of beginning a lerp, all other replications
    after that are lerped too. This prevents the initial 'tick' of lerp going from 0,0,0.
    Made some fixes to the movement merging/combining capability of the VRCharacter, should be more stable
    and reliable now.
    Now more appropriatley declaring Important moves so that they are sent again if not Acked
    (prior to this CustomInputVectors and Navigation Velocity didn't trigger as important).
    Made more nuanced checks for CanCombine in the saved movements that acutally allows for combining
    movements with HMD movements attached. Uses the same Dot Threshold as the acceleration combinining does.
    (5 Degrees by default).
    *From initial testing it appears safe now to enable MergeMovements on the movement component, if it remains stable I will default it*
    Removed Control Pitch and Control Roll from being replicated AT ALL in the VRCharacter.
    We never use these two values. (This saved 3 bytes per rep send)
    Upped CapsuleYaw from 1 byte compressed to 1 short compressed for sends
    (this cost 1 byte per rep send).
    (Overall this saves 2 bytes per rep send and has a higher accuracy of HMD yaw).
    Added alt path to restore original control roll/pitch replication if character is set to follow it
    I understand that this is a lot of additional code for a 2 byte per rep savings.
    Added replication smoothing to the camera like the controllers have  
    Made the first replication directly set the location instead of beginning a lerp, all other replications  
    after that are lerped too. This prevents the initial 'tick' of lerp going from 0,0,0.  
    Added IsInVRPreview node to the VRExpansionFunctionLibrary  
    Added boolean to player controller (default true) bDisableServerUpdateCamera. When true it disables the automatic view replication from the camera manager for the camera. Typically we are already sending the camera's position / rotation in VR and the replicated value isn't that useful anyway. Unreal tournament turns it off and sends the look value from the clients when important actions happen and in VR most actions happen off of direct input instead anyway. (this removes a 1000b/s replication cost or so).
    The boolean can be disable to return the typical engine functionality.
    Added ExLight RPCS for char movement that activate when Acceleration is also zero
    Removed the defaulting of Replicate movement on grippable components when movement is set to server side. After second thought I would prefer the bReplicateMovement be manually set by plugin users here.
    Made "Light" versions of the RPCs that send saved movements to the server.  
    These do not pass in the RequestedVelocity and CustomVRInputVector.  
    They are called if both the RequestVelocity and CustomVRInputVectors are zero.  
    This cuts down on some of the additional overhead built into the replication in the VR characters.  
    Also the saved movement capsule Yaw value being sent over the network is now the same calculated Pure yaw that the GenerateOffsetToWorld  
    uses. This will make running back movements slightly faster, as well as slightly more accurate as passing  
    in just the normal HMD yaw before could yeild slightly different results when the camera is rotated off axis than  
    if calculating entirely off of the full rotator.
    Removed default of grippable actors base components replicating, this was an oversite.
    Added a new boolean to all grippable components (defaulted: off), bReplicateMovement.
    This emulates the variable of the same name on actors and controls whether grippables
    will replicate their movement when set to replicate (IE: so gameplay tags can replicate).
    The value of this property is overriden when the current grip type of the grippable is
    serverSideMovement, then it forces allowing movement replication.
    Turned bReplicates off by default on all grippable components, if you need to set interfacesettings
    on placed objects that aren't set to load with the map for the client or have replicated gameplay tags then just turn it on for the component.
    Better to have this directly set by the game developer than defaulted by me.
    I now have more options in the grippable components for finer grained control of them when replication is turned on.
    Fixed it so that SetReplicatedMovementMode works with Move_None now, was mistakenly using
    Move_None as the empty specifier, now using Move_Max for that.
    Made VRLever and ParentRelativeAttachmentComponent use failsafe axis lerp functions instead
    of just a generic FLerp.
    Fixed Simple characters overriding the RequestedVelocity of the base FSavedMovement class (fixes client side navigation with simple char).  
    Added a check in the VRLever to help prevent it flipping sides when over rotating.
    Changed the parent relative attachment component so that it sets relative space instead of world space position now.  
    World space was a holdover for when it was directly attached to the camera, not only is it not needed anymore,
    but it also can result in the incorrect behavior.
    Added a default lerp to the snap setting for the ParentRelativeComponent
    Can be turned off and speed can be adjusted.  
    Fixed a bug with HasGripAuthority where the server was being assigned as grip authority
    for the Client_Auth grip on its end.
    Added a 1 frame delay flag after teleport where grips won't check the constraint for
    if it is outside of the auto drop distance. This is to allow for the constraints localpose to
    held object to be recalculated. Otherwise it could rarely drop the held object on teleport with
    small auto drop lengths.
    I could manually set the constraints local pose instead, but would rather have the delay anyway.
    Some VRDial component fixes / re-implementations, should be functional now and out of
    Likely needs some additional features and clean-up in the future.
    This makes it: Button, Lever, Dial being at least initially done remaking to c++.
    New UpdateOverlaps override, should correct multiple issues / problems with how
    overlaps have been working with the VRCharacter Capsule.
    Some things like overlap spam on character capsule and overlap offset have been around for a long time but were mostly forgotten about.
    Thanks to SlimeQ for bringing them up again so I remembered to look into it.
    Added calling controller capability to the GetClosestSocketInRange interface functions.
    Can be used in overridden versions to check the hand / other info about what/who is checking
    for a socket in range. - Will require c++ changes in anything that manually implements the interface
    Defaults to a nullptr, but a motion controller can be passed in and used on the implementation side.
    Template will have it filled in.
    Made bHadRelativeMovement publically readable in blueprints
    While misnamed, is true if we collided with a wall/obstacle due to the HMDs movement in this frame (not movement components)
    Removed MotionControllerLocDelta from TickGrip
    Not only can you manually calc it (and probably should) with custom grips.
    But being in worldspace the offset could be wrong due to character movement.
    Better to let items calc it themselves and store the variables for more advanced use instead.
    I don't think it had much use in its current state.
    Now I am only calling move ignore actor if the held
    object is an entire actor. If the grip is on a component only it does not perform
    it for the entire actor, just for the held component.
    If for whatever reason someone needs an entire actor to be uncollidable with a component
    grip they can do it themselves.
    Added somewhat working dial component - needs full testing
    Replaced some overzealous uses of FORCEINLINE with inline instead. One instance in particular was causing some massive stalling when
    UBT was compiling the precompiled headers for some reason.
    Thanks to: Makoto Nokata
    For taking the time to run down what was causing UBT to stall during initial precompiled headers compilation in engine.
    This commit should significantly speed up initial compilation.
    VRLeverComponent is now fully functional, still would like to clean up angle calculation
    some and reduce overhead on it but it is usable in its current state so i'm pushing it live.
    Further optimizations and features will be added over time to it now.
    (this component took longer than expected due to REALLY wanting perfection for the most part).
    initial setup of lever component, working on physics side of it.
    Combined axis enums from button and lever components into EVRInteractibleAxis
    Couldn't find a generic public XYZ enum in engine already to use.
    *Note c++ lever component is still unfinished in this update*
    Added an OverridePrefix string intput to the FindClosestSlotInRange function.
    This more easily allows the end user to do things like controller (touch vs vive)
    or hand (Left vs Right) define custom grip sockets to a mesh.
    IE: Pass in VRGripPLTouch for Left Hand Touch socket.
    Moved secondary grip information into a seperate struct in the grip structure, not only does this allow me to add some replication specific
    additional properties to it. But it also should be more efficient to replicate as I can boolean control its replication without forcing
    NetSerializer on the main struct. It also lets me just pass the struct for notification functions.
    Added bIsSlotGrip to both primary and secondary grip structs, can be set when calling the grip function, useful for checking in the object later on.
    Made it default to set physics gripped objects Center Of Mass to the controller location for the grip.
    Added Option in advanced physics to turn off setting COM to grip location
    Added advanced physics settings for the interface, by default they are turned off
    however when turned on they can be used to change constraint settings beyond the normal
    acceleration based with stiffness/damping for angular being auto calculated.
    One use would be to change it from an Acceleration based constraint to a force based one.
    This would create better behavior with manipulation grips in some scenarios as well
    as offer a method of delayed / weight simulated grips (would likely need the custom
    angular stiffness and damping set then as force values for these are far higher than
    acceleration values).
    I have plans to add more features to the advanced settings in the future. When deactivated the
    additional grip property costs 1 bit to replicate. When activated the replication cost
    is dependent on what in it has been enabled.
    I have been wanting to expose the physics settings more to the user and this is probably the best
    way to do it (Like auto center of mass setting on grip). I would love to merge the normal stiffness and
    damping into the same structure but it would break many projects so it may never happen.
    C++ Actors/Components using the interface will need to implement the new getting function
    for the advanced physics settings (if ever merged it would replace the separate stiffness
    and damping functions instead).
    Now using a nearly check for better precision safety when checking for replicated changes for
    stiffness and damping.
    Added optional angular stiffness / damping setting to the SetGripConstraint blueprint function
    Added visual and editable indicators to grip interface settings that are controlled by a boolean
    (IsInteractible / UseAdvancedPhysicsSettings). To make it easier to work with them.
    Made some WalkingCollision override changes to be more reliable and consistent as well as use
    more custom logic and less hackish workarounds. Will need feedback on how it behaves now.
    New ClimbingStepUp fixes (for VR Char only ATM) appear to help a ton with
    step up issues. Adds a configurable variable to the StepUp settings that sets a seperate
    threshold for when a capsule is considered within stepup range making it significantly harder
    to accidentally fall back off backwards when stepping up. Should not be increased beyond the radius
    of the capsule (is noted as such on the variable comment).
    Fixed a missing Super:: call in PhysCustom so that the HandleCustomMovement event would
    fire for blueprint users on custom movements that are not already handled by the plugin.
    Expanded EVRConjoinedMovementModes enum to include 6 custom movement mode definitions
    this will make it easier to select a custom movement mode that doesn't overlap with already used
    values. This also allows SetReplicatedMovementMode to work with those 6 custom movement mode
    index's for true during movement mode switching without explicit RPCs.
    Changed the auto step up for climbing to call SetReplicatedMovementMode now instead of
    directly changing movement mode, this allows it to still function if the server rolls
    back a move and replays (previously in rare cases it was hanging on climbing as the rollback replay
    wasn't re-setting the out of climbing mode).
    Added pipeline for replicated movement mode changes that tie in with fSavedMovements
    Does not currently support Custom MovementModes outside of the ones I define.
    To get it working correctly with up to 16 total values the Flag_Custom_0 and Flag_Custom_1
    and Flag_Reserved_1 and Flag_Reserved_2 of the saved movement have been taken up. There is room
    for 6 more custom modes to be added to the plugin at a later date.
    Added Alpha LowGravMovementMode
    Set StepUp to be overriden now that it is supported.
    Added EVRConjoinedMovementModes enum that combines the default modes with my custom ones.
    Added PostClimbingMovementMode property to climbing settings to set the auto step up
    movement mode switch.
    Added boolean SetDefaultPostClimbMovementOnStepUp defaulted to true, if true then
    will auto switch movement mode to the PostClimbingMovementMode value on the auto step up.
    If false the movement mode will need to be manually set instead when OnClimbingStepUp event is called.
    Added VRLowGravWallFrictionScale that modifies the speed that you retain when hitting a wall
    in low grav mode, defaulted to 1.0f.
    Added VRLowGravIngoresDefaultFluidFriction boolean defaulted to true, when true the low grav
    movement mode will ignore the default Air Fluid Friction that the engine uses. This allows
    low grav to work correctly without changing the default fluid friction, it will still use
    custom fluid frictions otherwise.
    Moved inline functions into header for root component to prevent a packaging error
    without removing inlining on them.
    Set step up capsule directional influence to only be used with walking movement
    in step up as it does not function with LowGrav / Flying correctly.
    Added capsule directional movement influence to VRClimbingStepup for VRCharacter
    Set VRClimbingStepUpMultiplier to default of 1.0 now
    Fixed step up height issue from today.
    Added prelim support for replicating capsule half heights in multiplayer.
    This is controllable by a new boolean VRReplicateCapsuleHeight on the character
    movement component.
    It causes minor issues with climbing step up and edge cases currently.
    Also now zeroing ALL Z values for HMD relative movement for the movement system.
    Before I was only doing it for the simple character.
    This free's up the Z axis value to be used for the capsule half height replication
    so that I don't have to pass any more variables on.
    Added "AddSceneComponentByClass" blueprint node to the VRfunctionlibrary.
    Made switching collision types for a grip not call OnGrip again.
    Added GetVRDevice_Matrix34Property function to the OpenVR Library, returns them as FTransforms.
    Changed GetClosestSlotInRange to check for snap range off of relative location for the snap distance
    instead of worldspace. This way snapping ranges should be object relative regardless of scale.
    GetClosestSlotInRange is now returning a worldtransform with an identity scale instead of the default
    which contains the actor scale. This way when made relative to the object the transform will
    be correct regardless of scaling.
    Physics simulating objects now are manually scaled if Scaling_Retain secondary grip type
    is defined in their VRGripInterface, this brings them to par with non simulating objects.
    Since simulating objects are not directly moved, but rather constrained to a kinematic object
    it was nessecary to manually rescale them seperately if the grip called for it. Current implementation
    may be streamlined in the future.
    Template Gun logic for snap point location check modified to support the fact that if
    scaled now it will have a modified relative location. (Need to consider whether to support
    direct grip storage of slotted grip or to continue leaving it up to users). Original logic
    will continue to function for 1:1 scaled objects, but up/downscaled objects would need to
    If I add direct support for "was slot" I would have to add the name of the slot as well for identification.
    I don't really want to bloat the grip structures or interface structures any more than they already are.
    OpenVRCleanup pass
    Consolidated VRDeviceProperty functions (removed separate controller specific function)
    Property getting function now return execution Success or Failure instead of boolean
    Now each property getting function includes all types
    Added HMD properties
    Updated property list to new/current SteamVR values
    HMD properties are prefixed with HMD
    Controller properties are prefixed with Controller
    Set default MinNetUpdateFrequency values for all relevant in objects.
    This was required due to Net.UseAdaptiveNetUpdateFrequency being defaulted to true
    now in 4.16.
    Users will want to be sure to set these for their actors that do not derive
    from grippable ACTORS (components need their parent actor to set this)
    or turn off the CVAR.
    Defaulting to adaptive net updates being true in 4.16, it means that with default settings replicating actors and actor components can end up in the situation where they can fall behind up to 500ms before they actually update after
    a property change.
    TL;DR, SET MinNetUpdateFrequency above the default of 2 now on all of your actors that have bReplicateMovement or ANY time sensitive replications involved in them (or ForceNetUpdate on changing those).
    Made auto drops plugin wide call DropObjectByInterface instead of just drop object.
    Local only grips now replicated to non owning clients to take the workload off of the users.
    Client still has total authority over the initial grip so it is instant. Secondary grips and drops
    are also auto replicated to the server and then down to non owning clients.
    Other custom changes like offsets and grip types will have to be manually handled for Client_Authority
    (local) grips still.
    Renamed LocalOnly_Not_Replicated movement type to ClientSide_Authoritive
    Added gameplay tag interface and a gameplay tag container to each grippable component/actor, allows for extremely
    flexible object management without enforcing gameplay systems. Used in the example template
    for defining if an object drops with specific buttons and a few other things. Is an
    optional feature, you don't have to use them if you don't want.
    Now that gameplay tags are an official part of the engine they should be first class
    citizens in the plugin.
    Made Gameplay tags on grippable objects replicate with the bRepGripSettingsAndGameplayTags boolean
    Removed the ObjectType function/variable from the VRGripInterface, close to useless when
    compared to the gameplay tags, I don't know if anyone was using it anyway.
    Fixed a packaging error with the make / break functions for the Transform_NetQuantize struct.
    Added Blueprint make/break and conversion functions for the new FTransform_NetQuantize struct
    Added some utility functions GetGrippedObjects, HasGrippedObjects
    Now clamping secondary grip lerps
    Moved more of the FSavedMove logic into the base FSavedMove of BaseVRCharacterMovementComponent
    Corrected an issue where step up functions were not correctly re-winding failed stepup attempts
    causing stuttering and jitter on step up attempts in multiplayer and solo at times.
    Now using a more correct movement rewind for when the server sends location corrections to the clients
    in VR.
    Now rounding climbing movement to 2 decimal precision in multiplayer so that it matches
    the resolution that is sent to the server.
    Now using a custom quantized FTransform for the grip transforms over network.
    This transform is only 2 decimal precision so in the blueprint when checking for
    the slot grip location I am now only checking up to 2 decimals of precision for a match
    I would like to start doing the interaction settings as a quantized value as well but it was clearing
    stored values in the editor and I didn't want to ruin peoples currently working setups.
    Removed custom NetSerialize functions on all structs except for the ReplicatedPos
    struct (as that changes every send anyway and needs to full rep).
    I was unaware that setting a custom NetSerialize prevented the delta serialization of
    structs from working. After network profiling however this appears to be the case, I had assumed
    that NetSerialize covered initial and full serialization only.
    Re-worked how the OnRep of the gripped array's detects significant changes to
    a grip that require re-initilization. Now that delta is working again the
    previous array value that gets passed in is of the previous delta, not the previous array.
    Because of this I had to move to caching important values and cross checking them with the new
    replicated values instead.
    Set all grippable components back to the default of bReplicates = false. On these
    the VRGripInterfaceSettings will not replicate unless you set the component to replicate. This
    makes more sense, and the grippable actors themselves which default to bReplicates = true
    auto replicate their VRGripInterfaceSettings.
    Set position and rotation to not replicate on the VRCamera and GripMotionControllers unless
    either has changed. This doesn't do much when in VR as they pretty much always change. However
    when testing with FPS pawns this is a bandwidth savings.
    Made all grippables replicate their grip settings by default now with
    an optional boolean to turn it off.
    Tested new scaling grips in a network enviroment (mostly functional).
    Changed VRGripInterface events to better allow for c++ overrides
    (from BlueprintImplementableEvent to BlueprintNativeEvent)
    Changed secondary grip bAllowSecondaryGrip into an enum with different types (WILL REQUIRE BP CHANGES)
    + SG_None, // No secondary grips
    + SG_Free, // Can secondary grip anywhere
    + SG_SlotOnly, // Can only secondary grip at a slot
    + SG_FreeWithScaling, // With scaling
    + SG_SlotOnlyWithScaling // With scaling
    Added prelim secondary grips with scaling (needs more work, but functional).
    SlotOnly and Free types are for the users convienance for checking prior to
    calling AddSecondaryGrip. (VRTemplate updated to do this).
    Changed the build.cs to place a lot more of the Dependancy modules into
    private includes instead of public.
    Added a VRLogComponent, can be used to render to texture either the console
    or the ouput log so that they can be visible and useable in VR.
    Also contains functions for passing keyboard and command input into the console
    without a keyboard (Template now has an example of this component).
    Latest informational video

    Incomplete List Of Example Template Features
    Interactive examples of doors, drawers, levers, buttons, dials.
    Climbing system implemented for preview using custom climbing / movement mode.
    Multiple locomotion examples including: Sliding with head/controller orientation, Running In place, Armswing, Teleport, Navigation, OutOfBody Navigation, Climbing. All multiplayer compatible.
    Example of setting up the grip system in a generic way using the VRGrip Interface and Gameplay Tags so that adding new VR Interactibles is as easy as drag/drop and editing settings.
    Basic server browser example using 3d Widgets.
    Incomplete List Of Plugin Features
    Built-In Multiplayer support with custom replicating controllers / cameras / grips and the full replication capabilities of the engines base character
    Physics based grips that interact with the environment and do not clip through objects, as well as manipulation grips to interact with physics levers, doors, ect
    Climbing/Custom movement mode fully replicated with normal movement in engine, could be used for more than climbing (zip lines, directed movement, anything you can think of).
    2 Different base Character classes, VRCharacter for full bore total VR re-write of a character, and SimpleVRCharacter for a stable simple overhaul.
    Full world collision by default, follows collision channels in engine like normal, in the VRCharacter there is also the bWalkingCollisionOverride that is
    settable in order to allow free walking through objects but collision during artificial locomotion.
    AI Controller that can be applied to AI to correctly target VR characters.
    4 different network grip replication types from fully client side, to client side server authoritative to server sided only.
    Waist / Body approximation component so you can easily create inventories and bodies.
    Vive tracker support for waist / objects with late updates.
    9 Different grip types each with its own uses.
    Secondary grip support (two handed interactions) with optional lerp in / out and scaling.
    Full late update control with 5 different settings for when late updates are applied.
    VRGrip Interface - Interface with many callbacks to provide grip information, nativley supported in the plugin.
    VRGrippableObjects - Most relevant actors and components, pre-overriden in c++ with the grip interface, gameplay tags interface, and
    a structure to hold VRGripInterface options in them. Drop into the scene, set some booleans and enums, and play in VR.
    VRExpansionFunctionLibrary - Many many useful functions for VR, too many to list here
    Stereo widget support for UMG menus in stereo layers
    VR Log component for rendering Outputlog and console to textures for use in VR
    Gesture system for recording, saving, detecting and drawing / rendering gestures.
    Open VR Features (seperate module that can be turned off)
    SteamVRKeyboard support
    HMD Camera access and render to texture support.
    OpenVR Render models / custom skins support.
    OpenVR device property support
    OpenVR function library - Too many functions to list here
    Last edited by mordentral; 03-16-2018, 08:56 AM.

    Consider supporting me on patreon

    My Open source tools and plugins
    Advanced Sessions Plugin
    VR Expansion Plugin

  • #2
    Fantastic! That replication is going to make life so much easier for me.
    Gonna have to download it and give it a try!


    • #3
      Awesome work, this looks great!

      [MENTION=4285]mordentral[/MENTION] - If I wanted to use Mitch's template for the pickup system, do you think I'd be able to just replace the Attach calls with your Grip function (e.g., would replication still work there?)? I found the system in the SteamVR template that uses the GripMC to be a little cryptic in terms of being able to easily extend it and implement different sorts of items.


      As an aside, I still think it would be beneficial to change how the Lock to HMD functionality works so that it would move the *actor* itself, rather than just components attached to the camera. I looked into it and it seems like that could be done by just recalculating the camera's matrix relative to the new actor matrix and then setting it on the actor where it currently does the component-move.

      I still think only moving the components could eventually cause gameplay problems (especially in cases of larger levels, multiplayer etc.), and have seen a few posts to that effect.
      Last edited by n00854180t; 07-12-2016, 06:56 PM.
      Storyteller - An immersive VR audiobook player

      Dungeon Survival - WIP First person dungeon crawler with a focus on survival and environmental gameplay ala roguelikes


      • #4
        Originally posted by n00854180t View Post
        Awesome work, this looks great!

        [MENTION=4285]mordentral[/MENTION] - If I wanted to use Mitch's template for the pickup system, do you think I'd be able to just replace the Attach calls with your Grip function (e.g., would replication still work there?)? I found the system in the SteamVR template that uses the GripMC to be a little cryptic in terms of being able to easily extend it and implement different sorts of items.
        Yeah it shouldn't be a problem, you'd have to keep in mind that Mitch's examples use attached simulating components with max Damping to keep them relative to the controller (if interactive), this plugin uses the sweeping functions to move items manually relative to the controller instead (and sends their components to the late update function). So there would have to be "some" changes, the plugin forces simulation off when gripping an actor so a bunch of nodes could / should be skipped from his example if using the grip function. I was considering implementing AttachTo as well as an option but after playing with it I didn't like how it worked so I scrapped my plans to support it.

        In my demo project I run all of the "Character has this in his left/right hand, drop this if he picks up that, ect ect" logic in BP and just call Grip/Drop in the plugin on what I decided to do from the server. It is game logic agnostic and just handles holding and dropping and triggering OnHit events.

        The steamVR template is very WIP and I get the idea that proteus is lacking in free time at the moment. The basics of gripping an object with my plugin is fairly simple, there is a write up on the motion controller wiki page with the basics and some best practices. I would have used Epics "World/Relative/Snap" enum like in attachment but passing in actual transforms has more total flexibility.


        *Note* Attachment is already replicated by default in the engine, when you attach a component it turns off replicating movement from the server and the clients handle it from then on out (until detached). That is one of the reasons why it doesn't sweep hit events on attached actors. You don't actually have to use the grip functions at all if you don't want to, they are just my preferred way of doing it.

        I may add back in having the server manually sweep actors attached to the controllers so that OnHit events still trigger, it was originally something I had it doing but removed it when I went over to only using the grip functions.

        Originally posted by n00854180t View Post
        As an aside, I still think it would be beneficial to change how the Lock to HMD functionality works so that it would move the *actor* itself, rather than just components attached to the camera. I looked into it and it seems like that could be done by just recalculating the camera's matrix relative to the new actor matrix and then setting it on the actor where it currently does the component-move.

        I still think only moving the components could eventually cause gameplay problems (especially in cases of larger levels, multiplayer etc.), and have seen a few posts to that effect.
        It wouldn't be that difficult to create a custom pawn that samples the HMD position instead of the camera and offsets its location by the difference from the last sample point.

        The thing is that OpenVR returns the HMD location in relative space to the tracking volume you have set up so using the camera in relative space to the chaperone in the engine is a very clean solution to it as the pawn can act as the tracking space (that you move with teleport / other movement inputs) and the components as the relative location within that tracking space, you are essentially moving around the tracking volume with you.

        Do you have any quotes/links about the concerns? As I said it wouldn't be hard to implement I just don't see the point in doing so, but I would like to read about any issues that the current method presents as if they are significant enough I would have to reconsider LockToHMD. I haven't been able to think of anything that would be a problem for me so far and also haven't run into any issues with the default setup. You aren't moving component farther from the pawn itself than the size of the tracking volume in the default setup.
        Last edited by mordentral; 07-12-2016, 09:45 PM.

        Consider supporting me on patreon

        My Open source tools and plugins
        Advanced Sessions Plugin
        VR Expansion Plugin


        • #5
          Originally posted by lambomang View Post
          Fantastic! That replication is going to make life so much easier for me.
          Gonna have to download it and give it a try!
          I'm looking into smoothing replication at lower update rates by the way. I'll need to test of bunch of different rates and try some lerp/prediction tests to see what feels best and where it actually becomes a problem first. The default 100htz (matching pawn default) rate didn't need any smoothing that I could see so I left it out to get it out the door but I could see needing to add it in for 30htz or so (though it is only a per client network load and isn't that heavy).

          Consider supporting me on patreon

          My Open source tools and plugins
          Advanced Sessions Plugin
          VR Expansion Plugin


          • #6
            Hey Mordentral. Thanks for putting in the effort to make this awesome plugin! It really helps with jumping straight into VR and building stuff. I've been using your VRGrip plugin for about a month now. It helped a lot, but I have run into some issues.

            Migrating to VR Expansion Plugin
            I'm interested in migrating from your old plugin to this one, but I'm seeing some issues trying to rip out the old one and replace it with this one. I wonder if there's something simple I'm missing. Depending on how many people used your other plugin, it might be helpful to add a How-To to the readme.

            Collision Event Bug.
            I have a SphereCollision component parented under the grip controller. I'm using the begin/end overlap events on this collision to determine which object I can pick up. I'm noticing that when the grip controller is holding an object then BOTH overlap begin and end events are triggered on every tick. The events are only triggered on the colliders close to the object, but they are triggered on every tick regardless of which controller is holding the object. That is to say, if I hold an object in my right hand, then my right collider is triggered on every tick. Then if I bring my left hand close enough to my right hand, that collider is also being triggered on ever tick - even though the right hand is holding the object.

            This rapid-fire of begin/end overlap events is causing incorrect results when I poll which objects I can pickup. If I had to guess, I'd say something about the way the plugin is updating the gripped object position is causing collision events to freak out. I noticed the wiki suggests that I use a sphere trace instead of overlap events - probably for this reason. I'll use the sphere trace for now, but performing a sphere trace every tick is probably more expensive than using overlap events.

            Better Physics Behavior
            Have you read Nick Abel's article and TomorrowTodayLabs' followup on how they solved physics-based object movement in unity? It's a really interesting read, and they put their work up as a plugin for Unity called NewtonVR. Here's a sweet video from the article of the final interaction they achieved:

            Obviously their solution won't be ideal for everyone, but I do think they address a number of areas that the sweep-to method falls short in. Namely...

            Objects get caught on floor easily.

            You can't pick up objects with another object on top.

            You can't push/pull objects, and objects have no mass.

            What do you think about trying to port some of their ideas to UE4?


            • #7
              Originally posted by AssumptionSoup View Post
              Hey Mordentral.

              Being a new plugin the classes technically are considered separate from their old versions, you actually have to place them back into the pawn and re-place their functions. I decided to rename it as the old name no longer suited the project but this is a sad consequence being a one time hit of placing the nodes again.

              Overlap Triggering
              I set move ignore to the controller when gripping an object, it is possible that overlap is triggering anyway as the current movement is swept location. You can either not use overlaps or set it to ignore the channel you place the overlap on after gripping (I have a special collision channel for traces / overlaps). I also don't call traces every frame, I call it on button press, but if you are looking to highlight objects to pick up I see your point. But you can always run traces on a timer set to 30-60 htz for highlighting and call the trace on button press for the actual pick up (my voxel project does this for block highlights).

              Push / Pull
              Yes you actually can, the object has to be simulating though for it to move it, i'll agree that the interaction is less than steller currently and I am going to provide a better option for real physics. The current grip is intended just for when you don't need full physics solving on the gripped object itself as it will be cheaper. It was also the fastest one out of the gate to implement so I could look at other things.

              New Grip Styles
              I fully intend to make a better grip option using physics, I originally had AttachTo set up and ran into it not being up to what I wanted from it and removed it from the grip function. Unity's solution is effectually what I am currently doing with location but done through the physics system instead so it actually slots right in. It is next on my Trello list actually to look into it now that I have decided to throw away AttachTo (spent my free time in the last day mulling over if AttachTo was worth it and trying it out).

              I don't like the visual drag latency in how they are doing it in Unity though and am pretty sure that there is a way around it by extending my current solution and using constraints (ripping from grab handles but forcing late updates and removing the lerp). I really like the interaction in say Hand Guns, Horseshoes, and Hand Grenades but don't like that the guns themselves lag behind hand movements visually (for actual shooting location they are correct so there is something to be said for that).

              TL;DR yes all of those things bug me as well and as a user of my own plugin I am fixing them. I'll move experiments to the side for now (was playing with movement options) and just implement the new grip option instead.

              The cool thing about the plugin is when the new grip is in you'll just have to select it from the grip style drop down and it should work.

              *Edit* Oh and I was looking into both hands on the same object interactions. Eventually both options should support that as well; but I will wayside it until the new grip is in too.
              Last edited by mordentral; 07-14-2016, 08:59 AM.

              Consider supporting me on patreon

              My Open source tools and plugins
              Advanced Sessions Plugin
              VR Expansion Plugin


              • #8
                Originally posted by AssumptionSoup View Post
                Hey Mordentral.
                I actually had this done yesterday but got side tracked trying to make a hybrid system (not sure how stable I can get that one yet). It needs some going over to make sure that multiplayer works fine with the new grip style before I merge it in but I think the video is pretty much what you wanted.

                Its up to 5 grip methods now I think (6 with hybrid if it makes it), you pick what one you want per item you are picking up and how you want it to behave. When it comes out this method will have several configurable options (you probably don't notice in the video but I have the grip strength 1000x higher on my right hand than my left so it doesn't free float as much in the video).

                I'll get it pushed out to the main branch of the plugin by the end of the weekend, I was off on a tangent for awhile there experimenting with a bunch of random things (VR gets me excited) or this would have already been in.


                Consider supporting me on patreon

                My Open source tools and plugins
                Advanced Sessions Plugin
                VR Expansion Plugin


                • #9
                  Being a new plugin the classes technically are considered separate from their old versions, you actually have to place them back into the pawn and re-place their functions. I decided to rename it as the old name no longer suited the project but this is a sad consequence being a one time hit of placing the nodes again.
                  Thanks for the help. As it turns out, I had to delete the original VRGrip components before deleting the plugin, or my game would crash on load. After deleting the components, it was okay if I still had any variables with the VRGrip type (they got reset to Object). Then I just had to put the new plugin in place and run around reconnecting everything (that was less fun). Next time around, I think I'll integrate the plugin with my game via C++ so it's easier to refactor things. Blueprints makes refactors surprisingly hard with it's propensity to disconnect nodes! And speaking of C++, I don't know if you intended the plugin to be using in C++ or not. I'm definitely a noob at both C++ and Unreal, but it looks like the plugin classes are missing the VREXPANSIONPLUGIN_API (macro? keyword?) in order to be exposed to game logic. I can send a pull request that adds this if you're interested.

                  Overlap Triggering
                  I set move ignore to the controller when gripping an object, it is possible that overlap is triggering anyway as the current movement is swept location. You can either not use overlaps or set it to ignore the channel you place the overlap on after gripping (I have a special collision channel for traces / overlaps). I also don't call traces every frame, I call it on button press, but if you are looking to highlight objects to pick up I see your point. But you can always run traces on a timer set to 30-60 htz for highlighting and call the trace on button press for the actual pick up (my voxel project does this for block highlights).
                  You're correct, I'm using it for highlighting. I forgot to mention that in my original post. I'll have to play around with running my traces on a slower frequency, that's a good idea! I'm a little worried that there will be a disconnect between the feedback the user sees and the action that occurs - but I won't know how bad it is without testing.

                  I don't like the visual drag latency in how they are doing it in Unity though and am pretty sure that there is a way around it by extending my current solution and using constraints (ripping from grab handles but forcing late updates and removing the lerp). I really like the interaction in say Hand Guns, Horseshoes, and Hand Grenades but don't like that the guns themselves lag behind hand movements visually (for actual shooting location they are correct so there is something to be said for that).
                  I totally agree. I think having really good physics interaction is worth the trade off of having some latency on gripped objects, but it's definitely not a compromise I'd like to make if I don't have to.

                  I actually had this done yesterday but got side tracked trying to make a hybrid system ...
                  Oh man, this looks super awesome!! Yeah, it looks like most of the things I was interested in. I can't wait!


                  • #10
                    Yeah I forgot the macro on the classes, I'll add it in to them today.

                    Consider supporting me on patreon

                    My Open source tools and plugins
                    Advanced Sessions Plugin
                    VR Expansion Plugin


                    • #11
                      Merged the physics grip branch into main, it needs more play time to lock down bugs but was working for me during initial multiplayer testing (don't forget to replicate movement on physics objects so they stay sync'd). The hybrid setup "works" but needs to be finished still.

                      InteractivePhysicsGrip is the style you were looking for, it also adds two properties to the motion controllers for Stiffness and Damping when holding physics simulating objects, I may break that out into a object by object basis later.

                      There are also a few new functions and features, i'll document them tomorrow.
                      Last edited by mordentral; 07-17-2016, 10:38 PM.

                      Consider supporting me on patreon

                      My Open source tools and plugins
                      Advanced Sessions Plugin
                      VR Expansion Plugin


                      • #12
                        Would any of the exposed OpenVR functions be able to return what kind of HMD is in use? Rift/Vive/OSVR. I need to change player class since the haptic events are very different on Vive vs Rift.


                        • #13
                          Originally posted by Fantasifall View Post
                          Would any of the exposed OpenVR functions be able to return what kind of HMD is in use? Rift/Vive/OSVR. I need to change player class since the haptic events are very different on Vive vs Rift.
                          I think someone requested of Rama to have his library include that function. It is already in GEngine so I will throw it in anyway since it makes sense and is easy, but if you don't intend to use the rest of my plugin and already use Rama's library then you should be able to find it there.

                          Regardless I'll have it in this by the end of the day (have to push out some cleanup for things anyway later).

                          *Edit* Pushed the new function early as the rest of my work today will be on a new branch

                          GetHMDType - static
                          Last edited by mordentral; 07-18-2016, 11:49 AM.

                          Consider supporting me on patreon

                          My Open source tools and plugins
                          Advanced Sessions Plugin
                          VR Expansion Plugin


                          • #14
                            Oh my, this Plugin couldn't have come at a better time. Literally just spent this last weekend testing my Vive game with some friends, and one of the biggest issues was the grabbing system I had made. My solution, using merely the built in blueprint functions was to turn off gravity on grabbed components. This wasn't the ideal solution but it worked for the most part. That said it seems this plugin gives far better control and I hope to implement it.

                            Could you by chance give some insight into the setup of the "New grip style" video? I've got a line trace on the controller trigger, then checking my grabbed object and then calling grip actor from your plugin, but it seems to go a bit crazy once attached. Will have a further tinker, but this does look promising. Great work!

                            Default Interactive

                            A Skip And A Hop Too Far Into Light Speed


                            • #15
                              Thank you so much for the HMD type! This makes my life so much easier. However, ParentRelativeAttachmentComponent does not seem to work at all. I looked at the code and it seems like it should but all that's happening is occasionally, there will be an offset of the child component of the ParentRelativeAttachmentComponent. It just sticks at an odd rotation, and keeps following the HMD rot at that offset rotation 1 to 1. I tried with both Static and Skeletal meshes, and tried yaw values between 1-3 as well as much higher, locked on pitch and roll.