Math

Helper for conveniently aligning a double array for extraction from VectorRegister4Double.

Helper for conveniently aligning a float array for extraction from VectorRegister4Float.

Provides default rules defining the result of concatenating two types.

A basic math expression evaluator

An unquantized bounding box.

FColor Stores a color with 8 bits of precision per channel.

Interface that allows the CurveEditor to edit this type of object.

Structure encompassing single DXT1 block.

Structure encompassing single DXT5 block

Helper struct for a 16 bit 565 color of a DXT1/3/5 block.

Helper struct for a 16 bit 565 color of a DXT1/3/5 block.

Implements an edge consisting of two vertices.

4 component vector corresponding to PF_R8G8B8A8_SNORM.

16 bit float components and conversion

RGBA Color made up of FFloat16

32 bit float components

3 component vector corresponding to DXGI_FORMAT_R11G11B10_FLOAT.

3 component vector corresponding to PF_R9G9B9EXP5.

Template for interpolation curves.

Template for interpolation points.

A linear, 32-bit/component floating point RGBA color.

Structure for all math helper functions, inherits from platform math to pick up platform-specific implementations Check GenericPlatformMath.h for additional math functions

Copyright Epic Games, Inc. All Rights Reserved.

FNumericUnit is a numeric type that wraps the templated type, whilst a specified unit.

A reference to a child of an octree node.

A subset of an octree node's children that intersect a bounding box.

An identifier for an element in the octree.

An identifier for an element in the octree.

The context of an octree node, derived from the traversal of the tree.

Structure for arbitrarily oriented boxes (not necessarily axis-aligned).

Structure used to define the factor required to get from one unit type to the next.

Implements a thread-safe SRand based RNG.

Support for Sobol quasi-random numbers

Used to measure a distribution.

A pair of 3D vectors.

Unit settings accessed globally through FUnitConversion::Settings()

Structure for two dimensional vectors with half floating point precision.

N-bit integer.

Realigns the near plane for an existing projection matrix with an arbitrary clip plane from: http://sourceforge.net/mailarchive/message.php?msg_id=000901c26324%242181ea90%24a1e93942%40firefly Updated for the fact that our FPlane uses Ax+By+Cz=D.

Template helper for FMath::Lerp<>() and related functions.

Encryption key - exponent and modulus pair

Template for numeric interval

Type traits for Arithmetic interval.

Structure for integer points in 2-d space.

Structure for integer rectangles in 2-d space.

Structure for integer vectors in 3-d space.

Inverse Rotation matrix

Traits class which tests if a type is POD.

Transform calculus for 2D types.

Mirrors a point about an arbitrary plane

Numeric type traits Helper class to map a numeric type to its limits

An octree.

An octree.

Floating point quaternion that can represent a rotation about an axis in 3-D space.

Represents a 2D rotation as a complex number (analagous to quaternions).

Rotation matrix using quaternion rotation

Rotation and translation matrix using quaternion rotation

Template for ranges.

Template for range bounds.

Template for range sets.

Transform calculus.

Rotates about an Origin point.

Rotation matrix no translation

Combined rotation and translation matrix

Implements a container for rotation information.

Transform calculus for 3D types.

Represents a 2D non-uniform scale (to disambiguate from an FVector2D, which is used for translation)

Scale matrix.

Combined Scale rotation and translation matrix

Represents a 2D shear: [1 YY] [XX 1] XX represents a shear parallel to the X axis.

A vector of spherical harmonic coefficients.

A vector of colored spherical harmonic coefficients.

Support for generalized 2D affine transforms.

Type used to return either a value or an error.

Forward declaration of templates.

A 4D homogeneous vector, 4x1 FLOATs, 16-byte aligned.

Double[4] vector register type, where the first double (X) is stored in the lowest 64 bits, and so on.

Float4 vector register type, where the first float (X) is stored in the lowest 32 bits, and so on.

Int32[4] vector register type, where the first int32 (X) is stored in the lowest 32 bits, and so on.

Platform specific vector intrinsics include.

Generic axis enum (mirrored for property use in Object.h)

Extended axis enum for more specialized usage.

Enumerates the valid types of range bounds.

Returns true if 'a' is more lower-left than 'b'.

Calculates convex hull on xy-plane of points on 'Points' and stores the indices of the resulting hull in 'OutIndices'.

Alternate simple implementation that was found to work correctly for points that are very close together (inside the 0-1 range).

Returns <0 if C is left of A-B

Returns <0 if C is left of A-B

Andrew's monotone chain convex hull algorithm for 2-dimensional points.

Consume a symbol from the specified consumer's stream, if one exists at the current read position

Greatest common divisor of ValueA and ValueB.

Multiplicative inverse of exponent using extended GCD algorithm.

Decrypts a stream of bytes

Encrypts a stream of bytes

Generate Key Pair for encryption and decryption.

Raise Base to power of Exponent in mod Modulus.

Vector full of positive infinity

Bitmask to AND out the sign bit of each components in a vector

Bitmask to AND out the XYZ components in a vector

Convert array to a new type.

Convert array to a new type and clamps values to the Max of TDest type.

Double->int64

Generic float type to int type, to enable specializations below.

Float->int32

Float->int64

Double->int32

Validated narrowing cast for world positions. FVector -> FVector3f.

Validated narrowing cast for world positions. FVector -> FVector3f.

Specialization for concatenating two 2D Translations.

Specialization for concatenating two Matrices.

Specialization for concatenating two translations.

Specialization for concatenating two rotations.

Creates a hash value from an FVector.

Creates a hash value from a TVector2.

Creates a hash value from an IntVector2.

Creates a hash value from an IntVector3.

Creates a hash value from an IntVector4.

Creates a hash value from an FQuat.

Creates a hash value from an FTransform.

Multiplies a Vector2 by a scaling factor.

Global operator for (float * Quat)

Global operator for (double * Quat)

FRotator inline functions Scale a rotator and return.

Multiplies a vector by a scaling factor.

Scales a vector.

Find the common quantization factor for the specified temperature unit. Quantizes to Kelvin.

All float numbers greater than or equal to this have no fractional value.

This is to speed up Quaternion Inverse. Static variable to keep sign of inverse