@jscad/modeling 2.9.2 → 2.9.5

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.2",
+  "version": "2.9.5",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
+  "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -60,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "0cebde0166c104e3c08cc05d2c03d9defc7eca26"
+  "gitHead": "225b034db0d94f748992da72b269833954a2e212"
 }

package/src/colors/colorize.d.ts

@@ -5,9 +5,10 @@ import { RGB, RGBA } from './types'
 
 export default colorize
 
-declare function colorize<T extends Geometry>(color: RGB | RGBA, object: T): T
-declare function colorize<T>(color: RGB | RGBA, object: T): T & Colored
+// Single Geom3 returns Colored Geom3
+declare function colorize<T extends Geometry>(color: RGB | RGBA, object: T): T & Colored
 
-declare function colorize<T extends Geometry>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T>
-declare function colorize<T>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T & Colored>
-declare function colorize(color: RGB | RGBA, ...objects: RecursiveArray<any>): Array<any & Colored>
+// List of Geom3 returns list of Colored Geom3
+declare function colorize<T extends Geometry>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T & Colored>
+// List of mixed geometries returns list of colored geometries
+declare function colorize(color: RGB | RGBA, ...objects: RecursiveArray<Geometry>): Array<Geometry & Colored>

package/src/colors/colorize.test.js

@@ -38,7 +38,7 @@ test('color (rgba on geometry)', (t) => {
   const obj0 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
   const obj1 = geom3.fromPoints([[[0, 0, 0], [1, 0, 0], [1, 0, 1]]])
   const obj2 = path2.fromPoints({ closed: true }, [[0, 0], [1, 0], [1, 1]])
-  const obj3 = poly3.fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const obj3 = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
 
   const obs = colorize([1, 1, 0.5, 0.8], obj0, obj1, obj2, obj3)
   t.is(obs.length, 4)

package/src/geometries/geom2/toOutlines.js

@@ -6,22 +6,42 @@ const toSides = require('./toSides')
  * Create a list of edges which SHARE vertices.
  * This allows the edges to be traversed in order.
  */
-const toEdges = (sides) => {
-  const vertices = {}
+const toSharedVertices = (sides) => {
+  const unique = new Map() // {key: vertex}
   const getUniqueVertex = (vertex) => {
     const key = vertex.toString()
-    if (!vertices[key]) {
-      vertices[key] = vertex
+    if (unique.has(key)) {
+      return unique.get(key)
+    } else {
+      unique.set(key, vertex)
+      return vertex
     }
-    return vertices[key]
   }
 
   return sides.map((side) => side.map(getUniqueVertex))
 }
 
+/*
+ * Convert a list of sides into a map from vertex to edges.
+ */
+const toVertexMap = (sides) => {
+  const vertexMap = new Map()
+  // first map to edges with shared vertices
+  const edges = toSharedVertices(sides)
+  // construct adjacent edges map
+  edges.forEach((edge) => {
+    if (vertexMap.has(edge[0])) {
+      vertexMap.get(edge[0]).push(edge)
+    } else {
+      vertexMap.set(edge[0], [edge])
+    }
+  })
+  return vertexMap
+}
+
 /**
  * Create the outline(s) of the given geometry.
- * @param  {geom2} geometry
+ * @param {geom2} geometry - geometry to create outlines from
  * @returns {Array} an array of outlines, where each outline is an array of ordered points
  * @alias module:modeling/geometries/geom2.toOutlines
  *
@@ -30,65 +50,35 @@ const toEdges = (sides) => {
  * let outlines = toOutlines(geometry) // returns two outlines
  */
 const toOutlines = (geometry) => {
-  const vertexMap = new Map()
-  const edges = toEdges(toSides(geometry))
-  edges.forEach((edge) => {
-    if (!(vertexMap.has(edge[0]))) {
-      vertexMap.set(edge[0], [])
-    }
-    const sideslist = vertexMap.get(edge[0])
-    sideslist.push(edge)
-  })
-
+  const vertexMap = toVertexMap(toSides(geometry)) // {vertex: [edges]}
   const outlines = []
   while (true) {
-    let startside
+    let startSide
     for (const [vertex, edges] of vertexMap) {
-      startside = edges.shift()
-      if (!startside) {
+      startSide = edges.shift()
+      if (!startSide) {
         vertexMap.delete(vertex)
         continue
       }
       break
     }
-    if (startside === undefined) break // all starting sides have been visited
+    if (startSide === undefined) break // all starting sides have been visited
 
     const connectedVertexPoints = []
-    const startvertex = startside[0]
-    const v0 = vec2.create()
+    const startVertex = startSide[0]
     while (true) {
-      connectedVertexPoints.push(startside[0])
-      const nextvertex = startside[1]
-      if (nextvertex === startvertex) break // the outline has been closed
-      const nextpossiblesides = vertexMap.get(nextvertex)
-      if (!nextpossiblesides) {
-        throw new Error('the given geometry is not closed. verify proper construction')
+      connectedVertexPoints.push(startSide[0])
+      const nextVertex = startSide[1]
+      if (nextVertex === startVertex) break // the outline has been closed
+      const nextPossibleSides = vertexMap.get(nextVertex)
+      if (!nextPossibleSides) {
+        throw new Error(`geometry is not closed at vertex ${nextVertex}`)
       }
-      let nextsideindex = -1
-      if (nextpossiblesides.length === 1) {
-        nextsideindex = 0
-      } else {
-        // more than one side starting at the same vertex
-        let bestangle
-        const startangle = vec2.angleDegrees(vec2.subtract(v0, startside[1], startside[0]))
-        for (let sideindex = 0; sideindex < nextpossiblesides.length; sideindex++) {
-          const nextpossibleside = nextpossiblesides[sideindex]
-          const nextangle = vec2.angleDegrees(vec2.subtract(v0, nextpossibleside[1], nextpossibleside[0]))
-          let angledif = nextangle - startangle
-          if (angledif < -180) angledif += 360
-          if (angledif >= 180) angledif -= 360
-          if ((nextsideindex < 0) || (angledif > bestangle)) {
-            nextsideindex = sideindex
-            bestangle = angledif
-          }
-        }
+      const nextSide = popNextSide(startSide, nextPossibleSides)
+      if (nextPossibleSides.length === 0) {
+        vertexMap.delete(nextVertex)
       }
-      const nextside = nextpossiblesides[nextsideindex]
-      nextpossiblesides.splice(nextsideindex, 1) // remove side from list
-      if (nextpossiblesides.length === 0) {
-        vertexMap.delete(nextvertex)
-      }
-      startside = nextside
+      startSide = nextSide
     } // inner loop
 
     // due to the logic of fromPoints()
@@ -102,4 +92,28 @@ const toOutlines = (geometry) => {
   return outlines
 }
 
+// find the first counter-clockwise edge from startSide and pop from nextSides
+const popNextSide = (startSide, nextSides) => {
+  if (nextSides.length === 1) {
+    return nextSides.pop()
+  }
+  const v0 = vec2.create()
+  const startAngle = vec2.angleDegrees(vec2.subtract(v0, startSide[1], startSide[0]))
+  let bestAngle
+  let bestIndex
+  nextSides.forEach((nextSide, index) => {
+    const nextAngle = vec2.angleDegrees(vec2.subtract(v0, nextSide[1], nextSide[0]))
+    let angle = nextAngle - startAngle
+    if (angle < -180) angle += 360
+    if (angle >= 180) angle -= 360
+    if (bestIndex === undefined || angle > bestAngle) {
+      bestIndex = index
+      bestAngle = angle
+    }
+  })
+  const nextSide = nextSides[bestIndex]
+  nextSides.splice(bestIndex, 1) // remove side from list
+  return nextSide
+}
+
 module.exports = toOutlines

package/src/geometries/geom2/type.d.ts

@@ -1,10 +1,11 @@
 import Vec2 from '../../maths/vec2/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Geom2
 
-declare interface Geom2 extends Colored {
+declare interface Geom2 {
   sides: Array<[Vec2, Vec2]>
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/geom3/applyTransforms.js

@@ -14,9 +14,8 @@ const applyTransforms = (geometry) => {
   if (mat4.isIdentity(geometry.transforms)) return geometry
 
   // apply transforms to each polygon
-  // const isMirror = mat4.isMirroring(geometry.transforms)
-  // TBD if (isMirror) newvertices.reverse()
   geometry.polygons = geometry.polygons.map((polygon) => poly3.transform(geometry.transforms, polygon))
+  // reset transforms
   geometry.transforms = mat4.create()
   return geometry
 }

package/src/geometries/geom3/create.js

@@ -18,7 +18,7 @@ const create = (polygons) => {
     polygons = [] // empty contents
   }
   return {
-    polygons: polygons,
+    polygons,
     transforms: mat4.create()
   }
 }

package/src/geometries/geom3/create.test.js

@@ -14,7 +14,7 @@ test('create: Creates an empty geom3', (t) => {
 
 test('create: Creates a populated geom3', (t) => {
   const points = [[0, 0, 0], [0, 10, 0], [0, 10, 10]]
-  const polygon = poly3.fromPoints(points)
+  const polygon = poly3.create(points)
 
   const polygons = [polygon]
   const expected = {

package/src/geometries/geom3/fromPoints.js

@@ -18,7 +18,7 @@ const fromPoints = (listofpoints) => {
 
   const polygons = listofpoints.map((points, index) => {
     // TODO catch the error, and rethrow with index
-    const polygon = poly3.fromPoints(points)
+    const polygon = poly3.create(points)
     return polygon
   })
   const result = create(polygons)

package/src/geometries/geom3/type.d.ts

@@ -1,10 +1,11 @@
 import Poly3 from '../poly3/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Geom3
 
-declare interface Geom3 extends Colored {
+declare interface Geom3 {
   polygons: Array<Poly3>
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/path2/index.d.ts

@@ -5,7 +5,6 @@ export { default as clone } from './clone'
 export { default as close } from './close'
 export { default as concat } from './concat'
 export { default as create } from './create'
-export { default as eachPoint, EachPointOptions } from './eachPoint'
 export { default as equals } from './equals'
 export { default as fromPoints, FromPointsOptions } from './fromPoints'
 export { default as fromCompactBinary } from './fromCompactBinary'

package/src/geometries/path2/index.js

@@ -22,7 +22,6 @@ module.exports = {
   close: require('./close'),
   concat: require('./concat'),
   create: require('./create'),
-  eachPoint: require('./eachPoint'),
   equals: require('./equals'),
   fromPoints: require('./fromPoints'),
   fromCompactBinary: require('./fromCompactBinary'),

package/src/geometries/path2/type.d.ts

@@ -1,11 +1,12 @@
 import Vec2 from '../../maths/vec2/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Path2
 
-declare interface Path2 extends Colored {
+declare interface Path2 {
   points: Array<Vec2>
   isClosed: boolean
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/poly3/create.js

@@ -18,7 +18,7 @@ const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
-  return { vertices: vertices }
+  return { vertices }
 }
 
 module.exports = create

package/src/geometries/poly3/measureBoundingSphere.d.ts

@@ -1,6 +1,6 @@
 import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import Vec4 from '../../maths/vec4/type'
 
 export default measureBoundingSphere
 
-declare function measureBoundingSphere(polygon: Poly3): [Vec3, Vec3]
+declare function measureBoundingSphere(polygon: Poly3): Vec4

package/src/geometries/poly3/measureBoundingSphere.js

@@ -1,19 +1,57 @@
 const vec3 = require('../../maths/vec3')
-const measureBoundingBox = require('./measureBoundingBox')
+const vec4 = require('../../maths/vec4')
+
+const cache = new WeakMap()
 
 /**
  * Measure the bounding sphere of the given polygon.
  * @param {poly3} polygon - the polygon to measure
- * @returns {Array} the computed bounding sphere; center point (3D) and radius
+ * @returns {vec4} the computed bounding sphere; center point (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
 const measureBoundingSphere = (polygon) => {
-  const box = measureBoundingBox(polygon)
-  const center = box[0]
-  vec3.add(center, box[0], box[1])
-  vec3.scale(center, center, 0.5)
-  const radius = vec3.distance(center, box[1])
-  return [center, radius]
+  let boundingSphere = cache.get(polygon)
+  if (boundingSphere) return boundingSphere
+
+  const vertices = polygon.vertices
+  const out = vec4.create()
+
+  if (vertices.length === 0) {
+    out[0] = 0
+    out[1] = 0
+    out[2] = 0
+    out[3] = 0
+    return out
+  }
+
+  // keep a list of min/max vertices by axis
+  let minx = vertices[0]
+  let miny = minx
+  let minz = minx
+  let maxx = minx
+  let maxy = minx
+  let maxz = minx
+
+  vertices.forEach((v) => {
+    if (minx[0] > v[0]) minx = v
+    if (miny[1] > v[1]) miny = v
+    if (minz[2] > v[2]) minz = v
+    if (maxx[0] < v[0]) maxx = v
+    if (maxy[1] < v[1]) maxy = v
+    if (maxz[2] < v[2]) maxz = v
+  })
+
+  out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
+  out[1] = (miny[1] + maxy[1]) * 0.5
+  out[2] = (minz[2] + maxz[2]) * 0.5
+  const x = out[0] - maxx[0]
+  const y = out[1] - maxy[1]
+  const z = out[2] - maxz[2]
+  out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
+
+  cache.set(polygon, out)
+
+  return out
 }
 
 module.exports = measureBoundingSphere

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -3,28 +3,23 @@ const { measureBoundingSphere, create, fromPoints, transform } = require('./inde
 
 const mat4 = require('../../maths/mat4')
 
-const { compareVectors, nearlyEqual } = require('../../../test/helpers/index')
-
 test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let ply1 = create()
-  let exp1 = [[0, 0, 0], 0]
+  let exp1 = [0, 0, 0, 0]
   let ret1 = measureBoundingSphere(ply1)
-  t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
+  t.deepEqual(ret1, exp1)
 
   // simple triangle
   let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
-  let exp2 = [[0, 5, 5], 7.0710678118654755]
+  let exp2 = [0, 5, 5, 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
-  t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
+  t.deepEqual(ret2, exp2)
 
   // simple square
   let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
-  let exp3 = [[0, 5, 5], 7.0710678118654755]
+  let exp3 = [0, 5, 5, 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
-  t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
+  t.deepEqual(ret3, exp3)
 
   // V-shape
   const points = [
@@ -40,10 +35,9 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
     [0, 3, 3]
   ]
   let ply4 = fromPoints(points)
-  let exp4 = [[0, 4.5, 3], 4.6097722286464435]
+  let exp4 = [0, 4.5, 3, 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
-  t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
+  t.deepEqual(ret4, exp4)
 
   // rotated to various angles
   const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
@@ -55,16 +49,12 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ret2 = measureBoundingSphere(ply2)
   ret3 = measureBoundingSphere(ply3)
   ret4 = measureBoundingSphere(ply4)
-  exp1 = [[0, 0, 0], 0]
-  t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
-  exp2 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
-  t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
-  exp3 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
-  t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
-  exp4 = [[-3.181980515339464, 3.1819805153394642, 3], 4.6097722286464435]
-  t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
+  exp1 = [0, 0, 0, 0]
+  t.deepEqual(ret1, exp1)
+  exp2 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]
+  t.deepEqual(ret2, exp2)
+  exp3 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]
+  t.deepEqual(ret3, exp3)
+  exp4 = [-3.181980515339464, 3.1819805153394642, 3, 4.6097722286464435]
+  t.deepEqual(ret4, exp4)
 })

package/src/geometries/poly3/type.d.ts

@@ -1,8 +1,9 @@
 import Vec3 from '../../maths/vec3/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Poly3
 
-declare interface Poly3 extends Colored {
+declare interface Poly3 {
   vertices: Array<Vec3>
+  color?: Color
 }

package/src/geometries/poly3/validate.js

@@ -1,7 +1,10 @@
+const signedDistanceToPoint = require('../../maths/plane/signedDistanceToPoint')
+const { NEPS } = require('../../maths/constants')
 const vec3 = require('../../maths/vec3')
 const isA = require('./isA')
 const isConvex = require('./isConvex')
 const measureArea = require('./measureArea')
+const plane = require('./plane')
 
 /**
  * Determine if the given object is a valid polygon.
@@ -45,6 +48,17 @@ const validate = (object) => {
       throw new Error(`poly3 invalid vertex ${vertex}`)
     }
   })
+
+  // check that points are co-planar
+  if (object.vertices.length > 3) {
+    const normal = plane(object)
+    object.vertices.forEach((vertex) => {
+      const dist = Math.abs(signedDistanceToPoint(normal, vertex))
+      if (dist > NEPS) {
+        throw new Error(`poly3 must be coplanar: vertex ${vertex} distance ${dist}`)
+      }
+    })
+  }
 }
 
 module.exports = validate

package/src/geometries/types.d.ts

@@ -8,8 +8,10 @@ import { RGB, RGBA } from '../colors'
 // see https://github.com/jscad/OpenJSCAD.org/pull/726#issuecomment-724575265
 export type Geometry = Geom2 | Geom3 | Poly3 | Path2
 
-export type Colored = {
-  color?: RGB | RGBA
+export type Color = RGB | RGBA
+
+export interface Colored {
+  color: Color
 }
 
 export { default as Geom2 } from './geom2/type'

package/src/maths/constants.d.ts

@@ -1,2 +1,3 @@
 export const EPS: number
+export const NEPS: number
 export const spatialResolution: number

package/src/maths/constants.js

@@ -14,7 +14,18 @@ const spatialResolution = 1e5
  */
 const EPS = 1e-5
 
+/**
+ * Smaller epsilon used for measuring near zero distances.
+ * @default
+ * @alias module:modeling/maths.NEPS
+ */
+const NEPS = 1e-13
+// NEPS is derived from a series of tests to determine the optimal precision
+// for comparing coplanar polygons, as provided by the sphere primitive at high
+// segmentation. NEPS is for 64 bit Number values.
+
 module.exports = {
   EPS,
+  NEPS,
   spatialResolution
 }

package/src/maths/mat4/fromRotation.js

@@ -1,6 +1,8 @@
-const identity = require('./identity')
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
 
-const { EPSILON } = require('./constants')
+const identity = require('./identity')
 
 /**
  * Creates a matrix from a given angle around a given axis
@@ -19,20 +21,20 @@ const { EPSILON } = require('./constants')
  */
 const fromRotation = (out, rad, axis) => {
   let [x, y, z] = axis
-  let len = Math.hypot(x, y, z)
+  const lengthSquared = x * x + y * y + z * z
 
-  if (Math.abs(len) < EPSILON) {
+  if (Math.abs(lengthSquared) < EPS) {
     // axis is 0,0,0 or almost
     return identity(out)
   }
 
-  len = 1 / len
+  const len = 1 / Math.sqrt(lengthSquared)
   x *= len
   y *= len
   z *= len
 
-  const s = Math.sin(rad)
-  const c = Math.cos(rad)
+  const s = sin(rad)
+  const c = cos(rad)
   const t = 1 - c
 
   // Perform rotation-specific matrix multiplication

package/src/maths/mat4/fromTaitBryanRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given Tait–Bryan angles.
  *
@@ -15,12 +17,12 @@
  */
 const fromTaitBryanRotation = (out, yaw, pitch, roll) => {
   // precompute sines and cosines of Euler angles
-  const sy = Math.sin(yaw)
-  const cy = Math.cos(yaw)
-  const sp = Math.sin(pitch)
-  const cp = Math.cos(pitch)
-  const sr = Math.sin(roll)
-  const cr = Math.cos(roll)
+  const sy = sin(yaw)
+  const cy = cos(yaw)
+  const sp = sin(pitch)
+  const cp = cos(pitch)
+  const sr = sin(roll)
+  const cr = cos(roll)
 
   // create and populate rotation matrix
   // left-hand-rule rotation

package/src/maths/mat4/fromXRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the X axis.
  * This is equivalent to (but much faster than):
@@ -13,8 +15,8 @@
  * let matrix = fromXRotation(create(), Math.PI / 2)
  */
 const fromXRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = 1

package/src/maths/mat4/fromYRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the Y axis.
  * This is equivalent to (but much faster than):
@@ -13,8 +15,8 @@
  * let matrix = fromYRotation(create(), Math.PI / 2)
  */
 const fromYRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = c