@cognite/reveal-components 1.0.2 → 1.48552.0

package/dist/domains/axis/AxisThreeView.js

@@ -1,256 +1,502 @@
-import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
-import { isIncrement as t } from "../../foundation/utilities/extensions/mathUtils.js";
-import { numberToString as n } from "../../foundation/utilities/extensions/stringUtils.js";
-import { PrimitiveUtils as r } from "../../foundation/utilities/primitives/PrimitiveUtils.js";
-import { Range1 as i } from "../../foundation/utilities/geometry/Range1.js";
-import { Range3 as a } from "../../foundation/utilities/geometry/Range3.js";
-import { GroupThreeView as o } from "../../foundation/views/GroupThreeView.js";
-import { TrianglesBuffers as s } from "../../foundation/utilities/geometry/TrianglesBuffers.js";
-import { DEFAULT_POLYGON_OFFSET as c } from "../../foundation/utilities/misc/defaultPolygonOffset.js";
-import { createSpriteWithText as l, moveSpriteByPositionAndDirection as u } from "../../foundation/utilities/sprites/createSprite.js";
-import { BackSide as d, Box3 as f, LineBasicMaterial as p, LineSegments as m, Mesh as h, MeshBasicMaterial as g, OrthographicCamera as _, Vector3 as v } from "three";
-import { Vector3Pool as y } from "@cognite/reveal";
-//#region libs/shared/reveal-components/src/domains/axis/AxisThreeView.ts
-var b = "faceIndex1", x = "faceIndex2", S = "mainAxis", C = class extends o {
-	_corners;
-	_faceCenters;
-	_sceneBoundingBox = new f().makeEmpty();
-	_expandedSceneBoundingBox = new a();
-	get style() {
-		return super.style;
-	}
-	constructor() {
-		super(), this._corners = Array(8).fill(null).map(() => new v()), this._faceCenters = [
-			,
-			,
-			,
-			,
-			,
-			,
-		].fill(null).map(() => new v());
-	}
-	update(t) {
-		super.update(t), !this.isEmpty && t.isChanged(e.renderStyle) && (this.removeChildren(), this.invalidateBoundingBox(), this.invalidateRenderTarget());
-	}
-	beforeRender(e) {
-		if (super.beforeRender(e), this.isEmpty) return;
-		let t, n;
-		e instanceof _ ? t = e.getWorldDirection(M()) : n = e.position;
-		for (let e of this.object.children) this.updateVisibleAxis(e, n, t);
-	}
-	get shouldPick() {
-		return !1;
-	}
-	get isPartOfBoundingBox() {
-		return !1;
-	}
-	needsUpdateCore() {
-		let e = this.renderTarget.clippedVisualSceneBoundingBox;
-		return !e.equals(this._sceneBoundingBox) && (this._sceneBoundingBox.copy(e), this._expandedSceneBoundingBox.copy(e), this._expandedSceneBoundingBox.isEmpty || this._expandedSceneBoundingBox.expandByFraction(.02), !0);
-	}
-	addChildren() {
-		let e = this._expandedSceneBoundingBox;
-		if (e.isEmpty) return;
-		this.initializeCornersAndCenters(e);
-		let t = E(e), { style: n } = this;
-		for (let e = 0; e < 6; e++) this.addFace(n, t, e);
-		let r = {
-			style: n,
-			useFace: t,
-			increment: w(e, n.numberOfTicks),
-			tickLength: e.diagonal * n.tickLength
-		};
-		e.x.hasSpan && (this.addAxis(r, 0, 1, 0, 1, 2), this.addAxis(r, 3, 2, 0, 2, 4), this.addAxis(r, 7, 6, 0, 4, 5), this.addAxis(r, 4, 5, 0, 1, 5)), e.y.hasSpan && (this.addAxis(r, 3, 0, 1, 0, 2), this.addAxis(r, 1, 2, 1, 2, 3), this.addAxis(r, 5, 6, 1, 3, 5), this.addAxis(r, 7, 4, 1, 0, 5)), e.z.hasSpan && (this.addAxis(r, 0, 4, 2, 0, 1), this.addAxis(r, 1, 5, 2, 1, 3), this.addAxis(r, 2, 6, 2, 3, 4), this.addAxis(r, 3, 7, 2, 0, 4)), n.showGrid && (this.addGrid(r, 0, 1, 2), this.addGrid(r, 1, 0, 2), this.addGrid(r, 2, 0, 1), this.addGrid(r, 3, 1, 2), this.addGrid(r, 4, 0, 2), this.addGrid(r, 5, 0, 1));
-	}
-	addAxis(e, t, n, r, i, a) {
-		let { style: o, useFace: s } = e;
-		!s[i] && !s[a] || (o.showAxis && this.addAxisLine(o, t, n, r, i, a), this.addAxisTickMarksAndLabels(e, t, n, r, i, a));
-	}
-	addAxisLine(e, t, n, r, i, a) {
-		for (let o = 0; o < 2; o++) {
-			let s = o === 0, c = e.getAxisColor(s, T(r)), l = s ? 2 : 1, u = [];
-			u.push(...this._corners[t]), u.push(...this._corners[n]);
-			let d = D(u, c, l);
-			this.setUserDataOnAxis(d, i, a, s), this.addChild(d);
-		}
-	}
-	addAxisTickMarksAndLabels(e, r, a, o, s, c) {
-		let d = new i(this._corners[r].getComponent(o), this._corners[a].getComponent(o));
-		if (d.isEmpty) return;
-		let f = 0, p = 0, { style: m, tickLength: h, increment: g } = e, _ = d.getBoldIncrement(g), y = A(s, c, new v());
-		if (y.normalize(), m.showAxisTicks || m.showAxisNumbers) {
-			let e = [], i = m.tickFontSize * h;
-			for (let a of d.getTicks(g)) {
-				let u = M(this._corners[r]);
-				u.setComponent(o, a);
-				let d = M(u);
-				if (m.showAxisTicks && (d.addScaledVector(y, h), e.push(...u), e.push(...d)), m.showAxisNumbers) {
-					if (!t(a, _)) continue;
-					p === 0 && (f = a), p += 1, d.addScaledVector(y, 2 * h);
-					let e = n(o === 2 ? -a : a), r = l(e, i, m.textColor);
-					r.position.copy(d), this.addChild(r), this.setUserDataOnAxis(r, s, c, !0);
-				}
-			}
-			if (m.showAxisTicks) {
-				let t = D(e, m.mainAxisColor, 1);
-				this.setUserDataOnAxis(t, s, c, !0), this.addChild(t);
-			}
-		}
-		if (m.showAxisLabel) {
-			let e = m.axisLabelFontSize * h, t = M(), n = f + Math.round(.5 * p - .5) * _;
-			n -= _ === g ? g / 2 : g, t.copy(this._corners[r]), t.setComponent(o, n), t.addScaledVector(y, h * 5);
-			let i = l(m.getAxisLabel(T(o)), e, m.textColor);
-			u(i, t, y), this.addChild(i), this.setUserDataOnAxis(i, s, c, !0);
-		}
-	}
-	addFace(e, t, n) {
-		if (!t[n]) return;
-		let r = k(n), i = new s(4);
-		i.addPosition(this._corners[r[0]]), i.addPosition(this._corners[r[1]]), i.addPosition(this._corners[r[2]]), i.addPosition(this._corners[r[3]]), i.addTriangle(0, 1, 2), i.addTriangle(0, 2, 3);
-		let a = new g({
-			color: e.wallColor,
-			side: d,
-			...c
-		}), o = new h(i.createBufferGeometry(), a);
-		this.setUserDataOnFace(o, n), this.addChild(o);
-	}
-	addGrid(e, t, n, r) {
-		let { style: i, useFace: a, increment: o } = e;
-		if (!a[t]) return;
-		let s = k(t), c = [];
-		this.addGridInOneDirection(c, o, s[0], s[1], s[3], n), this.addGridInOneDirection(c, o, s[0], s[3], s[1], r);
-		let l = D(c, i.gridColor, 1);
-		this.setUserDataOnFace(l, t), this.addChild(l);
-	}
-	addGridInOneDirection(e, n, r, a, o, s) {
-		let c = M(this._corners[r]), l = this._corners[a], u = M(this._corners[o]), d = new i(c.getComponent(s), l.getComponent(s));
-		if (d.isEmpty) return;
-		let f = d.getBoldIncrement(n);
-		for (let r of d.getTicks(n)) t(r, f) && (c.setComponent(s, r), u.setComponent(s, r), e.push(...c), e.push(...u));
-	}
-	setUserDataOnFace(e, t) {
-		e.userData[b] = t;
-	}
-	setUserDataOnAxis(e, t, n, r) {
-		e.userData[b] = t, e.userData[x] = n, e.userData[S] = r;
-	}
-	updateVisibleAxis(e, t, n) {
-		let r = e.userData[b];
-		if (r === void 0) return;
-		let i = this.isFaceVisible(r, t, n), a = e.userData[x];
-		if (a === void 0) {
-			e.visible = i;
-			return;
-		}
-		let o = this.isFaceVisible(a, t, n);
-		e.visible = e.userData[S] ? i !== o : i && o;
-	}
-	isFaceVisible(e, t, n) {
-		if (n === void 0) {
-			if (t === void 0) return !1;
-			n = M().subVectors(this._faceCenters[e], t);
-		}
-		let r = O(e, M());
-		return n.dot(r) > .02;
-	}
-	initializeCornersAndCenters(e) {
-		if (!e.isEmpty) {
-			e.getCornerPoints(this._corners);
-			for (let e = 0; e < 6; e++) {
-				let t = k(e), n = this._faceCenters[e];
-				n.copy(this._corners[t[0]]), n.add(this._corners[t[1]]), n.add(this._corners[t[2]]), n.add(this._corners[t[3]]), n.divideScalar(4);
-			}
-		}
-	}
-};
-function w(e, t) {
-	let n = 0;
-	return e.x.hasSpan && (n = Math.max(n, e.x.getBestIncrement(t))), e.y.hasSpan && (n = Math.max(n, e.y.getBestIncrement(t))), e.z.hasSpan && (n = Math.max(n, e.z.getBestIncrement(t))), n;
+import { Mesh, LineSegments, LineBasicMaterial, Vector3, MeshBasicMaterial, BackSide, Box3, OrthographicCamera } from "three";
+import { Vector3Pool } from "@cognite/reveal";
+import { Changes } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { isIncrement } from "../../foundation/utilities/extensions/mathUtils.js";
+import { numberToString } from "../../foundation/utilities/extensions/stringUtils.js";
+import { Range1 } from "../../foundation/utilities/geometry/Range1.js";
+import { Range3 } from "../../foundation/utilities/geometry/Range3.js";
+import { TrianglesBuffers } from "../../foundation/utilities/geometry/TrianglesBuffers.js";
+import { DEFAULT_POLYGON_OFFSET } from "../../foundation/utilities/misc/defaultPolygonOffset.js";
+import { PrimitiveUtils } from "../../foundation/utilities/primitives/PrimitiveUtils.js";
+import { createSpriteWithText, moveSpriteByPositionAndDirection } from "../../foundation/utilities/sprites/createSprite.js";
+import { GroupThreeView } from "../../foundation/views/GroupThreeView.js";
+const FACE_INDEX_NAME1 = 'faceIndex1';
+const FACE_INDEX_NAME2 = 'faceIndex2';
+const MAIN_AXIS_NAME = 'mainAxis';
+export class AxisThreeView extends GroupThreeView {
+    // ==================================================
+    // INSTANCE PROPERTIES
+    // ==================================================
+    get style() {
+        return super.style;
+    }
+    constructor(){
+        super(), this._sceneBoundingBox = new Box3().makeEmpty() // Cache the bounding box of the scene
+        , this._expandedSceneBoundingBox = new Range3();
+        this._corners = new Array(8).fill(null).map(()=>new Vector3());
+        this._faceCenters = new Array(6).fill(null).map(()=>new Vector3());
+    }
+    // ==================================================
+    // OVERRIDES of BaseView
+    // ==================================================
+    update(change) {
+        super.update(change);
+        if (this.isEmpty) {
+            return;
+        }
+        if (change.isChanged(Changes.renderStyle)) {
+            this.removeChildren();
+            this.invalidateBoundingBox();
+            this.invalidateRenderTarget();
+        }
+    }
+    // ==================================================
+    // OVERRIDES of ThreeView
+    // ==================================================
+    beforeRender(camera) {
+        super.beforeRender(camera);
+        if (this.isEmpty) {
+            return;
+        }
+        let cameraDirection;
+        let cameraPosition;
+        if (camera instanceof OrthographicCamera) {
+            cameraDirection = camera.getWorldDirection(newVector3());
+        } else {
+            cameraPosition = camera.position;
+        }
+        for (const child of this.object.children){
+            this.updateVisibleAxis(child, cameraPosition, cameraDirection);
+        }
+    }
+    // ==================================================
+    // OVERRIDES of GroupThreeView
+    // ==================================================
+    get shouldPick() {
+        return false;
+    }
+    get isPartOfBoundingBox() {
+        return false;
+    }
+    needsUpdateCore() {
+        const target = this.renderTarget;
+        // Check if bounding box is different
+        const boundingBox = target.clippedVisualSceneBoundingBox;
+        if (boundingBox.equals(this._sceneBoundingBox)) {
+            return false;
+        }
+        this._sceneBoundingBox.copy(boundingBox);
+        this._expandedSceneBoundingBox.copy(boundingBox);
+        if (!this._expandedSceneBoundingBox.isEmpty) {
+            this._expandedSceneBoundingBox.expandByFraction(0.02);
+        }
+        return true;
+    }
+    addChildren() {
+        const boundingBox = this._expandedSceneBoundingBox;
+        if (boundingBox.isEmpty) {
+            return;
+        }
+        this.initializeCornersAndCenters(boundingBox);
+        const useFace = createUseFaceArray(boundingBox);
+        const { style } = this;
+        // Add faces
+        for(let faceIndex = 0; faceIndex < 6; faceIndex++){
+            this.addFace(style, useFace, faceIndex);
+        }
+        const increment = getBestIncrement(boundingBox, style.numberOfTicks);
+        const tickLength = boundingBox.diagonal * style.tickLength;
+        const props = {
+            style,
+            useFace,
+            increment,
+            tickLength
+        };
+        // Add X-axis
+        if (boundingBox.x.hasSpan) {
+            this.addAxis(props, 0, 1, 0, 1, 2);
+            this.addAxis(props, 3, 2, 0, 2, 4);
+            this.addAxis(props, 7, 6, 0, 4, 5);
+            this.addAxis(props, 4, 5, 0, 1, 5);
+        }
+        // Add Y-axis
+        if (boundingBox.y.hasSpan) {
+            this.addAxis(props, 3, 0, 1, 0, 2);
+            this.addAxis(props, 1, 2, 1, 2, 3);
+            this.addAxis(props, 5, 6, 1, 3, 5);
+            this.addAxis(props, 7, 4, 1, 0, 5);
+        }
+        // Add Z-axis
+        if (boundingBox.z.hasSpan) {
+            this.addAxis(props, 0, 4, 2, 0, 1);
+            this.addAxis(props, 1, 5, 2, 1, 3);
+            this.addAxis(props, 2, 6, 2, 3, 4);
+            this.addAxis(props, 3, 7, 2, 0, 4);
+        }
+        // Add Grid
+        if (style.showGrid) {
+            this.addGrid(props, 0, 1, 2);
+            this.addGrid(props, 1, 0, 2);
+            this.addGrid(props, 2, 0, 1);
+            this.addGrid(props, 3, 1, 2);
+            this.addGrid(props, 4, 0, 2);
+            this.addGrid(props, 5, 0, 1);
+        }
+    }
+    // ==================================================
+    // INSTANCE METHODS: Add axis
+    // ==================================================
+    addAxis(props, i0, i1, dimension, faceIndex1, faceIndex2) {
+        const { style, useFace } = props;
+        if (!useFace[faceIndex1] && !useFace[faceIndex2]) {
+            return;
+        }
+        if (style.showAxis) {
+            this.addAxisLine(style, i0, i1, dimension, faceIndex1, faceIndex2);
+        }
+        this.addAxisTickMarksAndLabels(props, i0, i1, dimension, faceIndex1, faceIndex2);
+    }
+    addAxisLine(style, i0, i1, dimension, faceIndex1, faceIndex2) {
+        // Draw axis
+        for(let i = 0; i < 2; i++){
+            const isMainAxis = i === 0;
+            const color = style.getAxisColor(isMainAxis, convertToViewerDimension(dimension));
+            const linewidth = isMainAxis ? 2 : 1;
+            const positions = [];
+            positions.push(...this._corners[i0]);
+            positions.push(...this._corners[i1]);
+            const lineSegments = createLineSegments(positions, color, linewidth);
+            this.setUserDataOnAxis(lineSegments, faceIndex1, faceIndex2, isMainAxis);
+            this.addChild(lineSegments);
+        }
+    }
+    addAxisTickMarksAndLabels(props, i0, i1, dimension, faceIndex1, faceIndex2) {
+        const range = new Range1(this._corners[i0].getComponent(dimension), this._corners[i1].getComponent(dimension));
+        if (range.isEmpty) {
+            return;
+        }
+        let minLabelTick = 0;
+        let labelCount = 0;
+        const { style, tickLength, increment } = props;
+        // Draw ticks
+        const labelInc = range.getBoldIncrement(increment);
+        const tickDirection = getTickDirection(faceIndex1, faceIndex2, new Vector3());
+        tickDirection.normalize();
+        // Add tick marks and labels
+        if (style.showAxisTicks || style.showAxisNumbers) {
+            const positions = [];
+            const tickFontSize = style.tickFontSize * tickLength;
+            for (const tick of range.getTicks(increment)){
+                const start = newVector3(this._corners[i0]);
+                start.setComponent(dimension, tick);
+                const end = newVector3(start);
+                // Add tick mark
+                if (style.showAxisTicks) {
+                    end.addScaledVector(tickDirection, tickLength);
+                    positions.push(...start);
+                    positions.push(...end);
+                }
+                if (style.showAxisNumbers) {
+                    if (!isIncrement(tick, labelInc)) {
+                        continue;
+                    }
+                    if (labelCount === 0) {
+                        minLabelTick = tick;
+                    }
+                    labelCount += 1;
+                    end.addScaledVector(tickDirection, 2 * tickLength);
+                    const text = numberToString(dimension === 2 ? -tick : tick);
+                    const sprite = createSpriteWithText(text, tickFontSize, style.textColor);
+                    sprite.position.copy(end);
+                    this.addChild(sprite);
+                    this.setUserDataOnAxis(sprite, faceIndex1, faceIndex2, true);
+                }
+            }
+            if (style.showAxisTicks) {
+                const lineSegments = createLineSegments(positions, style.mainAxisColor, 1);
+                this.setUserDataOnAxis(lineSegments, faceIndex1, faceIndex2, true);
+                this.addChild(lineSegments);
+            }
+        }
+        // Add axis sprite
+        if (style.showAxisLabel) {
+            const labelFontSize = style.axisLabelFontSize * tickLength;
+            // Find the best position by collision detect
+            const position = newVector3();
+            let tick = minLabelTick + Math.round(0.5 * labelCount - 0.5) * labelInc;
+            if (labelInc === increment) {
+                tick -= increment / 2;
+            } else {
+                tick -= increment;
+            }
+            position.copy(this._corners[i0]);
+            position.setComponent(dimension, tick);
+            position.addScaledVector(tickDirection, tickLength * 5);
+            const sprite = createSpriteWithText(style.getAxisLabel(convertToViewerDimension(dimension)), labelFontSize, style.textColor);
+            moveSpriteByPositionAndDirection(sprite, position, tickDirection);
+            this.addChild(sprite);
+            this.setUserDataOnAxis(sprite, faceIndex1, faceIndex2, true);
+        }
+    }
+    // ==================================================
+    // INSTANCE METHODS: Add face
+    // ==================================================
+    addFace(style, useFace, faceIndex) {
+        if (!useFace[faceIndex]) {
+            return;
+        }
+        const indexes = getFaceCornerIndexes(faceIndex);
+        const buffer = new TrianglesBuffers(4);
+        buffer.addPosition(this._corners[indexes[0]]);
+        buffer.addPosition(this._corners[indexes[1]]);
+        buffer.addPosition(this._corners[indexes[2]]);
+        buffer.addPosition(this._corners[indexes[3]]);
+        buffer.addTriangle(0, 1, 2);
+        buffer.addTriangle(0, 2, 3);
+        const squareMaterial = new MeshBasicMaterial({
+            color: style.wallColor,
+            side: BackSide,
+            ...DEFAULT_POLYGON_OFFSET
+        });
+        const mesh = new Mesh(buffer.createBufferGeometry(), squareMaterial);
+        this.setUserDataOnFace(mesh, faceIndex);
+        this.addChild(mesh);
+    }
+    // ==================================================
+    // INSTANCE METHODS: Add grid
+    // ==================================================
+    addGrid(props, faceIndex, dim1, dim2) {
+        const { style, useFace, increment } = props;
+        if (!useFace[faceIndex]) {
+            return;
+        }
+        const indexes = getFaceCornerIndexes(faceIndex);
+        const positions = [];
+        this.addGridInOneDirection(positions, increment, indexes[0], indexes[1], indexes[3], dim1);
+        this.addGridInOneDirection(positions, increment, indexes[0], indexes[3], indexes[1], dim2);
+        const lineSegments = createLineSegments(positions, style.gridColor, 1);
+        this.setUserDataOnFace(lineSegments, faceIndex);
+        this.addChild(lineSegments);
+    }
+    addGridInOneDirection(positions, increment, i0, i1, i2, dimension) {
+        //   p2
+        //     +-----------+
+        //     | | | | | | |
+        //     | | | | | | | <--- Draw these lines
+        //     | | | | | | |
+        //     +-----------+
+        //   p0            p1
+        const p0 = newVector3(this._corners[i0]);
+        const p1 = this._corners[i1];
+        const p2 = newVector3(this._corners[i2]);
+        const range = new Range1(p0.getComponent(dimension), p1.getComponent(dimension));
+        if (range.isEmpty) {
+            return;
+        }
+        const boldIncrement = range.getBoldIncrement(increment);
+        for (const tick of range.getTicks(increment)){
+            if (!isIncrement(tick, boldIncrement)) {
+                continue;
+            }
+            p0.setComponent(dimension, tick);
+            p2.setComponent(dimension, tick);
+            positions.push(...p0);
+            positions.push(...p2);
+        }
+    }
+    // ==================================================
+    // INSTANCE METHODS: Visibility
+    // ==================================================
+    setUserDataOnFace(object, setUserDataOnFace) {
+        object.userData[FACE_INDEX_NAME1] = setUserDataOnFace;
+    }
+    setUserDataOnAxis(object, faceIndex1, faceIndex2, mainAxis) {
+        object.userData[FACE_INDEX_NAME1] = faceIndex1;
+        object.userData[FACE_INDEX_NAME2] = faceIndex2;
+        object.userData[MAIN_AXIS_NAME] = mainAxis;
+    }
+    updateVisibleAxis(object, cameraPosition, cameraDirection) {
+        const faceIndex1 = object.userData[FACE_INDEX_NAME1];
+        if (faceIndex1 === undefined) {
+            return;
+        }
+        const visible1 = this.isFaceVisible(faceIndex1, cameraPosition, cameraDirection);
+        const faceIndex2 = object.userData[FACE_INDEX_NAME2];
+        if (faceIndex2 === undefined) {
+            object.visible = visible1;
+            return;
+        }
+        const visible2 = this.isFaceVisible(faceIndex2, cameraPosition, cameraDirection);
+        const mainAxis = object.userData[MAIN_AXIS_NAME];
+        if (mainAxis) {
+            object.visible = visible1 !== visible2;
+        } else {
+            object.visible = visible1 && visible2;
+        }
+    }
+    isFaceVisible(faceIndex, cameraPosition, cameraDirection) {
+        if (cameraDirection === undefined) {
+            if (cameraPosition === undefined) {
+                return false;
+            }
+            cameraDirection = newVector3().subVectors(this._faceCenters[faceIndex], cameraPosition);
+        }
+        const normal = getFaceNormal(faceIndex, newVector3());
+        return cameraDirection.dot(normal) > 0.02;
+    }
+    initializeCornersAndCenters(boundingBox) {
+        if (boundingBox.isEmpty) {
+            return;
+        }
+        // Initialize the corners and the centers
+        boundingBox.getCornerPoints(this._corners);
+        for(let faceIndex = 0; faceIndex < 6; faceIndex++){
+            const indexes = getFaceCornerIndexes(faceIndex);
+            const center = this._faceCenters[faceIndex];
+            center.copy(this._corners[indexes[0]]);
+            center.add(this._corners[indexes[1]]);
+            center.add(this._corners[indexes[2]]);
+            center.add(this._corners[indexes[3]]);
+            center.divideScalar(4);
+        }
+    }
 }
-function T(e) {
-	return e === 1 ? 2 : e === 2 ? 1 : e;
+// ==================================================
+// PRIVATE FUNCTIONS: Getters
+// ==================================================
+function getBestIncrement(range, numberOfTicks) {
+    let increment = 0;
+    if (range.x.hasSpan) increment = Math.max(increment, range.x.getBestIncrement(numberOfTicks));
+    if (range.y.hasSpan) increment = Math.max(increment, range.y.getBestIncrement(numberOfTicks));
+    if (range.z.hasSpan) increment = Math.max(increment, range.z.getBestIncrement(numberOfTicks));
+    return increment;
 }
-function E(e) {
-	let t = [
-		,
-		,
-		,
-		,
-		,
-		,
-	];
-	return t[0] = e.y.hasSpan && e.z.hasSpan, t[1] = e.x.hasSpan && e.z.hasSpan, t[2] = e.x.hasSpan && e.y.hasSpan, t[3] = e.y.hasSpan && e.z.hasSpan, t[4] = e.x.hasSpan && e.z.hasSpan, t[5] = e.x.hasSpan && e.y.hasSpan, t;
+function convertToViewerDimension(dimension) {
+    // This swaps the Z and Y axis
+    if (dimension === 1) {
+        return 2;
+    }
+    if (dimension === 2) {
+        return 1;
+    }
+    return dimension;
 }
-function D(e, t, n) {
-	let i = r.createBufferGeometry(e), a = new p({
-		color: t,
-		linewidth: n
-	});
-	return new m(i, a);
+// ==================================================
+// PRIVATE FUNCTIONS: Creators
+// ==================================================
+function createUseFaceArray(range) {
+    const useFace = new Array(6);
+    useFace[0] = range.y.hasSpan && range.z.hasSpan;
+    useFace[1] = range.x.hasSpan && range.z.hasSpan;
+    useFace[2] = range.x.hasSpan && range.y.hasSpan;
+    useFace[3] = range.y.hasSpan && range.z.hasSpan;
+    useFace[4] = range.x.hasSpan && range.z.hasSpan;
+    useFace[5] = range.x.hasSpan && range.y.hasSpan;
+    return useFace;
 }
-function O(e, t) {
-	switch (e) {
-		case 0: return t.set(-1, 0, 0);
-		case 1: return t.set(0, -1, 0);
-		case 2: return t.set(0, 0, -1);
-		case 3: return t.set(1, 0, 0);
-		case 4: return t.set(0, 1, 0);
-		case 5: return t.set(0, 0, 1);
-		default: throw Error("getFaceNormal");
-	}
+function createLineSegments(positions, color, linewidth) {
+    const geometry = PrimitiveUtils.createBufferGeometry(positions);
+    const material = new LineBasicMaterial({
+        color,
+        linewidth
+    });
+    return new LineSegments(geometry, material);
 }
-function k(e) {
-	switch (e) {
-		case 0: return [
-			3,
-			0,
-			4,
-			7
-		];
-		case 1: return [
-			0,
-			1,
-			5,
-			4
-		];
-		case 2: return [
-			3,
-			2,
-			1,
-			0
-		];
-		case 3: return [
-			1,
-			2,
-			6,
-			5
-		];
-		case 4: return [
-			2,
-			3,
-			7,
-			6
-		];
-		case 5: return [
-			4,
-			5,
-			6,
-			7
-		];
-		default: return [
-			0,
-			0,
-			0,
-			0
-		];
-	}
+// ==================================================
+// PRIVATE METHODS: Some math
+// ==================================================
+// Corner and faces is pr. definition:
+//            5  4
+//            v /
+//        7--------6                7-------6
+//       / |      /|               / |      /|
+//      4-------5  |              4-------5  |
+// 0->  |  |    |  |  <-3         |  |    |  |
+//      |  3----|--2              |  3----|--2
+//      | /     | /               | /     | /
+//      0-------1                 0-------1
+//        /  ^
+//       1   2
+// Face number are marked with arrows
+function getFaceNormal(faceIndex, target) {
+    switch(faceIndex){
+        case 0:
+            return target.set(-1, +0, +0);
+        case 1:
+            return target.set(+0, -1, +0);
+        case 2:
+            return target.set(+0, +0, -1);
+        case 3:
+            return target.set(+1, +0, +0);
+        case 4:
+            return target.set(+0, +1, +0);
+        case 5:
+            return target.set(+0, +0, +1);
+        default:
+            throw Error('getFaceNormal');
+    }
 }
-function A(e, t, n) {
-	return n.setScalar(0), (e === 0 || t === 0) && (n.x = -Math.SQRT1_2), (e === 3 || t === 3) && (n.x = Math.SQRT1_2), (e === 1 || t === 1) && (n.y = -Math.SQRT1_2), (e === 4 || t === 4) && (n.y = Math.SQRT1_2), (e === 2 || t === 2) && (n.z = -Math.SQRT1_2), (e === 5 || t === 5) && (n.z = Math.SQRT1_2), n;
+function getFaceCornerIndexes(faceIndex) {
+    // These as CCW
+    switch(faceIndex){
+        case 0:
+            return [
+                3,
+                0,
+                4,
+                7
+            ];
+        case 1:
+            return [
+                0,
+                1,
+                5,
+                4
+            ];
+        case 2:
+            return [
+                3,
+                2,
+                1,
+                0
+            ];
+        case 3:
+            return [
+                1,
+                2,
+                6,
+                5
+            ];
+        case 4:
+            return [
+                2,
+                3,
+                7,
+                6
+            ];
+        case 5:
+            return [
+                4,
+                5,
+                6,
+                7
+            ];
+        default:
+            Error('getFaceCornerIndexes');
+            return [
+                0,
+                0,
+                0,
+                0
+            ];
+    }
 }
-var j = new y();
-function M(e) {
-	return j.getNext(e);
+function getTickDirection(faceIndex1, faceIndex2, target) {
+    target.setScalar(0);
+    if (faceIndex1 === 0 || faceIndex2 === 0) target.x = -Math.SQRT1_2;
+    if (faceIndex1 === 3 || faceIndex2 === 3) target.x = Math.SQRT1_2;
+    if (faceIndex1 === 1 || faceIndex2 === 1) target.y = -Math.SQRT1_2;
+    if (faceIndex1 === 4 || faceIndex2 === 4) target.y = Math.SQRT1_2;
+    if (faceIndex1 === 2 || faceIndex2 === 2) target.z = -Math.SQRT1_2;
+    if (faceIndex1 === 5 || faceIndex2 === 5) target.z = Math.SQRT1_2;
+    return target;
 }
-//#endregion
-export { C as AxisThreeView };
+// ==================================================
+// PRIVATE FUNCTIONS: Vector pool
+// ==================================================
+const VECTOR_POOL = new Vector3Pool();
+function newVector3(copyFrom) {
+    return VECTOR_POOL.getNext(copyFrom);
+}
+
+//# sourceMappingURL=AxisThreeView.js.map