RealDocs

50 results for "2d"

function
UKismetMathLibrary::Add_Vector2DFloat Engine

Adds a scalar float to both components of a 2D vector, returning (A.

function
UKismetMathLibrary::Add_Vector2DVector2D Engine

Returns the component-wise sum of two 2D vectors (A + B).

function
UKismetMathLibrary::BreakVector2D Engine

Decomposes an FVector2D into its individual X and Y double components via output parameters.

function
UKismetMathLibrary::ClampAxes2D Engine

Returns a copy of the vector with both X and Y clamped to [MinAxisVal, MaxAxisVal].

function
UKismetMathLibrary::Conv_DoubleToVector2D Engine

Broadcasts a single double to both components of an FVector2D, producing (InDouble, InDouble).

function
UKismetMathLibrary::Conv_IntPointToVector2D Engine

Converts an FIntPoint to an FVector2D by casting its integer X and Y components to double.

function
UKismetMathLibrary::Conv_IntVector2ToVector2D Engine

Converts an FIntVector2 (two int32 components) to an FVector2D (two doubles) component-wise.

function
UKismetMathLibrary::Conv_Vector2DToIntPoint Engine

Converts a 2D float vector to an integer point by truncating each component.

function
UKismetMathLibrary::Conv_Vector2DToVector Engine

Converts a 2D vector to a 3D vector by appending a Z component.

function
UKismetMathLibrary::Conv_VectorToVector2D Engine

Extracts the X and Y components of a 3D vector into an FVector2D, discarding the Z component entirely.

function
UGameplayStatics::CreateSound2D Engine

Creates a non-spatialized, non-attenuated UAudioComponent without immediately starting playback, useful when you need to configure the component before playing.

function
UKismetMathLibrary::CrossProduct2D Engine

Returns the 2D cross product (A.

function
UKismetMathLibrary::Distance2D Engine

Returns the Euclidean distance between two 2D points.

function
UKismetMathLibrary::DistanceSquared2D Engine

Returns the squared Euclidean distance between two 2D points without computing a square root.

function
UKismetMathLibrary::Divide_Vector2DFloat Engine

Divides both components of a 2D vector by a scalar, returning (A.

function
UKismetMathLibrary::Divide_Vector2DVector2D Engine

Performs element-wise division of two 2D vectors, returning {A.

function
UKismetMathLibrary::DotProduct2D Engine

Returns the dot product of two 2D vectors.

function
UKismetMathLibrary::EqualEqual_Vector2DVector2D Engine

Returns true if vector A is approximately equal to vector B within a per-component error tolerance.

function
UKismetMathLibrary::EqualExactly_Vector2DVector2D Engine

Returns true only if A and B are bit-exactly equal with no tolerance.

function
UKismetMathLibrary::FTruncVector2D Engine

Truncates each component of a 2D float vector toward zero, returning an integer 2D vector.

function
UKismetMathLibrary::GetAbs2D Engine

Returns a copy of the 2D vector with the absolute value applied to each component.

function
UKismetMathLibrary::GetAbsMax2D Engine

Returns the largest absolute value among the vector's X and Y components.

function
UKismetMathLibrary::GetMax2D Engine

Returns the larger of the vector's X and Y components, preserving sign.

function
UKismetMathLibrary::GetMin2D Engine

Returns the smaller of the vector's X and Y components, preserving sign.

function
UKismetMathLibrary::GetRotated2D Engine

Returns a copy of the 2D vector rotated by the given angle in degrees around the Z axis (0,0,1).

function
UKismetMathLibrary::IsNearlyZero2D Engine

Returns true if both components of the vector are within the given tolerance of zero.

function
UKismetMathLibrary::IsZero2D Engine

Returns true only if both X and Y are exactly 0.

function
UKismetMathLibrary::MakeBox2D Engine

Constructs a 2D axis-aligned bounding box from explicit Min and Max corners and sets IsValid to true.

function
UKismetMathLibrary::MakeVector2D Engine

Constructs an FVector2D from explicit X and Y double values.

function
UKismetMathLibrary::Multiply_Vector2DFloat Engine

Scales a 2D vector uniformly by a scalar, returning (A.

function
UKismetMathLibrary::Multiply_Vector2DVector2D Engine

Performs element-wise multiplication of two 2D vectors, returning {A.

function
UKismetMathLibrary::Negated2D Engine

Returns a copy of the 2D vector with both components negated (-X, -Y).

function
UKismetMathLibrary::Normal2D Engine

Returns a unit-length copy of the 2D vector without any safety check.

function
UKismetMathLibrary::NormalSafe2D Engine

Returns a unit-length copy of the 2D vector, or (0,0) if the vector is too small to normalize safely.

function
UKismetMathLibrary::Normalize2D Engine

Normalizes a 2D vector in place.

function
UKismetMathLibrary::NotEqualExactly_Vector2DVector2D Engine

Returns true if A and B are not bit-exactly equal.

function
UKismetMathLibrary::NotEqual_Vector2DVector2D Engine

Returns true if vector A is not approximately equal to vector B, within a per-component tolerance.

function
UGameplayStatics::PlayDialogue2D Engine

Plays a UDialogueWave at 2D (non-spatialized) volume, suitable for UI or cinematic dialogue where positional audio is not needed.

function
UGameplayStatics::PlaySound2D Engine

Plays a non-spatialized (2D) sound that is not affected by the listener's position or orientation.

function
FMath::SegmentIntersection2D Core

Tests whether two 3D segments intersect when projected onto the XY plane and returns the intersection point.

function
UKismetMathLibrary::Set2D Engine

Sets the X and Y components of an existing FVector2D variable in place.

function
UGameplayStatics::SpawnDialogue2D Engine

Creates and plays a 2D (non-spatialized) UAudioComponent for a UDialogueWave, returning the component for runtime control such as stopping or fading.

function
UGameplayStatics::SpawnSound2D Engine

Spawns an audio component that plays a non-spatialized (2D) sound with no attenuation.

function
UKismetMathLibrary::Spherical2DToUnitCartesian Engine

Converts a 2D spherical coordinate (polar + azimuth in radians) to a unit-length 3D Cartesian direction vector on the unit sphere.

function
UKismetMathLibrary::Subtract_Vector2DFloat Engine

Subtracts a scalar float from both components of a 2D vector, returning (A.

function
UKismetMathLibrary::Subtract_Vector2DVector2D Engine

Returns the component-wise difference of two 2D vectors (A - B).

function
UKismetMathLibrary::ToDirectionAndLength2D Engine

Decomposes a 2D vector into its unit direction and scalar length in a single call.

function
UKismetMathLibrary::ToRounded2D Engine

Returns a copy of the 2D vector with each component rounded to the nearest integer.

function
UKismetMathLibrary::ToSign2D Engine

Returns a copy of the vector where each component is replaced with its sign: +1 for positive or zero, -1 for negative.

function
UKismetMathLibrary::VSize2D Engine

Returns the Euclidean length (magnitude) of a 2D vector.