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

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

@@ -0,0 +1,396 @@
+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

@@ -0,0 +1,224 @@
+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
+};