@jscad/modeling 2.9.3 → 2.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.3",
+  "version": "2.9.6",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "85fa1fcdfb2d516a201ecf31da242e64b5b3274e"
+  "gitHead": "9768af96e5da00cd113c00ddeb0f6046707819b1"
 }

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/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/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/appendPoints.js

@@ -1,5 +1,5 @@
-const fromPoints = require('./fromPoints')
-const toPoints = require('./toPoints')
+const concat = require('./concat')
+const create = require('./create')
 
 /**
  * Append the given list of points to the end of the given geometry.
@@ -10,15 +10,6 @@ const toPoints = require('./toPoints')
  * @example
  * let newpath = appendPoints([[3, 4], [4, 5]], oldpath)
  */
-const appendPoints = (points, geometry) => {
-  if (geometry.isClosed) {
-    throw new Error('cannot append points to a closed path')
-  }
-
-  let newpoints = toPoints(geometry)
-  newpoints = newpoints.concat(points)
-
-  return fromPoints({}, newpoints)
-}
+const appendPoints = (points, geometry) => concat(geometry, create(points))
 
 module.exports = appendPoints

package/src/geometries/path2/appendPoints.test.js

@@ -17,3 +17,19 @@ test('appendPoints: appending to a path produces a new path with expected points
   t.not(p1, obs)
   t.is(pts.length, 4)
 })
+
+test('appendPoints: appending empty points to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 2)
+})
+
+test('appendPoints: appending same points to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([[2, 2], [3, 3]], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 3)
+})

package/src/geometries/path2/concat.js

@@ -1,8 +1,11 @@
 const fromPoints = require('./fromPoints')
 const toPoints = require('./toPoints')
+
 const { equals } = require('../../maths/vec2')
+
 /**
  * Concatenate the given paths.
+ *
  * If both contain the same point at the junction, merge it into one.
  * A concatenation of zero paths is an empty, open path.
  * A concatenation of one closed path to a series of open paths produces a closed path.
@@ -17,16 +20,14 @@ const { equals } = require('../../maths/vec2')
 const concat = (...paths) => {
   // Only the last path can be closed, producing a closed path.
   let isClosed = false
-  for (const path of paths) {
-    if (isClosed) {
-      throw new Error('Cannot concatenate to a closed path')
-    }
-    isClosed = path.isClosed
-  }
   let newpoints = []
-  paths.forEach((path) => {
-    const tmp = toPoints(path)
+  paths.forEach((path, i) => {
+    const tmp = toPoints(path).slice()
     if (newpoints.length > 0 && tmp.length > 0 && equals(tmp[0], newpoints[newpoints.length - 1])) tmp.shift()
+    if (tmp.length > 0 && isClosed) {
+      throw new Error(`Cannot concatenate to a closed path; check the ${i}th path`)
+    }
+    isClosed = path.isClosed
     newpoints = newpoints.concat(tmp)
   })
   return fromPoints({ closed: isClosed }, newpoints)

package/src/geometries/path2/concat.test.js

@@ -10,10 +10,16 @@ test('concat: empty paths produces an empty open path', (t) => {
   t.true(equals(concat(fromPoints({}, []), fromPoints({}, [])), fromPoints({ closed: false }, [])))
 })
 
-test('concat: Two open paths produces a open path', (t) => {
-  t.true(equals(concat(fromPoints({ closed: false }, [[0, 0]]),
-    fromPoints({ closed: false }, [[1, 1]])),
-  fromPoints({ closed: false }, [[0, 0], [1, 1]])))
+test('concat: many open paths produces a open path', (t) => {
+  const p1 = fromPoints({ closed: false }, [[0, 0]])
+  const p2 = fromPoints({ closed: false }, [[1, 1]])
+  const p3 = fromPoints({ closed: false }, [[1, 1], [3, 3]])
+
+  const result = concat(p1, p2, p3)
+  t.true(equals(result, fromPoints({}, [[0, 0], [1, 1], [3, 3]])))
+  t.is(p1.points.length, 1)
+  t.is(p2.points.length, 1)
+  t.is(p3.points.length, 2)
 })
 
 test('concat: An open path and a closed path produces a closed path', (t) => {
@@ -23,7 +29,7 @@ test('concat: An open path and a closed path produces a closed path', (t) => {
 })
 
 test('concat: A closed path and an open path throws an error', (t) => {
-  t.throws(() => concat(fromPoints({ closed: true }, [[0, 0]]),
-    fromPoints({ closed: false }, [[1, 1]])),
-  { message: 'Cannot concatenate to a closed path' })
+  const p1 = fromPoints({ closed: true }, [[0, 0]])
+  const p2 = fromPoints({ closed: false }, [[1, 1]])
+  t.throws(() => concat(p1, p2), { message: 'Cannot concatenate to a closed path; check the 1th path' })
 })

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/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/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/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

package/src/maths/mat4/fromZRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the Z axis.
  * This is equivalent to (but much faster than):
@@ -13,8 +15,8 @@
  * let matrix = fromZRotation(create(), Math.PI / 2)
  */
 const fromZRotation = (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

package/src/maths/mat4/isMirroring.js

@@ -1,7 +1,3 @@
-const cross = require('../vec3/cross')
-const dot = require('../vec3/dot')
-const fromValues = require('../vec3/fromValues')
-
 /**
  * Determine whether the given matrix is a mirroring transformation.
  *
@@ -10,15 +6,19 @@ const fromValues = require('../vec3/fromValues')
  * @alias module:modeling/maths/mat4.isMirroring
  */
 const isMirroring = (matrix) => {
-  const u = fromValues(matrix[0], matrix[4], matrix[8])
-  const v = fromValues(matrix[1], matrix[5], matrix[9])
-  const w = fromValues(matrix[2], matrix[6], matrix[10])
+  // const xVector = [matrix[0], matrix[4], matrix[8]]
+  // const yVector = [matrix[1], matrix[5], matrix[9]]
+  // const zVector = [matrix[2], matrix[6], matrix[10]]
 
-  // for a true orthogonal, non-mirrored base, u.cross(v) == w
+  // for a true orthogonal, non-mirrored base, xVector.cross(yVector) == zVector
   // If they have an opposite direction then we are mirroring
-  const mirrorvalue = dot(cross(u, u, v), w)
-  const ismirror = (mirrorvalue < 0)
-  return ismirror
+  // calcuate xVector.cross(yVector)
+  const x = matrix[4] * matrix[9] - matrix[8] * matrix[5]
+  const y = matrix[8] * matrix[1] - matrix[0] * matrix[9]
+  const z = matrix[0] * matrix[5] - matrix[4] * matrix[1]
+  // calcualte dot(cross, zVector)
+  const d = x * matrix[2] + y * matrix[6] + z * matrix[10]
+  return (d < 0)
 }
 
 module.exports = isMirroring

package/src/maths/mat4/rotate.js

@@ -1,3 +1,7 @@
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
+
 const copy = require('./copy')
 
 /**
@@ -12,20 +16,20 @@ const copy = require('./copy')
  */
 const rotate = (out, matrix, radians, 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) < 0.000001) {
+  if (Math.abs(lengthSquared) < EPS) {
     // axis is 0,0,0 or almost
     return copy(out, matrix)
   }
 
-  len = 1 / len
+  const len = 1 / Math.sqrt(lengthSquared)
   x *= len
   y *= len
   z *= len
 
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const t = 1 - c
 
   const a00 = matrix[0]

package/src/maths/mat4/rotateX.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the X axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateX
  */
 const rotateX = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a10 = matrix[4]
   const a11 = matrix[5]
   const a12 = matrix[6]

package/src/maths/mat4/rotateY.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the Y axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateY
  */
 const rotateY = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a00 = matrix[0]
   const a01 = matrix[1]
   const a02 = matrix[2]

package/src/maths/mat4/rotateZ.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the Z axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateZ
  */
 const rotateZ = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a00 = matrix[0]
   const a01 = matrix[1]
   const a02 = matrix[2]

package/src/maths/mat4/translate.test.js

@@ -52,10 +52,9 @@ test('mat4: translate() called with three parameters should update a mat4 with c
   t.true(compareVectors(obs4, [1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 2, 9, 30, 1]))
   t.true(compareVectors(ret4, [1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 2, 9, 30, 1]))
 
-  const r = (90 * 0.017453292519943295)
   const rotateZMatrix = [
-    Math.cos(r), -Math.sin(r), 0, 0,
-    Math.sin(r), Math.cos(r), 0, 0,
+    0, -1, 0, 0,
+    1, 0, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1
   ]

package/src/maths/utils/index.d.ts

@@ -3,5 +3,6 @@ export { default as area } from './area'
 export { default as interpolateBetween2DPointsForY } from './interpolateBetween2DPointsForY'
 export { default as intersect } from './intersect'
 export { default as solve2Linear } from './solve2Linear'
+export { sin, cos } from './trigonometry'
 
 export as namespace utils

package/src/maths/utils/index.js

@@ -7,7 +7,9 @@
 module.exports = {
   aboutEqualNormals: require('./aboutEqualNormals'),
   area: require('./area'),
+  cos: require('./trigonometry').cos,
   interpolateBetween2DPointsForY: require('./interpolateBetween2DPointsForY'),
   intersect: require('./intersect'),
+  sin: require('./trigonometry').sin,
   solve2Linear: require('./solve2Linear')
 }