// Called every frame void AMissleProjectile::Tick( float DeltaTime ) { Super::Tick(DeltaTime); if (TargetActor != nullptr) { NotifyTarget(this); FVector WantedDir = (TargetActor->GetActorLocation() - GetActorLocation()).GetSafeNormal(); WantedDir += TargetActor->GetVelocity() * WantedDir.Size() / MissleMovement->MaxSpeed; MissleMovement->Velocity += WantedDir * MissleMovement->InitialSpeed * 100.0f * DeltaTime; MissleMovement->Velocity = MissleMovement->Velocity.GetSafeNormal() * MissleMovement->MaxSpeed; FVector Dis = GetActorLocation() - (TargetActor->GetActorLocation()); if (Dis.Size() < 5) { Server_Explode(TargetActor, BP_Explosion.GetDefaultObject(), Damage); } } else { NotifyTarget(nullptr); SetLifeSpan(1.0f); } }
int32 UTKMathFunctionLibrary::PointOnWhichSideOfLineSegment(FVector linePoint1, FVector linePoint2, FVector point) { FVector lineVec = linePoint2 - linePoint1; FVector pointVec = point - linePoint1; float dot = FVector::DotProduct(pointVec, lineVec); //point is on side of linePoint2, compared to linePoint1 if (dot > 0) { //point is on the line segment if (pointVec.Size() <= lineVec.Size()) { return 0; } //point is not on the line segment and it is on the side of linePoint2 else { return 2; } } //Point is not on side of linePoint2, compared to linePoint1. //Point is not on the line segment and it is on the side of linePoint1. else { return 1; } }
void ABounceBlock::OnHit(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit) { //衝突された場合の判定 UE_LOG(LogTemp, Log, TEXT("On Hit Call!")); //横方向に限定して弾き返す float speed = NormalImpulse.Size(); NormalImpulse.Z = 0; //ベロシティを反射方向に導く FVector velocity = OtherComp->GetComponentVelocity(); float power = velocity.Size(); if (power > 0.0f){ NormalImpulse.Normalize(); NormalImpulse = velocity + 2 * (-velocity | NormalImpulse) * NormalImpulse; power = NormalImpulse.Size(); NormalImpulse.Z = 0; NormalImpulse.Normalize(); NormalImpulse *= power; OtherComp->SetPhysicsLinearVelocity(NormalImpulse); } //トルクを0にしてみる OtherComp->SetPhysicsAngularVelocity(FVector(0, 0, 0)); //弾き返す!! //OtherComp->AddImpulseAtLocation(NormalImpulse * 2.0f, Hit.Location); }
void UEditorEngine::polyTexScale( UModel* Model, float UU, float UV, float VU, float VV, bool Absolute ) { for( int32 i=0; i<Model->Surfs.Num(); i++ ) { FBspSurf *Poly = &Model->Surfs[i]; if (Poly->PolyFlags & PF_Selected) { FVector OriginalU = Model->Vectors[Poly->vTextureU]; FVector OriginalV = Model->Vectors[Poly->vTextureV]; if( Absolute ) { OriginalU *= 1.0/OriginalU.Size(); OriginalV *= 1.0/OriginalV.Size(); } // Calc new vectors. Model->Vectors[Poly->vTextureU] = OriginalU * UU + OriginalV * UV; Model->Vectors[Poly->vTextureV] = OriginalU * VU + OriginalV * VV; // Update generating brush poly. polyUpdateMaster( Model, i, 1 ); } } }
// Weisstein, Eric W. "Point-Line Distance--3-Dimensional." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html static float DistanceToLine(const FVector& LineStart, const FVector& LineEnd, const FVector& Point) { const FVector StartToEnd = LineEnd - LineStart; const FVector PointToStart = LineStart - Point; const FVector Cross = StartToEnd ^ PointToStart; return Cross.Size()/StartToEnd.Size(); }
FVector2D FSingleTileEditorViewportClient::SelectedItemConvertWorldSpaceDeltaToLocalSpace(const FVector& WorldSpaceDelta) const { const FVector ProjectionX = WorldSpaceDelta.ProjectOnTo(PaperAxisX); const FVector ProjectionY = WorldSpaceDelta.ProjectOnTo(PaperAxisY); const float XValue = FMath::Sign(ProjectionX | PaperAxisX) * ProjectionX.Size(); const float YValue = FMath::Sign(ProjectionY | PaperAxisY) * ProjectionY.Size(); return FVector2D(XValue, YValue); }
FVector2D FSingleTileEditorViewportClient::WorldSpaceToTextureSpace(const FVector& SourcePoint) const { const FVector ProjectionX = SourcePoint.ProjectOnTo(PaperAxisX); const FVector ProjectionY = -SourcePoint.ProjectOnTo(PaperAxisY); const float XValue = FMath::Sign(ProjectionX | PaperAxisX) * ProjectionX.Size(); const float YValue = FMath::Sign(ProjectionY | PaperAxisY) * ProjectionY.Size(); return FVector2D(XValue, YValue); }
FVector UFlareSpacecraftNavigationSystem::GetAngularVelocityToAlignAxis(FVector LocalShipAxis, FVector TargetAxis, FVector TargetAngularVelocity, float DeltaSeconds) const { TArray<UActorComponent*> Engines = Spacecraft->GetComponentsByClass(UFlareEngine::StaticClass()); FVector AngularVelocity = Spacecraft->Airframe->GetPhysicsAngularVelocity(); FVector WorldShipAxis = Spacecraft->Airframe->GetComponentToWorld().GetRotation().RotateVector(LocalShipAxis); WorldShipAxis.Normalize(); TargetAxis.Normalize(); FVector RotationDirection = FVector::CrossProduct(WorldShipAxis, TargetAxis); RotationDirection.Normalize(); float Dot = FVector::DotProduct(WorldShipAxis, TargetAxis); float angle = FMath::RadiansToDegrees(FMath::Acos(Dot)); FVector DeltaVelocity = TargetAngularVelocity - AngularVelocity; FVector DeltaVelocityAxis = DeltaVelocity; DeltaVelocityAxis.Normalize(); float TimeToFinalVelocity; if (FMath::IsNearlyZero(DeltaVelocity.SizeSquared())) { TimeToFinalVelocity = 0; } else { FVector SimpleAcceleration = DeltaVelocityAxis * GetAngularAccelerationRate(); // Scale with damages float DamageRatio = GetTotalMaxTorqueInAxis(Engines, DeltaVelocityAxis, true) / GetTotalMaxTorqueInAxis(Engines, DeltaVelocityAxis, false); FVector DamagedSimpleAcceleration = SimpleAcceleration * DamageRatio; FVector Acceleration = DamagedSimpleAcceleration; float AccelerationInAngleAxis = FMath::Abs(FVector::DotProduct(DamagedSimpleAcceleration, RotationDirection)); TimeToFinalVelocity = (DeltaVelocity.Size() / AccelerationInAngleAxis); } float AngleToStop = (DeltaVelocity.Size() / 2) * (FMath::Max(TimeToFinalVelocity,DeltaSeconds)); FVector RelativeResultSpeed; if (AngleToStop > angle) { RelativeResultSpeed = TargetAngularVelocity; } else { float MaxPreciseSpeed = FMath::Min((angle - AngleToStop) / (DeltaSeconds * 0.75f), GetAngularMaxVelocity()); RelativeResultSpeed = RotationDirection; RelativeResultSpeed *= MaxPreciseSpeed; } return RelativeResultSpeed; }
void AGameObject::Walk( float t ) { CheckWaypoint(); // Alter destination based on locations of other units. FVector ToDest = Dest - Pos; // Clamp travel length so that we can't overshoot destination if( float Len = ToDest.Size() ) { Dir = ToDest / Len; // normalize if( !Stats.SpeedMax ) error( FS("%s had 0 speed", *GetName()) ); // I am maxing out the speed here. Speed = Stats.SpeedMax; // The direction of travel is modified by repulsion forces FVector repulsionForces = GetRepulsionForcesFromOverlappedUnits(); FVector modDir = Dir + repulsionForces; modDir.Normalize(); FVector Vel = modDir*Speed; //Game->flycam->DrawDebug( Pos, Pos + Vel, 5.f, FLinearColor::Red, 0.f ); FVector travel = Vel*t; // If travel exceeds destination, then jump to dest, // so we don't jitter over the final position. if( Len < travel.Size() ) { // snap to position & stop moving. Pos = Dest; // we are @ destination. travel = ToDest; // This is the displacement we actually moved. Speed = 0; } else { Pos += travel; if( Grounds ) { FVector newPos = Pos + UnitZ * 10.f; // Travel in direction plus some amount straight up. // The straight up amount ensures that the unit doesn't sink underground if( Game->flycam->SetOnGround( newPos ) ) Pos = newPos; else error( FS( "%s Object was trying to leave the ground plane.", *GetName() ) ); } SetRot( Dir.Rotation() ); } } else { // We're at the destination, so the velocity becomes 0 Speed = 0.f; } }
void FIndirectLightingCache::UpdateTransitionsOverTime(const TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate, float DeltaWorldTime) const { for (int32 AllocationIndex = 0; AllocationIndex < TransitionsOverTimeToUpdate.Num(); AllocationIndex++) { FIndirectLightingCacheAllocation* Allocation = TransitionsOverTimeToUpdate[AllocationIndex]; const float TransitionDistance = (Allocation->SingleSamplePosition - Allocation->TargetPosition).Size(); if (TransitionDistance > DELTA) { // Compute a frame rate independent transition by maintaining a constant world space speed between the current sample position and the target position const float LerpFactor = FMath::Clamp(GSingleSampleTransitionSpeed * DeltaWorldTime / TransitionDistance, 0.0f, 1.0f); Allocation->SingleSamplePosition = FMath::Lerp(Allocation->SingleSamplePosition, Allocation->TargetPosition, LerpFactor); for (int32 VectorIndex = 0; VectorIndex < ARRAY_COUNT(Allocation->SingleSamplePacked); VectorIndex++) { Allocation->SingleSamplePacked[VectorIndex] = FMath::Lerp(Allocation->SingleSamplePacked[VectorIndex], Allocation->TargetSamplePacked[VectorIndex], LerpFactor); } Allocation->CurrentDirectionalShadowing = FMath::Lerp(Allocation->CurrentDirectionalShadowing, Allocation->TargetDirectionalShadowing, LerpFactor); const FVector CurrentSkyBentNormal = FMath::Lerp( FVector(Allocation->CurrentSkyBentNormal) * Allocation->CurrentSkyBentNormal.W, FVector(Allocation->TargetSkyBentNormal) * Allocation->TargetSkyBentNormal.W, LerpFactor); const float BentNormalLength = CurrentSkyBentNormal.Size(); Allocation->CurrentSkyBentNormal = FVector4(CurrentSkyBentNormal / FMath::Max(BentNormalLength, .0001f), BentNormalLength); } } }
void SetParameters(FRHICommandList& RHICmdList, const FViewInfo& View) { FGlobalShader::SetParameters(RHICmdList, GetVertexShader(),View); { // The fog can be set to start at a certain euclidean distance. // clamp the value to be behind the near plane z float FogStartDistance = FMath::Max(30.0f, View.ExponentialFogParameters.W); // Here we compute the nearest z value the fog can start // to render the quad at this z value with depth test enabled. // This means with a bigger distance specified more pixels are // are culled and don't need to be rendered. This is faster if // there is opaque content nearer than the computed z. FMatrix InvProjectionMatrix = View.ViewMatrices.GetInvProjMatrix(); FVector ViewSpaceCorner = InvProjectionMatrix.TransformFVector4(FVector4(1, 1, 1, 1)); float Ratio = ViewSpaceCorner.Z / ViewSpaceCorner.Size(); FVector ViewSpaceStartFogPoint(0.0f, 0.0f, FogStartDistance * Ratio); FVector4 ClipSpaceMaxDistance = View.ViewMatrices.ProjMatrix.TransformPosition(ViewSpaceStartFogPoint); float FogClipSpaceZ = ClipSpaceMaxDistance.Z / ClipSpaceMaxDistance.W; SetShaderValue(RHICmdList, GetVertexShader(),FogStartZ, FogClipSpaceZ); } }
void AMagnetTile::PullBall( ABallPawn* ball ) { auto prim = Cast<UPrimitiveComponent>( ball->GetRootComponent() ); UWorld* world = GetWorld(); auto DeltaTime = world->DeltaTimeSeconds; AProjectTapGameState* gameState; if ( world != nullptr && ( gameState = world->GetGameState<AProjectTapGameState>() ) != nullptr && gameState->SetMagnetTile( this ) != this ) { FVector angular = FVector::ZeroVector; prim->SetPhysicsAngularVelocity( angular ); float distanceAtNormal = FVector::DotProduct( ball->GetActorLocation() - GetActorLocation() , GetActorForwardVector() ); FVector normalLoc = ( distanceAtNormal * GetActorForwardVector() ) + GetActorLocation(); FVector normalToBall = ball->GetActorLocation() - normalLoc; float dist = normalToBall.Size(); if ( dist > centerTolerance ) { FVector toAdd = dist * -normalToBall.GetSafeNormal(); toAdd.Z = 0; prim->AddRelativeLocation( toAdd ); } } if ( isVertical ) { attractionSpeed *= verticalForceMultiplier; } float originalSpeed = prim->GetPhysicsLinearVelocity().Size(); float newSpeed = attractionSpeed + originalSpeed; prim->SetPhysicsLinearVelocity(newSpeed * -GetActorForwardVector()); }
FVector UTKMathFunctionLibrary::GetVelocityAtPoint(UPrimitiveComponent* Target, FVector Point, FName BoneName, bool DrawDebugInfo) { //FTransform Transform = Target->GetComponentTransform(); //FVector LocalLinearVelocity = Transform.InverseTransformVectorNoScale(Target->GetPhysicsLinearVelocity()); //FVector LocalAngularVelocity = Transform.InverseTransformVectorNoScale(Target->GetPhysicsAngularVelocity()); //FVector ResultPointVelocity = LocalLinearVelocity + FVector::CrossProduct(FVector::DegreesToRadians(LocalAngularVelocity), Transform.InverseTransformVectorNoScale(Point - Target->GetCenterOfMass())); if (!Target) return FVector::ZeroVector; //You can actually get it from the physx body instance instead. FBodyInstance* BI = Target->GetBodyInstance(BoneName); if (BI && BI->IsValidBodyInstance()) { FVector PointVelocity = BI->GetUnrealWorldVelocityAtPoint(Point); UWorld* TheWorld = Target->GetWorld(); if (DrawDebugInfo && TheWorld) { FColor DefaultColor(255,200,0); DrawDebugPoint(TheWorld, Point, 10, DefaultColor); DrawDebugString(TheWorld, Point, FString::SanitizeFloat(PointVelocity.Size()), NULL, FColor::White, 0.0f); } return PointVelocity; } return FVector::ZeroVector; }
// Called every frame void AMonster::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); ARaiderCharacter *avatar = Cast<ARaiderCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0)); if (!avatar) return; FVector toPlayer = avatar->GetActorLocation() - GetActorLocation(); this->GetCharacterMovement()->bOrientRotationToMovement = true; // Rotate character to moving direction float distanceToPlayer = toPlayer.Size(); // If the player is not in the SightSphere of the monster, // go back if (distanceToPlayer > SightSphere->GetScaledSphereRadius()) { // If the player is out of sight, // then the enemy cannot chase return; } toPlayer /= distanceToPlayer; // normalizes the vector FRotator Rotation = toPlayer.Rotation(); const FVector Direction = FRotationMatrix(Rotation).GetScaledAxis(EAxis::X); AddMovementInput(Direction, m_fSpeed * DeltaTime); }
void FIndirectLightingCache::UpdateTransitionsOverTime(const TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate, float DeltaWorldTime) const { for (int32 AllocationIndex = 0; AllocationIndex < TransitionsOverTimeToUpdate.Num(); AllocationIndex++) { FIndirectLightingCacheAllocation* Allocation = TransitionsOverTimeToUpdate[AllocationIndex]; const float TransitionDistance = (Allocation->SingleSamplePosition - Allocation->TargetPosition).Size(); if (TransitionDistance > DELTA) { // Transition faster for unbuilt meshes which is important for meshing visualization const float EffectiveTransitionSpeed = GSingleSampleTransitionSpeed * (Allocation->bUnbuiltPreview ? 4 : 1); const float LerpFactor = FMath::Clamp(GSingleSampleTransitionSpeed * DeltaWorldTime / TransitionDistance, 0.0f, 1.0f); Allocation->SingleSamplePosition = FMath::Lerp(Allocation->SingleSamplePosition, Allocation->TargetPosition, LerpFactor); for (int32 VectorIndex = 0; VectorIndex < 3; VectorIndex++) // RGB { Allocation->SingleSamplePacked0[VectorIndex] = FMath::Lerp(Allocation->SingleSamplePacked0[VectorIndex], Allocation->TargetSamplePacked0[VectorIndex], LerpFactor); Allocation->SingleSamplePacked1[VectorIndex] = FMath::Lerp(Allocation->SingleSamplePacked1[VectorIndex], Allocation->TargetSamplePacked1[VectorIndex], LerpFactor); } Allocation->SingleSamplePacked2 = FMath::Lerp(Allocation->SingleSamplePacked2, Allocation->TargetSamplePacked2, LerpFactor); Allocation->CurrentDirectionalShadowing = FMath::Lerp(Allocation->CurrentDirectionalShadowing, Allocation->TargetDirectionalShadowing, LerpFactor); const FVector CurrentSkyBentNormal = FMath::Lerp( FVector(Allocation->CurrentSkyBentNormal) * Allocation->CurrentSkyBentNormal.W, FVector(Allocation->TargetSkyBentNormal) * Allocation->TargetSkyBentNormal.W, LerpFactor); const float BentNormalLength = CurrentSkyBentNormal.Size(); Allocation->CurrentSkyBentNormal = FVector4(CurrentSkyBentNormal / FMath::Max(BentNormalLength, .0001f), BentNormalLength); } } }
void ACloud10Character::bounceJump(float Value) { float curJumpVelocity = Value; float jumpVelocity; GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("bounceJump")); const FVector ForwardDir = GetActorForwardVector(); /*bounceCount++; if(bounceCount > 1) { jumpVelocity = jumpVelocity * 1.3; }*/ //if player has landed, reset jumpVelocity /*if (curJumpVelocity < baseJumpForce) jumpVelocity = baseJumpForce;*/ //thresholds for jump velocity's that convert to force? //max jump? if (curJumpVelocity >= 3000) { curJumpVelocity = 3000; } //add only player's vertical speed to the last jump Velocity jumpVelocity = FMath().Abs(curJumpVelocity) + baseJumpForce; FVector AddForce = FVector(0, 0, 1) * jumpVelocity; //separate max walk speed from max fall speed //GetCharacterMovement()->MaxWalkSpeed = AddForce.Size(); //convert float to string FString tempString = FString::SanitizeFloat(AddForce.Size()); GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, *tempString); LaunchCharacter(AddForce, false, true); //bPressedJump = true; //jumpVelocity = 600; }
void UAirBlueprintLib::FollowActor(AActor* follower, const AActor* followee, const FVector& offset, bool fixed_z, float fixed_z_val) { //can we see followee? FHitResult hit; if (followee == nullptr) { return; } FVector actor_location = followee->GetActorLocation() + FVector(0, 0, 4); FVector next_location = actor_location + offset; if (fixed_z) next_location.Z = fixed_z_val; if (GetObstacle(follower, next_location, actor_location, hit, followee)) { next_location = hit.ImpactPoint + offset; if (GetObstacle(follower, next_location, actor_location, hit, followee)) { float next_z = next_location.Z; next_location = hit.ImpactPoint - offset; next_location.Z = next_z; } } float dist = (follower->GetActorLocation() - next_location).Size(); float offset_dist = offset.Size(); float dist_offset = (dist - offset_dist) / offset_dist; float lerp_alpha = common_utils::Utils::clip((dist_offset*dist_offset) * 0.01f + 0.01f, 0.0f, 1.0f); next_location = FMath::Lerp(follower->GetActorLocation(), next_location, lerp_alpha); follower->SetActorLocation(next_location); FRotator next_rot = UKismetMathLibrary::FindLookAtRotation(follower->GetActorLocation(), followee->GetActorLocation()); next_rot = FMath::Lerp(follower->GetActorRotation(), next_rot, 0.5f); follower->SetActorRotation(next_rot); }
void AVehiclePawn::ReceiveHit(class UPrimitiveComponent* MyComp, class AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalForce, const FHitResult& Hit) { Super::ReceiveHit(MyComp, Other, OtherComp, bSelfMoved, HitLocation, HitNormal, NormalForce, Hit); if (ImpactTemplate && NormalForce.Size() > ImpactEffectNormalForceThreshold) { AVehicleImpactEffect* EffectActor = GetWorld()->SpawnActorDeferred<AVehicleImpactEffect>(ImpactTemplate, HitLocation, HitNormal.Rotation()); if (EffectActor) { float DotBetweenHitAndUpRotation = FVector::DotProduct(HitNormal, GetMesh()->GetUpVector()); EffectActor->HitSurface = Hit; EffectActor->HitForce = NormalForce; EffectActor->bWheelLand = DotBetweenHitAndUpRotation > 0.8; UGameplayStatics::FinishSpawningActor(EffectActor, FTransform(HitNormal.Rotation(), HitLocation)); } } if (ImpactCameraShake) { AVehiclePlayerController* PC = Cast<AVehiclePlayerController>(Controller); if (PC != NULL && PC->IsLocalController()) { PC->ClientPlayCameraShake(ImpactCameraShake, 1); } } }
FVector FGeomEdge::GetWidgetLocation() { FVector dir = (GetParentObject()->VertexPool[ VertexIndices[1] ] - GetParentObject()->VertexPool[ VertexIndices[0] ]); const float dist = dir.Size() / 2; dir.Normalize(); const FVector loc = GetParentObject()->VertexPool[ VertexIndices[0] ] + (dir * dist); return GetParentObject()->GetActualBrush()->ActorToWorld().TransformPosition( loc ); }
/** * Convert Convex Normal to Capsule Normal * For capsule, we'd like to get normal of capsule rather than convex, so the normal can be smooth when we move character * * @param HalfHeight : HalfHeight of the capsule * @param Radius : Radius of the capsule * @param OutHit : The result of hit from physX @ @param PointOnGeom : If not null, use this point and the impact normal to recompute the impact point (which can yield a better normal). * @result OutHit.Normal is converted to Capsule Normal */ static void ConvertConvexNormalToCapsuleNormal(float HalfHeight, float Radius, struct FHitResult& OutHit, const FVector* PointOnGeom) { if ( OutHit.Time > 0.f ) { // Impact point is contact point where it meet const float ContactZ = OutHit.ImpactPoint.Z; // Hit.Location is center of the object const FVector CenterOfCapsule = OutHit.Location; // We're looking for end of the normal for this capsule FVector NormalEnd = CenterOfCapsule; // see if it's upper hemisphere if (ContactZ > CenterOfCapsule.Z + HalfHeight) { // if upper hemisphere, the normal should point to the center of upper hemisphere NormalEnd.Z = CenterOfCapsule.Z + HalfHeight; } else if (ContactZ < CenterOfCapsule.Z - HalfHeight) { // if lower hemisphere, the normal should point to the center of lower hemisphere NormalEnd.Z = CenterOfCapsule.Z - HalfHeight; } else { // otherwise, normal end is going to be same as contact point // since it's the tube section of the capsule NormalEnd.Z = ContactZ; } // Recompute ImpactPoint if requested if (PointOnGeom) { const FPlane GeomPlane(*PointOnGeom, OutHit.ImpactNormal); const float DistToPlane = GeomPlane.PlaneDot(NormalEnd); if (DistToPlane >= Radius) { OutHit.ImpactPoint = NormalEnd - DistToPlane * OutHit.ImpactNormal; } } //DrawDebugLine(ContactPoint, NormalEnd, FColor(0, 255, 0), true); //DrawDebugLine(NormalEnd, CenterOfCapsule, FColor(0, 0, 255), true); FVector ContactNormal = (NormalEnd - OutHit.ImpactPoint); // if ContactNormal is not nearly zero, set it // otherwise use previous normal const float Size = ContactNormal.Size(); if (Size >= KINDA_SMALL_NUMBER) { ContactNormal /= Size; OutHit.Normal = ContactNormal; } #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST || !WITH_EDITOR) CheckHitResultNormal(OutHit, TEXT("ConvertConvexNormalToCapsuleNormal")); #endif } }
float USplineComponent::GetSegmentLength(const int32 Index, const float Param) const { const int32 NumPoints = SplineInfo.Points.Num(); const int32 LastPoint = NumPoints - 1; check(Index >= 0 && ((bClosedLoop && Index < NumPoints) || (!bClosedLoop && Index < LastPoint))); check(Param >= 0.0f && Param <= 1.0f); // Evaluate the length of a Hermite spline segment. // This calculates the integral of |dP/dt| dt, where P(t) is the spline equation with components (x(t), y(t), z(t)). // This isn't solvable analytically, so we use a numerical method (Legendre-Gauss quadrature) which performs very well // with functions of this type, even with very few samples. In this case, just 5 samples is sufficient to yield a // reasonable result. struct FLegendreGaussCoefficient { float Abscissa; float Weight; }; static const FLegendreGaussCoefficient LegendreGaussCoefficients[] = { { 0.0f, 0.5688889f }, { -0.5384693f, 0.47862867f }, { 0.5384693f, 0.47862867f }, { -0.90617985f, 0.23692688f }, { 0.90617985f, 0.23692688f } }; const auto& StartPoint = SplineInfo.Points[Index]; const auto& EndPoint = SplineInfo.Points[Index == LastPoint ? 0 : Index + 1]; check(Index == LastPoint || (static_cast<int32>(EndPoint.InVal) - static_cast<int32>(StartPoint.InVal) == 1)); const auto& P0 = StartPoint.OutVal; const auto& T0 = StartPoint.LeaveTangent; const auto& P1 = EndPoint.OutVal; const auto& T1 = EndPoint.ArriveTangent; // Cache the coefficients to be fed into the function to calculate the spline derivative at each sample point as they are constant. const FVector Coeff1 = ((P0 - P1) * 2.0f + T0 + T1) * 3.0f; const FVector Coeff2 = (P1 - P0) * 6.0f - T0 * 4.0f - T1 * 2.0f; const FVector Coeff3 = T0; const float HalfParam = Param * 0.5f; float Length = 0.0f; for (const auto& LegendreGaussCoefficient : LegendreGaussCoefficients) { // Calculate derivative at each Legendre-Gauss sample, and perform a weighted sum const float Alpha = HalfParam * (1.0f + LegendreGaussCoefficient.Abscissa); const FVector Derivative = ((Coeff1 * Alpha + Coeff2) * Alpha + Coeff3) * ComponentToWorld.GetScale3D(); Length += Derivative.Size() * LegendreGaussCoefficient.Weight; } Length *= HalfParam; return Length; }
void AFlappyBirdCharacter::UpdateAnimation() { const FVector PlayerVelocity = GetVelocity(); const float PlayerSpeed = PlayerVelocity.Size(); // Are we moving or standing still? UPaperFlipbook* DesiredAnimation = (PlayerSpeed > 0.0f) ? RunningAnimation : IdleAnimation; GetSprite()->SetFlipbook(DesiredAnimation); }
/** * Draws a line with an arrow at the end. * * @param Start Starting point of the line. * @param End Ending point of the line. * @param Color Color of the line. * @param Mag Size of the arrow. */ void FDebugRenderSceneProxy::DrawLineArrow(FPrimitiveDrawInterface* PDI,const FVector &Start,const FVector &End,const FColor &Color,float Mag) const { // draw a pretty arrow FVector Dir = End - Start; const float DirMag = Dir.Size(); Dir /= DirMag; FVector YAxis, ZAxis; Dir.FindBestAxisVectors(YAxis,ZAxis); FMatrix ArrowTM(Dir,YAxis,ZAxis,Start); DrawDirectionalArrow(PDI,ArrowTM,Color,DirMag,Mag,SDPG_World); }
bool AMonster::isInAttackRangeOfPlayer() { ARaiderCharacter *avatar = Cast<ARaiderCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0)); if (!avatar) return false; FVector playerPos = avatar->GetActorLocation(); FVector toPlayer = playerPos - GetActorLocation(); float distanceToPlayer = toPlayer.Size(); return distanceToPlayer < AttackRangeSphere->GetScaledSphereRadius(); }
void ARadialForceActor::EditorApplyScale(const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown) { FVector ModifiedScale = DeltaScale * ( AActor::bUsePercentageBasedScaling ? 500.0f : 5.0f ); const float Multiplier = ( ModifiedScale.X > 0.0f || ModifiedScale.Y > 0.0f || ModifiedScale.Z > 0.0f ) ? 1.0f : -1.0f; if(ForceComponent) { ForceComponent->Radius += Multiplier * ModifiedScale.Size(); ForceComponent->Radius = FMath::Max( 0.f, ForceComponent->Radius ); } }
void UBTTask_FlyTo::TickPathNavigation(UBehaviorTreeComponent& OwnerComp, FBT_FlyToTarget* MyMemory, float DeltaSeconds) { const auto& queryResults = MyMemory->QueryResults; APawn* pawn = OwnerComp.GetAIOwner()->GetPawn(); if (DebugParams.bVisualizePawnAsVoxels) NavigationManager->Debug_DrawVoxelCollisionProfile(Cast<UPrimitiveComponent>(pawn->GetRootComponent())); FVector flightDirection = queryResults.PathSolutionOptimized[MyMemory->solutionTraversalIndex] - pawn->GetActorLocation(); //auto navigator = Cast<IDonNavigator>(pawn); // Add movement input: if (MyMemory->bIsANavigator) { // Customized movement handling for advanced users: IDonNavigator::Execute_AddMovementInputCustom(pawn, flightDirection, 1.f); } else { // Default movement (handled by Pawn or Character class) pawn->AddMovementInput(flightDirection, 1.f); } FVector test = FVector(10,10,100); //test. // Reached next segment: if (flightDirection.Size() <= MinimumProximityRequired) { // Goal reached? if (MyMemory->solutionTraversalIndex == queryResults.PathSolutionOptimized.Num() - 1) { UBlackboardComponent* blackboard = pawn->GetController()->FindComponentByClass<UBlackboardComponent>(); blackboard->SetValueAsBool(FlightResultKey.SelectedKeyName, true); blackboard->SetValueAsBool(KeyToFlipFlopWhenTaskExits.SelectedKeyName, !blackboard->GetValueAsBool(KeyToFlipFlopWhenTaskExits.SelectedKeyName)); // Unregister all dynamic collision listeners. We've completed our task and are no longer interested in listening to these: NavigationManager->StopListeningToDynamicCollisionsForPath(MyMemory->DynamicCollisionListener, queryResults); FinishLatentTask(OwnerComp, EBTNodeResult::Succeeded); return; } else { MyMemory->solutionTraversalIndex++; } } }
void UFlareSpacecraftNavigationSystem::UpdateAngularBraking(float DeltaSeconds) { AngularTargetVelocity = FVector::ZeroVector; FVector AngularVelocity = Spacecraft->Airframe->GetPhysicsAngularVelocity(); // Null speed detection if (AngularVelocity.Size() < NegligibleSpeedRatio * AngularMaxVelocity) { AngularTargetVelocity = FVector::ZeroVector; Spacecraft->Airframe->SetPhysicsAngularVelocity(FVector::ZeroVector, false); // TODO remove ClearCurrentCommand(); } }
void UFlareSpacecraftNavigationSystem::UpdateLinearBraking(float DeltaSeconds, FVector TargetVelocity) { LinearTargetVelocity = TargetVelocity; FVector DeltaLinearVelocity = TargetVelocity*100 - Spacecraft->Airframe->GetPhysicsLinearVelocity(); // Null speed detection if (DeltaLinearVelocity.Size() < NegligibleSpeedRatio * LinearMaxVelocity) { Spacecraft->Airframe->SetAllPhysicsLinearVelocity(TargetVelocity*100); ClearCurrentCommand(); } }
void ATP_2DSideScrollerCharacter::UpdateAnimation() { const FVector PlayerVelocity = GetVelocity(); const float PlayerSpeed = PlayerVelocity.Size(); // Are we moving or standing still? UPaperFlipbook* DesiredAnimation = (PlayerSpeed > 0.0f) ? RunningAnimation : IdleAnimation; if( GetSprite()->GetFlipbook() != DesiredAnimation ) { GetSprite()->SetFlipbook(DesiredAnimation); } }
static bool GetBarycentricWeights( const FVector& Position0, const FVector& Position1, const FVector& Position2, FVector InterpolatePosition, float Tolerance, FVector& BarycentricWeights ) { BarycentricWeights = FVector::ZeroVector; FVector TriangleNormal = (Position0 - Position1) ^ (Position2 - Position0); float ParallelogramArea = TriangleNormal.Size(); FVector UnitTriangleNormal = TriangleNormal / ParallelogramArea; float PlaneDistance = UnitTriangleNormal | (InterpolatePosition - Position0); // Only continue if the position to interpolate to is in the plane of the triangle (within some error) if (FMath::Abs(PlaneDistance) < Tolerance) { // Move the position to interpolate to into the plane of the triangle along the normal, // Otherwise there will be error in our barycentric coordinates InterpolatePosition -= UnitTriangleNormal * PlaneDistance; FVector NormalU = (InterpolatePosition - Position1) ^ (Position2 - InterpolatePosition); // Signed area, if negative then InterpolatePosition is not in the triangle float ParallelogramAreaU = NormalU.Size() * FMath::FloatSelect(NormalU | TriangleNormal, 1.0f, -1.0f); float BaryCentricU = ParallelogramAreaU / ParallelogramArea; FVector NormalV = (InterpolatePosition - Position2) ^ (Position0 - InterpolatePosition); float ParallelogramAreaV = NormalV.Size() * FMath::FloatSelect(NormalV | TriangleNormal, 1.0f, -1.0f); float BaryCentricV = ParallelogramAreaV / ParallelogramArea; float BaryCentricW = 1.0f - BaryCentricU - BaryCentricV; if (BaryCentricU > -Tolerance && BaryCentricV > -Tolerance && BaryCentricW > -Tolerance) { BarycentricWeights = FVector(BaryCentricU, BaryCentricV, BaryCentricW); return true; } } return false; }