@zephyr3d/scene 0.5.0 → 0.6.1

package/dist/posteffect/water.js.map

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

package/dist/render/abuffer_oit.js

@@ -5,13 +5,14 @@ import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
 import '@zephyr3d/device';
+import '../values.js';
+import '../app.js';
 import '../material/meshmaterial.js';
 import '../material/grassmaterial.js';
 import '../material/terrainmaterial.js';
 import '../material/pbrmr.js';
 import '../material/pbrsg.js';
 import '@zephyr3d/base';
-import '../app.js';
 
 /**
  * per-pixel linked list OIT renderer using ABuffer.
@@ -342,7 +343,6 @@ import '../app.js';
             stencilStates.setBackOp('keep', 'keep', 'replace');
             stencilStates.setReference(0);
             stencilStates.setReadMask(0xff);
-            console.log(this._compositeProgram.getShaderSource('fragment'));
         }
         return this._compositeProgram;
     }

package/dist/render/clipmap.js

@@ -1,8 +1,7 @@
-import { AABB, Vector2, Matrix4x4, Vector3, ClipState } from '@zephyr3d/base';
+import { AABB, Matrix4x4, Vector3, ClipState, Vector2 } from '@zephyr3d/base';
 import { Primitive } from './primitive.js';
 
 const tmpAABB = new AABB();
-const tmpExtents = new Vector2(0, 0);
 const modelMatrices = [
     Matrix4x4.identity(),
     // rotation z 270
@@ -358,37 +357,35 @@ const modelMatrices = [
     intervalsOverlap(a0, a1, b0, b1) {
         return a0 <= b1 && b0 <= a1;
     }
-    visible(aabb, camera, modelMatrix, offset, scale, AABBExtents, gridScale) {
+    visible(ctx, aabb, camera, modelMatrix, offset, scale, gridScale) {
         if (!modelMatrix) {
             tmpAABB.minPoint.set(aabb.minPoint);
             tmpAABB.maxPoint.set(aabb.maxPoint);
         } else {
             AABB.transform(aabb, modelMatrix, tmpAABB);
         }
-        tmpAABB.minPoint.x = (tmpAABB.minPoint.x * scale + offset.x) * gridScale - AABBExtents.x;
-        tmpAABB.minPoint.z = (tmpAABB.minPoint.y * scale + offset.y) * gridScale - AABBExtents.x;
-        tmpAABB.minPoint.y = -AABBExtents.y;
-        tmpAABB.maxPoint.x = (tmpAABB.maxPoint.x * scale + offset.x) * gridScale + AABBExtents.x;
-        tmpAABB.maxPoint.z = (tmpAABB.maxPoint.y * scale + offset.y) * gridScale + AABBExtents.x;
-        tmpAABB.maxPoint.y = AABBExtents.y;
+        const minX = (tmpAABB.minPoint.x * scale + offset.x) * gridScale;
+        const maxX = (tmpAABB.maxPoint.x * scale + offset.x) * gridScale;
+        const minZ = (tmpAABB.minPoint.y * scale + offset.y) * gridScale;
+        const maxZ = (tmpAABB.maxPoint.y * scale + offset.y) * gridScale;
+        ctx.calcAABB(ctx.userData, minX, maxX, minZ, maxZ, tmpAABB);
         return tmpAABB.getClipStateWithFrustum(camera.frustum) !== ClipState.NOT_CLIPPED;
     }
     draw(context, numMipmaps) {
         let drawn = 0;
-        const distX = Math.max(Math.abs(context.position.x - context.minWorldPos.x), Math.abs(context.position.x - context.maxWorldPos.x));
-        const distY = Math.max(Math.abs(context.position.y - context.minWorldPos.y), Math.abs(context.position.y - context.maxWorldPos.y));
+        const distX = Math.max(Math.abs(context.position.x - context.minMaxWorldPos.x), Math.abs(context.position.x - context.minMaxWorldPos.z));
+        const distY = Math.max(Math.abs(context.position.y - context.minMaxWorldPos.y), Math.abs(context.position.y - context.minMaxWorldPos.w));
         const maxDist = Math.min(Math.max(distX, distY), context.camera.getFarPlane());
-        const mipLevels = Math.ceil(Math.log2(maxDist / (this._tileResolution * context.gridScale))) + 1;
+        const mipLevels = Math.max(Math.ceil(Math.log2(maxDist / (this._tileResolution * context.gridScale))), 0) + 1;
         const snappedPos = new Vector2();
         const tileSize = new Vector2();
         const base = new Vector2();
         const offset = new Vector2();
         const posX = context.position.x / context.gridScale;
         const posY = context.position.y / context.gridScale;
-        const h = context.AABBExtents ?? tmpExtents;
         // draw cross
         snappedPos.setXY(Math.floor(posX), Math.floor(posY));
-        if (this.visible(this._crossMeshAABB, context.camera, null, snappedPos, 1, h, context.gridScale)) {
+        if (this.visible(context, this._crossMeshAABB, context.camera, null, snappedPos, 1, context.gridScale)) {
             context.drawPrimitive(this._crossMesh, modelMatrices[0], snappedPos, 1, context.gridScale);
             drawn++;
         }
@@ -406,8 +403,8 @@ const modelMatrices = [
                     const fillX = x >= 2 ? scale : 0;
                     const fillY = y >= 2 ? scale : 0;
                     offset.setXY(base.x + x * tileSize.x + fillX, base.y + y * tileSize.y + fillY);
-                    if (this.intervalsOverlap(offset.x * context.gridScale, (offset.x + tileSize.x) * context.gridScale, context.minWorldPos.x, context.maxWorldPos.x) && this.intervalsOverlap(offset.y * context.gridScale, (offset.y + tileSize.y) * context.gridScale, context.minWorldPos.y, context.maxWorldPos.y)) {
-                        if (this.visible(this._tileMeshBBox, context.camera, null, offset, scale, h, context.gridScale)) {
+                    if (this.intervalsOverlap(offset.x * context.gridScale, (offset.x + tileSize.x) * context.gridScale, context.minMaxWorldPos.x, context.minMaxWorldPos.z) && this.intervalsOverlap(offset.y * context.gridScale, (offset.y + tileSize.y) * context.gridScale, context.minMaxWorldPos.y, context.minMaxWorldPos.w)) {
+                        if (this.visible(context, this._tileMeshBBox, context.camera, null, offset, scale, context.gridScale)) {
                             context.drawPrimitive(this._tileMesh, modelMatrices[0], offset, scale, context.gridScale);
                             drawn++;
                         }
@@ -415,7 +412,7 @@ const modelMatrices = [
                 }
             }
             // draw filler
-            if (this.visible(this._fillerMeshAABB, context.camera, null, snappedPos, scale, h, context.gridScale)) {
+            if (this.visible(context, this._fillerMeshAABB, context.camera, null, snappedPos, scale, context.gridScale)) {
                 context.drawPrimitive(this._fillerMesh, modelMatrices[0], snappedPos, scale, context.gridScale);
                 drawn++;
             }
@@ -428,13 +425,13 @@ const modelMatrices = [
                 let r = 0;
                 r |= d.x >= scale ? 0 : 2;
                 r |= d.y >= scale ? 0 : 1;
-                if (this.visible(this._trimMeshAABB, context.camera, r === 0 ? null : modelMatrices[r], tileCentre, scale, h, context.gridScale)) {
+                if (this.visible(context, this._trimMeshAABB, context.camera, r === 0 ? null : modelMatrices[r], tileCentre, scale, context.gridScale)) {
                     context.drawPrimitive(this._trimMesh, modelMatrices[r], tileCentre, scale, context.gridScale);
                     drawn++;
                 }
                 // draw seam
                 const nextBase = new Vector2(nextSnappedPos.x - (this._tileResolution << l + 1), nextSnappedPos.y - (this._tileResolution << l + 1));
-                if (this.visible(this._seamMeshAABB, context.camera, null, nextBase, scale, h, context.gridScale)) {
+                if (this.visible(context, this._seamMeshAABB, context.camera, null, nextBase, scale, context.gridScale)) {
                     context.drawPrimitive(this._seamMesh, modelMatrices[0], nextBase, scale, context.gridScale);
                     drawn++;
                 }

package/dist/render/clipmap.js.map

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

package/dist/render/cull_visitor.js

@@ -94,9 +94,11 @@ import { RENDER_PASS_TYPE_SHADOWMAP } from '../values.js';
     }
     /** @internal */ visitBatchGroup(node) {
         if (!node.hidden) {
-            const renderQueue = node.getRenderQueue(this);
-            this.pushRenderQueue(renderQueue);
-            return true;
+            const clipState = this.getClipStateWithNode(node);
+            if (clipState !== ClipState.NOT_CLIPPED) {
+                node.cull(this);
+                return true;
+            }
         }
         return false;
     }

package/dist/render/cull_visitor.js.map

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

package/dist/render/depthpass.js

@@ -9,13 +9,29 @@ import { ShaderHelper } from '../material/shader/helper.js';
  *
  * @public
  */ class DepthPass extends RenderPass {
+    _renderBackface;
+    _encodeDepth;
     /**
    * Creates an instance of DepthRenderPass
    */ constructor(){
         super(RENDER_PASS_TYPE_DEPTH);
+        this._renderBackface = false;
+        this._encodeDepth = false;
+    }
+    get renderBackface() {
+        return this._renderBackface;
+    }
+    set renderBackface(val) {
+        this._renderBackface = !!val;
+    }
+    get encodeDepth() {
+        return this._encodeDepth;
+    }
+    set encodeDepth(val) {
+        this._encodeDepth = !!val;
     }
     /** @internal */ _getGlobalBindGroupHash(ctx) {
-        return '';
+        return `${Number(this._renderBackface)}:${Number(this._encodeDepth)}`;
     }
     /** @internal */ renderItems(ctx, renderQueue) {
         const items = renderQueue.itemList;

package/dist/render/depthpass.js.map

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

package/dist/render/drawable_mixin.js

@@ -1,17 +1,20 @@
 import { Vector4 } from '@zephyr3d/base';
-import { ProgramBuilder } from '@zephyr3d/device';
 import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
+import '@zephyr3d/device';
+import { MaterialVaryingFlags } from '../values.js';
+import { Application } from '../app.js';
 import '../material/meshmaterial.js';
 import '../material/grassmaterial.js';
 import '../material/terrainmaterial.js';
 import '../material/pbrmr.js';
 import '../material/pbrsg.js';
-import { Application } from '../app.js';
 
 let _drawableId = 0;
+const instanceBindGroupTransfromTags = new WeakMap();
+const drawableBindGroupTransfromTags = new WeakMap();
 function mixinDrawable(baseCls) {
     const cls = class extends baseCls {
         _mdRenderQueueRef;
@@ -75,11 +78,23 @@ function mixinDrawable(baseCls) {
         }
         applyTransformUniforms(renderQueue) {
             const instanceInfo = renderQueue.getInstanceInfo(this);
-            const drawableBindGroup = this.getDrawableBindGroup(Application.instance.device, !!instanceInfo, renderQueue);
+            const currentTag = this.getXForm().transformTag;
             if (instanceInfo) {
-                instanceInfo.bindGroup.bindGroup.setRawData(ShaderHelper.getInstanceDataUniformName(), instanceInfo.offset * 4, this.getXForm().worldMatrix, 0, 16);
+                const tag = instanceBindGroupTransfromTags.get(instanceInfo) ?? -1;
+                if (tag !== currentTag) {
+                    instanceInfo.bindGroup.bindGroup.setRawData(ShaderHelper.getInstanceDataUniformName(), instanceInfo.offset * 4, this.getXForm().worldMatrix, 0, 16);
+                    instanceBindGroupTransfromTags.set(instanceInfo, tag);
+                }
             } else {
-                drawableBindGroup.setValue(ShaderHelper.getWorldMatrixUniformName(), this.getXForm().worldMatrix);
+                const drawableBindGroup = this.getDrawableBindGroup(Application.instance.device, false, renderQueue);
+                const tag = drawableBindGroupTransfromTags.get(drawableBindGroup) ?? -1;
+                if (tag !== currentTag) {
+                    drawableBindGroup.setValue(ShaderHelper.getWorldMatrixUniformName(), this.getXForm().worldMatrix);
+                    if (this.getBoneMatrices()) {
+                        drawableBindGroup.setValue(ShaderHelper.getBoneInvBindMatrixUniformName(), this.invWorldMatrix);
+                    }
+                    drawableBindGroupTransfromTags.set(drawableBindGroup, tag);
+                }
             }
         }
         applyMaterialUniforms(instanceInfo) {
@@ -93,13 +108,13 @@ function mixinDrawable(baseCls) {
             const drawableBindGroup = this.getDrawableBindGroup(device, !!ctx.instanceData, ctx.renderQueue);
             device.setBindGroup(1, drawableBindGroup);
             device.setBindGroup(3, ctx.instanceData ? ctx.instanceData.bindGroup.bindGroup : null);
-            if (ctx.skinAnimation) {
+            if (ctx.materialFlags & MaterialVaryingFlags.SKIN_ANIMATION) {
                 const boneTexture = this.getBoneMatrices();
                 drawableBindGroup.setTexture(ShaderHelper.getBoneMatricesUniformName(), boneTexture);
-                drawableBindGroup.setValue(ShaderHelper.getBoneInvBindMatrixUniformName(), this.getInvBindMatrix());
+                drawableBindGroup.setValue(ShaderHelper.getBoneInvBindMatrixUniformName(), this.invWorldMatrix);
                 drawableBindGroup.setValue(ShaderHelper.getBoneTextureSizeUniformName(), boneTexture.width);
             }
-            if (ctx.morphAnimation) {
+            if (ctx.materialFlags & MaterialVaryingFlags.MORPH_ANIMATION) {
                 const morphData = this.getMorphData();
                 const morphInfo = this.getMorphInfo();
                 drawableBindGroup.setTexture(ShaderHelper.getMorphDataUniformName(), morphData);
@@ -111,16 +126,8 @@ function mixinDrawable(baseCls) {
             const morphing = !!this.getMorphData();
             let bindGroup = instancing ? this._mdDrawableBindGroupInstanced.get(renderQueue) : skinning && morphing ? this._mdDrawableBindGroupSkinMorph : skinning ? this._mdDrawableBindGroupSkin : morphing ? this._mdDrawableBindGroupMorph : this._mdDrawableBindGroup;
             if (!bindGroup) {
-                const buildInfo = new ProgramBuilder(device).buildRender({
-                    vertex (pb) {
-                        ShaderHelper.vertexShaderDrawableStuff(this, skinning, morphing, instancing);
-                        pb.main(function() {});
-                    },
-                    fragment (pb) {
-                        pb.main(function() {});
-                    }
-                });
-                bindGroup = device.createBindGroup(buildInfo[2][1]);
+                const layout = ShaderHelper.getDrawableBindGroupLayout(skinning, morphing, instancing);
+                bindGroup = device.createBindGroup(layout);
                 if (instancing) {
                     this._mdDrawableBindGroupInstanced.set(renderQueue, bindGroup);
                 } else if (skinning && morphing) {
@@ -128,7 +135,6 @@ function mixinDrawable(baseCls) {
                 } else if (skinning) {
                     this._mdDrawableBindGroupSkin = bindGroup;
                 } else if (morphing) {
-                    const layout = buildInfo[2][1];
                     const bindName = layout.nameMap?.[ShaderHelper.getMorphInfoUniformName()] ?? ShaderHelper.getMorphInfoUniformName();
                     for(let binding = 0; binding < layout.entries.length; binding++){
                         const bindingPoint = layout.entries[binding];

package/dist/render/drawable_mixin.js.map

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

package/dist/render/envlight.js

@@ -390,7 +390,9 @@ import { Application } from '../app.js';
    * {@inheritDoc EnvironmentLighting.getRadiance}
    * @override
    */ getRadiance(scope, refl, roughness) {
-        return null;
+        const pb = scope.$builder;
+        const factor = pb.add(pb.mul(refl.y, 0.5), 0.5);
+        return pb.mix(scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN], scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP], factor).rgb;
     }
     /**
    * {@inheritDoc EnvironmentLighting.getIrradiance}
@@ -404,7 +406,7 @@ import { Application } from '../app.js';
    * {@inheritDoc EnvironmentLighting.hasRadiance}
    * @override
    */ hasRadiance() {
-        return false;
+        return true;
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasIrradiance}

package/dist/render/envlight.js.map

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