@zephyr3d/scene 0.3.0 → 0.4.0

package/dist/index.js

@@ -9,7 +9,6 @@ export { CylinderShape } from './shapes/cylinder.js';
 export { TorusShape } from './shapes/torus.js';
 export { PlaneShape } from './shapes/plane.js';
 export { SphereShape } from './shapes/sphere.js';
-export { RenderScheme } from './render/renderscheme.js';
 export { RenderPass } from './render/renderpass.js';
 export { SceneRenderer } from './render/renderer.js';
 export { LightPass } from './render/lightpass.js';
@@ -23,6 +22,9 @@ export { Primitive } from './render/primitive.js';
 export { CullVisitor } from './render/cull_visitor.js';
 export { TemporalCache } from './render/temporalcache.js';
 export { WaterMesh, defaultBuildParams } from './render/watermesh.js';
+export { OIT } from './render/oit.js';
+export { WeightedBlendedOIT } from './render/weightedblended_oit.js';
+export { ABufferOIT } from './render/abuffer_oit.js';
 export { ShaderHelper } from './material/shader/helper.js';
 export { LambertMaterial } from './material/lambert.js';
 export { BlinnMaterial } from './material/blinn.js';
@@ -54,7 +56,7 @@ export { SceneNode } from './scene/scene_node.js';
 export { BatchGroup } from './scene/batchgroup.js';
 export { Terrain } from './scene/terrain/terrain.js';
 export { HeightField, HeightfieldBBoxTree } from './scene/terrain/heightfield.js';
-export { TerrainPatch } from './scene/terrain/patch.js';
+export { TerrainPatch, TerrainPatchBase } from './scene/terrain/patch.js';
 export { Quadtree, QuadtreeNode } from './scene/terrain/quadtree.js';
 export { XForm } from './scene/xform.js';
 export { AnimationClip } from './animation/animation.js';

package/dist/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/material/grassmaterial.js

@@ -43,6 +43,12 @@ import { mixinFoliage } from './mixins/foliage.js';
    */ supportLighting() {
         return true;
     }
+    /**
+   * {@inheritDoc Material.supportInstancing}
+   * @override
+   */ supportInstancing() {
+        return false;
+    }
     applyUniformValues(bindGroup, ctx, pass) {
         super.applyUniformValues(bindGroup, ctx, pass);
         bindGroup.setTexture('terrainNormalMap', this._terrainNormalMap);
@@ -87,6 +93,15 @@ import { mixinFoliage } from './mixins/foliage.js';
             this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
         }
     }
+    apply(ctx) {
+        this.alphaToCoverage = ctx.device.getFrameBufferSampleCount() > 1;
+        this.alphaCutoff = this.alphaToCoverage ? 1 : 0.8;
+        return super.apply(ctx);
+    }
+    updateRenderStates(pass, stateSet, ctx) {
+        super.updateRenderStates(pass, stateSet, ctx);
+        stateSet.useRasterizerState().setCullMode('none');
+    }
 }
 
 export { GrassMaterial };

package/dist/material/grassmaterial.js.map

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

package/dist/material/material.js

@@ -1,8 +1,5 @@
-import { List } from '@zephyr3d/base';
 import { ProgramBuilder } from '@zephyr3d/device';
-import { Application } from '../app.js';
-import { QUEUE_OPAQUE, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH } from '../values.js';
-import { ShaderHelper } from './shader/helper.js';
+import { QUEUE_OPAQUE } from '../values.js';
 
 /**
  * Base class for any kind of materials
@@ -10,41 +7,23 @@ import { ShaderHelper } from './shader/helper.js';
  * @public
  */ class Material {
     /** @internal */ static _nextId = 0;
-    /** @internal */ static _programMap = {};
-    /** @internal */ static _drawableTimestamps = new WeakMap();
-    /** @internal */ static _drawableIterators = new WeakMap();
-    /** @internal */ static _drawableLRU = new List();
-    /** @internal */ static _materialTimestamps = new WeakMap();
-    /** @internal */ static _materialIterators = new WeakMap();
-    /** @internal */ static _materialLRU = new List();
-    /** @internal */ static _gcOptions = {
-        disabled: true,
-        drawableCountThreshold: 500,
-        materialCountThreshold: 200,
-        inactiveTimeDuration: 30000
-    };
-    /** @internal */ static _boneMatrixTextureSampler = null;
-    /** @internal */ //private static _instanceBindGroupPool: InstanceBindGroupPool = new InstanceBindGroupPool();
-    /** @internal */ static _drawableBindGroupMap = new WeakMap();
+    /** @internal */ _states;
     /** @internal */ _numPasses;
     /** @internal */ _hash;
-    /** @internal */ _renderStateSet;
-    /** @internal */ _bindGroupMap;
     /** @internal */ _optionTag;
-    /** @internal */ _materialBindGroup;
     /** @internal */ _id;
+    /** @internal */ _currentHash;
     /**
    * Creates an instance of material
    */ constructor(){
         this._id = ++Material._nextId;
+        this._states = {};
         this._numPasses = 1;
         this._hash = [
-            []
+            null
         ];
-        this._renderStateSet = null;
-        this._bindGroupMap = {};
         this._optionTag = 0;
-        this._materialBindGroup = null;
+        this._currentHash = [];
     }
     /** Unique identifier of the material */ get instanceId() {
         return this._id;
@@ -54,94 +33,91 @@ import { ShaderHelper } from './shader/helper.js';
     }
     set numPasses(val) {
         while(this._hash.length < val){
-            this._hash.push([]);
+            this._hash.push(null);
         }
         this._numPasses = val;
     }
-    /** @internal */ getHash(renderPassType, pass) {
-        if (this._hash[pass][renderPassType] === void 0) {
-            this._hash[pass][renderPassType] = this.createHash(renderPassType, pass);
+    /** @internal */ getHash(pass) {
+        if (this._hash[pass] === null) {
+            this._hash[pass] = this.createHash(pass);
         }
-        return this._hash[pass][renderPassType];
-    }
-    /** Render states associated to this material */ get stateSet() {
-        if (!this._renderStateSet) {
-            this._renderStateSet = this.createRenderStateSet();
-        }
-        return this._renderStateSet;
-    }
-    set stateSet(stateset) {
-        this._renderStateSet = stateset;
+        return this._hash[pass];
     }
     getQueueType() {
         return QUEUE_OPAQUE;
     }
-    /** Returns true if this is a transparency material */ isTransparentPass(pass) {
+    /** Returns true if given pass is transparent */ isTransparentPass(pass) {
         return false;
     }
     /** Returns true if shading of the material will be affected by lights  */ supportLighting() {
         return true;
     }
+    /** Returns true if this material supports geometry instancing  */ supportInstancing() {
+        return true;
+    }
     /** Returns true if this material supports geometry instancing  */ isBatchable() {
         return false;
     }
-    /**
-   * Draws a primitive using this material
-   *
-   * @param primitive - The prmitive to be drawn
-   * @param ctx - The context of current drawing task
-   * @param numInstances - How many instances should be drawn. if zero, the instance count will be automatically detected.
-   */ draw(primitive, ctx, numInstances = 0) {
-        for(let i = 0; i < this._numPasses; i++){
-            if (this.beginDraw(i, ctx)) {
-                this.drawPrimitive(i, primitive, ctx, numInstances);
-                this.endDraw(i);
-            }
-        }
+    /** @internal */ get coreMaterial() {
+        return this;
     }
     /**
-   * Prepares for drawing
-   * @param ctx - The context of current drawing task
-   * @returns true if succeeded, otherwise false
-   */ beginDraw(pass, ctx) {
-        const device = Application.instance.device;
-        const programInfo = this.getOrCreateProgram(ctx, pass);
-        if (programInfo) {
-            const hash = programInfo.hash;
-            if (!programInfo.programs[ctx.renderPass.type]) {
-                return false;
-            }
-            if (pass > 0) {
-                this.optionChanged(false);
+   * Apply material
+   * @param ctx - Draw context
+   * @returns true if no error, otherwise false
+   */ apply(ctx) {
+        for(let pass = 0; pass < this._numPasses; pass++){
+            const hash = this.calcGlobalHash(ctx, pass);
+            let state = this._states[hash];
+            if (!state) {
+                const program = this.createProgram(ctx, pass) ?? null;
+                const bindGroup = program.bindGroupLayouts.length > 2 ? ctx.device.createBindGroup(program.bindGroupLayouts[2]) : null;
+                state = {
+                    program,
+                    bindGroup,
+                    renderStateSet: ctx.device.createRenderStateSet(),
+                    materialTag: -1
+                };
+                this._states[hash] = state;
             }
-            this._materialBindGroup = this.applyMaterialBindGroups(ctx, hash, pass);
-            if (pass === 0) {
-                if (ctx.instanceData) {
-                    this.applyInstanceBindGroups(ctx, hash);
-                } else {
-                    this.applyDrawableBindGroups(ctx, hash);
-                }
+            if (!state.program) {
+                return false;
             }
-            ctx.renderPass.applyRenderStates(device, this.stateSet, ctx);
-            device.setProgram(programInfo.programs[ctx.renderPass.type]);
-            Material._drawableTimestamps.set(ctx.target, ctx.timestamp);
-            Material.lruPutDrawable(ctx.target);
-            Material._materialTimestamps.set(this, ctx.timestamp);
-            Material.lruPutMaterial(this);
-            return true;
+            this.applyUniforms(state.bindGroup, ctx, state.materialTag !== this._optionTag, pass);
+            state.materialTag = this._optionTag;
+            this.updateRenderStates(pass, state.renderStateSet, ctx);
+            this._currentHash[pass] = hash;
         }
-        return false;
     }
-    /**
-   * Ends drawing a primitive
-   */ endDraw(pass) {
-        this._materialBindGroup = null;
+    /** @internal */ bind(device, pass) {
+        const hash = this._currentHash[pass];
+        const state = this._states[hash];
+        if (!state) {
+            console.error('Material.bind() failed: state not found');
+            return false;
+        }
+        if (!state.program) {
+            return false;
+        }
+        device.setProgram(state.program);
+        device.setBindGroup(2, state.bindGroup);
+        device.setRenderStates(state.renderStateSet);
+    }
+    /** @internal */ calcGlobalHash(ctx, pass) {
+        return `${this.getHash(pass)}:${Number(!!ctx.skinAnimation)}:${Number(!!ctx.instancing)}:${ctx.renderPassHash}`;
     }
     /**
-   * Gets the bind group of this material
-   * @returns The bind group of this material
-   */ getMaterialBindGroup() {
-        return this._materialBindGroup;
+   * Draws a primitive using this material
+   * @internal
+   *
+   * @param primitive - The prmitive to be drawn
+   * @param ctx - The context of current drawing task
+   * @param numInstances - How many instances should be drawn. if zero, the instance count will be automatically detected.
+   */ draw(primitive, ctx, numInstances = 0) {
+        for(let pass = 0; pass < this._numPasses; pass++){
+            this.bind(ctx.device, pass);
+            this.drawPrimitive(pass, primitive, ctx, numInstances);
+        }
     }
     /**
    * Sets all uniform values to the bind group of the material if needed
@@ -153,222 +129,14 @@ import { ShaderHelper } from './shader/helper.js';
             this._applyUniforms(bindGroup, ctx, pass);
         }
     }
-    /**
-   * Fetch the gpu program of the material for drawing
-   * @param ctx - The context for current drawing task
-   * @returns Information of the gpu program
-   */ getOrCreateProgram(ctx, pass) {
-        const programMap = Material._programMap;
-        const renderPassType = ctx.renderPass.type;
-        const hash = `${this.getHash(renderPassType, pass)}:${!!ctx.target.getBoneMatrices()}:${Number(!!ctx.instanceData)}:${ctx.renderPassHash}`;
-        let programInfo = programMap[hash];
-        if (!programInfo || programInfo.programs[renderPassType] === undefined) {
-            const program = this.createProgram(ctx, pass) ?? null;
-            if (!programInfo) {
-                programInfo = {
-                    programs: [
-                        null,
-                        null,
-                        null
-                    ],
-                    hash
-                };
-                programMap[hash] = programInfo;
-            }
-            programInfo.programs[renderPassType] = program;
-        }
-        return programInfo;
-    }
-    dispose() {
-        this.clearBindGroupCache();
-    }
-    /**
-   * Sets the options of garbage collection
-   * @param opt - The options to set
-   */ static setGCOptions(opt) {
-        this._gcOptions = Object.assign({}, this._gcOptions, opt || {});
-    }
-    /**
-   * Gets the options of garbage collection
-   * @returns The options of garbage collection
-   */ static getGCOptions() {
-        return this._gcOptions;
-    }
-    /**
-   * Performs a garbage collection for this material
-   * @param ts - Current time stamp
-   * @returns How many bind groups have been garbage collected
-   */ static garbageCollect(ts) {
-        let n = 0;
-        ts -= this._gcOptions.inactiveTimeDuration;
-        while(this._drawableLRU.length > this._gcOptions.drawableCountThreshold){
-            const iter = this._drawableLRU.begin();
-            if (this._drawableTimestamps.get(iter.data) < ts) {
-                const bindGroups = this._drawableBindGroupMap.get(iter.data);
-                if (bindGroups) {
-                    for(const k in bindGroups){
-                        for (const bindGroup of bindGroups[k].bindGroup){
-                            if (bindGroup) {
-                                this.bindGroupGarbageCollect(bindGroup);
-                                n++;
-                            }
-                        }
-                    }
-                }
-                this._drawableBindGroupMap.delete(iter.data);
-                this._drawableIterators.delete(iter.data);
-                this._drawableLRU.remove(iter);
-            } else {
-                break;
-            }
-        }
-        while(this._materialLRU.length > this._gcOptions.materialCountThreshold){
-            const iter = this._materialLRU.begin();
-            const mat = iter.data;
-            if (this._materialTimestamps.get(mat) < ts && mat._bindGroupMap) {
-                n += mat.clearBindGroupCache();
-                this._materialIterators.delete(mat);
-                this._materialLRU.remove(iter);
-            } else {
-                break;
-            }
-        }
-        if (n > 0 && this._gcOptions.verbose) {
-            console.log(`INFO: ${n} bind groups have been garbage collected`);
-        }
-        return n;
-    }
     /** @internal */ optionChanged(changeHash) {
         this._optionTag++;
         if (changeHash) {
             for(let i = 0; i < this._numPasses; i++){
-                this._hash[i] = [];
+                this._hash[i] = null;
             }
         }
     }
-    /** @internal */ static getProgramByHashIndex(hash, index) {
-        return this._programMap[hash].programs[index];
-    }
-    /** @internal */ applyMaterialBindGroups(ctx, hash, pass) {
-        const index = ctx.renderPass.type;
-        let bindGroupInfo = this._bindGroupMap[hash];
-        if (!bindGroupInfo) {
-            // bindGroups not created or have been garbage collected
-            const materialBindGroup = [
-                RENDER_PASS_TYPE_LIGHT,
-                RENDER_PASS_TYPE_SHADOWMAP,
-                RENDER_PASS_TYPE_DEPTH
-            ].map((k)=>{
-                const program = Material._programMap[hash].programs[k];
-                return program?.bindGroupLayouts[2] ? Application.instance.device.createBindGroup(program.bindGroupLayouts[2]) : null;
-            });
-            bindGroupInfo = this._bindGroupMap[hash] = {
-                materialBindGroup,
-                bindGroupTag: [
-                    0,
-                    0,
-                    0
-                ],
-                materialTag: [
-                    -1,
-                    -1,
-                    -1
-                ]
-            };
-        }
-        const bindGroup = bindGroupInfo.materialBindGroup[index];
-        if (bindGroup) {
-            this.applyUniforms(bindGroup, ctx, bindGroupInfo.materialTag[index] < this._optionTag || bindGroupInfo.bindGroupTag[index] !== bindGroup.cid, pass);
-            bindGroupInfo.materialTag[index] = this._optionTag;
-            bindGroupInfo.bindGroupTag[index] = bindGroup.cid;
-            Application.instance.device.setBindGroup(2, bindGroup);
-        } else {
-            Application.instance.device.setBindGroup(2, null);
-        }
-        return bindGroup;
-    }
-    /** @internal */ getDrawableBindGroup(ctx, hash) {
-        let drawableBindGroups = Material._drawableBindGroupMap.get(ctx.target);
-        if (!drawableBindGroups) {
-            drawableBindGroups = {};
-            Material._drawableBindGroupMap.set(ctx.target, drawableBindGroups);
-        }
-        let drawableBindGroup = drawableBindGroups[hash];
-        if (!drawableBindGroup) {
-            const bindGroup = [
-                RENDER_PASS_TYPE_LIGHT,
-                RENDER_PASS_TYPE_SHADOWMAP,
-                RENDER_PASS_TYPE_DEPTH
-            ].map((k)=>{
-                const program = Material._programMap[hash].programs[k];
-                return program?.bindGroupLayouts[1] ? Application.instance.device.createBindGroup(program.bindGroupLayouts[1]) : null;
-            });
-            drawableBindGroup = drawableBindGroups[hash] = {
-                bindGroup,
-                bindGroupTag: [
-                    0,
-                    0,
-                    0
-                ],
-                xformTag: [
-                    -1,
-                    -1,
-                    -1
-                ]
-            };
-        }
-        return drawableBindGroup;
-    }
-    /** @internal */ applyInstanceBindGroups(ctx, hash) {
-        if (ctx.instanceData) {
-            if (ctx.instanceData.bindGroup.dirty) {
-                ctx.instanceData.bindGroup.bindGroup.setRawData(ShaderHelper.getWorldMatricesUniformName(), 0, ctx.instanceData.bindGroup.buffer, 0, ctx.instanceData.currentSize * 4);
-                ctx.instanceData.bindGroup.dirty = false;
-            }
-            Application.instance.device.setBindGroup(3, ctx.instanceData.bindGroup.bindGroup ?? null);
-        } else {
-            Application.instance.device.setBindGroup(3, null);
-        }
-        const bindGroup = this.getDrawableBindGroup(ctx, hash).bindGroup?.[ctx.renderPass.type];
-        if (bindGroup) {
-            if (ctx.instanceData) {
-                bindGroup.setValue(ShaderHelper.getInstanceBufferStrideUniformName(), ctx.instanceData.stride);
-            }
-            Application.instance.device.setBindGroup(1, bindGroup);
-        } else {
-            Application.instance.device.setBindGroup(1, null);
-        }
-    }
-    /** @internal */ applyDrawableBindGroups(ctx, hash) {
-        const device = Application.instance.device;
-        const index = ctx.renderPass.type;
-        const drawableBindGroup = this.getDrawableBindGroup(ctx, hash);
-        if (drawableBindGroup.bindGroup) {
-            const bindGroup = drawableBindGroup.bindGroup[index];
-            if (drawableBindGroup.xformTag[index] < ctx.target.getXForm().getTag() || drawableBindGroup.bindGroupTag[index] !== bindGroup.cid) {
-                bindGroup.setValue(ShaderHelper.getWorldMatrixUniformName(), ctx.target.getXForm().worldMatrix);
-                drawableBindGroup.xformTag[index] = ctx.target.getXForm().getTag();
-                drawableBindGroup.bindGroupTag[index] = bindGroup.cid;
-            }
-            const boneMatrices = ctx.target.getBoneMatrices();
-            if (boneMatrices) {
-                if (!Material._boneMatrixTextureSampler) {
-                    Material._boneMatrixTextureSampler = device.createSampler({
-                        magFilter: 'nearest',
-                        minFilter: 'nearest',
-                        mipFilter: 'none'
-                    });
-                }
-                bindGroup.setTexture(ShaderHelper.getBoneMatricesUniformName(), boneMatrices);
-                bindGroup.setValue(ShaderHelper.getBoneTextureSizeUniformName(), boneMatrices.width);
-                bindGroup.setValue(ShaderHelper.getBoneInvBindMatrixUniformName(), ctx.target.getInvBindMatrix());
-            }
-            device.setBindGroup(1, bindGroup);
-        } else {
-            device.setBindGroup(1, null);
-        }
-        device.setBindGroup(3, null);
-    }
     /**
    * Convert pass to hash
    * @param pass - pass number
@@ -376,47 +144,8 @@ import { ShaderHelper } from './shader/helper.js';
    */ passToHash(pass) {
         return String(pass);
     }
-    /** @internal */ createHash(renderPassType, pass) {
-        return `${this.constructor.name}|${this.passToHash(pass)}|${this._createHash(renderPassType)}`;
-    }
-    /** @internal */ clearBindGroupCache() {
-        let n = 0;
-        for(const k in this._bindGroupMap){
-            for (const bindGroup of this._bindGroupMap[k].materialBindGroup){
-                if (bindGroup) {
-                    Material.bindGroupGarbageCollect(bindGroup);
-                    n++;
-                }
-            }
-        }
-        this._bindGroupMap = {};
-        return n;
-    }
-    /** @internal */ static bindGroupGarbageCollect(bindGroup) {
-        const layout = bindGroup.getLayout();
-        for (const entry of layout.entries){
-            if (entry.buffer) {
-                const buffer = bindGroup.getBuffer(entry.name);
-                if (buffer) {
-                    buffer.dispose();
-                    bindGroup.setBuffer(entry.name, null);
-                }
-            }
-        }
-    }
-    /** @internal */ static lruPutDrawable(drawable) {
-        const iter = this._drawableIterators.get(drawable);
-        if (iter) {
-            this._drawableLRU.remove(iter);
-        }
-        this._drawableIterators.set(drawable, this._drawableLRU.append(drawable));
-    }
-    /** @internal */ static lruPutMaterial(material) {
-        const iter = this._materialIterators.get(material);
-        if (iter) {
-            this._materialLRU.remove(iter);
-        }
-        this._materialIterators.set(material, this._materialLRU.append(material));
+    /** @internal */ createHash(pass) {
+        return `${this.constructor.name}|${pass}|${this._createHash()}`;
     }
     /**
    * Draw primitve
@@ -427,18 +156,15 @@ import { ShaderHelper } from './shader/helper.js';
         if (numInstances > 0) {
             primitive.drawInstanced(numInstances);
         } else if (ctx.instanceData) {
-            primitive.drawInstanced(ctx.instanceData.currentSize / ctx.instanceData.stride);
+            primitive.drawInstanced(ctx.instanceData.numInstances);
         } else {
             primitive.draw();
         }
     }
     /** @internal */ createProgram(ctx, pass) {
-        const pb = new ProgramBuilder(Application.instance.device);
+        const pb = new ProgramBuilder(ctx.device);
         return this._createProgram(pb, ctx, pass);
     }
-    /** @internal */ createRenderStateSet() {
-        return Application.instance.device.createRenderStateSet();
-    }
     /**
    * Creates the shader program
    * @param pb - The program builder
@@ -454,9 +180,15 @@ import { ShaderHelper } from './shader/helper.js';
    * @param ctx - The drawing context
    */ _applyUniforms(bindGroup, ctx, pass) {}
     /**
+   * Update render states according to draw context and current material pass
+   * @param pass - Current material pass
+   * @param renderStates - Render state set to be updated
+   * @param ctx - Draw context
+   */ updateRenderStates(pass, renderStates, ctx) {}
+    /**
    * Calculates the hash code of the shader program
    * @returns The hash code
-   */ _createHash(renderPassType) {
+   */ _createHash() {
         return '';
     }
     /**

package/dist/material/material.js.map

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