C++ FVector2D::SizeSquared方法代码示例

void SProfilerThreadView::DrawText( const FString& Text, const FSlateFontInfo& FontInfo, FVector2D Position, const FColor& TextColor, const FColor& ShadowColor, FVector2D ShadowOffset, const FSlateRect* ClippingRect /*= nullptr*/ ) const
{
	check( PaintState );

	if( ShadowOffset.SizeSquared() > 0.0f )
	{
		FSlateDrawElement::MakeText
		(
			PaintState->OutDrawElements,
			PaintState->LayerId,
			PaintState->AllottedGeometry.ToOffsetPaintGeometry( Position + ShadowOffset ),
			Text,
			FontInfo,
			ClippingRect ? *ClippingRect : PaintState->AbsoluteClippingRect,
			PaintState->DrawEffects,
			ShadowColor
		);
	}

	FSlateDrawElement::MakeText
	(
		PaintState->OutDrawElements,
		++PaintState->LayerId,
		PaintState->AllottedGeometry.ToOffsetPaintGeometry( Position ),
		Text,
		FontInfo,
		ClippingRect ? *ClippingRect : PaintState->AbsoluteClippingRect,
		PaintState->DrawEffects,
		TextColor
	);
}

/** Find the point on line segment from LineStart to LineEnd which is closest to Point */
FVector2D FGeometryHelper::FindClosestPointOnLine(const FVector2D& LineStart, const FVector2D& LineEnd, const FVector2D& TestPoint)
{
	const FVector2D LineVector = LineEnd - LineStart;

	const float A = -FVector2D::DotProduct(LineStart - TestPoint, LineVector);
	const float B = LineVector.SizeSquared();
	const float T = FMath::Clamp<float>(A / B, 0.0f, 1.0f);

	// Generate closest point
	return LineStart + (T * LineVector);
}

ETransformAction STransformHandle::ComputeActionAtLocation(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) const
{
	FVector2D LocalPosition = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
	FVector2D GrabOriginOffset = LocalPosition - DragOrigin;
	if ( GrabOriginOffset.SizeSquared() < 36.f )
	{
		return ETransformAction::Primary;
	}
	else
	{
		return ETransformAction::Secondary;
	}
}

FVector2D UAvoidanceComponent::GetPreferredVelocity()
{
	FVector2D ToTarget;
	if (bUseAITargetLocation && aiController)
	{
		ToTarget = FVector2D{ aiController->GetPathFollowingComponent()->GetCurrentTargetLocation() };
		//FVector2D actLoc {pawn->GetActorLocation() };
		//UE_LOG(LogRVOTest, Warning, TEXT("UAv::prefv GetCurrentTargetLocation, %f %f, actloc: %f %f"), CurrentTarget.X, CurrentTarget.Y, actLoc.X, actLoc.Y);
		//UE_LOG(LogRVOTest, Warning, TEXT("UAv::Totarget: %f %f"), ToTarget.X, ToTarget.Y);

	}
	else
	{
		ToTarget = FVector2D{ CurrentTarget - FVector2D{ pawn->GetActorLocation() } };
	}
	
	

	float sqrDist = ToTarget.SizeSquared();

	
	if (sqrDist < AcceptanceSquared)
		return FVector2D::ZeroVector;

	float m = 1.f / (SlowdownSquared - AcceptanceSquared);

	float b = -m * AcceptanceSquared;

	float k = (sqrDist < SlowdownSquared && pathFollowSlowdown) ? sqrDist * m + b : 1.f;
	if (k < SMALL_NUMBER)
	{
		return FVector2D::ZeroVector;
	}

	FVector2D res = ToTarget.GetSafeNormal() * MaxVelocity * k;
	
	if (res.ContainsNaN())
	{
		UE_LOG(LogRVOTest, VeryVerbose, TEXT("UAvoidanceComp:: GetPreferredV , %f %f"), res.X, res.Y);
	}
	

	return res;
}

float UKismetMathLibrary::VSize2DSquared(FVector2D A)
{
	return A.SizeSquared();
}

void UTapGestureRecognizer::ReceiveTick(float DeltaTime)
{
	Super::ReceiveTick(DeltaTime);
	if (CurrentTouchCount > PreviousTouchCount) // more fingers this tick than last means a tap sequence can't have ended
	{
		return;
	}
	
	float Now = GetWorld()->GetRealTimeSeconds();
	
	for (int32 i = 0; i < EKeys::NUM_TOUCH_KEYS; i++)
	{
		TapCounts[i] = 0;
	}
	
	bool bDidFindTapSequence = false;
	// If less fingers on screen, we could have a tap sequence in any of the fingers
	for (int32 Index = CurrentTouchCount; Index < EKeys::NUM_TOUCH_KEYS; Index++)
	{
		FGestureTouchData ThisTouch = TouchData[Index];
		if (ThisTouch.TouchStartTimes.Num() == 0) continue; // No points to look at, so bail
		
		if (Now > ThisTouch.LatestTouchTime + MaximumTimeBetweenTaps && ThisTouch.LatestTouchTime != 0.f)
		{
			// Make sure it wasn't a pan or swipe
			if (ThisTouch.TouchPoints.Num() > 1)
			{
				FVector2D TouchDelta = ThisTouch.TouchPoints.Last() - ThisTouch.TouchPoints[0];
				float MovementSquared = TouchDelta.SizeSquared();
				if (MovementSquared > 16.f) // More than 4 pixels of movement
				{
					// Not a tap, move along
					ResetGesture();
					continue;
				}
			}
			
			// Enough time has passed that this finger MIGHT have finished a tap sequence
			for (int32 TouchTimeIndex = ThisTouch.TouchStartTimes.Num()-1; TouchTimeIndex >= 0; TouchTimeIndex--)
			{
				float TapDuration = ThisTouch.TouchEndTimes[TouchTimeIndex] - ThisTouch.TouchStartTimes[TouchTimeIndex];
				if ( TapDuration >= MinimumTimeForTap && TapDuration <= MaximumTimeForTap)
				{
					// We have a tap! But was it part of a sequence?
					
					// First valid touch doesn't need this check
					if (TouchTimeIndex == ThisTouch.TouchStartTimes.Num()-1)
					{
						TapCounts[Index]++;
					}
					// Need to include 0 in the loop for single taps, but don't want to try and compare it with previous tap
					if (TouchTimeIndex > 0)
					{
						if (ThisTouch.TouchStartTimes[TouchTimeIndex] <= ThisTouch.TouchStartTimes[TouchTimeIndex-1] + MaximumTimeBetweenTaps)
						{
							TapCounts[Index]++;
						}
					}
				}
				else
				{
					break; // Not fast enough for tap
				}
			}
		}
		
		// Don't want to count this one again!
		if (TapCounts[Index] > 0)
		{
			bDidFindTapSequence = true;
		}
	}
	if (bDidFindTapSequence)
	{
		NumberOfFingersInTap = 0;
		int32 HighestTapCount = 0;
		int32 FirstIndexMatchingHighestTapCount;
		
		// Find the highest tap count for a finger
		for (int32 Index = 0; Index < EKeys::NUM_TOUCH_KEYS; Index++)
		{
			if (TapCounts[Index] > HighestTapCount)
			{
				HighestTapCount = TapCounts[Index];
				FirstIndexMatchingHighestTapCount = Index;
			}
		}
		// Find out how many fingers tapped for that amount
		for (int32 Index = 0; Index < EKeys::NUM_TOUCH_KEYS; Index++)
		{
			if (TapCounts[Index] == HighestTapCount)
			{
				NumberOfFingersInTap++;
			}
		}
		NumberOfTaps = HighestTapCount;
		LastTapLocation = TouchData[FirstIndexMatchingHighestTapCount].TouchPoints.Last();
		
		if (NumberOfTaps >= MinimumNumberOfTaps &&
			NumberOfTaps <= MaximumNumberOfTaps &&
//.........这里部分代码省略.........

void FVertexSnappingImpl::SnapDragDelta( FVertexSnappingArgs& InArgs, const FVector& StartLocation, const FBox& AllowedSnappingBox, TSet< TWeakObjectPtr<AActor> >& ActorsToIgnore, FVector& DragDelta )
{	
	const FSceneView* View = InArgs.SceneView;
	const FVector& DesiredUnsnappedLocation = InArgs.CurrentLocation;
	const FVector2D& MousePosition = InArgs.MousePosition;
	const EAxisList::Type CurrentAxis = InArgs.CurrentAxis;
	const FPlane ActorPlane = InArgs.ActorPlane;
	FLevelEditorViewportClient* ViewportClient = InArgs.ViewportClient;

	TArray<FSnapActor> PossibleSnapPointActors;
	GetPossibleSnapActors( AllowedSnappingBox, MousePosition.IntPoint(), ViewportClient, View, CurrentAxis, ActorsToIgnore, PossibleSnapPointActors );

	FVector Direction = FVector( ActorPlane.X, ActorPlane.Y, ActorPlane.Z );

	if( PossibleSnapPointActors.Num() > 0 )
	{
		// Get the closest vertex to the desired location (before snapping)
		FVector ClosestPoint = GetClosestVertex( PossibleSnapPointActors, InArgs ).Position;

		FVector PrevDragDelta = DragDelta;
		float Distance = 0;
		if( CurrentAxis != EAxisList::Screen )
		{
			// Compute a distance from the stat location to the snap point.  
			// When not using the screen space translation we snap to the plane along the movement axis that the nearest vertex is on and not the vertex itself
			FPlane RealPlane( StartLocation, Direction );
			Distance = RealPlane.PlaneDot( ClosestPoint );
						
			// Snap to the plane
			DragDelta = Distance*Direction;
		}
		else
		{
			// Snap to the nearest vertex
			DragDelta = ClosestPoint-StartLocation;
			Distance = DragDelta.Size();			
		}

		const FVector& PreSnapLocation = StartLocation;

		// Compute snapped location after computing the new drag delta
		FVector SnappedLocation = StartLocation+DragDelta;
				
		if( ViewportClient->IsPerspective() )
		{
			// Distance from start location to the location the actor would be in without snapping
			float DistFromPreSnapToDesiredUnsnapped = FVector::DistSquared( PreSnapLocation, DesiredUnsnappedLocation );

			// Distance from the new location of the actor without snapping to the location with snapping
			float DistFromDesiredUnsnappedToSnapped = FVector::DistSquared( DesiredUnsnappedLocation, SnappedLocation );

			// Only snap if the distance to the snapped location is less than the distance to the unsnapped location.  
			// This allows the user to control the speed of snapping based on how fast they move the mouse and also avoids jerkiness when the mouse is behind the snap location
			if( (CurrentAxis != EAxisList::Screen && DistFromDesiredUnsnappedToSnapped >= DistFromPreSnapToDesiredUnsnapped) || ClosestPoint == DesiredUnsnappedLocation )
			{
				DragDelta = FVector::ZeroVector;
			}
		}
		else
		{
			FVector2D PreSnapLocationPixel;
			View->WorldToPixel( PreSnapLocation, PreSnapLocationPixel );

			FVector2D SnappedLocationPixel;
			View->WorldToPixel( SnappedLocation, SnappedLocationPixel );

			FVector2D SLtoML = SnappedLocationPixel-MousePosition;
			FVector2D PStoML = MousePosition-PreSnapLocationPixel;

			// Only snap if the distance to the snapped location is less than the distance to the unsnapped location
			float Dist2 = PStoML.SizeSquared();
			float Dist1 = SLtoML.SizeSquared();
			if( Dist1 >= Dist2 || ClosestPoint == DesiredUnsnappedLocation )
			{
				DragDelta = FVector::ZeroVector;
			}
		}
	}
}