parin.joka.math

The math module provides mathematical data structures and functions.

var beige black blank blue brown cyan dpi dpi180 dpi2 dsqrt2 epsilon euler gray gray1 gray2 gray3 gray4 green ln10 ln2 log10e log2e magenta maroon orange pi pi180 pi2 pi4 pink red sqrt2 white yellow
alias Circ Color EasingFunc IRect IVec2 IVec3 IVec4 Line Rect Rounding64Func RoundingFunc SRect Tween Tween2 Vec2 Vec3 Vec4
enum Easing Hook Rounding TweenMode
struct GCirc GLine GRect GTween GVec2 GVec3 GVec4 Margin Rgba SmoothToggle
fn acos acos64 applyRounding applyRounding64 asin asin64 atan atan2 atan264 atan64 ceil ceil64 cos cos64 easeInBack easeInBounce easeInCirc easeInCubic easeInElastic easeInExpo easeInOutBack easeInOutBounce easeInOutCirc easeInOutCubic easeInOutElastic easeInOutExpo easeInOutQuad easeInOutQuart easeInOutQuint easeInOutSine easeInQuad easeInQuart easeInQuint easeInSine easeLinear easeOutBack easeOutBounce easeOutCirc easeOutCubic easeOutElastic easeOutExpo easeOutQuad easeOutQuart easeOutQuint easeOutSine easing exp exp2 exp264 exp64 fequals fequals64 floor floor64 fmod fmod64 followState followState64 lerp lerp64 log log10 log1064 log2 log264 log64 moveTo moveTo64 moveToState moveToState64 moveToWithSlowdown moveToWithSlowdown64 pow pow64 remainder remainder64 round round64 rounding rounding64 roundNothing roundNothing64 sin sin64 smootherstep smootherstep64 smoothstep smoothstep64 snap sqrt sqrt64 tan tan64 toDegrees toDegrees64 toIRect toIVec toRadians toRadians64 toRect toRgb toRgba toVec wrap

Types 31

aliasColor = Rgba

The common color type.

aliasVec2 = GVec2!float

A 2D vector using floats.

aliasVec3 = GVec3!float

A 3D vector using floats.

aliasVec4 = GVec4!float

A 4D vector using floats.

aliasIVec2 = GVec2!int

A 2D vector using ints.

aliasIVec3 = GVec3!int

A 3D vector using ints.

aliasIVec4 = GVec4!int

A 4D vector using ints.

aliasRect = GRect!float

A 2D rectangle using floats.

aliasCirc = GCirc!float

A 2D circle using floats.

aliasLine = GLine!float

A 2D line using floats.

aliasIRect = GRect!int

A 2D rectangle using ints.

aliasSRect = GRect!(int, short)

A 2D rectangle using ints for the position and shorts for the size.

aliasTween = GTween!float

A tween using floats.

aliasTween2 = GTween!Vec2

A tween using 2D vectors.

aliasRoundingFunc = float function(float x)

A function used for rounding.

aliasRounding64Func = double function(double x)

A function used for rounding.

aliasEasingFunc = float function(float x)

A function used for easing.

enumRounding : ubyte

A type representing rounding functions.

noneNo rounding.
floorRound down.
roundRound to nearest.
ceilRound up.
enumEasing : ubyte

A type representing easing functions.

linearConstant speed.
inSineSlow start.
outSineSlow end.
inOutSineSlow start and end.
inCubicCubic in.
outCubicCubic out.
inOutCubicCubic in-out.
inQuintQuintic in.
outQuintQuintic out.
inOutQuintQuintic in-out.
inCircCircular in.
outCircCircular out.
inOutCircCircular in-out.
inElasticElastic in.
outElasticElastic out.
inOutElasticElastic in-out.
inQuadQuadratic in.
outQuadQuadratic out.
inOutQuadQuadratic in-out.
inQuartQuartic in.
outQuartQuartic out.
inOutQuartQuartic in-out.
inExpoExponential in.
outExpoExponential out.
inOutExpoExponential in-out.
inBackBack in.
outBackBack out.
inOutBackBack in-out.
inBounceBounce in.
outBounceBounce out.
inOutBounceBounce in-out.
enumTweenMode : ubyte

A type that describes how a tween should update.

bombIt stops updating when it reaches the beginning or end of the animation.
loopIt returns to the beginning or end of the animation when it reaches the beginning or end of the animation.
yoyoIt reverses the given delta time when it reaches the beginning or end of the animation.
enumHook : ubyte

A type representing relative points.

topLeftThe top left point.
topThe top point.
topRightThe top right point.
leftThe left point.
centerThe center point.
rightThe right point.
bottomLeftThe bottom left point.
bottomThe bottom point.
bottomRightThe bottom right point.
structMargin

A set of 4 integer margins.

Fields
int left
int top
int right
int bottom
Constructors
this(int left, int top, int right, int bottom)
this(int left)
structRgba

A RGBA color using ubytes.

Fields
ubyte r
ubyte g
ubyte b
ubyte a
formThe form of the color.
zeroThe zero value of the color.
oneThe one value of the color.
lengthThe length of the color.
Methods
IStr toStr() @trusted
ubyte[] items() @trusted
bool isZero()
bool isOne()
Rgba rrrr()
Rgba gggg()
Rgba bbbb()
Rgba aaaa()
Rgba alpha(ubyte value)Returns a color with just the alpha modified.
ubyte min()
ubyte max()
structGVec2(T)

A generic 2D vector.

Fields
T x
T y
formThe form of the vector.
zeroThe zero value of the vector.
oneThe one value of the vector.
lengthThe length of the vector.
Methods
IStr toStr() @trusted
T[] items() @trusted
bool isZero()
bool isOne()
T chop()
GVec2!T abs()
GVec2!T yx()
GVec2!T xx()
GVec2!T yy()
Float magnitudeSquared()
GVec2!T opUnary(IStr op)()
GVec2!T opBinary(IStr op)(GVec2!T rhs)
GVec2!T opBinary(IStr op)(T rhs)
GVec2!T opBinaryRight(IStr op)(T lhs)
void opOpAssign(IStr op)(GVec2!T rhs)
void opOpAssign(IStr op)(T rhs)
GVec2!T _swizzleN(G)(const(G)[] args...)
GVec2!T _swizzleC(IStr args...)
GVec2!T swizzle(G)(const(G)[] args...)
T min()
T max()
structGVec3(T)

A generic 3D vector.

Fields
T x
T y
T z
formThe form of the vector.
zeroThe zero value of the vector.
oneThe one value of the vector.
lengthThe length of the vector.
Methods
IStr toStr() @trusted
T[] items() @trusted
bool isZero()
bool isOne()
GVec2!T chop()
GVec3!T abs()
GVec2!T yx()
GVec2!T xx()
GVec2!T yy()
GVec2!T xy()
GVec2!T yz()
Float magnitudeSquared()
GVec3!T opUnary(IStr op)()
GVec3!T opBinary(IStr op)(GVec3!T rhs)
GVec3!T opBinary(IStr op)(T rhs)
GVec3!T opBinaryRight(IStr op)(T lhs)
void opOpAssign(IStr op)(GVec3!T rhs)
void opOpAssign(IStr op)(T rhs)
GVec3!T _swizzleN(G)(const(G)[] args...)
GVec3!T _swizzleC(IStr args...)
GVec3!T swizzle(G)(const(G)[] args...)
T min()
T max()
structGVec4(T)

A generic 4D vector.

Fields
T x
T y
T z
T w
formThe form of the vector.
zeroThe zero value of the vector.
oneThe one value of the vector.
lengthThe length of the vector.
Methods
IStr toStr() @trusted
T[] items() @trusted
bool isZero()
bool isOne()
GVec3!T chop()
GVec4!T abs()
GVec2!T yx()
GVec2!T xx()
GVec2!T yy()
GVec2!T xy()
GVec2!T yz()
Float magnitudeSquared()
GVec4!T opUnary(IStr op)()
GVec4!T opBinary(IStr op)(GVec4!T rhs)
GVec4!T opBinary(IStr op)(T rhs)
GVec4!T opBinaryRight(IStr op)(T lhs)
void opOpAssign(IStr op)(GVec4!T rhs)
void opOpAssign(IStr op)(T rhs)
GVec4!T _swizzleN(G)(const(G)[] args...)
GVec4!T _swizzleC(IStr args...)
GVec4!T swizzle(G)(const(G)[] args...)
T min()
T max()
structGRect(P, S = P) if (P.sizeof >= S.sizeof)

A generic 2D rectangle.

Fields
GVec2!P position
GVec2!S size
Methods
IStr toStr() @trusted
P x() @trusted refThe X position of the rectangle.
P y() @trusted refThe Y position of the rectangle.
S w() @trusted refThe width of the rectangle.
S h() @trusted refThe height of the rectangle.
bool hasSize()
Self abs()
GVec2!P origin(Hook hook)
GVec2!P point(Hook hook)
GVec2!P topLeftPoint()
GVec2!P topPoint()
GVec2!P topRightPoint()
GVec2!P leftPoint()
GVec2!P centerPoint()
GVec2!P rightPoint()
GVec2!P bottomLeftPoint()
GVec2!P bottomPoint()
GVec2!P bottomRightPoint()
Self area(Hook hook)
Self centerArea()
void fix()
bool hasPoint(GVec2!P point)
bool hasIntersection(Self area)
Self intersection(Self area)
Self merger(Self area)
P sliceX(P areaCount, P spacing = 0)
P sliceY(P areaCount, P spacing = 0)
Self addLeft(P amount)
Self addRight(P amount)
Self addTop(P amount)
Self addBottom(P amount)
Self subLeft(P amount, P spacing = 0)
Self subRight(P amount, P spacing = 0)
Self subTop(P amount, P spacing = 0)
Self subBottom(P amount, P spacing = 0)
Self addLeftRight(P amount)
Self addTopBottom(P amount)
Self addAll(P amount)
Self subLeftRight(P amount)
Self subTopBottom(P amount)
Self subAll(P amount)
structGCirc(T)

A generic 2D Circle.

Fields
GVec2!T position
T radius
Methods
IStr toStr() @trusted
T x() @trusted refThe X position of the circle.
T y() @trusted refThe Y position of the circle.
T r() @trusted refThe radius of the circle.
bool hasSize()
GCirc!T abs()
structGLine(T)

A generic 2D Line.

Fields
GVec2!T a
GVec2!T b
Methods
IStr toStr() @trusted
T x1() @trusted ref
T y1() @trusted ref
T x2() @trusted ref
T y2() @trusted ref
GLine!T abs()
structGTween(T)

Handles the transition between two values over a specified duration.

Fields
T a
T b
float time
float duration
TweenMode mode
Easing type
bool isYoyoing
Methods
bool isAtStart()Returns true if time is at the start (0.0). Useful when using `TweenMode.bomb`.
bool isAtEnd()Returns true if time is at the end (duration). Useful when using `TweenMode.bomb`.
T now()Returns the current interpolated value between `a` and `b`.
T update(float delta)Advances the tween by the given delta time and returns the current value.
T reset()Resets the tween to the start and returns the current value.
float progress()Returns the current progress (between 0.0 to 1.0).
void setProgress(float value)Sets the progress to a specific value (between 0.0 to 1.0).
void setTime(float value)Sets the current time and applies the tween mode rules.
Constructors
this(T a, T b, float duration, TweenMode mode = TweenMode.bomb, Easing type = Easing.linear)Creates a new tween.
structSmoothToggle

Handles the transition between two boolean states.

Fields
float progress
bool state
Methods
bool isAtStart()Returns true if progress is at the start (0.0).
bool isAtEnd()Returns true if progress is at the end (1.0).
bool isActive()Returns true if progress is not at the start (0.0) or the end (1.0).
float now()Returns the current progress (between 0.0 and 1.0).
float update(float delta)Advances the progress toward the current state. Returns the updated progress.
float reset()Resets the progress to 0.0. Returns the updated progress.
void setProgress(float value)Sets the progress to the given value (clamped).
bool toggle()Toggles the target state. Returns the new state.
bool toggleSnap()Toggles the state and instantly sets progress to match. Returns the new state.
Constructors
this(bool state)Creates a new toggle.

Functions 126

fnT wrap(T)(T x, T a, T b)Returns `x` wrapped to the range [`a`, `b`], wrapping around when out of bounds.
fnT snap(T)(T x, T step)Returns `x` rounded to the nearest multiple of `step`.
fnfloat fmod(float x, float y)Returns the floating-point remainder of `x / y`.
fndouble fmod64(double x, double y)Returns the floating-point remainder of `x / y`.
fnfloat remainder(float x, float y)Returns the IEEE 754 floating-point remainder of `x / y`.
fndouble remainder64(double x, double y)Returns the IEEE 754 floating-point remainder of `x / y`.
fnfloat exp(float x)Returns Euler's number `e` raised to the power of `x`.
fndouble exp64(double x)Returns Euler's number `e` raised to the power of `x`.
fnfloat exp2(float x)Returns `2` raised to the power of `x`.
fndouble exp264(double x)Returns `2` raised to the power of `x`.
fnfloat log(float x)Returns the natural logarithm of `x`.
fndouble log64(double x)Returns the natural logarithm of `x`.
fnfloat log10(float x)Returns the base-10 logarithm of `x`.
fndouble log1064(double x)Returns the base-10 logarithm of `x`.
fnfloat log2(float x)Returns the base-2 logarithm of `x`.
fndouble log264(double x)Returns the base-2 logarithm of `x`.
fnfloat pow(float base, float exponent)Returns `base` raised to the power of `exponent`.
fndouble pow64(double base, double exponent)Returns `base` raised to the power of `exponent`.
fnfloat atan2(float y, float x)Returns the angle between the positive x-axis and the point (`x`, `y`).
fndouble atan264(double y, double x)Returns the angle between the positive x-axis and the point (`x`, `y`).
fnfloat roundNothing(float x)Returns `x` unchanged.
fndouble roundNothing64(double x)Returns `x` unchanged.
fnfloat floor(float x)Returns the floor of `x`.
fndouble floor64(double x)Returns the floor of `x`.
fnfloat round(float x)Returns the nearest integer to `x`.
fndouble round64(double x)Returns the nearest integer to `x`.
fnfloat ceil(float x)Returns the ceiling of `x`.
fndouble ceil64(double x)Returns the ceiling of `x`.
fnfloat applyRounding(float x, Rounding type)Applies the specified `type` of rounding to `x`.
fndouble applyRounding64(double x, Rounding type)Applies the specified `type` of rounding to `x`.
fnfloat sqrt(float x)Returns the square root of `x`.
fndouble sqrt64(double x)Returns the square root of `x`.
fnfloat sin(float x)Returns the sine of `x`.
fndouble sin64(double x)Returns the sine of `x`.
fnfloat cos(float x)Returns the cosine of `x`.
fndouble cos64(double x)Returns the cosine of `x`.
fnfloat tan(float x)Returns the tangent of `x`.
fndouble tan64(double x)Returns the tangent of `x`.
fnfloat asin(float x)Returns the arcsine of `x`.
fndouble asin64(double x)Returns the arcsine of `x`.
fnfloat acos(float x)Returns the arccosine of `x`.
fndouble acos64(double x)Returns the arccosine of `x`.
fnfloat atan(float x)Returns the arctangent of `x`.
fndouble atan64(double x)Returns the arctangent of `x`.
fnfloat lerp(float from, float to, float weight)Returns the linear interpolation between `from` and `to` by `weight`. A weight of 0 returns `from`, a weight of 1 returns `to`.
fndouble lerp64(double from, double to, double weight)Returns the linear interpolation between `from` and `to` by `weight`. A weight of 0 returns `from`, a weight of 1 returns `to`.
fnfloat smoothstep(float from, float to, float weight)Returns the smooth interpolation between `from` and `to` by `weight` using a cubic curve. Eases in and out, with zero first-order derivatives at both endpoints.
fndouble smoothstep64(double from, double to, double weight)Returns the smooth interpolation between `from` and `to` by `weight` using a cubic curve. Eases in and out, with zero first-order derivatives at both endpoints.
fnfloat smootherstep(float from, float to, float weight)Returns the smoother interpolation between `from` and `to` by `weight` using a quintic curve. Eases in and out, with zero first and second-order derivatives at both endpoints.
fndouble smootherstep64(double from, double to, double weight)Returns the smoother interpolation between `from` and `to` by `weight` using a quintic curve. Eases in and out, with zero first and second-order derivatives at both endpoints.
fnfloat easeLinear(float x)Easing function with no acceleration. Returns `x` unchanged.
fnfloat easeInSine(float x)Easing function that starts slow and accelerates using a sine curve.
fnfloat easeOutSine(float x)Easing function that starts fast and decelerates using a sine curve.
fnfloat easeInOutSine(float x)Easing function that accelerates then decelerates using a sine curve.
fnfloat easeInCubic(float x)Easing function that starts slow and accelerates using a cubic curve.
fnfloat easeOutCubic(float x)Easing function that starts fast and decelerates using a cubic curve.
fnfloat easeInOutCubic(float x)Easing function that accelerates then decelerates using a cubic curve.
fnfloat easeInQuint(float x)Easing function that starts slow and accelerates using a quintic curve.
fnfloat easeOutQuint(float x)Easing function that starts fast and decelerates using a quintic curve.
fnfloat easeInOutQuint(float x)Easing function that accelerates then decelerates using a quintic curve.
fnfloat easeInCirc(float x)Easing function that starts slow and accelerates along a circular arc.
fnfloat easeOutCirc(float x)Easing function that starts fast and decelerates along a circular arc.
fnfloat easeInOutCirc(float x)Easing function that accelerates then decelerates along a circular arc.
fnfloat easeInElastic(float x)Easing function that overshoots the start with an elastic spring effect.
fnfloat easeOutElastic(float x)Easing function that overshoots the end with an elastic spring effect.
fnfloat easeInOutElastic(float x)Easing function that overshoots both ends with an elastic spring effect.
fnfloat easeInQuad(float x)Easing function that starts slow and accelerates using a quadratic curve.
fnfloat easeOutQuad(float x)Easing function that starts fast and decelerates using a quadratic curve.
fnfloat easeInOutQuad(float x)Easing function that accelerates then decelerates using a quadratic curve.
fnfloat easeInQuart(float x)Easing function that starts slow and accelerates using a quartic curve.
fnfloat easeOutQuart(float x)Easing function that starts fast and decelerates using a quartic curve.
fnfloat easeInOutQuart(float x)Easing function that accelerates then decelerates using a quartic curve.
fnfloat easeInExpo(float x)Easing function that starts slow and accelerates exponentially.
fnfloat easeOutExpo(float x)Easing function that starts fast and decelerates exponentially.
fnfloat easeInOutExpo(float x)Easing function that accelerates then decelerates exponentially.
fnfloat easeInBack(float x)Easing function that pulls back slightly before accelerating forward.
fnfloat easeOutBack(float x)Easing function that overshoots the target before settling.
fnfloat easeInOutBack(float x)Easing function that pulls back at the start and overshoots at the end.
fnfloat easeInBounce(float x)Easing function that starts with a bouncing effect before reaching the target.
fnfloat easeOutBounce(float x)Easing function that ends with a bouncing effect after reaching the target.
fnfloat easeInOutBounce(float x)Easing function that bounces at both the start and end.
fnbool fequals(float a, float b, float localEpsilon = epsilon)Returns true if `a` and `b` are within `localEpsilon` of each other.
fnbool fequals64(double a, double b, double localEpsilon = epsilon)Returns true if `a` and `b` are within `localEpsilon` of each other.
fnbool fequals(Vec2 a, Vec2 b, float localEpsilon = epsilon)Returns true if all components of `a` and `b` are within `localEpsilon` of each other.
fnbool fequals(Vec3 a, Vec3 b, float localEpsilon = epsilon)Returns true if all components of `a` and `b` are within `localEpsilon` of each other.
fnbool fequals(Vec4 a, Vec4 b, float localEpsilon = epsilon)Returns true if all components of `a` and `b` are within `localEpsilon` of each other.
fnfloat toRadians(float degrees)Converts degrees to radians.
fndouble toRadians64(double degrees)Converts degrees to radians.
fnfloat toDegrees(float radians)Converts radians to degrees.
fndouble toDegrees64(double radians)Converts radians to degrees.
fnIVec2 toIVec(Vec2 vec)Converts a `Vec2` to an `IVec2` by truncating each component to an integer.
fnIVec3 toIVec(Vec3 vec)Converts a `Vec3` to an `IVec3` by truncating each component to an integer.
fnIVec4 toIVec(Vec4 vec)Converts a `Vec4` to an `IVec4` by truncating each component to an integer.
fnVec2 toVec(IVec2 vec)Converts an `IVec2` to a `Vec2`.
fnVec2 toVec(GVec2!short vec)Converts a `GVec2!short` to a `Vec2`.
fnVec3 toVec(IVec3 vec)Converts an `IVec3` to a `Vec3`.
fnVec4 toVec(IVec4 vec)Converts an `IVec4` to a `Vec4`.
fnVec4 toVec(Rgba color)Converts an `Rgba` color to a `Vec4` with components in the order `(r, g, b, a)`.
fnIRect toIRect(Rect rect)Converts a `Rect` to an `IRect` by truncating position and size components to integers.
fnRect toRect(IRect rect)Converts an `IRect` to a `Rect`.
fnRect toRect(SRect rect)Converts an `SRect` to a `Rect`.
fnRgba toRgb(uint rgb)Converts a packed 24-bit RGB integer to an `Rgba` color with full opacity.
fnRgba toRgba(uint rgba)Converts a packed 32-bit RGBA integer to an `Rgba` color.
fnRgba toRgba(Vec3 vec)Converts a `Vec3` to an `Rgba` color, clamping each component to the range [0, 255] with full opacity.
fnRgba toRgba(Vec4 vec)Converts a `Vec4` to an `Rgba` color, clamping each component to the range [0, 255].
fnRgba toRgba(IStr str)Converts a hex color string (e.g. `"#RGB"`, `"RRGGBB"`, `"RRGGBBAA"`) to an `Rgba` color. Returns `blank` if the string is invalid.
fnVec2 lerp(Vec2 from, Vec2 to, float weight)Returns the linear interpolation between `from` and `to` by `weight`, applied per component.
fnVec3 lerp(Vec3 from, Vec3 to, float weight)Returns the linear interpolation between `from` and `to` by `weight`, applied per component.
fnVec4 lerp(Vec4 from, Vec4 to, float weight)Returns the linear interpolation between `from` and `to` by `weight`, applied per component.
fnRoundingFunc rounding(Rounding type)Returns the rounding function corresponding to the given `Rounding` type.
fnRounding64Func rounding64(Rounding type)Returns the 64-bit rounding function corresponding to the given `Rounding` type.
fnEasingFunc easing(Easing type)Returns the easing function corresponding to the given `Easing` type.
fnfloat moveToState(float from, bool to, float delta)Moves `from` toward 1 by `delta` if `to` is true, or toward 0 if false. Result is clamped to [0, 1].
fnfloat moveToState64(double from, bool to, double delta)Moves `from` toward 1 by `delta` if `to` is true, or toward 0 if false. Result is clamped to [0, 1].
fnfloat followState(ref float weight, bool target, float speed)Moves `weight` by ref toward the `target` state by `speed` and returns the updated value.
fndouble followState64(ref double weight, bool target, double speed)Moves `weight` by ref toward the `target` state by `speed` and returns the updated value.
fnfloat moveTo(float from, float to, float delta)Moves `from` toward `to` by at most `delta`, stopping exactly at `to`.
fnfloat moveTo64(double from, double to, double delta)Moves `from` toward `to` by at most `delta`, stopping exactly at `to`.
fnVec2 moveTo(Vec2 from, Vec2 to, Vec2 delta)Moves `from` toward `to` per component by at most `delta`, stopping exactly at `to`.
fnVec3 moveTo(Vec3 from, Vec3 to, Vec3 delta)Moves `from` toward `to` per component by at most `delta`, stopping exactly at `to`.
fnVec4 moveTo(Vec4 from, Vec4 to, Vec4 delta)Moves `from` toward `to` per component by at most `delta`, stopping exactly at `to`.
fnfloat moveToWithSlowdown(float from, float to, float delta, float slowdown)Moves `from` toward `to` by `delta` each step, decelerating as it approaches using `slowdown`. A `slowdown` value around 0.1 gives a natural deceleration feel.
fnfloat moveToWithSlowdown64(double from, double to, double delta, double slowdown)Moves `from` toward `to` by `delta` each step, decelerating as it approaches using `slowdown`. A `slowdown` value around 0.1 gives a natural deceleration feel.
fnVec2 moveToWithSlowdown(Vec2 from, Vec2 to, Vec2 delta, float slowdown)Moves `from` toward `to` per component by `delta`, decelerating as it approaches using `slowdown`. A `slowdown` value around 0.1 gives a natural deceleration feel.
fnVec3 moveToWithSlowdown(Vec3 from, Vec3 to, Vec3 delta, float slowdown)Moves `from` toward `to` per component by `delta`, decelerating as it approaches using `slowdown`. A `slowdown` value around 0.1 gives a natural deceleration feel.
fnVec4 moveToWithSlowdown(Vec4 from, Vec4 to, Vec4 delta, float slowdown)Moves `from` toward `to` per component by `delta`, decelerating as it approaches using `slowdown`. A `slowdown` value around 0.1 gives a natural deceleration feel.

Variables 34

enumvarepsilon = 0.0001

The value of epsilon.

enumvareuler = 2.71828182845904523536028747135266249

The value of Euler's number.

enumvarlog2e = 1.44269504088896340735992468100189214

The value of log2(e).

enumvarlog10e = 0.43429448190325182765112891891660508

The value of log10(e).

enumvarln2 = 0.69314718055994530941723212145817656

The value of ln(2).

enumvarln10 = 2.30258509299404568401799145468436421

The value of ln(10).

enumvarpi = 3.14159265358979323846264338327950288

The value of PI.

enumvarpi2 = pi / 2.0

The value of PI / 2.

enumvarpi4 = pi / 4.0

The value of PI / 4.

enumvarpi180 = pi / 180.0

The value of PI / 180.

enumvardpi = 1.0 / pi

The value of 1 / PI.

enumvardpi2 = 2.0 / pi

The value of 2 / PI.

enumvardpi180 = 180.0 / pi

The value of 180 / PI.

enumvarsqrt2 = 1.41421356237309504880168872420969808

The value of sqrt(2).

enumvardsqrt2 = 0.70710678118654752440084436210484903

The value of 1 / sqrt(2).

enumvarblank = Rgba()

#00000000

enumvarblack = Rgba(0)

#000000FF

enumvarwhite = Rgba(255)

#FFFFFFFF

enumvarred = Rgba(255, 0, 0)

#FF0000FF

enumvargreen = Rgba(0, 255, 0)

#00FF00FF

enumvarblue = Rgba(0, 0, 255)

#0000FFFF

enumvaryellow = Rgba(255, 255, 0)

#FFFF00FF

enumvarmagenta = Rgba(255, 0, 255)

#FF00FFFF

enumvarcyan = Rgba(0, 255, 255)

#00FFFFFF

enumvarpink = Rgba(255, 192, 204)

#FFC0CCFF

enumvarorange = Rgba(255, 165, 0)

#FFA500FF

enumvarbeige = Rgba(240, 235, 210)

#F0EBD2FF

enumvarbrown = Rgba(165, 72, 42)

#A5482AFF

enumvarmaroon = Rgba(128, 0, 0)

#800000FF

enumvargray1 = Rgba(32, 32, 32)

#202020FF

enumvargray2 = Rgba(96, 96, 96)

#606060FF

enumvargray3 = Rgba(159, 159, 159)

#9F9F9FFF

enumvargray4 = Rgba(223, 223, 223)

#DFDFDFFF

enumvargray = gray2

#606060FF