@cyclonium/canvas-3d 0.0.100

package/lib/geometry.js

@@ -0,0 +1,1503 @@
+import { Color, gfx, Mat4, RenderingSubMesh, Vec2, Vec3 } from 'cc';
+import { Canvas3DLineCap, Canvas3DLineJoin } from './types.js';
+export var PrimitiveEntryType;
+(function (PrimitiveEntryType) {
+    PrimitiveEntryType["line"] = "line";
+    PrimitiveEntryType["box"] = "box";
+    PrimitiveEntryType["quad"] = "quad";
+    PrimitiveEntryType["cylinder"] = "cylinder";
+    PrimitiveEntryType["disc"] = "disc";
+    PrimitiveEntryType["ring"] = "ring";
+    PrimitiveEntryType["sphere"] = "sphere";
+    PrimitiveEntryType["capsule"] = "capsule";
+})(PrimitiveEntryType || (PrimitiveEntryType = {}));
+export const epsilon = 1e-6;
+const defaultCircleSegments = 64;
+const defaultSphereLatitudeSegments = 12;
+const defaultSphereLongitudeSegments = 24;
+const defaultCylinderRadialSegments = defaultSphereLongitudeSegments;
+const defaultCapsuleCapSegments = 6;
+const minCircleSegments = 3;
+const minSphereLatitudeSegments = 2;
+const minCapsuleCapSegments = 1;
+const lineCapLatitudeSegments = 6;
+const lineCapLongitudeSegments = 12;
+export const roundSegmentRadians = Math.PI / 16;
+const vertexStrideF = 7;
+const strokeSegmentVertexCount = 8;
+const vec3Caches_appendDashedLine3DStroke = createVec3Cache(3);
+const vec3Caches_appendSolidLine3DStroke = createVec3Cache(4);
+const vec3Caches_appendDiscFill = createVec3Cache(2);
+const vec3Caches_appendRingFill = createVec3Cache(8);
+const vec3Caches_appendSphereFill = createVec3Cache(2);
+const vec3Caches_appendHemisphereWireStroke = createVec3Cache(4);
+const vec3Caches_appendHemisphereFill = createVec3Cache(2);
+const vec3Caches_appendCylinderFill = createVec3Cache(4);
+export const defaultDrawOptions = {
+    depthTest: false,
+    depthWrite: false,
+};
+const circleTopologyCache = new Map();
+const sphereTopologyCache = new Map();
+const cylinderIndexTopologyCache = new Map();
+const hemisphereTopologyCache = new Map();
+export function createMeshGeometry() {
+    return {
+        vertices: [],
+        indices: [],
+    };
+}
+export function hasGeometry(geometry) {
+    return geometry.vertices.length > 0 && geometry.indices.length > 0;
+}
+export function appendMeshGeometry(out, geometry) {
+    if (!hasGeometry(geometry)) {
+        return;
+    }
+    const baseVertex = out.vertices.length / vertexStrideF;
+    out.vertices.push(...geometry.vertices);
+    for (const index of geometry.indices) {
+        out.indices.push(baseVertex + index);
+    }
+}
+export function resolvePoint(pointOrX, y, z) {
+    if (typeof pointOrX === 'number') {
+        return new Vec3(pointOrX, y ?? 0, z ?? 0);
+    }
+    return pointOrX.clone();
+}
+export function setColor(out, value) {
+    if (typeof value === 'string') {
+        Color.fromHEX(out, value);
+        return;
+    }
+    out.set(value);
+}
+function getDrawOptions(state) {
+    return {
+        depthTest: state.depthTest,
+        depthWrite: state.depthWrite,
+    };
+}
+export function getMaterialKey(options) {
+    return `${options.depthTest ? 1 : 0}:${options.depthWrite ? 1 : 0}`;
+}
+export function drawPrimitive(enqueueGeometry, baseState, entries, options) {
+    const state = createPrimitiveDrawStateWithOptions(baseState, options);
+    const mode = options?.mode ?? 'wireframe';
+    if (shouldDrawPrimitiveSolid(mode)) {
+        const geometry = createMeshGeometry();
+        appendPrimitiveEntriesFill(geometry, entries, state);
+        enqueueGeometry(geometry, getDrawOptions(state));
+    }
+    if (shouldDrawPrimitiveWireframe(mode) && state.lineWidth > 0) {
+        const geometry = createMeshGeometry();
+        appendPrimitiveEntriesStroke(geometry, entries, state);
+        enqueueGeometry(geometry, getDrawOptions(state));
+    }
+}
+function shouldDrawPrimitiveSolid(mode) {
+    return mode === 'solid' || mode === 'both';
+}
+function shouldDrawPrimitiveWireframe(mode) {
+    return mode === 'wireframe' || mode === 'both';
+}
+export function createPrimitiveDrawState() {
+    const transform = new Mat4();
+    Mat4.identity(transform);
+    return {
+        lineWidth: 1,
+        lineJoin: Canvas3DLineJoin.miter,
+        lineCap: Canvas3DLineCap.butt,
+        miterLimit: 10,
+        lineDash: [],
+        lineDashOffset: 0,
+        fillColor: Color.WHITE.clone(),
+        strokeColor: Color.WHITE.clone(),
+        transform,
+        depthTest: true,
+        depthWrite: true,
+    };
+}
+export function clonePrimitiveDrawState(state) {
+    return copyPrimitiveDrawState(createPrimitiveDrawState(), state);
+}
+export function copyPrimitiveDrawState(out, state) {
+    out.lineWidth = state.lineWidth;
+    out.lineJoin = state.lineJoin;
+    out.lineCap = state.lineCap;
+    out.miterLimit = state.miterLimit;
+    out.lineDash = state.lineDash.length === 0 ? state.lineDash : state.lineDash.slice();
+    out.lineDashOffset = state.lineDashOffset;
+    out.fillColor.set(state.fillColor);
+    out.strokeColor.set(state.strokeColor);
+    out.transform.set(state.transform);
+    out.depthTest = state.depthTest;
+    out.depthWrite = state.depthWrite;
+    return out;
+}
+function createPrimitiveDrawStateWithOptions(state, options) {
+    const result = clonePrimitiveDrawState(state);
+    if (!options) {
+        return result;
+    }
+    if (options.color) {
+        setColor(result.fillColor, options.color);
+        setColor(result.strokeColor, options.color);
+    }
+    if (options.fillColor) {
+        setColor(result.fillColor, options.fillColor);
+    }
+    if (options.strokeColor) {
+        setColor(result.strokeColor, options.strokeColor);
+    }
+    if (options.lineWidth !== undefined) {
+        result.lineWidth = Math.max(0, options.lineWidth);
+    }
+    if (options.lineJoin !== undefined) {
+        result.lineJoin = options.lineJoin;
+    }
+    if (options.lineCap !== undefined) {
+        result.lineCap = options.lineCap;
+    }
+    if (options.lineDash !== undefined) {
+        result.lineDash = normalizeLineDash(options.lineDash);
+    }
+    if (options.lineDashOffset !== undefined) {
+        result.lineDashOffset = Number.isFinite(options.lineDashOffset) ? options.lineDashOffset : 0;
+    }
+    if (options.transform) {
+        Mat4.multiply(result.transform, result.transform, options.transform);
+    }
+    if (options.depthTest !== undefined) {
+        result.depthTest = options.depthTest;
+    }
+    if (options.depthWrite !== undefined) {
+        result.depthWrite = options.depthWrite;
+    }
+    return result;
+}
+export function resolveCapsule(options) {
+    const radius = Math.max(0, options.radius);
+    const height = Math.max(0, options.height);
+    const up = options.up?.clone() ?? Vec3.UP.clone();
+    if (up.lengthSqr() <= epsilon) {
+        up.set(Vec3.UP);
+    }
+    else {
+        up.normalize();
+    }
+    const halfSegmentLength = Math.max(0, height * 0.5 - radius);
+    const offset = up.multiplyScalar(halfSegmentLength);
+    return {
+        from: Vec3.subtract(new Vec3(), options.center, offset),
+        to: Vec3.add(new Vec3(), options.center, offset),
+        radius,
+    };
+}
+export function resolveCylinder(options) {
+    const radius = Math.max(0, options.radius);
+    const height = Math.max(0, options.height);
+    const up = resolveDirection(options.up ?? Vec3.UP);
+    const offset = up.multiplyScalar(height * 0.5);
+    return {
+        from: Vec3.subtract(new Vec3(), options.center, offset),
+        to: Vec3.add(new Vec3(), options.center, offset),
+        radius,
+    };
+}
+export function createQuadCorners(options) {
+    const halfExtents = resolveQuadHalfExtents(options.halfExtents);
+    const basis = createNormalBasis(options.normal);
+    const axisA = basis.axisA.multiplyScalar(halfExtents.x);
+    const axisB = basis.axisB.multiplyScalar(halfExtents.y);
+    return [
+        Vec3.subtract(new Vec3(), Vec3.subtract(new Vec3(), options.center, axisA), axisB),
+        Vec3.subtract(new Vec3(), Vec3.add(new Vec3(), options.center, axisA), axisB),
+        Vec3.add(new Vec3(), Vec3.add(new Vec3(), options.center, axisA), axisB),
+        Vec3.add(new Vec3(), Vec3.subtract(new Vec3(), options.center, axisA), axisB),
+    ];
+}
+export function resolveDiscRadius(options) {
+    return Math.max(0, options.radius);
+}
+export function resolveCircleSegments(value) {
+    return clampInteger(value, defaultCircleSegments, minCircleSegments);
+}
+export function resolveCylinderSegments(options) {
+    const manualSegments = normalizeInteger(options.radialSegments, minCircleSegments);
+    return {
+        radialSegments: manualSegments ?? defaultCylinderRadialSegments,
+        wireSegments: manualSegments ?? defaultCircleSegments,
+    };
+}
+export function resolveDiscSegments(options) {
+    return resolveCircleSegments(options.segments);
+}
+export function resolveRingSegments(options) {
+    return resolveCircleSegments(options.segments);
+}
+export function resolveSphereSegments(options) {
+    const manualLongitudeSegments = normalizeInteger(options.longitudeSegments ?? options.segments, minCircleSegments);
+    const longitudeSegments = manualLongitudeSegments ?? defaultSphereLongitudeSegments;
+    return {
+        latitudeSegments: clampInteger(options.latitudeSegments ?? (options.segments === undefined ? defaultSphereLatitudeSegments : Math.ceil(longitudeSegments * 0.5)), defaultSphereLatitudeSegments, minSphereLatitudeSegments),
+        longitudeSegments,
+        wireSegments: manualLongitudeSegments ?? defaultCircleSegments,
+    };
+}
+export function resolveCapsuleSegments(options) {
+    const manualSegments = normalizeInteger(options.radialSegments, minCircleSegments);
+    return {
+        radialSegments: manualSegments ?? defaultCylinderRadialSegments,
+        wireSegments: manualSegments ?? defaultCircleSegments,
+        capSegments: clampInteger(options.capSegments, defaultCapsuleCapSegments, minCapsuleCapSegments),
+    };
+}
+export function resolveRingRadii(options) {
+    return {
+        innerRadius: Math.max(0, options.innerRadius),
+        outerRadius: Math.max(0, options.outerRadius),
+    };
+}
+export function resolveQuadHalfExtents(halfExtents) {
+    if (typeof halfExtents === 'number') {
+        const value = Math.max(0, halfExtents);
+        return new Vec2(value, value);
+    }
+    return new Vec2(Math.max(0, halfExtents.x), Math.max(0, halfExtents.y));
+}
+function clampInteger(value, fallback, min) {
+    return normalizeInteger(value, min) ?? fallback;
+}
+function normalizeInteger(value, min) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return Math.max(min, Math.floor(value));
+}
+export function normalizeLineDash(value) {
+    const lineDash = value.filter((entry) => {
+        return Number.isFinite(entry) && entry > epsilon;
+    });
+    if (lineDash.length === 0 || sum(lineDash) <= epsilon) {
+        return [];
+    }
+    if (lineDash.length % 2 === 1) {
+        lineDash.push(...lineDash);
+    }
+    return lineDash;
+}
+export function appendSubPathStroke(geometry, subPath, style, color) {
+    const points = normalizedSubPathPoints(subPath);
+    if (appendPlanarPolylineStroke(geometry, points, subPath.closed, style, color)) {
+        return;
+    }
+    const segmentCount = countSubPathStrokeSegments(points, subPath.closed);
+    const writer = createStrokeSegmentWriter(geometry, segmentCount);
+    if (!writer) {
+        return;
+    }
+    for (let iPoint = 1; iPoint < points.length; iPoint++) {
+        const from = points[iPoint - 1];
+        const to = points[iPoint];
+        if (hasStrokeSegmentLength(from, to)) {
+            appendStrokeSegment(writer, from, to, style.lineWidth, color);
+        }
+    }
+    if (subPath.closed && points.length > 2) {
+        const from = points[points.length - 1];
+        const to = points[0];
+        if (hasStrokeSegmentLength(from, to)) {
+            appendStrokeSegment(writer, from, to, style.lineWidth, color);
+        }
+    }
+}
+export function appendSubPathFill(geometry, subPath, color) {
+    const points = normalizedSubPathPoints(subPath);
+    if (points.length < 3) {
+        return;
+    }
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    for (const point of points) {
+        appendVertex(geometry, point, color);
+    }
+    for (let iPoint = 1; iPoint < points.length - 1; iPoint++) {
+        geometry.indices.push(baseVertex, baseVertex + iPoint, baseVertex + iPoint + 1);
+    }
+}
+export function appendBoxStroke(geometry, center, halfExtents, style, color) {
+    const corners = createBoxCorners(center, halfExtents);
+    if (Math.abs(halfExtents.z) <= epsilon && appendPlanarPolylineStroke(geometry, corners.slice(0, 4), true, style, color)) {
+        return;
+    }
+    const segmentCount = countBoxStrokeSegments(corners);
+    const writer = createStrokeSegmentWriter(geometry, segmentCount);
+    if (!writer) {
+        return;
+    }
+    for (const [fromIndex, toIndex] of boxEdges) {
+        const from = corners[fromIndex];
+        const to = corners[toIndex];
+        if (hasStrokeSegmentLength(from, to)) {
+            appendStrokeSegment(writer, from, to, style.lineWidth, color);
+        }
+    }
+}
+export function appendBoxFill(geometry, center, halfExtents, color) {
+    const corners = createBoxCorners(center, halfExtents);
+    appendBoxCornersFill(geometry, corners, color);
+}
+function appendBoxCornersStroke(geometry, corners, style, color) {
+    const segmentCount = countBoxStrokeSegments(corners);
+    const writer = createStrokeSegmentWriter(geometry, segmentCount);
+    if (!writer) {
+        return;
+    }
+    for (const [fromIndex, toIndex] of boxEdges) {
+        const from = corners[fromIndex];
+        const to = corners[toIndex];
+        if (hasStrokeSegmentLength(from, to)) {
+            appendStrokeSegment(writer, from, to, style.lineWidth, color);
+        }
+    }
+}
+function appendBoxCornersFill(geometry, corners, color) {
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    for (const corner of corners) {
+        appendVertex(geometry, corner, color);
+    }
+    for (const index of boxTriangleIndices) {
+        geometry.indices.push(baseVertex + index);
+    }
+}
+function appendPrimitiveEntriesStroke(geometry, entries, state) {
+    for (const entry of entries) {
+        switch (entry.type) {
+            case PrimitiveEntryType.line:
+                appendLine3DStroke(geometry, transformPoint(entry.from, state.transform), transformPoint(entry.to, state.transform), state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.box:
+                appendBoxCornersStroke(geometry, transformPoints(createBoxCorners(entry.center, entry.halfExtents), state.transform), state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.quad:
+                appendQuadCornersStroke(geometry, transformPoints(entry.corners, state.transform), state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.cylinder:
+                appendCylinderWireStroke(geometry, entry.from, entry.to, entry.radius, entry.wireSegments, state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.disc:
+                appendDiscWireStroke(geometry, entry.center, entry.normal, entry.radius, entry.segments, state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.ring:
+                appendRingWireStroke(geometry, entry.center, entry.normal, entry.innerRadius, entry.outerRadius, entry.segments, state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.sphere:
+                appendSphereWireStroke(geometry, entry.center, entry.radius, entry.wireSegments, state, state.strokeColor);
+                break;
+            case PrimitiveEntryType.capsule:
+                appendCapsuleWireStroke(geometry, entry.from, entry.to, entry.radius, entry.wireSegments, entry.capSegments, state, state.strokeColor);
+                break;
+        }
+    }
+}
+function appendPrimitiveEntriesFill(geometry, entries, state) {
+    for (const entry of entries) {
+        switch (entry.type) {
+            case PrimitiveEntryType.line:
+                break;
+            case PrimitiveEntryType.box:
+                appendBoxCornersFill(geometry, transformPoints(createBoxCorners(entry.center, entry.halfExtents), state.transform), state.fillColor);
+                break;
+            case PrimitiveEntryType.quad:
+                appendQuadCornersFill(geometry, transformPoints(entry.corners, state.transform), state.fillColor);
+                break;
+            case PrimitiveEntryType.cylinder:
+                appendCylinderFill(geometry, entry.from, entry.to, entry.radius, entry.radialSegments, state.transform, state.fillColor);
+                break;
+            case PrimitiveEntryType.disc:
+                appendDiscFill(geometry, entry.center, entry.normal, entry.radius, entry.segments, state.transform, state.fillColor);
+                break;
+            case PrimitiveEntryType.ring:
+                appendRingFill(geometry, entry.center, entry.normal, entry.innerRadius, entry.outerRadius, entry.segments, state.transform, state.fillColor);
+                break;
+            case PrimitiveEntryType.sphere:
+                appendSphereFill(geometry, entry.center, entry.radius, entry.latitudeSegments, entry.longitudeSegments, state.transform, state.fillColor);
+                break;
+            case PrimitiveEntryType.capsule:
+                appendCapsuleFill(geometry, entry.from, entry.to, entry.radius, entry.radialSegments, entry.capSegments, state.transform, state.fillColor);
+                break;
+        }
+    }
+}
+function appendLine3DStroke(geometry, from, to, style, color) {
+    if (!hasStrokeSegmentLength(from, to)) {
+        return;
+    }
+    if (style.lineDash.length > 0) {
+        appendDashedLine3DStroke(geometry, from, to, style, color);
+        return;
+    }
+    appendSolidLine3DStroke(geometry, from, to, style, color);
+}
+function appendDashedLine3DStroke(geometry, from, to, style, color) {
+    const segmentLength = Vec3.distance(from, to);
+    if (segmentLength <= epsilon) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendDashedLine3DStroke);
+    let pVec3Cache = 0;
+    const direction = Vec3.subtract(vec3Cache[pVec3Cache++], to, from).normalize();
+    const dashState = createDashState(style.lineDash, style.lineDashOffset);
+    const startPoint = vec3Cache[pVec3Cache++];
+    const endPoint = vec3Cache[pVec3Cache++];
+    let traveled = 0;
+    while (segmentLength - traveled > epsilon) {
+        const step = Math.min(segmentLength - traveled, dashState.remaining);
+        if (dashState.drawing) {
+            Vec3.scaleAndAdd(startPoint, from, direction, traveled);
+            Vec3.scaleAndAdd(endPoint, from, direction, traveled + step);
+            appendSolidLine3DStroke(geometry, startPoint, endPoint, style, color);
+        }
+        traveled += step;
+        dashState.remaining -= step;
+        if (dashState.remaining <= epsilon) {
+            advanceDashState(dashState);
+        }
+    }
+    releaseVec3ScratchCache(vec3Caches_appendDashedLine3DStroke);
+}
+function appendSolidLine3DStroke(geometry, from, to, style, color) {
+    if (!hasStrokeSegmentLength(from, to)) {
+        return;
+    }
+    const writer = createStrokeSegmentWriter(geometry, 1);
+    if (!writer) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendSolidLine3DStroke);
+    let pVec3Cache = 0;
+    const start = vec3Cache[pVec3Cache++].set(from);
+    const end = vec3Cache[pVec3Cache++].set(to);
+    const direction = Vec3.subtract(vec3Cache[pVec3Cache++], end, start).normalize();
+    const halfWidth = style.lineWidth * 0.5;
+    if (style.lineCap === Canvas3DLineCap.square) {
+        Vec3.scaleAndAdd(start, start, direction, -halfWidth);
+        Vec3.scaleAndAdd(end, end, direction, halfWidth);
+    }
+    appendStrokeSegment(writer, start, end, style.lineWidth, color);
+    releaseVec3ScratchCache(vec3Caches_appendSolidLine3DStroke);
+    if (style.lineCap === Canvas3DLineCap.round) {
+        const transform = new Mat4();
+        Mat4.identity(transform);
+        appendSphereFill(geometry, from, halfWidth, lineCapLatitudeSegments, lineCapLongitudeSegments, transform, color);
+        appendSphereFill(geometry, to, halfWidth, lineCapLatitudeSegments, lineCapLongitudeSegments, transform, color);
+    }
+}
+function appendQuadCornersStroke(geometry, corners, style, color) {
+    if (corners.length < 4) {
+        return;
+    }
+    appendSubPathStroke(geometry, {
+        points: corners.slice(0, 4),
+        closed: true,
+    }, style, color);
+}
+function appendQuadCornersFill(geometry, corners, color) {
+    if (corners.length < 4) {
+        return;
+    }
+    appendQuad(geometry, corners[0], corners[1], corners[2], corners[3], color);
+}
+function appendDiscWireStroke(geometry, center, normal, radius, segments, state, color) {
+    if (radius <= 0) {
+        return;
+    }
+    const basis = createNormalBasis(normal);
+    appendPlaneCircleStroke(geometry, center, radius, basis.axisA, basis.axisB, segments, state, color);
+}
+function appendDiscFill(geometry, center, normal, radius, segments, transform, color) {
+    if (radius <= 0) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendDiscFill);
+    let pVec3Cache = 0;
+    const point = vec3Cache[pVec3Cache++];
+    const transformedPoint = vec3Cache[pVec3Cache++];
+    const basis = createNormalBasis(normal);
+    const centerVertex = appendVertex(geometry, transformPointInto(transformedPoint, center, transform), color);
+    const firstRingVertex = geometry.vertices.length / vertexStrideF;
+    for (let iPoint = 0; iPoint < segments; iPoint++) {
+        setPlaneCirclePoint(point, center, radius, basis.axisA, basis.axisB, iPoint, segments);
+        appendVertex(geometry, transformPointInto(transformedPoint, point, transform), color);
+    }
+    releaseVec3ScratchCache(vec3Caches_appendDiscFill);
+    for (let iPoint = 0; iPoint < segments; iPoint++) {
+        geometry.indices.push(centerVertex, firstRingVertex + iPoint, firstRingVertex + ((iPoint + 1) % segments));
+    }
+}
+function appendRingWireStroke(geometry, center, normal, innerRadius, outerRadius, segments, state, color) {
+    if (outerRadius <= 0) {
+        return;
+    }
+    const basis = createNormalBasis(normal);
+    appendPlaneCircleStroke(geometry, center, outerRadius, basis.axisA, basis.axisB, segments, state, color);
+    if (innerRadius > epsilon && innerRadius < outerRadius) {
+        appendPlaneCircleStroke(geometry, center, innerRadius, basis.axisA, basis.axisB, segments, state, color);
+    }
+}
+function appendRingFill(geometry, center, normal, innerRadius, outerRadius, segments, transform, color) {
+    if (outerRadius <= 0) {
+        return;
+    }
+    if (innerRadius <= epsilon) {
+        appendDiscFill(geometry, center, normal, outerRadius, segments, transform, color);
+        return;
+    }
+    if (innerRadius >= outerRadius) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendRingFill);
+    const basis = createNormalBasis(normal);
+    let pVec3Cache = 0;
+    const outerPoint = vec3Cache[pVec3Cache++];
+    const innerPoint = vec3Cache[pVec3Cache++];
+    const innerNextPoint = vec3Cache[pVec3Cache++];
+    const outerNextPoint = vec3Cache[pVec3Cache++];
+    const transformedOuterPoint = vec3Cache[pVec3Cache++];
+    const transformedInnerPoint = vec3Cache[pVec3Cache++];
+    const transformedInnerNextPoint = vec3Cache[pVec3Cache++];
+    const transformedOuterNextPoint = vec3Cache[pVec3Cache++];
+    for (let iPoint = 0; iPoint < segments; iPoint++) {
+        const nextPoint = (iPoint + 1) % segments;
+        setPlaneCirclePoint(outerPoint, center, outerRadius, basis.axisA, basis.axisB, iPoint, segments);
+        setPlaneCirclePoint(innerPoint, center, innerRadius, basis.axisA, basis.axisB, iPoint, segments);
+        setPlaneCirclePoint(innerNextPoint, center, innerRadius, basis.axisA, basis.axisB, nextPoint, segments);
+        setPlaneCirclePoint(outerNextPoint, center, outerRadius, basis.axisA, basis.axisB, nextPoint, segments);
+        appendQuad(geometry, transformPointInto(transformedOuterPoint, outerPoint, transform), transformPointInto(transformedInnerPoint, innerPoint, transform), transformPointInto(transformedInnerNextPoint, innerNextPoint, transform), transformPointInto(transformedOuterNextPoint, outerNextPoint, transform), color);
+    }
+    releaseVec3ScratchCache(vec3Caches_appendRingFill);
+}
+function appendSphereWireStroke(geometry, center, radius, segments, state, color) {
+    if (radius <= 0) {
+        return;
+    }
+    appendPlaneCircleStroke(geometry, center, radius, new Vec3(1, 0, 0), new Vec3(0, 1, 0), segments, state, color);
+    appendPlaneCircleStroke(geometry, center, radius, new Vec3(1, 0, 0), new Vec3(0, 0, 1), segments, state, color);
+    appendPlaneCircleStroke(geometry, center, radius, new Vec3(0, 1, 0), new Vec3(0, 0, 1), segments, state, color);
+}
+function appendSphereFill(geometry, center, radius, latitudeSegments, longitudeSegments, transform, color) {
+    if (radius <= 0) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendSphereFill);
+    let pVec3Cache = 0;
+    const point = vec3Cache[pVec3Cache++];
+    const transformedPoint = vec3Cache[pVec3Cache++];
+    const topology = getSphereTopology(latitudeSegments, longitudeSegments);
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    for (let pPosition = 0; pPosition < topology.positions.length; pPosition += 3) {
+        point.set(center.x + topology.positions[pPosition] * radius, center.y + topology.positions[pPosition + 1] * radius, center.z + topology.positions[pPosition + 2] * radius);
+        appendVertex(geometry, transformPointInto(transformedPoint, point, transform), color);
+    }
+    releaseVec3ScratchCache(vec3Caches_appendSphereFill);
+    appendTopologyIndices(geometry, baseVertex, topology.indices);
+}
+function appendCapsuleWireStroke(geometry, from, to, radius, radialSegments, capSegments, state, color) {
+    if (radius <= 0) {
+        return;
+    }
+    if (!hasStrokeSegmentLength(from, to)) {
+        appendSphereWireStroke(geometry, from, radius, radialSegments, state, color);
+        return;
+    }
+    const direction = Vec3.subtract(new Vec3(), to, from).normalize();
+    appendCylinderWireStroke(geometry, from, to, radius, radialSegments, state, color);
+    appendHemisphereWireStroke(geometry, from, direction.clone().multiplyScalar(-1), radius, radialSegments, capSegments, state, color);
+    appendHemisphereWireStroke(geometry, to, direction, radius, radialSegments, capSegments, state, color);
+}
+function appendCapsuleFill(geometry, from, to, radius, radialSegments, capSegments, transform, color) {
+    if (radius <= 0) {
+        return;
+    }
+    if (!hasStrokeSegmentLength(from, to)) {
+        appendSphereFill(geometry, from, radius, capSegments * 2, radialSegments, transform, color);
+        return;
+    }
+    const direction = Vec3.subtract(new Vec3(), to, from).normalize();
+    appendCylinderFill(geometry, from, to, radius, radialSegments, transform, color, false);
+    appendHemisphereFill(geometry, from, direction.clone().multiplyScalar(-1), radius, radialSegments, capSegments, transform, color);
+    appendHemisphereFill(geometry, to, direction, radius, radialSegments, capSegments, transform, color);
+}
+function appendHemisphereWireStroke(geometry, center, axis, radius, radialSegments, capSegments, state, color) {
+    const basis = createDirectionBasis(axis);
+    if (!basis) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendHemisphereWireStroke);
+    let pVec3Cache = 0;
+    const radialDirection = vec3Cache[pVec3Cache++];
+    const point = vec3Cache[pVec3Cache++];
+    const transformedPoint = vec3Cache[pVec3Cache++];
+    const ringCenter = vec3Cache[pVec3Cache++];
+    for (let iMeridian = 0; iMeridian < 4; iMeridian++) {
+        const phi = iMeridian / 4 * Math.PI * 2;
+        setBasisDirection(radialDirection, basis.normalA, basis.normalB, phi);
+        const points = [];
+        for (let iCap = 0; iCap <= capSegments; iCap++) {
+            const theta = iCap / capSegments * Math.PI * 0.5;
+            setHemispherePoint(point, center, radius, axis, radialDirection, theta);
+            points.push(transformPointInto(transformedPoint, point, state.transform).clone());
+        }
+        appendSubPathStroke(geometry, {
+            points,
+            closed: false,
+        }, state, color);
+    }
+    if (capSegments > 1) {
+        for (let iCap = 1; iCap < capSegments; iCap++) {
+            const theta = iCap / capSegments * Math.PI * 0.5;
+            Vec3.scaleAndAdd(ringCenter, center, axis, Math.cos(theta) * radius);
+            appendPlaneCircleStroke(geometry, ringCenter, Math.sin(theta) * radius, basis.normalA, basis.normalB, radialSegments, state, color);
+        }
+    }
+    releaseVec3ScratchCache(vec3Caches_appendHemisphereWireStroke);
+}
+function appendHemisphereFill(geometry, center, axis, radius, radialSegments, capSegments, transform, color) {
+    const basis = createDirectionBasis(axis);
+    if (!basis) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendHemisphereFill);
+    let pVec3Cache = 0;
+    const point = vec3Cache[pVec3Cache++];
+    const transformedPoint = vec3Cache[pVec3Cache++];
+    const topology = getHemisphereTopology(radialSegments, capSegments);
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    for (let pPosition = 0; pPosition < topology.positions.length; pPosition += 3) {
+        const radialX = topology.positions[pPosition];
+        const radialY = topology.positions[pPosition + 1];
+        const axisScale = topology.positions[pPosition + 2];
+        point.set(center.x + (basis.normalA.x * radialX + basis.normalB.x * radialY + axis.x * axisScale) * radius, center.y + (basis.normalA.y * radialX + basis.normalB.y * radialY + axis.y * axisScale) * radius, center.z + (basis.normalA.z * radialX + basis.normalB.z * radialY + axis.z * axisScale) * radius);
+        appendVertex(geometry, transformPointInto(transformedPoint, point, transform), color);
+    }
+    releaseVec3ScratchCache(vec3Caches_appendHemisphereFill);
+    appendTopologyIndices(geometry, baseVertex, topology.indices);
+}
+function appendCylinderWireStroke(geometry, from, to, radius, radialSegments, state, color) {
+    const basis = createAxisBasis(from, to);
+    if (!basis) {
+        return;
+    }
+    appendPlaneCircleStroke(geometry, from, radius, basis.normalA, basis.normalB, radialSegments, state, color);
+    appendPlaneCircleStroke(geometry, to, radius, basis.normalA, basis.normalB, radialSegments, state, color);
+    for (let iSide = 0; iSide < 4; iSide++) {
+        const iPoint = Math.floor(iSide * radialSegments / 4);
+        appendLine3DStroke(geometry, transformPoint(createPlaneCirclePoint(from, radius, basis.normalA, basis.normalB, iPoint, radialSegments), state.transform), transformPoint(createPlaneCirclePoint(to, radius, basis.normalA, basis.normalB, iPoint, radialSegments), state.transform), state, color);
+    }
+}
+function appendCylinderFill(geometry, from, to, radius, radialSegments, transform, color, includeCaps = true) {
+    const basis = createAxisBasis(from, to);
+    if (!basis) {
+        return;
+    }
+    const vec3Cache = borrowVec3ScratchCache(vec3Caches_appendCylinderFill);
+    let pVec3Cache = 0;
+    const point = vec3Cache[pVec3Cache++];
+    const transformedPoint = vec3Cache[pVec3Cache++];
+    const topology = getCircleTopology(radialSegments);
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    for (let iPoint = 0; iPoint < radialSegments; iPoint++) {
+        setPlaneCirclePoint(point, from, radius, basis.normalA, basis.normalB, iPoint, radialSegments);
+        appendVertex(geometry, transformPointInto(transformedPoint, point, transform), color);
+    }
+    for (let iPoint = 0; iPoint < radialSegments; iPoint++) {
+        point.set(to.x + (basis.normalA.x * topology.cos[iPoint] + basis.normalB.x * topology.sin[iPoint]) * radius, to.y + (basis.normalA.y * topology.cos[iPoint] + basis.normalB.y * topology.sin[iPoint]) * radius, to.z + (basis.normalA.z * topology.cos[iPoint] + basis.normalB.z * topology.sin[iPoint]) * radius);
+        appendVertex(geometry, transformPointInto(transformedPoint, point, transform), color);
+    }
+    if (includeCaps) {
+        appendVertex(geometry, transformPointInto(transformedPoint, from, transform), color);
+        appendVertex(geometry, transformPointInto(transformedPoint, to, transform), color);
+    }
+    releaseVec3ScratchCache(vec3Caches_appendCylinderFill);
+    appendTopologyIndices(geometry, baseVertex, getCylinderIndexTopology(radialSegments, includeCaps).indices);
+}
+function appendPlaneCircleStroke(geometry, center, radius, axisA, axisB, segments, state, color) {
+    const points = [];
+    for (let iPoint = 0; iPoint < segments; iPoint++) {
+        points.push(transformPoint(createPlaneCirclePoint(center, radius, axisA, axisB, iPoint, segments), state.transform));
+    }
+    appendSubPathStroke(geometry, {
+        points,
+        closed: true,
+    }, state, color);
+}
+export function appendCircleStroke(geometry, center, radius, style, color) {
+    if (radius <= 0) {
+        return;
+    }
+    if (style.lineDash.length > 0) {
+        appendPlanarPolylineStroke(geometry, createCirclePoints(center, radius), true, style, color);
+        return;
+    }
+    const innerRadius = Math.max(0, radius - style.lineWidth * 0.5);
+    const outerRadius = radius + style.lineWidth * 0.5;
+    appendCircleRingStroke(geometry, center, innerRadius, outerRadius, color);
+}
+function appendCircleRingStroke(geometry, center, innerRadius, outerRadius, color) {
+    if (outerRadius <= 0) {
+        return;
+    }
+    if (innerRadius <= epsilon) {
+        appendCircleFill(geometry, center, outerRadius, color);
+        return;
+    }
+    const outerPoint = new Vec3();
+    const innerPoint = new Vec3();
+    for (let iPoint = 0; iPoint < defaultCircleSegments; iPoint++) {
+        setCirclePoint(outerPoint, center, outerRadius, iPoint);
+        setCirclePoint(innerPoint, center, innerRadius, iPoint);
+        const nextPoint = (iPoint + 1) % defaultCircleSegments;
+        const outerNext = createCirclePoint(center, outerRadius, nextPoint);
+        const innerNext = createCirclePoint(center, innerRadius, nextPoint);
+        appendQuad(geometry, outerPoint, innerPoint, innerNext, outerNext, color);
+    }
+}
+export function appendCircleFill(geometry, center, radius, color) {
+    if (radius <= 0) {
+        return;
+    }
+    const centerVertex = appendVertex(geometry, center, color);
+    const firstRingVertex = geometry.vertices.length / vertexStrideF;
+    for (let iPoint = 0; iPoint < defaultCircleSegments; iPoint++) {
+        appendVertex(geometry, createCirclePoint(center, radius, iPoint), color);
+    }
+    for (let iPoint = 0; iPoint < defaultCircleSegments; iPoint++) {
+        geometry.indices.push(centerVertex, firstRingVertex + iPoint, firstRingVertex + ((iPoint + 1) % defaultCircleSegments));
+    }
+}
+function createStrokeSegmentWriter(geometry, segmentCount) {
+    if (segmentCount <= 0) {
+        return undefined;
+    }
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    const vertexOffsetF = geometry.vertices.length;
+    const indexOffset = geometry.indices.length;
+    geometry.vertices.length += segmentCount * strokeSegmentVertexCount * vertexStrideF;
+    geometry.indices.length += segmentCount * strokeBoxTriangleIndices.length;
+    return {
+        geometry,
+        direction: new Vec3(),
+        normalA: new Vec3(),
+        normalB: new Vec3(),
+        vertexOffsetF,
+        indexOffset,
+        baseVertex,
+    };
+}
+function appendStrokeSegment(writer, from, to, strokeWidth, color) {
+    const direction = Vec3.subtract(writer.direction, to, from);
+    if (direction.lengthSqr() <= epsilon) {
+        return;
+    }
+    direction.normalize();
+    const halfWidth = strokeWidth * 0.5;
+    const referenceAxis = Math.abs(Vec3.dot(direction, Vec3.UP)) > 0.95 ? Vec3.RIGHT : Vec3.UP;
+    const normalA = Vec3.cross(writer.normalA, direction, referenceAxis).normalize();
+    const normalB = Vec3.cross(writer.normalB, direction, normalA).normalize();
+    normalA.multiplyScalar(halfWidth);
+    normalB.multiplyScalar(halfWidth);
+    const ax = normalA.x;
+    const ay = normalA.y;
+    const az = normalA.z;
+    const bx = normalB.x;
+    const by = normalB.y;
+    const bz = normalB.z;
+    writeStrokeVertex(writer, from, ax + bx, ay + by, az + bz, color);
+    writeStrokeVertex(writer, from, ax - bx, ay - by, az - bz, color);
+    writeStrokeVertex(writer, from, -ax - bx, -ay - by, -az - bz, color);
+    writeStrokeVertex(writer, from, bx - ax, by - ay, bz - az, color);
+    writeStrokeVertex(writer, to, ax + bx, ay + by, az + bz, color);
+    writeStrokeVertex(writer, to, ax - bx, ay - by, az - bz, color);
+    writeStrokeVertex(writer, to, -ax - bx, -ay - by, -az - bz, color);
+    writeStrokeVertex(writer, to, bx - ax, by - ay, bz - az, color);
+    for (const index of strokeBoxTriangleIndices) {
+        writer.geometry.indices[writer.indexOffset++] = writer.baseVertex + index;
+    }
+    writer.baseVertex += strokeSegmentVertexCount;
+}
+function writeStrokeVertex(writer, center, offsetX, offsetY, offsetZ, color) {
+    const vertices = writer.geometry.vertices;
+    let offset = writer.vertexOffsetF;
+    vertices[offset++] = center.x + offsetX;
+    vertices[offset++] = center.y + offsetY;
+    vertices[offset++] = center.z + offsetZ;
+    vertices[offset++] = color.x;
+    vertices[offset++] = color.y;
+    vertices[offset++] = color.z;
+    vertices[offset++] = color.w;
+    writer.vertexOffsetF = offset;
+}
+function countSubPathStrokeSegments(points, closed) {
+    let segmentCount = 0;
+    for (let iPoint = 1; iPoint < points.length; iPoint++) {
+        if (hasStrokeSegmentLength(points[iPoint - 1], points[iPoint])) {
+            segmentCount++;
+        }
+    }
+    if (closed && points.length > 2 && hasStrokeSegmentLength(points[points.length - 1], points[0])) {
+        segmentCount++;
+    }
+    return segmentCount;
+}
+function countBoxStrokeSegments(corners) {
+    let segmentCount = 0;
+    for (const [fromIndex, toIndex] of boxEdges) {
+        if (hasStrokeSegmentLength(corners[fromIndex], corners[toIndex])) {
+            segmentCount++;
+        }
+    }
+    return segmentCount;
+}
+function hasStrokeSegmentLength(from, to) {
+    const dx = to.x - from.x;
+    const dy = to.y - from.y;
+    const dz = to.z - from.z;
+    return dx * dx + dy * dy + dz * dz > epsilon;
+}
+function appendPlanarPolylineStroke(geometry, points, closed, style, color) {
+    const strokePoints = normalizedStrokePoints(points, closed);
+    if (!isPlanarXY(strokePoints)) {
+        return false;
+    }
+    if (strokePoints.length < (closed ? 3 : 2)) {
+        return true;
+    }
+    if (style.lineDash.length > 0) {
+        appendDashedPlanarPolylineStroke(geometry, strokePoints, closed, style, color);
+        return true;
+    }
+    appendSolidPlanarPolylineStroke(geometry, strokePoints, closed, style, color);
+    return true;
+}
+function appendSolidPlanarPolylineStroke(geometry, strokePoints, closed, style, color) {
+    const segments = createPlanarStrokeSegments(strokePoints, closed);
+    if (!segments) {
+        return;
+    }
+    const halfWidth = style.lineWidth * 0.5;
+    for (let iSegment = 0; iSegment < segments.length; iSegment++) {
+        const segment = segments[iSegment];
+        const isFirst = iSegment === 0;
+        const isLast = iSegment === segments.length - 1;
+        const startExtension = !closed && isFirst && style.lineCap === Canvas3DLineCap.square ? halfWidth : 0;
+        const endExtension = !closed && isLast && style.lineCap === Canvas3DLineCap.square ? halfWidth : 0;
+        appendPlanarSegmentBody(geometry, strokePoints[segment.fromIndex], strokePoints[segment.toIndex], segment.direction, segment.normal, halfWidth, startExtension, endExtension, color);
+    }
+    if (closed) {
+        for (let iPoint = 0; iPoint < strokePoints.length; iPoint++) {
+            appendPlanarStrokeJoin(geometry, strokePoints[iPoint], segments[(iPoint - 1 + segments.length) % segments.length], segments[iPoint], style, color);
+        }
+        return;
+    }
+    for (let iPoint = 1; iPoint < strokePoints.length - 1; iPoint++) {
+        appendPlanarStrokeJoin(geometry, strokePoints[iPoint], segments[iPoint - 1], segments[iPoint], style, color);
+    }
+    appendPlanarCaps(geometry, strokePoints, segments, style, color);
+}
+function appendDashedPlanarPolylineStroke(geometry, strokePoints, closed, style, color) {
+    const segments = createPlanarStrokeSegments(strokePoints, closed);
+    if (!segments) {
+        return;
+    }
+    const dashState = createDashState(style.lineDash, style.lineDashOffset);
+    const fragment = [];
+    const flushFragment = () => {
+        if (fragment.length >= 2) {
+            appendSolidPlanarPolylineStroke(geometry, fragment, false, style, color);
+        }
+        fragment.length = 0;
+    };
+    const appendFragmentPoint = (point) => {
+        const previous = fragment[fragment.length - 1];
+        if (!previous || hasStrokeSegmentLength(previous, point)) {
+            fragment.push(point.clone());
+        }
+    };
+    const startPoint = new Vec3();
+    const endPoint = new Vec3();
+    for (const segment of segments) {
+        const from = strokePoints[segment.fromIndex];
+        const to = strokePoints[segment.toIndex];
+        const segmentLength = Vec3.distance(from, to);
+        let traveled = 0;
+        while (segmentLength - traveled > epsilon) {
+            const step = Math.min(segmentLength - traveled, dashState.remaining);
+            setLerpPoint(startPoint, from, to, traveled / segmentLength);
+            setLerpPoint(endPoint, from, to, (traveled + step) / segmentLength);
+            if (dashState.drawing) {
+                appendFragmentPoint(startPoint);
+                appendFragmentPoint(endPoint);
+            }
+            traveled += step;
+            dashState.remaining -= step;
+            if (dashState.remaining <= epsilon) {
+                if (dashState.drawing) {
+                    flushFragment();
+                }
+                advanceDashState(dashState);
+            }
+        }
+    }
+    flushFragment();
+}
+function createPlanarStrokeSegments(strokePoints, closed) {
+    const segmentCount = closed ? strokePoints.length : strokePoints.length - 1;
+    const segments = [];
+    for (let iSegment = 0; iSegment < segmentCount; iSegment++) {
+        const from = strokePoints[iSegment];
+        const to = strokePoints[(iSegment + 1) % strokePoints.length];
+        const dx = to.x - from.x;
+        const dy = to.y - from.y;
+        const length = Math.hypot(dx, dy);
+        if (length <= epsilon) {
+            return undefined;
+        }
+        const dirX = dx / length;
+        const dirY = dy / length;
+        segments.push({
+            fromIndex: iSegment,
+            toIndex: (iSegment + 1) % strokePoints.length,
+            direction: new Vec3(dirX, dirY, 0),
+            normal: new Vec3(-dirY, dirX, 0),
+        });
+    }
+    return segments;
+}
+function appendPlanarSegmentBody(geometry, from, to, direction, normal, halfWidth, startExtension, endExtension, color) {
+    const start = new Vec3(from.x - direction.x * startExtension, from.y - direction.y * startExtension, from.z);
+    const end = new Vec3(to.x + direction.x * endExtension, to.y + direction.y * endExtension, to.z);
+    const leftStart = new Vec3(start.x + normal.x * halfWidth, start.y + normal.y * halfWidth, start.z);
+    const rightStart = new Vec3(start.x - normal.x * halfWidth, start.y - normal.y * halfWidth, start.z);
+    const rightEnd = new Vec3(end.x - normal.x * halfWidth, end.y - normal.y * halfWidth, end.z);
+    const leftEnd = new Vec3(end.x + normal.x * halfWidth, end.y + normal.y * halfWidth, end.z);
+    appendQuad(geometry, leftStart, rightStart, rightEnd, leftEnd, color);
+}
+function appendPlanarStrokeJoin(geometry, point, prevSegment, nextSegment, style, color) {
+    const turn = cross2D(prevSegment.direction.x, prevSegment.direction.y, nextSegment.direction.x, nextSegment.direction.y);
+    if (Math.abs(turn) <= epsilon) {
+        return;
+    }
+    const halfWidth = style.lineWidth * 0.5;
+    const outerSign = turn > 0 ? -1 : 1;
+    const offset = outerSign * halfWidth;
+    const prevOuter = createPlanarOffsetPoint(point, prevSegment.normal, offset);
+    const nextOuter = createPlanarOffsetPoint(point, nextSegment.normal, offset);
+    switch (style.lineJoin) {
+        case Canvas3DLineJoin.round:
+            appendRoundJoin(geometry, point, prevOuter, nextOuter, turn, color);
+            break;
+        case Canvas3DLineJoin.bevel:
+            appendTriangle(geometry, point, prevOuter, nextOuter, color);
+            break;
+        case Canvas3DLineJoin.miter:
+            appendMiterJoin(geometry, point, prevSegment, nextSegment, prevOuter, nextOuter, offset, style.miterLimit, color);
+            break;
+    }
+}
+function appendMiterJoin(geometry, point, prevSegment, nextSegment, prevOuter, nextOuter, offset, miterLimit, color) {
+    const miter = calculatePlanarMiterPoint(point, prevSegment.direction, prevSegment.normal, nextSegment.direction, nextSegment.normal, offset, miterLimit);
+    if (!miter) {
+        appendTriangle(geometry, point, prevOuter, nextOuter, color);
+        return;
+    }
+    appendTriangle(geometry, point, prevOuter, miter, color);
+    appendTriangle(geometry, point, miter, nextOuter, color);
+}
+function calculatePlanarMiterPoint(point, prevDirection, prevNormal, nextDirection, nextNormal, offset, miterLimit) {
+    const prevX = point.x + prevNormal.x * offset;
+    const prevY = point.y + prevNormal.y * offset;
+    const nextX = point.x + nextNormal.x * offset;
+    const nextY = point.y + nextNormal.y * offset;
+    const denominator = cross2D(prevDirection.x, prevDirection.y, nextDirection.x, nextDirection.y);
+    if (Math.abs(denominator) > epsilon) {
+        const t = cross2D(nextX - prevX, nextY - prevY, nextDirection.x, nextDirection.y) / denominator;
+        const x = prevX + prevDirection.x * t;
+        const y = prevY + prevDirection.y * t;
+        const maxMiterLength = Math.abs(offset) * miterLimit;
+        const dx = x - point.x;
+        const dy = y - point.y;
+        if (dx * dx + dy * dy <= maxMiterLength * maxMiterLength) {
+            return new Vec3(x, y, point.z);
+        }
+    }
+    return undefined;
+}
+function appendRoundJoin(geometry, center, startPoint, endPoint, turn, color) {
+    const startAngle = Math.atan2(startPoint.y - center.y, startPoint.x - center.x);
+    const endAngle = Math.atan2(endPoint.y - center.y, endPoint.x - center.x);
+    let delta = normalizeAngle(endAngle - startAngle);
+    if (turn > 0 && delta < 0) {
+        delta += Math.PI * 2;
+    }
+    else if (turn < 0 && delta > 0) {
+        delta -= Math.PI * 2;
+    }
+    appendArcFan(geometry, center, startAngle, delta, Vec3.distance(center, startPoint), color);
+}
+function appendPlanarCaps(geometry, strokePoints, segments, style, color) {
+    if (style.lineCap !== Canvas3DLineCap.round) {
+        return;
+    }
+    const halfWidth = style.lineWidth * 0.5;
+    appendCircleFill(geometry, strokePoints[0], halfWidth, color);
+    appendCircleFill(geometry, strokePoints[segments[segments.length - 1].toIndex], halfWidth, color);
+}
+function createPlanarOffsetPoint(point, normal, offset) {
+    return new Vec3(point.x + normal.x * offset, point.y + normal.y * offset, point.z);
+}
+function appendArcFan(geometry, center, startAngle, delta, radius, color) {
+    if (radius <= epsilon || Math.abs(delta) <= epsilon) {
+        return;
+    }
+    const segmentCount = Math.max(1, Math.ceil(Math.abs(delta) / roundSegmentRadians));
+    let previousPoint = new Vec3(center.x + Math.cos(startAngle) * radius, center.y + Math.sin(startAngle) * radius, center.z);
+    for (let iSegment = 1; iSegment <= segmentCount; iSegment++) {
+        const angle = startAngle + delta * iSegment / segmentCount;
+        const point = new Vec3(center.x + Math.cos(angle) * radius, center.y + Math.sin(angle) * radius, center.z);
+        appendTriangle(geometry, center, previousPoint, point, color);
+        previousPoint = point;
+    }
+}
+function createDashState(pattern, lineDashOffset) {
+    const patternLength = sum(pattern);
+    let offset = lineDashOffset % patternLength;
+    if (offset < 0) {
+        offset += patternLength;
+    }
+    let patternIndex = 0;
+    while (offset >= pattern[patternIndex] && pattern[patternIndex] > 0) {
+        offset -= pattern[patternIndex];
+        patternIndex = (patternIndex + 1) % pattern.length;
+    }
+    return {
+        pattern,
+        patternIndex,
+        remaining: pattern[patternIndex] - offset,
+        drawing: patternIndex % 2 === 0,
+    };
+}
+function advanceDashState(state) {
+    state.patternIndex = (state.patternIndex + 1) % state.pattern.length;
+    state.remaining = state.pattern[state.patternIndex];
+    state.drawing = state.patternIndex % 2 === 0;
+}
+function setLerpPoint(out, from, to, t) {
+    return out.set(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t, from.z + (to.z - from.z) * t);
+}
+function normalizedStrokePoints(points, closed) {
+    const strokePoints = [];
+    for (const point of points) {
+        if (strokePoints.length === 0 || hasStrokeSegmentLength(strokePoints[strokePoints.length - 1], point)) {
+            strokePoints.push(point);
+        }
+    }
+    if (closed && strokePoints.length > 1 && !hasStrokeSegmentLength(strokePoints[strokePoints.length - 1], strokePoints[0])) {
+        strokePoints.pop();
+    }
+    return strokePoints;
+}
+function isPlanarXY(points) {
+    const firstPoint = points[0];
+    if (!firstPoint) {
+        return true;
+    }
+    for (const point of points) {
+        if (Math.abs(point.z - firstPoint.z) > epsilon) {
+            return false;
+        }
+    }
+    return true;
+}
+function cross2D(ax, ay, bx, by) {
+    return ax * by - ay * bx;
+}
+function appendVertex(geometry, point, color) {
+    const vertexIndex = geometry.vertices.length / vertexStrideF;
+    geometry.vertices.push(point.x, point.y, point.z, color.x, color.y, color.z, color.w);
+    return vertexIndex;
+}
+function appendTriangle(geometry, a, b, c, color) {
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    appendVertex(geometry, a, color);
+    appendVertex(geometry, b, color);
+    appendVertex(geometry, c, color);
+    geometry.indices.push(baseVertex, baseVertex + 1, baseVertex + 2);
+}
+function appendQuad(geometry, a, b, c, d, color) {
+    const baseVertex = geometry.vertices.length / vertexStrideF;
+    appendVertex(geometry, a, color);
+    appendVertex(geometry, b, color);
+    appendVertex(geometry, c, color);
+    appendVertex(geometry, d, color);
+    geometry.indices.push(baseVertex, baseVertex + 1, baseVertex + 2, baseVertex, baseVertex + 2, baseVertex + 3);
+}
+export function createOrUpdateRenderingSubMeshRecord(device, geometry, record) {
+    const vertexCount = geometry.vertices.length / vertexStrideF;
+    if (vertexCount === 0 || geometry.indices.length === 0) {
+        return undefined;
+    }
+    const vertexBufferData = Float32Array.from(geometry.vertices);
+    const indexBufferData = createIndexBufferData(geometry.indices, vertexCount);
+    if (record && record.indexBytesPerElement === indexBufferData.BYTES_PER_ELEMENT) {
+        updateRenderingSubMeshRecord(record, vertexBufferData, indexBufferData);
+        return record;
+    }
+    record?.renderingSubMesh.destroy();
+    const vertexBuffer = device.createBuffer(new gfx.BufferInfo(gfx.BufferUsageBit.VERTEX, gfx.MemoryUsageBit.DEVICE, vertexBufferData.byteLength, Float32Array.BYTES_PER_ELEMENT * vertexStrideF, gfx.BufferFlagBit.NONE));
+    updateGfxBuffer(vertexBuffer, vertexBufferData);
+    const indexBuffer = device.createBuffer(new gfx.BufferInfo(gfx.BufferUsageBit.INDEX, gfx.MemoryUsageBit.DEVICE, indexBufferData.byteLength, indexBufferData.BYTES_PER_ELEMENT, gfx.BufferFlagBit.NONE));
+    updateGfxBuffer(indexBuffer, indexBufferData);
+    return {
+        renderingSubMesh: new RenderingSubMesh([vertexBuffer], canvas3DVertexAttributes, gfx.PrimitiveMode.TRIANGLE_LIST, indexBuffer, null, true),
+        vertexBuffer,
+        indexBuffer,
+        vertexBufferBytes: vertexBufferData.byteLength,
+        indexBufferBytes: indexBufferData.byteLength,
+        indexBytesPerElement: indexBufferData.BYTES_PER_ELEMENT,
+    };
+}
+function updateRenderingSubMeshRecord(record, vertexBufferData, indexBufferData) {
+    resizeGfxBuffer(record.vertexBuffer, vertexBufferData.byteLength);
+    updateGfxBuffer(record.vertexBuffer, vertexBufferData);
+    record.vertexBufferBytes = vertexBufferData.byteLength;
+    resizeGfxBuffer(record.indexBuffer, indexBufferData.byteLength);
+    updateGfxBuffer(record.indexBuffer, indexBufferData);
+    record.indexBufferBytes = indexBufferData.byteLength;
+}
+function resizeGfxBuffer(buffer, byteLength) {
+    const resizableBuffer = buffer;
+    if (resizableBuffer.size !== byteLength) {
+        resizableBuffer.resize(byteLength);
+    }
+}
+function updateGfxBuffer(buffer, source) {
+    buffer.update(source);
+}
+function createIndexBufferData(indices, vertexCount) {
+    if (vertexCount > 2 ** 16) {
+        return Uint32Array.from(indices);
+    }
+    return Uint16Array.from(indices);
+}
+function normalizedSubPathPoints(subPath) {
+    const points = subPath.points;
+    if (points.length > 1 && Vec3.equals(points[0], points[points.length - 1], epsilon)) {
+        return points.slice(0, -1);
+    }
+    return points;
+}
+export function resolveHalfExtents(halfExtents) {
+    if (typeof halfExtents === 'number') {
+        return new Vec3(halfExtents, halfExtents, halfExtents);
+    }
+    return halfExtents.clone();
+}
+function createBoxCorners(center, halfExtents) {
+    const { x, y, z } = halfExtents;
+    return [
+        new Vec3(center.x - x, center.y - y, center.z - z),
+        new Vec3(center.x + x, center.y - y, center.z - z),
+        new Vec3(center.x + x, center.y + y, center.z - z),
+        new Vec3(center.x - x, center.y + y, center.z - z),
+        new Vec3(center.x - x, center.y - y, center.z + z),
+        new Vec3(center.x + x, center.y - y, center.z + z),
+        new Vec3(center.x + x, center.y + y, center.z + z),
+        new Vec3(center.x - x, center.y + y, center.z + z),
+    ];
+}
+function transformPoint(point, transform) {
+    return transformPointInto(new Vec3(), point, transform);
+}
+function transformPointInto(out, point, transform) {
+    return Vec3.transformMat4(out, point, transform);
+}
+function transformPoints(points, transform) {
+    return points.map((point) => {
+        return transformPoint(point, transform);
+    });
+}
+function createAxisBasis(from, to) {
+    const direction = Vec3.subtract(new Vec3(), to, from);
+    return createDirectionBasis(direction);
+}
+function createDirectionBasis(direction) {
+    const normalizedDirection = direction.clone();
+    if (normalizedDirection.lengthSqr() <= epsilon) {
+        return undefined;
+    }
+    normalizedDirection.normalize();
+    const referenceAxis = Math.abs(Vec3.dot(normalizedDirection, Vec3.UP)) > 0.95 ? Vec3.RIGHT : Vec3.UP;
+    const normalA = Vec3.cross(new Vec3(), normalizedDirection, referenceAxis).normalize();
+    const normalB = Vec3.cross(new Vec3(), normalizedDirection, normalA).normalize();
+    return {
+        normalA,
+        normalB,
+    };
+}
+function createNormalBasis(normal) {
+    const direction = resolveDirection(normal, new Vec3(0, 0, 1));
+    const referenceAxis = Math.abs(Vec3.dot(direction, Vec3.UP)) > 0.95 ? Vec3.RIGHT : Vec3.UP;
+    const axisA = Vec3.cross(new Vec3(), referenceAxis, direction).normalize();
+    const axisB = Vec3.cross(new Vec3(), direction, axisA).normalize();
+    return {
+        axisA,
+        axisB,
+    };
+}
+function resolveDirection(value, fallback = Vec3.UP) {
+    const result = value.clone();
+    if (result.lengthSqr() <= epsilon) {
+        result.set(fallback);
+    }
+    else {
+        result.normalize();
+    }
+    return result;
+}
+function setBasisDirection(out, axisA, axisB, angle) {
+    return out.set(axisA.x * Math.cos(angle) + axisB.x * Math.sin(angle), axisA.y * Math.cos(angle) + axisB.y * Math.sin(angle), axisA.z * Math.cos(angle) + axisB.z * Math.sin(angle));
+}
+function setHemispherePoint(out, center, radius, axis, radialDirection, theta) {
+    const radialScale = Math.sin(theta) * radius;
+    const axisScale = Math.cos(theta) * radius;
+    return out.set(center.x + axis.x * axisScale + radialDirection.x * radialScale, center.y + axis.y * axisScale + radialDirection.y * radialScale, center.z + axis.z * axisScale + radialDirection.z * radialScale);
+}
+function createVec3Cache(size) {
+    return {
+        values: createVec3ScratchValues(size),
+        borrowed: false,
+    };
+}
+function borrowVec3ScratchCache(cache) {
+    if (cache.borrowed) {
+        throw new Error('Canvas3D Vec3 scratch cache is already borrowed.');
+    }
+    cache.borrowed = true;
+    return cache.values;
+}
+function releaseVec3ScratchCache(cache) {
+    cache.borrowed = false;
+}
+function createVec3ScratchValues(size) {
+    return Array.from({ length: size }, () => {
+        return new Vec3();
+    });
+}
+function getCircleTopology(segments) {
+    let topology = circleTopologyCache.get(segments);
+    if (!topology) {
+        const cos = [];
+        const sin = [];
+        for (let iPoint = 0; iPoint < segments; iPoint++) {
+            const angle = iPoint / segments * Math.PI * 2;
+            cos.push(Math.cos(angle));
+            sin.push(Math.sin(angle));
+        }
+        topology = { cos, sin };
+        circleTopologyCache.set(segments, topology);
+    }
+    return topology;
+}
+function getSphereTopology(latitudeSegments, longitudeSegments) {
+    const key = `${latitudeSegments}:${longitudeSegments}`;
+    let topology = sphereTopologyCache.get(key);
+    if (!topology) {
+        const positions = [];
+        const indices = [];
+        for (let iLatitude = 0; iLatitude <= latitudeSegments; iLatitude++) {
+            const theta = iLatitude / latitudeSegments * Math.PI;
+            const z = Math.cos(theta);
+            const ringRadius = Math.sin(theta);
+            for (let iLongitude = 0; iLongitude <= longitudeSegments; iLongitude++) {
+                const phi = iLongitude / longitudeSegments * Math.PI * 2;
+                positions.push(Math.cos(phi) * ringRadius, Math.sin(phi) * ringRadius, z);
+            }
+        }
+        const ringStride = longitudeSegments + 1;
+        for (let iLatitude = 0; iLatitude < latitudeSegments; iLatitude++) {
+            for (let iLongitude = 0; iLongitude < longitudeSegments; iLongitude++) {
+                const a = iLatitude * ringStride + iLongitude;
+                const b = a + ringStride;
+                const c = b + 1;
+                const d = a + 1;
+                indices.push(a, b, d, d, b, c);
+            }
+        }
+        topology = { positions, indices };
+        sphereTopologyCache.set(key, topology);
+    }
+    return topology;
+}
+function getCylinderIndexTopology(radialSegments, includeCaps) {
+    const key = `${radialSegments}:${includeCaps ? 1 : 0}`;
+    let topology = cylinderIndexTopologyCache.get(key);
+    if (!topology) {
+        const indices = [];
+        for (let iPoint = 0; iPoint < radialSegments; iPoint++) {
+            const nextPoint = (iPoint + 1) % radialSegments;
+            const start = iPoint;
+            const startNext = nextPoint;
+            const end = radialSegments + iPoint;
+            const endNext = radialSegments + nextPoint;
+            indices.push(start, end, startNext, startNext, end, endNext);
+        }
+        if (includeCaps) {
+            const fromCenter = radialSegments * 2;
+            const toCenter = fromCenter + 1;
+            for (let iPoint = 0; iPoint < radialSegments; iPoint++) {
+                const nextPoint = (iPoint + 1) % radialSegments;
+                indices.push(fromCenter, nextPoint, iPoint, toCenter, radialSegments + iPoint, radialSegments + nextPoint);
+            }
+        }
+        topology = { indices };
+        cylinderIndexTopologyCache.set(key, topology);
+    }
+    return topology;
+}
+function getHemisphereTopology(radialSegments, capSegments) {
+    const key = `${radialSegments}:${capSegments}`;
+    let topology = hemisphereTopologyCache.get(key);
+    if (!topology) {
+        const positions = [];
+        const indices = [];
+        for (let iCap = 0; iCap <= capSegments; iCap++) {
+            const theta = iCap / capSegments * Math.PI * 0.5;
+            const radialScale = Math.sin(theta);
+            const axisScale = Math.cos(theta);
+            for (let iRadial = 0; iRadial <= radialSegments; iRadial++) {
+                const phi = iRadial / radialSegments * Math.PI * 2;
+                positions.push(Math.cos(phi) * radialScale, Math.sin(phi) * radialScale, axisScale);
+            }
+        }
+        const ringStride = radialSegments + 1;
+        for (let iCap = 0; iCap < capSegments; iCap++) {
+            for (let iRadial = 0; iRadial < radialSegments; iRadial++) {
+                const a = iCap * ringStride + iRadial;
+                const b = a + ringStride;
+                const c = b + 1;
+                const d = a + 1;
+                indices.push(a, b, d, d, b, c);
+            }
+        }
+        topology = { positions, indices };
+        hemisphereTopologyCache.set(key, topology);
+    }
+    return topology;
+}
+function appendTopologyIndices(geometry, baseVertex, indices) {
+    for (const index of indices) {
+        geometry.indices.push(baseVertex + index);
+    }
+}
+function createCirclePoint(center, radius, pointIndex) {
+    return setCirclePoint(new Vec3(), center, radius, pointIndex);
+}
+function createCirclePoints(center, radius) {
+    const points = [];
+    for (let iPoint = 0; iPoint < defaultCircleSegments; iPoint++) {
+        points.push(createCirclePoint(center, radius, iPoint));
+    }
+    return points;
+}
+function setCirclePoint(out, center, radius, pointIndex) {
+    const topology = getCircleTopology(defaultCircleSegments);
+    return out.set(center.x + topology.cos[pointIndex] * radius, center.y + topology.sin[pointIndex] * radius, center.z);
+}
+function createPlaneCirclePoint(center, radius, axisA, axisB, pointIndex, segmentCount) {
+    return setPlaneCirclePoint(new Vec3(), center, radius, axisA, axisB, pointIndex, segmentCount);
+}
+function setPlaneCirclePoint(out, center, radius, axisA, axisB, pointIndex, segmentCount) {
+    const topology = getCircleTopology(segmentCount);
+    const cos = topology.cos[pointIndex];
+    const sin = topology.sin[pointIndex];
+    return out.set(center.x + (axisA.x * cos + axisB.x * sin) * radius, center.y + (axisA.y * cos + axisB.y * sin) * radius, center.z + (axisA.z * cos + axisB.z * sin) * radius);
+}
+export function normalizeArcDelta(startAngle, endAngle, counterclockwise) {
+    const fullTurn = Math.PI * 2;
+    let delta = endAngle - startAngle;
+    if (counterclockwise) {
+        while (delta > 0) {
+            delta -= fullTurn;
+        }
+        return Math.max(delta, -fullTurn);
+    }
+    while (delta < 0) {
+        delta += fullTurn;
+    }
+    return Math.min(delta, fullTurn);
+}
+function normalizeAngle(value) {
+    let result = value;
+    while (result <= -Math.PI) {
+        result += Math.PI * 2;
+    }
+    while (result > Math.PI) {
+        result -= Math.PI * 2;
+    }
+    return result;
+}
+function sum(values) {
+    let result = 0;
+    for (const value of values) {
+        result += value;
+    }
+    return result;
+}
+const canvas3DVertexAttributes = [
+    new gfx.Attribute(gfx.AttributeName.ATTR_POSITION, gfx.Format.RGB32F, false, undefined, false, undefined),
+    new gfx.Attribute(gfx.AttributeName.ATTR_COLOR, gfx.Format.RGBA32F, false, undefined, false, undefined),
+];
+const boxEdges = [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [3, 0],
+    [4, 5],
+    [5, 6],
+    [6, 7],
+    [7, 4],
+    [0, 4],
+    [1, 5],
+    [2, 6],
+    [3, 7],
+];
+const boxTriangleIndices = [
+    0, 2, 1,
+    0, 3, 2,
+    4, 5, 6,
+    4, 6, 7,
+    0, 4, 7,
+    0, 7, 3,
+    1, 2, 6,
+    1, 6, 5,
+    0, 1, 5,
+    0, 5, 4,
+    3, 7, 6,
+    3, 6, 2,
+];
+const strokeBoxTriangleIndices = [
+    0, 1, 5,
+    0, 5, 4,
+    1, 2, 6,
+    1, 6, 5,
+    2, 3, 7,
+    2, 7, 6,
+    3, 0, 4,
+    3, 4, 7,
+    0, 2, 1,
+    0, 3, 2,
+    4, 5, 6,
+    4, 6, 7,
+];
+//# sourceMappingURL=geometry.js.map