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

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

@@ -0,0 +1,92 @@
+import { __decorate as s } from "../tslib.es6.esm.js";
+import { serializeAsColor3 as a, serializeAsVector3 as u } from "../Misc/decorators.esm.js";
+import { Vector3 as o, Matrix as d } from "../Maths/math.vector.esm.js";
+import { Color3 as h } from "../Maths/math.color.esm.js";
+import { Node as m } from "../node.esm.js";
+import { Light as f } from "./light.esm.js";
+m.AddNodeConstructor("Light_Type_3", (n, r) => () => new e(n, o.Zero(), r));
+class e extends f {
+  /**
+   * Creates a HemisphericLight object in the scene according to the passed direction (Vector3).
+   * The HemisphericLight simulates the ambient environment light, so the passed direction is the light reflection direction, not the incoming direction.
+   * The HemisphericLight can't 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 reflection
+   * @param scene The scene the light belongs to
+   */
+  constructor(r, i, t) {
+    super(r, t), this.groundColor = new h(0, 0, 0), this.direction = i || o.Up();
+  }
+  _buildUniformLayout() {
+    this._uniformBuffer.addUniform("vLightData", 4), this._uniformBuffer.addUniform("vLightDiffuse", 4), this._uniformBuffer.addUniform("vLightSpecular", 4), this._uniformBuffer.addUniform("vLightGround", 3), this._uniformBuffer.addUniform("shadowsInfo", 3), this._uniformBuffer.addUniform("depthValues", 2), this._uniformBuffer.create();
+  }
+  /**
+   * Returns the string "HemisphericLight".
+   * @returns The class name
+   */
+  getClassName() {
+    return "HemisphericLight";
+  }
+  /**
+   * Sets the HemisphericLight direction towards the passed target (Vector3).
+   * Returns the updated direction.
+   * @param target The target the direction should point to
+   * @returns The computed direction
+   */
+  setDirectionToTarget(r) {
+    return this.direction = o.Normalize(r.subtract(o.Zero())), this.direction;
+  }
+  /**
+   * Returns the shadow generator associated to the light.
+   * @returns Always null for hemispheric lights because it does not support shadows.
+   */
+  getShadowGenerator() {
+    return null;
+  }
+  /**
+   * Sets the passed Effect object with the HemisphericLight normalized direction and color and the passed name (string).
+   * @param _effect The effect to update
+   * @param lightIndex The index of the light in the effect to update
+   * @returns The hemispheric light
+   */
+  transferToEffect(r, i) {
+    const t = o.Normalize(this.direction);
+    return this._uniformBuffer.updateFloat4("vLightData", t.x, t.y, t.z, 0, i), this._uniformBuffer.updateColor3("vLightGround", this.groundColor.scale(this.intensity), i), this;
+  }
+  transferToNodeMaterialEffect(r, i) {
+    const t = o.Normalize(this.direction);
+    return r.setFloat3(i, t.x, t.y, t.z), this;
+  }
+  /**
+   * Computes the world matrix of the node
+   * @returns the world matrix
+   */
+  computeWorldMatrix() {
+    return this._worldMatrix || (this._worldMatrix = d.Identity()), this._worldMatrix;
+  }
+  /**
+   * Returns the integer 3.
+   * @returns The light Type id as a constant defines in Light.LIGHTTYPEID_x
+   */
+  getTypeID() {
+    return f.LIGHTTYPEID_HEMISPHERICLIGHT;
+  }
+  /**
+   * 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(r, i) {
+    r["HEMILIGHT" + i] = !0;
+  }
+}
+s([
+  a()
+], e.prototype, "groundColor", void 0);
+s([
+  u()
+], e.prototype, "direction", void 0);
+export {
+  e as HemisphericLight
+};

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

@@ -0,0 +1,476 @@
+import { __decorate as h } from "../tslib.es6.esm.js";
+import { SerializationHelper as c, serializeAsColor3 as M, serialize as d, expandToProperty as y } from "../Misc/decorators.esm.js";
+import { Vector3 as E } from "../Maths/math.vector.esm.js";
+import { Color3 as _, TmpColors as I } from "../Maths/math.color.esm.js";
+import { Node as T } from "../node.esm.js";
+import { UniformBuffer as p } from "../Materials/uniformBuffer.esm.js";
+import { GetClass as S } from "../Misc/typeStore.esm.js";
+import { LightConstants as r } from "./lightConstants.esm.js";
+class t extends T {
+  /**
+   * Defines how far from the source the light is impacting in scene units.
+   * Note: Unused in PBR material as the distance light falloff is defined following the inverse squared falloff.
+   */
+  get range() {
+    return this._range;
+  }
+  /**
+   * Defines how far from the source the light is impacting in scene units.
+   * Note: Unused in PBR material as the distance light falloff is defined following the inverse squared falloff.
+   */
+  set range(e) {
+    this._range = e, this._inverseSquaredRange = 1 / (this.range * this.range);
+  }
+  /**
+   * Gets the photometric scale used to interpret the intensity.
+   * This is only relevant with PBR Materials where the light intensity can be defined in a physical way.
+   */
+  get intensityMode() {
+    return this._intensityMode;
+  }
+  /**
+   * Sets the photometric scale used to interpret the intensity.
+   * This is only relevant with PBR Materials where the light intensity can be defined in a physical way.
+   */
+  set intensityMode(e) {
+    this._intensityMode = e, this._computePhotometricScale();
+  }
+  /**
+   * Gets the light radius used by PBR Materials to simulate soft area lights.
+   */
+  get radius() {
+    return this._radius;
+  }
+  /**
+   * sets the light radius used by PBR Materials to simulate soft area lights.
+   */
+  set radius(e) {
+    this._radius = e, this._computePhotometricScale();
+  }
+  /**
+   * Gets whether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
+   * the current shadow generator.
+   */
+  get shadowEnabled() {
+    return this._shadowEnabled;
+  }
+  /**
+   * Sets whether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
+   * the current shadow generator.
+   */
+  set shadowEnabled(e) {
+    this._shadowEnabled !== e && (this._shadowEnabled = e, this._markMeshesAsLightDirty());
+  }
+  /**
+   * Gets the only meshes impacted by this light.
+   */
+  get includedOnlyMeshes() {
+    return this._includedOnlyMeshes;
+  }
+  /**
+   * Sets the only meshes impacted by this light.
+   */
+  set includedOnlyMeshes(e) {
+    this._includedOnlyMeshes = e, this._hookArrayForIncludedOnly(e);
+  }
+  /**
+   * Gets the meshes not impacted by this light.
+   */
+  get excludedMeshes() {
+    return this._excludedMeshes;
+  }
+  /**
+   * Sets the meshes not impacted by this light.
+   */
+  set excludedMeshes(e) {
+    this._excludedMeshes = e, this._hookArrayForExcluded(e);
+  }
+  /**
+   * Gets the layer id use to find what meshes are not impacted by the light.
+   * Inactive if 0
+   */
+  get excludeWithLayerMask() {
+    return this._excludeWithLayerMask;
+  }
+  /**
+   * Sets the layer id use to find what meshes are not impacted by the light.
+   * Inactive if 0
+   */
+  set excludeWithLayerMask(e) {
+    this._excludeWithLayerMask = e, this._resyncMeshes();
+  }
+  /**
+   * Gets the layer id use to find what meshes are impacted by the light.
+   * Inactive if 0
+   */
+  get includeOnlyWithLayerMask() {
+    return this._includeOnlyWithLayerMask;
+  }
+  /**
+   * Sets the layer id use to find what meshes are impacted by the light.
+   * Inactive if 0
+   */
+  set includeOnlyWithLayerMask(e) {
+    this._includeOnlyWithLayerMask = e, this._resyncMeshes();
+  }
+  /**
+   * Gets the lightmap mode of this light (should be one of the constants defined by Light.LIGHTMAP_x)
+   */
+  get lightmapMode() {
+    return this._lightmapMode;
+  }
+  /**
+   * Sets the lightmap mode of this light (should be one of the constants defined by Light.LIGHTMAP_x)
+   */
+  set lightmapMode(e) {
+    this._lightmapMode !== e && (this._lightmapMode = e, this._markMeshesAsLightDirty());
+  }
+  /**
+   * Creates a Light object in the scene.
+   * Documentation : https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
+   * @param name The friendly name of the light
+   * @param scene The scene the light belongs too
+   */
+  constructor(e, i) {
+    super(e, i), this.diffuse = new _(1, 1, 1), this.specular = new _(1, 1, 1), this.falloffType = t.FALLOFF_DEFAULT, this.intensity = 1, this._range = Number.MAX_VALUE, this._inverseSquaredRange = 0, this._photometricScale = 1, this._intensityMode = t.INTENSITYMODE_AUTOMATIC, this._radius = 1e-5, this.renderPriority = 0, this._shadowEnabled = !0, this._excludeWithLayerMask = 0, this._includeOnlyWithLayerMask = 0, this._lightmapMode = 0, this._shadowGenerators = null, this._excludedMeshesIds = new Array(), this._includedOnlyMeshesIds = new Array(), this._isLight = !0, this.getScene().addLight(this), this._uniformBuffer = new p(this.getScene().getEngine(), void 0, void 0, e), this._buildUniformLayout(), this.includedOnlyMeshes = new Array(), this.excludedMeshes = new Array(), this._resyncMeshes();
+  }
+  /**
+   * Sets the passed Effect "effect" with the Light textures.
+   * @param effect The effect to update
+   * @param lightIndex The index of the light in the effect to update
+   * @returns The light
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  transferTexturesToEffect(e, i) {
+    return this;
+  }
+  /**
+   * Binds the lights information from the scene to the effect for the given mesh.
+   * @param lightIndex Light index
+   * @param scene The scene where the light belongs to
+   * @param effect The effect we are binding the data to
+   * @param useSpecular Defines if specular is supported
+   * @param receiveShadows Defines if the effect (mesh) we bind the light for receives shadows
+   */
+  _bindLight(e, i, n, s, o = !0) {
+    var a;
+    const l = e.toString();
+    let f = !1;
+    if (this._uniformBuffer.bindToEffect(n, "Light" + l), this._renderId !== i.getRenderId() || this._lastUseSpecular !== s || !this._uniformBuffer.useUbo) {
+      this._renderId = i.getRenderId(), this._lastUseSpecular = s;
+      const u = this.getScaledIntensity();
+      this.transferToEffect(n, l), this.diffuse.scaleToRef(u, I.Color3[0]), this._uniformBuffer.updateColor4("vLightDiffuse", I.Color3[0], this.range, l), s && (this.specular.scaleToRef(u, I.Color3[1]), this._uniformBuffer.updateColor4("vLightSpecular", I.Color3[1], this.radius, l)), f = !0;
+    }
+    if (this.transferTexturesToEffect(n, l), i.shadowsEnabled && this.shadowEnabled && o) {
+      const u = (a = this.getShadowGenerator(i.activeCamera)) !== null && a !== void 0 ? a : this.getShadowGenerator();
+      u && (u.bindShadowLight(l, n), f = !0);
+    }
+    f ? this._uniformBuffer.update() : this._uniformBuffer.bindUniformBuffer();
+  }
+  /**
+   * Returns the string "Light".
+   * @returns the class name
+   */
+  getClassName() {
+    return "Light";
+  }
+  /**
+   * Converts the light information to a readable string for debug purpose.
+   * @param fullDetails Supports for multiple levels of logging within scene loading
+   * @returns the human readable light info
+   */
+  toString(e) {
+    let i = "Name: " + this.name;
+    if (i += ", type: " + ["Point", "Directional", "Spot", "Hemispheric"][this.getTypeID()], this.animations)
+      for (let n = 0; n < this.animations.length; n++)
+        i += ", animation[0]: " + this.animations[n].toString(e);
+    return i;
+  }
+  /** @internal */
+  _syncParentEnabledState() {
+    super._syncParentEnabledState(), this.isDisposed() || this._resyncMeshes();
+  }
+  /**
+   * Set the enabled state of this node.
+   * @param value - the new enabled state
+   */
+  setEnabled(e) {
+    super.setEnabled(e), this._resyncMeshes();
+  }
+  /**
+   * Returns the Light associated shadow generator if any.
+   * @param camera Camera for which the shadow generator should be retrieved (default: null). If null, retrieves the default shadow generator
+   * @returns the associated shadow generator.
+   */
+  getShadowGenerator(e = null) {
+    var i;
+    return this._shadowGenerators === null ? null : (i = this._shadowGenerators.get(e)) !== null && i !== void 0 ? i : null;
+  }
+  /**
+   * Returns all the shadow generators associated to this light
+   * @returns
+   */
+  getShadowGenerators() {
+    return this._shadowGenerators;
+  }
+  /**
+   * Returns a Vector3, the absolute light position in the World.
+   * @returns the world space position of the light
+   */
+  getAbsolutePosition() {
+    return E.Zero();
+  }
+  /**
+   * Specifies if the light will affect the passed mesh.
+   * @param mesh The mesh to test against the light
+   * @returns true the mesh is affected otherwise, false.
+   */
+  canAffectMesh(e) {
+    return e ? !(this.includedOnlyMeshes && this.includedOnlyMeshes.length > 0 && this.includedOnlyMeshes.indexOf(e) === -1 || this.excludedMeshes && this.excludedMeshes.length > 0 && this.excludedMeshes.indexOf(e) !== -1 || this.includeOnlyWithLayerMask !== 0 && !(this.includeOnlyWithLayerMask & e.layerMask) || this.excludeWithLayerMask !== 0 && this.excludeWithLayerMask & e.layerMask) : !0;
+  }
+  /**
+   * Releases resources associated with this node.
+   * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
+   * @param disposeMaterialAndTextures Set to true to also dispose referenced materials and textures (false by default)
+   */
+  dispose(e, i = !1) {
+    if (this._shadowGenerators) {
+      const n = this._shadowGenerators.values();
+      for (let s = n.next(); s.done !== !0; s = n.next())
+        s.value.dispose();
+      this._shadowGenerators = null;
+    }
+    if (this.getScene().stopAnimation(this), this._parentContainer) {
+      const n = this._parentContainer.lights.indexOf(this);
+      n > -1 && this._parentContainer.lights.splice(n, 1), this._parentContainer = null;
+    }
+    for (const n of this.getScene().meshes)
+      n._removeLightSource(this, !0);
+    this._uniformBuffer.dispose(), this.getScene().removeLight(this), super.dispose(e, i);
+  }
+  /**
+   * Returns the light type ID (integer).
+   * @returns The light Type id as a constant defines in Light.LIGHTTYPEID_x
+   */
+  getTypeID() {
+    return 0;
+  }
+  /**
+   * Returns the intensity scaled by the Photometric Scale according to the light type and intensity mode.
+   * @returns the scaled intensity in intensity mode unit
+   */
+  getScaledIntensity() {
+    return this._photometricScale * this.intensity;
+  }
+  /**
+   * Returns a new Light object, named "name", from the current one.
+   * @param name The name of the cloned light
+   * @param newParent The parent of this light, if it has one
+   * @returns the new created light
+   */
+  clone(e, i = null) {
+    const n = t.GetConstructorFromName(this.getTypeID(), e, this.getScene());
+    if (!n)
+      return null;
+    const s = c.Clone(n, this);
+    return e && (s.name = e), i && (s.parent = i), s.setEnabled(this.isEnabled()), this.onClonedObservable.notifyObservers(s), s;
+  }
+  /**
+   * Serializes the current light into a Serialization object.
+   * @returns the serialized object.
+   */
+  serialize() {
+    const e = c.Serialize(this);
+    return e.uniqueId = this.uniqueId, e.type = this.getTypeID(), this.parent && this.parent._serializeAsParent(e), this.excludedMeshes.length > 0 && (e.excludedMeshesIds = [], this.excludedMeshes.forEach((i) => {
+      e.excludedMeshesIds.push(i.id);
+    })), this.includedOnlyMeshes.length > 0 && (e.includedOnlyMeshesIds = [], this.includedOnlyMeshes.forEach((i) => {
+      e.includedOnlyMeshesIds.push(i.id);
+    })), c.AppendSerializedAnimations(this, e), e.ranges = this.serializeAnimationRanges(), e.isEnabled = this.isEnabled(), e;
+  }
+  /**
+   * Creates a new typed light from the passed type (integer) : point light = 0, directional light = 1, spot light = 2, hemispheric light = 3.
+   * This new light is named "name" and added to the passed scene.
+   * @param type Type according to the types available in Light.LIGHTTYPEID_x
+   * @param name The friendly name of the light
+   * @param scene The scene the new light will belong to
+   * @returns the constructor function
+   */
+  static GetConstructorFromName(e, i, n) {
+    const s = T.Construct("Light_Type_" + e, i, n);
+    return s || null;
+  }
+  /**
+   * Parses the passed "parsedLight" and returns a new instanced Light from this parsing.
+   * @param parsedLight The JSON representation of the light
+   * @param scene The scene to create the parsed light in
+   * @returns the created light after parsing
+   */
+  static Parse(e, i) {
+    const n = t.GetConstructorFromName(e.type, e.name, i);
+    if (!n)
+      return null;
+    const s = c.Parse(n, e, i);
+    if (e.excludedMeshesIds && (s._excludedMeshesIds = e.excludedMeshesIds), e.includedOnlyMeshesIds && (s._includedOnlyMeshesIds = e.includedOnlyMeshesIds), e.parentId !== void 0 && (s._waitingParentId = e.parentId), e.parentInstanceIndex !== void 0 && (s._waitingParentInstanceIndex = e.parentInstanceIndex), e.falloffType !== void 0 && (s.falloffType = e.falloffType), e.lightmapMode !== void 0 && (s.lightmapMode = e.lightmapMode), e.animations) {
+      for (let o = 0; o < e.animations.length; o++) {
+        const a = e.animations[o], l = S("BABYLON.Animation");
+        l && s.animations.push(l.Parse(a));
+      }
+      T.ParseAnimationRanges(s, e, i);
+    }
+    return e.autoAnimate && i.beginAnimation(s, e.autoAnimateFrom, e.autoAnimateTo, e.autoAnimateLoop, e.autoAnimateSpeed || 1), e.isEnabled !== void 0 && s.setEnabled(e.isEnabled), s;
+  }
+  _hookArrayForExcluded(e) {
+    const i = e.push;
+    e.push = (...s) => {
+      const o = i.apply(e, s);
+      for (const a of s)
+        a._resyncLightSource(this);
+      return o;
+    };
+    const n = e.splice;
+    e.splice = (s, o) => {
+      const a = n.apply(e, [s, o]);
+      for (const l of a)
+        l._resyncLightSource(this);
+      return a;
+    };
+    for (const s of e)
+      s._resyncLightSource(this);
+  }
+  _hookArrayForIncludedOnly(e) {
+    const i = e.push;
+    e.push = (...s) => {
+      const o = i.apply(e, s);
+      return this._resyncMeshes(), o;
+    };
+    const n = e.splice;
+    e.splice = (s, o) => {
+      const a = n.apply(e, [s, o]);
+      return this._resyncMeshes(), a;
+    }, this._resyncMeshes();
+  }
+  _resyncMeshes() {
+    for (const e of this.getScene().meshes)
+      e._resyncLightSource(this);
+  }
+  /**
+   * Forces the meshes to update their light related information in their rendering used effects
+   * @internal Internal Use Only
+   */
+  _markMeshesAsLightDirty() {
+    for (const e of this.getScene().meshes)
+      e.lightSources.indexOf(this) !== -1 && e._markSubMeshesAsLightDirty();
+  }
+  /**
+   * Recomputes the cached photometric scale if needed.
+   */
+  _computePhotometricScale() {
+    this._photometricScale = this._getPhotometricScale(), this.getScene().resetCachedMaterial();
+  }
+  /**
+   * Returns the Photometric Scale according to the light type and intensity mode.
+   */
+  _getPhotometricScale() {
+    let e = 0;
+    const i = this.getTypeID();
+    let n = this.intensityMode;
+    switch (n === t.INTENSITYMODE_AUTOMATIC && (i === t.LIGHTTYPEID_DIRECTIONALLIGHT ? n = t.INTENSITYMODE_ILLUMINANCE : n = t.INTENSITYMODE_LUMINOUSINTENSITY), i) {
+      case t.LIGHTTYPEID_POINTLIGHT:
+      case t.LIGHTTYPEID_SPOTLIGHT:
+        switch (n) {
+          case t.INTENSITYMODE_LUMINOUSPOWER:
+            e = 1 / (4 * Math.PI);
+            break;
+          case t.INTENSITYMODE_LUMINOUSINTENSITY:
+            e = 1;
+            break;
+          case t.INTENSITYMODE_LUMINANCE:
+            e = this.radius * this.radius;
+            break;
+        }
+        break;
+      case t.LIGHTTYPEID_DIRECTIONALLIGHT:
+        switch (n) {
+          case t.INTENSITYMODE_ILLUMINANCE:
+            e = 1;
+            break;
+          case t.INTENSITYMODE_LUMINANCE: {
+            let s = this.radius;
+            s = Math.max(s, 1e-3), e = 2 * Math.PI * (1 - Math.cos(s));
+            break;
+          }
+        }
+        break;
+      case t.LIGHTTYPEID_HEMISPHERICLIGHT:
+        e = 1;
+        break;
+    }
+    return e;
+  }
+  /**
+   * Reorder the light in the scene according to their defined priority.
+   * @internal Internal Use Only
+   */
+  _reorderLightsInScene() {
+    const e = this.getScene();
+    this._renderPriority != 0 && (e.requireLightSorting = !0), this.getScene().sortLightsByPriority();
+  }
+}
+t.FALLOFF_DEFAULT = r.FALLOFF_DEFAULT;
+t.FALLOFF_PHYSICAL = r.FALLOFF_PHYSICAL;
+t.FALLOFF_GLTF = r.FALLOFF_GLTF;
+t.FALLOFF_STANDARD = r.FALLOFF_STANDARD;
+t.LIGHTMAP_DEFAULT = r.LIGHTMAP_DEFAULT;
+t.LIGHTMAP_SPECULAR = r.LIGHTMAP_SPECULAR;
+t.LIGHTMAP_SHADOWSONLY = r.LIGHTMAP_SHADOWSONLY;
+t.INTENSITYMODE_AUTOMATIC = r.INTENSITYMODE_AUTOMATIC;
+t.INTENSITYMODE_LUMINOUSPOWER = r.INTENSITYMODE_LUMINOUSPOWER;
+t.INTENSITYMODE_LUMINOUSINTENSITY = r.INTENSITYMODE_LUMINOUSINTENSITY;
+t.INTENSITYMODE_ILLUMINANCE = r.INTENSITYMODE_ILLUMINANCE;
+t.INTENSITYMODE_LUMINANCE = r.INTENSITYMODE_LUMINANCE;
+t.LIGHTTYPEID_POINTLIGHT = r.LIGHTTYPEID_POINTLIGHT;
+t.LIGHTTYPEID_DIRECTIONALLIGHT = r.LIGHTTYPEID_DIRECTIONALLIGHT;
+t.LIGHTTYPEID_SPOTLIGHT = r.LIGHTTYPEID_SPOTLIGHT;
+t.LIGHTTYPEID_HEMISPHERICLIGHT = r.LIGHTTYPEID_HEMISPHERICLIGHT;
+h([
+  M()
+], t.prototype, "diffuse", void 0);
+h([
+  M()
+], t.prototype, "specular", void 0);
+h([
+  d()
+], t.prototype, "falloffType", void 0);
+h([
+  d()
+], t.prototype, "intensity", void 0);
+h([
+  d()
+], t.prototype, "range", null);
+h([
+  d()
+], t.prototype, "intensityMode", null);
+h([
+  d()
+], t.prototype, "radius", null);
+h([
+  d()
+], t.prototype, "_renderPriority", void 0);
+h([
+  y("_reorderLightsInScene")
+], t.prototype, "renderPriority", void 0);
+h([
+  d("shadowEnabled")
+], t.prototype, "_shadowEnabled", void 0);
+h([
+  d("excludeWithLayerMask")
+], t.prototype, "_excludeWithLayerMask", void 0);
+h([
+  d("includeOnlyWithLayerMask")
+], t.prototype, "_includeOnlyWithLayerMask", void 0);
+h([
+  d("lightmapMode")
+], t.prototype, "_lightmapMode", void 0);
+export {
+  t as Light
+};

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

@@ -0,0 +1,30 @@
+class I {
+  /**
+   * Sort function to order lights for rendering.
+   * @param a First Light object to compare to second.
+   * @param b Second Light object to compare first.
+   * @returns -1 to reduce's a's index relative to be, 0 for no change, 1 to increase a's index relative to b.
+   */
+  static CompareLightsPriority(T, L) {
+    return T.shadowEnabled !== L.shadowEnabled ? (L.shadowEnabled ? 1 : 0) - (T.shadowEnabled ? 1 : 0) : L.renderPriority - T.renderPriority;
+  }
+}
+I.FALLOFF_DEFAULT = 0;
+I.FALLOFF_PHYSICAL = 1;
+I.FALLOFF_GLTF = 2;
+I.FALLOFF_STANDARD = 3;
+I.LIGHTMAP_DEFAULT = 0;
+I.LIGHTMAP_SPECULAR = 1;
+I.LIGHTMAP_SHADOWSONLY = 2;
+I.INTENSITYMODE_AUTOMATIC = 0;
+I.INTENSITYMODE_LUMINOUSPOWER = 1;
+I.INTENSITYMODE_LUMINOUSINTENSITY = 2;
+I.INTENSITYMODE_ILLUMINANCE = 3;
+I.INTENSITYMODE_LUMINANCE = 4;
+I.LIGHTTYPEID_POINTLIGHT = 0;
+I.LIGHTTYPEID_DIRECTIONALLIGHT = 1;
+I.LIGHTTYPEID_SPOTLIGHT = 2;
+I.LIGHTTYPEID_HEMISPHERICLIGHT = 3;
+export {
+  I as LightConstants
+};