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

package/dist/node_modules/@babylonjs/core/States/depthCullingState.esm.js

@@ -0,0 +1,69 @@
+class i {
+  /**
+   * Initializes the state.
+   * @param reset
+   */
+  constructor(t = !0) {
+    this._isDepthTestDirty = !1, this._isDepthMaskDirty = !1, this._isDepthFuncDirty = !1, this._isCullFaceDirty = !1, this._isCullDirty = !1, this._isZOffsetDirty = !1, this._isFrontFaceDirty = !1, t && this.reset();
+  }
+  get isDirty() {
+    return this._isDepthFuncDirty || this._isDepthTestDirty || this._isDepthMaskDirty || this._isCullFaceDirty || this._isCullDirty || this._isZOffsetDirty || this._isFrontFaceDirty;
+  }
+  get zOffset() {
+    return this._zOffset;
+  }
+  set zOffset(t) {
+    this._zOffset !== t && (this._zOffset = t, this._isZOffsetDirty = !0);
+  }
+  get zOffsetUnits() {
+    return this._zOffsetUnits;
+  }
+  set zOffsetUnits(t) {
+    this._zOffsetUnits !== t && (this._zOffsetUnits = t, this._isZOffsetDirty = !0);
+  }
+  get cullFace() {
+    return this._cullFace;
+  }
+  set cullFace(t) {
+    this._cullFace !== t && (this._cullFace = t, this._isCullFaceDirty = !0);
+  }
+  get cull() {
+    return this._cull;
+  }
+  set cull(t) {
+    this._cull !== t && (this._cull = t, this._isCullDirty = !0);
+  }
+  get depthFunc() {
+    return this._depthFunc;
+  }
+  set depthFunc(t) {
+    this._depthFunc !== t && (this._depthFunc = t, this._isDepthFuncDirty = !0);
+  }
+  get depthMask() {
+    return this._depthMask;
+  }
+  set depthMask(t) {
+    this._depthMask !== t && (this._depthMask = t, this._isDepthMaskDirty = !0);
+  }
+  get depthTest() {
+    return this._depthTest;
+  }
+  set depthTest(t) {
+    this._depthTest !== t && (this._depthTest = t, this._isDepthTestDirty = !0);
+  }
+  get frontFace() {
+    return this._frontFace;
+  }
+  set frontFace(t) {
+    this._frontFace !== t && (this._frontFace = t, this._isFrontFaceDirty = !0);
+  }
+  reset() {
+    this._depthMask = !0, this._depthTest = !0, this._depthFunc = null, this._cullFace = null, this._cull = null, this._zOffset = 0, this._zOffsetUnits = 0, this._frontFace = null, this._isDepthTestDirty = !0, this._isDepthMaskDirty = !0, this._isDepthFuncDirty = !1, this._isCullFaceDirty = !1, this._isCullDirty = !1, this._isZOffsetDirty = !0, this._isFrontFaceDirty = !1;
+  }
+  apply(t) {
+    this.isDirty && (this._isCullDirty && (this.cull ? t.enable(t.CULL_FACE) : t.disable(t.CULL_FACE), this._isCullDirty = !1), this._isCullFaceDirty && (t.cullFace(this.cullFace), this._isCullFaceDirty = !1), this._isDepthMaskDirty && (t.depthMask(this.depthMask), this._isDepthMaskDirty = !1), this._isDepthTestDirty && (this.depthTest ? t.enable(t.DEPTH_TEST) : t.disable(t.DEPTH_TEST), this._isDepthTestDirty = !1), this._isDepthFuncDirty && (t.depthFunc(this.depthFunc), this._isDepthFuncDirty = !1), this._isZOffsetDirty && (this.zOffset || this.zOffsetUnits ? (t.enable(t.POLYGON_OFFSET_FILL), t.polygonOffset(this.zOffset, this.zOffsetUnits)) : t.disable(t.POLYGON_OFFSET_FILL), this._isZOffsetDirty = !1), this._isFrontFaceDirty && (t.frontFace(this.frontFace), this._isFrontFaceDirty = !1));
+  }
+}
+export {
+  i as DepthCullingState
+};

package/dist/node_modules/@babylonjs/core/States/stencilState.esm.js

@@ -0,0 +1,62 @@
+class s {
+  constructor() {
+    this.reset();
+  }
+  reset() {
+    this.enabled = !1, this.mask = 255, this.func = s.ALWAYS, this.funcRef = 1, this.funcMask = 255, this.opStencilFail = s.KEEP, this.opDepthFail = s.KEEP, this.opStencilDepthPass = s.REPLACE;
+  }
+  get stencilFunc() {
+    return this.func;
+  }
+  set stencilFunc(t) {
+    this.func = t;
+  }
+  get stencilFuncRef() {
+    return this.funcRef;
+  }
+  set stencilFuncRef(t) {
+    this.funcRef = t;
+  }
+  get stencilFuncMask() {
+    return this.funcMask;
+  }
+  set stencilFuncMask(t) {
+    this.funcMask = t;
+  }
+  get stencilOpStencilFail() {
+    return this.opStencilFail;
+  }
+  set stencilOpStencilFail(t) {
+    this.opStencilFail = t;
+  }
+  get stencilOpDepthFail() {
+    return this.opDepthFail;
+  }
+  set stencilOpDepthFail(t) {
+    this.opDepthFail = t;
+  }
+  get stencilOpStencilDepthPass() {
+    return this.opStencilDepthPass;
+  }
+  set stencilOpStencilDepthPass(t) {
+    this.opStencilDepthPass = t;
+  }
+  get stencilMask() {
+    return this.mask;
+  }
+  set stencilMask(t) {
+    this.mask = t;
+  }
+  get stencilTest() {
+    return this.enabled;
+  }
+  set stencilTest(t) {
+    this.enabled = t;
+  }
+}
+s.ALWAYS = 519;
+s.KEEP = 7680;
+s.REPLACE = 7681;
+export {
+  s as StencilState
+};

package/dist/node_modules/@babylonjs/core/States/stencilStateComposer.esm.js

@@ -0,0 +1,70 @@
+class n {
+  get isDirty() {
+    return this._isStencilTestDirty || this._isStencilMaskDirty || this._isStencilFuncDirty || this._isStencilOpDirty;
+  }
+  get func() {
+    return this._func;
+  }
+  set func(t) {
+    this._func !== t && (this._func = t, this._isStencilFuncDirty = !0);
+  }
+  get funcRef() {
+    return this._funcRef;
+  }
+  set funcRef(t) {
+    this._funcRef !== t && (this._funcRef = t, this._isStencilFuncDirty = !0);
+  }
+  get funcMask() {
+    return this._funcMask;
+  }
+  set funcMask(t) {
+    this._funcMask !== t && (this._funcMask = t, this._isStencilFuncDirty = !0);
+  }
+  get opStencilFail() {
+    return this._opStencilFail;
+  }
+  set opStencilFail(t) {
+    this._opStencilFail !== t && (this._opStencilFail = t, this._isStencilOpDirty = !0);
+  }
+  get opDepthFail() {
+    return this._opDepthFail;
+  }
+  set opDepthFail(t) {
+    this._opDepthFail !== t && (this._opDepthFail = t, this._isStencilOpDirty = !0);
+  }
+  get opStencilDepthPass() {
+    return this._opStencilDepthPass;
+  }
+  set opStencilDepthPass(t) {
+    this._opStencilDepthPass !== t && (this._opStencilDepthPass = t, this._isStencilOpDirty = !0);
+  }
+  get mask() {
+    return this._mask;
+  }
+  set mask(t) {
+    this._mask !== t && (this._mask = t, this._isStencilMaskDirty = !0);
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(t) {
+    this._enabled !== t && (this._enabled = t, this._isStencilTestDirty = !0);
+  }
+  constructor(t = !0) {
+    this._isStencilTestDirty = !1, this._isStencilMaskDirty = !1, this._isStencilFuncDirty = !1, this._isStencilOpDirty = !1, this.useStencilGlobalOnly = !1, t && this.reset();
+  }
+  reset() {
+    var t;
+    this.stencilMaterial = void 0, (t = this.stencilGlobal) === null || t === void 0 || t.reset(), this._isStencilTestDirty = !0, this._isStencilMaskDirty = !0, this._isStencilFuncDirty = !0, this._isStencilOpDirty = !0;
+  }
+  apply(t) {
+    var s;
+    if (!t)
+      return;
+    const i = !this.useStencilGlobalOnly && !!(!((s = this.stencilMaterial) === null || s === void 0) && s.enabled);
+    this.enabled = i ? this.stencilMaterial.enabled : this.stencilGlobal.enabled, this.func = i ? this.stencilMaterial.func : this.stencilGlobal.func, this.funcRef = i ? this.stencilMaterial.funcRef : this.stencilGlobal.funcRef, this.funcMask = i ? this.stencilMaterial.funcMask : this.stencilGlobal.funcMask, this.opStencilFail = i ? this.stencilMaterial.opStencilFail : this.stencilGlobal.opStencilFail, this.opDepthFail = i ? this.stencilMaterial.opDepthFail : this.stencilGlobal.opDepthFail, this.opStencilDepthPass = i ? this.stencilMaterial.opStencilDepthPass : this.stencilGlobal.opStencilDepthPass, this.mask = i ? this.stencilMaterial.mask : this.stencilGlobal.mask, this.isDirty && (this._isStencilTestDirty && (this.enabled ? t.enable(t.STENCIL_TEST) : t.disable(t.STENCIL_TEST), this._isStencilTestDirty = !1), this._isStencilMaskDirty && (t.stencilMask(this.mask), this._isStencilMaskDirty = !1), this._isStencilFuncDirty && (t.stencilFunc(this.func, this.funcRef, this.funcMask), this._isStencilFuncDirty = !1), this._isStencilOpDirty && (t.stencilOp(this.opStencilFail, this.opDepthFail, this.opStencilDepthPass), this._isStencilOpDirty = !1));
+  }
+}
+export {
+  n as StencilStateComposer
+};

package/dist/node_modules/@babylonjs/core/abstractScene.esm.js

@@ -0,0 +1,71 @@
+class t {
+  constructor() {
+    this.rootNodes = new Array(), this.cameras = new Array(), this.lights = new Array(), this.meshes = new Array(), this.skeletons = new Array(), this.particleSystems = new Array(), this.animations = [], this.animationGroups = new Array(), this.multiMaterials = new Array(), this.materials = new Array(), this.morphTargetManagers = new Array(), this.geometries = new Array(), this.transformNodes = new Array(), this.actionManagers = new Array(), this.textures = new Array(), this._environmentTexture = null, this.postProcesses = new Array();
+  }
+  /**
+   * Adds a parser in the list of available ones
+   * @param name Defines the name of the parser
+   * @param parser Defines the parser to add
+   */
+  static AddParser(r, e) {
+    this._BabylonFileParsers[r] = e;
+  }
+  /**
+   * Gets a general parser from the list of available ones
+   * @param name Defines the name of the parser
+   * @returns the requested parser or null
+   */
+  static GetParser(r) {
+    return this._BabylonFileParsers[r] ? this._BabylonFileParsers[r] : null;
+  }
+  /**
+   * Adds n individual parser in the list of available ones
+   * @param name Defines the name of the parser
+   * @param parser Defines the parser to add
+   */
+  static AddIndividualParser(r, e) {
+    this._IndividualBabylonFileParsers[r] = e;
+  }
+  /**
+   * Gets an individual parser from the list of available ones
+   * @param name Defines the name of the parser
+   * @returns the requested parser or null
+   */
+  static GetIndividualParser(r) {
+    return this._IndividualBabylonFileParsers[r] ? this._IndividualBabylonFileParsers[r] : null;
+  }
+  /**
+   * Parser json data and populate both a scene and its associated container object
+   * @param jsonData Defines the data to parse
+   * @param scene Defines the scene to parse the data for
+   * @param container Defines the container attached to the parsing sequence
+   * @param rootUrl Defines the root url of the data
+   */
+  static Parse(r, e, a, i) {
+    for (const s in this._BabylonFileParsers)
+      Object.prototype.hasOwnProperty.call(this._BabylonFileParsers, s) && this._BabylonFileParsers[s](r, e, a, i);
+  }
+  /**
+   * Texture used in all pbr material as the reflection texture.
+   * As in the majority of the scene they are the same (exception for multi room and so on),
+   * this is easier to reference from here than from all the materials.
+   */
+  get environmentTexture() {
+    return this._environmentTexture;
+  }
+  set environmentTexture(r) {
+    this._environmentTexture = r;
+  }
+  /**
+   * @returns all meshes, lights, cameras, transformNodes and bones
+   */
+  getNodes() {
+    let r = new Array();
+    return r = r.concat(this.meshes), r = r.concat(this.lights), r = r.concat(this.cameras), r = r.concat(this.transformNodes), this.skeletons.forEach((e) => r = r.concat(e.bones)), r;
+  }
+}
+t._BabylonFileParsers = {};
+t._IndividualBabylonFileParsers = {};
+export {
+  t as AbstractScene
+};