@zephyr3d/scene 0.9.26 → 0.10.0

package/dist/scene/mesh.js

@@ -1,18 +1,20 @@
-import { castObservable, applyMixins, DRef } from '@zephyr3d/base';
+import { Vector3, castObservable, applyMixins, DRef, DWeakRef, Matrix4x4, Vector4 } from '@zephyr3d/base';
+import { isWireframeActive } from '../render/debug_views.js';
 import { GraphNode } from './graph_node.js';
 import { ShaderHelper } from '../material/shader/helper.js';
 import { LambertMaterial } from '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
+import '../material/meshmaterial.js';
 import '../material/particle.js';
 import '../material/subsurfaceprofile.js';
-import '../material/skin.js';
+import '../material/sssprofile.js';
+import '../material/sss.js';
 import '../material/eye.js';
 import { PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, PBPrimitiveType } from '@zephyr3d/device';
-import { QUEUE_OPAQUE, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_ATTRIBUTE_VECTOR_COUNT, getMorphTargetLimit, getActiveMorphTargetLimit } from '../values.js';
+import { QUEUE_OPAQUE, RENDER_PASS_TYPE_LIGHT, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_ATTRIBUTE_VECTOR_COUNT, getMorphTargetLimit, getActiveMorphTargetLimit } from '../values.js';
 import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
 import { getDevice } from '../app/api.js';
-import '../material/meshmaterial.js';
 import '../material/hair.js';
 import '../material/hairstrand.js';
 import '../material/grassmaterial.js';
@@ -27,7 +29,52 @@ import '../utility/blueprint/material/texture.js';
 import { BoundingBox } from '../utility/bounding_volume.js';
 import { mixinDrawable } from '../render/drawable_mixin.js';
 import { calculateMorphBoundingBox } from '../animation/morphtarget.js';
+import { SkinPaletteAtlas } from '../animation/skin_palette_atlas.js';
+import { computeAABBScreenRadiusSquared, selectLod } from '../render/lod.js';
 
+const tmpLodCenter = new Vector3();
+const LOD_COLORATION_COLORS = [
+    [
+        1,
+        1,
+        1
+    ],
+    [
+        1,
+        0,
+        0
+    ],
+    [
+        0,
+        1,
+        0
+    ],
+    [
+        0,
+        0,
+        1
+    ],
+    [
+        1,
+        1,
+        0
+    ],
+    [
+        1,
+        0,
+        1
+    ],
+    [
+        0,
+        1,
+        1
+    ],
+    [
+        0.5,
+        0,
+        0.5
+    ]
+];
 const MORPH_WEIGHT_CAPACITY = MORPH_WEIGHTS_VECTOR_COUNT * 4;
 const MORPH_ATTRIBUTE_CAPACITY = MORPH_ATTRIBUTE_VECTOR_COUNT * 4;
 const MORPH_INFO_DATA_LENGTH = 4 + MORPH_WEIGHT_CAPACITY + MORPH_ATTRIBUTE_CAPACITY;
@@ -70,10 +117,16 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /** @internal */ _primitive;
     /** @internal */ _material;
     /** @internal */ _castShadow;
+    /** @internal */ _sdfMode;
     /** @internal */ _skinnedBoundingInfo;
     /** @internal */ _animatedBoundingBox;
     /** @internal */ _skinBindingName;
     /** @internal */ _boneMatrices;
+    /** @internal Skin binding resolved from _skinBindingName at the last skeleton state update */ _skinBinding;
+    /** @internal */ _skinSpaceMatrix;
+    /** @internal Skin binding and palette version the skinned bounds were last computed for */ _skinnedBoundsVersion;
+    /** @internal Palette written by an animation bank track in place of the skin binding's */ _skinPaletteOverride;
+    /** Palette base last written to instance data and drawable uniforms */ _appliedSkinPaletteBase;
     /** @internal */ _skinInfluenceData;
     /** @internal */ _morphData;
     /** @internal */ _morphInfo;
@@ -94,6 +147,9 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /** @internal */ _materialChangeTag;
     /** @internal */ _primitiveChangeTag;
     /** @internal */ _postUpdateCallbacks;
+    /** @internal */ _forcedLod;
+    /** @internal */ _minLod;
+    /** @internal Level of detail last selected for each camera, for the hysteresis */ _lodByCamera;
     /**
    * Creates an instance of mesh node
    * @param scene - The scene to which the mesh node belongs
@@ -102,9 +158,18 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         this._primitive = new DRef();
         this._material = new DRef();
         this._castShadow = true;
+        this._sdfMode = 'auto';
         this._skinnedBoundingInfo = null;
         this._animatedBoundingBox = null;
         this._boneMatrices = new DRef();
+        this._skinBinding = new DWeakRef();
+        this._skinSpaceMatrix = new Matrix4x4();
+        this._skinPaletteOverride = null;
+        this._appliedSkinPaletteBase = 0;
+        this._skinnedBoundsVersion = {
+            binding: null,
+            version: -1
+        };
         this._skinInfluenceData = null;
         this._morphData = null;
         this._morphInfo = null;
@@ -120,7 +185,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         this._pickTarget = {
             node: this
         };
-        this._batchable = getDevice().type !== 'webgl';
+        this._batchable = true;
         this.primitive = primitive ?? null;
         this.material = material ?? Mesh._getDefaultMaterial();
         this._suspendSkinning = false;
@@ -130,11 +195,29 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         this._materialChangeTag = null;
         this._primitiveChangeTag = null;
         this._postUpdateCallbacks = new Set();
+        this._forcedLod = -1;
+        this._minLod = 0;
+        this._lodByCamera = null;
     }
     /**
    * Returns the batch instance ID for the current render pass.
    */ getInstanceId(_renderPass) {
-        return `${this._instanceHash}:${this.worldMatrixDet >= 0}`;
+        const id = `${this._instanceHash}:${this.worldMatrixDet >= 0}`;
+        return this._boneMatrices.get() ? `${id}:skin:${this.getSkinSpaceKey()}` : id;
+    }
+    /**
+   * Key of the skin space matrix, equal for meshes that may share one in a batch.
+   *
+   * @remarks
+   * A batch transforms the palettes of all its instances by the skin space matrix of its first
+   * mesh. Instances of one model share it up to rounding, so the key is quantized.
+   */ getSkinSpaceKey() {
+        const m = this.getSkinSpaceMatrix();
+        let key = '';
+        for(let i = 0; i < 16; i++){
+            key += `${Math.round(m[i] * 1e4)},`;
+        }
+        return key;
     }
     /**
    * Returns the packed instance-uniform buffer used for batching.
@@ -180,6 +263,12 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         return this._suspendSkinning;
     }
     /** @internal */ set suspendSkinning(val) {
+        if (val && !this._suspendSkinning) {
+            this.setAnimatedBoundingBox(null);
+        } else if (!val && this._suspendSkinning) {
+            // Skinned meshes sleep until their pose changes, so wake this one to pick skinning up again
+            this.scene?.queueUpdateNode(this);
+        }
         this._suspendSkinning = !!val;
     }
     /** Wether the mesh node casts shadows */ get castShadow() {
@@ -188,6 +277,83 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     set castShadow(b) {
         this._castShadow = b;
     }
+    /** How the mesh takes part in the scene's signed distance field. */ get sdfMode() {
+        return this._sdfMode;
+    }
+    set sdfMode(val) {
+        if (val !== this._sdfMode) {
+            this._sdfMode = val;
+            this.dispatchEvent('sdfmode_changed', this);
+        }
+    }
+    /** {@link Mesh.sdfMode} with `auto` resolved. */ get effectiveSDFMode() {
+        if (this._sdfMode !== 'auto') {
+            return this._sdfMode;
+        }
+        if (this._skinBindingName || this._morphData) {
+            return 'dynamic';
+        }
+        for(let node = this; node; node = node.parent){
+            const physics = node.physics;
+            const body = physics?.body;
+            if (body && body.motionType !== 'static' || physics?.character) {
+                return 'dynamic';
+            }
+        }
+        return 'static';
+    }
+    /**
+   * Level of detail to always draw, or -1 to select it by the projected size.
+   * Clamped to the levels of the primitive.
+   */ get forcedLod() {
+        return this._forcedLod;
+    }
+    set forcedLod(val) {
+        val = Math.max(-1, Math.floor(val));
+        if (val !== this._forcedLod) {
+            this._forcedLod = val;
+            this.dispatchEvent('lod_changed', this);
+        }
+    }
+    /**
+   * Finest level of detail drawn when selecting by the projected size.
+   * Clamped to the levels of the primitive.
+   */ get minLod() {
+        return this._minLod;
+    }
+    set minLod(val) {
+        val = Math.max(0, Math.floor(val));
+        if (val !== this._minLod) {
+            this._minLod = val;
+            this.dispatchEvent('lod_changed', this);
+        }
+    }
+    /**
+   * Selects the level of detail of the primitive for a view: forced, or picked from the projected
+   * size of the world bounds. Always 0 for a primitive without levels.
+   *
+   * @param camera - The view's camera
+   * @returns The level of detail, 0 being the finest
+   */ selectLod(camera) {
+        const lods = this._primitive.get()?.lods;
+        if (!lods || lods.length === 0) {
+            return 0;
+        }
+        if (this._forcedLod >= 0) {
+            return Math.min(this._forcedLod, lods.length);
+        }
+        const bv = this.getWorldBoundingVolume();
+        if (!bv) {
+            return Math.min(this._minLod, lods.length);
+        }
+        const screenRadiusSquared = computeAABBScreenRadiusSquared(bv.toAABB(), camera, tmpLodCenter);
+        if (!this._lodByCamera) {
+            this._lodByCamera = new WeakMap();
+        }
+        const lod = selectLod(lods, screenRadiusSquared, camera.lodDistanceScale, this._lodByCamera.get(camera) ?? 0, this._minLod);
+        this._lodByCamera.set(camera, lod);
+        return lod;
+    }
     /** Primitive of the mesh */ get primitive() {
         return this._primitive?.get() ?? null;
     }
@@ -205,12 +371,6 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
             this.invalidateBoundingVolume();
             RenderBundleWrapper.drawableChanged(this);
             this._primitiveChangeTag = null;
-            if (this._morphData) {
-                this._ensureWebGLVertexIndexAttribute('morphing');
-            }
-            if (this._skinInfluenceData && this._skinInfluenceData.influenceCount > 4) {
-                this._ensureWebGLVertexIndexAttribute('skinning');
-            }
             this.dispatchEvent('primitive_changed', prim);
         }
     }
@@ -267,6 +427,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    */ setBoneMatrices(matrices) {
         if (this._boneMatrices.get() !== matrices) {
             this._boneMatrices.set(matrices);
+            Mesh._trackBoneMatrices(this, !!matrices);
             this._renderBundle = {};
             RenderBundleWrapper.drawableChanged(this);
         }
@@ -316,7 +477,6 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
             }
             tex.update(data.data, 0, 0, data.width, data.height);
         }
-        this._ensureWebGLVertexIndexAttribute('skinning');
         this._renderBundle = {};
         RenderBundleWrapper.drawableChanged(this);
     }
@@ -358,7 +518,6 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
                 }
                 tex.update(data.data, 0, 0, data.width, data.height);
             }
-            this._ensureWebGLVertexIndexAttribute('morphing');
             this._renderBundle = {};
             RenderBundleWrapper.drawableChanged(this);
             if (this._morphInfo && !this._morphSourceData) {
@@ -383,6 +542,54 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         return this._skinInfluenceData;
     }
     /**
+   * Gets the slot index of the skinning palette header in the bone matrix texture.
+   *
+   * @internal
+   */ getSkinPaletteBase() {
+        return this._skinPaletteOverride?.paletteBase ?? this._skinBinding.get()?.paletteBase ?? 0;
+    }
+    /**
+   * Gets the palette that skins this mesh in place of its skin binding's, if any.
+   *
+   * @internal
+   */ getSkinPaletteOverride() {
+        return this._skinPaletteOverride;
+    }
+    /**
+   * Skins this mesh by a palette written elsewhere instead of by its skin binding.
+   *
+   * @remarks
+   * The palette must be laid out like the binding's: same joints, relative to the same
+   * reference node. The mesh then neither reads the binding's palette nor computes its bounds
+   * from the binding's joints each frame; the override supplies its animated bounds.
+   *
+   * @param override - The palette and bounds, or null to skin by the binding again
+   * @internal
+   */ setSkinPaletteOverride(override) {
+        this._skinPaletteOverride = override;
+        this.updateSkeletonState();
+    }
+    /**
+   * Gets the matrix transforming skinning palette output to the local space of this mesh.
+   *
+   * @remarks
+   * Palette matrices are relative to the reference node of the skin binding, so this is
+   * `inverse(worldMatrix) * referenceNode.worldMatrix`.
+   *
+   * @param binding - Skin binding the palette belongs to. Defaults to the binding last resolved
+   *   for this mesh, which is not resolved yet before the first update after deserialization,
+   *   since the children of a node are deserialized before its skin bindings
+   * @internal
+   */ getSkinSpaceMatrix(binding) {
+        const reference = (binding ?? this._skinBinding.get())?.referenceNode;
+        if (reference) {
+            Matrix4x4.multiplyAffine(this.invWorldMatrix, reference.worldMatrix, this._skinSpaceMatrix);
+        } else {
+            this._skinSpaceMatrix.set(this.invWorldMatrix);
+        }
+        return this._skinSpaceMatrix;
+    }
+    /**
    * Gets the external morph source descriptor.
    */ getMorphSource() {
         return this._morphSource;
@@ -663,7 +870,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         });
     }
     /** @internal */ resolveAnimatedBoundingBox(morphBoundingBox) {
-        const skinnedBoundingBox = this._boneMatrices.get() && this._skinnedBoundingInfo?.boundingBox?.isValid() ? this._skinnedBoundingInfo.boundingBox : null;
+        const skinnedBoundingBox = !this._boneMatrices.get() ? null : this._skinPaletteOverride ? this._skinPaletteOverride.boundingBox : this._skinnedBoundingInfo?.boundingBox?.isValid() ? this._skinnedBoundingInfo.boundingBox : null;
         if (skinnedBoundingBox && morphBoundingBox) {
             // Skinning and morphing both active. The two boxes live in different
             // frames: the skinned box already reflects where the geometry actually
@@ -795,6 +1002,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /** @internal */ addPostUpdateCallback(callback) {
         if (callback) {
             this._postUpdateCallbacks.add(callback);
+            this.scene?.queueUpdateNode(this);
         }
     }
     /** @internal */ removePostUpdateCallback(callback) {
@@ -805,7 +1013,8 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /**
    * {@inheritDoc Drawable.isBatchable}
    */ isBatchable() {
-        return this._batchable && !this._boneMatrices.get() && !this._morphData && (this._material.get()?.isBatchable() ?? false);
+        return this._batchable && !this._morphData && // Extra skin influences are read from a texture of each mesh, which a batch cannot vary
+        !(this._boneMatrices.get() && (this._skinInfluenceData?.influenceCount ?? 4) > 4) && (this._material.get()?.isBatchable() ?? false);
     }
     /**
    * {@inheritDoc Drawable.getQueueType}
@@ -878,34 +1087,81 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     }
     /** @internal */ updateSkeletonState() {
         if (this._suspendSkinning) {
+            if (this._skinnedBoundsVersion) {
+                this._skinnedBoundsVersion.binding = null;
+            }
             this.setBoneMatrices(null);
-            this.setAnimatedBoundingBox(null);
             return;
         }
-        const binding = this._skinBindingName && this.findSkinBindingById(this._skinBindingName);
+        // Looking a binding up walks the model, so the one found last time is kept while it matches
+        const cached = this._skinBinding.get();
+        const binding = this._skinBindingName && (cached && !cached.disposed && cached.persistentId === this._skinBindingName ? cached : this.findSkinBindingById(this._skinBindingName));
+        this._skinBinding.set(binding || null);
+        const paletteBase = this.getSkinPaletteBase();
+        if (paletteBase !== this._appliedSkinPaletteBase) {
+            // Instance data and drawable uniforms hold the palette base and are not rewritten every
+            // frame; it changes with the binding, with palette overrides, and with a binding's palette
+            // being allocated again after a suspension
+            this._appliedSkinPaletteBase = paletteBase;
+            this.applyTransformUniformsAll();
+            RenderBundleWrapper.drawableChanged(this);
+        }
         if (binding) {
             this.setBoneMatrices(binding.jointTexture);
-            binding.computeBoundingBox(this._skinnedBoundingInfo, this.invWorldMatrix);
-            this.refreshAnimatedBoundingBox();
+            const bounds = this._skinnedBoundsVersion;
+            if (this._skinPaletteOverride) {
+                bounds.binding = null;
+                this.refreshAnimatedBoundingBox();
+            } else if (bounds.binding !== binding || bounds.version !== binding.paletteVersion) {
+                // Bounds follow the pose, which only changes with the joint matrices
+                bounds.binding = binding;
+                bounds.version = binding.paletteVersion;
+                binding.computeBoundingBox(this._skinnedBoundingInfo, this.getSkinSpaceMatrix(binding));
+                this.refreshAnimatedBoundingBox();
+            }
         } else {
+            this._skinnedBoundsVersion.binding = null;
             this.setBoneMatrices(null);
             this.refreshAnimatedBoundingBox();
         }
-        if (this._skinBindingName) {
-            this.scene.queueUpdateNode(this);
+        // Bounds of an overriding palette only change when the override is set again, and bounds
+        // of the binding's palette when its pose does, which wakes the mesh up
+        if (this._postUpdateCallbacks.size > 0 || this._skinBindingName && !binding) {
+            // Post update callbacks (GPU cloth) run every frame, and the binding may not be loaded yet
+            this.scene?.queueUpdateNode(this);
+        } else if (binding && !this._skinPaletteOverride) {
+            binding.sleepUntilPoseChanges(this);
         }
     }
     /**
    * {@inheritDoc Drawable.draw}
    */ draw(ctx, renderQueue, hash) {
-        const material = this.material;
-        const primitive = this.primitive;
-        if (material && primitive) {
-            if (this._useRenderBundle && !ctx.instanceData && hash) {
-                if (this._primitiveChangeTag !== primitive.changeTag || this._materialChangeTag !== material.changeTag) {
+        const ownMaterial = this.material;
+        const solid = this.primitive;
+        if (ownMaterial && solid) {
+            const coloration = this.getLodColorationMaterial(ctx);
+            // Render passes apply the materials of their item lists before drawing, which the
+            // coloration material is not part of
+            if (coloration && !coloration.apply(ctx)) {
+                return;
+            }
+            const material = coloration ?? ownMaterial;
+            const primitive = solid;
+            // Edges of a wireframe view are built asynchronously, a bundle recorded before would keep
+            // drawing the triangles
+            if (this._useRenderBundle && !ctx.instanceData && hash && !isWireframeActive()) {
+                // Each level of detail records its own draw range
+                const lod = ctx.primitiveLod ?? 0;
+                if (lod > 0) {
+                    hash = `${hash}:lod${lod}`;
+                }
+                if (coloration) {
+                    hash = `${hash}:lodcolor`;
+                }
+                if (this._primitiveChangeTag !== solid.changeTag || this._materialChangeTag !== ownMaterial.changeTag) {
                     this._renderBundle = {};
-                    this._primitiveChangeTag = primitive.changeTag;
-                    this._materialChangeTag = material.changeTag;
+                    this._primitiveChangeTag = solid.changeTag;
+                    this._materialChangeTag = ownMaterial.changeTag;
                 }
                 const renderBundle = this._renderBundle[hash];
                 if (!renderBundle) {
@@ -923,6 +1179,25 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         }
     }
     /**
+   * The material shading the level of detail in its color in the light pass
+   * of a camera showing it, null otherwise. Depth, shadow and picking passes keep the
+   * mesh's own material.
+   * @internal
+   */ getLodColorationMaterial(ctx) {
+        if (!ctx.camera?.lodColoration || ctx.renderPass?.type !== RENDER_PASS_TYPE_LIGHT) {
+            return null;
+        }
+        const lod = Math.min(ctx.primitiveLod ?? 0, LOD_COLORATION_COLORS.length - 1);
+        let material = Mesh._lodColorationMaterials[lod];
+        if (!material) {
+            material = new LambertMaterial();
+            const [r, g, b] = LOD_COLORATION_COLORS[lod];
+            material.albedoColor = new Vector4(r, g, b, 1);
+            Mesh._lodColorationMaterials[lod] = material;
+        }
+        return material;
+    }
+    /**
    * {@inheritDoc Drawable.getMaterial}
    */ getMaterial() {
         return this.material;
@@ -958,6 +1233,8 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         this._primitive.dispose();
         this._material.dispose();
         this._boneMatrices.dispose();
+        Mesh._trackBoneMatrices(this, false);
+        this._skinBinding.dispose();
         this.setSkinInfluenceData(null);
         this.setMorphData(null);
         this.setRenderMorphInfo(null);
@@ -970,26 +1247,31 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /** @internal */ _onBoundingboxChange() {
         this.invalidateBoundingVolume();
     }
-    /** @internal */ _ensureWebGLVertexIndexAttribute(feature) {
-        const primitive = this._primitive.get();
-        if (!primitive || getDevice().type !== 'webgl') {
-            return;
-        }
-        if (primitive.getVertexBuffer('texCoord7')) {
-            return;
-        }
-        const numVertices = primitive.getNumVertices();
-        if (numVertices <= 0) {
+    /** @internal */ static _defaultMaterial = null;
+    /** Meshes holding a joint texture, rebound when the skin palette atlas replaces it */ static _skinnedMeshes = new Set();
+    static _listeningAtlas = false;
+    /**
+   * Keep the joint textures of skinned meshes current when the atlas grows: a mesh only picks the
+   * texture up in update(), which a mesh posed by an animation bank track no longer runs
+   */ static _trackBoneMatrices(mesh, skinned) {
+        if (!skinned) {
+            this._skinnedMeshes.delete(mesh);
             return;
         }
-        const vertexIndices = new Float32Array(numVertices);
-        for(let i = 0; i < numVertices; i++){
-            vertexIndices[i] = i;
+        this._skinnedMeshes.add(mesh);
+        if (!this._listeningAtlas) {
+            this._listeningAtlas = true;
+            SkinPaletteAtlas.addTextureReplacedListener(()=>{
+                for (const m of this._skinnedMeshes){
+                    const binding = m._skinBinding.get();
+                    if (binding && !binding.disposed) {
+                        m.setBoneMatrices(binding.jointTexture);
+                    }
+                }
+            });
         }
-        primitive.createAndSetVertexBuffer('tex7_f32', vertexIndices);
-        console.info(`Injected texCoord7 vertex indices for WebGL ${feature} on mesh "${this.name ?? ''}"`);
     }
-    /** @internal */ static _defaultMaterial = null;
+    /** @internal Materials of the LOD coloration view, by level */ static _lodColorationMaterials = [];
     /** @internal */ static _getDefaultMaterial() {
         if (!this._defaultMaterial) {
             this._defaultMaterial = new LambertMaterial();