@codexo/exojs 0.6.3 → 0.6.5

package/dist/esm/core/capabilities.js

@@ -1,17 +1,99 @@
-// Browser feature-detection probes evaluated once at module load. The
-// resulting `capabilities` object is a `Readonly<Record<CapabilityName,
-// boolean>>` and can be inspected directly or queried via `isSupported`.
+/// <reference types="@webgpu/types" />
+// Browser-environment feature detection. Construction is private; the
+// only public entry is `Capabilities.ready`, a lazy-cached `Promise<Capabilities>`
+// that fires the (mostly) async probes on first access and returns the
+// same Promise for every subsequent call. Once it resolves, the returned
+// instance is frozen — every property is read once and never mutates.
 //
-// All probes are synchronous. Async questions ("can I actually acquire a
-// WebGPU adapter?", "can the audio decoder play this OGG file?") are
-// outside this module's scope — they're owned by the Application's
-// backend selection and the Loader respectively. `capabilities.webgpu`
-// returning `true` only guarantees that the browser advertises WebGPU,
-// not that an adapter request will succeed.
+// Synchronous callsites should keep the resolved instance in scope (e.g.,
+// `app.capabilities` after `await app.start(...)`); there is no global
+// sync mirror, by design.
 const hasWindow = typeof window !== 'undefined';
 const hasDocument = typeof document !== 'undefined';
 const hasNavigator = typeof navigator !== 'undefined';
-const probeWebGl2 = () => {
+class Capabilities {
+    static _readyPromise = null;
+    /**
+     * Lazy-cached Promise that resolves to a frozen Capabilities instance.
+     *
+     * The first read kicks off the async probes (currently just the WebGPU
+     * adapter request); every subsequent read returns the same Promise.
+     * Concurrent callers share the in-flight detection — no double work.
+     *
+     * Early-warmup pattern for callers who want to overlap detection with
+     * other startup work:
+     *
+     * ```ts
+     * void Capabilities.ready;          // fire-and-forget; starts probes now
+     * // ... unrelated bootstrap ...
+     * const caps = await Capabilities.ready;  // typically already resolved
+     * ```
+     */
+    static get ready() {
+        if (Capabilities._readyPromise === null) {
+            Capabilities._readyPromise = Capabilities._detect();
+        }
+        return Capabilities._readyPromise;
+    }
+    webgl2;
+    webgpu;
+    webgpuAdapter;
+    webgpuVendor;
+    webgpuArchitecture;
+    pointer;
+    keyboard;
+    gamepad;
+    touch;
+    maxTouchPoints;
+    audio;
+    fullscreen;
+    vibration;
+    offscreenCanvas;
+    webWorkers;
+    devicePixelRatio;
+    constructor(values) {
+        this.webgl2 = values.webgl2;
+        this.webgpu = values.webgpu;
+        this.webgpuAdapter = values.webgpuAdapter;
+        this.webgpuVendor = values.webgpuVendor;
+        this.webgpuArchitecture = values.webgpuArchitecture;
+        this.pointer = values.pointer;
+        this.keyboard = values.keyboard;
+        this.gamepad = values.gamepad;
+        this.touch = values.touch;
+        this.maxTouchPoints = values.maxTouchPoints;
+        this.audio = values.audio;
+        this.fullscreen = values.fullscreen;
+        this.vibration = values.vibration;
+        this.offscreenCanvas = values.offscreenCanvas;
+        this.webWorkers = values.webWorkers;
+        this.devicePixelRatio = values.devicePixelRatio;
+        Object.freeze(this);
+    }
+    static async _detect() {
+        const [webgpuAdapter, webgpuInfo] = await probeWebGpu();
+        return new Capabilities({
+            webgl2: probeWebGl2(),
+            webgpu: probeWebGpuApiSurface(),
+            webgpuAdapter,
+            webgpuVendor: webgpuInfo?.vendor ?? null,
+            webgpuArchitecture: webgpuInfo?.architecture ?? null,
+            pointer: probePointer(),
+            keyboard: probeKeyboard(),
+            gamepad: probeGamepad(),
+            touch: probeTouchSupported(),
+            maxTouchPoints: probeMaxTouchPoints(),
+            audio: probeAudio(),
+            fullscreen: probeFullscreen(),
+            vibration: probeVibration(),
+            offscreenCanvas: probeOffscreenCanvas(),
+            webWorkers: probeWebWorkers(),
+            devicePixelRatio: hasWindow ? window.devicePixelRatio : 1,
+        });
+    }
+}
+// --- probes ---------------------------------------------------------------
+function probeWebGl2() {
     if (!hasDocument)
         return false;
     try {
@@ -22,75 +104,95 @@ const probeWebGl2 = () => {
     catch {
         return false;
     }
-};
-const probeWebGpu = () => {
+}
+function probeWebGpuApiSurface() {
     return hasNavigator && 'gpu' in navigator;
-};
-const probeAudio = () => {
-    if (!hasWindow)
-        return false;
-    const w = window;
-    return typeof w.AudioContext !== 'undefined' || typeof w.webkitAudioContext !== 'undefined';
-};
-const probePointer = () => {
+}
+async function probeWebGpu() {
+    if (!probeWebGpuApiSurface())
+        return [null, null];
+    const gpu = navigator.gpu;
+    if (!gpu || typeof gpu.requestAdapter !== 'function')
+        return [null, null];
+    try {
+        const adapter = await gpu.requestAdapter();
+        if (!adapter)
+            return [null, null];
+        // Modern path: GPUAdapter.info is a sync property (Chrome 116+,
+        // Safari 18+). Older browsers exposed a deprecated async
+        // requestAdapterInfo() instead. Try the modern path first, fall
+        // back if needed.
+        const adapterAny = adapter;
+        if (adapterAny.info) {
+            return [adapter, adapterAny.info];
+        }
+        if (typeof adapterAny.requestAdapterInfo === 'function') {
+            try {
+                return [adapter, await adapterAny.requestAdapterInfo()];
+            }
+            catch {
+                return [adapter, null];
+            }
+        }
+        return [adapter, null];
+    }
+    catch {
+        return [null, null];
+    }
+}
+function probePointer() {
     return hasWindow && 'PointerEvent' in window;
-};
-const probeTouch = () => {
+}
+function probeKeyboard() {
+    return hasWindow && 'KeyboardEvent' in window;
+}
+function probeGamepad() {
+    return hasNavigator && typeof navigator.getGamepads === 'function';
+}
+function probeTouchSupported() {
     if (!hasWindow)
         return false;
     if ('ontouchstart' in window)
         return true;
-    if (hasNavigator && typeof navigator.maxTouchPoints === 'number' && navigator.maxTouchPoints > 0)
+    if (probeMaxTouchPoints() > 0)
         return true;
     return false;
-};
-const probeGamepad = () => {
-    return hasNavigator && typeof navigator.getGamepads === 'function';
-};
-const probeKeyboard = () => {
-    return hasWindow && 'KeyboardEvent' in window;
-};
-const probeFullscreen = () => {
+}
+function probeMaxTouchPoints() {
+    if (!hasNavigator)
+        return 0;
+    const points = navigator.maxTouchPoints;
+    return typeof points === 'number' ? points : 0;
+}
+function probeAudio() {
+    if (!hasWindow)
+        return false;
+    const w = window;
+    return typeof w.AudioContext !== 'undefined' || typeof w.webkitAudioContext !== 'undefined';
+}
+function probeFullscreen() {
     if (!hasDocument)
         return false;
     const el = document.documentElement;
     return typeof el.requestFullscreen === 'function' || typeof el.webkitRequestFullscreen === 'function';
-};
-const probeVibration = () => {
+}
+function probeVibration() {
     return hasNavigator && typeof navigator.vibrate === 'function';
-};
-const probeOffscreenCanvas = () => {
+}
+function probeOffscreenCanvas() {
     // The browser global is verbatim `OffscreenCanvas`; eslint's
     // strict-camelCase rule rejects the property name even though we
     // can't rename a web standard.
     // eslint-disable-next-line @typescript-eslint/naming-convention
     return hasWindow && typeof window.OffscreenCanvas !== 'undefined';
-};
-/**
- * Synchronous, one-shot feature-detection results. Computed once at
- * module load and frozen. Use either as a property bag (`capabilities.touch`)
- * or via {@link isSupported} for typed lookup.
- */
-const capabilities = Object.freeze({
-    webgl2: probeWebGl2(),
-    webgpu: probeWebGpu(),
-    audio: probeAudio(),
-    pointer: probePointer(),
-    touch: probeTouch(),
-    gamepad: probeGamepad(),
-    keyboard: probeKeyboard(),
-    fullscreen: probeFullscreen(),
-    vibration: probeVibration(),
-    offscreenCanvas: probeOffscreenCanvas(),
-});
-/**
- * Typed lookup over {@link capabilities}. Identical to
- * `capabilities[name]` but the function form gives clearer call-sites
- * when the name is computed.
- */
-function isSupported(name) {
-    return capabilities[name];
+}
+function probeWebWorkers() {
+    // The browser global is verbatim `Worker`; eslint's strict-camelCase
+    // rule rejects the property name even though we can't rename a web
+    // standard.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    return hasWindow && typeof window.Worker === 'function';
 }
 
-export { capabilities, isSupported };
+export { Capabilities };
 //# sourceMappingURL=capabilities.js.map

package/dist/esm/core/capabilities.js.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.js","sources":["../../../../src/core/capabilities.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"capabilities.js","sources":["../../../../src/core/capabilities.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 export { canvasSourceToDataUrl, emptyArrayBuffer, getCanvasSourceSize, getPreciseTime, getTextureSourceSize, hours, milliseconds, minutes, noop, rand, removeArrayItems, seconds, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio } from './core/utils.js';
 export { Application, ApplicationStatus } from './core/Application.js';
 export { Bounds } from './core/Bounds.js';
-export { capabilities, isSupported } from './core/capabilities.js';
+export { Capabilities } from './core/capabilities.js';
 export { Clock } from './core/Clock.js';
 export { Color } from './core/Color.js';
 export { Quadtree } from './core/Quadtree.js';
@@ -63,9 +63,6 @@ export { UniversalEmitter } from './particles/emitters/UniversalEmitter.js';
 export { Particle } from './particles/Particle.js';
 export { ParticleSystem } from './particles/ParticleSystem.js';
 export { Mesh } from './rendering/mesh/Mesh.js';
-export { CircleGeometry } from './rendering/primitives/CircleGeometry.js';
-export { Geometry } from './rendering/primitives/Geometry.js';
-export { DrawableShape } from './rendering/primitives/DrawableShape.js';
 export { Graphics } from './rendering/primitives/Graphics.js';
 export { Shader } from './rendering/shader/Shader.js';
 export { ShaderAttribute } from './rendering/shader/ShaderAttribute.js';
@@ -87,7 +84,6 @@ export { webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl
 export { WebGl2VertexArrayObject } from './rendering/webgl2/WebGl2VertexArrayObject.js';
 export { WebGl2MeshRenderer } from './rendering/webgl2/WebGl2MeshRenderer.js';
 export { WebGl2ParticleRenderer } from './rendering/webgl2/WebGl2ParticleRenderer.js';
-export { WebGl2PrimitiveRenderer } from './rendering/webgl2/WebGl2PrimitiveRenderer.js';
 export { WebGl2Backend } from './rendering/webgl2/WebGl2Backend.js';
 export { createWebGl2ShaderProgram } from './rendering/webgl2/WebGl2ShaderProgram.js';
 export { WebGl2SpriteRenderer } from './rendering/webgl2/WebGl2SpriteRenderer.js';
@@ -95,7 +91,6 @@ export { AbstractWebGpuRenderer } from './rendering/webgpu/AbstractWebGpuRendere
 export { getWebGpuBlendState } from './rendering/webgpu/WebGpuBlendState.js';
 export { WebGpuMeshRenderer } from './rendering/webgpu/WebGpuMeshRenderer.js';
 export { WebGpuParticleRenderer } from './rendering/webgpu/WebGpuParticleRenderer.js';
-export { WebGpuPrimitiveRenderer } from './rendering/webgpu/WebGpuPrimitiveRenderer.js';
 export { WebGpuBackend } from './rendering/webgpu/WebGpuBackend.js';
 export { WebGpuSpriteRenderer } from './rendering/webgpu/WebGpuSpriteRenderer.js';
 export { BlendModes, BufferTypes, BufferUsage, RenderingPrimitives, ScaleModes, ShaderPrimitives, WrapModes } from './rendering/types.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/math/geometry.d.ts

@@ -1,8 +1,12 @@
-import { Geometry } from '@/rendering/primitives/Geometry';
-export declare const buildLine: (startX: number, startY: number, endX: number, endY: number, width: number, vertices?: Array<number>, indices?: Array<number>) => Geometry;
-export declare const buildPath: (points: Array<number>, width: number, vertices?: Array<number>, indices?: Array<number>) => Geometry;
-export declare const buildCircle: (centerX: number, centerY: number, radius: number, vertices?: Array<number>, indices?: Array<number>) => Geometry;
-export declare const buildEllipse: (centerX: number, centerY: number, radiusX: number, radiusY: number, vertices?: Array<number>, indices?: Array<number>) => Geometry;
-export declare const buildPolygon: (points: Array<number>, vertices?: Array<number>, indices?: Array<number>) => Geometry;
-export declare const buildRectangle: (x: number, y: number, width: number, height: number, vertices?: Array<number>, indices?: Array<number>) => Geometry;
-export declare const buildStar: (centerX: number, centerY: number, points: number, radius: number, innerRadius?: number, rotation?: number) => Geometry;
+export interface MeshGeometryData {
+    readonly vertices: Float32Array;
+    readonly indices: Uint16Array;
+    readonly points: Array<number>;
+}
+export declare const buildLine: (startX: number, startY: number, endX: number, endY: number, width: number) => MeshGeometryData;
+export declare const buildPath: (points: Array<number>, width: number) => MeshGeometryData;
+export declare const buildCircle: (centerX: number, centerY: number, radius: number) => MeshGeometryData;
+export declare const buildEllipse: (centerX: number, centerY: number, radiusX: number, radiusY: number) => MeshGeometryData;
+export declare const buildPolygon: (points: Array<number>) => MeshGeometryData;
+export declare const buildRectangle: (x: number, y: number, width: number, height: number) => MeshGeometryData;
+export declare const buildStar: (centerX: number, centerY: number, points: number, radius: number, innerRadius?: number, rotation?: number) => MeshGeometryData;

package/dist/esm/math/geometry.js

@@ -1,26 +1,31 @@
 import earcut from 'earcut';
-import { Geometry } from '../rendering/primitives/Geometry.js';
 import { Vector } from './Vector.js';
 import { tau } from './utils.js';
 
-const buildLine = (startX, startY, endX, endY, width, vertices = [], indices = []) => {
+const buildLine = (startX, startY, endX, endY, width) => {
     const points = [startX, startY, endX, endY];
     const distance = width / 2;
-    const index = vertices.length / 6;
     const perpA = new Vector(startX - endX, startY - endY).perp().normalize().multiply(distance);
     const perpB = new Vector(endX - startX, endY - startY).perp().normalize().multiply(distance);
-    vertices.push(startX - perpA.x, startY - perpA.y);
-    vertices.push(startX + perpA.x, startY + perpA.y);
-    vertices.push(endX - perpB.x, endY - perpB.y);
-    vertices.push(endX + perpB.x, endY + perpB.y);
-    indices.push(index, index, index + 1, index + 2, index + 3, index + 3);
-    return new Geometry({ vertices, indices, points });
+    const vertices = new Float32Array([
+        startX - perpA.x, startY - perpA.y, // 0: start-left
+        startX + perpA.x, startY + perpA.y, // 1: start-right
+        endX - perpB.x, endY - perpB.y, // 2: end-left
+        endX + perpB.x, endY + perpB.y, // 3: end-right
+    ]);
+    perpA.destroy();
+    perpB.destroy();
+    const indices = new Uint16Array([0, 1, 3, 0, 3, 2]);
+    return { vertices, indices, points };
 };
-const buildPath = (points, width, vertices = [], indices = []) => {
+const buildPath = (points, width) => {
     if (points.length < 4) {
         throw new Error('At least two X/Y pairs are required to build a line.');
     }
-    const lineWidth = width / 2, firstPoint = new Vector(points[0], points[1]), lastPoint = new Vector(points[points.length - 2], points[points.length - 1]);
+    const lineWidth = width / 2;
+    const firstPoint = new Vector(points[0], points[1]);
+    const lastPoint = new Vector(points[points.length - 2], points[points.length - 1]);
+    const outlinePoints = points;
     if (firstPoint.x === lastPoint.x && firstPoint.y === lastPoint.y) {
         points = points.slice();
         points.pop();
@@ -31,9 +36,10 @@ const buildPath = (points, width, vertices = [], indices = []) => {
         points.unshift(midPointX, midPointY);
         points.push(midPointX, midPointY);
     }
+    firstPoint.destroy();
+    lastPoint.destroy();
     const length = points.length / 2;
-    let indexCount = points.length;
-    let indexStart = vertices.length / 6;
+    const stripVertices = [];
     let p1x = points[0];
     let p1y = points[1];
     let p2x = points[2];
@@ -51,8 +57,8 @@ const buildPath = (points, width, vertices = [], indices = []) => {
     perpy /= dist;
     perpx *= lineWidth;
     perpy *= lineWidth;
-    vertices.push(p1x - perpx, p1y - perpy);
-    vertices.push(p1x + perpx, p1y + perpy);
+    stripVertices.push(p1x - perpx, p1y - perpy);
+    stripVertices.push(p1x + perpx, p1y + perpy);
     for (let i = 1; i < length - 1; i++) {
         p1x = points[(i - 1) * 2];
         p1y = points[((i - 1) * 2) + 1];
@@ -83,8 +89,8 @@ const buildPath = (points, width, vertices = [], indices = []) => {
         let denom = (a1 * b2) - (a2 * b1);
         if (Math.abs(denom) < 0.1) {
             denom += 10.1;
-            vertices.push(p2x - perpx, p2y - perpy);
-            vertices.push(p2x + perpx, p2y + perpy);
+            stripVertices.push(p2x - perpx, p2y - perpy);
+            stripVertices.push(p2x + perpx, p2y + perpy);
             continue;
         }
         const px = ((b1 * c2) - (b2 * c1)) / denom;
@@ -98,14 +104,13 @@ const buildPath = (points, width, vertices = [], indices = []) => {
             perp3y /= dist;
             perp3x *= lineWidth;
             perp3y *= lineWidth;
-            vertices.push(p2x - perp3x, p2y - perp3y);
-            vertices.push(p2x + perp3x, p2y + perp3y);
-            vertices.push(p2x - perp3x, p2y - perp3y);
-            indexCount++;
+            stripVertices.push(p2x - perp3x, p2y - perp3y);
+            stripVertices.push(p2x + perp3x, p2y + perp3y);
+            stripVertices.push(p2x - perp3x, p2y - perp3y);
         }
         else {
-            vertices.push(px, py);
-            vertices.push(p2x - (px - p2x), p2y - (py - p2y));
+            stripVertices.push(px, py);
+            stripVertices.push(p2x - (px - p2x), p2y - (py - p2y));
         }
     }
     p1x = points[(length - 2) * 2];
@@ -119,70 +124,112 @@ const buildPath = (points, width, vertices = [], indices = []) => {
     perpy /= dist;
     perpx *= lineWidth;
     perpy *= lineWidth;
-    vertices.push(p2x - perpx, p2y - perpy);
-    vertices.push(p2x + perpx, p2y + perpy);
-    indices.push(indexStart);
-    for (let i = 0; i < indexCount; i++) {
-        indices.push(indexStart++);
+    stripVertices.push(p2x - perpx, p2y - perpy);
+    stripVertices.push(p2x + perpx, p2y + perpy);
+    // Convert strip-style vertex sequence to triangle-list indices.
+    // For N strip vertices (N = stripVertices.length / 2), each i in [0, N-3]
+    // produces a triangle. Even i: (i, i+1, i+2). Odd i: (i+1, i, i+2).
+    // This preserves the same winding the original triangle-strip pipeline saw.
+    const stripVertexCount = stripVertices.length / 2;
+    const vertices = new Float32Array(stripVertices);
+    const triangleCount = stripVertexCount >= 3 ? stripVertexCount - 2 : 0;
+    const indices = new Uint16Array(triangleCount * 3);
+    for (let i = 0; i < triangleCount; i++) {
+        const base = i * 3;
+        if ((i & 1) === 0) {
+            indices[base] = i;
+            indices[base + 1] = i + 1;
+            indices[base + 2] = i + 2;
+        }
+        else {
+            indices[base] = i + 1;
+            indices[base + 1] = i;
+            indices[base + 2] = i + 2;
+        }
     }
-    indices.push(indexStart - 1);
-    return new Geometry({ vertices, indices, points });
+    return { vertices, indices, points: outlinePoints };
 };
-const buildCircle = (centerX, centerY, radius, vertices = [], indices = []) => {
-    const length = Math.floor(15 * Math.sqrt(radius + radius)), segment = (Math.PI * 2) / length, points = [];
-    let index = vertices.length / 6;
-    indices.push(index);
-    for (let i = 0; i < length + 1; i++) {
-        const segmentX = centerX + (Math.sin(segment * i) * radius), segmentY = centerY + (Math.cos(segment * i) * radius);
+const buildCircle = (centerX, centerY, radius) => {
+    const length = Math.floor(15 * Math.sqrt(radius + radius));
+    const segment = (Math.PI * 2) / length;
+    const points = [];
+    // 1 center vertex + N perimeter vertices.
+    const vertices = new Float32Array((length + 1) * 2);
+    vertices[0] = centerX;
+    vertices[1] = centerY;
+    for (let i = 0; i < length; i++) {
+        const segmentX = centerX + (Math.sin(segment * i) * radius);
+        const segmentY = centerY + (Math.cos(segment * i) * radius);
         points.push(segmentX, segmentY);
-        vertices.push(centerX, centerY);
-        vertices.push(segmentX, segmentY);
-        indices.push(index++, index++);
+        const offset = (i + 1) * 2;
+        vertices[offset] = segmentX;
+        vertices[offset + 1] = segmentY;
     }
-    indices.push(index - 1);
-    return new Geometry({ vertices, indices, points });
+    const indices = new Uint16Array(length * 3);
+    for (let i = 0; i < length; i++) {
+        const base = i * 3;
+        indices[base] = 0;
+        indices[base + 1] = i + 1;
+        indices[base + 2] = i + 2 > length ? 1 : i + 2;
+    }
+    return { vertices, indices, points };
 };
-const buildEllipse = (centerX, centerY, radiusX, radiusY, vertices = [], indices = []) => {
-    const length = Math.floor(15 * Math.sqrt(radiusX + radiusY)), segment = (Math.PI * 2) / length, points = [];
-    let index = vertices.length / 6;
-    indices.push(index);
-    for (let i = 0; i < length + 1; i++) {
-        const segmentX = centerX + (Math.sin(segment * i) * radiusX), segmentY = centerY + (Math.cos(segment * i) * radiusY);
+const buildEllipse = (centerX, centerY, radiusX, radiusY) => {
+    const length = Math.floor(15 * Math.sqrt(radiusX + radiusY));
+    const segment = (Math.PI * 2) / length;
+    const points = [];
+    const vertices = new Float32Array((length + 1) * 2);
+    vertices[0] = centerX;
+    vertices[1] = centerY;
+    for (let i = 0; i < length; i++) {
+        const segmentX = centerX + (Math.sin(segment * i) * radiusX);
+        const segmentY = centerY + (Math.cos(segment * i) * radiusY);
         points.push(segmentX, segmentY);
-        vertices.push(centerX, centerY);
-        vertices.push(segmentX, segmentY);
-        indices.push(index++, index++);
+        const offset = (i + 1) * 2;
+        vertices[offset] = segmentX;
+        vertices[offset + 1] = segmentY;
     }
-    indices.push(index - 1);
-    return new Geometry({ vertices, indices, points });
+    const indices = new Uint16Array(length * 3);
+    for (let i = 0; i < length; i++) {
+        const base = i * 3;
+        indices[base] = 0;
+        indices[base + 1] = i + 1;
+        indices[base + 2] = i + 2 > length ? 1 : i + 2;
+    }
+    return { vertices, indices, points };
 };
-const buildPolygon = (points, vertices = [], indices = []) => {
+const buildPolygon = (points) => {
     if (points.length < 6) {
         throw new Error('At least three X/Y pairs are required to build a polygon.');
     }
-    const index = vertices.length / 6, length = points.length / 2, triangles = earcut(points, [], 2);
-    if (triangles) {
-        for (let i = 0; i < triangles.length; i += 3) {
-            indices.push(triangles[i] + index);
-            indices.push(triangles[i] + index);
-            indices.push(triangles[i + 1] + index);
-            indices.push(triangles[i + 2] + index);
-            indices.push(triangles[i + 2] + index);
-        }
-        for (let i = 0; i < length; i++) {
-            vertices.push(points[i * 2], points[(i * 2) + 1]);
-        }
+    const length = points.length / 2;
+    const triangles = earcut(points, [], 2);
+    const vertices = new Float32Array(points.length);
+    for (let i = 0; i < length; i++) {
+        vertices[i * 2] = points[i * 2];
+        vertices[(i * 2) + 1] = points[(i * 2) + 1];
     }
-    return new Geometry({ vertices, indices, points });
+    const indices = triangles ? new Uint16Array(triangles) : new Uint16Array(0);
+    return { vertices, indices, points };
 };
-const buildRectangle = (x, y, width, height, vertices = [], indices = []) => {
-    const points = [x, y, x + width, y, x, y + height, x + width, y + height], index = vertices.length / 6;
-    vertices.push(...points);
-    indices.push(index, index, index + 1, index + 2, index + 3, index + 3);
-    return new Geometry({ vertices, indices, points });
+const buildRectangle = (x, y, width, height) => {
+    // 4 vertices: TL, TR, BL, BR. Triangles [0, 1, 2,  1, 3, 2] (clockwise).
+    const vertices = new Float32Array([
+        x, y, // 0 TL
+        x + width, y, // 1 TR
+        x, y + height, // 2 BL
+        x + width, y + height, // 3 BR
+    ]);
+    const indices = new Uint16Array([0, 1, 2, 1, 3, 2]);
+    // Outline points walk the perimeter (TL -> TR -> BR -> BL).
+    const points = [x, y, x + width, y, x + width, y + height, x, y + height];
+    return { vertices, indices, points };
 };
 const buildStar = (centerX, centerY, points, radius, innerRadius = radius / 2, rotation = 0) => {
-    const startAngle = (Math.PI / -2) + rotation, length = points * 2, delta = tau / length, path = [];
+    const startAngle = (Math.PI / -2) + rotation;
+    const length = points * 2;
+    const delta = tau / length;
+    const path = [];
     for (let i = 0; i < length; i++) {
         const angle = startAngle + (i * delta);
         const rad = i % 2 ? innerRadius : radius;