void ACinemotusPlayerController::AbsoluteTick(float DeltaTime)
{
TotalYawAbs += addYaw;
UPrimitiveComponent* prim = GetPawn()->GetMovementComponent()->UpdatedComponent;
//USceneComponent* sComponent = GetPawn()->GetRootComponent();
//sComponent->SetRelativeLocation;
bool SetPrimDirectly = true;
FQuat finalQuat;
if (((currentCaptureState&ECinemotusCaptureState::EAbsolute) == ECinemotusCaptureState::EAbsolute) &&
((currentCaptureState&ECinemotusCaptureState::EAbsoluteOff) == 0))
{
finalQuat = FRotator(0, TotalYawAbs, 0).Quaternion()*(HydraLatestData->controllers[CAM_HAND].quat);
}
else
{
finalQuat = FRotator(0, addYaw, 0).Quaternion()*prim->GetComponentQuat();
}
SetControlRotation(finalQuat.Rotator());
if (SetPrimDirectly && prim)
{
prim->SetWorldLocationAndRotation(prim->GetComponentLocation(), finalQuat);// not sure need
}
HandleMovementAbs(DeltaTime, ((currentCaptureState&ECinemotusCaptureState::EAbsolute) == ECinemotusCaptureState::EAbsolute));
}
void AActor::GatherCurrentMovement()
{
UPrimitiveComponent* RootPrimComp = Cast<UPrimitiveComponent>(GetRootComponent());
if (RootPrimComp && RootPrimComp->IsSimulatingPhysics())
{
FRigidBodyState RBState;
RootPrimComp->GetRigidBodyState(RBState);
ReplicatedMovement.FillFrom(RBState);
}
else if(RootComponent != NULL)
{
// If we are attached, don't replicate absolute position
if( RootComponent->AttachParent != NULL )
{
// Networking for attachments assumes the RootComponent of the AttachParent actor.
// If that's not the case, we can't update this, as the client wouldn't be able to resolve the Component and would detach as a result.
if( AttachmentReplication.AttachParent != NULL )
{
AttachmentReplication.LocationOffset = RootComponent->RelativeLocation;
AttachmentReplication.RotationOffset = RootComponent->RelativeRotation;
AttachmentReplication.RelativeScale3D = RootComponent->RelativeScale3D;
}
}
else
{
ReplicatedMovement.Location = RootComponent->GetComponentLocation();
ReplicatedMovement.Rotation = RootComponent->GetComponentRotation();
ReplicatedMovement.LinearVelocity = GetVelocity();
ReplicatedMovement.bRepPhysics = false;
}
}
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext(const TArray<AActor*>& InParentActors)
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
// Detach only actor components that are children of the actors list provided
for(TObjectIterator<UActorComponent> ComponentIt;ComponentIt;++ComponentIt)
{
bool bShouldReregister=false;
UPrimitiveComponent* PrimitiveComponent = Cast<UPrimitiveComponent>(*ComponentIt);
if (PrimitiveComponent && PrimitiveComponent->ReplacementPrimitive.Get())
{
UPrimitiveComponent* ReplacementPrimitive = PrimitiveComponent->ReplacementPrimitive.Get();
AActor* ParentActor = Cast<AActor>(ReplacementPrimitive->GetOuter());
if (ParentActor && InParentActors.Contains(ParentActor))
{
bShouldReregister = true;
}
}
if( bShouldReregister )
{
new(ComponentContexts) FComponentReregisterContext(*ComponentIt);
}
}
}
void UUnrealEdEngine::SetActorSelectionFlags (AActor* InActor)
{
TInlineComponentArray<UActorComponent*> Components;
InActor->GetComponents(Components);
//for every component in the actor
for(int32 ComponentIndex = 0; ComponentIndex < Components.Num(); ComponentIndex++)
{
UActorComponent* Component = Components[ComponentIndex];
if (Component->IsRegistered())
{
// If we have a 'child actor' component, want to update its visible selection state
UChildActorComponent* ChildActorComponent = Cast<UChildActorComponent>(Component);
if(ChildActorComponent != NULL && ChildActorComponent->ChildActor != NULL)
{
SetActorSelectionFlags(ChildActorComponent->ChildActor);
}
UPrimitiveComponent* PrimComponent = Cast<UPrimitiveComponent>(Component);
if(PrimComponent != NULL && PrimComponent->IsRegistered())
{
PrimComponent->PushSelectionToProxy();
}
UDecalComponent* DecalComponent = Cast<UDecalComponent>(Component);
if(DecalComponent != NULL)// && DecalComponent->IsRegistered())
{
DecalComponent->PushSelectionToProxy();
}
}
}
}
void FBodyInstance2D::TermBody()
{
#if WITH_BOX2D
UPrimitiveComponent* OwnerComponent = OwnerComponentPtr.Get();
//@TODO: Handle this - check(OwnerComponent);
if (OwnerComponent == NULL)
{
return;
}
if (BodyInstancePtr != NULL)
{
if (b2World* World = FPhysicsIntegration2D::FindAssociatedWorld(OwnerComponent->GetWorld()))
{
World->DestroyBody(BodyInstancePtr);
}
else
{
BodyInstancePtr->SetUserData(NULL);
}
BodyInstancePtr = NULL;
}
#endif
}
void UBuoyancyForceComponent::InitializeComponent()
{
Super::InitializeComponent();
//UE_LOG(LogTemp, Warning, TEXT("We're initializing..."));
//Store the world ref.
World = GetWorld();
// If no OceanManager is defined, auto-detect
if (!OceanManager)
{
for (TActorIterator<AOceanManager> ActorItr(World); ActorItr; ++ActorItr)
{
OceanManager = Cast<AOceanManager>(*ActorItr);
break;
}
}
TestPointRadius = FMath::Abs(TestPointRadius);
UPrimitiveComponent* BasePrimComp = Cast<UPrimitiveComponent>(GetAttachParent());
if (BasePrimComp)
{
ApplyUprightConstraint(BasePrimComp);
//Store the initial damping values.
_baseLinearDamping = BasePrimComp->GetLinearDamping();
_baseAngularDamping = BasePrimComp->GetAngularDamping();
}
}
FText FPrimitiveComponentDetails::OnGetBodyMass() const
{
UPrimitiveComponent* Comp = NULL;
float Mass = 0.0f;
bool bMultipleValue = false;
for (auto ObjectIt = ObjectsCustomized.CreateConstIterator(); ObjectIt; ++ObjectIt)
{
if(ObjectIt->IsValid() && (*ObjectIt)->IsA(UPrimitiveComponent::StaticClass()))
{
Comp = Cast<UPrimitiveComponent>(ObjectIt->Get());
float CompMass = Comp->CalculateMass();
if (Mass == 0.0f || FMath::Abs(Mass - CompMass) < 0.1f)
{
Mass = CompMass;
}
else
{
bMultipleValue = true;
break;
}
}
}
if (bMultipleValue)
{
return LOCTEXT("MultipleValues", "Multiple Values");
}
return FText::AsNumber(Mass);
}
/** This occurs when play begins */
void AMagicBattleSoccerBall::BeginPlay()
{
Super::BeginPlay();
if (Role < ROLE_Authority)
{
// The server manages the game state; the soccer ball will be replicated to us.
// Physics however are not replicated. We will need to have the ball orientation
// replicated to us. We need to turn off physics simulation and collision detection.
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
Root->PutRigidBodyToSleep();
Root->SetSimulatePhysics(false);
Root->SetEnableGravity(false);
SetActorEnableCollision(false);
}
else
{
// Servers should add this soccer ball to the game mode cache.
// It will get replicated to clients for when they need to access
// the ball itself to get information such as who possesses it.
AMagicBattleSoccerGameState* GameState = GetGameState();
GameState->SoccerBall = this;
}
}
bool UPrimitiveComponent::WeldToImplementation(USceneComponent * InParent, FName ParentSocketName /* = Name_None */, bool bWeldSimulatedChild /* = false */)
{
//WeldToInternal assumes attachment is already done
if (AttachParent != InParent || AttachSocketName != ParentSocketName)
{
return false;
}
//Check that we can actually our own socket name
FBodyInstance* BI = GetBodyInstance(NAME_None, false);
if (BI == NULL)
{
return false;
}
if (BI->ShouldInstanceSimulatingPhysics() && bWeldSimulatedChild == false)
{
return false;
}
UnWeldFromParent(); //make sure to unweld from wherever we currently are
FName SocketName;
UPrimitiveComponent * RootComponent = GetRootWelded(this, ParentSocketName, &SocketName, true);
if (RootComponent)
{
if (FBodyInstance* RootBI = RootComponent->GetBodyInstance(SocketName, false))
{
if (BI->WeldParent == RootBI) //already welded so stop
{
return true;
}
BI->bWelded = true;
//There are multiple cases to handle:
//Root is kinematic, simulated
//Child is kinematic, simulated
//Child always inherits from root
//if root is kinematic simply set child to be kinematic and we're done
if (RootComponent->IsSimulatingPhysics(SocketName) == false)
{
BI->WeldParent = NULL;
SetSimulatePhysics(false);
return false; //return false because we need to continue with regular body initialization
}
//root is simulated so we actually weld the body
FTransform RelativeTM = RootComponent == AttachParent ? GetRelativeTransform() : GetComponentToWorld().GetRelativeTransform(RootComponent->GetComponentToWorld()); //if direct parent we already have relative. Otherwise compute it
RootBI->Weld(BI, GetComponentToWorld());
BI->WeldParent = RootBI;
return true;
}
}
return false;
}
void APawn::MoveIgnoreActorRemove(AActor* ActorToIgnore)
{
UPrimitiveComponent* RootPrimitiveComponent = Cast<UPrimitiveComponent>(GetRootComponent());
if( RootPrimitiveComponent )
{
RootPrimitiveComponent->IgnoreActorWhenMoving(ActorToIgnore, false);
}
}
void FLayers::RemoveViewFromActorViewVisibility( FLevelEditorViewportClient* ViewportClient )
{
const int32 ViewIndex = ViewportClient->ViewIndex;
// get the bit for the view index
uint64 ViewBit = ((uint64)1 << ViewIndex);
// get all bits under that that we want to keep
uint64 KeepBits = ViewBit - 1;
// Iterate over all actors, looking for actors in the specified layers.
for( FActorIterator It(ViewportClient->GetWorld()) ; It ; ++It )
{
const TWeakObjectPtr< AActor > Actor = *It;
if( !IsActorValidForLayer( Actor ) )
{
continue;
}
// remember original bits
uint64 OriginalHiddenViews = Actor->HiddenEditorViews;
uint64 Was = Actor->HiddenEditorViews;
// slide all bits higher than ViewIndex down one since the view is being removed from Editor
uint64 LowBits = Actor->HiddenEditorViews & KeepBits;
// now slide the top bits down by ViewIndex + 1 (chopping off ViewBit)
uint64 HighBits = Actor->HiddenEditorViews >> (ViewIndex + 1);
// then slide back up by ViewIndex, which will now have erased ViewBit, as well as leaving 0 in the low bits
HighBits = HighBits << ViewIndex;
// put it all back together
Actor->HiddenEditorViews = LowBits | HighBits;
// reregister if we changed the visibility bits, as the rendering thread needs them
if (OriginalHiddenViews == Actor->HiddenEditorViews)
{
continue;
}
// Find all registered primitive components and update the scene proxy with the actors updated visibility map
TInlineComponentArray<UPrimitiveComponent*> Components;
Actor->GetComponents(Components);
for( int32 ComponentIdx = 0; ComponentIdx < Components.Num(); ++ComponentIdx )
{
UPrimitiveComponent* PrimitiveComponent = Components[ComponentIdx];
if (PrimitiveComponent->IsRegistered())
{
// Push visibility to the render thread
PrimitiveComponent->PushEditorVisibilityToProxy( Actor->HiddenEditorViews );
}
}
}
}
void ABomb::OnConstruction(const FTransform &Transform)
{
UPrimitiveComponent *pc = Cast<UPrimitiveComponent>(GetComponent(RootComponent, "BombMesh"));
if (pc)
{
BombMIB = pc->CreateDynamicMaterialInstance(0, NULL);
SetBombColor(FLinearColor::Black);
}
}
UMaterialInterface* FComponentMaterialTrackEditor::GetMaterialInterfaceForTrack( FGuid ObjectBinding, UMovieSceneMaterialTrack* MaterialTrack )
{
UObject* ComponentObject = GetSequencer()->GetFocusedMovieSceneSequence()->FindObject( ObjectBinding );
UPrimitiveComponent* Component = Cast<UPrimitiveComponent>( ComponentObject );
UMovieSceneComponentMaterialTrack* ComponentMaterialTrack = Cast<UMovieSceneComponentMaterialTrack>( MaterialTrack );
if ( Component != nullptr && ComponentMaterialTrack != nullptr )
{
return Component->GetMaterial( ComponentMaterialTrack->GetMaterialIndex() );
}
return nullptr;
}
void AMagicBattleSoccerBall::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
if (nullptr != Possessor)
{
// If the ball is possessed by a player, then the ball should move as a function
// of the possessor
MoveWithPossessor();
}
else
{
// No possessor. The ball is freely moving.
if (Role < ROLE_Authority)
{
// Clients should update its local position based on where it is on the server
ClientSimulateFreeMovingBall();
}
else
{
// Update the charging value
if (GetVelocity().SizeSquared() > 1.f)
{
IsCharging = false;
}
// Servers should simulate the ball physics freely and replicate the orientation
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
ServerPhysicsState.pos = GetActorLocation();
ServerPhysicsState.rot = GetActorRotation();
ServerPhysicsState.vel = Root->GetComponentVelocity();
ServerPhysicsState.timestamp = AMagicBattleSoccerPlayerController::GetLocalTime();
// Servers should also test the distance from the old possessor and reset it
if (nullptr != PossessorToIgnore)
{
if (!PossessorToIgnore->IsAlive())
{
PossessorToIgnore = nullptr;
}
else
{
FVector2D PossessorLoc(PossessorToIgnore->GetActorLocation());
FVector2D BallLoc(GetActorLocation());
float d = FVector2D::DistSquared(PossessorLoc, BallLoc);
if (d > 14000)
{
PossessorToIgnore = nullptr;
}
}
}
}
}
}
void AFP_FirstPersonCharacter::OnFire()
{
// Play a sound if there is one
if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}
// try and play a firing animation if specified
if(FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if(AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
// Now send a trace from the end of our gun to see if we should hit anything
APlayerController* PlayerController = Cast<APlayerController>(GetController());
// Calculate the direction of fire and the start location for trace
FVector CamLoc;
FRotator CamRot;
PlayerController->GetPlayerViewPoint(CamLoc, CamRot);
const FVector ShootDir = CamRot.Vector();
FVector StartTrace = FVector::ZeroVector;
if (PlayerController)
{
FRotator UnusedRot;
PlayerController->GetPlayerViewPoint(StartTrace, UnusedRot);
// Adjust trace so there is nothing blocking the ray between the camera and the pawn, and calculate distance from adjusted start
StartTrace = StartTrace + ShootDir * ((GetActorLocation() - StartTrace) | ShootDir);
}
// Calculate endpoint of trace
const FVector EndTrace = StartTrace + ShootDir * WeaponRange;
// Check for impact
const FHitResult Impact = WeaponTrace(StartTrace, EndTrace);
// Deal with impact
AActor* DamagedActor = Impact.GetActor();
UPrimitiveComponent* DamagedComponent = Impact.GetComponent();
// If we hit an actor, with a component that is simulating physics, apply an impulse
if ((DamagedActor != NULL) && (DamagedActor != this) && (DamagedComponent != NULL) && DamagedComponent->IsSimulatingPhysics())
{
DamagedComponent->AddImpulseAtLocation(ShootDir*WeaponDamage, Impact.Location);
}
}
void AActor::PostNetReceivePhysicState()
{
UPrimitiveComponent* RootPrimComp = Cast<UPrimitiveComponent>(RootComponent);
if (RootPrimComp)
{
FRigidBodyState NewState;
ReplicatedMovement.CopyTo(NewState);
FVector DeltaPos(FVector::ZeroVector);
RootPrimComp->ConditionalApplyRigidBodyState(NewState, GEngine->PhysicErrorCorrection, DeltaPos);
}
}
bool APawn::IsBasedOnActor(const AActor* Other) const
{
UPrimitiveComponent * MovementBase = GetMovementBase();
AActor* MovementBaseActor = MovementBase ? MovementBase->GetOwner() : NULL;
if (MovementBaseActor && MovementBaseActor == Other)
{
return true;
}
return Super::IsBasedOnActor(Other);
}
bool APhysicsVolume::IsOverlapInVolume(const class USceneComponent& TestComponent) const
{
bool bInsideVolume = true;
if (!bPhysicsOnContact)
{
FVector ClosestPoint(0.f);
UPrimitiveComponent* RootPrimitive = Cast<UPrimitiveComponent>(GetRootComponent());
const float DistToCollision = RootPrimitive ? RootPrimitive->GetDistanceToCollision(TestComponent.GetComponentLocation(), ClosestPoint) : 0.f;
bInsideVolume = (DistToCollision == 0.f);
}
return bInsideVolume;
}
bool UGripMotionControllerComponent::TeleportMoveGrippedActor(AActor * GrippedActorToMove)
{
if (!GrippedActorToMove || !GrippedActors.Num())
return false;
FTransform WorldTransform;
FTransform InverseTransform = this->GetComponentTransform().Inverse();
for (int i = GrippedActors.Num() - 1; i >= 0; --i)
{
if (GrippedActors[i].Actor == GrippedActorToMove)
{
// GetRelativeTransformReverse had some serious f*****g floating point errors associated with it that was f*****g everything up
// Not sure whats wrong with the function but I might want to push a patch out eventually
WorldTransform = GrippedActors[i].RelativeTransform.GetRelativeTransform(InverseTransform);
// Need to use WITH teleport for this function so that the velocity isn't updated and without sweep so that they don't collide
GrippedActors[i].Actor->SetActorTransform(WorldTransform, false, NULL, ETeleportType::TeleportPhysics);
FBPActorPhysicsHandleInformation * Handle = GetPhysicsGrip(GrippedActors[i]);
if (Handle && Handle->KinActorData)
{
{
PxScene* PScene = GetPhysXSceneFromIndex(Handle->SceneIndex);
if (PScene)
{
SCOPED_SCENE_WRITE_LOCK(PScene);
Handle->KinActorData->setKinematicTarget(PxTransform(U2PVector(WorldTransform.GetLocation()), Handle->KinActorData->getGlobalPose().q));
Handle->KinActorData->setGlobalPose(PxTransform(U2PVector(WorldTransform.GetLocation()), Handle->KinActorData->getGlobalPose().q));
}
}
//Handle->KinActorData->setGlobalPose(PxTransform(U2PVector(WorldTransform.GetLocation()), Handle->KinActorData->getGlobalPose().q));
UPrimitiveComponent *root = Cast<UPrimitiveComponent>(GrippedActors[i].Actor->GetRootComponent());
if (root)
{
FBodyInstance * body = root->GetBodyInstance();
if (body)
{
body->SetBodyTransform(WorldTransform, ETeleportType::TeleportPhysics);
}
}
}
return true;
}
}
return false;
}
/** Sets the current ball possessor */
void AMagicBattleSoccerBall::SetPossessor(AMagicBattleSoccerCharacter* Player)
{
if (Role < ROLE_Authority)
{
// Safety check. Only authority entities should drive the ball.
}
else
{
// We only allow a possession change if the ball is being unpossessed or the player is not one we're ignoring
if (nullptr == Player || (CanPossessBall(Player) && (PossessorToIgnore != Player)))
{
AMagicBattleSoccerCharacter *OldPossessor = Possessor;
// Assign the new possessor
Possessor = Player;
// Handle cases when the ball had a possessor in the previous frame
if (nullptr != OldPossessor)
{
// Assign the last possessor
LastPossessor = OldPossessor;
// Assign the possessor to ignore
PossessorToIgnore = OldPossessor;
}
// Toggle physics
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
if (nullptr != Possessor)
{
Possessor->StopWeaponFire(Possessor->PrimaryWeapon);
Possessor->StopWeaponFire(Possessor->SecondaryWeapon);
Root->PutRigidBodyToSleep();
Root->SetSimulatePhysics(false);
Root->SetEnableGravity(false);
SetActorEnableCollision(false);
MoveWithPossessor();
}
else
{
Root->SetSimulatePhysics(true);
Root->SetEnableGravity(true);
SetActorEnableCollision(true);
Root->PutRigidBodyToSleep();
}
}
// Force the orientation to be replicated at the same time the possessor is replicated
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
ServerPhysicsState.pos = GetActorLocation();
ServerPhysicsState.rot = GetActorRotation();
ServerPhysicsState.vel = Root->GetComponentVelocity();
ServerPhysicsState.timestamp = AMagicBattleSoccerPlayerController::GetLocalTime();
}
}
/** Kicks this ball with a given force */
void AMagicBattleSoccerBall::Kick(const FVector& Force)
{
if (nullptr == Possessor)
{
// Safety check. The possessor must be valid.
}
else
{
// Reset the possessor
SetPossessor(nullptr);
// Now apply the force
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
Root->AddForce(Force);
}
}
/** Called by the GameMode object when the next round has begun */
void AMagicBattleSoccerBall::RoundHasStarted_Implementation()
{
if (Role == ROLE_Authority)
{
if (nullptr != Possessor)
{
SetPossessor(nullptr); // This change will be replicated to all clients
}
else
{
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
Root->PutRigidBodyToSleep();
}
PossessorToIgnore = nullptr;
}
}
FBodyInstance* UPhysicsConstraintComponent::GetBodyInstance(EConstraintFrame::Type Frame) const
{
FBodyInstance* Instance = NULL;
UPrimitiveComponent* PrimComp = GetComponentInternal(Frame);
if(PrimComp != NULL)
{
if(Frame == EConstraintFrame::Frame1)
{
Instance = PrimComp->GetBodyInstance(ConstraintInstance.ConstraintBone1);
}
else
{
Instance = PrimComp->GetBodyInstance(ConstraintInstance.ConstraintBone2);
}
}
return Instance;
}
void UCarlaSettingsDelegate::SetActorComponentsDrawDistance(AActor* actor, const float max_draw_distance) const
{
if(!actor) return;
TArray<UActorComponent*> components = actor->GetComponentsByClass(UPrimitiveComponent::StaticClass());
float dist = max_draw_distance;
const float maxscale = actor->GetActorScale().GetMax();
if(maxscale>_MAX_SCALE_SIZE) dist *= 100.0f;
for(int32 j=0; j<components.Num(); j++)
{
UPrimitiveComponent* primitivecomponent = Cast<UPrimitiveComponent>(components[j]);
if(IsValid(primitivecomponent))
{
primitivecomponent->SetCullDistance(dist);
primitivecomponent->bAllowCullDistanceVolume = dist>0;
}
}
}
void ACullDistanceVolume::GetPrimitiveMaxDrawDistances(TMap<UPrimitiveComponent*,float>& OutCullDistances)
{
// Nothing to do if there is no brush component or no cull distances are set
if (GetBrushComponent() && CullDistances.Num() > 0 && bEnabled)
{
for (auto It(OutCullDistances.CreateIterator()); It; ++It)
{
UPrimitiveComponent* PrimitiveComponent = It.Key();
// Check whether primitive can be affected by cull distance volumes.
if( ACullDistanceVolume::CanBeAffectedByVolumes( PrimitiveComponent ) )
{
// Check whether primitive supports cull distance volumes and its center point is being encompassed by this volume.
if( EncompassesPoint( PrimitiveComponent->GetComponentLocation() ) )
{
// Find best match in CullDistances array.
float PrimitiveSize = PrimitiveComponent->Bounds.SphereRadius * 2;
float CurrentError = FLT_MAX;
float CurrentCullDistance = 0;
for( int32 CullDistanceIndex=0; CullDistanceIndex<CullDistances.Num(); CullDistanceIndex++ )
{
const FCullDistanceSizePair& CullDistancePair = CullDistances[CullDistanceIndex];
if( FMath::Abs( PrimitiveSize - CullDistancePair.Size ) < CurrentError )
{
CurrentError = FMath::Abs( PrimitiveSize - CullDistancePair.Size );
CurrentCullDistance = CullDistancePair.CullDistance;
}
}
float& CullDistance = It.Value();
// LD or other volume specified cull distance, use minimum of current and one used for this volume.
if (CullDistance > 0)
{
CullDistance = FMath::Min(CullDistance, CurrentCullDistance);
}
// LD didn't specify cull distance, use current setting directly.
else
{
CullDistance = CurrentCullDistance;
}
}
}
}
}
}
bool FClassActorThumbnailScene::IsValidComponentForVisualization(UActorComponent* Component)
{
UPrimitiveComponent* PrimComp = Cast<UPrimitiveComponent>(Component);
if ( PrimComp && PrimComp->IsVisible() && !PrimComp->bHiddenInGame )
{
UStaticMeshComponent* StaticMeshComp = Cast<UStaticMeshComponent>(Component);
if ( StaticMeshComp && StaticMeshComp->StaticMesh )
{
return true;
}
USkeletalMeshComponent* SkelMeshComp = Cast<USkeletalMeshComponent>(Component);
if ( SkelMeshComp && SkelMeshComp->SkeletalMesh )
{
return true;
}
}
return false;
}
ALODActor* FHierarchicalLODUtilities::GetParentLODActor(const AActor* InActor)
{
ALODActor* ParentActor = nullptr;
if (InActor)
{
TArray<UStaticMeshComponent*> ComponentArray;
InActor->GetComponents<UStaticMeshComponent>(ComponentArray);
for (auto Component : ComponentArray)
{
UPrimitiveComponent* ParentComponent = Component->GetLODParentPrimitive();
if (ParentComponent)
{
ParentActor = CastChecked<ALODActor>(ParentComponent->GetOwner());
break;
}
}
}
return ParentActor;
}
void UGripMotionControllerComponent::NotifyDrop_Implementation(const FBPActorGripInformation &NewDrop, bool bSimulate)
{
if (bIsServer)
{
if (NewDrop.Actor)
{
NewDrop.Actor->RemoveTickPrerequisiteComponent(this);
this->IgnoreActorWhenMoving(NewDrop.Actor, false);
NewDrop.Actor->SetReplicateMovement(NewDrop.bOriginalReplicatesMovement);
}
else if (NewDrop.Component)
{
NewDrop.Component->RemoveTickPrerequisiteComponent(this);
if (NewDrop.Component->GetOwner())
{
this->IgnoreActorWhenMoving(NewDrop.Component->GetOwner(), false);
NewDrop.Component->GetOwner()->SetReplicateMovement(NewDrop.bOriginalReplicatesMovement);
}
}
}
DestroyPhysicsHandle(NewDrop);
UPrimitiveComponent *root = NewDrop.Component;
if (!root && NewDrop.Actor)
{
root = Cast<UPrimitiveComponent>(NewDrop.Actor->GetRootComponent());
if (root)
{
root->IgnoreActorWhenMoving(this->GetOwner(), false);
root->SetSimulatePhysics(bSimulate);
root->WakeAllRigidBodies();
root->SetEnableGravity(true);
}
}
else if (root)
{
root->IgnoreActorWhenMoving(this->GetOwner(), false);
root->SetSimulatePhysics(bSimulate);
root->WakeAllRigidBodies();
root->SetEnableGravity(true);
}
}
bool UGripMotionControllerComponent::DestroyPhysicsHandle(const FBPActorGripInformation &Grip)
{
UPrimitiveComponent *root = Grip.Component;
if(!root)
root = Cast<UPrimitiveComponent>(Grip.Actor->GetRootComponent());
if (!root)
return false;
root->SetEnableGravity(true);
FBPActorPhysicsHandleInformation * HandleInfo = GetPhysicsGrip(Grip);
if (!HandleInfo)
return true;
DestroyPhysicsHandle(HandleInfo->SceneIndex, &HandleInfo->HandleData, &HandleInfo->KinActorData);
PhysicsGrips.RemoveAt(GetPhysicsGripIndex(Grip));
return true;
}
void ConvertQueryOverlap(const PxShape* PShape, const PxRigidActor* PActor, FOverlapResult& OutOverlap, const PxFilterData& QueryFilter)
{
const bool bBlock = IsBlocking(PShape, QueryFilter);
FBodyInstance* BodyInst = FPhysxUserData::Get<FBodyInstance>(PActor->userData);
FDestructibleChunkInfo* ChunkInfo = FPhysxUserData::Get<FDestructibleChunkInfo>(PActor->userData);
// Grab actor/component
UPrimitiveComponent* OwnerComponent = nullptr;
// Try body instance
if (BodyInst)
{
OwnerComponent = BodyInst->OwnerComponent.Get(); // cache weak pointer object, avoid multiple derefs below.
if (OwnerComponent)
{
OutOverlap.Actor = OwnerComponent->GetOwner();
OutOverlap.Component = BodyInst->OwnerComponent; // Copying weak pointer is faster than assigning raw pointer.
OutOverlap.ItemIndex = OwnerComponent->bMultiBodyOverlap ? BodyInst->InstanceBodyIndex : INDEX_NONE;
}
}
if (!OwnerComponent)
{
// Try chunk info
if (ChunkInfo)
{
OwnerComponent = ChunkInfo->OwningComponent.Get(); // cache weak pointer object, avoid multiple derefs below.
if (OwnerComponent)
{
OutOverlap.Actor = OwnerComponent->GetOwner();
OutOverlap.Component = ChunkInfo->OwningComponent; // Copying weak pointer is faster than assigning raw pointer.
OutOverlap.ItemIndex = OwnerComponent->bMultiBodyOverlap ? UDestructibleComponent::ChunkIdxToBoneIdx(ChunkInfo->ChunkIndex) : INDEX_NONE;
}
}
}
// Other info
OutOverlap.bBlockingHit = bBlock;
}
