@zephyr3d/scene 0.1.0

package/dist/shapes/box.js

@@ -0,0 +1,313 @@
+import { Vector3 } from '@zephyr3d/base';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Shape } from './shape.js';
+
+/**
+ * Box shape
+ * @public
+ */ class BoxShape extends Shape {
+    /**
+   * Creates an instance of box shape
+   * @param options - The creation options
+   */ constructor(options){
+        super(options);
+    }
+    /** @internal */ createDefaultOptions() {
+        const options = super.createDefaultOptions();
+        options.size = 1;
+        return options;
+    }
+    /** @internal */ _createArrays(vertices, normals, uvs, indices, minx, miny, minz, maxx, maxy, maxz) {
+        const needTangent = this._options.needTangent;
+        const needNormal = this._options.needNormal || needTangent;
+        const needUV = this._options.needUV;
+        const uv = needUV ? [
+            0,
+            0,
+            0,
+            1,
+            1,
+            1,
+            1,
+            0
+        ] : null;
+        const topFacePos = [
+            minx,
+            maxy,
+            minz,
+            minx,
+            maxy,
+            maxz,
+            maxx,
+            maxy,
+            maxz,
+            maxx,
+            maxy,
+            minz
+        ];
+        const topFacenormal = needNormal ? [
+            0,
+            1,
+            0,
+            0,
+            1,
+            0,
+            0,
+            1,
+            0,
+            0,
+            1,
+            0
+        ] : null;
+        const frontFacePos = [
+            minx,
+            maxy,
+            maxz,
+            minx,
+            miny,
+            maxz,
+            maxx,
+            miny,
+            maxz,
+            maxx,
+            maxy,
+            maxz
+        ];
+        const frontFaceNormal = needNormal ? [
+            0,
+            0,
+            1,
+            0,
+            0,
+            1,
+            0,
+            0,
+            1,
+            0,
+            0,
+            1
+        ] : null;
+        const rightFacePos = [
+            maxx,
+            maxy,
+            maxz,
+            maxx,
+            miny,
+            maxz,
+            maxx,
+            miny,
+            minz,
+            maxx,
+            maxy,
+            minz
+        ];
+        const rightFaceNormal = needNormal ? [
+            1,
+            0,
+            0,
+            1,
+            0,
+            0,
+            1,
+            0,
+            0,
+            1,
+            0,
+            0
+        ] : null;
+        const backFacePos = [
+            maxx,
+            maxy,
+            minz,
+            maxx,
+            miny,
+            minz,
+            minx,
+            miny,
+            minz,
+            minx,
+            maxy,
+            minz
+        ];
+        const backFaceNormal = needNormal ? [
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1
+        ] : null;
+        const leftFacePos = [
+            minx,
+            maxy,
+            minz,
+            minx,
+            miny,
+            minz,
+            minx,
+            miny,
+            maxz,
+            minx,
+            maxy,
+            maxz
+        ];
+        const leftFaceNormal = needNormal ? [
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0
+        ] : null;
+        const bottomFacePos = [
+            minx,
+            miny,
+            maxz,
+            minx,
+            miny,
+            minz,
+            maxx,
+            miny,
+            minz,
+            maxx,
+            miny,
+            maxz
+        ];
+        const bottomFaceNormal = needNormal ? [
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0,
+            0,
+            -1,
+            0
+        ] : null;
+        indices && indices.push(0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13, 14, 12, 14, 15, 16, 17, 18, 16, 18, 19, 20, 21, 22, 20, 22, 23);
+        vertices && vertices.push(...topFacePos, ...frontFacePos, ...rightFacePos, ...backFacePos, ...leftFacePos, ...bottomFacePos);
+        needNormal && normals && normals.push(...topFacenormal, ...frontFaceNormal, ...rightFaceNormal, ...backFaceNormal, ...leftFaceNormal, ...bottomFaceNormal);
+        needUV && uvs && uvs.push(...uv, ...uv, ...uv, ...uv, ...uv, ...uv);
+        this.primitiveType = 'triangle-list';
+    }
+    /** @internal */ _create() {
+        const needNormal = this._options.needNormal;
+        const needUV = this._options.needUV;
+        const sizeX = this._options.sizeX ?? this._options.size ?? 1;
+        const sizeY = this._options.sizeY ?? this._options.size ?? 1;
+        const sizeZ = this._options.sizeZ ?? this._options.size ?? 1;
+        const anchorX = this._options.anchorX ?? 0;
+        const anchorY = this._options.anchorY ?? 0;
+        const anchorZ = this._options.anchorZ ?? 0;
+        const minx = -anchorX * sizeX;
+        const maxx = minx + sizeX;
+        const miny = -anchorY * sizeY;
+        const maxy = miny + sizeY;
+        const minz = -anchorZ * sizeZ;
+        const maxz = minz + sizeZ;
+        const vertices = [];
+        const indices = [];
+        const normals = needNormal ? [] : null;
+        const uvs = needUV ? [] : null;
+        this._createArrays(vertices, normals, uvs, indices, minx, miny, minz, maxx, maxy, maxz);
+        this.createAndSetVertexBuffer('position_f32x3', new Float32Array(vertices));
+        normals && this.createAndSetVertexBuffer('normal_f32x3', new Float32Array(normals));
+        uvs && this.createAndSetVertexBuffer('tex0_f32x2', new Float32Array(uvs));
+        this.createAndSetIndexBuffer(new Uint16Array(indices));
+        this.setBoundingVolume(new BoundingBox(new Vector3(minx, miny, minz), new Vector3(maxx, maxy, maxz)));
+        this.indexCount = indices.length;
+        return true;
+    }
+}
+/**
+ * Wireframe box shape
+ * @public
+ */ class BoxFrameShape extends Shape {
+    /**
+   * Creates an instance of wireframe box shape
+   * @param options - The creation options
+   */ constructor(options){
+        super(options);
+    }
+    /** @internal */ createDefaultOptions() {
+        const options = super.createDefaultOptions();
+        options.size = 1;
+        options.needNormal = false;
+        options.needTangent = false;
+        options.needUV = false;
+        return options;
+    }
+    /** @internal */ _createArrays(vertices, indices, minx, miny, minz, maxx, maxy, maxz) {
+        const topFacePos = [
+            minx,
+            maxy,
+            minz,
+            minx,
+            maxy,
+            maxz,
+            maxx,
+            maxy,
+            maxz,
+            maxx,
+            maxy,
+            minz
+        ];
+        const bottomFacePos = [
+            minx,
+            miny,
+            maxz,
+            minx,
+            miny,
+            minz,
+            maxx,
+            miny,
+            minz,
+            maxx,
+            miny,
+            maxz
+        ];
+        indices && indices.push(0, 1, 1, 2, 2, 3, 3, 0, 0, 5, 1, 4, 2, 7, 3, 6, 6, 5, 5, 4, 4, 7, 7, 6);
+        vertices && vertices.push(...topFacePos, ...bottomFacePos);
+        this.primitiveType = 'line-list';
+    }
+    /** @internal */ _create() {
+        const sizeX = this._options.sizeX ?? this._options.size ?? 1;
+        const sizeY = this._options.sizeY ?? this._options.size ?? 1;
+        const sizeZ = this._options.sizeZ ?? this._options.size ?? 1;
+        const anchorX = this._options.anchorX ?? 0;
+        const anchorY = this._options.anchorY ?? 0;
+        const anchorZ = this._options.anchorZ ?? 0;
+        const minx = -anchorX * sizeX;
+        const maxx = minx + sizeX;
+        const miny = -anchorY * sizeY;
+        const maxy = miny + sizeY;
+        const minz = -anchorZ * sizeZ;
+        const maxz = minz + sizeZ;
+        const vertices = [];
+        const indices = [];
+        this._createArrays(vertices, indices, minx, miny, minz, maxx, maxy, maxz);
+        this.createAndSetVertexBuffer('position_f32x3', new Float32Array(vertices));
+        this.createAndSetIndexBuffer(new Uint16Array(indices));
+        this.setBoundingVolume(new BoundingBox(new Vector3(minx, miny, minz), new Vector3(maxx, maxy, maxz)));
+        this.indexCount = indices.length;
+        return true;
+    }
+}
+
+export { BoxFrameShape, BoxShape };
+//# sourceMappingURL=box.js.map

package/dist/shapes/box.js.map

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

package/dist/shapes/cylinder.js

@@ -0,0 +1,74 @@
+import { Vector3 } from '@zephyr3d/base';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Shape } from './shape.js';
+
+/**
+ * Box shape
+ * @public
+ */ class CylinderShape extends Shape {
+    /**
+   * Creates an instance of cylinder shape
+   * @param options - The creation options
+   */ constructor(options){
+        super(options);
+    }
+    /** @internal */ createDefaultOptions() {
+        const options = super.createDefaultOptions();
+        options.topRadius = 1;
+        options.bottomRadius = 1;
+        options.heightDetail = 1;
+        options.radialDetail = 20;
+        options.height = 1;
+        options.anchorX = 0.5;
+        options.anchorY = 0;
+        options.anchorZ = 0.5;
+        return options;
+    }
+    /** @internal */ addPatch(x, y, indices) {
+        const stride = this._options.radialDetail + 1;
+        const lt = (y + 1) * stride + x;
+        const rt = lt + 1;
+        const lb = lt - stride;
+        const rb = lb + 1;
+        indices.push(lt, lb, rb, lt, rb, rt);
+    }
+    /** @internal */ _createArrays(vertices, normals, uvs, indices) {
+        const slope = (this._options.bottomRadius - this._options.topRadius) / this._options.height;
+        for(let y = 0; y <= this._options.heightDetail; y++){
+            const v = y / this._options.heightDetail;
+            const radius = (this._options.bottomRadius - this._options.topRadius) * v + this._options.topRadius;
+            for(let x = 0; x <= this._options.radialDetail; x++){
+                const u = x / this._options.radialDetail;
+                const theta = u * Math.PI * 2;
+                const sinTheta = Math.sin(theta);
+                const cosTheta = Math.cos(theta);
+                const m = 1 / Math.sqrt(sinTheta * sinTheta + slope * slope + cosTheta * cosTheta);
+                vertices.push(radius * sinTheta, v * this._options.height, radius * cosTheta);
+                normals.push(sinTheta * m, slope * m, cosTheta * m);
+                uvs.push(u, 1 - v);
+                if (y < this._options.heightDetail && x < this._options.radialDetail) {
+                    this.addPatch(x, y, indices);
+                }
+            }
+        }
+        this.primitiveType = 'triangle-list';
+    }
+    /** @internal */ _create() {
+        const vertices = [];
+        const indices = [];
+        const normals = [];
+        const uvs = [];
+        this._createArrays(vertices, normals, uvs, indices);
+        this.createAndSetVertexBuffer('position_f32x3', new Float32Array(vertices));
+        this.createAndSetVertexBuffer('normal_f32x3', new Float32Array(normals));
+        this.createAndSetVertexBuffer('tex0_f32x2', new Float32Array(uvs));
+        this.createAndSetIndexBuffer(new Uint16Array(indices));
+        const radiusMax = Math.max(this._options.topRadius, this._options.bottomRadius);
+        this.setBoundingVolume(new BoundingBox(new Vector3(-radiusMax, 0, -radiusMax), new Vector3(radiusMax, this._options.height, radiusMax)));
+        this.indexCount = indices.length;
+        return true;
+    }
+}
+
+export { CylinderShape };
+//# sourceMappingURL=cylinder.js.map

package/dist/shapes/cylinder.js.map

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

package/dist/shapes/plane.js

@@ -0,0 +1,48 @@
+import { Vector3 } from '@zephyr3d/base';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Shape } from './shape.js';
+
+/**
+ * The plane shape
+ * @public
+ */ class PlaneShape extends Shape {
+    /**
+   * Creates an instance of plane shape
+   * @param options - The creation options
+   */ constructor(options){
+        super(options);
+    }
+    /** @internal */ createDefaultOptions() {
+        const options = super.createDefaultOptions();
+        options.size = 1;
+        return options;
+    }
+    /** @internal */ _createArrays(vertices, normals, uvs, indices, sizeX, sizeY) {
+        uvs?.push(0, 1, 0, 0, 1, 0, 1, 1);
+        vertices?.push(0, 0, sizeY, sizeX, 0, sizeY, sizeX, 0, 0, 0, 0, 0);
+        indices?.push(0, 1, 2, 0, 2, 3);
+        normals?.push(0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0);
+        this.primitiveType = 'triangle-list';
+    }
+    /** @internal */ _create() {
+        const needNormal = this._options.needNormal;
+        const needUV = this._options.needUV;
+        const sizeX = Math.abs(this._options.sizeX || this._options.size) || 1;
+        const sizeY = Math.abs(this._options.sizeY || this._options.size) || 1;
+        const vertices = [];
+        const indices = [];
+        const normals = needNormal ? [] : null;
+        const uvs = needUV ? [] : null;
+        this._createArrays(vertices, normals, uvs, indices, sizeX, sizeY);
+        this.createAndSetVertexBuffer('position_f32x3', new Float32Array(vertices));
+        normals && this.createAndSetVertexBuffer('normal_f32x3', new Float32Array(normals));
+        uvs && this.createAndSetVertexBuffer('tex0_f32x2', new Float32Array(uvs));
+        this.createAndSetIndexBuffer(new Uint16Array(indices));
+        this.setBoundingVolume(new BoundingBox(new Vector3(0, 0, 0), new Vector3(sizeX, 0, sizeY)));
+        this.indexCount = indices.length;
+        return true;
+    }
+}
+
+export { PlaneShape };
+//# sourceMappingURL=plane.js.map

package/dist/shapes/plane.js.map

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

package/dist/shapes/shape.js

@@ -0,0 +1,33 @@
+import { Primitive } from '../render/primitive.js';
+
+/**
+ * Abstract base class for any kind of shapes
+ * @public
+ */ class Shape extends Primitive {
+    /** @internal */ _options;
+    /**
+   * Creates an instance of shape
+   * @param options - The creation options
+   */ constructor(options){
+        super();
+        this._options = this.createDefaultOptions();
+        this.create(options);
+    }
+    /** @internal */ create(options) {
+        if (options) {
+            this._options = this.createDefaultOptions();
+            Object.assign(this._options, options);
+        }
+        return this._create();
+    }
+    /** @internal */ createDefaultOptions() {
+        return {
+            needNormal: true,
+            needTangent: false,
+            needUV: true
+        };
+    }
+}
+
+export { Shape };
+//# sourceMappingURL=shape.js.map

package/dist/shapes/shape.js.map

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

package/dist/shapes/sphere.js

@@ -0,0 +1,91 @@
+import { Vector3 } from '@zephyr3d/base';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Shape } from './shape.js';
+
+/**
+ * Sphere shape
+ * @public
+ */ class SphereShape extends Shape {
+    /**
+   * Creates an instance of sphere shape
+   * @param options - The creation options
+   */ constructor(options){
+        super(options);
+    }
+    /**
+   * {@inheritDoc Primitive.raycast}
+   * @override
+   */ raycast(ray) {
+        const rSquared = this._options.radius * this._options.radius;
+        const eSquared = Vector3.dot(ray.origin, ray.origin);
+        if (eSquared < rSquared) {
+            return null;
+        }
+        const a = -Vector3.dot(ray.origin, ray.direction);
+        const bSquared = eSquared - a * a;
+        if (rSquared < bSquared) {
+            return null;
+        }
+        return a - Math.sqrt(rSquared - bSquared);
+    }
+    /** @internal */ createDefaultOptions() {
+        const options = super.createDefaultOptions();
+        options.radius = 1;
+        options.verticalDetail = 20;
+        options.horizonalDetail = 20;
+        return options;
+    }
+    /** @internal */ _create() {
+        function getVertex(v, h, r) {
+            const y = r * Math.cos(v);
+            const hRadius = r * Math.sin(v);
+            const x = hRadius * Math.sin(h);
+            const z = hRadius * Math.cos(h);
+            return [
+                x,
+                y,
+                z
+            ];
+        }
+        const radius = this._options.radius ?? 1;
+        const verticalDetail = this._options.verticalDetail ?? 20;
+        const horizonalDetail = this._options.horizonalDetail ?? 20;
+        const vTheta = Math.PI / verticalDetail;
+        const hTheta = Math.PI * 2 / horizonalDetail;
+        const vertices = [];
+        const normals = [];
+        const uv = [];
+        const indices = [];
+        for(let i = 0; i <= verticalDetail; i++){
+            for(let j = 0; j <= horizonalDetail; j++){
+                const v = getVertex(i * vTheta, j * hTheta, radius);
+                vertices.push(...v);
+                if (this._options.needUV) {
+                    uv.push(j / horizonalDetail, i / verticalDetail);
+                }
+                if (this._options.needNormal) {
+                    normals.push(v[0] / radius, v[1] / radius, v[2] / radius);
+                }
+            }
+        }
+        for(let i = 0; i < verticalDetail; i++){
+            for(let j = 0; j <= horizonalDetail; j++){
+                const startIndex = i * (horizonalDetail + 1);
+                indices.push(startIndex + j, startIndex + j + horizonalDetail + 1);
+            }
+            indices.push(indices[indices.length - 1]);
+            indices.push((i + 1) * (horizonalDetail + 1));
+        }
+        this.createAndSetVertexBuffer('position_f32x3', new Float32Array(vertices));
+        normals?.length > 0 && this.createAndSetVertexBuffer('normal_f32x3', new Float32Array(normals));
+        uv?.length > 0 && this.createAndSetVertexBuffer('tex0_f32x2', new Float32Array(uv));
+        this.createAndSetIndexBuffer(new Uint32Array(indices));
+        this.setBoundingVolume(new BoundingBox(new Vector3(-radius, -radius, -radius), new Vector3(radius, radius, radius)));
+        this.primitiveType = 'triangle-strip';
+        this.indexCount = indices.length;
+        return true;
+    }
+}
+
+export { SphereShape };
+//# sourceMappingURL=sphere.js.map

package/dist/shapes/sphere.js.map

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

package/dist/shapes/torus.js

@@ -0,0 +1,100 @@
+import { Vector3 } from '@zephyr3d/base';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Shape } from './shape.js';
+
+/*
+N slices
+M sides
+OR outter radius
+IR  inner radius
+Up (0, 1, 0)
+
+C(n) = (cos((n/N) * TwoPI) * OR, 0, sin((n/N) * twoPI * OR);
+Theta = m/M * TwoPI
+V(n, m) = C(n) * (1 + IR * cos(Theta) / OR) + Up * IR * sin(Theta)
+N(n, m) = normalize(V(n, m) - C(n))
+TC(n, m) = (m / M, n / N)
+
+VIndex(n, m) = n * (M + 1) + m
+Triangle(n, m) = (VIndex(n, m), VIndex(n+1, m), VIndex(n+1, m+1), VIndex(n, m), VIndex(n+1, m+1), VIndex(n, m+1))*/ /**
+ * 
+ * Torus shape
+ * 
+ * @public
+ */ class TorusShape extends Shape {
+    /**
+   * Creates an instance of torus shape
+   * @param options - The creation options
+   */ constructor(options){
+        super(options);
+    }
+    /** @internal */ createDefaultOptions() {
+        const options = super.createDefaultOptions();
+        options.numSlices = 40;
+        options.numSegments = 16;
+        options.outerRadius = 10;
+        options.innerRadius = 3;
+        options.radialDetail = 20;
+        return options;
+    }
+    /** @internal */ _createArrays(vertices, normals, uvs, indices) {
+        this.primitiveType = 'triangle-list';
+        const N = this._options.numSlices;
+        const M = this._options.numSegments;
+        const OR = this._options.outerRadius;
+        const IR = this._options.innerRadius;
+        for(let n = 0; n <= N; n++){
+            const alpha = n % N / N * Math.PI * 2;
+            const cx = OR * Math.cos(alpha);
+            const cy = 0;
+            const cz = OR * Math.sin(alpha);
+            for(let m = 0; m <= M; m++){
+                const theta = m % M / M * Math.PI * 2;
+                const idx = n * (M + 1) + m;
+                const t = 1 + IR * Math.cos(theta) / OR;
+                const s = IR * Math.sin(theta);
+                vertices[idx * 3 + 0] = cx * t;
+                vertices[idx * 3 + 1] = cy * t + s;
+                vertices[idx * 3 + 2] = cz * t;
+                const nx = vertices[idx * 3 + 0] - cx;
+                const ny = vertices[idx * 3 + 1] - cy;
+                const nz = vertices[idx * 3 + 2] - cz;
+                const mag = Math.sqrt(nx * nx + ny * ny + nz * nz);
+                normals[idx * 3 + 0] = nx / mag;
+                normals[idx * 3 + 1] = ny / mag;
+                normals[idx * 3 + 2] = nz / mag;
+                uvs[idx * 2 + 0] = m / M;
+                uvs[idx * 2 + 1] = n / N;
+            }
+        }
+        for(let n = 0; n < N; n++){
+            for(let m = 0; m < M; m++){
+                indices.push(n * (M + 1) + m);
+                indices.push((n + 1) * (M + 1) + m + 1);
+                indices.push((n + 1) * (M + 1) + m);
+                indices.push(n * (M + 1) + m);
+                indices.push(n * (M + 1) + m + 1);
+                indices.push((n + 1) * (M + 1) + m + 1);
+            }
+        }
+    }
+    /** @internal */ _create() {
+        const vertices = [];
+        const indices = [];
+        const normals = [];
+        const uvs = [];
+        this._createArrays(vertices, normals, uvs, indices);
+        this.createAndSetVertexBuffer('position_f32x3', new Float32Array(vertices));
+        this.createAndSetVertexBuffer('normal_f32x3', new Float32Array(normals));
+        this.createAndSetVertexBuffer('tex0_f32x2', new Float32Array(uvs));
+        this.createAndSetIndexBuffer(new Uint16Array(indices));
+        const radiusX = this._options.outerRadius + this._options.innerRadius;
+        const radiusY = this._options.innerRadius;
+        this.setBoundingVolume(new BoundingBox(new Vector3(-radiusX, -radiusY, -radiusX), new Vector3(radiusX, radiusY, radiusX)));
+        this.indexCount = indices.length;
+        return true;
+    }
+}
+
+export { TorusShape };
+//# sourceMappingURL=torus.js.map

package/dist/shapes/torus.js.map

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