@spiffcommerce/preview 3.6.2-rc.5 → 3.6.2-rc.6

package/dist/node_modules/@babylonjs/core/Layers/highlightLayer.esm.js

@@ -1,396 +0,0 @@
-import { __decorate as h } from "../tslib.es6.esm.js";
-import { SerializationHelper as _, serialize as u } from "../Misc/decorators.esm.js";
-import { Observable as m } from "../Misc/observable.esm.js";
-import { Vector2 as d } from "../Maths/math.vector.esm.js";
-import { Engine as p } from "../Engines/engine.esm.js";
-import { VertexBuffer as M } from "../Buffers/buffer.esm.js";
-import { Material as g } from "../Materials/material.esm.js";
-import { Texture as l } from "../Materials/Textures/texture.esm.js";
-import { RenderTargetTexture as v } from "../Materials/Textures/renderTargetTexture.esm.js";
-import { PostProcess as B } from "../PostProcesses/postProcess.esm.js";
-import { PassPostProcess as T } from "../PostProcesses/passPostProcess.esm.js";
-import { BlurPostProcess as b } from "../PostProcesses/blurPostProcess.esm.js";
-import { EffectLayer as P } from "./effectLayer.esm.js";
-import { AbstractScene as E } from "../abstractScene.esm.js";
-import { Logger as R } from "../Misc/logger.esm.js";
-import { RegisterClass as O } from "../Misc/typeStore.esm.js";
-import { Color3 as w, Color4 as z } from "../Maths/math.color.esm.js";
-import "../Shaders/glowMapMerge.fragment.esm.js";
-import "../Shaders/glowMapMerge.vertex.esm.js";
-import "../Shaders/glowBlurPostProcess.fragment.esm.js";
-import "./effectLayerSceneComponent.esm.js";
-E.prototype.getHighlightLayerByName = function(f) {
-  var e;
-  for (let t = 0; t < ((e = this.effectLayers) === null || e === void 0 ? void 0 : e.length); t++)
-    if (this.effectLayers[t].name === f && this.effectLayers[t].getEffectName() === n.EffectName)
-      return this.effectLayers[t];
-  return null;
-};
-class x extends B {
-  constructor(e, t, s, i, r, o = l.BILINEAR_SAMPLINGMODE, a, S) {
-    super(e, "glowBlurPostProcess", ["screenSize", "direction", "blurWidth"], null, i, r, o, a, S), this.direction = t, this.kernel = s, this.onApplyObservable.add((c) => {
-      c.setFloat2("screenSize", this.width, this.height), c.setVector2("direction", this.direction), c.setFloat("blurWidth", this.kernel);
-    });
-  }
-}
-class n extends P {
-  /**
-   * Specifies the horizontal size of the blur.
-   */
-  set blurHorizontalSize(e) {
-    this._horizontalBlurPostprocess.kernel = e, this._options.blurHorizontalSize = e;
-  }
-  /**
-   * Specifies the vertical size of the blur.
-   */
-  set blurVerticalSize(e) {
-    this._verticalBlurPostprocess.kernel = e, this._options.blurVerticalSize = e;
-  }
-  /**
-   * Gets the horizontal size of the blur.
-   */
-  get blurHorizontalSize() {
-    return this._horizontalBlurPostprocess.kernel;
-  }
-  /**
-   * Gets the vertical size of the blur.
-   */
-  get blurVerticalSize() {
-    return this._verticalBlurPostprocess.kernel;
-  }
-  /**
-   * Instantiates a new highlight Layer and references it to the scene..
-   * @param name The name of the layer
-   * @param scene The scene to use the layer in
-   * @param options Sets of none mandatory options to use with the layer (see IHighlightLayerOptions for more information)
-   */
-  constructor(e, t, s) {
-    super(e, t), this.name = e, this.innerGlow = !0, this.outerGlow = !0, this.onBeforeBlurObservable = new m(), this.onAfterBlurObservable = new m(), this._instanceGlowingMeshStencilReference = n.GlowingMeshStencilReference++, this._meshes = {}, this._excludedMeshes = {}, this.neutralColor = n.NeutralColor, this._engine.isStencilEnable || R.Warn("Rendering the Highlight Layer requires the stencil to be active on the canvas. var engine = new Engine(canvas, antialias, { stencil: true }"), this._options = Object.assign({ mainTextureRatio: 0.5, blurTextureSizeRatio: 0.5, blurHorizontalSize: 1, blurVerticalSize: 1, alphaBlendingMode: 2, camera: null, renderingGroupId: -1, mainTextureType: 0 }, s), this._init({
-      alphaBlendingMode: this._options.alphaBlendingMode,
-      camera: this._options.camera,
-      mainTextureFixedSize: this._options.mainTextureFixedSize,
-      mainTextureRatio: this._options.mainTextureRatio,
-      renderingGroupId: this._options.renderingGroupId,
-      mainTextureType: this._options.mainTextureType
-    }), this._shouldRender = !1;
-  }
-  /**
-   * Get the effect name of the layer.
-   * @returns The effect name
-   */
-  getEffectName() {
-    return n.EffectName;
-  }
-  _numInternalDraws() {
-    return 2;
-  }
-  /**
-   * Create the merge effect. This is the shader use to blit the information back
-   * to the main canvas at the end of the scene rendering.
-   */
-  _createMergeEffect() {
-    return this._engine.createEffect("glowMapMerge", [M.PositionKind], ["offset"], ["textureSampler"], this._options.isStroke ? `#define STROKE 
-` : void 0);
-  }
-  /**
-   * Creates the render target textures and post processes used in the highlight layer.
-   */
-  _createTextureAndPostProcesses() {
-    let e = this._mainTextureDesiredSize.width * this._options.blurTextureSizeRatio, t = this._mainTextureDesiredSize.height * this._options.blurTextureSizeRatio;
-    e = this._engine.needPOTTextures ? p.GetExponentOfTwo(e, this._maxSize) : e, t = this._engine.needPOTTextures ? p.GetExponentOfTwo(t, this._maxSize) : t;
-    let s = 0;
-    this._engine.getCaps().textureHalfFloatRender ? s = 2 : s = 0, this._blurTexture = new v("HighlightLayerBlurRTT", {
-      width: e,
-      height: t
-    }, this._scene, !1, !0, s), this._blurTexture.wrapU = l.CLAMP_ADDRESSMODE, this._blurTexture.wrapV = l.CLAMP_ADDRESSMODE, this._blurTexture.anisotropicFilteringLevel = 16, this._blurTexture.updateSamplingMode(l.TRILINEAR_SAMPLINGMODE), this._blurTexture.renderParticles = !1, this._blurTexture.ignoreCameraViewport = !0, this._textures = [this._blurTexture], this._options.alphaBlendingMode === 2 ? (this._downSamplePostprocess = new T("HighlightLayerPPP", this._options.blurTextureSizeRatio, null, l.BILINEAR_SAMPLINGMODE, this._scene.getEngine()), this._downSamplePostprocess.externalTextureSamplerBinding = !0, this._downSamplePostprocess.onApplyObservable.add((i) => {
-      i.setTexture("textureSampler", this._mainTexture);
-    }), this._horizontalBlurPostprocess = new x("HighlightLayerHBP", new d(1, 0), this._options.blurHorizontalSize, 1, null, l.BILINEAR_SAMPLINGMODE, this._scene.getEngine()), this._horizontalBlurPostprocess.onApplyObservable.add((i) => {
-      i.setFloat2("screenSize", e, t);
-    }), this._verticalBlurPostprocess = new x("HighlightLayerVBP", new d(0, 1), this._options.blurVerticalSize, 1, null, l.BILINEAR_SAMPLINGMODE, this._scene.getEngine()), this._verticalBlurPostprocess.onApplyObservable.add((i) => {
-      i.setFloat2("screenSize", e, t);
-    }), this._postProcesses = [this._downSamplePostprocess, this._horizontalBlurPostprocess, this._verticalBlurPostprocess]) : (this._horizontalBlurPostprocess = new b("HighlightLayerHBP", new d(1, 0), this._options.blurHorizontalSize / 2, {
-      width: e,
-      height: t
-    }, null, l.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, s), this._horizontalBlurPostprocess.width = e, this._horizontalBlurPostprocess.height = t, this._horizontalBlurPostprocess.externalTextureSamplerBinding = !0, this._horizontalBlurPostprocess.onApplyObservable.add((i) => {
-      i.setTexture("textureSampler", this._mainTexture);
-    }), this._verticalBlurPostprocess = new b("HighlightLayerVBP", new d(0, 1), this._options.blurVerticalSize / 2, {
-      width: e,
-      height: t
-    }, null, l.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, s), this._postProcesses = [this._horizontalBlurPostprocess, this._verticalBlurPostprocess]), this._mainTexture.onAfterUnbindObservable.add(() => {
-      this.onBeforeBlurObservable.notifyObservers(this);
-      const i = this._blurTexture.renderTarget;
-      i && (this._scene.postProcessManager.directRender(this._postProcesses, i, !0), this._engine.unBindFramebuffer(i, !0)), this.onAfterBlurObservable.notifyObservers(this);
-    }), this._postProcesses.map((i) => {
-      i.autoClear = !1;
-    });
-  }
-  /**
-   * Returns whether or not the layer needs stencil enabled during the mesh rendering.
-   */
-  needStencil() {
-    return !0;
-  }
-  /**
-   * Checks for the readiness of the element composing the layer.
-   * @param subMesh the mesh to check for
-   * @param useInstances specify whether or not to use instances to render the mesh
-   * @returns true if ready otherwise, false
-   */
-  isReady(e, t) {
-    const s = e.getMaterial(), i = e.getRenderingMesh();
-    if (!s || !i || !this._meshes)
-      return !1;
-    let r = null;
-    const o = this._meshes[i.uniqueId];
-    return o && o.glowEmissiveOnly && s && (r = s.emissiveTexture), super._isReady(e, t, r);
-  }
-  /**
-   * Implementation specific of rendering the generating effect on the main canvas.
-   * @param effect The effect used to render through
-   * @param renderIndex
-   */
-  _internalRender(e, t) {
-    e.setTexture("textureSampler", this._blurTexture);
-    const s = this._engine;
-    s.cacheStencilState(), s.setStencilOperationPass(7681), s.setStencilOperationFail(7680), s.setStencilOperationDepthFail(7680), s.setStencilMask(0), s.setStencilBuffer(!0), s.setStencilFunctionReference(this._instanceGlowingMeshStencilReference), this.outerGlow && t === 0 && (e.setFloat("offset", 0), s.setStencilFunction(517), s.drawElementsType(g.TriangleFillMode, 0, 6)), this.innerGlow && t === 1 && (e.setFloat("offset", 1), s.setStencilFunction(514), s.drawElementsType(g.TriangleFillMode, 0, 6)), s.restoreStencilState();
-  }
-  /**
-   * Returns true if the layer contains information to display, otherwise false.
-   */
-  shouldRender() {
-    return super.shouldRender() ? !!this._meshes : !1;
-  }
-  /**
-   * Returns true if the mesh should render, otherwise false.
-   * @param mesh The mesh to render
-   * @returns true if it should render otherwise false
-   */
-  _shouldRenderMesh(e) {
-    return !(this._excludedMeshes && this._excludedMeshes[e.uniqueId] || !super.hasMesh(e));
-  }
-  /**
-   * Returns true if the mesh can be rendered, otherwise false.
-   * @param mesh The mesh to render
-   * @param material The material used on the mesh
-   * @returns true if it can be rendered otherwise false
-   */
-  _canRenderMesh(e, t) {
-    return !0;
-  }
-  /**
-   * Adds specific effects defines.
-   * @param defines The defines to add specifics to.
-   */
-  _addCustomEffectDefines(e) {
-    e.push("#define HIGHLIGHT");
-  }
-  /**
-   * Sets the required values for both the emissive texture and and the main color.
-   * @param mesh
-   * @param subMesh
-   * @param material
-   */
-  _setEmissiveTextureAndColor(e, t, s) {
-    const i = this._meshes[e.uniqueId];
-    i ? this._emissiveTextureAndColor.color.set(i.color.r, i.color.g, i.color.b, 1) : this._emissiveTextureAndColor.color.set(this.neutralColor.r, this.neutralColor.g, this.neutralColor.b, this.neutralColor.a), i && i.glowEmissiveOnly && s ? (this._emissiveTextureAndColor.texture = s.emissiveTexture, this._emissiveTextureAndColor.color.set(1, 1, 1, 1)) : this._emissiveTextureAndColor.texture = null;
-  }
-  /**
-   * Add a mesh in the exclusion list to prevent it to impact or being impacted by the highlight layer.
-   * @param mesh The mesh to exclude from the highlight layer
-   */
-  addExcludedMesh(e) {
-    if (!this._excludedMeshes)
-      return;
-    if (!this._excludedMeshes[e.uniqueId]) {
-      const s = {
-        mesh: e,
-        beforeBind: null,
-        afterRender: null,
-        stencilState: !1
-      };
-      s.beforeBind = e.onBeforeBindObservable.add((i) => {
-        s.stencilState = i.getEngine().getStencilBuffer(), i.getEngine().setStencilBuffer(!1);
-      }), s.afterRender = e.onAfterRenderObservable.add((i) => {
-        i.getEngine().setStencilBuffer(s.stencilState);
-      }), this._excludedMeshes[e.uniqueId] = s;
-    }
-  }
-  /**
-   * Remove a mesh from the exclusion list to let it impact or being impacted by the highlight layer.
-   * @param mesh The mesh to highlight
-   */
-  removeExcludedMesh(e) {
-    if (!this._excludedMeshes)
-      return;
-    const t = this._excludedMeshes[e.uniqueId];
-    t && (t.beforeBind && e.onBeforeBindObservable.remove(t.beforeBind), t.afterRender && e.onAfterRenderObservable.remove(t.afterRender)), this._excludedMeshes[e.uniqueId] = null;
-  }
-  /**
-   * Determine if a given mesh will be highlighted by the current HighlightLayer
-   * @param mesh mesh to test
-   * @returns true if the mesh will be highlighted by the current HighlightLayer
-   */
-  hasMesh(e) {
-    return !this._meshes || !super.hasMesh(e) ? !1 : this._meshes[e.uniqueId] !== void 0 && this._meshes[e.uniqueId] !== null;
-  }
-  /**
-   * Add a mesh in the highlight layer in order to make it glow with the chosen color.
-   * @param mesh The mesh to highlight
-   * @param color The color of the highlight
-   * @param glowEmissiveOnly Extract the glow from the emissive texture
-   */
-  addMesh(e, t, s = !1) {
-    if (!this._meshes)
-      return;
-    const i = this._meshes[e.uniqueId];
-    i ? i.color = t : (this._meshes[e.uniqueId] = {
-      mesh: e,
-      color: t,
-      // Lambda required for capture due to Observable this context
-      observerHighlight: e.onBeforeBindObservable.add((r) => {
-        this.isEnabled && (this._excludedMeshes && this._excludedMeshes[r.uniqueId] ? this._defaultStencilReference(r) : r.getScene().getEngine().setStencilFunctionReference(this._instanceGlowingMeshStencilReference));
-      }),
-      observerDefault: e.onAfterRenderObservable.add((r) => {
-        this.isEnabled && this._defaultStencilReference(r);
-      }),
-      glowEmissiveOnly: s
-    }, e.onDisposeObservable.add(() => {
-      this._disposeMesh(e);
-    })), this._shouldRender = !0;
-  }
-  /**
-   * Remove a mesh from the highlight layer in order to make it stop glowing.
-   * @param mesh The mesh to highlight
-   */
-  removeMesh(e) {
-    if (!this._meshes)
-      return;
-    const t = this._meshes[e.uniqueId];
-    t && (t.observerHighlight && e.onBeforeBindObservable.remove(t.observerHighlight), t.observerDefault && e.onAfterRenderObservable.remove(t.observerDefault), delete this._meshes[e.uniqueId]), this._shouldRender = !1;
-    for (const s in this._meshes)
-      if (this._meshes[s]) {
-        this._shouldRender = !0;
-        break;
-      }
-  }
-  /**
-   * Remove all the meshes currently referenced in the highlight layer
-   */
-  removeAllMeshes() {
-    if (this._meshes) {
-      for (const e in this._meshes)
-        if (Object.prototype.hasOwnProperty.call(this._meshes, e)) {
-          const t = this._meshes[e];
-          t && this.removeMesh(t.mesh);
-        }
-    }
-  }
-  /**
-   * Force the stencil to the normal expected value for none glowing parts
-   * @param mesh
-   */
-  _defaultStencilReference(e) {
-    e.getScene().getEngine().setStencilFunctionReference(n.NormalMeshStencilReference);
-  }
-  /**
-   * Free any resources and references associated to a mesh.
-   * Internal use
-   * @param mesh The mesh to free.
-   * @internal
-   */
-  _disposeMesh(e) {
-    this.removeMesh(e), this.removeExcludedMesh(e);
-  }
-  /**
-   * Dispose the highlight layer and free resources.
-   */
-  dispose() {
-    if (this._meshes) {
-      for (const e in this._meshes) {
-        const t = this._meshes[e];
-        t && t.mesh && (t.observerHighlight && t.mesh.onBeforeBindObservable.remove(t.observerHighlight), t.observerDefault && t.mesh.onAfterRenderObservable.remove(t.observerDefault));
-      }
-      this._meshes = null;
-    }
-    if (this._excludedMeshes) {
-      for (const e in this._excludedMeshes) {
-        const t = this._excludedMeshes[e];
-        t && (t.beforeBind && t.mesh.onBeforeBindObservable.remove(t.beforeBind), t.afterRender && t.mesh.onAfterRenderObservable.remove(t.afterRender));
-      }
-      this._excludedMeshes = null;
-    }
-    super.dispose();
-  }
-  /**
-   * Gets the class name of the effect layer
-   * @returns the string with the class name of the effect layer
-   */
-  getClassName() {
-    return "HighlightLayer";
-  }
-  /**
-   * Serializes this Highlight layer
-   * @returns a serialized Highlight layer object
-   */
-  serialize() {
-    const e = _.Serialize(this);
-    if (e.customType = "BABYLON.HighlightLayer", e.meshes = [], this._meshes)
-      for (const t in this._meshes) {
-        const s = this._meshes[t];
-        s && e.meshes.push({
-          glowEmissiveOnly: s.glowEmissiveOnly,
-          color: s.color.asArray(),
-          meshId: s.mesh.id
-        });
-      }
-    if (e.excludedMeshes = [], this._excludedMeshes)
-      for (const t in this._excludedMeshes) {
-        const s = this._excludedMeshes[t];
-        s && e.excludedMeshes.push(s.mesh.id);
-      }
-    return e;
-  }
-  /**
-   * Creates a Highlight layer from parsed Highlight layer data
-   * @param parsedHightlightLayer defines the Highlight layer data
-   * @param scene defines the current scene
-   * @param rootUrl defines the root URL containing the Highlight layer information
-   * @returns a parsed Highlight layer
-   */
-  static Parse(e, t, s) {
-    const i = _.Parse(() => new n(e.name, t, e.options), e, t, s);
-    let r;
-    for (r = 0; r < e.excludedMeshes.length; r++) {
-      const o = t.getMeshById(e.excludedMeshes[r]);
-      o && i.addExcludedMesh(o);
-    }
-    for (r = 0; r < e.meshes.length; r++) {
-      const o = e.meshes[r], a = t.getMeshById(o.meshId);
-      a && i.addMesh(a, w.FromArray(o.color), o.glowEmissiveOnly);
-    }
-    return i;
-  }
-}
-n.EffectName = "HighlightLayer";
-n.NeutralColor = new z(0, 0, 0, 0);
-n.GlowingMeshStencilReference = 2;
-n.NormalMeshStencilReference = 1;
-h([
-  u()
-], n.prototype, "innerGlow", void 0);
-h([
-  u()
-], n.prototype, "outerGlow", void 0);
-h([
-  u()
-], n.prototype, "blurHorizontalSize", null);
-h([
-  u()
-], n.prototype, "blurVerticalSize", null);
-h([
-  u("options")
-], n.prototype, "_options", void 0);
-O("BABYLON.HighlightLayer", n);
-export {
-  n as HighlightLayer
-};

package/dist/node_modules/@babylonjs/core/Lights/directionalLight.esm.js

@@ -1,224 +0,0 @@
-import { __decorate as r } from "../tslib.es6.esm.js";
-import { serialize as h } from "../Misc/decorators.esm.js";
-import { Vector3 as m, Matrix as S } from "../Maths/math.vector.esm.js";
-import { Node as M } from "../node.esm.js";
-import { Light as B } from "./light.esm.js";
-import { ShadowLight as D } from "./shadowLight.esm.js";
-M.AddNodeConstructor("Light_Type_1", (c, t) => () => new i(c, m.Zero(), t));
-class i extends D {
-  /**
-   * Fix frustum size for the shadow generation. This is disabled if the value is 0.
-   */
-  get shadowFrustumSize() {
-    return this._shadowFrustumSize;
-  }
-  /**
-   * Specifies a fix frustum size for the shadow generation.
-   */
-  set shadowFrustumSize(t) {
-    this._shadowFrustumSize = t, this.forceProjectionMatrixCompute();
-  }
-  /**
-   * Gets the shadow projection scale against the optimal computed one.
-   * 0.1 by default which means that the projection window is increase by 10% from the optimal size.
-   * This does not impact in fixed frustum size (shadowFrustumSize being set)
-   */
-  get shadowOrthoScale() {
-    return this._shadowOrthoScale;
-  }
-  /**
-   * Sets the shadow projection scale against the optimal computed one.
-   * 0.1 by default which means that the projection window is increase by 10% from the optimal size.
-   * This does not impact in fixed frustum size (shadowFrustumSize being set)
-   */
-  set shadowOrthoScale(t) {
-    this._shadowOrthoScale = t, this.forceProjectionMatrixCompute();
-  }
-  /**
-   * Gets or sets the orthoLeft property used to build the light frustum
-   */
-  get orthoLeft() {
-    return this._orthoLeft;
-  }
-  set orthoLeft(t) {
-    this._orthoLeft = t;
-  }
-  /**
-   * Gets or sets the orthoRight property used to build the light frustum
-   */
-  get orthoRight() {
-    return this._orthoRight;
-  }
-  set orthoRight(t) {
-    this._orthoRight = t;
-  }
-  /**
-   * Gets or sets the orthoTop property used to build the light frustum
-   */
-  get orthoTop() {
-    return this._orthoTop;
-  }
-  set orthoTop(t) {
-    this._orthoTop = t;
-  }
-  /**
-   * Gets or sets the orthoBottom property used to build the light frustum
-   */
-  get orthoBottom() {
-    return this._orthoBottom;
-  }
-  set orthoBottom(t) {
-    this._orthoBottom = t;
-  }
-  /**
-   * Creates a DirectionalLight object in the scene, oriented towards the passed direction (Vector3).
-   * The directional light is emitted from everywhere in the given direction.
-   * It can cast shadows.
-   * Documentation : https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
-   * @param name The friendly name of the light
-   * @param direction The direction of the light
-   * @param scene The scene the light belongs to
-   */
-  constructor(t, o, s) {
-    super(t, s), this._shadowFrustumSize = 0, this._shadowOrthoScale = 0.1, this.autoUpdateExtends = !0, this.autoCalcShadowZBounds = !1, this._orthoLeft = Number.MAX_VALUE, this._orthoRight = Number.MIN_VALUE, this._orthoTop = Number.MIN_VALUE, this._orthoBottom = Number.MAX_VALUE, this.position = o.scale(-1), this.direction = o;
-  }
-  /**
-   * Returns the string "DirectionalLight".
-   * @returns The class name
-   */
-  getClassName() {
-    return "DirectionalLight";
-  }
-  /**
-   * Returns the integer 1.
-   * @returns The light Type id as a constant defines in Light.LIGHTTYPEID_x
-   */
-  getTypeID() {
-    return B.LIGHTTYPEID_DIRECTIONALLIGHT;
-  }
-  /**
-   * Sets the passed matrix "matrix" as projection matrix for the shadows cast by the light according to the passed view matrix.
-   * Returns the DirectionalLight Shadow projection matrix.
-   * @param matrix
-   * @param viewMatrix
-   * @param renderList
-   */
-  _setDefaultShadowProjectionMatrix(t, o, s) {
-    this.shadowFrustumSize > 0 ? this._setDefaultFixedFrustumShadowProjectionMatrix(t) : this._setDefaultAutoExtendShadowProjectionMatrix(t, o, s);
-  }
-  /**
-   * Sets the passed matrix "matrix" as fixed frustum projection matrix for the shadows cast by the light according to the passed view matrix.
-   * Returns the DirectionalLight Shadow projection matrix.
-   * @param matrix
-   */
-  _setDefaultFixedFrustumShadowProjectionMatrix(t) {
-    const o = this.getScene().activeCamera;
-    o && S.OrthoLHToRef(this.shadowFrustumSize, this.shadowFrustumSize, this.shadowMinZ !== void 0 ? this.shadowMinZ : o.minZ, this.shadowMaxZ !== void 0 ? this.shadowMaxZ : o.maxZ, t, this.getScene().getEngine().isNDCHalfZRange);
-  }
-  /**
-   * Sets the passed matrix "matrix" as auto extend projection matrix for the shadows cast by the light according to the passed view matrix.
-   * Returns the DirectionalLight Shadow projection matrix.
-   * @param matrix
-   * @param viewMatrix
-   * @param renderList
-   */
-  _setDefaultAutoExtendShadowProjectionMatrix(t, o, s) {
-    const n = this.getScene().activeCamera;
-    if (!n)
-      return;
-    if (this.autoUpdateExtends || this._orthoLeft === Number.MAX_VALUE) {
-      const e = m.Zero();
-      this._orthoLeft = Number.MAX_VALUE, this._orthoRight = Number.MIN_VALUE, this._orthoTop = Number.MIN_VALUE, this._orthoBottom = Number.MAX_VALUE;
-      let a = Number.MAX_VALUE, f = Number.MIN_VALUE;
-      for (let u = 0; u < s.length; u++) {
-        const L = s[u];
-        if (!L)
-          continue;
-        const x = L.getBoundingInfo().boundingBox;
-        for (let d = 0; d < x.vectorsWorld.length; d++)
-          m.TransformCoordinatesToRef(x.vectorsWorld[d], o, e), e.x < this._orthoLeft && (this._orthoLeft = e.x), e.y < this._orthoBottom && (this._orthoBottom = e.y), e.x > this._orthoRight && (this._orthoRight = e.x), e.y > this._orthoTop && (this._orthoTop = e.y), this.autoCalcShadowZBounds && (e.z < a && (a = e.z), e.z > f && (f = e.z));
-      }
-      this.autoCalcShadowZBounds && (this._shadowMinZ = a, this._shadowMaxZ = f);
-    }
-    const _ = this._orthoRight - this._orthoLeft, g = this._orthoTop - this._orthoBottom, p = this.shadowMinZ !== void 0 ? this.shadowMinZ : n.minZ, l = this.shadowMaxZ !== void 0 ? this.shadowMaxZ : n.maxZ, w = this.getScene().getEngine().useReverseDepthBuffer;
-    S.OrthoOffCenterLHToRef(this._orthoLeft - _ * this.shadowOrthoScale, this._orthoRight + _ * this.shadowOrthoScale, this._orthoBottom - g * this.shadowOrthoScale, this._orthoTop + g * this.shadowOrthoScale, w ? l : p, w ? p : l, t, this.getScene().getEngine().isNDCHalfZRange);
-  }
-  _buildUniformLayout() {
-    this._uniformBuffer.addUniform("vLightData", 4), this._uniformBuffer.addUniform("vLightDiffuse", 4), this._uniformBuffer.addUniform("vLightSpecular", 4), this._uniformBuffer.addUniform("shadowsInfo", 3), this._uniformBuffer.addUniform("depthValues", 2), this._uniformBuffer.create();
-  }
-  /**
-   * Sets the passed Effect object with the DirectionalLight transformed position (or position if not parented) and the passed name.
-   * @param effect The effect to update
-   * @param lightIndex The index of the light in the effect to update
-   * @returns The directional light
-   */
-  transferToEffect(t, o) {
-    return this.computeTransformedInformation() ? (this._uniformBuffer.updateFloat4("vLightData", this.transformedDirection.x, this.transformedDirection.y, this.transformedDirection.z, 1, o), this) : (this._uniformBuffer.updateFloat4("vLightData", this.direction.x, this.direction.y, this.direction.z, 1, o), this);
-  }
-  transferToNodeMaterialEffect(t, o) {
-    return this.computeTransformedInformation() ? (t.setFloat3(o, this.transformedDirection.x, this.transformedDirection.y, this.transformedDirection.z), this) : (t.setFloat3(o, this.direction.x, this.direction.y, this.direction.z), this);
-  }
-  /**
-   * Gets the minZ used for shadow according to both the scene and the light.
-   *
-   * Values are fixed on directional lights as it relies on an ortho projection hence the need to convert being
-   * -1 and 1 to 0 and 1 doing (depth + min) / (min + max) -> (depth + 1) / (1 + 1) -> (depth * 0.5) + 0.5.
-   * (when not using reverse depth buffer / NDC half Z range)
-   * @param activeCamera The camera we are returning the min for
-   * @returns the depth min z
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getDepthMinZ(t) {
-    const o = this._scene.getEngine();
-    return !o.useReverseDepthBuffer && o.isNDCHalfZRange ? 0 : 1;
-  }
-  /**
-   * Gets the maxZ used for shadow according to both the scene and the light.
-   *
-   * Values are fixed on directional lights as it relies on an ortho projection hence the need to convert being
-   * -1 and 1 to 0 and 1 doing (depth + min) / (min + max) -> (depth + 1) / (1 + 1) -> (depth * 0.5) + 0.5.
-   * (when not using reverse depth buffer / NDC half Z range)
-   * @param activeCamera The camera we are returning the max for
-   * @returns the depth max z
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getDepthMaxZ(t) {
-    const o = this._scene.getEngine();
-    return o.useReverseDepthBuffer && o.isNDCHalfZRange ? 0 : 1;
-  }
-  /**
-   * Prepares the list of defines specific to the light type.
-   * @param defines the list of defines
-   * @param lightIndex defines the index of the light for the effect
-   */
-  prepareLightSpecificDefines(t, o) {
-    t["DIRLIGHT" + o] = !0;
-  }
-}
-r([
-  h()
-], i.prototype, "shadowFrustumSize", null);
-r([
-  h()
-], i.prototype, "shadowOrthoScale", null);
-r([
-  h()
-], i.prototype, "autoUpdateExtends", void 0);
-r([
-  h()
-], i.prototype, "autoCalcShadowZBounds", void 0);
-r([
-  h("orthoLeft")
-], i.prototype, "_orthoLeft", void 0);
-r([
-  h("orthoRight")
-], i.prototype, "_orthoRight", void 0);
-r([
-  h("orthoTop")
-], i.prototype, "_orthoTop", void 0);
-r([
-  h("orthoBottom")
-], i.prototype, "_orthoBottom", void 0);
-export {
-  i as DirectionalLight
-};