GrippableStaticMeshComponent.cpp

Go to the documentation of this file.

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
 
#include "Grippables/GrippableStaticMeshComponent.h"
#include "Net/UnrealNetwork.h"
 
  //=============================================================================
UGrippableStaticMeshComponent::UGrippableStaticMeshComponent(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    VRGripInterfaceSettings.bDenyGripping = false;
    VRGripInterfaceSettings.OnTeleportBehavior = EGripInterfaceTeleportBehavior::DropOnTeleport;
    VRGripInterfaceSettings.bSimulateOnDrop = true;
    VRGripInterfaceSettings.SlotDefaultGripType = EGripCollisionType::ManipulationGrip;
    VRGripInterfaceSettings.FreeDefaultGripType = EGripCollisionType::ManipulationGrip;
    VRGripInterfaceSettings.SecondaryGripType = ESecondaryGripType::SG_None;
    VRGripInterfaceSettings.MovementReplicationType = EGripMovementReplicationSettings::ForceClientSideMovement;
    VRGripInterfaceSettings.LateUpdateSetting = EGripLateUpdateSettings::LateUpdatesAlwaysOff;
    VRGripInterfaceSettings.ConstraintStiffness = 1500.0f;
    VRGripInterfaceSettings.ConstraintDamping = 200.0f;
    VRGripInterfaceSettings.ConstraintBreakDistance = 100.0f;
    VRGripInterfaceSettings.SecondarySlotRange = 20.0f;
    VRGripInterfaceSettings.PrimarySlotRange = 20.0f;
 
    VRGripInterfaceSettings.bIsHeld = false;
 
    bReplicateMovement = false;
    //this->bReplicates = true;
 
    bRepGripSettingsAndGameplayTags = true;
    bReplicateGripScripts = false;
}
 
void UGrippableStaticMeshComponent::GetLifetimeReplicatedProps(TArray< class FLifetimeProperty > & OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
    
    DOREPLIFETIME_CONDITION(UGrippableStaticMeshComponent, GripLogicScripts, COND_Custom);
    DOREPLIFETIME(UGrippableStaticMeshComponent, bReplicateGripScripts);
    DOREPLIFETIME(UGrippableStaticMeshComponent, bRepGripSettingsAndGameplayTags);
    DOREPLIFETIME(UGrippableStaticMeshComponent, bReplicateMovement);
    DOREPLIFETIME_CONDITION(UGrippableStaticMeshComponent, VRGripInterfaceSettings, COND_Custom);
    DOREPLIFETIME_CONDITION(UGrippableStaticMeshComponent, GameplayTags, COND_Custom);
}
 
void UGrippableStaticMeshComponent::PreReplication(IRepChangedPropertyTracker & ChangedPropertyTracker)
{
    Super::PreReplication(ChangedPropertyTracker);
 
    // Don't replicate if set to not do it
    DOREPLIFETIME_ACTIVE_OVERRIDE(UGrippableStaticMeshComponent, VRGripInterfaceSettings, bRepGripSettingsAndGameplayTags);
    DOREPLIFETIME_ACTIVE_OVERRIDE(UGrippableStaticMeshComponent, GameplayTags, bRepGripSettingsAndGameplayTags);
    DOREPLIFETIME_ACTIVE_OVERRIDE(UGrippableStaticMeshComponent, GripLogicScripts, bReplicateGripScripts);
 
    DOREPLIFETIME_ACTIVE_OVERRIDE_PRIVATE_PROPERTY(USceneComponent, RelativeLocation, bReplicateMovement);
    DOREPLIFETIME_ACTIVE_OVERRIDE_PRIVATE_PROPERTY(USceneComponent, RelativeRotation, bReplicateMovement);
    DOREPLIFETIME_ACTIVE_OVERRIDE_PRIVATE_PROPERTY(USceneComponent, RelativeScale3D, bReplicateMovement);
}
 
bool UGrippableStaticMeshComponent::ReplicateSubobjects(UActorChannel* Channel, class FOutBunch *Bunch, FReplicationFlags *RepFlags)
{
    bool WroteSomething = Super::ReplicateSubobjects(Channel, Bunch, RepFlags);
 
    if (bReplicateGripScripts)
    {
        for (UVRGripScriptBase* Script : GripLogicScripts)
        {
            if (Script && !Script->IsPendingKill())
            {
                WroteSomething |= Channel->ReplicateSubobject(Script, *Bunch, *RepFlags);
            }
        }
    }
 
    return WroteSomething;
}
 
//=============================================================================
UGrippableStaticMeshComponent::~UGrippableStaticMeshComponent()
{
}
 
void UGrippableStaticMeshComponent::BeginPlay()
{
    // Call the base class 
    Super::BeginPlay();
 
    // Call all grip scripts begin play events so they can perform any needed logic
    for (UVRGripScriptBase* Script : GripLogicScripts)
    {
        if (Script)
        {
            Script->BeginPlay(this);
        }
    }
 
    bOriginalReplicatesMovement = bReplicateMovement;
}
 
void UGrippableStaticMeshComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    // Call the base class 
    Super::EndPlay(EndPlayReason);
 
    // Call all grip scripts begin play events so they can perform any needed logic
    for (UVRGripScriptBase* Script : GripLogicScripts)
    {
        if (Script)
        {
            Script->EndPlay(EndPlayReason);
        }
    }
}
 
void UGrippableStaticMeshComponent::SetDenyGripping(bool bDenyGripping)
{
    VRGripInterfaceSettings.bDenyGripping = bDenyGripping;
}
 
void UGrippableStaticMeshComponent::SetGripPriority(int NewGripPriority)
{
    VRGripInterfaceSettings.AdvancedGripSettings.GripPriority = NewGripPriority;
}
 
void UGrippableStaticMeshComponent::TickGrip_Implementation(UGripMotionControllerComponent * GrippingController, const FBPActorGripInformation & GripInformation, float DeltaTime) {}
void UGrippableStaticMeshComponent::OnGrip_Implementation(UGripMotionControllerComponent* GrippingController, const FBPActorGripInformation& GripInformation) { }
void UGrippableStaticMeshComponent::OnGripRelease_Implementation(UGripMotionControllerComponent* ReleasingController, const FBPActorGripInformation& GripInformation, bool bWasSocketed) { }
void UGrippableStaticMeshComponent::OnChildGrip_Implementation(UGripMotionControllerComponent* GrippingController, const FBPActorGripInformation& GripInformation) {}
void UGrippableStaticMeshComponent::OnChildGripRelease_Implementation(UGripMotionControllerComponent* ReleasingController, const FBPActorGripInformation& GripInformation, bool bWasSocketed) {}
void UGrippableStaticMeshComponent::OnSecondaryGrip_Implementation(UGripMotionControllerComponent* GripOwningController, USceneComponent* SecondaryGripComponent, const FBPActorGripInformation& GripInformation) { OnSecondaryGripAdded.Broadcast(GripOwningController, GripInformation); }
void UGrippableStaticMeshComponent::OnSecondaryGripRelease_Implementation(UGripMotionControllerComponent* GripOwningController, USceneComponent* ReleasingSecondaryGripComponent, const FBPActorGripInformation& GripInformation) { OnSecondaryGripRemoved.Broadcast(GripOwningController, GripInformation); }
void UGrippableStaticMeshComponent::OnUsed_Implementation() {}
void UGrippableStaticMeshComponent::OnEndUsed_Implementation() {}
void UGrippableStaticMeshComponent::OnSecondaryUsed_Implementation() {}
void UGrippableStaticMeshComponent::OnEndSecondaryUsed_Implementation() {}
void UGrippableStaticMeshComponent::OnInput_Implementation(FKey Key, EInputEvent KeyEvent) {}
bool UGrippableStaticMeshComponent::RequestsSocketing_Implementation(USceneComponent *& ParentToSocketTo, FName & OptionalSocketName, FTransform_NetQuantize & RelativeTransform) { return false; }
 
bool UGrippableStaticMeshComponent::DenyGripping_Implementation(UGripMotionControllerComponent * GripInitiator)
{
    return VRGripInterfaceSettings.bDenyGripping;
}
 
EGripInterfaceTeleportBehavior UGrippableStaticMeshComponent::TeleportBehavior_Implementation()
{
    return VRGripInterfaceSettings.OnTeleportBehavior;
}
 
bool UGrippableStaticMeshComponent::SimulateOnDrop_Implementation()
{
    return VRGripInterfaceSettings.bSimulateOnDrop;
}
 
EGripCollisionType UGrippableStaticMeshComponent::GetPrimaryGripType_Implementation(bool bIsSlot)
{
    return bIsSlot ? VRGripInterfaceSettings.SlotDefaultGripType : VRGripInterfaceSettings.FreeDefaultGripType;
}
 
ESecondaryGripType UGrippableStaticMeshComponent::SecondaryGripType_Implementation()
{
    return VRGripInterfaceSettings.SecondaryGripType;
}
 
EGripMovementReplicationSettings UGrippableStaticMeshComponent::GripMovementReplicationType_Implementation()
{
    return VRGripInterfaceSettings.MovementReplicationType;
}
 
EGripLateUpdateSettings UGrippableStaticMeshComponent::GripLateUpdateSetting_Implementation()
{
    return VRGripInterfaceSettings.LateUpdateSetting;
}
 
void UGrippableStaticMeshComponent::GetGripStiffnessAndDamping_Implementation(float &GripStiffnessOut, float &GripDampingOut)
{
    GripStiffnessOut = VRGripInterfaceSettings.ConstraintStiffness;
    GripDampingOut = VRGripInterfaceSettings.ConstraintDamping;
}
 
FBPAdvGripSettings UGrippableStaticMeshComponent::AdvancedGripSettings_Implementation()
{
    return VRGripInterfaceSettings.AdvancedGripSettings;
}
 
float UGrippableStaticMeshComponent::GripBreakDistance_Implementation()
{
    return VRGripInterfaceSettings.ConstraintBreakDistance;
}
 
void UGrippableStaticMeshComponent::ClosestGripSlotInRange_Implementation(FVector WorldLocation, bool bSecondarySlot, bool & bHadSlotInRange, FTransform & SlotWorldTransform, FName & SlotName, UGripMotionControllerComponent * CallingController, FName OverridePrefix)
{
    if (OverridePrefix.IsNone())
        bSecondarySlot ? OverridePrefix = "VRGripS" : OverridePrefix = "VRGripP";
 
    UVRExpansionFunctionLibrary::GetGripSlotInRangeByTypeName_Component(OverridePrefix, this, WorldLocation, bSecondarySlot ? VRGripInterfaceSettings.SecondarySlotRange : VRGripInterfaceSettings.PrimarySlotRange, bHadSlotInRange, SlotWorldTransform, SlotName, CallingController);
}
 
bool UGrippableStaticMeshComponent::AllowsMultipleGrips_Implementation()
{
    return VRGripInterfaceSettings.bAllowMultipleGrips;
}
 
void UGrippableStaticMeshComponent::IsHeld_Implementation(TArray<FBPGripPair> & HoldingControllers, bool & bIsHeld)
{
    HoldingControllers = VRGripInterfaceSettings.HoldingControllers;
    bIsHeld = VRGripInterfaceSettings.bIsHeld;
}
 
void UGrippableStaticMeshComponent::Native_NotifyThrowGripDelegates(UGripMotionControllerComponent* Controller, bool bGripped, const FBPActorGripInformation& GripInformation, bool bWasSocketed)
{
    if (bGripped)
    {
        OnGripped.Broadcast(Controller, GripInformation);
    }
    else
    {
        OnDropped.Broadcast(Controller, GripInformation, bWasSocketed);
    }
}
 
void UGrippableStaticMeshComponent::SetHeld_Implementation(UGripMotionControllerComponent * HoldingController, uint8 GripID, bool bIsHeld)
{
    if (bIsHeld)
    {
        if (VRGripInterfaceSettings.MovementReplicationType != EGripMovementReplicationSettings::ForceServerSideMovement)
        {
            if (!VRGripInterfaceSettings.bIsHeld)
                bOriginalReplicatesMovement = bReplicateMovement;
            bReplicateMovement = false;
        }
 
        VRGripInterfaceSettings.bWasHeld = true;
        VRGripInterfaceSettings.HoldingControllers.AddUnique(FBPGripPair(HoldingController, GripID));
    }
    else
    {
        if (VRGripInterfaceSettings.MovementReplicationType != EGripMovementReplicationSettings::ForceServerSideMovement)
        {
            bReplicateMovement = bOriginalReplicatesMovement;
        }
 
        VRGripInterfaceSettings.HoldingControllers.Remove(FBPGripPair(HoldingController, GripID));
    }
 
    VRGripInterfaceSettings.bIsHeld = VRGripInterfaceSettings.HoldingControllers.Num() > 0;
}
 
bool UGrippableStaticMeshComponent::GetGripScripts_Implementation(TArray<UVRGripScriptBase*> & ArrayReference)
{
    ArrayReference = GripLogicScripts;
    return GripLogicScripts.Num() > 0;
}
 
void UGrippableStaticMeshComponent::PreDestroyFromReplication()
{
    Super::PreDestroyFromReplication();
 
    // Destroy any sub-objects we created
    for (int32 i = 0; i < GripLogicScripts.Num(); ++i)
    {
        if (UObject *SubObject = GripLogicScripts[i])
        {
            SubObject->PreDestroyFromReplication();
            SubObject->MarkPendingKill();
        }
    }
 
    GripLogicScripts.Empty();
}
 
void UGrippableStaticMeshComponent::GetSubobjectsWithStableNamesForNetworking(TArray<UObject*> &ObjList)
{
    if (bReplicateGripScripts)
    {
        for (int32 i = 0; i < GripLogicScripts.Num(); ++i)
        {
            if (UObject* SubObject = GripLogicScripts[i])
            {
                ObjList.Add(SubObject);
            }
        }
    }
}
 
void UGrippableStaticMeshComponent::OnComponentDestroyed(bool bDestroyingHierarchy)
{
    // Call the super at the end, after we've done what we needed to do
    Super::OnComponentDestroyed(bDestroyingHierarchy);
 
    // Don't set these in editor preview window and the like, it causes saving issues
    if (UWorld * World = GetWorld())
    {
        EWorldType::Type WorldType = World->WorldType;
        if (WorldType == EWorldType::Editor || WorldType == EWorldType::EditorPreview)
        {
            return;
        }
    }
 
    for (int32 i = 0; i < GripLogicScripts.Num(); i++)
    {
        if (UObject *SubObject = GripLogicScripts[i])
        {
            SubObject->MarkPendingKill();
        }
    }
 
    GripLogicScripts.Empty();
}