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; }