@zephyr3d/scene 0.1.0

package/dist/utility/aabbtree.js

@@ -0,0 +1,390 @@
+import { Vector3, AABB } from '@zephyr3d/base';
+
+const tmpTriangle = [
+    0,
+    0,
+    0
+];
+/**
+ * Axis-Aligned Bounding Box Tree
+ * @public
+ */ class AABBTree {
+    /** @internal */ _primitivesInfo;
+    /** @internal */ _nodes;
+    constructor(other){
+        this._primitivesInfo = null;
+        this._nodes = null;
+        if (other) {
+            this._primitivesInfo = other._primitivesInfo ? {
+                vertices: other._primitivesInfo.vertices?.map((value)=>new Vector3(value)),
+                indices: other._primitivesInfo.indices?.map((value)=>value),
+                primitiveType: other._primitivesInfo.primitiveType
+            } : null;
+            this._nodes = other._nodes ? other._nodes.map((value)=>{
+                return {
+                    box: new AABB(value.box),
+                    triangles: value.triangles?.map((val)=>val),
+                    axis: value.axis,
+                    left: value.left,
+                    right: value.right
+                };
+            }) : null;
+        }
+    }
+    /**
+   * Build the AABB tree from a polygon soup
+   * @param vertices - Vertices of the polygon soup
+   * @param indices - indices of the polygon soup
+   * @param primitiveType - Prmitive type of the polygon soup
+   */ buildFromPrimitives(vertices, indices, primitiveType) {
+        this._primitivesInfo = {
+            vertices: [],
+            indices: null,
+            primitiveType: primitiveType
+        };
+        for(let i = 0; i < vertices.length; i += 3){
+            this._primitivesInfo.vertices.push(new Vector3(vertices[i], vertices[i + 1], vertices[i + 2]));
+        }
+        if (indices) {
+            this._primitivesInfo.indices = [];
+            for (const index of indices){
+                this._primitivesInfo.indices.push(index);
+            }
+        }
+        this._buildSubNodes();
+    }
+    /**
+   * Checks for intersection between a ray and the AABB tree without calculating the intersection point
+   * @param ray - The ray being traced
+   * @returns true if the ray hits the AABB tree, false otherwise
+   */ rayIntersectionTest(ray) {
+        return this._nodes.length > 0 ? this._rayIntersectionTest(0, ray) : false;
+    }
+    /**
+   * Checks for intersection between a ray and the AABB tree
+   * @param ray - The ray being traced
+   * @returns The distance between the ray origin and the hit point if the ray hits the AABB tree, null otherwise
+   */ rayIntersectionDistance(ray) {
+        return this._nodes.length > 0 ? this._rayIntersectionDistance(0, ray) : null;
+    }
+    /**
+   * Gets the top level bounding box of the tree
+   * @returns The top level bounding box
+   */ getTopLevelAABB() {
+        return this._nodes.length > 0 ? this._nodes[0].box : null;
+    }
+    /**
+   * Transform the tree by a matrix
+   * @param matrix - The transform matrix
+   */ transform(matrix) {
+        if (matrix && this._primitivesInfo && this._primitivesInfo.vertices) {
+            for (const vert of this._primitivesInfo.vertices){
+                matrix.transformPointAffine(vert, vert);
+            }
+            this._buildSubNodes();
+        }
+    }
+    /** @internal */ verify() {
+        const numTris = this._verifyNode(0);
+        const n = this._getNumTriangles();
+        if (numTris !== n) {
+            throw new Error(`AABB tree verification failed: triangle count mismatch, got ${numTris}, expect ${n}`);
+        }
+    }
+    /** @internal */ _verifyNode(nodeIndex) {
+        const node = this._nodes[nodeIndex];
+        if (!node) {
+            throw new Error(`AABB tree verification failed: invalid node index: ${nodeIndex}`);
+        }
+        let numTris = 0;
+        const extents = node.box.extents[node.axis];
+        const tmpTri = [
+            0,
+            0,
+            0
+        ];
+        for (const tri of node.triangles){
+            this._getTriangle(tri, tmpTri);
+            let max = Number.MIN_VALUE;
+            let min = Number.MAX_VALUE;
+            for (const v of tmpTri){
+                const p = this._primitivesInfo.vertices[v];
+                if (!node.box.containsPoint(p)) {
+                    throw new Error(`AABB tree verification failed: triangle not inside AABB`);
+                }
+                const t = p[node.axis];
+                if (t < min) min = t;
+                if (t > max) max = t;
+                if (max - min <= extents) {
+                    throw new Error(`AABB tree verification failed: extents test failed`);
+                }
+            }
+        }
+        numTris += node.triangles.length;
+        if (node.left >= 0) {
+            numTris += this._verifyNode(node.left);
+        }
+        if (node.right >= 0) {
+            numTris += this._verifyNode(node.right);
+        }
+        return numTris;
+    }
+    /** @internal */ _buildNode(nodeIndex, triangles, triangleMin, triangleMax) {
+        const node = this._nodes[nodeIndex];
+        if (triangles.length === 1) {
+            node.triangles.push(triangles[0]);
+        } else {
+            const splitAxis = node.axis = this._selectBestSplitAxis(node.box.extents, triangles, triangleMin, triangleMax);
+            const sizeMax = node.box.extents[splitAxis];
+            const sizeCenter = node.box.center[splitAxis];
+            const sizeLeft = sizeCenter - node.box.extents[splitAxis] * 0.5;
+            const leftTriangles = [];
+            const rightTriangles = [];
+            const leftbox = new AABB();
+            leftbox.beginExtend();
+            const rightbox = new AABB();
+            rightbox.beginExtend();
+            for (const tri of triangles){
+                const min = triangleMin[tri];
+                const max = triangleMax[tri];
+                const size = max[splitAxis] - min[splitAxis];
+                if (size >= sizeMax) {
+                    node.triangles.push(tri);
+                } else if (max[splitAxis] <= sizeCenter || min[splitAxis] <= sizeLeft) {
+                    leftTriangles.push(tri);
+                    leftbox.extend3(min[0], min[1], min[2]);
+                    leftbox.extend3(max[0], max[1], max[2]);
+                } else {
+                    rightTriangles.push(tri);
+                    rightbox.extend3(min[0], min[1], min[2]);
+                    rightbox.extend3(max[0], max[1], max[2]);
+                }
+            }
+            if (leftTriangles.length) {
+                this._nodes.push({
+                    box: leftbox,
+                    triangles: [],
+                    axis: -1,
+                    left: -1,
+                    right: -1
+                });
+                node.left = this._nodes.length - 1;
+                this._buildNode(this._nodes.length - 1, leftTriangles, triangleMin, triangleMax);
+            }
+            if (rightTriangles.length) {
+                this._nodes.push({
+                    box: rightbox,
+                    triangles: [],
+                    axis: -1,
+                    left: -1,
+                    right: -1
+                });
+                node.right = this._nodes.length - 1;
+                this._buildNode(this._nodes.length - 1, rightTriangles, triangleMin, triangleMax);
+            }
+        }
+    }
+    /** @internal */ _selectBestSplitAxis(extents, triangles, triangleMin, triangleMax) {
+        const dx = extents.x, dy = extents.y, dz = extents.z;
+        let nx = 0, ny = 0, nz = 0;
+        for (const tri of triangles){
+            const max = triangleMax[tri];
+            const min = triangleMin[tri];
+            if (max[0] - min[0] >= dx) nx++;
+            if (max[1] - min[1] >= dy) ny++;
+            if (max[2] - min[2] >= dz) nz++;
+        }
+        if (nx < ny) {
+            if (nx < nz) {
+                return 0;
+            } else {
+                return nx === nz ? dx > dz ? 0 : 2 : 2;
+            }
+        } else if (nx == ny) {
+            if (nz < nx) {
+                return 2;
+            } else if (nz > nx) {
+                return dx > dy ? 0 : 1;
+            } else {
+                if (dx < dy) {
+                    return dy > dz ? 1 : 2;
+                } else {
+                    return dx > dz ? 0 : 2;
+                }
+            }
+        } else {
+            if (ny < nz) {
+                return 1;
+            } else {
+                return ny === nz ? dy > dz ? 1 : 2 : 2;
+            }
+        }
+    }
+    /** @internal */ _getNumTriangles() {
+        const numIndices = this._primitivesInfo.indices ? this._primitivesInfo.indices.length : this._primitivesInfo.vertices.length;
+        switch(this._primitivesInfo.primitiveType){
+            case 'triangle-list':
+                return Math.floor(numIndices / 3);
+            case 'triangle-strip':
+                return numIndices - 2;
+            case 'triangle-fan':
+                return numIndices - 2;
+            default:
+                return 0;
+        }
+    }
+    /** @internal */ _rayIntersectionDistance(nodeIndex, ray) {
+        const node = this._nodes[nodeIndex];
+        if (!ray.bboxIntersectionTest(node.box)) {
+            return null;
+        }
+        let minDist = Number.MAX_VALUE;
+        for (const tri of node.triangles){
+            this._getTriangle(tri, tmpTriangle);
+            const v0 = this._primitivesInfo.vertices[tmpTriangle[0]];
+            const v1 = this._primitivesInfo.vertices[tmpTriangle[1]];
+            const v2 = this._primitivesInfo.vertices[tmpTriangle[2]];
+            const dist = ray.intersectionTestTriangle(v0, v1, v2, false);
+            if (dist !== null && dist >= 0 && dist < minDist) {
+                minDist = dist;
+            }
+        }
+        let a, b;
+        if (node.axis >= 0) {
+            if (ray.direction[node.axis] < 0) {
+                a = node.right;
+                b = node.left;
+            } else {
+                a = node.left;
+                b = node.right;
+            }
+            if (a >= 0) {
+                const dist = this._rayIntersectionDistance(a, ray);
+                if (dist !== null && dist >= 0 && dist < minDist) {
+                    minDist = dist;
+                }
+            }
+            if (b >= 0) {
+                const dist = this._rayIntersectionDistance(b, ray);
+                if (dist !== null && dist >= 0 && dist < minDist) {
+                    minDist = dist;
+                }
+            }
+        }
+        return minDist === Number.MAX_VALUE ? null : minDist;
+    }
+    /** @internal */ _rayIntersectionTest(nodeIndex, ray) {
+        const node = this._nodes[nodeIndex];
+        if (!ray.bboxIntersectionTest(node.box)) {
+            return false;
+        }
+        for (const tri of node.triangles){
+            this._getTriangle(tri, tmpTriangle);
+            const v0 = this._primitivesInfo.vertices[tmpTriangle[0]];
+            const v1 = this._primitivesInfo.vertices[tmpTriangle[1]];
+            const v2 = this._primitivesInfo.vertices[tmpTriangle[2]];
+            const dist = ray.intersectionTestTriangle(v0, v1, v2, false);
+            if (dist !== null && dist > 0) {
+                return true;
+            }
+        }
+        let a, b;
+        if (node.axis >= 0) {
+            if (ray.direction[node.axis] < 0) {
+                a = node.right;
+                b = node.left;
+            } else {
+                a = node.left;
+                b = node.right;
+            }
+            if (a >= 0 && this._rayIntersectionTest(a, ray)) {
+                return true;
+            }
+            if (b >= 0 && this._rayIntersectionTest(b, ray)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal */ _getTriangle(n, out) {
+        const indices = this._primitivesInfo.indices;
+        let v0, v1, v2;
+        out = out || [
+            0,
+            0,
+            0
+        ];
+        switch(this._primitivesInfo.primitiveType){
+            case 'triangle-list':
+                v0 = n * 3;
+                v1 = v0 + 1;
+                v2 = v0 + 2;
+                break;
+            case 'triangle-strip':
+                {
+                    const r = n % 2;
+                    v0 = n + r;
+                    v1 = n - r + 1;
+                    v2 = n + 2;
+                    break;
+                }
+            case 'triangle-fan':
+                v0 = 0;
+                v1 = n + 1;
+                v2 = n + 2;
+                break;
+            default:
+                return null;
+        }
+        out[0] = indices ? indices[v0] : v0;
+        out[1] = indices ? indices[v1] : v1;
+        out[2] = indices ? indices[v2] : v2;
+        return out;
+    }
+    /** @internal */ _buildSubNodes() {
+        const triangleMin = [];
+        const triangleMax = [];
+        const triangles = [];
+        const numTriangles = this._getNumTriangles();
+        const rootNode = {
+            box: new AABB(),
+            triangles: [],
+            axis: -1,
+            left: -1,
+            right: -1
+        };
+        rootNode.box.beginExtend();
+        for(let i = 0; i < numTriangles; i++){
+            triangles.push(i);
+            this._getTriangle(i, tmpTriangle);
+            const v0 = this._primitivesInfo.vertices[tmpTriangle[0]];
+            const v1 = this._primitivesInfo.vertices[tmpTriangle[1]];
+            const v2 = this._primitivesInfo.vertices[tmpTriangle[2]];
+            const min = [
+                Math.min(Math.min(v0.x, v1.x), v2.x),
+                Math.min(Math.min(v0.y, v1.y), v2.y),
+                Math.min(Math.min(v0.z, v1.z), v2.z)
+            ];
+            rootNode.box.extend3(min[0], min[1], min[2]);
+            triangleMin.push(min);
+            const max = [
+                Math.max(Math.max(v0.x, v1.x), v2.x),
+                Math.max(Math.max(v0.y, v1.y), v2.y),
+                Math.max(Math.max(v0.z, v1.z), v2.z)
+            ];
+            rootNode.box.extend3(max[0], max[1], max[2]);
+            triangleMax.push(max);
+        }
+        if (rootNode.box.isValid()) {
+            this._nodes = [
+                rootNode
+            ];
+            this._buildNode(0, triangles, triangleMin, triangleMax);
+        } else {
+            this._nodes = [];
+        }
+    }
+}
+
+export { AABBTree };
+//# sourceMappingURL=aabbtree.js.map

package/dist/utility/aabbtree.js.map

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

package/dist/utility/bounding_volume.js

@@ -0,0 +1,78 @@
+import { AABB, Frustum, ClipState } from '@zephyr3d/base';
+import { AABBTree } from './aabbtree.js';
+
+/**
+ * The bounding box class
+ * @public
+ */ class BoundingBox extends AABB {
+    constructor(arg0, arg1){
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        super(arg0, arg1);
+    }
+    /** {@inheritDoc BoundingVolume.clone} */ clone() {
+        return new BoundingBox(this);
+    }
+    /** {@inheritDoc BoundingVolume.transform} */ transform(matrix) {
+        return new BoundingBox(AABB.transform(this, matrix));
+    }
+    /** {@inheritDoc BoundingVolume.outsideFrustum} */ outsideFrustum(frustum) {
+        return (frustum instanceof Frustum ? this.getClipStateWithFrustum(frustum) : this.getClipState(frustum)) === ClipState.NOT_CLIPPED;
+    }
+    /** {@inheritDoc BoundingVolume.toAABB} */ toAABB() {
+        return this;
+    }
+}
+/**
+ * Bounding box tree
+ * @public
+ */ class BoundingBoxTree extends AABBTree {
+    constructor(arg){
+        super(arg);
+    }
+    /** {@inheritDoc BoundingVolume.clone} */ clone() {
+        return new BoundingBoxTree(this);
+    }
+    /** {@inheritDoc BoundingVolume.transform} */ transform(matrix) {
+        const newBV = new BoundingBoxTree(this);
+        newBV.transform(matrix);
+        return newBV;
+    }
+    /** {@inheritDoc BoundingVolume.behindPlane} */ behindPlane(plane) {
+        return this.toAABB().behindPlane(plane);
+    }
+    /** {@inheritDoc BoundingVolume.outsideFrustum} */ outsideFrustum(frustum) {
+        const aabb = this.getTopLevelAABB();
+        if (aabb) {
+            return (frustum instanceof Frustum ? aabb.getClipStateWithFrustum(frustum) : aabb.getClipState(frustum)) === ClipState.NOT_CLIPPED;
+        } else {
+            return false;
+        }
+    }
+    /** {@inheritDoc BoundingVolume.toAABB} */ toAABB() {
+        return this.getTopLevelAABB();
+    }
+} /*
+export class BoundingFrustum implements BoundingVolume {
+    protected _frustum: Frustum;
+    constructor ();
+    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
+    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
+        if (arg0 instanceof BoundingFrustum) {
+            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
+        } else if (arg0 instanceof Frustum) {
+            this._frustum = new Frustum (arg0);
+        } else if (arg0 instanceof Matrix4x4) {
+            this._frustum = new Frustum (arg0);
+        } else {
+            this._frustum = null;
+        }
+    }
+    clone (): BoundingVolume {
+        return new BoundingFrustum (this);
+    }
+    transform (matrix: Matrix4x4)
+}
+*/
+
+export { BoundingBox, BoundingBoxTree };
+//# sourceMappingURL=bounding_volume.js.map

package/dist/utility/bounding_volume.js.map

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

package/dist/utility/panorama.js

@@ -0,0 +1,163 @@
+import { Vector3 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+import { gammaToLinear } from '../shaders/misc.js';
+
+let vertexLayout = null;
+let renderStates = null;
+let panoramaToCubemapProgram = null;
+let panoramaToCubemapBindGroup = null;
+let panoramaToCubemapProgramRGBM = null;
+let panoramaToCubemapBindGroupRGBM = null;
+const faceDirections = [
+    [
+        new Vector3(0, 0, -1),
+        new Vector3(0, -1, 0),
+        new Vector3(1, 0, 0)
+    ],
+    [
+        new Vector3(0, 0, 1),
+        new Vector3(0, -1, 0),
+        new Vector3(-1, 0, 0)
+    ],
+    [
+        new Vector3(1, 0, 0),
+        new Vector3(0, 0, 1),
+        new Vector3(0, 1, 0)
+    ],
+    [
+        new Vector3(1, 0, 0),
+        new Vector3(0, 0, -1),
+        new Vector3(0, -1, 0)
+    ],
+    [
+        new Vector3(1, 0, 0),
+        new Vector3(0, -1, 0),
+        new Vector3(0, 0, 1)
+    ],
+    [
+        new Vector3(-1, 0, 0),
+        new Vector3(0, -1, 0),
+        new Vector3(0, 0, -1)
+    ]
+];
+function init() {
+    const device = Application.instance.device;
+    const vertices = new Float32Array([
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        1,
+        -1
+    ]);
+    const indices = new Uint16Array([
+        0,
+        1,
+        2,
+        0,
+        2,
+        3
+    ]);
+    vertexLayout = device.createVertexLayout({
+        vertexBuffers: [
+            {
+                buffer: device.createVertexBuffer('position_f32x2', vertices)
+            }
+        ],
+        indexBuffer: device.createIndexBuffer(indices)
+    });
+    renderStates = device.createRenderStateSet();
+    renderStates.useRasterizerState().setCullMode('none');
+    renderStates.useDepthState().enableTest(false).enableWrite(false);
+    panoramaToCubemapProgram = createPanoramaToCubemapProgram(false);
+    panoramaToCubemapBindGroup = device.createBindGroup(panoramaToCubemapProgram.bindGroupLayouts[0]);
+    panoramaToCubemapProgramRGBM = createPanoramaToCubemapProgram(true);
+    panoramaToCubemapBindGroupRGBM = device.createBindGroup(panoramaToCubemapProgramRGBM.bindGroupLayouts[0]);
+}
+function createPanoramaToCubemapProgram(rgbm) {
+    const device = Application.instance.device;
+    const pb = device;
+    return pb.buildRenderProgram({
+        vertex (pb) {
+            this.$inputs.pos = pb.vec2().attrib('position');
+            this.up = pb.vec3().uniform(0);
+            this.right = pb.vec3().uniform(0);
+            this.front = pb.vec3().uniform(0);
+            pb.main(function() {
+                this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                this.$outputs.direction = pb.mul(pb.mat3(this.up, this.right, this.front), pb.vec3(this.$inputs.pos, 1));
+                if (pb.getDevice().type === 'webgpu') {
+                    this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                }
+            });
+        },
+        fragment (pb) {
+            this.u_panoramaTexture = pb.tex2D().uniform(0);
+            this.$outputs.outcolor = pb.vec4();
+            pb.func('dirToUV', [
+                pb.vec3('dir')
+            ], function() {
+                this.$l.x = pb.add(0.5, pb.div(pb.atan2(this.dir.z, this.dir.x), 2 * Math.PI));
+                this.$l.y = pb.div(pb.acos(this.dir.y), Math.PI);
+                this.$return(pb.vec2(this.x, this.y));
+            });
+            pb.main(function() {
+                this.$l.uv = this.dirToUV(pb.normalize(this.$inputs.direction));
+                this.$l.color = pb.textureSampleLevel(this.u_panoramaTexture, this.uv, 0);
+                if (rgbm) {
+                    this.$l.rgb = pb.mul(this.color.rgb, this.color.a, 6);
+                    this.rgb = gammaToLinear(this, this.rgb);
+                    this.$outputs.outcolor = pb.vec4(this.rgb, 1);
+                } else {
+                    this.$outputs.outcolor = pb.vec4(this.color.rgb, 1);
+                }
+            });
+        }
+    });
+}
+function doConvertPanoramaToCubemap(srcTexture, dstTexture) {
+    const device = Application.instance.device;
+    const rgbm = srcTexture.format === 'rgba8unorm';
+    const program = rgbm ? panoramaToCubemapProgramRGBM : panoramaToCubemapProgram;
+    const bindgroup = rgbm ? panoramaToCubemapBindGroupRGBM : panoramaToCubemapBindGroup;
+    const framebuffer = device.createFrameBuffer([
+        dstTexture
+    ], null);
+    device.pushDeviceStates();
+    device.setFramebuffer(framebuffer);
+    for(let i = 0; i < 6; i++){
+        framebuffer.setColorAttachmentCubeFace(0, i);
+        device.setVertexLayout(vertexLayout);
+        device.setRenderStates(renderStates);
+        device.setProgram(program);
+        device.setBindGroup(0, bindgroup);
+        bindgroup.setValue('up', faceDirections[i][0]);
+        bindgroup.setValue('right', faceDirections[i][1]);
+        bindgroup.setValue('front', faceDirections[i][2]);
+        bindgroup.setTexture('u_panoramaTexture', srcTexture);
+        device.draw('triangle-list', 0, 6);
+    }
+    device.popDeviceStates();
+}
+/**
+ * Converts an equirectangular image to cubemap
+ *
+ * @param tex - The equirectangular image to be converted
+ * @param textureSize - cubemap size
+ * @returns The converted cubemap
+ *
+ * @public
+ */ function panoramaToCubemap(tex, outputCubeMap) {
+    const device = Application.instance.device;
+    if (!vertexLayout) {
+        init();
+    }
+    device.pushDeviceStates();
+    doConvertPanoramaToCubemap(tex, outputCubeMap);
+    device.popDeviceStates();
+}
+
+export { panoramaToCubemap };
+//# sourceMappingURL=panorama.js.map

package/dist/utility/panorama.js.map

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