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

package/dist/node_modules/@babylonjs/core/Engines/performanceConfigurator.esm.js

@@ -0,0 +1,22 @@
+class t {
+  /**
+   * @internal
+   */
+  static SetMatrixPrecision(M) {
+    if (t.MatrixTrackPrecisionChange = !1, M && !t.MatrixUse64Bits && t.MatrixTrackedMatrices)
+      for (let a = 0; a < t.MatrixTrackedMatrices.length; ++a) {
+        const s = t.MatrixTrackedMatrices[a], e = s._m;
+        s._m = new Array(16);
+        for (let i = 0; i < 16; ++i)
+          s._m[i] = e[i];
+      }
+    t.MatrixUse64Bits = M, t.MatrixCurrentType = t.MatrixUse64Bits ? Array : Float32Array, t.MatrixTrackedMatrices = null;
+  }
+}
+t.MatrixUse64Bits = !1;
+t.MatrixTrackPrecisionChange = !0;
+t.MatrixCurrentType = Float32Array;
+t.MatrixTrackedMatrices = [];
+export {
+  t as PerformanceConfigurator
+};

package/dist/node_modules/@babylonjs/core/Engines/renderTargetWrapper.esm.js

@@ -0,0 +1,273 @@
+import { InternalTextureSource as v } from "../Materials/Textures/internalTexture.esm.js";
+class A {
+  /**
+   * Gets the depth/stencil texture (if created by a createDepthStencilTexture() call)
+   */
+  get depthStencilTexture() {
+    return this._depthStencilTexture;
+  }
+  /**
+   * Indicates if the depth/stencil texture has a stencil aspect
+   */
+  get depthStencilTextureWithStencil() {
+    return this._depthStencilTextureWithStencil;
+  }
+  /**
+   * Defines if the render target wrapper is for a cube texture or if false a 2d texture
+   */
+  get isCube() {
+    return this._isCube;
+  }
+  /**
+   * Defines if the render target wrapper is for a single or multi target render wrapper
+   */
+  get isMulti() {
+    return this._isMulti;
+  }
+  /**
+   * Defines if the render target wrapper is for a single or an array of textures
+   */
+  get is2DArray() {
+    return this.layers > 0;
+  }
+  /**
+   * Gets the size of the render target wrapper (used for cubes, as width=height in this case)
+   */
+  get size() {
+    return this.width;
+  }
+  /**
+   * Gets the width of the render target wrapper
+   */
+  get width() {
+    return this._size.width || this._size;
+  }
+  /**
+   * Gets the height of the render target wrapper
+   */
+  get height() {
+    return this._size.height || this._size;
+  }
+  /**
+   * Gets the number of layers of the render target wrapper (only used if is2DArray is true and wrapper is not a multi render target)
+   */
+  get layers() {
+    return this._size.layers || 0;
+  }
+  /**
+   * Gets the render texture. If this is a multi render target, gets the first texture
+   */
+  get texture() {
+    var e, t;
+    return (t = (e = this._textures) === null || e === void 0 ? void 0 : e[0]) !== null && t !== void 0 ? t : null;
+  }
+  /**
+   * Gets the list of render textures. If we are not in a multi render target, the list will be null (use the texture getter instead)
+   */
+  get textures() {
+    return this._textures;
+  }
+  /**
+   * Gets the face indices that correspond to the list of render textures. If we are not in a multi render target, the list will be null
+   */
+  get faceIndices() {
+    return this._faceIndices;
+  }
+  /**
+   * Gets the layer indices that correspond to the list of render textures. If we are not in a multi render target, the list will be null
+   */
+  get layerIndices() {
+    return this._layerIndices;
+  }
+  /**
+   * Gets the sample count of the render target
+   */
+  get samples() {
+    return this._samples;
+  }
+  /**
+   * Sets the sample count of the render target
+   * @param value sample count
+   * @param initializeBuffers If set to true, the engine will make an initializing call to drawBuffers (only used when isMulti=true).
+   * @param force true to force calling the update sample count engine function even if the current sample count is equal to value
+   * @returns the sample count that has been set
+   */
+  setSamples(e, t = !0, i = !1) {
+    if (this.samples === e && !i)
+      return e;
+    const h = this._isMulti ? this._engine.updateMultipleRenderTargetTextureSampleCount(this, e, t) : this._engine.updateRenderTargetTextureSampleCount(this, e);
+    return this._samples = e, h;
+  }
+  /**
+   * Initializes the render target wrapper
+   * @param isMulti true if the wrapper is a multi render target
+   * @param isCube true if the wrapper should render to a cube texture
+   * @param size size of the render target (width/height/layers)
+   * @param engine engine used to create the render target
+   */
+  constructor(e, t, i, h) {
+    this._textures = null, this._faceIndices = null, this._layerIndices = null, this._samples = 1, this._attachments = null, this._generateStencilBuffer = !1, this._generateDepthBuffer = !1, this._depthStencilTextureWithStencil = !1, this._isMulti = e, this._isCube = t, this._size = i, this._engine = h, this._depthStencilTexture = null;
+  }
+  /**
+   * Sets the render target texture(s)
+   * @param textures texture(s) to set
+   */
+  setTextures(e) {
+    Array.isArray(e) ? this._textures = e : e ? this._textures = [e] : this._textures = null;
+  }
+  /**
+   * Set a texture in the textures array
+   * @param texture The texture to set
+   * @param index The index in the textures array to set
+   * @param disposePrevious If this function should dispose the previous texture
+   */
+  setTexture(e, t = 0, i = !0) {
+    this._textures || (this._textures = []), this._textures[t] && i && this._textures[t].dispose(), this._textures[t] = e;
+  }
+  /**
+   * Sets the layer and face indices of every render target texture bound to each color attachment
+   * @param layers The layers of each texture to be set
+   * @param faces The faces of each texture to be set
+   */
+  setLayerAndFaceIndices(e, t) {
+    this._layerIndices = e, this._faceIndices = t;
+  }
+  /**
+   * Sets the layer and face indices of a texture in the textures array that should be bound to each color attachment
+   * @param index The index of the texture in the textures array to modify
+   * @param layer The layer of the texture to be set
+   * @param face The face of the texture to be set
+   */
+  setLayerAndFaceIndex(e = 0, t, i) {
+    this._layerIndices || (this._layerIndices = []), this._faceIndices || (this._faceIndices = []), t !== void 0 && t >= 0 && (this._layerIndices[e] = t), i !== void 0 && i >= 0 && (this._faceIndices[e] = i);
+  }
+  /**
+   * Creates the depth/stencil texture
+   * @param comparisonFunction Comparison function to use for the texture
+   * @param bilinearFiltering true if bilinear filtering should be used when sampling the texture
+   * @param generateStencil true if the stencil aspect should also be created
+   * @param samples sample count to use when creating the texture
+   * @param format format of the depth texture
+   * @param label defines the label to use for the texture (for debugging purpose only)
+   * @returns the depth/stencil created texture
+   */
+  createDepthStencilTexture(e = 0, t = !0, i = !1, h = 1, p = 14, _) {
+    var u;
+    return (u = this._depthStencilTexture) === null || u === void 0 || u.dispose(), this._depthStencilTextureWithStencil = i, this._depthStencilTexture = this._engine.createDepthStencilTexture(this._size, {
+      bilinearFiltering: t,
+      comparisonFunction: e,
+      generateStencil: i,
+      isCube: this._isCube,
+      samples: h,
+      depthTextureFormat: p,
+      label: _
+    }, this), this._depthStencilTexture;
+  }
+  /**
+   * Shares the depth buffer of this render target with another render target.
+   * @internal
+   * @param renderTarget Destination renderTarget
+   */
+  _shareDepth(e) {
+    this._depthStencilTexture && (e._depthStencilTexture && e._depthStencilTexture.dispose(), e._depthStencilTexture = this._depthStencilTexture, this._depthStencilTexture.incrementReferences());
+  }
+  /**
+   * @internal
+   */
+  _swapAndDie(e) {
+    this.texture && this.texture._swapAndDie(e), this._textures = null, this.dispose(!0);
+  }
+  _cloneRenderTargetWrapper() {
+    var e, t, i, h, p, _, u, x;
+    let l = null;
+    if (this._isMulti) {
+      const s = this.textures;
+      if (s && s.length > 0) {
+        let c = !1, o = s.length;
+        const g = s[s.length - 1]._source;
+        (g === v.Depth || g === v.DepthStencil) && (c = !0, o--);
+        const T = [], S = [], y = [], d = [], m = [], I = [], a = [], f = {};
+        for (let r = 0; r < o; ++r) {
+          const n = s[r];
+          T.push(n.samplingMode), S.push(n.type), y.push(n.format), f[n.uniqueId] !== void 0 ? (d.push(-1), a.push(0)) : (f[n.uniqueId] = r, n.is2DArray ? (d.push(35866), a.push(n.depth)) : n.isCube ? (d.push(34067), a.push(0)) : n.is3D ? (d.push(32879), a.push(n.depth)) : (d.push(3553), a.push(0))), this._faceIndices && m.push((e = this._faceIndices[r]) !== null && e !== void 0 ? e : 0), this._layerIndices && I.push((t = this._layerIndices[r]) !== null && t !== void 0 ? t : 0);
+        }
+        const M = {
+          samplingModes: T,
+          generateMipMaps: s[0].generateMipMaps,
+          generateDepthBuffer: this._generateDepthBuffer,
+          generateStencilBuffer: this._generateStencilBuffer,
+          generateDepthTexture: c,
+          types: S,
+          formats: y,
+          textureCount: o,
+          targetTypes: d,
+          faceIndex: m,
+          layerIndex: I,
+          layerCounts: a
+        }, D = {
+          width: this.width,
+          height: this.height
+        };
+        l = this._engine.createMultipleRenderTarget(D, M);
+        for (let r = 0; r < o; ++r) {
+          if (d[r] !== -1)
+            continue;
+          const n = f[s[r].uniqueId];
+          l.setTexture(l.textures[n], r);
+        }
+      }
+    } else {
+      const s = {};
+      if (s.generateDepthBuffer = this._generateDepthBuffer, s.generateMipMaps = (h = (i = this.texture) === null || i === void 0 ? void 0 : i.generateMipMaps) !== null && h !== void 0 ? h : !1, s.generateStencilBuffer = this._generateStencilBuffer, s.samplingMode = (p = this.texture) === null || p === void 0 ? void 0 : p.samplingMode, s.type = (_ = this.texture) === null || _ === void 0 ? void 0 : _.type, s.format = (u = this.texture) === null || u === void 0 ? void 0 : u.format, this.isCube)
+        l = this._engine.createRenderTargetCubeTexture(this.width, s);
+      else {
+        const c = {
+          width: this.width,
+          height: this.height,
+          layers: this.is2DArray ? (x = this.texture) === null || x === void 0 ? void 0 : x.depth : void 0
+        };
+        l = this._engine.createRenderTargetTexture(c, s);
+      }
+      l.texture.isReady = !0;
+    }
+    return l;
+  }
+  _swapRenderTargetWrapper(e) {
+    if (this._textures && e._textures)
+      for (let t = 0; t < this._textures.length; ++t)
+        this._textures[t]._swapAndDie(e._textures[t], !1), e._textures[t].isReady = !0;
+    this._depthStencilTexture && e._depthStencilTexture && (this._depthStencilTexture._swapAndDie(e._depthStencilTexture), e._depthStencilTexture.isReady = !0), this._textures = null, this._depthStencilTexture = null;
+  }
+  /** @internal */
+  _rebuild() {
+    const e = this._cloneRenderTargetWrapper();
+    if (e) {
+      if (this._depthStencilTexture) {
+        const t = this._depthStencilTexture.samplingMode, i = t === 2 || t === 3 || t === 11;
+        e.createDepthStencilTexture(this._depthStencilTexture._comparisonFunction, i, this._depthStencilTextureWithStencil, this._depthStencilTexture.samples);
+      }
+      this.samples > 1 && e.setSamples(this.samples), e._swapRenderTargetWrapper(this), e.dispose();
+    }
+  }
+  /**
+   * Releases the internal render textures
+   */
+  releaseTextures() {
+    var e, t;
+    if (this._textures)
+      for (let i = 0; (t = i < ((e = this._textures) === null || e === void 0 ? void 0 : e.length)) !== null && t !== void 0 && t; ++i)
+        this._textures[i].dispose();
+    this._textures = null;
+  }
+  /**
+   * Disposes the whole render target wrapper
+   * @param disposeOnlyFramebuffers true if only the frame buffers should be released (used for the WebGL engine). If false, all the textures will also be released
+   */
+  dispose(e = !1) {
+    var t;
+    e || ((t = this._depthStencilTexture) === null || t === void 0 || t.dispose(), this._depthStencilTexture = null, this.releaseTextures()), this._engine._releaseRenderTargetWrapper(this);
+  }
+}
+export {
+  A as RenderTargetWrapper
+};

package/dist/node_modules/@babylonjs/core/Engines/shaderStore.esm.js

@@ -0,0 +1,36 @@
+import { ShaderLanguage as r } from "../Materials/shaderLanguage.esm.js";
+class e {
+  /**
+   * Gets the shaders repository path for a given shader language
+   * @param shaderLanguage the shader language
+   * @returns the path to the shaders repository
+   */
+  static GetShadersRepository(s = r.GLSL) {
+    return s === r.GLSL ? e.ShadersRepository : e.ShadersRepositoryWGSL;
+  }
+  /**
+   * Gets the shaders store of a given shader language
+   * @param shaderLanguage the shader language
+   * @returns the shaders store
+   */
+  static GetShadersStore(s = r.GLSL) {
+    return s === r.GLSL ? e.ShadersStore : e.ShadersStoreWGSL;
+  }
+  /**
+   * Gets the include shaders store of a given shader language
+   * @param shaderLanguage the shader language
+   * @returns the include shaders store
+   */
+  static GetIncludesShadersStore(s = r.GLSL) {
+    return s === r.GLSL ? e.IncludesShadersStore : e.IncludesShadersStoreWGSL;
+  }
+}
+e.ShadersRepository = "src/Shaders/";
+e.ShadersStore = {};
+e.IncludesShadersStore = {};
+e.ShadersRepositoryWGSL = "src/ShadersWGSL/";
+e.ShadersStoreWGSL = {};
+e.IncludesShadersStoreWGSL = {};
+export {
+  e as ShaderStore
+};