unreal.MathLibrary ¶

classmethod add_int_point_int_point(a, b) → IntPoint¶

Returns IntPoint A added by B

Parameters:

a (IntPoint) –
b (IntPoint) –

Return type:

classmethod add_linear_color_linear_color(a, b) → LinearColor¶

Element-wise addition of two linear colors (R+R, G+G, B+B, A+A)

Parameters:

a (LinearColor) –
b (LinearColor) –

Return type:

classmethod add_matrix_matrix(a, b) → Matrix¶

Gets the result of adding a matrix to this.

Parameters:

a (Matrix) –
b (Matrix) –

Returns:

The result of addition.

Return type:

classmethod add_quat_quat(a, b) → Quat¶

Returns addition of Vector A and Vector B (A + B)

Parameters:

a (Quat) –
b (Quat) –

Return type:

classmethod add_timespan_timespan(a, b) → Timespan¶

Addition (A + B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

Timespan

classmethod add_vector2d_float(a, b) → Vector2D¶

Returns Vector A added by B

Parameters:

a (Vector2D) –
b (double) –

Return type:

classmethod add_vector2d_vector2d(a, b) → Vector2D¶

Returns addition of Vector A and Vector B (A + B)

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

classmethod add_vector4_vector4(a, b) → Vector4¶

Returns addition of Vector A and Vector B (A + B)

Parameters:

a (Vector4) –
b (Vector4) –

Return type:

classmethod add_vector_float(a, b) → Vector¶

Adds a float to each component of a vector

Parameters:

a (Vector) –
b (double) –

Return type:

classmethod add_vector_int(a, b) → Vector¶

Adds an integer to each component of a vector

Parameters:

a (Vector) –
b (int32) –

Return type:

classmethod add_vector_vector(a, b) → Vector¶

Vector addition

Parameters:

a (Vector) –
b (Vector) –

Return type:

classmethod and_int64_int64(a, b) → int64¶

Bitwise AND (A & B)

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod and_int_int(a, b) → int32¶

Bitwise AND (A & B)

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod asin(a) → double¶

Returns the inverse sine (arcsin) of A (result is in Radians)

Parameters:: a (double) –
Return type:: double

classmethod atan(a) → double¶

Returns the inverse tan (atan) (result is in Radians)

Parameters:: a (double) –
Return type:: double

classmethod atan2(y, x) → double¶

Returns the inverse tan (atan2) of A/B (result is in Radians)

Parameters:

y (double) –
x (double) –

Return type:

double

classmethod average_of_int_array(int_array) → float¶

Returns average of all array entries. Returns value of 0 if the supplied array is empty.

Parameters:: int_array (Array[int32]) –
Returns:: average_value (float):
Return type:: float

classmethod b_max(a, b) → uint8¶

Returns the maximum value of A and B

Parameters:

a (uint8) –
b (uint8) –

Return type:

uint8

classmethod b_min(a, b) → uint8¶

Returns the minimum value of A and B

Parameters:

a (uint8) –
b (uint8) –

Return type:

uint8

classmethod boolean_and(a, b) → bool¶

Returns the logical AND of two values (A AND B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod boolean_nand(a, b) → bool¶

Returns the logical NAND of two values (A AND B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod boolean_nor(a, b) → bool¶

Returns the logical Not OR of two values (A NOR B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod boolean_or(a, b) → bool¶

Returns the logical OR of two values (A OR B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod boolean_xor(a, b) → bool¶

Returns the logical eXclusive OR of two values (A XOR B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod box_expand_by(box, negative, positive) → Box¶

Returns a box of increased size.

Parameters:

box (Box) –
negative (Vector) – The size to increase the volume by in the negative direction (positive values move the bounds outwards)
positive (Vector) – The size to increase the volume by in the positive direction (positive values move the bounds outwards)

Returns:

A new bounding box.

Return type:

Box

classmethod box_get_closest_point_to(box, point) → Vector¶

Calculates the closest point on or inside the box to a given point in space.

Parameters:

box (Box) – The box to check if the point is inside of
point (Vector) – The point in space

Returns:

The closest point on or inside the box.

Return type:

classmethod box_intersects(a, b) → bool¶

Checks whether the given bounding box A intersects this bounding box B. note: This function assumes boxes have closed bounds, i.e. boxes with coincident borders on any edge will overlap.

Parameters:

a (Box) – The bounding box to check intersection against
b (Box) – The bounding box to intersect with.

Returns:

true if the boxes intersect, false otherwise.

Return type:

classmethod box_is_inside(inner_test, outer_test) → bool¶

Returns true if the InnerTest Box is is completely inside of the OuterTest Box

Parameters:

inner_test (Box) – The box to check if it is on the inside
outer_test (Box) – The box to check if InnerTest is within.

Returns:

True if InnerTest Box is is completely inside of OuterTest Box

Return type:

classmethod box_is_inside_or_on(inner_test, outer_test) → bool¶

Returns true if the InnerTest Box is is completely inside or on OuterTest Box

Parameters:

inner_test (Box) – The box to check if it is on the inside
outer_test (Box) – The box to check if InnerTest is within or on.

Returns:

True if InnerTest Box is is completely inside of or on OuterTest Box

Return type:

classmethod box_is_point_inside(box, point) → bool¶

Checks whether the given location is inside this box. note: This function assumes boxes have open bounds, i.e. points lying on the border of the box are not inside. Use IsPointInBox_Box to include borders in the test.

Parameters:

box (Box) – The box to test
point (Vector) – The location to test for inside the bounding volume.

Returns:

true if location is inside this volume.

Return type:

classmethod box_overlap(a, b) → Box¶

Returns the overlap TBox<T> of two boxes

Parameters:

a (Box) – The bounding box to test
b (Box) – The bounding box to test overlap against

Returns:

the overlap box. It can be 0 if they don’t overlap

Return type:

Box

classmethod break_color(color) -> (r=float, g=float, b=float, a=float)¶

Breaks apart a color into individual RGB components (as well as alpha)

Parameters:

color (LinearColor) –

Returns:

r (float):

g (float):

b (float):

a (float):

Return type:

tuple

classmethod break_rot_into_axes(rot) -> (x=Vector, y=Vector, z=Vector)¶

Breaks apart a rotator into its component axes

Parameters:

rot (Rotator) –

Returns:

x (Vector):

y (Vector):

z (Vector):

Return type:

tuple

classmethod c_interp_to(current, target, delta_time, interp_speed) → LinearColor¶

Interpolate Linear Color from Current to Target. Scaled by distance to Target, so it has a strong start speed and ease out.

Parameters:

current (LinearColor) – Current Color
target (LinearColor) – Target Color
delta_time (float) – Time since last tick
interp_speed (float) – Interpolation speed, if the speed given is 0, then jump to the target.

Returns:

New interpolated Color

Return type:

classmethod clamp(value, min, max) → int32¶

Returns Value clamped to be between A and B (inclusive)

Parameters:

value (int32) –
min (int32) –
max (int32) –

Return type:

int32

classmethod clamp_angle(angle_degrees, min_angle_degrees, max_angle_degrees) → double¶

Clamps an arbitrary angle to be between the given angles. Will clamp to nearest boundary.

Parameters:

angle_degrees (double) –
min_angle_degrees (double) – “from” angle that defines the beginning of the range of valid angles (sweeping clockwise)
max_angle_degrees (double) – “to” angle that defines the end of the range of valid angles

Returns:

Returns clamped angle in the range -180..180.

Return type:

double

classmethod clamp_axes2d(a, min_axis_val, max_axis_val) → Vector2D¶

Creates a copy of this vector with both axes clamped to the given range.

Parameters:

a (Vector2D) –
min_axis_val (double) –
max_axis_val (double) –

Returns:

New vector with clamped axes.

Return type:

classmethod clamp_axis(angle) → float¶

Clamps an angle to the range of [0, 360].

Parameters:: angle (float) – The angle to clamp.
Returns:: The clamped angle.
Return type:: float

classmethod clamp_int64(value, min, max) → int64¶

Returns Value clamped to be between A and B (inclusive)

Parameters:

value (int64) –
min (int64) –
max (int64) –

Return type:

int64

classmethod clamp_vector_size(a, min, max) → Vector¶

Create a copy of this vector, with its magnitude/size/length clamped between Min and Max.

Parameters:

a (Vector) –
min (double) –
max (double) –

Return type:

classmethod class_is_child_of(test_class, parent_class) → bool¶

Determine if a class is a child of another class.

Parameters:

test_class (type(Class)) –
parent_class (type(Class)) –

Returns:

true if TestClass == ParentClass, or if TestClass is a child of ParentClass; false otherwise, or if either the value for either parameter is ‘None’.

Return type:

classmethod compose_rotators(a, b) → Rotator¶

Combine 2 rotations to give you the resulting rotation of first applying A, then B.

Parameters:

a (Rotator) –
b (Rotator) –

Return type:

classmethod compose_transforms(a, b) → Transform¶

Compose two transforms in order: A * B.

Order matters when composing transforms: A * B will yield a transform that logically first applies A then B to any subsequent transformation.

Example: LocalToWorld = ComposeTransforms(DeltaRotation, LocalToWorld) will change rotation in local space by DeltaRotation. Example: LocalToWorld = ComposeTransforms(LocalToWorld, DeltaRotation) will change rotation in world space by DeltaRotation.

Parameters:

a (Transform) –
b (Transform) –

Returns:

New transform: A * B

Return type:

Transform

classmethod conv_bool_to_byte(bool) → uint8¶

Converts a bool to a byte

Parameters:: bool (bool) –
Return type:: uint8

classmethod conv_bool_to_double(bool) → double¶

Converts a bool to a float (0.0 or 1.0)

Parameters:: bool (bool) –
Return type:: double

classmethod conv_bool_to_float(bool: bool) → float¶: deprecated: ‘conv_bool_to_float’ was renamed to ‘conv_bool_to_double’.

classmethod conv_bool_to_int(bool) → int32¶

Converts a bool to an int

Parameters:: bool (bool) –
Return type:: int32

classmethod conv_byte_to_double(byte) → double¶

Converts a byte to a float

Parameters:: byte (uint8) –
Return type:: double

classmethod conv_byte_to_float(byte: int) → float¶: deprecated: ‘conv_byte_to_float’ was renamed to ‘conv_byte_to_double’.

classmethod conv_byte_to_int(byte) → int32¶

Converts a byte to an integer

Parameters:: byte (uint8) –
Return type:: int32

classmethod conv_byte_to_int64(byte) → int64¶

Converts a byte to an integer

Parameters:: byte (uint8) –
Return type:: int64

classmethod conv_color_to_linear_color(color) → LinearColor¶

Converts a color to LinearColor

Parameters:: color (Color) –
Return type:: LinearColor

classmethod conv_double_to_int64(double) → int64¶

Converts a float to a 64 bit integer

Parameters:: double (double) –
Return type:: int64

classmethod conv_double_to_linear_color(double) → LinearColor¶

Converts a float into a LinearColor, where each RGB element is that float

Parameters:: double (double) –
Return type:: LinearColor

classmethod conv_double_to_vector(double) → Vector¶

Converts a double into a vector, where each element is that float

Parameters:: double (double) –
Return type:: Vector

classmethod conv_double_to_vector2d(double) → Vector2D¶

Convert a float into a vector, where each element is that float

Parameters:: double (double) –
Return type:: Vector2D

classmethod conv_float_to_linear_color(double: float) → LinearColor¶: deprecated: ‘conv_float_to_linear_color’ was renamed to ‘conv_double_to_linear_color’.

classmethod conv_float_to_vector(double: float) → Vector¶: deprecated: ‘conv_float_to_vector’ was renamed to ‘conv_double_to_vector’.

classmethod conv_int64_to_byte(int) → uint8¶

Converts a 64 bit integer to a byte (if the integer is too large, returns the low 8 bits)

Parameters:: int (int64) –
Return type:: uint8

classmethod conv_int64_to_double(int) → double¶

Converts a 64 bit integer to a float

Parameters:: int (int64) –
Return type:: double

classmethod conv_int64_to_int(int) → int32¶

Converts a 64 bit integer to a 32 bit integer (if the integer is too large, returns the low 32 bits)

Parameters:: int (int64) –
Return type:: int32

classmethod conv_int_point_to_vector2d(int_point) → Vector2D¶

Converts an IntPoint to a Vector2D

Parameters:: int_point (IntPoint) –
Return type:: Vector2D

classmethod conv_int_to_bool(int) → bool¶

Converts a int to a bool

Parameters:: int (int32) –
Return type:: bool

classmethod conv_int_to_byte(int) → uint8¶

Converts an integer to a byte (if the integer is too large, returns the low 8 bits)

Parameters:: int (int32) –
Return type:: uint8

classmethod conv_int_to_double(int) → double¶

Converts an integer to a float

Parameters:: int (int32) –
Return type:: double

classmethod conv_int_to_float(int: int) → float¶: deprecated: ‘conv_int_to_float’ was renamed to ‘conv_int_to_double’.

classmethod conv_int_to_int64(int) → int64¶

Converts an integer to a 64 bit integer

Parameters:: int (int32) –
Return type:: int64

classmethod conv_int_to_int_vector(int) → IntVector¶

Converts an integer to an IntVector

Parameters:: int (int32) –
Return type:: IntVector

classmethod conv_int_to_vector(int) → Vector¶

Converts an integer to a FVector

Parameters:: int (int32) –
Return type:: Vector

classmethod conv_int_vector_to_vector(int_vector) → Vector¶

Converts an IntVector to a vector

Parameters:: int_vector (IntVector) –
Return type:: Vector

classmethod conv_linear_color_to_color(linear_color, use_srgb=True) → Color¶

Quantizes the linear color and returns the result as a FColor with optional sRGB conversion and quality as goal.

Parameters:

linear_color (LinearColor) –
use_srgb (bool) –

Return type:

Color

classmethod conv_linear_color_to_vector(linear_color) → Vector¶

Converts a LinearColor to a vector

Parameters:: linear_color (LinearColor) –
Return type:: Vector

classmethod conv_matrix_to_rotator(matrix) → Rotator¶

Converts a Matrix to a Rotator (Assumes Matrix represents a transform)

Parameters:: matrix (Matrix) –
Return type:: Rotator

classmethod conv_matrix_to_transform(matrix) → Transform¶

Converts a Matrix to a Transform (Assumes Matrix represents a transform)

Parameters:: matrix (Matrix) –
Return type:: Transform

classmethod conv_rotator_to_quaternion(rot) → Quat¶

Converts to Quaternion representation of this Rotator.

Parameters:: rot (Rotator) –
Return type:: Quat

classmethod conv_rotator_to_transform(rotator) → Transform¶

Converts Rotator to Transform

Parameters:: rotator (Rotator) –
Return type:: Transform

classmethod conv_rotator_to_vector(rot) → Vector¶

Get the X direction vector after this rotation

Parameters:: rot (Rotator) –
Return type:: Vector

classmethod conv_transform_to_matrix(transform) → Matrix¶

Converts a Transform to a Matrix with scale

Parameters:: transform (Transform) –
Return type:: Matrix

classmethod conv_vector2d_to_int_point(vector2d) → IntPoint¶

Converts a Vector2D to an IntPoint

Parameters:: vector2d (Vector2D) –
Return type:: IntPoint

classmethod conv_vector2d_to_vector(vector2d, z=0.000000) → Vector¶

Converts a Vector2D to a Vector

Parameters:

vector2d (Vector2D) –
z (float) –

Return type:

classmethod conv_vector4_to_quaterion(vec: Vector4) → Quat¶: deprecated: ‘conv_vector4_to_quaterion’ was renamed to ‘conv_vector4_to_quaternion’.

classmethod conv_vector4_to_quaternion(vec) → Quat¶

Return the Quaternion orientation corresponding to the direction in which the vector points. Similar to the FRotator version, returns a result without roll such that it preserves the up vector. note: If you don’t care about preserving the up vector and just want the most direct rotation, you can use the faster ‘FindBetweenVectors(ForwardVector, YourVector)’ or ‘FindBetweenNormals(…)’ if you know the vector is of unit length.

Parameters:: vec (Vector4) –
Returns:: Quaternion from the Vector’s direction, without any roll.
Return type:: Quat

classmethod conv_vector4_to_rotator(vec) → Rotator¶

Return the FRotator orientation corresponding to the direction in which the vector points. Sets Yaw and Pitch to the proper numbers, and sets Roll to zero because the roll can’t be determined from a vector.

Parameters:: vec (Vector4) –
Returns:: FRotator from the Vector’s direction, without any roll.
Return type:: Rotator

classmethod conv_vector4_to_vector(vector4) → Vector¶

Converts a Vector4 to a Vector (dropping the W element)

Parameters:: vector4 (Vector4) –
Return type:: Vector

classmethod conv_vector_to_linear_color(vec) → LinearColor¶

Converts a vector to LinearColor

Parameters:: vec (Vector) –
Return type:: LinearColor

classmethod conv_vector_to_quaterion(vec: Vector) → Quat¶: deprecated: ‘conv_vector_to_quaterion’ was renamed to ‘conv_vector_to_quaternion’.

classmethod conv_vector_to_quaternion(vec) → Quat¶

Return the Quaternion orientation corresponding to the direction in which the vector points. Similar to the FRotator version, returns a result without roll such that it preserves the up vector. note: If you don’t care about preserving the up vector and just want the most direct rotation, you can use the faster ‘FindBetweenVectors(ForwardVector, YourVector)’ or ‘FindBetweenNormals(…)’ if you know the vector is of unit length.

Parameters:: vec (Vector) –
Returns:: Quaternion from the Vector’s direction, without any roll.
Return type:: Quat

classmethod conv_vector_to_rotator(vec) → Rotator¶

Return the FRotator orientation corresponding to the direction in which the vector points. Sets Yaw and Pitch to the proper numbers, and sets Roll to zero because the roll can’t be determined from a vector.

Parameters:: vec (Vector) –
Returns:: FRotator from the Vector’s direction, without any roll.
Return type:: Rotator

classmethod conv_vector_to_transform(location) → Transform¶

Converts a vector to a transform. Uses vector as location

Parameters:: location (Vector) –
Return type:: Transform

classmethod conv_vector_to_vector2d(vector) → Vector2D¶

Converts a Vector to a Vector2D using the Vector’s (X, Y) coordinates

Parameters:: vector (Vector) –
Return type:: Vector2D

classmethod convert1d_to2d(index1d, x_size) → IntPoint¶

Maps a 1D array index to a 2D array index.

Parameters:

index1d (int32) – The 1D array index
x_size (int32) – X dimension of the 2D array

Returns:

The equivalent 2D index of the array

Return type:

classmethod convert1d_to3d(index1d, x_size, y_size) → IntVector¶

Maps a 1D array index to a 3D array index.

Parameters:

index1d (int32) – The 1D array index
x_size (int32) – X dimension of the 3D array
y_size (int32) – Y dimension of the 3D array

Returns:

The equivalent 3D index of the array

Return type:

IntVector

classmethod convert2d_to1d(index2d, x_size) → int32¶

Maps a 2D array index to a 1D array index.

Parameters:

index2d (IntPoint) – The 2D array index
x_size (int32) – X dimension of the 2D array

Returns:

The equivalent 1D index of the array

Return type:

int32

classmethod convert3d_to1d(index3d, x_size, y_size) → int32¶

Maps a 3D array index to a 1D array index.

Parameters:

index3d (IntVector) – The 3D array index
x_size (int32) – X dimension of the 3D array
y_size (int32) – Y dimension of the 3D array

Returns:

The equivalent 1D index of the array

Return type:

int32

classmethod convert_transform_to_relative(a: Transform, relative_to: Transform) → Transform¶: deprecated: ‘convert_transform_to_relative’ was renamed to ‘make_relative_transform’.

classmethod cos(a) → double¶

Returns the cosine of A (expects Radians)

Parameters:: a (double) –
Return type:: double

classmethod create_vector_from_yaw_pitch(yaw, pitch, length=1.000000) → Vector¶

Creates a directional vector from rotation values {Pitch, Yaw} supplied in degrees with specified Length

Parameters:

yaw (float) –
pitch (float) –
length (float) –

Return type:

classmethod cross_product2d(a, b) → double¶

Returns the cross product of two 2d vectors - see http://mathworld.wolfram.com/CrossProduct.html

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

double

classmethod cross_vector_vector(a, b) → Vector¶

Returns the cross product of two 3d vectors - see http://mathworld.wolfram.com/CrossProduct.html

Parameters:

a (Vector) –
b (Vector) –

Return type:

classmethod date_time_from_iso_string(iso_string) → DateTime or None¶

Converts a date string in ISO-8601 format to a DateTime object

Parameters:: iso_string (str) –
Returns:: result (DateTime):
Return type:: DateTime or None

classmethod date_time_from_string(date_time_string) → DateTime or None¶

Converts a date string to a DateTime object

Parameters:: date_time_string (str) –
Returns:: result (DateTime):
Return type:: DateTime or None

classmethod date_time_max_value() → DateTime¶

Returns the maximum date and time value

Return type:: DateTime

classmethod date_time_min_value() → DateTime¶

Returns the minimum date and time value

Return type:: DateTime

classmethod days_in_month(year, month) → int32¶

Returns the number of days in the given year and month

Parameters:

year (int32) –
month (int32) –

Return type:

int32

classmethod days_in_year(year) → int32¶

Returns the number of days in the given year

Parameters:: year (int32) –
Return type:: int32

classmethod deg_acos(a) → double¶

Returns the inverse cos (arccos) of A (result is in Degrees)

Parameters:: a (double) –
Return type:: double

classmethod deg_asin(a) → double¶

Returns the inverse sin (arcsin) of A (result is in Degrees)

Parameters:: a (double) –
Return type:: double

classmethod deg_atan(a) → double¶

Returns the inverse tan (atan) (result is in Degrees)

Parameters:: a (double) –
Return type:: double

classmethod deg_atan2(y, x) → double¶

Returns the inverse tan (atan2) of A/B (result is in Degrees)

Parameters:

y (double) –
x (double) –

Return type:

double

classmethod deg_cos(a) → double¶

Returns the cos of A (expects Degrees)

Parameters:: a (double) –
Return type:: double

classmethod deg_sin(a) → double¶

Returns the sin of A (expects Degrees)

Parameters:: a (double) –
Return type:: double

classmethod deg_tan(a) → double¶

Returns the tan of A (expects Degrees)

Parameters:: a (double) –
Return type:: double

classmethod degrees_to_radians(a) → double¶

Returns radians value based on the input degrees

Parameters:: a (double) –
Return type:: double

classmethod distance2d(v1, v2) → double¶

Distance between two 2D points.

Parameters:

v1 (Vector2D) – The first point.
v2 (Vector2D) – The second point.

Returns:

The distance between two 2D points.

Return type:

double

classmethod distance_squared2d(v1, v2) → double¶

Squared distance between two 2D points.

Parameters:

v1 (Vector2D) – The first point.
v2 (Vector2D) – The second point.

Returns:

The squared distance between two 2D points.

Return type:

double

classmethod divide_byte_byte(a, b=1) → uint8¶

Division (A / B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

uint8

classmethod divide_double_double(a, b=1.000000) → double¶

Division (A / B)

Parameters:

a (double) –
b (double) –

Return type:

double

classmethod divide_float_float(a: float, b: float = 1.0) → float¶: deprecated: ‘divide_float_float’ was renamed to ‘divide_double_double’.

classmethod divide_int64_int64(a, b=1) → int64¶

Division (A / B)

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod divide_int_int(a, b=1) → int32¶

Division (A / B)

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod divide_int_point_int(a, b) → IntPoint¶

Division (A * B)

Parameters:

a (IntPoint) –
b (int32) –

Return type:

classmethod divide_int_point_int_point(a, b) → IntPoint¶

Returns IntPoint A divided by B

Parameters:

a (IntPoint) –
b (IntPoint) –

Return type:

classmethod divide_linear_color_linear_color(a, b) → LinearColor¶

Element-wise multiplication of two linear colors (R/R, G/G, B/B, A/A)

Parameters:

a (LinearColor) –
b (LinearColor) –

Return type:

classmethod divide_timespan_float(a, scalar) → Timespan¶

Scalar division (A / s)

Parameters:

a (Timespan) –
scalar (float) –

Return type:

Timespan

classmethod divide_vector2d_float(a, b=1.000000) → Vector2D¶

Returns Vector A divided by B

Parameters:

a (Vector2D) –
b (double) –

Return type:

classmethod divide_vector2d_vector2d(a, b) → Vector2D¶

Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y})

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

classmethod divide_vector4_vector4(a, b) → Vector4¶

Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y, A.z/B.z, A.w/B.w})

Parameters:

a (Vector4) –
b (Vector4) –

Return type:

classmethod divide_vector_float(a, b=1.000000) → Vector¶

Vector divide by a float

Parameters:

a (Vector) –
b (double) –

Return type:

classmethod divide_vector_int(a, b=1) → Vector¶

Vector divide by an integer

Parameters:

a (Vector) –
b (int32) –

Return type:

classmethod divide_vector_vector(a, b=[1.000000, 1.000000, 1.000000]) → Vector¶

Element-wise Vector division (Result = {A.x/B.x, A.y/B.y, A.z/B.z})

Parameters:

a (Vector) –
b (Vector) –

Return type:

classmethod dot_product2d(a, b) → double¶

Returns the dot product of two 2d vectors - see http://mathworld.wolfram.com/DotProduct.html

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

double

classmethod dot_vector_vector(a, b) → double¶

Returns the dot product of two 3d vectors - see http://mathworld.wolfram.com/DotProduct.html

Parameters:

a (Vector) –
b (Vector) –

Return type:

double

classmethod dynamic_weighted_moving_average_f_rotator(current_sample, previous_sample, max_distance, min_weight, max_weight) → Rotator¶

Calculates the new value in a weighted moving average series using the previous value and a weight range. The weight range is used to dynamically adjust based upon distance between the samples This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)

Parameters:

current_sample (Rotator) – The value to blend with the previous sample to get a new weighted value
previous_sample (Rotator) – The last value from the series
max_distance (float) – Distance to use as the blend between min weight or max weight
min_weight (float) – The weight use when the distance is small
max_weight (float) – The weight use when the distance is large

Returns:

the next value in the series

Return type:

classmethod dynamic_weighted_moving_average_f_vector(current_sample, previous_sample, max_distance, min_weight, max_weight) → Vector¶

Calculates the new value in a weighted moving average series using the previous value and a weight range. The weight range is used to dynamically adjust based upon distance between the samples This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)

Parameters:

current_sample (Vector) – The value to blend with the previous sample to get a new weighted value
previous_sample (Vector) – The last value from the series
max_distance (float) – Distance to use as the blend between min weight or max weight
min_weight (float) – The weight use when the distance is small
max_weight (float) – The weight use when the distance is large

Returns:

the next value in the series

Return type:

classmethod dynamic_weighted_moving_average_float(current_sample, previous_sample, max_distance, min_weight, max_weight) → float¶

Calculates the new value in a weighted moving average series using the previous value and a weight range. The weight range is used to dynamically adjust based upon distance between the samples This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)

Parameters:

current_sample (float) – The value to blend with the previous sample to get a new weighted value
previous_sample (float) – The last value from the series
max_distance (float) – Distance to use as the blend between min weight or max weight
min_weight (float) – The weight use when the distance is small
max_weight (float) – The weight use when the distance is large

Returns:

the next value in the series

Return type:

classmethod equal_equal_bool_bool(a, b) → bool¶

Returns true if the values are equal (A == B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod equal_equal_byte_byte(a, b) → bool¶

Returns true if A is equal to B (A == B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

classmethod equal_equal_class_class(a, b) → bool¶

Returns true if A and B are equal (A == B)

Parameters:

a (type(Class)) –
b (type(Class)) –

Return type:

classmethod equal_equal_date_time_date_time(a, b) → bool¶

Returns true if the values are equal (A == B)

Parameters:

a (DateTime) –
b (DateTime) –

Return type:

classmethod equal_equal_double_double(a, b) → bool¶

Returns true if A is exactly equal to B (A == B)

Parameters:

a (double) –
b (double) –

Return type:

classmethod equal_equal_float_float(a: float, b: float) → bool¶: deprecated: ‘equal_equal_float_float’ was renamed to ‘equal_equal_double_double’.

classmethod equal_equal_int64_int64(a, b) → bool¶

Returns true if A is equal to B (A == B)

Parameters:

a (int64) –
b (int64) –

Return type:

classmethod equal_equal_int_int(a, b) → bool¶

Returns true if A is equal to B (A == B)

Parameters:

a (int32) –
b (int32) –

Return type:

classmethod equal_equal_linear_color_linear_color(a, b) → bool¶

Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance

Parameters:

a (LinearColor) –
b (LinearColor) –

Return type:

classmethod equal_equal_matrix_matrix(a, b, tolerance=0.000100) → bool¶

Checks whether another Matrix is equal to this, within specified tolerance.

Parameters:

a (Matrix) –
b (Matrix) –
tolerance (float) – Error Tolerance.

Returns:

true if two Matrix are equal, within specified tolerance, otherwise false.

Return type:

classmethod equal_equal_name_name(a, b) → bool¶

Returns true if A and B are equal (A == B)

Parameters:

a (Name) –
b (Name) –

Return type:

classmethod equal_equal_object_object(a, b) → bool¶

Returns true if A and B are equal (A == B)

Parameters:

a (Object) –
b (Object) –

Return type:

classmethod equal_equal_quat_quat(a, b, tolerance=0.000100) → bool¶

Returns true if Quaternion A is equal to Quaternion B (A == B) within a specified error tolerance

Parameters:

a (Quat) –
b (Quat) –
tolerance (float) –

Return type:

classmethod equal_equal_rotator_rotator(a, b, error_tolerance=0.000100) → bool¶

Returns true if rotator A is equal to rotator B (A == B) within a specified error tolerance

Parameters:

a (Rotator) –
b (Rotator) –
error_tolerance (float) –

Return type:

classmethod equal_equal_timespan_timespan(a, b) → bool¶

Returns true if the values are equal (A == B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

classmethod equal_equal_transform_transform(a, b) → bool¶

Returns true if transform A is equal to transform B

Parameters:

a (Transform) –
b (Transform) –

Return type:

classmethod equal_equal_vector2d_vector2d(a, b, error_tolerance=0.000100) → bool¶

Returns true if vector2D A is equal to vector2D B (A == B) within a specified error tolerance

Parameters:

a (Vector2D) –
b (Vector2D) –
error_tolerance (float) –

Return type:

classmethod equal_equal_vector4_vector4(a, b, error_tolerance=0.000100) → bool¶

Returns true if vector A is equal to vector B (A == B) within a specified error tolerance

Parameters:

a (Vector4) –
b (Vector4) –
error_tolerance (float) –

Return type:

classmethod equal_equal_vector_vector(a, b, error_tolerance=0.000100) → bool¶

Returns true if vector A is equal to vector B (A == B) within a specified error tolerance

Parameters:

a (Vector) –
b (Vector) –
error_tolerance (float) –

Return type:

classmethod equal_exactly_vector2d_vector2d(a, b) → bool¶

Returns true if vector A is equal to vector B (A == B)

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

classmethod equal_exactly_vector4_vector4(a, b) → bool¶

Returns true if vector A is equal to vector B (A == B)

Parameters:

a (Vector4) –
b (Vector4) –

Return type:

classmethod equal_exactly_vector_vector(a, b) → bool¶

Returns true if vector A is equal to vector B (A == B)

Parameters:

a (Vector) –
b (Vector) –

Return type:

classmethod equal_int_point_int_point(a, b) → bool¶

Returns true if IntPoint A is equal to IntPoint B (A == B)

Parameters:

a (IntPoint) –
b (IntPoint) –

Return type:

classmethod exp(a) → double¶

Returns exponential(e) to the power A (e^A)

Parameters:: a (double) –
Return type:: double

classmethod f_ceil(a) → int32¶

Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2)

Parameters:: a (double) –
Return type:: int32

classmethod f_ceil64(a) → int64¶

Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2)

Parameters:: a (double) –
Return type:: int64

classmethod f_clamp(value, min=0.000000, max=1.000000) → double¶

Returns Value clamped between A and B (inclusive)

Parameters:

value (double) –
min (double) –
max (double) –

Return type:

double

classmethod f_floor(a) → int32¶

Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1)

Parameters:: a (double) –
Return type:: int32

classmethod f_floor64(a) → int64¶

Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1)

Parameters:: a (double) –
Return type:: int64

classmethod f_interp_ease_in_out(a, b, alpha, exponent) → double¶

Interpolate between A and B, applying an ease in/out function. Exp controls the degree of the curve.

Parameters:

a (double) –
b (double) –
alpha (double) –
exponent (double) –

Return type:

double

classmethod f_interp_to(current, target, delta_time, interp_speed) → double¶

Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.

Parameters:

current (double) – Actual position
target (double) – Target position
delta_time (double) – Time since last tick
interp_speed (double) – Interpolation speed, if the speed given is 0, then jump to the target.

Returns:

New interpolated position

Return type:

double

classmethod f_interp_to_constant(current, target, delta_time, interp_speed) → double¶

Tries to reach Target at a constant rate.

Parameters:

current (double) – Actual position
target (double) – Target position
delta_time (double) – Time since last tick
interp_speed (double) – Interpolation speed

Returns:

New interpolated position

Return type:

double

classmethod f_max(a, b) → double¶

Returns the maximum value of A and B

Parameters:

a (double) –
b (double) –

Return type:

double

classmethod f_min(a, b) → double¶

Returns the minimum value of A and B

Parameters:

a (double) –
b (double) –

Return type:

double

classmethod f_mod(dividend, divisor) -> (int32, remainder=double)¶

Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder

Parameters:

dividend (double) –
divisor (double) –

Returns:

remainder (double):

Return type:

double

classmethod f_mod64(dividend, divisor) -> (int64, remainder=double)¶

Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder

Parameters:

dividend (double) –
divisor (double) –

Returns:

remainder (double):

Return type:

double

classmethod f_rand() → float¶: deprecated: ‘f_rand’ was renamed to ‘random_float’.

classmethod f_rand_from_stream(stream: RandomStream) → float¶: deprecated: ‘f_rand_from_stream’ was renamed to ‘random_float_from_stream’.

classmethod f_rand_range(min: float, max: float) → float¶: deprecated: ‘f_rand_range’ was renamed to ‘random_float_in_range’.

classmethod f_rand_range_from_stream(stream: RandomStream, min: float, max: float) → float¶: deprecated: ‘f_rand_range_from_stream’ was renamed to ‘random_float_in_range_from_stream’.

classmethod f_trunc(a) → int32¶

Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1)

Parameters:: a (double) –
Return type:: int32

classmethod f_trunc64(a) → int64¶

Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1)

Parameters:: a (double) –
Return type:: int64

classmethod f_trunc_vector(vector) → IntVector¶

Rounds A to an integer with truncation towards zero for each element in a vector. (e.g. -1.7 truncated to -1, 2.8 truncated to 2)

Parameters:: vector (Vector) –
Return type:: IntVector

classmethod f_wrap(value, min=0.000000, max=1.000000) → double¶

Returns Value wrapped from A and B (inclusive)

Parameters:

value (double) –
min (double) –
max (double) –

Return type:

double

classmethod find_closest_point_on_line(point, line_origin, line_direction) → Vector¶

Find the closest point on an infinite line to a given point.

Parameters:

point (Vector) – Point for which we find the closest point on the line.
line_origin (Vector) – Point of reference on the line.
line_direction (Vector) – Direction of the line. Not required to be normalized.

Returns:

The closest point on the line to the given point.

Return type:

classmethod find_closest_point_on_segment(point, segment_start, segment_end) → Vector¶

Find the closest point on a segment to a given point.

Parameters:

point (Vector) – Point for which we find the closest point on the segment.
segment_start (Vector) – Start of the segment.
segment_end (Vector) – End of the segment.

Returns:

The closest point on the segment to the given point.

Return type:

classmethod find_look_at_rotation(start, target) → Rotator¶

Find a rotation for an object at Start location to point at Target location.

Parameters:

start (Vector) –
target (Vector) –

Return type:

classmethod find_nearest_points_on_line_segments(segment1_start, segment1_end, segment2_start, segment2_end) -> (segment1_point=Vector, segment2_point=Vector)¶

Find closest points between 2 segments.

Parameters:

segment1_start (Vector) – Start of the 1st segment.
segment1_end (Vector) – End of the 1st segment.
segment2_start (Vector) – Start of the 2nd segment.
segment2_end (Vector) – End of the 2nd segment.

Returns:

segment1_point (Vector): Closest point on segment 1 to segment 2.

segment2_point (Vector): Closest point on segment 2 to segment 1.

Return type:

tuple

classmethod find_relative_look_at_rotation(start_transform, target_location) → Rotator¶

Find a local rotation (range of [-180, 180]) for an object with StartTransform to point at TargetLocation. Useful for getting LookAt Azimuth or Pawn Aim Offset.

Parameters:

start_transform (Transform) –
target_location (Vector) –

Return type:

classmethod fixed_turn(current, desired, delta_rate) → float¶

Returns a new rotation component value

Parameters:

current (float) – is the current rotation value
desired (float) – is the desired rotation value
delta_rate (float) – is the rotation amount to apply

Returns:

a new rotation component value clamped in the range (-360,360)

Return type:

classmethod float_spring_interp(current, target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, clamp=False, min_value=-1.000000, max_value=1.000000, initialize_from_target=False) -> (float, spring_state=FloatSpringState)¶

Uses a simple spring model to interpolate a float from Current to Target.

Parameters:

current (float) – Current value
target (float) – Target value
spring_state (FloatSpringState) – Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
stiffness (float) – How stiff the spring model is (more stiffness means more oscillation around the target value)
critical_damping_factor (float) – How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
delta_time (float) – Time difference since the last update
mass (float) – Multiplier that acts like mass on a spring
target_velocity_amount (float) – If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
clamp (bool) – Whether to use the Min/Max values to clamp the motion
min_value (float) – Clamps the minimum output value and cancels the velocity if it reaches this limit
max_value (float) – Clamps the maximum output value and cancels the velocity if it reaches this limit
initialize_from_target (bool) – If set then the current value will be set from the target on the first update

Returns:

spring_state (FloatSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring

Return type:

FloatSpringState

classmethod fraction(a) → double¶

Returns the fractional part of a float.

Parameters:: a (double) –
Return type:: double

classmethod from_days(days) → Timespan¶

Returns a time span that represents the specified number of days

Parameters:: days (float) –
Return type:: Timespan

classmethod from_hours(hours) → Timespan¶

Returns a time span that represents the specified number of hours

Parameters:: hours (float) –
Return type:: Timespan

classmethod from_milliseconds(milliseconds) → Timespan¶

Returns a time span that represents the specified number of milliseconds

Parameters:: milliseconds (float) –
Return type:: Timespan

classmethod from_minutes(minutes) → Timespan¶

Returns a time span that represents the specified number of minutes

Parameters:: minutes (float) –
Return type:: Timespan

classmethod from_seconds(seconds) → Timespan¶

Returns a time span that represents the specified number of seconds

Parameters:: seconds (float) –
Return type:: Timespan

classmethod from_unix_timestamp(unix_time) → DateTime¶

Returns the date from Unix time (seconds from midnight 1970-01-01) see: ToUnixTimestamp

Parameters:: unix_time (int64) – Unix time (seconds from midnight 1970-01-01)
Returns:: Gregorian date and time.
Return type:: DateTime

classmethod get_abs2d(a) → Vector2D¶

Get a copy of this vector with absolute value of each component.

Parameters:: a (Vector2D) –
Returns:: A copy of this vector with absolute value of each component.
Return type:: Vector2D

classmethod get_abs_max2d(a) → double¶

Get the maximum absolute value of the vector’s components.

Parameters:: a (Vector2D) –
Returns:: The maximum absolute value of the vector’s components.
Return type:: double

classmethod get_axes(a) -> (x=Vector, y=Vector, z=Vector)¶

Get the reference frame direction vectors (axes) described by this rotation

Parameters:

a (Rotator) –

Returns:

x (Vector):

y (Vector):

z (Vector):

Return type:

tuple

classmethod get_box_center(box) → Vector¶

Gets the center point of this box.

Parameters:: box (Box) –
Returns:: The center point.
Return type:: Vector

classmethod get_box_size(box) → Vector¶

Gets the size of this box.

Parameters:: box (Box) –
Returns:: The box size.
Return type:: Vector

classmethod get_box_volume(box) → double¶

Gets the volume of this box.

Parameters:: box (Box) –
Returns:: The box volume.
Return type:: double

classmethod get_date(a) → DateTime¶

Returns the date component of A

Parameters:: a (DateTime) –
Return type:: DateTime

classmethod get_day(a) → int32¶

Returns the day component of A (1 to 31)

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_day_of_year(a) → int32¶

Returns the day of year of A

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_days(a) → int32¶

Returns the days component of A

Parameters:: a (Timespan) –
Return type:: int32

classmethod get_direction_unit_vector(from_, to) → Vector¶

Find the unit direction vector from one position to another or (0,0,0) if positions are the same.

Parameters:

from (Vector) –
to (Vector) –

Return type:

classmethod get_direction_vector(from_: Vector, to: Vector) → Vector¶: deprecated: ‘get_direction_vector’ was renamed to ‘get_direction_unit_vector’.

classmethod get_duration(a) → Timespan¶

Returns the absolute value of A

Parameters:: a (Timespan) –
Return type:: Timespan

classmethod get_forward_vector(rot) → Vector¶

Rotate the world forward vector by the given rotation

Parameters:: rot (Rotator) –
Return type:: Vector

classmethod get_hour(a) → int32¶

Returns the hour component of A (24h format)

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_hour12(a) → int32¶

Returns the hour component of A (12h format)

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_hours(a) → int32¶

Returns the hours component of A

Parameters:: a (Timespan) –
Return type:: int32

classmethod get_max2d(a) → double¶

Get the maximum value of the vector’s components.

Parameters:: a (Vector2D) –
Returns:: The maximum value of the vector’s components.
Return type:: double

classmethod get_max_element(a) → double¶

Find the maximum element (X, Y or Z) of a vector

Parameters:: a (Vector) –
Return type:: double

classmethod get_millisecond(a) → int32¶

Returns the millisecond component of A

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_milliseconds(a) → int32¶

Returns the milliseconds component of A

Parameters:: a (Timespan) –
Return type:: int32

classmethod get_min2d(a) → double¶

Get the minimum value of the vector’s components.

Parameters:: a (Vector2D) –
Returns:: The minimum value of the vector’s components.
Return type:: double

classmethod get_min_element(a) → double¶

Find the minimum element (X, Y or Z) of a vector

Parameters:: a (Vector) –
Return type:: double

classmethod get_minute(a) → int32¶

Returns the minute component of A

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_minutes(a) → int32¶

Returns the minutes component of A

Parameters:: a (Timespan) –
Return type:: int32

classmethod get_month(a) → int32¶

Returns the month component of A

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_pi() → double¶

Returns the value of PI

Return type:: double

classmethod get_point_distance_to_line(point, line_origin, line_direction) → float¶

Find the distance from a point to the closest point on an infinite line.

Parameters:

point (Vector) – Point for which we find the distance to the closest point on the line.
line_origin (Vector) – Point of reference on the line.
line_direction (Vector) – Direction of the line. Not required to be normalized.

Returns:

The distance from the given point to the closest point on the line.

Return type:

classmethod get_point_distance_to_segment(point, segment_start, segment_end) → float¶

Find the distance from a point to the closest point on a segment.

Parameters:

point (Vector) – Point for which we find the distance to the closest point on the segment.
segment_start (Vector) – Start of the segment.
segment_end (Vector) – End of the segment.

Returns:

The distance from the given point to the closest point on the segment.

Return type:

classmethod get_reflection_vector(direction, surface_normal) → Vector¶

Given a direction vector and a surface normal, returns the vector reflected across the surface normal. Produces a result like shining a laser at a mirror!

Parameters:

direction (Vector) – Direction vector the ray is coming from.
surface_normal (Vector) – A normal of the surface the ray should be reflected on.

Returns:

Reflected vector.

Return type:

classmethod get_right_vector(rot) → Vector¶

Rotate the world right vector by the given rotation

Parameters:: rot (Rotator) –
Return type:: Vector

classmethod get_rotated2d(a, angle_deg) → Vector2D¶

Rotates around axis (0,0,1)

Parameters:

a (Vector2D) –
angle_deg (float) – Angle to rotate (in degrees)

Returns:

Rotated Vector

Return type:

classmethod get_runtime_float_curve_value(curve, time, default_value=0.000000) → float¶

Evaluate this runtime float curve at the specified time see: FRichCurve::Eval

Parameters:

curve (RuntimeFloatCurve) – The runtime float curve to evaluate
time (float) – The time at which to evaluate the curve
default_value (float) – The default value which should be used if the curve cannot be evaluated at the given time.

Returns:

The curve’s value at the given time.

Return type:

classmethod get_second(a) → int32¶

Returns the second component of A

Parameters:: a (DateTime) –
Return type:: int32

classmethod get_seconds(a) → int32¶

Returns the seconds component of A

Parameters:: a (Timespan) –
Return type:: int32

classmethod get_slope_degree_angles(my_right_y_axis, floor_normal, up_vector) -> (out_slope_pitch_degree_angle=float, out_slope_roll_degree_angle=float)¶

Returns Slope Pitch and Roll angles in degrees based on the following information: outparam: OutSlopePitchDegreeAngle Slope Pitch angle (degrees) outparam: OutSlopeRollDegreeAngle Slope Roll angle (degrees)

Parameters:

my_right_y_axis (Vector) – Right (Y) direction unit vector of Actor standing on Slope.
floor_normal (Vector) – Floor Normal (unit) vector.
up_vector (Vector) – UpVector of reference frame.

Returns:

out_slope_pitch_degree_angle (float):

out_slope_roll_degree_angle (float):

Return type:

tuple

classmethod get_tau() → double¶

Returns the value of TAU (= 2 * PI)

Return type:: double

classmethod get_time_of_day(a) → Timespan¶

Returns the time elapsed since midnight of A

Parameters:: a (DateTime) –
Return type:: Timespan

classmethod get_total_days(a) → float¶

Returns the total number of days in A

Parameters:: a (Timespan) –
Return type:: float

classmethod get_total_hours(a) → float¶

Returns the total number of hours in A

Parameters:: a (Timespan) –
Return type:: float

classmethod get_total_milliseconds(a) → float¶

Returns the total number of milliseconds in A

Parameters:: a (Timespan) –
Return type:: float

classmethod get_total_minutes(a) → float¶

Returns the total number of minutes in A

Parameters:: a (Timespan) –
Return type:: float

classmethod get_total_seconds(a) → float¶

Returns the total number of seconds in A

Parameters:: a (Timespan) –
Return type:: float

classmethod get_up_vector(rot) → Vector¶

Rotate the world up vector by the given rotation

Parameters:: rot (Rotator) –
Return type:: Vector

classmethod get_vector_array_average(vectors) → Vector¶

Find the average of an array of vectors

Parameters:: vectors (Array[Vector]) –
Return type:: Vector

classmethod get_year(a) → int32¶

Returns the year component of A

Parameters:: a (DateTime) –
Return type:: int32

classmethod greater_byte_byte(a, b) → bool¶

Returns true if A is greater than B (A > B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

classmethod greater_date_time_date_time(a, b) → bool¶

Returns true if A is greater than B (A > B)

Parameters:

a (DateTime) –
b (DateTime) –

Return type:

classmethod greater_double_double(a, b) → bool¶

Returns true if A is greater than B (A > B)

Parameters:

a (double) –
b (double) –

Return type:

classmethod greater_equal_byte_byte(a, b) → bool¶

Returns true if A is greater than or equal to B (A >= B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

classmethod greater_equal_date_time_date_time(a, b) → bool¶

Returns true if A is greater than or equal to B (A >= B)

Parameters:

a (DateTime) –
b (DateTime) –

Return type:

classmethod greater_equal_double_double(a, b) → bool¶

Returns true if A is greater than or equal to B (A >= B)

Parameters:

a (double) –
b (double) –

Return type:

classmethod greater_equal_float_float(a: float, b: float) → bool¶: deprecated: ‘greater_equal_float_float’ was renamed to ‘greater_equal_double_double’.

classmethod greater_equal_int64_int64(a, b) → bool¶

Returns true if A is greater than or equal to B (A >= B)

Parameters:

a (int64) –
b (int64) –

Return type:

classmethod greater_equal_int_int(a, b) → bool¶

Returns true if A is greater than or equal to B (A >= B)

Parameters:

a (int32) –
b (int32) –

Return type:

classmethod greater_equal_timespan_timespan(a, b) → bool¶

Returns true if A is greater than or equal to B (A >= B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

classmethod greater_float_float(a: float, b: float) → bool¶: deprecated: ‘greater_float_float’ was renamed to ‘greater_double_double’.

classmethod greater_greater_vector_rotator(a, b) → Vector¶

Returns result of vector A rotated by Rotator B

Parameters:

a (Vector) –
b (Rotator) –

Return type:

classmethod greater_int64_int64(a, b) → bool¶

Returns true if A is greater than B (A > B)

Parameters:

a (int64) –
b (int64) –

Return type:

classmethod greater_int_int(a, b) → bool¶

Returns true if A is greater than B (A > B)

Parameters:

a (int32) –
b (int32) –

Return type:

classmethod greater_timespan_timespan(a, b) → bool¶

Returns true if A is greater than B (A > B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

classmethod grid_snap_float(location, grid_size) → double¶

Snaps a value to the nearest grid multiple. E.g.,: Location = 5.1, GridSize = 10.0 : return value = 10.0

If GridSize is 0 Location is returned if GridSize is very small precision issues may occur.

Parameters:

location (double) –
grid_size (double) –

Return type:

double

classmethod hsv_to_rgb(h, s, v, a=1.000000) → LinearColor¶

Make a color from individual color components (HSV space; Hue is [0..360) while Saturation and Value are 0..1)

Parameters:

h (float) –
s (float) –
v (float) –
a (float) –

Return type:

classmethod hsv_to_rgb_linear(hsv) → LinearColor¶

Converts a HSV linear color (where H is in R, S is in G, and V is in B) to linear RGB

Parameters:: hsv (LinearColor) –
Return type:: LinearColor

classmethod hsv_to_rgb_vector(hsv) → LinearColor¶

Converts a HSV linear color (where H is in R (0..360), S is in G (0..1), and V is in B (0..1)) to RGB

Parameters:: hsv (LinearColor) –
Returns:: rgb (LinearColor):
Return type:: LinearColor

classmethod hypotenuse(width, height) → double¶

Returns the hypotenuse of a right-angled triangle given the width and height.

Parameters:

width (double) –
height (double) –

Return type:

double

classmethod in_range_float_float(value, min=0.000000, max=1.000000, inclusive_min=True, inclusive_max=True) → bool¶

Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller

Parameters:

value (double) –
min (double) –
max (double) –
inclusive_min (bool) –
inclusive_max (bool) –

Return type:

classmethod in_range_int64_int64(value, min=0, max=10, inclusive_min=True, inclusive_max=True) → bool¶

Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller

Parameters:

value (int64) –
min (int64) –
max (int64) –
inclusive_min (bool) –
inclusive_max (bool) –

Return type:

classmethod in_range_int_int(value, min=0, max=10, inclusive_min=True, inclusive_max=True) → bool¶

Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller

Parameters:

value (int32) –
min (int32) –
max (int32) –
inclusive_min (bool) –
inclusive_max (bool) –

Return type:

classmethod inverse_lerp(value: float, range_min: float, range_max: float) → float¶: deprecated: ‘inverse_lerp’ was renamed to ‘normalize_to_range’.

classmethod inverse_transform_direction(t, direction) → Vector¶

Transform a direction vector by the inverse of the supplied transform - will not change its length. For example, if T was an object’s transform, this would transform a direction from world space to local space.

Parameters:

t (Transform) –
direction (Vector) –

Return type:

classmethod inverse_transform_location(t, location) → Vector¶

Transform a position by the inverse of the supplied transform. For example, if T was an object’s transform, this would transform a position from world space to local space.

Parameters:

t (Transform) –
location (Vector) –

Return type:

classmethod inverse_transform_position(t: Transform, location: Vector) → Vector¶: deprecated: ‘inverse_transform_position’ was renamed to ‘inverse_transform_location’.

classmethod inverse_transform_rotation(t, rotation) → Rotator¶

Transform a rotator by the inverse of the supplied transform. For example, if T was an object’s transform, this would transform a rotation from world space to local space.

Parameters:

t (Transform) –
rotation (Rotator) –

Return type:

classmethod invert_transform(t) → Transform¶

Returns the inverse of the given transform T.

Example: Given a LocalToWorld transform, WorldToLocal will be returned.

Parameters:: t (Transform) – The transform you wish to invert
Returns:: The inverse of T.
Return type:: Transform

classmethod is_afternoon(a) → bool¶

Returns whether A’s time is in the afternoon

Parameters:: a (DateTime) –
Return type:: bool

classmethod is_leap_year(year) → bool¶

Returns whether given year is a leap year

Parameters:: year (int32) –
Return type:: bool

classmethod is_morning(a) → bool¶

Returns whether A’s time is in the morning

Parameters:: a (DateTime) –
Return type:: bool

classmethod is_nearly_zero2d(a, tolerance=0.000100) → bool¶

Checks whether vector is near to zero within a specified tolerance.

Parameters:

a (Vector2D) –
tolerance (float) – Error tolerance.

Returns:

true if vector is in tolerance to zero, otherwise false.

Return type:

classmethod is_point_in_box(point, box_origin, box_extent) → bool¶

Determines whether the given point is in a box. Includes points on the box.

Parameters:

point (Vector) – Point to test
box_origin (Vector) – Origin of the box
box_extent (Vector) – Extents of the box (distance in each axis from origin)

Returns:

Whether the point is in the box.

Return type:

classmethod is_point_in_box_box(point, box) → bool¶

Determines whether the given point is in a box. Includes points on the box.

Parameters:

point (Vector) – Point to test
box (Box) – Box to test against

Returns:

Whether the point is in the box.

Return type:

classmethod is_point_in_box_with_transform(point, box_world_transform, box_extent) → bool¶

Determines whether a given point is in a box with a given transform. Includes points on the box.

Parameters:

point (Vector) – Point to test
box_world_transform (Transform) – Component-to-World transform of the box.
box_extent (Vector) – Extents of the box (distance in each axis from origin), in component space.

Returns:

Whether the point is in the box.

Return type:

classmethod is_point_in_box_with_transform_box(point, box_world_transform, box_extent) → bool¶

Determines whether a given point is in a box with a given transform. Includes points on the box.

Parameters:

point (Vector) – Point to test
box_world_transform (Transform) – Component-to-World transform of the box.
box_extent (Box) –

Returns:

Whether the point is in the box.

Return type:

classmethod is_zero2d(a) → bool¶

Checks whether all components of the vector are exactly zero.

Parameters:: a (Vector2D) –
Returns:: true if vector is exactly zero, otherwise false.
Return type:: bool

classmethod lerp(a, b, alpha) → double¶

Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)

Parameters:

a (double) –
b (double) –
alpha (double) –

Return type:

double

classmethod less_byte_byte(a, b) → bool¶

Returns true if A is less than B (A < B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

classmethod less_date_time_date_time(a, b) → bool¶

Returns true if A is less than B (A < B)

Parameters:

a (DateTime) –
b (DateTime) –

Return type:

classmethod less_double_double(a, b) → bool¶

Returns true if A is Less than B (A < B)

Parameters:

a (double) –
b (double) –

Return type:

classmethod less_equal_byte_byte(a, b) → bool¶

Returns true if A is less than or equal to B (A <= B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

classmethod less_equal_date_time_date_time(a, b) → bool¶

Returns true if A is less than or equal to B (A <= B)

Parameters:

a (DateTime) –
b (DateTime) –

Return type:

classmethod less_equal_double_double(a, b) → bool¶

Returns true if A is Less than or equal to B (A <= B)

Parameters:

a (double) –
b (double) –

Return type:

classmethod less_equal_float_float(a: float, b: float) → bool¶: deprecated: ‘less_equal_float_float’ was renamed to ‘less_equal_double_double’.

classmethod less_equal_int64_int64(a, b) → bool¶

Returns true if A is less than or equal to B (A <= B)

Parameters:

a (int64) –
b (int64) –

Return type:

classmethod less_equal_int_int(a, b) → bool¶

Returns true if A is less than or equal to B (A <= B)

Parameters:

a (int32) –
b (int32) –

Return type:

classmethod less_equal_timespan_timespan(a, b) → bool¶

Returns true if A is less than or equal to B (A <= B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

classmethod less_float_float(a: float, b: float) → bool¶: deprecated: ‘less_float_float’ was renamed to ‘less_double_double’.

classmethod less_int64_int64(a, b) → bool¶

Returns true if A is less than B (A < B)

Parameters:

a (int64) –
b (int64) –

Return type:

classmethod less_int_int(a, b) → bool¶

Returns true if A is less than B (A < B)

Parameters:

a (int32) –
b (int32) –

Return type:

classmethod less_less_vector_rotator(a, b) → Vector¶

Returns result of vector A rotated by the inverse of Rotator B

Parameters:

a (Vector) –
b (Rotator) –

Return type:

classmethod less_timespan_timespan(a, b) → bool¶

Returns true if A is less than B (A < B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

classmethod line_plane_intersection(line_start, line_end, a_plane) → (t=float, intersection=Vector) or None¶

Computes the intersection point between a line and a plane.

Parameters:

line_start (Vector) –
line_end (Vector) –
a_plane (Plane) –

Returns:

True if the intersection test was successful.

t (float): The t of the intersection between the line and the plane

intersection (Vector): The point of intersection between the line and the plane

Return type:

tuple or None

classmethod line_plane_intersection_origin_normal(line_start, line_end, plane_origin, plane_normal) → (t=float, intersection=Vector) or None¶

Computes the intersection point between a line and a plane.

Parameters:

line_start (Vector) –
line_end (Vector) –
plane_origin (Vector) –
plane_normal (Vector) –

Returns:

True if the intersection test was successful.

t (float): The t of the intersection between the line and the plane

intersection (Vector): The point of intersection between the line and the plane

Return type:

tuple or None

classmethod linear_color_desaturated(color, desaturation) → LinearColor¶

Returns a desaturated color, with 0 meaning no desaturation and 1 == full desaturation

Parameters:

color (LinearColor) –
desaturation (float) –

Returns:

Desaturated color

Return type:

classmethod linear_color_distance(c1, c2) → float¶

Euclidean distance between two color points.

Parameters:

c1 (LinearColor) –
c2 (LinearColor) –

Return type:

classmethod linear_color_get_luminance(color) → float¶

Returns the perceived brightness of a color on a display taking into account the impact on the human eye per color channel: green > red > blue.

Parameters:: color (LinearColor) –
Return type:: float

classmethod linear_color_get_max(color) → float¶

Returns the maximum color channel value in this color structure

Parameters:: color (LinearColor) –
Returns:: The maximum color channel value
Return type:: float

classmethod linear_color_get_min(color) → float¶

Returns the minimum color channel value in this color structure

Parameters:: color (LinearColor) –
Returns:: The minimum color channel value
Return type:: float

classmethod linear_color_is_near_equal(a, b, tolerance=0.000100) → bool¶

Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance

Parameters:

a (LinearColor) –
b (LinearColor) –
tolerance (float) –

Return type:

classmethod linear_color_lerp(a, b, alpha) → LinearColor¶

Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)

Parameters:

a (LinearColor) –
b (LinearColor) –
alpha (float) –

Return type:

classmethod linear_color_lerp_using_hsv(a, b, alpha) → LinearColor¶

Linearly interpolates between two colors by the specified Alpha amount (100% of A when Alpha=0 and 100% of B when Alpha=1). The interpolation is performed in HSV color space taking the shortest path to the new color’s hue. This can give better results than a normal lerp, but is much more expensive. The incoming colors are in RGB space, and the output color will be RGB. The alpha value will also be interpolated.

Parameters:

a (LinearColor) – The color and alpha to interpolate from as linear RGBA
b (LinearColor) – The color and alpha to interpolate to as linear RGBA
alpha (float) – Scalar interpolation amount (usually between 0.0 and 1.0 inclusive)

Returns:

The interpolated color in linear RGB space along with the interpolated alpha value

Return type:

classmethod linear_color_quantize(color) → Color¶

Quantizes the linear color and returns the result as an 8-bit color. This bypasses the SRGB conversion. deprecated: Use LinearColor_QuantizeRound instead for correct color conversion.

Parameters:: color (LinearColor) –
Return type:: Color

classmethod linear_color_quantize_round(color) → Color¶

Quantizes the linear color with rounding and returns the result as an 8-bit color. This bypasses the SRGB conversion.

Parameters:: color (LinearColor) –
Return type:: Color

classmethod linear_color_set(out_color, color) → LinearColor¶

Assign contents of InColor

Parameters:

out_color (LinearColor) –
color (LinearColor) –

Returns:

out_color (LinearColor):

Return type:

classmethod linear_color_set_from_hsv(out_color, h, s, v, a=1.000000) → LinearColor¶

Assigns an HSV color to a linear space RGB color

Parameters:

out_color (LinearColor) –
h (float) –
s (float) –
v (float) –
a (float) –

Returns:

out_color (LinearColor):

Return type:

classmethod linear_color_set_from_pow22(out_color, color) → LinearColor¶

Assigns an FColor coming from an observed Pow(1/2.2) output, into a linear color.

Parameters:

out_color (LinearColor) –
color (Color) – The Pow(1/2.2) color that needs to be converted into linear space.

Returns:

out_color (LinearColor):

Return type:

classmethod linear_color_set_from_srgb(out_color, srgb) → LinearColor¶

Assigns an FColor coming from an observed sRGB output, into a linear color.

Parameters:

out_color (LinearColor) –
srgb (Color) – The sRGB color that needs to be converted into linear space.

Returns:

out_color (LinearColor):

Return type:

classmethod linear_color_set_random_hue(out_color) → LinearColor¶

Sets to a random color. Choses a quite nice color based on a random hue.

Parameters:: out_color (LinearColor) –
Returns:: out_color (LinearColor):
Return type:: LinearColor

classmethod linear_color_set_rgba(out_color, r, g, b, a=1.000000) → LinearColor¶

Assign individual linear RGBA components.

Parameters:

out_color (LinearColor) –
r (float) –
g (float) –
b (float) –
a (float) –

Returns:

out_color (LinearColor):

Return type:

classmethod linear_color_set_temperature(out_color, temperature) → LinearColor¶

Converts temperature in Kelvins of a black body radiator to RGB chromaticity.

Parameters:

out_color (LinearColor) –
temperature (float) –

Returns:

out_color (LinearColor):

Return type:

classmethod linear_color_to_new_opacity(color, opacity) → LinearColor¶

Returns a copy of this color using the specified opacity/alpha.

Parameters:

color (LinearColor) –
opacity (float) –

Return type:

classmethod linear_color_to_rgbe(linear_color) → Color¶

Converts from linear to 8-bit RGBE as outlined in Gregory Ward’s Real Pixels article, Graphics Gems II, page 80.

Parameters:: linear_color (LinearColor) –
Return type:: Color

classmethod log(a, base=1.000000) → double¶

Returns log of A base B (if B^R == A, returns R)

Parameters:

a (double) –
base (double) –

Return type:

double

classmethod loge(a) → double¶

Returns natural log of A (if e^R == A, returns R)

Parameters:: a (double) –
Return type:: double

classmethod make_box_with_origin(origin, extent) → Box¶

Utility function to build an box from an Origin and Extent

Parameters:

origin (Vector) – The location of the bounding box.
extent (Vector) – Half size of the bounding box.

Returns:

A new axis-aligned bounding box.

Return type:

Box

classmethod make_plane_from_point_and_normal(point, normal) → Plane¶

Creates a plane with a facing direction of Normal at the given Point

Parameters:

point (Vector) – A point on the plane
normal (Vector) – The Normal of the plane at Point

Returns:

Plane instance

Return type:

Plane

classmethod make_pulsating_value(current_time, pulses_per_second=1.000000, phase=0.000000) → float¶

Simple function to create a pulsating scalar value

Parameters:

current_time (float) – Current absolute time
pulses_per_second (float) – How many full pulses per second?
phase (float) – Optional phase amount, between 0.0 and 1.0 (to synchronize pulses)

Returns:

Pulsating value (0.0-1.0)

Return type:

classmethod make_relative_transform(a, relative_to) → Transform¶

Computes a relative transform of one transform compared to another.

Example: ChildOffset = MakeRelativeTransform(Child.GetActorTransform(), Parent.GetActorTransform()) This computes the relative transform of the Child from the Parent.

Parameters:

a (Transform) – The object’s transform
relative_to (Transform) – The transform the result is relative to (in the same space as A)

Returns:

The new relative transform

Return type:

Transform

classmethod make_rot_from_x(x) → Rotator¶

Builds a rotator given only a XAxis. Y and Z are unspecified but will be orthonormal. XAxis need not be normalized.

Parameters:: x (Vector) –
Return type:: Rotator

classmethod make_rot_from_xy(x, y) → Rotator¶

Builds a matrix with given X and Y axes. X will remain fixed, Y may be changed minimally to enforce orthogonality. Z will be computed. Inputs need not be normalized.

Parameters:

x (Vector) –
y (Vector) –

Return type:

classmethod make_rot_from_xz(x, z) → Rotator¶

Builds a matrix with given X and Z axes. X will remain fixed, Z may be changed minimally to enforce orthogonality. Y will be computed. Inputs need not be normalized.

Parameters:

x (Vector) –
z (Vector) –

Return type:

classmethod make_rot_from_y(y) → Rotator¶

Builds a rotation matrix given only a YAxis. X and Z are unspecified but will be orthonormal. YAxis need not be normalized.

Parameters:: y (Vector) –
Return type:: Rotator

classmethod make_rot_from_yx(y, x) → Rotator¶

Builds a matrix with given Y and X axes. Y will remain fixed, X may be changed minimally to enforce orthogonality. Z will be computed. Inputs need not be normalized.

Parameters:

y (Vector) –
x (Vector) –

Return type:

classmethod make_rot_from_yz(y, z) → Rotator¶

Builds a matrix with given Y and Z axes. Y will remain fixed, Z may be changed minimally to enforce orthogonality. X will be computed. Inputs need not be normalized.

Parameters:

y (Vector) –
z (Vector) –

Return type:

classmethod make_rot_from_z(z) → Rotator¶

Builds a rotation matrix given only a ZAxis. X and Y are unspecified but will be orthonormal. ZAxis need not be normalized.

Parameters:: z (Vector) –
Return type:: Rotator

classmethod make_rot_from_zx(z, x) → Rotator¶

Builds a matrix with given Z and X axes. Z will remain fixed, X may be changed minimally to enforce orthogonality. Y will be computed. Inputs need not be normalized.

Parameters:

z (Vector) –
x (Vector) –

Return type:

classmethod make_rot_from_zy(z, y) → Rotator¶

Builds a matrix with given Z and Y axes. Z will remain fixed, Y may be changed minimally to enforce orthogonality. X will be computed. Inputs need not be normalized.

Parameters:

z (Vector) –
y (Vector) –

Return type:

classmethod make_rotation_from_axes(forward, right, up) → Rotator¶

Build a reference frame from three axes

Parameters:

forward (Vector) –
right (Vector) –
up (Vector) –

Return type:

classmethod map_range(value: float, range_a: float, range_b: float, out_range_a: float, out_range_b: float) → float¶: deprecated: ‘map_range’ was renamed to ‘map_range_unclamped’.

classmethod map_range_clamped(value, range_a, range_b, out_range_a, out_range_b) → double¶

Returns Value mapped from one range into another where the Value is clamped to the Input Range. (e.g. 0.5 normalized from the range 0->1 to 0->50 would result in 25)

Parameters:

value (double) –
range_a (double) –
range_b (double) –
out_range_a (double) –
out_range_b (double) –

Return type:

double

classmethod map_range_unclamped(value, range_a, range_b, out_range_a, out_range_b) → double¶

Returns Value mapped from one range into another. (e.g. 20 normalized from the range 10->50 to 20->40 would result in 25)

Parameters:

value (double) –
range_a (double) –
range_b (double) –
out_range_a (double) –
out_range_b (double) –

Return type:

double

classmethod matrix_apply_scale(m, scale) → Matrix¶

Apply Scale to this matrix (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
scale (float) –

Return type:

classmethod matrix_concatenate_translation(m, translation) → Matrix¶

Returns a matrix with an additional translation concatenated. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
translation (Vector) –

Return type:

classmethod matrix_contains_na_n(m) → bool¶

Returns true if any element of this matrix is NaN

Parameters:: m (Matrix) –
Return type:: bool

classmethod matrix_get_column(m, column) → Vector¶

get a column of this matrix

Parameters:

m (Matrix) –
column (MatrixColumns) –

Returns:

vector of the column

Return type:

classmethod matrix_get_determinant(m) → float¶

Parameters:: m (Matrix) –
Returns:: determinant of this matrix.
Return type:: float

classmethod matrix_get_frustum_bottom_plane(m) → Plane or None¶

Get the bottom plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)

Parameters:: m (Matrix) –
Returns:: out_plane (Plane): the bottom plane of the Frustum of this matrix
Return type:: Plane or None

classmethod matrix_get_frustum_far_plane(m) → Plane or None¶

Get the far plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)

Parameters:: m (Matrix) –
Returns:: out_plane (Plane): the far plane of the Frustum of this matrix
Return type:: Plane or None

classmethod matrix_get_frustum_left_plane(m) → Plane or None¶

Get the left plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)

Parameters:: m (Matrix) –
Returns:: out_plane (Plane): the left plane of the Frustum of this matrix
Return type:: Plane or None

classmethod matrix_get_frustum_near_plane(m) → Plane or None¶

Get the near plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)

Parameters:: m (Matrix) –
Returns:: out_plane (Plane): the near plane of the Frustum of this matrix
Return type:: Plane or None

classmethod matrix_get_frustum_right_plane(m) → Plane or None¶

Get the right plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)

Parameters:: m (Matrix) –
Returns:: out_plane (Plane): the right plane of the Frustum of this matrix
Return type:: Plane or None

classmethod matrix_get_frustum_top_plane(m) → Plane or None¶

Get the top plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)

Parameters:: m (Matrix) –
Returns:: out_plane (Plane): the top plane of the Frustum of this matrix
Return type:: Plane or None

classmethod matrix_get_inverse(m) → Matrix¶

Get the inverse of the Matrix. Handles nil matrices.

Parameters:: m (Matrix) –
Return type:: Matrix

classmethod matrix_get_matrix_without_scale(m, tolerance=0.000000) → Matrix¶

Returns matrix after RemoveScaling with error Tolerance (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
tolerance (float) –

Return type:

classmethod matrix_get_maximum_axis_scale(m) → float¶

Parameters:: m (Matrix) –
Returns:: the maximum magnitude of any row of the matrix. (Assumes Matrix represents a transform)
Return type:: float

classmethod matrix_get_origin(matrix) → Vector¶

Get the origin of the co-ordinate system (Assumes Matrix represents a transform)

Parameters:: matrix (Matrix) –
Returns:: co-ordinate system origin
Return type:: Vector

classmethod matrix_get_rot_determinant(m) → float¶

Parameters:: m (Matrix) –
Returns:: the determinant of rotation 3x3 matrix (Assumes Top Left 3x3 Submatrix represents a Rotation)
Return type:: float

classmethod matrix_get_rotator(m) → Rotator¶

Get the rotator representation of this matrix (Assumes Matrix represents a transform)

Parameters:: m (Matrix) –
Returns:: rotator representation of this matrix
Return type:: Rotator

classmethod matrix_get_scale_vector(m, tolerance=0.000000) → Vector¶

return a 3D scale vector calculated from this matrix (where each component is the magnitude of a row vector) with error Tolerance. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
tolerance (float) –

Return type:

classmethod matrix_get_scaled_axes(m) -> (x=Vector, y=Vector, z=Vector)¶

get axes of this matrix scaled by the scale of the matrix (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –

Returns:

x (Vector): axes returned to this param

y (Vector): axes returned to this param

z (Vector): axes returned to this param

Return type:

tuple

classmethod matrix_get_scaled_axis(m, axis) → Vector¶

get axis of this matrix scaled by the scale of the matrix (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
axis (AxisType) –

Returns:

vector of the axis

Return type:

classmethod matrix_get_transpose_adjoint(m) → Matrix¶

Get the Transose Adjoint of the Matrix.

Parameters:: m (Matrix) –
Return type:: Matrix

classmethod matrix_get_transposed(m) → Matrix¶

Transpose.

Parameters:: m (Matrix) –
Return type:: Matrix

classmethod matrix_get_unit_axes(m) -> (x=Vector, y=Vector, z=Vector)¶

get unit length axes of this matrix (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –

Returns:

x (Vector): axes returned to this param

y (Vector): axes returned to this param

z (Vector): axes returned to this param

Return type:

tuple

classmethod matrix_get_unit_axis(m, axis) → Vector¶

get unit length axis of this matrix (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
axis (AxisType) –

Returns:

vector of the axis

Return type:

classmethod matrix_inverse_transform_position(m, v) → Vector¶

Inverts the matrix and then transforms V - correctly handles scaling in this matrix. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
v (Vector) –

Return type:

classmethod matrix_inverse_transform_vector(m, v) → Vector¶

Transform a direction vector by the inverse of this matrix - will not take into account translation part. If you want to transform a surface normal (or plane) and correctly account for non-uniform scaling you should use TransformByUsingAdjointT with adjoint of matrix inverse. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
v (Vector) –

Return type:

classmethod matrix_mirror(m, mirror_axis, flip_axis) → Matrix¶

Utility for mirroring this transform across a certain plane, and flipping one of the axis as well. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
mirror_axis (AxisType) –
flip_axis (AxisType) –

Return type:

classmethod matrix_remove_scaling(m, tolerance=0.000000) → Matrix¶

Remove any scaling from this matrix (ie magnitude of each row is 1) with error Tolerance (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
tolerance (float) –

Returns:

m (Matrix):

Return type:

classmethod matrix_remove_translation(m) → Matrix¶

Remove any translation from this matrix (Assumes Matrix represents a transform)

Parameters:: m (Matrix) –
Return type:: Matrix

classmethod matrix_scale_translation(m, scale3d) → Matrix¶

Scale the translation part of the matrix by the supplied vector. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
scale3d (Vector) –

Return type:

classmethod matrix_set_axis(m, axis, axis_vector) → Matrix¶

set an axis of this matrix (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
axis (AxisType) – vector of the axis
axis_vector (Vector) –

Returns:

m (Matrix):

Return type:

classmethod matrix_set_column(m, column, value) → Matrix¶

Matrix Set Column

Parameters:

m (Matrix) –
column (MatrixColumns) –
value (Vector) –

Returns:

m (Matrix):

Return type:

classmethod matrix_set_origin(m, new_origin) → Matrix¶

Set the origin of the coordinate system to the given vector (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
new_origin (Vector) –

Returns:

m (Matrix):

Return type:

classmethod matrix_to_quat(m) → Quat¶

Transform a rotation matrix into a quaternion. (Assumes Matrix represents a transform) warning: rotation part will need to be unit length for this to be right!

Parameters:: m (Matrix) –
Return type:: Quat

classmethod matrix_transform_position(m, v) → Vector4¶

Transform a location - will take into account translation part of the FMatrix. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
v (Vector) –

Return type:

classmethod matrix_transform_vector(m, v) → Vector4¶

Transform a direction vector - will not take into account translation part of the FMatrix. If you want to transform a surface normal (or plane) and correctly account for non-uniform scaling you should use TransformByUsingAdjointT. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
v (Vector) –

Return type:

classmethod matrix_transform_vector4(m, v) → Vector4¶

Transform a vector by the matrix. (Assumes Matrix represents a transform)

Parameters:

m (Matrix) –
v (Vector4) –

Return type:

classmethod max(a, b) → int32¶

Returns the maximum value of A and B

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod max_int64(a, b) → int64¶

Returns the maximum value of A and B

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod max_of_byte_array(byte_array) -> (index_of_max_value=int32, max_value=uint8)¶

Returns max of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.

Parameters:

byte_array (Array[uint8]) –

Returns:

index_of_max_value (int32):

max_value (uint8):

Return type:

tuple

classmethod max_of_float_array(float_array) -> (index_of_max_value=int32, max_value=float)¶

Returns max of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.

Parameters:

float_array (Array[float]) –

Returns:

index_of_max_value (int32):

max_value (float):

Return type:

tuple

classmethod max_of_int_array(int_array) -> (index_of_max_value=int32, max_value=int32)¶

Returns max of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.

Parameters:

int_array (Array[int32]) –

Returns:

index_of_max_value (int32):

max_value (int32):

Return type:

tuple

classmethod median_of_int_array(int_array) → float¶

Returns median of all array entries. Returns value of 0 if the supplied array is empty.

Parameters:: int_array (Array[int32]) –
Returns:: median_value (float):
Return type:: float

classmethod min(a, b) → int32¶

Returns the minimum value of A and B

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod min_area_rectangle(world_context_object, points, sample_surface_normal, debug_draw=False) -> (out_rect_center=Vector, out_rect_rotation=Rotator, out_rect_length_x=float, out_rect_length_y=float)¶

Finds the minimum area rectangle that encloses a set of coplanar points. Uses the exhaustive search algorithm in http://www.geometrictools.com/Documentation/MinimumAreaRectangle.pdf

Parameters:

world_context_object (Object) – Pointer to world context; only used when debug draw is enabled
points (Array[Vector]) – Points to enclose in the rectangle; need to be within the same plane for correct results
sample_surface_normal (Vector) – Normal indicating the surface direction for the points
debug_draw (bool) – Draws the output rectangle for debugging purposes provided the world context is set as well

Returns:

out_rect_center (Vector): Translation for the output rectangle from the origin

out_rect_rotation (Rotator): Rotation for the output rectangle from the XY plane

out_rect_length_x (float): Length of the output rectangle along the X axis before rotation

out_rect_length_y (float): Length of the output rectangle along the Y axis before rotation

Return type:

tuple

classmethod min_int64(a, b) → int64¶

Returns the minimum value of A and B

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod min_of_byte_array(byte_array) -> (index_of_min_value=int32, min_value=uint8)¶

Returns min of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.

Parameters:

byte_array (Array[uint8]) –

Returns:

index_of_min_value (int32):

min_value (uint8):

Return type:

tuple

classmethod min_of_float_array(float_array) -> (index_of_min_value=int32, min_value=float)¶

Returns min of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.

Parameters:

float_array (Array[float]) –

Returns:

index_of_min_value (int32):

min_value (float):

Return type:

tuple

classmethod min_of_int_array(int_array) -> (index_of_min_value=int32, min_value=int32)¶

Returns min of all array entries and the index at which it was found. Returns value of 0 and index of -1 if the supplied array is empty.

Parameters:

int_array (Array[int32]) –

Returns:

index_of_min_value (int32):

min_value (int32):

Return type:

tuple

classmethod minimum_area_rectangle(world_context_object, verts, sample_surface_normal, debug_draw=False) -> (out_rect_center=Vector, out_rect_rotation=Rotator, out_side_length_x=float, out_side_length_y=float)¶

Minimum Area Rectangle deprecated: Use ‘Min Area Rectangle’ instead; this deprecated version incorrectly returns the average of all input points as the rectangle center.

Parameters:

world_context_object (Object) –
verts (Array[Vector]) –
sample_surface_normal (Vector) –
debug_draw (bool) –

Returns:

out_rect_center (Vector):

out_rect_rotation (Rotator):

out_side_length_x (float):

out_side_length_y (float):

Return type:

tuple

classmethod mirror_vector_by_normal(vect, normal) → Vector¶

Given a direction vector and a surface normal, returns the vector reflected across the surface normal. Produces a result like shining a laser at a mirror!

Parameters:

vect (Vector) – Direction vector the ray is coming from.
normal (Vector) – A normal of the surface the ray should be reflected on.

Returns:

Reflected vector.

Return type:

classmethod multiply_by_pi(value) → double¶

Multiplies the input value by pi.

Parameters:: value (double) –
Return type:: double

classmethod multiply_byte_byte(a, b) → uint8¶

Multiplication (A * B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

uint8

classmethod multiply_double_double(a, b) → double¶

Multiplication (A * B)

Parameters:

a (double) –
b (double) –

Return type:

double

classmethod multiply_float_float(a: float, b: float) → float¶: deprecated: ‘multiply_float_float’ was renamed to ‘multiply_double_double’.

classmethod multiply_int64_int64(a, b) → int64¶

Multiplication (A * B)

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod multiply_int_float(a, b) → double¶

Multiplication (A * B)

Parameters:

a (int32) –
b (double) –

Return type:

double

classmethod multiply_int_int(a, b) → int32¶

Multiplication (A * B)

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod multiply_int_point_int(a, b) → IntPoint¶

Multiplication (A * B)

Parameters:

a (IntPoint) –
b (int32) –

Return type:

classmethod multiply_int_point_int_point(a, b) → IntPoint¶

Returns IntPoint A multiplied by B

Parameters:

a (IntPoint) –
b (IntPoint) –

Return type:

classmethod multiply_linear_color_float(a, b) → LinearColor¶

Element-wise multiplication of a linear color by a float (F*R, F*G, F*B, F*A)

Parameters:

a (LinearColor) –
b (float) –

Return type:

classmethod multiply_linear_color_linear_color(a, b) → LinearColor¶

Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A)

Parameters:

a (LinearColor) –
b (LinearColor) –

Return type:

classmethod multiply_matrix_float(a, b) → Matrix¶

Multiplies all values of the matrix by a float. If your Matrix represents a Transform that you wish to scale you should use Apply Scale instead

Parameters:

a (Matrix) –
b (double) –

Return type:

classmethod multiply_matrix_matrix(a, b) → Matrix¶

Gets the result of multiplying a Matrix to this.

Parameters:

a (Matrix) –
b (Matrix) –

Returns:

The result of multiplication.

Return type:

classmethod multiply_multiply_float_float(base, exp) → double¶

Power (Base to the Exp-th power)

Parameters:

base (double) –
exp (double) –

Return type:

double

classmethod multiply_quat_quat(a, b) → Quat¶

Gets the result of multiplying two quaternions (A * B).

Order matters when composing quaternions: C = A * B will yield a quaternion C that logically first applies B then A to any subsequent transformation (right first, then left).

Parameters:

a (Quat) –
b (Quat) – The Quaternion to multiply by.

Returns:

The result of multiplication (A * B).

Return type:

classmethod multiply_rotator_float(a, b) → Rotator¶

Returns rotator representing rotator A scaled by B

Parameters:

a (Rotator) –
b (float) –

Return type:

classmethod multiply_rotator_int(a, b) → Rotator¶

Returns rotator representing rotator A scaled by B

Parameters:

a (Rotator) –
b (int32) –

Return type:

classmethod multiply_timespan_float(a, scalar) → Timespan¶

Scalar multiplication (A * s)

Parameters:

a (Timespan) –
scalar (float) –

Return type:

Timespan

classmethod multiply_vector2d_float(a, b) → Vector2D¶

Returns Vector A scaled by B

Parameters:

a (Vector2D) –
b (double) –

Return type:

classmethod multiply_vector2d_vector2d(a, b) → Vector2D¶

Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y})

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

classmethod multiply_vector4_vector4(a, b) → Vector4¶

Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w})

Parameters:

a (Vector4) –
b (Vector4) –

Return type:

classmethod multiply_vector_float(a, b) → Vector¶

Scales Vector A by B

Parameters:

a (Vector) –
b (double) –

Return type:

classmethod multiply_vector_int(a, b) → Vector¶

Scales Vector A by B

Parameters:

a (Vector) –
b (int32) –

Return type:

classmethod multiply_vector_vector(a, b) → Vector¶

Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z})

Parameters:

a (Vector) –
b (Vector) –

Return type:

classmethod nearly_equal_float_float(a, b, error_tolerance=0.000001) → bool¶

Returns true if A is nearly equal to B (|A - B| < ErrorTolerance)

Parameters:

a (double) –
b (double) –
error_tolerance (double) –

Return type:

classmethod nearly_equal_rotator_rotator(a: Rotator, b: Rotator, error_tolerance: float = 0.0001) → bool¶: deprecated: ‘nearly_equal_rotator_rotator’ was renamed to ‘equal_equal_rotator_rotator’.

classmethod nearly_equal_transform_transform(a, b, location_tolerance=0.000100, rotation_tolerance=0.000100, scale3d_tolerance=0.000100) → bool¶

Returns true if transform A is nearly equal to B

Parameters:

a (Transform) –
b (Transform) –
location_tolerance (float) – How close position of transforms need to be to be considered equal
rotation_tolerance (float) – How close rotations of transforms need to be to be considered equal
scale3d_tolerance (float) – How close scale of transforms need to be to be considered equal

Return type:

classmethod nearly_equal_vector_vector(a: Vector, b: Vector, error_tolerance: float = 0.0001) → bool¶: deprecated: ‘nearly_equal_vector_vector’ was renamed to ‘equal_equal_vector_vector’.

classmethod negate_rotator(a) → Rotator¶

Negate a rotator

Parameters:: a (Rotator) –
Return type:: Rotator

classmethod negate_vector(a) → Vector¶

Negate a vector.

Parameters:: a (Vector) –
Return type:: Vector

classmethod negated2d(a) → Vector2D¶

Gets a negated copy of the vector.

Parameters:: a (Vector2D) –
Return type:: Vector2D

classmethod normal(a, tolerance=0.000100) → Vector¶

Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length. Returns zero vector if vector length is too small to safely normalize.

Parameters:

a (Vector) –
tolerance (float) – Minimum squared vector length.

Returns:

A normalized copy if safe, (0,0,0) otherwise.

Return type:

classmethod normal2d(a) → Vector2D¶

Returns a unit normal version of the 2D vector

Parameters:: a (Vector2D) –
Return type:: Vector2D

classmethod normal_safe2d(a, tolerance=0.000000) → Vector2D¶

Gets a normalized copy of the vector, checking it is safe to do so based on the length. Returns zero vector if vector length is too small to safely normalize.

Parameters:

a (Vector2D) –
tolerance (float) – Minimum squared length of vector for normalization.

Returns:

A normalized copy of the vector if safe, (0,0) otherwise.

Return type:

classmethod normalize2d(a, tolerance=0.000000) → Vector2D¶

Normalize this vector in-place if it is large enough, set it to (0,0) otherwise. see: NormalSafe2D()

Parameters:

a (Vector2D) –
tolerance (float) – Minimum squared length of vector for normalization.

Returns:

a (Vector2D):

Return type:

classmethod normalize_axis(angle) → float¶

Clamps an angle to the range of [-180, 180].

Parameters:: angle (float) – The Angle to clamp.
Returns:: The clamped angle.
Return type:: float

classmethod normalize_to_range(value, range_min, range_max) → double¶

Returns Value normalized to the given range. (e.g. 20 normalized to the range 10->50 would result in 0.25)

Parameters:

value (double) –
range_min (double) –
range_max (double) –

Return type:

double

classmethod normalized_delta_rotator(a, b) → Rotator¶

Normalized A-B

Parameters:

a (Rotator) –
b (Rotator) –

Return type:

classmethod not_equal_bool_bool(a, b) → bool¶

Returns true if the values are not equal (A != B)

Parameters:

a (bool) –
b (bool) –

Return type:

classmethod not_equal_byte_byte(a, b) → bool¶

Returns true if A is not equal to B (A != B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

classmethod not_equal_class_class(a, b) → bool¶

Returns true if A and B are not equal (A != B)

Parameters:

a (type(Class)) –
b (type(Class)) –

Return type:

classmethod not_equal_date_time_date_time(a, b) → bool¶

Returns true if the values are not equal (A != B)

Parameters:

a (DateTime) –
b (DateTime) –

Return type:

classmethod not_equal_double_double(a, b) → bool¶

Returns true if A does not equal B (A != B)

Parameters:

a (double) –
b (double) –

Return type:

classmethod not_equal_exactly_vector2d_vector2d(a, b) → bool¶

Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance

Parameters:

a (Vector2D) –
b (Vector2D) –

Return type:

classmethod not_equal_exactly_vector4_vector4(a, b) → bool¶

Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance

Parameters:

a (Vector4) –
b (Vector4) –

Return type:

classmethod not_equal_exactly_vector_vector(a, b) → bool¶

Returns true if vector A is not equal to vector B (A != B)

Parameters:

a (Vector) –
b (Vector) –

Return type:

classmethod not_equal_float_float(a: float, b: float) → bool¶: deprecated: ‘not_equal_float_float’ was renamed to ‘not_equal_double_double’.

classmethod not_equal_int64_int64(a, b) → bool¶

Returns true if A is not equal to B (A != B)

Parameters:

a (int64) –
b (int64) –

Return type:

classmethod not_equal_int_int(a, b) → bool¶

Returns true if A is not equal to B (A != B)

Parameters:

a (int32) –
b (int32) –

Return type:

classmethod not_equal_int_point_int_point(a, b) → bool¶

Returns true if IntPoint A is NOT equal to IntPoint B (A != B)

Parameters:

a (IntPoint) –
b (IntPoint) –

Return type:

classmethod not_equal_linear_color_linear_color(a, b) → bool¶

Returns true if linear color A is not equal to linear color B (A != B) within a specified error tolerance

Parameters:

a (LinearColor) –
b (LinearColor) –

Return type:

classmethod not_equal_matrix_matrix(a, b, tolerance=0.000100) → bool¶

Checks whether another Matrix is not equal to this, within specified tolerance.

Parameters:

a (Matrix) –
b (Matrix) –
tolerance (float) –

Returns:

true if two Matrix are not equal, within specified tolerance, otherwise false.

Return type:

classmethod not_equal_name_name(a, b) → bool¶

Returns true if A and B are not equal (A != B)

Parameters:

a (Name) –
b (Name) –

Return type:

classmethod not_equal_object_object(a, b) → bool¶

Returns true if A and B are not equal (A != B)

Parameters:

a (Object) –
b (Object) –

Return type:

classmethod not_equal_quat_quat(a, b, error_tolerance=0.000100) → bool¶

Returns true if Quat A is not equal to Quat B (A != B) within a specified error tolerance

Parameters:

a (Quat) –
b (Quat) –
error_tolerance (float) –

Return type:

classmethod not_equal_rotator_rotator(a, b, error_tolerance=0.000100) → bool¶

Returns true if rotator A is not equal to rotator B (A != B) within a specified error tolerance

Parameters:

a (Rotator) –
b (Rotator) –
error_tolerance (float) –

Return type:

classmethod not_equal_timespan_timespan(a, b) → bool¶

Returns true if the values are not equal (A != B)

Parameters:

a (Timespan) –
b (Timespan) –

Return type:

classmethod not_equal_vector2d_vector2d(a, b, error_tolerance=0.000100) → bool¶

Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance

Parameters:

a (Vector2D) –
b (Vector2D) –
error_tolerance (float) –

Return type:

classmethod not_equal_vector4_vector4(a, b, error_tolerance=0.000100) → bool¶

Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance

Parameters:

a (Vector4) –
b (Vector4) –
error_tolerance (float) –

Return type:

classmethod not_equal_vector_vector(a, b, error_tolerance=0.000100) → bool¶

Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance

Parameters:

a (Vector) –
b (Vector) –
error_tolerance (float) –

Return type:

classmethod not_int(a) → int32¶

Bitwise NOT (~A)

Parameters:: a (int32) –
Return type:: int32

classmethod not_int64(a) → int64¶

Bitwise NOT (~A)

Parameters:: a (int64) –
Return type:: int64

classmethod not_pre_bool(a) → bool¶

Returns the logical complement of the Boolean value (NOT A)

Parameters:: a (bool) –
Return type:: bool

classmethod now() → DateTime¶

Returns the local date and time on this computer

Return type:: DateTime

classmethod or_int64_int64(a, b) → int64¶

Bitwise OR (A | B)

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod or_int_int(a, b) → int32¶

Bitwise OR (A | B)

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod percent_byte_byte(a, b=1) → uint8¶

Modulo (A % B)

Parameters:

a (uint8) –
b (uint8) –

Return type:

uint8

classmethod percent_int64_int64(a, b=1) → int64¶

Modulo (A % B)

Parameters:

a (int64) –
b (int64) –

Return type:

int64

classmethod percent_int_int(a, b=1) → int32¶

Modulo (A % B)

Parameters:

a (int32) –
b (int32) –

Return type:

int32

classmethod perlin_noise1d(value) → float¶

Generates a 1D Perlin noise from the given value. Returns a continuous random value between -1.0 and 1.0.

Parameters:: value (float) – The input value that Perlin noise will be generated from. This is usually a steadily incrementing time value.
Returns:: Perlin noise in the range of -1.0 to 1.0
Return type:: float

classmethod points_are_coplanar(points, tolerance=0.100000) → bool¶

Determines whether a given set of points are coplanar, with a tolerance. Any three points or less are always coplanar.

Parameters:

points (Array[Vector]) – The set of points to determine coplanarity for.
tolerance (float) – Larger numbers means more variance is allowed.

Returns:

Whether the points are relatively coplanar, based on the tolerance

Return type:

classmethod project_on_to(v: Vector, target: Vector) → Vector¶: deprecated: ‘project_on_to’ was renamed to ‘project_vector_on_to_vector’.

classmethod project_point_on_to_plane(point, plane_base, plane_normal) → Vector¶

Projects/snaps a point onto a plane defined by a point on the plane and a plane normal.

Parameters:

point (Vector) – Point to project onto the plane.
plane_base (Vector) – A point on the plane.
plane_normal (Vector) – Normal of the plane.

Returns:

Point projected onto the plane.

Return type:

classmethod project_vector_on_to_plane(v, plane_normal) → Vector¶

Projects a vector onto a plane defined by a normalized vector (PlaneNormal).

Parameters:

v (Vector) – Vector to project onto the plane.
plane_normal (Vector) – Normal of the plane.

Returns:

Vector projected onto the plane.

Return type:

classmethod project_vector_on_to_vector(v, target) → Vector¶

Projects one vector (V) onto another (Target) and returns the projected vector. If Target is nearly zero in length, returns the zero vector.

Parameters:

v (Vector) – Vector to project.
target (Vector) – Vector on which we are projecting.

Returns:

V projected on to Target.

Return type:

classmethod quat_angular_distance(a, b) → float¶

Find the angular distance/difference between two rotation quaternions.

Parameters:

a (Quat) –
b (Quat) – Quaternion to find angle distance to

Returns:

angular distance in radians

Return type:

classmethod quat_enforce_shortest_arc_with(a, b) → Quat¶

Modify the quaternion to ensure that the delta between it and B represents the shortest possible rotation angle.

Parameters:

a (Quat) –
b (Quat) –

Returns:

a (Quat):

Return type:

classmethod quat_euler(q) → Vector¶

Convert a Quaternion into floating-point Euler angles (in degrees).

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_exp(q) → Quat¶

Used in combination with Log(). Assumes a quaternion with W=0 and V=theta*v (where |v| = 1). Exp(q) = (sin(theta)*v, cos(theta))

Parameters:: q (Quat) –
Return type:: Quat

classmethod quat_find_between_normals(start_normal, end_normal) → Quat¶

Generates the ‘smallest’ (geodesic) rotation around a sphere between two normals (assumed to be unit length).

Parameters:

start_normal (Vector) –
end_normal (Vector) –

Returns:

Quat that will rotate from Start to End

Return type:

classmethod quat_find_between_vectors(start, end) → Quat¶

Generates the ‘smallest’ (geodesic) rotation around a sphere between two vectors of arbitrary length.

Parameters:

start (Vector) – Vector the rotation starts from
end (Vector) – Vector the rotation ends at

Returns:

Quat that will rotate from Start to End

Return type:

classmethod quat_get_angle(q) → float¶

Get the angle of this quaternion

Parameters:: q (Quat) –
Return type:: float

classmethod quat_get_axis_x(q) → Vector¶

Get the forward direction (X axis) after it has been rotated by this Quaternion.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_get_axis_y(q) → Vector¶

Get the right direction (Y axis) after it has been rotated by this Quaternion.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_get_axis_z(q) → Vector¶

Get the up direction (Z axis) after it has been rotated by this Quaternion.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_get_rotation_axis(q) → Vector¶

Get the axis of rotation of the Quaternion. This is the axis around which rotation occurs to transform the canonical coordinate system to the target orientation. For the identity Quaternion which has no such rotation, FVector(1,0,0) is returned.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_inversed(q) → Quat¶

Return an inversed copy of this quaternion.

Parameters:: q (Quat) –
Return type:: Quat

classmethod quat_is_finite(q) → bool¶

Determine if all the values are finite (not NaN nor Inf) in this Quat.

Parameters:: q (Quat) –
Return type:: bool

classmethod quat_is_identity(q, tolerance=0.000100) → bool¶

Checks whether this Quaternion is an Identity Quaternion. Assumes Quaternion tested is normalized.

Parameters:

q (Quat) –
tolerance (float) – Error tolerance for comparison with Identity Quaternion.

Returns:

true if Quaternion is a normalized Identity Quaternion.

Return type:

classmethod quat_is_non_finite(q) → bool¶

Determine if there are any non-finite values (NaN or Inf) in this Quat.

Parameters:: q (Quat) –
Return type:: bool

classmethod quat_is_normalized(q) → bool¶

Return true if this quaternion is normalized

Parameters:: q (Quat) –
Return type:: bool

classmethod quat_log(q) → Quat¶

Quaternion with W=0 and V=theta*v. Used in combination with Exp().

Parameters:: q (Quat) –
Return type:: Quat

classmethod quat_make_from_euler(euler) → Quat¶

Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.

Parameters:: euler (Vector) – the Euler angles
Returns:: constructed Quat
Return type:: Quat

classmethod quat_normalize(q, tolerance=0.000100) → Quat¶

Normalize this quaternion if it is large enough as compared to the supplied tolerance. If it is too small then set it to the identity quaternion.

Parameters:

q (Quat) –
tolerance (float) – Minimum squared length of quaternion for normalization.

Returns:

q (Quat):

Return type:

classmethod quat_normalized(q, tolerance=0.000100) → Quat¶

Get a normalized copy of this quaternion. If it is too small, returns an identity quaternion.

Parameters:

q (Quat) –
tolerance (float) – Minimum squared length of quaternion for normalization.

Return type:

classmethod quat_rotate_vector(q, v) → Vector¶

Rotate a vector by this quaternion.

Parameters:

q (Quat) –
v (Vector) – the vector to be rotated

Returns:

vector after rotation

Return type:

classmethod quat_rotator(q) → Rotator¶

Converts to Rotator representation of this Quaternion.

Parameters:: q (Quat) –
Return type:: Rotator

classmethod quat_set_components(q, x, y, z, w) → Quat¶

Set X, Y, Z, W components of Quaternion.

Parameters:

q (Quat) –
x (float) –
y (float) –
z (float) –
w (float) –

Returns:

q (Quat):

Return type:

classmethod quat_set_from_euler(q, euler) → Quat¶

Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.

Parameters:

q (Quat) – Quaternion to update
euler (Vector) – the Euler angles

Returns:

q (Quat): Quaternion to update

Return type:

classmethod quat_size(q) → float¶

Get the length of the quaternion.

Parameters:: q (Quat) –
Returns:: The length of the quaternion.
Return type:: float

classmethod quat_size_squared(q) → float¶

Get the squared length of the quaternion.

Parameters:: q (Quat) –
Returns:: The squared length of the quaternion.
Return type:: float

classmethod quat_slerp(a, b, alpha) → Quat¶

Spherical interpolation between Quaternions. Result is normalized.

Parameters:

a (Quat) – The starting quat we interp from
b (Quat) – The target quat we interp to
alpha (double) – The interpolation amount, usually 0 to 1.

Returns:

Quat after spherical interpolation

Return type:

classmethod quat_unrotate_vector(q, v) → Vector¶

Rotate a vector by the inverse of this quaternion.

Parameters:

q (Quat) –
v (Vector) – the vector to be rotated

Returns:

vector after rotation by the inverse of this quaternion.

Return type:

classmethod quat_vector_forward(q) → Vector¶

Get the forward direction (X axis) after it has been rotated by this Quaternion.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_vector_right(q) → Vector¶

Get the right direction (Y axis) after it has been rotated by this Quaternion.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quat_vector_up(q) → Vector¶

Get the up direction (Z axis) after it has been rotated by this Quaternion.

Parameters:: q (Quat) –
Return type:: Vector

classmethod quaternion_spring_interp(current, target, spring_state, stiffness, critical_damping_factor, delta_time, mass=1.000000, target_velocity_amount=1.000000, initialize_from_target=False) -> (Quat, spring_state=QuaternionSpringState)¶

Uses a simple spring model to interpolate a quaternion from Current to Target.

Parameters:

current (Quat) – Current value
target (Quat) – Target value
spring_state (QuaternionSpringState) – Data related to spring model (velocity, error, etc..) - Create a unique variable per spring
stiffness (float) – How stiff the spring model is (more stiffness means more oscillation around the target value)
critical_damping_factor (float) – How much damping to apply to the spring (0 means no damping, 1 means critically damped which means no oscillation)
delta_time (float) – Time difference since the last update
mass (float) – Multiplier that acts like mass on a spring
target_velocity_amount (float) – If 1 then the target velocity will be calculated and used, which results following the target more closely/without lag. Values down to zero (recommended when using this to smooth data) will progressively disable this effect.
initialize_from_target (bool) – If set then the current value will be set from the target on the first update

Returns:

spring_state (QuaternionSpringState): Data related to spring model (velocity, error, etc..) - Create a unique variable per spring

Return type:

QuaternionSpringState

classmethod r_interp_to(current, target, delta_time, interp_speed) → Rotator¶

Tries to reach Target rotation based on Current rotation, giving a nice smooth feeling when rotating to Target rotation.

Parameters:

current (Rotator) – Actual rotation
target (Rotator) – Target rotation
delta_time (float) – Time since last tick
interp_speed (float) – Interpolation speed, if the speed given is 0, then jump to the target.

Returns:

New interpolated position

Return type:

classmethod r_interp_to_constant(current, target, delta_time, interp_speed) → Rotator¶

Tries to reach Target rotation at a constant rate.

Parameters:

current (Rotator) – Actual rotation
target (Rotator) – Target rotation
delta_time (float) – Time since last tick
interp_speed (float) – Interpolation speed

Returns:

New interpolated position

Return type:

classmethod r_lerp(a, b, alpha, shortest_path) → Rotator¶

Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)

Parameters:

a (Rotator) –
b (Rotator) –
alpha (float) –
shortest_path (bool) –

Return type:

classmethod radians_to_degrees(a) → double¶

Returns degrees value based on the input radians

Parameters:: a (double) –
Return type:: double

classmethod rand(max: int) → int¶: deprecated: ‘rand’ was renamed to ‘random_integer’.

classmethod rand_bool() → bool¶: deprecated: ‘rand_bool’ was renamed to ‘random_bool’.

classmethod rand_bool_from_stream(stream: RandomStream) → bool¶: deprecated: ‘rand_bool_from_stream’ was renamed to ‘random_bool_from_stream’.

classmethod rand_from_stream(stream: RandomStream, max: int) → int¶: deprecated: ‘rand_from_stream’ was renamed to ‘random_integer_from_stream’.

classmethod rand_range(min: int, max: int) → int¶: deprecated: ‘rand_range’ was renamed to ‘random_integer_in_range’.

classmethod rand_range_from_stream(stream: RandomStream, min: int, max: int) → int¶: deprecated: ‘rand_range_from_stream’ was renamed to ‘random_integer_in_range_from_stream’.

classmethod random_bool() → bool¶

Returns a uniformly distributed random bool

Return type:: bool

classmethod random_bool_from_stream(stream) → bool¶

Returns a random bool

Parameters:: stream (RandomStream) –
Return type:: bool

classmethod random_bool_with_weight(weight=0.500000) → bool¶

Get a random chance with the specified weight. Range of weight is 0.0 - 1.0 E.g.,: Weight = .6 return value = True 60% of the time

Parameters:: weight (float) –
Return type:: bool

classmethod random_bool_with_weight_from_stream(random_stream, weight=0.500000) → bool¶

Get a random chance with the specified weight. Range of weight is 0.0 - 1.0 E.g.,: Weight = .6 return value = True 60% of the time

Parameters:

random_stream (RandomStream) –
weight (float) –

Return type:

classmethod random_float() → double¶

Returns a random float between 0 and 1

Return type:: double

classmethod random_float_from_stream(stream) → float¶

Returns a random float between 0 and 1

Parameters:: stream (RandomStream) –
Return type:: float

classmethod random_float_in_range(min, max) → double¶

Generate a random number between Min and Max

Parameters:

min (double) –
max (double) –

Return type:

double

classmethod random_float_in_range_from_stream(stream, min, max) → float¶

Generate a random number between Min and Max

Parameters:

stream (RandomStream) –
min (float) –
max (float) –

Return type:

classmethod random_integer(max) → int32¶

Returns a uniformly distributed random number between 0 and Max - 1

Parameters:: max (int32) –
Return type:: int32

classmethod random_integer64(max) → int64¶

Returns a uniformly distributed random number between 0 and Max - 1

Parameters:: max (int64) –
Return type:: int64

classmethod random_integer64_in_range(min, max) → int64¶

Return a random integer64 between Min and Max (>= Min and <= Max)

Parameters:

min (int64) –
max (int64) –

Return type:

int64

classmethod random_integer_from_stream(stream, max) → int32¶

Returns a uniformly distributed random number between 0 and Max - 1

Parameters:

stream (RandomStream) –
max (int32) –

Return type:

int32

classmethod random_integer_in_range(min, max) → int32¶

Return a random integer between Min and Max (>= Min and <= Max)

Parameters:

min (int32) –
max (int32) –

Return type:

int32

classmethod random_integer_in_range_from_stream(stream, min, max) → int32¶

Return a random integer between Min and Max (>= Min and <= Max)

Parameters:

stream (RandomStream) –
min (int32) –
max (int32) –

Return type:

int32

classmethod random_point_in_bounding_box(center, half_size) → Vector¶

Returns a random point within the specified bounding box using the first vector as an origin and the second as the box extents.

Parameters:

center (Vector) –
half_size (Vector) –

Return type:

classmethod random_point_in_bounding_box_box(box) → Vector¶

Returns a random point within the specified bounding box.

Parameters:: box (Box) –
Return type:: Vector

classmethod random_point_in_bounding_box_from_stream(stream, center, half_size) → Vector¶

Returns a random point within the specified bounding box using the first vector as an origin and the second as the half size of the AABB.

Parameters:

stream (RandomStream) –
center (Vector) –
half_size (Vector) –

Return type:

classmethod random_point_in_bounding_box_from_stream_box(stream, box) → Vector¶

Returns a random point within the specified bounding box.

Parameters:

stream (RandomStream) –
box (Box) –

Return type:

classmethod random_rotator(roll=False) → Rotator¶

Generates a random rotation, with optional random roll.

Parameters:: roll (bool) –
Return type:: Rotator

classmethod random_rotator_from_stream(stream, roll) → Rotator¶

Create a random rotation

Parameters:

stream (RandomStream) –
roll (bool) –

Return type:

classmethod random_unit_vector() → Vector¶

Returns a random vector with length of 1

Return type:: Vector

classmethod random_unit_vector_from_stream(stream) → Vector¶

Returns a random vector with length of 1.0

Parameters:: stream (RandomStream) –
Return type:: Vector

classmethod random_unit_vector_in_cone(cone_dir: Vector, cone_half_angle_in_radians: float) → Vector¶: deprecated: ‘random_unit_vector_in_cone’ was renamed to ‘random_unit_vector_in_cone_in_radians’.

classmethod random_unit_vector_in_cone_in_degrees(cone_dir, cone_half_angle_in_degrees) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution.

Parameters:

cone_dir (Vector) – The base “center” direction of the cone.
cone_half_angle_in_degrees (float) – The half-angle of the cone (from ConeDir to edge), in degrees.

Return type:

classmethod random_unit_vector_in_cone_in_degrees_from_stream(stream, cone_dir, cone_half_angle_in_degrees) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution.

Parameters:

stream (RandomStream) – The random stream from which to obtain the vector.
cone_dir (Vector) – The base “center” direction of the cone.
cone_half_angle_in_degrees (float) – The half-angle of the cone (from ConeDir to edge), in degrees.

Return type:

classmethod random_unit_vector_in_cone_in_radians(cone_dir, cone_half_angle_in_radians) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution.

Parameters:

cone_dir (Vector) – The base “center” direction of the cone.
cone_half_angle_in_radians (float) – The half-angle of the cone (from ConeDir to edge), in radians.

Return type:

classmethod random_unit_vector_in_cone_in_radians_from_stream(stream, cone_dir, cone_half_angle_in_radians) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution.

Parameters:

stream (RandomStream) – The random stream from which to obtain the vector.
cone_dir (Vector) – The base “center” direction of the cone.
cone_half_angle_in_radians (float) – The half-angle of the cone (from ConeDir to edge), in radians.

Return type:

classmethod random_unit_vector_in_cone_with_yaw_and_pitch(cone_dir: Vector, max_yaw_in_degrees: float, max_pitch_in_degrees: float) → Vector¶: deprecated: ‘random_unit_vector_in_cone_with_yaw_and_pitch’ was renamed to ‘random_unit_vector_in_elliptical_cone_in_degrees’.

classmethod random_unit_vector_in_elliptical_cone_in_degrees(cone_dir, max_yaw_in_degrees, max_pitch_in_degrees) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution. The shape of the cone can be modified according to the yaw and pitch angles.

Parameters:

cone_dir (Vector) –
max_yaw_in_degrees (float) – The yaw angle of the cone (from ConeDir to horizontal edge), in degrees.
max_pitch_in_degrees (float) – The pitch angle of the cone (from ConeDir to vertical edge), in degrees.

Return type:

classmethod random_unit_vector_in_elliptical_cone_in_degrees_from_stream(stream, cone_dir, max_yaw_in_degrees, max_pitch_in_degrees) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution. The shape of the cone can be modified according to the yaw and pitch angles.

Parameters:

stream (RandomStream) – The random stream from which to obtain the vector.
cone_dir (Vector) –
max_yaw_in_degrees (float) – The yaw angle of the cone (from ConeDir to horizontal edge), in degrees.
max_pitch_in_degrees (float) – The pitch angle of the cone (from ConeDir to vertical edge), in degrees.

Return type:

classmethod random_unit_vector_in_elliptical_cone_in_radians(cone_dir, max_yaw_in_radians, max_pitch_in_radians) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution. The shape of the cone can be modified according to the yaw and pitch angles.

Parameters:

cone_dir (Vector) –
max_yaw_in_radians (float) – The yaw angle of the cone (from ConeDir to horizontal edge), in radians.
max_pitch_in_radians (float) – The pitch angle of the cone (from ConeDir to vertical edge), in radians.

Return type:

classmethod random_unit_vector_in_elliptical_cone_in_radians_from_stream(stream, cone_dir, max_yaw_in_radians, max_pitch_in_radians) → Vector¶

Returns a random vector with length of 1, within the specified cone, with uniform random distribution. The shape of the cone can be modified according to the yaw and pitch angles.

Parameters:

stream (RandomStream) – The random stream from which to obtain the vector.
cone_dir (Vector) –
max_yaw_in_radians (float) – The yaw angle of the cone (from ConeDir to horizontal edge), in radians.
max_pitch_in_radians (float) – The pitch angle of the cone (from ConeDir to vertical edge), in radians.

Return type:

classmethod reset_float_spring_state(spring_state) → FloatSpringState¶

Resets the state of a float spring

Parameters:: spring_state (FloatSpringState) –
Returns:: spring_state (FloatSpringState):
Return type:: FloatSpringState

classmethod reset_quaternion_spring_state(spring_state) → QuaternionSpringState¶

Resets the state of a quaternion spring

Parameters:: spring_state (QuaternionSpringState) –
Returns:: spring_state (QuaternionSpringState):
Return type:: QuaternionSpringState

classmethod reset_random_stream(stream) → None¶

Reset a random stream

Parameters:: stream (RandomStream) –

classmethod reset_vector_spring_state(spring_state) → VectorSpringState¶

Resets the state of a vector spring

Parameters:: spring_state (VectorSpringState) –
Returns:: spring_state (VectorSpringState):
Return type:: VectorSpringState

classmethod rgb_linear_to_hsv(rgb) → LinearColor¶

Converts a RGB linear color to HSV (where H is in R, S is in G, and V is in B)

Parameters:: rgb (LinearColor) –
Return type:: LinearColor

classmethod rgb_to_hsv(color) -> (h=float, s=float, v=float, a=float)¶

Breaks apart a color into individual HSV components (as well as alpha) (Hue is [0..360) while Saturation and Value are 0..1)

Parameters:

color (LinearColor) –

Returns:

h (float):

s (float):

v (float):

a (float):

Return type:

tuple

classmethod rgb_to_hsv_vector(rgb) → LinearColor¶

Converts a RGB linear color to HSV (where H is in R (0..360), S is in G (0..1), and V is in B (0..1))

Parameters:: rgb (LinearColor) –
Returns:: hsv (LinearColor):
Return type:: LinearColor

classmethod rot_rand(roll: bool = False) → Rotator¶: deprecated: ‘rot_rand’ was renamed to ‘random_rotator’.

classmethod rot_rand_from_stream(stream: RandomStream, roll: bool) → Rotator¶: deprecated: ‘rot_rand_from_stream’ was renamed to ‘random_rotator_from_stream’.

classmethod rotate_angle_axis(vect, angle_deg, axis) → Vector¶

Returns result of vector A rotated by AngleDeg around Axis

Parameters:

vect (Vector) –
angle_deg (float) –
axis (Vector) –

Return type:

classmethod rotator_from_axis_and_angle(axis, angle) → Rotator¶

Create a rotation from an axis and supplied angle (in degrees)

Parameters:

axis (Vector) –
angle (float) –

Return type: