VRCharacterMovementComponent.h

Go to the documentation of this file.

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "CoreMinimal.h"
#include "AI/Navigation/NavigationAvoidanceTypes.h"
#include "AI/RVOAvoidanceInterface.h"
#include "AITypes.h"
#include "VRRootComponent.h"
#include "Navigation/PathFollowingComponent.h"
#include "AI/Navigation/NavigationTypes.h"
//#include "AI/Navigation/NavigationSystem.h"
#include "Animation/AnimationAsset.h"
#include "Engine/EngineBaseTypes.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/PawnMovementComponent.h"
#include "Interfaces/NetworkPredictionInterface.h"
#include "WorldCollision.h"
#include "Runtime/Launch/Resources/Version.h"
#include "VRBaseCharacterMovementComponent.h"
#include "GameFramework/CharacterMovementReplication.h"
#include "VRCharacterMovementComponent.generated.h"
 
class FDebugDisplayInfo;
class ACharacter;
class AVRCharacter;
 
DECLARE_LOG_CATEGORY_EXTERN(LogVRCharacterMovement, Log, All);
 
//typedef TSharedPtr<class FSavedMove_Character> FSavedMovePtr;
 
 
 
//FCharacterMoveResponseDataContainer VRMoveResponseDataContainer;
 
 
//=============================================================================
//DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FAIMoveCompletedSignature, FAIRequestID, RequestID, EPathFollowingResult::Type, Result);
 
UCLASS()
class VREXPANSIONPLUGIN_API UVRCharacterMovementComponent : public UVRBaseCharacterMovementComponent
{
    GENERATED_BODY()
public:
 
    UPROPERTY(BlueprintReadOnly, Transient, Category = VRMovement)
    UVRRootComponent * VRRootCapsule;
 
    static const float CLIMB_SWEEP_EDGE_REJECT_DISTANCE;
    virtual bool IsWithinClimbingEdgeTolerance(const FVector& CapsuleLocation, const FVector& TestImpactPoint, const float CapsuleRadius) const;
    virtual bool VRClimbStepUp(const FVector& GravDir, const FVector& Delta, const FHitResult &InHit, FStepDownResult* OutStepDownResult = nullptr) override;
 
    virtual bool IsWithinEdgeTolerance(const FVector& CapsuleLocation, const FVector& TestImpactPoint, const float CapsuleRadius) const override;
 
    // Allow merging movement replication (may cause issues when >10 players due to capsule location
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "VRCharacterMovementComponent")
        bool bAllowMovementMerging;
 
    // If true we will run client corrections off of the HMD location instead of actor, this is a settable value to allow backwards compatibility
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "VRCharacterMovementComponent")
        bool bRunClientCorrectionToHMD;
 
    // Higher values will cause more slide but better step up
    //UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "VRCharacterMovementComponent", meta = (ClampMin = "0.01", UIMin = "0", ClampMax = "1.0", UIMax = "1"))
    //float WallRepulsionMultiplier;
 
    virtual void Crouch(bool bClientSimulation = false) override;
 
    virtual void UnCrouch(bool bClientSimulation = false) override;
 
    //virtual bool CanCrouchInCurrentState() const;
 
    // Navigation Functions
 
    //UPROPERTY(BlueprintAssignable, meta = (DisplayName = "MoveCompleted"))
    //FAIMoveCompletedSignature ReceiveMoveCompleted;
 
    virtual FBasedPosition GetActorFeetLocationBased() const override;
 
    virtual bool TryToLeaveNavWalking() override;
    
    
    virtual void PhysNavWalking(float deltaTime, int32 Iterations) override;
    virtual void ProcessLanded(const FHitResult& Hit, float remainingTime, int32 Iterations) override;
 
    void PostPhysicsTickComponent(float DeltaTime, FCharacterMovementComponentPostPhysicsTickFunction& ThisTickFunction) override;
    void SimulateMovement(float DeltaSeconds) override;
    void MoveSmooth(const FVector& InVelocity, const float DeltaSeconds, FStepDownResult* OutStepDownResult) override;
    //void PerformMovement(float DeltaSeconds) override;
 
    // End Navigation Functions
    
 
    // Client adjustment overrides to allow for rotation
 
    virtual void ClientHandleMoveResponse(const FCharacterMoveResponseDataContainer& MoveResponse) override;
 
    //virtual void SendClientAdjustment() override;
    virtual void ServerMoveHandleClientErrorVR(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& RelativeClientLocation, float ClientYaw, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    virtual bool ServerCheckClientErrorVR(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& ClientWorldLocation, float ClientYaw, const FVector& RelativeClientLocation, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    virtual void ClientAdjustPositionVR_Implementation(float TimeStamp, FVector NewLoc, uint16 NewYaw, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
 
    // Replication Functions
 
    // Network RPCs for movement
 
    // Using my own as I don't want to cast the standard fsavedmove
    //virtual void CallServerMove(const class FSavedMove_Character* NewMove, const class FSavedMove_Character* OldMove) override;
 
    virtual void ServerMove_PerformMovement(const FCharacterNetworkMoveData& MoveData) override;
 
    FNetworkPredictionData_Client* GetPredictionData_Client() const override;
    FNetworkPredictionData_Server* GetPredictionData_Server() const override;
 
    // End Replication Functions
 
    UVRCharacterMovementComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
    virtual void OnRegister() override;
 
    float ImmersionDepth() const override;
    bool CanCrouch();
 
    // Don't really need to override this at all, it doesn't work that well even when fixed in VR
    //void VisualizeMovement() const override;
 
 
    /*
    bool HasRootMotion() const
    {
        return RootMotionParams.bHasRootMotion;
    }*/
 
    // Had to modify this, since every frame can start in penetration (capsule component moves into wall before movement tick)
    // It was throwing out the initial hit and not calling "step up", now I am only checking for penetration after adjustment but keeping the initial hit for step up.
    // this makes for FAR more responsive step ups.
    // I WILL need to override these for flying / swimming as well
    bool SafeMoveUpdatedComponent(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport = ETeleportType::None);
    bool SafeMoveUpdatedComponent(const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport = ETeleportType::None);
    
    // This is here to force it to call the correct SafeMoveUpdatedComponent functions for floor movement
    virtual void MoveAlongFloor(const FVector& InVelocity, float DeltaSeconds, FStepDownResult* OutStepDownResult) override;
 
    // Modify for correct location
    virtual void ApplyRepulsionForce(float DeltaSeconds) override;
 
    // Update BaseOffset to be zero
    virtual void UpdateBasedMovement(float DeltaSeconds) override;
 
    // Stop subtracting the capsules half height
    virtual FVector GetImpartedMovementBaseVelocity() const override;
 
    // Cheating at the relative collision detection
    void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction);
 
    // Need to fill our capsule component variable here and override the default tick ordering
    virtual void SetUpdatedComponent(USceneComponent* NewUpdatedComponent) override;
 
    // Correct an offset sweep test
    virtual void ReplicateMoveToServer(float DeltaTime, const FVector& NewAcceleration) override;
 
    // Always called with the capsulecomponent location, no idea why it doesn't just get it inside it already
    // Had to force it within the function to use VRLocation instead.
    virtual void FindFloor(const FVector& CapsuleLocation, FFindFloorResult& OutFloorResult, bool bCanUseCachedLocation, const FHitResult* DownwardSweepResult = NULL) const;
 
    // Need to use actual capsule location for step up
    bool StepUp(const FVector& GravDir, const FVector& Delta, const FHitResult &InHit, FStepDownResult* OutStepDownResult = NULL) override;
 
    virtual FVector GetPenetrationAdjustment(const FHitResult& Hit) const override;
 
    // MOVED THIS TO THE BASE VR CHARACTER MOVEMENT COMPONENT
    // Also added a control variable for it there
    // Skip physics channels when looking for floor
    /*virtual bool FloorSweepTest(
        FHitResult& OutHit,
        const FVector& Start,
        const FVector& End,
        ECollisionChannel TraceChannel,
        const struct FCollisionShape& CollisionShape,
        const struct FCollisionQueryParams& Params,
        const struct FCollisionResponseParams& ResponseParam
        ) const override;*/
 
    // Multiple changes to support relative motion and ledge sweeps
    virtual void PhysWalking(float deltaTime, int32 Iterations) override;
 
    // Supporting the direct move injection
    virtual void PhysFlying(float deltaTime, int32 Iterations) override;
    
    // Need to use VR location, was defaulting to actor
    virtual bool ShouldCheckForValidLandingSpot(float DeltaTime, const FVector& Delta, const FHitResult& Hit) const override;
 
    // Overriding the physfalling because valid landing spots were computed incorrectly.
    virtual void PhysFalling(float deltaTime, int32 Iterations) override;
 
    virtual void PhysSwimming(float deltaTime, int32 Iterations) override;
    void StartSwimmingVR(FVector OldLocation, FVector OldVelocity, float timeTick, float remainingTime, int32 Iterations);
 
    /* Swimming uses gravity - but scaled by (1.f - buoyancy) */
    float SwimVR(FVector Delta, FHitResult& Hit);
 
    virtual bool CheckWaterJump(FVector CheckPoint, FVector& WallNormal) override;
 
    // Shouldn't need to override this
    //FVector FindWaterLine(FVector Start, FVector End) override;
 
    // Just calls find floor
    //virtual bool IsValidLandingSpot(const FVector& CapsuleLocation, const FHitResult& Hit) const override;
 
    // Making sure that impulses are correct
    virtual void CapsuleTouched(UPrimitiveComponent* OverlappedComp, AActor* Other, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult) override;
    virtual void StoreSetTrackingPaused(bool bNewTrackingPaused) override;
};
 
 
class VREXPANSIONPLUGIN_API FSavedMove_VRCharacter : public FSavedMove_VRBaseCharacter
{
 
public:
 
    virtual void SetInitialPosition(ACharacter* C);
    virtual void PrepMoveFor(ACharacter* Character) override;
 
    FSavedMove_VRCharacter() : FSavedMove_VRBaseCharacter()
    {}
 
};
 
// Need this for capsule location replication
class VREXPANSIONPLUGIN_API FNetworkPredictionData_Client_VRCharacter : public FNetworkPredictionData_Client_Character
{
public:
    FNetworkPredictionData_Client_VRCharacter(const UCharacterMovementComponent& ClientMovement)
        : FNetworkPredictionData_Client_Character(ClientMovement)
    {
 
    }
 
    FSavedMovePtr AllocateNewMove()
    {
        return FSavedMovePtr(new FSavedMove_VRCharacter());
    }
};
 
 
// Need this for capsule location replication?????
class VREXPANSIONPLUGIN_API FNetworkPredictionData_Server_VRCharacter : public FNetworkPredictionData_Server_Character
{
public:
    FNetworkPredictionData_Server_VRCharacter(const UCharacterMovementComponent& ClientMovement)
        : FNetworkPredictionData_Server_Character(ClientMovement)
    {
 
    }
 
    FSavedMovePtr AllocateNewMove()
    {
        return FSavedMovePtr(new FSavedMove_VRCharacter());
    }
};