toosoon-utils 4.1.9 → 4.2.0

package/lib/geometry.js

@@ -1,5 +1,4 @@
-import { EPSILON, PI, TWO_PI } from './constants';
-import { lerp } from './maths';
+import { PI } from './constants';
 /**
  * Convert a radians value into degrees
  *
@@ -55,30 +54,6 @@ export function distance(x1, y1, x2, y2) {
     const dy = y1 - y2;
     return Math.sqrt(dx * dx + dy * dy);
 }
-/**
- * Calculate the dot product of two vectors
- *
- * @param {number} x1 X-axis coordinate of the first vector
- * @param {number} y1 Y-axis coordinate of the first vector
- * @param {number} x2 X-axis coordinate of the second vector
- * @param {number} y2 Y-axis coordinate of the second vector
- * @returns {number} Computed dot product
- */
-export function dot(x1, y1, x2, y2) {
-    return x1 * x2 + y1 * y2;
-}
-/**
- * Calculate the cross product of two vectors
- *
- * @param {number} x1 X-axis coordinate of the first vector
- * @param {number} y1 Y-axis coordinate of the first vector
- * @param {number} x2 X-axis coordinate of the second vector
- * @param {number} y2 Y-axis coordinate of the second vector
- * @returns {number} Computed cross product
- */
-export function cross(x1, y1, x2, y2) {
-    return x1 * x2 - y1 * y2;
-}
 /**
  * Calculate the length of the diagonal of a rectangle
  *
@@ -89,199 +64,6 @@ export function cross(x1, y1, x2, y2) {
 export function diagonal(width, height) {
     return Math.sqrt(width * width + height * height);
 }
-/**
- * Convert radians to a 3D point on the surface of a unit sphere
- *
- * @param  {number} radius  Radius of the sphere
- * @param  {number} phi     Polar angle from the y (up) axis     : [0, PI]
- * @param  {number} theta   Equator angle around the y (up) axis : [0, 2*PI]
- * @param  {Point3} target Target 3D point
- * @returns {Point3}
- */
-export function radToSphere(radius, phi, theta, target = [0, 0, 0]) {
-    target[0] = radius * Math.sin(phi) * Math.sin(theta);
-    target[1] = radius * Math.cos(phi);
-    target[2] = radius * Math.sin(phi) * Math.cos(theta);
-    return target;
-}
-// *********************
-// Curves
-// *********************
-/**
- * Interpolate a point on a line
- *
- * @param {number} t  Normalized time value to interpolate
- * @param {number} x1 X-axis coordinate of the start point
- * @param {number} y1 Y-axis coordinate of the start point
- * @param {number} x2 X-axis coordinate of the end point
- * @param {number} y2 Y-axis coordinate of the end point
- * @returns {Point} Interpolated coordinates on the line
- */
-export function line(t, x1, y1, x2, y2) {
-    const x = lerp(t, x1, x2);
-    const y = lerp(t, y1, y2);
-    return [x, y];
-}
-/**
- * Interpolate a point on a Quadratic Bézier curve
- *
- * @param {number} t   Normalized time value to interpolate
- * @param {number} x1  X-axis coordinate of the start point
- * @param {number} y1  Y-axis coordinate of the start point
- * @param {number} cpx X-axis coordinate of the control point
- * @param {number} cpy Y-axis coordinate of the control point
- * @param {number} x2  X-axis coordinate of the end point
- * @param {number} y2  Y-axis coordinate of the end point
- * @returns {Point} Interpolated coordinates on the curve
- */
-export function quadraticBezier(t, x1, y1, cpx, cpy, x2, y2) {
-    const t2 = t * t;
-    const k = 1 - t;
-    const k2 = k * k;
-    const x = k2 * x1 + 2 * k * t * cpx + t2 * x2;
-    const y = k2 * y1 + 2 * k * t * cpy + t2 * y2;
-    return [x, y];
-}
-/**
- * Interpolate a point on a Cubic Bézier curve
- *
- * @param {number} t    Normalized time value to interpolate
- * @param {number} x1   X-axis coordinate of the start point
- * @param {number} y1   Y-axis coordinate of the start point
- * @param {number} cp1x X-axis coordinate of the first control point
- * @param {number} cp1y Y-axis coordinate of the first control point
- * @param {number} cp2x X-axis coordinate of the second control point
- * @param {number} cp2y Y-axis coordinate of the second control point
- * @param {number} x2   X-axis coordinate of the end point
- * @param {number} y2   Y-axis coordinate of the end point
- * @returns {Point} Interpolated coordinates on the curve
- */
-export function cubicBezier(t, x1, y1, cp1x, cp1y, cp2x, cp2y, x2, y2) {
-    const t2 = t * t;
-    const t3 = t2 * t;
-    const k = 1 - t;
-    const k2 = k * k;
-    const k3 = k2 * k;
-    const x = k3 * x1 + 3 * k2 * t * cp1x + 3 * k * t2 * cp2x + t3 * x2;
-    const y = k3 * y1 + 3 * k2 * t * cp1y + 3 * k * t2 * cp2y + t3 * y2;
-    return [x, y];
-}
-/**
- * Interpolate a point on a Catmull-Rom spline
- *
- * @param {number} t   Normalized time value to interpolate
- * @param {number} x1  X-axis coordinate of the start point
- * @param {number} y1  Y-axis coordinate of the start point
- * @param {number} cp1x X-axis coordinate of the first control point
- * @param {number} cp1y Y-axis coordinate of the first control point
- * @param {number} cp2x X-axis coordinate of the second control point
- * @param {number} cp2y Y-axis coordinate of the second control point
- * @param {number} x2  X-axis coordinate of the end point
- * @param {number} y2  Y-axis coordinate of the end point
- * @returns {Point} Interpolated coordinates on the spline
- */
-export function catmullRom(t, x1, y1, cp1x, cp1y, cp2x, cp2y, x2, y2) {
-    const t2 = t * t;
-    const t3 = t2 * t;
-    const vx1 = (cp2x - x1) * 0.5;
-    const vy1 = (cp2y - y1) * 0.5;
-    const vx2 = (x2 - cp1x) * 0.5;
-    const vy2 = (y2 - cp1y) * 0.5;
-    const x = (2 * cp1x - 2 * cp2x + vx1 + vx2) * t3 + (-3 * cp1x + 3 * cp2x - 2 * vx1 - vx2) * t2 + vx1 * t + cp1x;
-    const y = (2 * cp1y - 2 * cp2y + vy1 + vy2) * t3 + (-3 * cp1y + 3 * cp2y - 2 * vy1 - vy2) * t2 + vy1 * t + cp1y;
-    return [x, y];
-}
-/**
- * Interpolate a point on an elliptical arc
- *
- * @param {number} t  Normalized time value to interpolate
- * @param {number} cx X-axis coordinate of the center of the ellipse
- * @param {number} cy Y-axis coordinate of the center of the ellipse
- * @param {number} rx X-radius of the ellipse
- * @param {number} ry Y-radius of the ellipse
- * @param {number} [rotation=0] Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis
- * @param {number} [startAngle=0]  Start angle of the arc (in radians)
- * @param {number} [endAngle=2*PI] End angle of the arc (in radians)
- * @param {boolean} [counterclockwise=false] Flag indicating the direction of the arc
- * @returns {Point} Interpolated coordinates on the arc
- */
-export function ellipse(t, cx, cy, rx, ry, rotation = 0, startAngle = 0, endAngle = TWO_PI, counterclockwise = false) {
-    let deltaAngle = endAngle - startAngle;
-    const isEmpty = Math.abs(deltaAngle) <= EPSILON;
-    while (deltaAngle < 0)
-        deltaAngle += TWO_PI;
-    while (deltaAngle > TWO_PI)
-        deltaAngle -= TWO_PI;
-    if (deltaAngle <= EPSILON) {
-        if (isEmpty) {
-            deltaAngle = 0;
-        }
-        else {
-            deltaAngle = TWO_PI;
-        }
-    }
-    if (counterclockwise === true && !isEmpty) {
-        if (deltaAngle === TWO_PI) {
-            deltaAngle = -TWO_PI;
-        }
-        else {
-            deltaAngle = deltaAngle - TWO_PI;
-        }
-    }
-    const angle = startAngle + t * deltaAngle;
-    let x = cx + rx * Math.cos(angle);
-    let y = cy + ry * Math.sin(angle);
-    if (rotation !== 0) {
-        const cos = Math.cos(rotation);
-        const sin = Math.sin(rotation);
-        const deltaX = x - cx;
-        const deltaY = y - cy;
-        x = deltaX * cos - deltaY * sin + cx;
-        y = deltaX * sin + deltaY * cos + cy;
-    }
-    return [x, y];
-}
-/**
- * Interpolate a point on a circular arc
- *
- * @param {number} t  Normalized time value to interpolate
- * @param {number} cx X-axis coordinate of the center of the circle
- * @param {number} cy Y-axis coordinate of the center of the circle
- * @param {number} radius Radius of the circle
- * @param {number} [startAngle] Start angle of the arc (in radians)
- * @param {number} [endAngle]   End angle of the arc (in radians)
- * @param {boolean} [counterclockwise=false] Flag indicating the direction of the arc
- * @returns {Point} Interpolated coordinates on the arc
- */
-export function arc(t, cx, cy, radius, startAngle, endAngle, counterclockwise) {
-    return ellipse(t, cx, cy, radius, radius, 0, startAngle, endAngle, counterclockwise);
-}
-/**
- * Check if two points are coincident
- *
- * @param {number} x1 X-axis coordinate of the first point
- * @param {number} y1 Y-axis coordinate of the first point
- * @param {number} x2 X-axis coordinate of the second point
- * @param {number} y2 Y-axis coordinate of the second point
- * @returns {boolean} True if the two are coincident, false otherwise
- */
-export function isCoincident(x1, y1, x2, y2) {
-    return distance(x1, y1, x2, y2) <= EPSILON;
-}
-/**
- * Check if three points are collinear (aligned on the same line)
- *
- * @param {number} x1 X-axis coordinate of the first point
- * @param {number} y1 Y-axis coordinate of the first point
- * @param {number} x2 X-axis coordinate of the second point
- * @param {number} y2 Y-axis coordinate of the second point
- * @param {number} x3 X-axis coordinate of the third point
- * @param {number} y3 Y-axis coordinate of the third point
- * @returns {boolean} True if the three points are collinear, false otherwise
- */
-export function isCollinear(x1, y1, x2, y2, x3, y3) {
-    return Math.abs((x2 - x1) * (y3 - y2) - (y2 - y1) * (x3 - x2)) <= EPSILON;
-}
 /**
  * Make a target fit a container
  *

package/lib/maths.d.ts

@@ -44,7 +44,15 @@ export declare function sign(value: number): number;
  */
 export declare function clamp(value: number, min?: number, max?: number): number;
 /**
- * Linear interpolation between two values (lerping)
+ * Round a number up to a nearest multiple
+ *
+ * @param {number} value        Value to round
+ * @param {number} [multiple=1] Multiple to round to
+ * @returns {number} Closest multiple
+ */
+export declare function snap(value: number, multiple?: number): number;
+/**
+ * Interpolate a value between two values using Linear interpolation (lerping)
  *
  * @param {number} t   Normalized time value to interpolate
  * @param {number} min Minimum value
@@ -53,7 +61,27 @@ export declare function clamp(value: number, min?: number, max?: number): number
  */
 export declare function lerp(t: number, min: number, max: number): number;
 /**
- * Triangular interpolation between two values
+ * Normalize a value between two bounds
+ *
+ * @param {number} value Value to normalize
+ * @param {number} min   Minimum boundary
+ * @param {number} max   Maximum boundary
+ * @returns {number} Normalized value
+ */
+export declare function normalize(value: number, min: number, max: number): number;
+/**
+ * Re-map a number from one range to another
+ *
+ * @param {number} value      Value to re-map
+ * @param {number} currentMin Lower bound of the value's current range
+ * @param {number} currentMax Upper bound of the value's current range
+ * @param {number} targetMin  Lower bound of the value's target range
+ * @param {number} targetMax  Upper bound of the value's target range
+ * @returns {number} Re-mapped value
+ */
+export declare function map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
+/**
+ * Interpolate a value between two values using Triangular interpolation
  *
  * @param {number} t      Normalized time value to interpolate
  * @param {number} min    Minimum value
@@ -63,7 +91,7 @@ export declare function lerp(t: number, min: number, max: number): number;
  */
 export declare function triLerp(t: number, min: number, max: number, target: number): number;
 /**
- * Exponential interpolation between two values
+ * Interpolate a value using Exponential interpolation
  *
  * @param {number} t          Normalized time value to interpolate
  * @param {number} currentMin Lower bound of the value's current range
@@ -74,33 +102,37 @@ export declare function triLerp(t: number, min: number, max: number, target: num
  */
 export declare function expLerp(t: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
 /**
- * Normalize a value between two bounds
+ * Interpolate a value using Quadratic Bézier interpolation
  *
- * @param {number} value Value to normalize
- * @param {number} min   Minimum boundary
- * @param {number} max   Maximum boundary
- * @returns {number} Normalized value
+ * @param {number} t  Normalized time value to interpolate
+ * @param {number} p1 Start point
+ * @param {number} cp Control point
+ * @param {number} p2 End point
+ * @returns {number} Interpolated value
  */
-export declare function normalize(value: number, min: number, max: number): number;
+export declare function quadraticBezier(t: number, p1: number, cp: number, p2: number): number;
 /**
- * Re-map a number from one range to another
+ * Interpolate a value using Cubic Bézier interpolation
  *
- * @param {number} value      Value to re-map
- * @param {number} currentMin Lower bound of the value's current range
- * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
- * @returns {number} Re-mapped value
+ * @param {number} t   Normalized time value to interpolate
+ * @param {number} p1  Start point
+ * @param {number} cp1 First control point
+ * @param {number} cp2 Second control point
+ * @param {number} p2  End point
+ * @returns {number} Interpolated value
  */
-export declare function map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
+export declare function cubicBezier(t: number, p1: number, cp1: number, cp2: number, p2: number): number;
 /**
- * Round a number up to a nearest multiple
+ * Interpolate a value using Catmull-Rom interpolation
  *
- * @param {number} value        Value to round
- * @param {number} [multiple=1] Multiple to round to
- * @returns {number} Closest multiple
+ * @param {number} t   Normalized time value to interpolate
+ * @param {number} p1  Start point
+ * @param {number} cp1 First control point
+ * @param {number} cp2 Second control point
+ * @param {number} p2  End point
+ * @returns {number} Interpolated value
  */
-export declare function snap(value: number, multiple?: number): number;
+export declare function catmullRom(t: number, p1: number, cp1: number, cp2: number, p2: number): number;
 /**
  * Modulo absolute a value based on a length
  *

package/lib/maths.js

@@ -60,7 +60,19 @@ export function clamp(value, min = 0, max = 1) {
     return Math.min(max, Math.max(min, value));
 }
 /**
- * Linear interpolation between two values (lerping)
+ * Round a number up to a nearest multiple
+ *
+ * @param {number} value        Value to round
+ * @param {number} [multiple=1] Multiple to round to
+ * @returns {number} Closest multiple
+ */
+export function snap(value, multiple = 1) {
+    if (multiple === 0)
+        return value;
+    return Math.round(value / multiple) * multiple;
+}
+/**
+ * Interpolate a value between two values using Linear interpolation (lerping)
  *
  * @param {number} t   Normalized time value to interpolate
  * @param {number} min Minimum value
@@ -71,7 +83,31 @@ export function lerp(t, min, max) {
     return min + (max - min) * t;
 }
 /**
- * Triangular interpolation between two values
+ * Normalize a value between two bounds
+ *
+ * @param {number} value Value to normalize
+ * @param {number} min   Minimum boundary
+ * @param {number} max   Maximum boundary
+ * @returns {number} Normalized value
+ */
+export function normalize(value, min, max) {
+    return (value - min) / (max - min);
+}
+/**
+ * Re-map a number from one range to another
+ *
+ * @param {number} value      Value to re-map
+ * @param {number} currentMin Lower bound of the value's current range
+ * @param {number} currentMax Upper bound of the value's current range
+ * @param {number} targetMin  Lower bound of the value's target range
+ * @param {number} targetMax  Upper bound of the value's target range
+ * @returns {number} Re-mapped value
+ */
+export function map(value, currentMin, currentMax, targetMin, targetMax) {
+    return ((value - currentMin) / (currentMax - currentMin)) * (targetMax - targetMin) + targetMin;
+}
+/**
+ * Interpolate a value between two values using Triangular interpolation
  *
  * @param {number} t      Normalized time value to interpolate
  * @param {number} min    Minimum value
@@ -84,7 +120,7 @@ export function triLerp(t, min, max, target) {
     return t <= x ? min - (min - target) * (t / x) : target - (target - max) * ((t - x) / (1 - x));
 }
 /**
- * Exponential interpolation between two values
+ * Interpolate a value using Exponential interpolation
  *
  * @param {number} t          Normalized time value to interpolate
  * @param {number} currentMin Lower bound of the value's current range
@@ -98,40 +134,54 @@ export function expLerp(t, currentMin, currentMax, targetMin, targetMax) {
         Math.pow(targetMax / targetMin, (clamp(t, currentMin, currentMax) - currentMin) / (currentMax - currentMin)));
 }
 /**
- * Normalize a value between two bounds
+ * Interpolate a value using Quadratic Bézier interpolation
  *
- * @param {number} value Value to normalize
- * @param {number} min   Minimum boundary
- * @param {number} max   Maximum boundary
- * @returns {number} Normalized value
+ * @param {number} t  Normalized time value to interpolate
+ * @param {number} p1 Start point
+ * @param {number} cp Control point
+ * @param {number} p2 End point
+ * @returns {number} Interpolated value
  */
-export function normalize(value, min, max) {
-    return (value - min) / (max - min);
+export function quadraticBezier(t, p1, cp, p2) {
+    const t2 = t * t;
+    const k = 1 - t;
+    const k2 = k * k;
+    return k2 * p1 + 2 * k * t * cp + t2 * p2;
 }
 /**
- * Re-map a number from one range to another
+ * Interpolate a value using Cubic Bézier interpolation
  *
- * @param {number} value      Value to re-map
- * @param {number} currentMin Lower bound of the value's current range
- * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
- * @returns {number} Re-mapped value
+ * @param {number} t   Normalized time value to interpolate
+ * @param {number} p1  Start point
+ * @param {number} cp1 First control point
+ * @param {number} cp2 Second control point
+ * @param {number} p2  End point
+ * @returns {number} Interpolated value
  */
-export function map(value, currentMin, currentMax, targetMin, targetMax) {
-    return ((value - currentMin) / (currentMax - currentMin)) * (targetMax - targetMin) + targetMin;
+export function cubicBezier(t, p1, cp1, cp2, p2) {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const k = 1 - t;
+    const k2 = k * k;
+    const k3 = k2 * k;
+    return k3 * p1 + 3 * k2 * t * cp1 + 3 * k * t2 * cp2 + t3 * p2;
 }
 /**
- * Round a number up to a nearest multiple
+ * Interpolate a value using Catmull-Rom interpolation
  *
- * @param {number} value        Value to round
- * @param {number} [multiple=1] Multiple to round to
- * @returns {number} Closest multiple
+ * @param {number} t   Normalized time value to interpolate
+ * @param {number} p1  Start point
+ * @param {number} cp1 First control point
+ * @param {number} cp2 Second control point
+ * @param {number} p2  End point
+ * @returns {number} Interpolated value
  */
-export function snap(value, multiple = 1) {
-    if (multiple === 0)
-        return value;
-    return Math.round(value / multiple) * multiple;
+export function catmullRom(t, p1, cp1, cp2, p2) {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const v1 = (cp2 - p1) * 0.5;
+    const v2 = (p2 - cp1) * 0.5;
+    return (2 * cp1 - 2 * cp2 + v1 + v2) * t3 + (-3 * cp1 + 3 * cp2 - 2 * v1 - v2) * t2 + v1 * t + cp1;
 }
 /**
  * Modulo absolute a value based on a length

package/lib/random.d.ts

@@ -1,4 +1,4 @@
-import type { Point, Point3 } from './types';
+import type { Point2, Point3 } from './types';
 /**
  * Generate a random boolean (true or false)
  *
@@ -66,34 +66,30 @@ export declare function randomIndex(weights: number[]): number;
  */
 export declare function randomGaussian(mean?: number, spread?: number): number;
 /**
- * Produce a random 2D point around the perimiter of a unit circle
+ * Produce a random 2D point around the perimiter of a circle
  *
  * @param  {number} [radius=1] Radius of the circle
- * @param  {Point} [target]    Target point
- * @returns {Point} Random 2D point on circle
+ * @returns {Point} Random 2D point on the circle
  */
-export declare function onCircle(radius?: number, target?: Point): Point;
+export declare function onCircle(radius?: number): Point2;
 /**
- * Produce a random 2D point inside a unit circle
+ * Produce a random 2D point inside a circle
  *
  * @param  {number} [radius=1] Radius of the circle
- * @param  {Point} [target]    Target vector
- * @returns {Point} Random 2D point inside circle
+ * @returns {Point} Random 2D point inside the circle
  */
-export declare function insideCircle(radius?: number, target?: Point): Point;
+export declare function insideCircle(radius?: number): Point2;
 /**
- * Produce a random 3D point on the surface of a unit sphere
+ * Produce a random 3D point on the surface of a sphere
  *
  * @param  {number} [radius=1] Radius of the sphere
- * @param  {Point3} [target]   Target vector
- * @returns {Point3} Random 3D point on sphere
+ * @returns {Point3} Random 3D point on the sphere
  */
-export declare function onSphere(radius?: number, target?: Point3): Point3;
+export declare function onSphere(radius?: number): Point3;
 /**
  * Produce a random 3D point inside a unit sphere
  *
  * @param  {number} [radius=1] Radius of the sphere
- * @param  {Point3} [target]   Target vector
- * @returns {Point3} Random 3D point inside sphere
+ * @returns {Point3} Random 3D point inside the sphere
  */
-export declare function insideSphere(radius?: number, target?: Point3): Point3;
+export declare function insideSphere(radius?: number): Point3;

package/lib/random.js

@@ -1,4 +1,4 @@
-import { radToSphere } from './geometry';
+import { Vector2, Vector3 } from './extras/geometry';
 /**
  * Generate a random boolean (true or false)
  *
@@ -112,51 +112,43 @@ export function randomGaussian(mean = 0, spread = 1) {
 // Geometry
 // *********************
 /**
- * Produce a random 2D point around the perimiter of a unit circle
+ * Produce a random 2D point around the perimiter of a circle
  *
  * @param  {number} [radius=1] Radius of the circle
- * @param  {Point} [target]    Target point
- * @returns {Point} Random 2D point on circle
+ * @returns {Point} Random 2D point on the circle
  */
-export function onCircle(radius = 1, target = [0, 0]) {
-    const angle = Math.random() * 2.0 * Math.PI;
-    target[0] = radius * Math.cos(angle);
-    target[1] = radius * Math.sin(angle);
-    return target;
+export function onCircle(radius = 1) {
+    const angle = randomFloat(0, Math.PI * 2);
+    return Vector2.fromCircularCoords(angle, radius);
 }
 /**
- * Produce a random 2D point inside a unit circle
+ * Produce a random 2D point inside a circle
  *
  * @param  {number} [radius=1] Radius of the circle
- * @param  {Point} [target]    Target vector
- * @returns {Point} Random 2D point inside circle
+ * @returns {Point} Random 2D point inside the circle
  */
-export function insideCircle(radius = 1, target = [0, 0]) {
+export function insideCircle(radius = 1) {
     radius *= Math.random();
-    return onCircle(radius, target);
+    return onCircle(radius);
 }
 /**
- * Produce a random 3D point on the surface of a unit sphere
+ * Produce a random 3D point on the surface of a sphere
  *
  * @param  {number} [radius=1] Radius of the sphere
- * @param  {Point3} [target]   Target vector
- * @returns {Point3} Random 3D point on sphere
+ * @returns {Point3} Random 3D point on the sphere
  */
-export function onSphere(radius = 1, target = [0, 0, 0]) {
-    const u = Math.random() * Math.PI * 2;
-    const v = Math.random() * 2 - 1;
-    const phi = u;
-    const theta = Math.acos(v);
-    return radToSphere(radius, phi, theta, target);
+export function onSphere(radius = 1) {
+    const phi = randomFloat(0, Math.PI);
+    const theta = randomFloat(0, 2 * Math.PI);
+    return Vector3.fromSphericalCoords(phi, theta, radius);
 }
 /**
  * Produce a random 3D point inside a unit sphere
  *
  * @param  {number} [radius=1] Radius of the sphere
- * @param  {Point3} [target]   Target vector
- * @returns {Point3} Random 3D point inside sphere
+ * @returns {Point3} Random 3D point inside the sphere
  */
-export function insideSphere(radius = 1, target = [0, 0, 0]) {
+export function insideSphere(radius = 1) {
     radius *= Math.random();
-    return onSphere(radius, target);
+    return onSphere(radius);
 }