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

package/dist/node_modules/@babylonjs/core/Rendering/geometryBufferRendererSceneComponent.esm.js

@@ -0,0 +1,55 @@
+import { Scene as n } from "../scene.esm.js";
+import { SceneComponentConstants as t } from "../sceneComponent.esm.js";
+import { GeometryBufferRenderer as o } from "./geometryBufferRenderer.esm.js";
+Object.defineProperty(n.prototype, "geometryBufferRenderer", {
+  get: function() {
+    return this._geometryBufferRenderer;
+  },
+  set: function(e) {
+    e && e.isSupported && (this._geometryBufferRenderer = e);
+  },
+  enumerable: !0,
+  configurable: !0
+});
+n.prototype.enableGeometryBufferRenderer = function(e = 1, r = 15) {
+  return this._geometryBufferRenderer ? this._geometryBufferRenderer : (this._geometryBufferRenderer = new o(this, e, r), this._geometryBufferRenderer.isSupported || (this._geometryBufferRenderer = null), this._geometryBufferRenderer);
+};
+n.prototype.disableGeometryBufferRenderer = function() {
+  this._geometryBufferRenderer && (this._geometryBufferRenderer.dispose(), this._geometryBufferRenderer = null);
+};
+class f {
+  /**
+   * Creates a new instance of the component for the given scene
+   * @param scene Defines the scene to register the component in
+   */
+  constructor(r) {
+    this.name = t.NAME_GEOMETRYBUFFERRENDERER, this.scene = r;
+  }
+  /**
+   * Registers the component in a given scene
+   */
+  register() {
+    this.scene._gatherRenderTargetsStage.registerStep(t.STEP_GATHERRENDERTARGETS_GEOMETRYBUFFERRENDERER, this, this._gatherRenderTargets);
+  }
+  /**
+   * Rebuilds the elements related to this component in case of
+   * context lost for instance.
+   */
+  rebuild() {
+  }
+  /**
+   * Disposes the component and the associated resources
+   */
+  dispose() {
+  }
+  _gatherRenderTargets(r) {
+    this.scene._geometryBufferRenderer && r.push(this.scene._geometryBufferRenderer.getGBuffer());
+  }
+}
+o._SceneComponentInitialization = (e) => {
+  let r = e._getComponent(t.NAME_GEOMETRYBUFFERRENDERER);
+  r || (r = new f(e), e._addComponent(r));
+};
+export {
+  f as GeometryBufferRendererSceneComponent
+};

package/dist/node_modules/@babylonjs/core/Rendering/motionBlurConfiguration.esm.js

@@ -0,0 +1,8 @@
+class e {
+  constructor() {
+    this.enabled = !1, this.name = "motionBlur", this.texturesRequired = [2];
+  }
+}
+export {
+  e as MotionBlurConfiguration
+};

package/dist/node_modules/@babylonjs/core/Rendering/renderingGroup.esm.js

@@ -0,0 +1,223 @@
+import { SmartArray as p, SmartArrayNoDuplicate as u } from "../Misc/smartArray.esm.js";
+import { Vector3 as c } from "../Maths/math.vector.esm.js";
+class i {
+  /**
+   * Set the opaque sort comparison function.
+   * If null the sub meshes will be render in the order they were created
+   */
+  set opaqueSortCompareFn(e) {
+    e ? this._opaqueSortCompareFn = e : this._opaqueSortCompareFn = i.PainterSortCompare, this._renderOpaque = this._renderOpaqueSorted;
+  }
+  /**
+   * Set the alpha test sort comparison function.
+   * If null the sub meshes will be render in the order they were created
+   */
+  set alphaTestSortCompareFn(e) {
+    e ? this._alphaTestSortCompareFn = e : this._alphaTestSortCompareFn = i.PainterSortCompare, this._renderAlphaTest = this._renderAlphaTestSorted;
+  }
+  /**
+   * Set the transparent sort comparison function.
+   * If null the sub meshes will be render in the order they were created
+   */
+  set transparentSortCompareFn(e) {
+    e ? this._transparentSortCompareFn = e : this._transparentSortCompareFn = i.defaultTransparentSortCompare, this._renderTransparent = this._renderTransparentSorted;
+  }
+  /**
+   * Creates a new rendering group.
+   * @param index The rendering group index
+   * @param scene
+   * @param opaqueSortCompareFn The opaque sort comparison function. If null no order is applied
+   * @param alphaTestSortCompareFn The alpha test sort comparison function. If null no order is applied
+   * @param transparentSortCompareFn The transparent sort comparison function. If null back to front + alpha index sort is applied
+   */
+  constructor(e, t, s = null, n = null, r = null) {
+    this.index = e, this._opaqueSubMeshes = new p(256), this._transparentSubMeshes = new p(256), this._alphaTestSubMeshes = new p(256), this._depthOnlySubMeshes = new p(256), this._particleSystems = new p(256), this._spriteManagers = new p(256), this._empty = !0, this._edgesRenderers = new u(16), this._scene = t, this.opaqueSortCompareFn = s, this.alphaTestSortCompareFn = n, this.transparentSortCompareFn = r;
+  }
+  /**
+   * Render all the sub meshes contained in the group.
+   * @param customRenderFunction Used to override the default render behaviour of the group.
+   * @param renderSprites
+   * @param renderParticles
+   * @param activeMeshes
+   * @returns true if rendered some submeshes.
+   */
+  render(e, t, s, n) {
+    if (e) {
+      e(this._opaqueSubMeshes, this._alphaTestSubMeshes, this._transparentSubMeshes, this._depthOnlySubMeshes);
+      return;
+    }
+    const r = this._scene.getEngine();
+    this._depthOnlySubMeshes.length !== 0 && (r.setColorWrite(!1), this._renderAlphaTest(this._depthOnlySubMeshes), r.setColorWrite(!0)), this._opaqueSubMeshes.length !== 0 && this._renderOpaque(this._opaqueSubMeshes), this._alphaTestSubMeshes.length !== 0 && this._renderAlphaTest(this._alphaTestSubMeshes);
+    const a = r.getStencilBuffer();
+    if (r.setStencilBuffer(!1), t && this._renderSprites(), s && this._renderParticles(n), this.onBeforeTransparentRendering && this.onBeforeTransparentRendering(), this._transparentSubMeshes.length !== 0 || this._scene.useOrderIndependentTransparency) {
+      if (r.setStencilBuffer(a), this._scene.useOrderIndependentTransparency) {
+        const h = this._scene.depthPeelingRenderer.render(this._transparentSubMeshes);
+        h.length && this._renderTransparent(h);
+      } else
+        this._renderTransparent(this._transparentSubMeshes);
+      r.setAlphaMode(0);
+    }
+    if (r.setStencilBuffer(!1), this._edgesRenderers.length) {
+      for (let h = 0; h < this._edgesRenderers.length; h++)
+        this._edgesRenderers.data[h].render();
+      r.setAlphaMode(0);
+    }
+    r.setStencilBuffer(a);
+  }
+  /**
+   * Renders the opaque submeshes in the order from the opaqueSortCompareFn.
+   * @param subMeshes The submeshes to render
+   */
+  _renderOpaqueSorted(e) {
+    return i._RenderSorted(e, this._opaqueSortCompareFn, this._scene.activeCamera, !1);
+  }
+  /**
+   * Renders the opaque submeshes in the order from the alphatestSortCompareFn.
+   * @param subMeshes The submeshes to render
+   */
+  _renderAlphaTestSorted(e) {
+    return i._RenderSorted(e, this._alphaTestSortCompareFn, this._scene.activeCamera, !1);
+  }
+  /**
+   * Renders the opaque submeshes in the order from the transparentSortCompareFn.
+   * @param subMeshes The submeshes to render
+   */
+  _renderTransparentSorted(e) {
+    return i._RenderSorted(e, this._transparentSortCompareFn, this._scene.activeCamera, !0);
+  }
+  /**
+   * Renders the submeshes in a specified order.
+   * @param subMeshes The submeshes to sort before render
+   * @param sortCompareFn The comparison function use to sort
+   * @param camera The camera position use to preprocess the submeshes to help sorting
+   * @param transparent Specifies to activate blending if true
+   */
+  static _RenderSorted(e, t, s, n) {
+    let r = 0, a;
+    const h = s ? s.globalPosition : i._ZeroVector;
+    if (n)
+      for (; r < e.length; r++)
+        a = e.data[r], a._alphaIndex = a.getMesh().alphaIndex, a._distanceToCamera = c.Distance(a.getBoundingInfo().boundingSphere.centerWorld, h);
+    const o = e.length === e.data.length ? e.data : e.data.slice(0, e.length);
+    t && o.sort(t);
+    const _ = o[0].getMesh().getScene();
+    for (r = 0; r < o.length; r++)
+      if (a = o[r], !(_._activeMeshesFrozenButKeepClipping && !a.isInFrustum(_._frustumPlanes))) {
+        if (n) {
+          const d = a.getMaterial();
+          if (d && d.needDepthPrePass) {
+            const l = d.getScene().getEngine();
+            l.setColorWrite(!1), l.setAlphaMode(0), a.render(!1), l.setColorWrite(!0);
+          }
+        }
+        a.render(n);
+      }
+  }
+  /**
+   * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+   * are rendered back to front if in the same alpha index.
+   *
+   * @param a The first submesh
+   * @param b The second submesh
+   * @returns The result of the comparison
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static defaultTransparentSortCompare(e, t) {
+    return e._alphaIndex > t._alphaIndex ? 1 : e._alphaIndex < t._alphaIndex ? -1 : i.backToFrontSortCompare(e, t);
+  }
+  /**
+   * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+   * are rendered back to front.
+   *
+   * @param a The first submesh
+   * @param b The second submesh
+   * @returns The result of the comparison
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static backToFrontSortCompare(e, t) {
+    return e._distanceToCamera < t._distanceToCamera ? 1 : e._distanceToCamera > t._distanceToCamera ? -1 : 0;
+  }
+  /**
+   * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+   * are rendered front to back (prevent overdraw).
+   *
+   * @param a The first submesh
+   * @param b The second submesh
+   * @returns The result of the comparison
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static frontToBackSortCompare(e, t) {
+    return e._distanceToCamera < t._distanceToCamera ? -1 : e._distanceToCamera > t._distanceToCamera ? 1 : 0;
+  }
+  /**
+   * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+   * are grouped by material then geometry.
+   *
+   * @param a The first submesh
+   * @param b The second submesh
+   * @returns The result of the comparison
+   */
+  static PainterSortCompare(e, t) {
+    const s = e.getMesh(), n = t.getMesh();
+    return s.material && n.material ? s.material.uniqueId - n.material.uniqueId : s.uniqueId - n.uniqueId;
+  }
+  /**
+   * Resets the different lists of submeshes to prepare a new frame.
+   */
+  prepare() {
+    this._opaqueSubMeshes.reset(), this._transparentSubMeshes.reset(), this._alphaTestSubMeshes.reset(), this._depthOnlySubMeshes.reset(), this._particleSystems.reset(), this.prepareSprites(), this._edgesRenderers.reset(), this._empty = !0;
+  }
+  /**
+   * Resets the different lists of sprites to prepare a new frame.
+   */
+  prepareSprites() {
+    this._spriteManagers.reset();
+  }
+  dispose() {
+    this._opaqueSubMeshes.dispose(), this._transparentSubMeshes.dispose(), this._alphaTestSubMeshes.dispose(), this._depthOnlySubMeshes.dispose(), this._particleSystems.dispose(), this._spriteManagers.dispose(), this._edgesRenderers.dispose();
+  }
+  /**
+   * Inserts the submesh in its correct queue depending on its material.
+   * @param subMesh The submesh to dispatch
+   * @param [mesh] Optional reference to the submeshes's mesh. Provide if you have an exiting reference to improve performance.
+   * @param [material] Optional reference to the submeshes's material. Provide if you have an exiting reference to improve performance.
+   */
+  dispatch(e, t, s) {
+    t === void 0 && (t = e.getMesh()), s === void 0 && (s = e.getMaterial()), s != null && (s.needAlphaBlendingForMesh(t) ? this._transparentSubMeshes.push(e) : s.needAlphaTesting() ? (s.needDepthPrePass && this._depthOnlySubMeshes.push(e), this._alphaTestSubMeshes.push(e)) : (s.needDepthPrePass && this._depthOnlySubMeshes.push(e), this._opaqueSubMeshes.push(e)), t._renderingGroup = this, t._edgesRenderer && t._edgesRenderer.isEnabled && this._edgesRenderers.pushNoDuplicate(t._edgesRenderer), this._empty = !1);
+  }
+  dispatchSprites(e) {
+    this._spriteManagers.push(e), this._empty = !1;
+  }
+  dispatchParticles(e) {
+    this._particleSystems.push(e), this._empty = !1;
+  }
+  _renderParticles(e) {
+    if (this._particleSystems.length === 0)
+      return;
+    const t = this._scene.activeCamera;
+    this._scene.onBeforeParticlesRenderingObservable.notifyObservers(this._scene);
+    for (let s = 0; s < this._particleSystems.length; s++) {
+      const n = this._particleSystems.data[s];
+      if ((t && t.layerMask & n.layerMask) === 0)
+        continue;
+      const r = n.emitter;
+      (!r.position || !e || e.indexOf(r) !== -1) && this._scene._activeParticles.addCount(n.render(), !1);
+    }
+    this._scene.onAfterParticlesRenderingObservable.notifyObservers(this._scene);
+  }
+  _renderSprites() {
+    if (!this._scene.spritesEnabled || this._spriteManagers.length === 0)
+      return;
+    const e = this._scene.activeCamera;
+    this._scene.onBeforeSpritesRenderingObservable.notifyObservers(this._scene);
+    for (let t = 0; t < this._spriteManagers.length; t++) {
+      const s = this._spriteManagers.data[t];
+      (e && e.layerMask & s.layerMask) !== 0 && s.render();
+    }
+    this._scene.onAfterSpritesRenderingObservable.notifyObservers(this._scene);
+  }
+}
+i._ZeroVector = c.Zero();
+export {
+  i as RenderingGroup
+};

package/dist/node_modules/@babylonjs/core/Rendering/renderingManager.esm.js

@@ -0,0 +1,185 @@
+import { RenderingGroup as u } from "./renderingGroup.esm.js";
+class c {
+}
+class s {
+  /**
+   * Gets or sets a boolean indicating that the manager will not reset between frames.
+   * This means that if a mesh becomes invisible or transparent it will not be visible until this boolean is set to false again.
+   * By default, the rendering manager will dispatch all active meshes per frame (moving them to the transparent, opaque or alpha testing lists).
+   * By turning this property on, you will accelerate the rendering by keeping all these lists unchanged between frames.
+   */
+  get maintainStateBetweenFrames() {
+    return this._maintainStateBetweenFrames;
+  }
+  set maintainStateBetweenFrames(e) {
+    if (e !== this._maintainStateBetweenFrames && (this._maintainStateBetweenFrames = e, !this._maintainStateBetweenFrames)) {
+      for (const t of this._scene.meshes)
+        if (t.subMeshes)
+          for (const i of t.subMeshes)
+            i._wasDispatched = !1;
+      if (this._scene.spriteManagers)
+        for (const t of this._scene.spriteManagers)
+          t._wasDispatched = !1;
+      for (const t of this._scene.particleSystems)
+        t._wasDispatched = !1;
+    }
+  }
+  /**
+   * Instantiates a new rendering group for a particular scene
+   * @param scene Defines the scene the groups belongs to
+   */
+  constructor(e) {
+    this._useSceneAutoClearSetup = !1, this._renderingGroups = new Array(), this._autoClearDepthStencil = {}, this._customOpaqueSortCompareFn = {}, this._customAlphaTestSortCompareFn = {}, this._customTransparentSortCompareFn = {}, this._renderingGroupInfo = new c(), this._maintainStateBetweenFrames = !1, this._scene = e;
+    for (let t = s.MIN_RENDERINGGROUPS; t < s.MAX_RENDERINGGROUPS; t++)
+      this._autoClearDepthStencil[t] = { autoClear: !0, depth: !0, stencil: !0 };
+  }
+  /**
+   * Gets the rendering group with the specified id.
+   */
+  getRenderingGroup(e) {
+    const t = e || 0;
+    return this._prepareRenderingGroup(t), this._renderingGroups[t];
+  }
+  _clearDepthStencilBuffer(e = !0, t = !0) {
+    this._depthStencilBufferAlreadyCleaned || (this._scene.getEngine().clear(null, !1, e, t), this._depthStencilBufferAlreadyCleaned = !0);
+  }
+  /**
+   * Renders the entire managed groups. This is used by the scene or the different render targets.
+   * @internal
+   */
+  render(e, t, i, o) {
+    const n = this._renderingGroupInfo;
+    if (n.scene = this._scene, n.camera = this._scene.activeCamera, this._scene.spriteManagers && o)
+      for (let r = 0; r < this._scene.spriteManagers.length; r++) {
+        const p = this._scene.spriteManagers[r];
+        this.dispatchSprites(p);
+      }
+    for (let r = s.MIN_RENDERINGGROUPS; r < s.MAX_RENDERINGGROUPS; r++) {
+      this._depthStencilBufferAlreadyCleaned = r === s.MIN_RENDERINGGROUPS;
+      const p = this._renderingGroups[r];
+      if (!p || p._empty)
+        continue;
+      const h = Math.pow(2, r);
+      if (n.renderingGroupId = r, this._scene.onBeforeRenderingGroupObservable.notifyObservers(n, h), s.AUTOCLEAR) {
+        const a = this._useSceneAutoClearSetup ? this._scene.getAutoClearDepthStencilSetup(r) : this._autoClearDepthStencil[r];
+        a && a.autoClear && this._clearDepthStencilBuffer(a.depth, a.stencil);
+      }
+      for (const a of this._scene._beforeRenderingGroupDrawStage)
+        a.action(r);
+      p.render(e, o, i, t);
+      for (const a of this._scene._afterRenderingGroupDrawStage)
+        a.action(r);
+      this._scene.onAfterRenderingGroupObservable.notifyObservers(n, h);
+    }
+  }
+  /**
+   * Resets the different information of the group to prepare a new frame
+   * @internal
+   */
+  reset() {
+    if (!this.maintainStateBetweenFrames)
+      for (let e = s.MIN_RENDERINGGROUPS; e < s.MAX_RENDERINGGROUPS; e++) {
+        const t = this._renderingGroups[e];
+        t && t.prepare();
+      }
+  }
+  /**
+   * Resets the sprites information of the group to prepare a new frame
+   * @internal
+   */
+  resetSprites() {
+    if (!this.maintainStateBetweenFrames)
+      for (let e = s.MIN_RENDERINGGROUPS; e < s.MAX_RENDERINGGROUPS; e++) {
+        const t = this._renderingGroups[e];
+        t && t.prepareSprites();
+      }
+  }
+  /**
+   * Dispose and release the group and its associated resources.
+   * @internal
+   */
+  dispose() {
+    this.freeRenderingGroups(), this._renderingGroups.length = 0, this._renderingGroupInfo = null;
+  }
+  /**
+   * Clear the info related to rendering groups preventing retention points during dispose.
+   */
+  freeRenderingGroups() {
+    for (let e = s.MIN_RENDERINGGROUPS; e < s.MAX_RENDERINGGROUPS; e++) {
+      const t = this._renderingGroups[e];
+      t && t.dispose();
+    }
+  }
+  _prepareRenderingGroup(e) {
+    this._renderingGroups[e] === void 0 && (this._renderingGroups[e] = new u(e, this._scene, this._customOpaqueSortCompareFn[e], this._customAlphaTestSortCompareFn[e], this._customTransparentSortCompareFn[e]));
+  }
+  /**
+   * Add a sprite manager to the rendering manager in order to render it this frame.
+   * @param spriteManager Define the sprite manager to render
+   */
+  dispatchSprites(e) {
+    this.maintainStateBetweenFrames && e._wasDispatched || (e._wasDispatched = !0, this.getRenderingGroup(e.renderingGroupId).dispatchSprites(e));
+  }
+  /**
+   * Add a particle system to the rendering manager in order to render it this frame.
+   * @param particleSystem Define the particle system to render
+   */
+  dispatchParticles(e) {
+    this.maintainStateBetweenFrames && e._wasDispatched || (e._wasDispatched = !0, this.getRenderingGroup(e.renderingGroupId).dispatchParticles(e));
+  }
+  /**
+   * Add a submesh to the manager in order to render it this frame
+   * @param subMesh The submesh to dispatch
+   * @param mesh Optional reference to the submeshes's mesh. Provide if you have an exiting reference to improve performance.
+   * @param material Optional reference to the submeshes's material. Provide if you have an exiting reference to improve performance.
+   */
+  dispatch(e, t, i) {
+    t === void 0 && (t = e.getMesh()), !(this.maintainStateBetweenFrames && e._wasDispatched) && (e._wasDispatched = !0, this.getRenderingGroup(t.renderingGroupId).dispatch(e, t, i));
+  }
+  /**
+   * Overrides the default sort function applied in the rendering group to prepare the meshes.
+   * This allowed control for front to back rendering or reversely depending of the special needs.
+   *
+   * @param renderingGroupId The rendering group id corresponding to its index
+   * @param opaqueSortCompareFn The opaque queue comparison function use to sort.
+   * @param alphaTestSortCompareFn The alpha test queue comparison function use to sort.
+   * @param transparentSortCompareFn The transparent queue comparison function use to sort.
+   */
+  setRenderingOrder(e, t = null, i = null, o = null) {
+    if (this._customOpaqueSortCompareFn[e] = t, this._customAlphaTestSortCompareFn[e] = i, this._customTransparentSortCompareFn[e] = o, this._renderingGroups[e]) {
+      const n = this._renderingGroups[e];
+      n.opaqueSortCompareFn = this._customOpaqueSortCompareFn[e], n.alphaTestSortCompareFn = this._customAlphaTestSortCompareFn[e], n.transparentSortCompareFn = this._customTransparentSortCompareFn[e];
+    }
+  }
+  /**
+   * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
+   *
+   * @param renderingGroupId The rendering group id corresponding to its index
+   * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
+   * @param depth Automatically clears depth between groups if true and autoClear is true.
+   * @param stencil Automatically clears stencil between groups if true and autoClear is true.
+   */
+  setRenderingAutoClearDepthStencil(e, t, i = !0, o = !0) {
+    this._autoClearDepthStencil[e] = {
+      autoClear: t,
+      depth: i,
+      stencil: o
+    };
+  }
+  /**
+   * Gets the current auto clear configuration for one rendering group of the rendering
+   * manager.
+   * @param index the rendering group index to get the information for
+   * @returns The auto clear setup for the requested rendering group
+   */
+  getAutoClearDepthStencilSetup(e) {
+    return this._autoClearDepthStencil[e];
+  }
+}
+s.MAX_RENDERINGGROUPS = 4;
+s.MIN_RENDERINGGROUPS = 0;
+s.AUTOCLEAR = !0;
+export {
+  c as RenderingGroupInfo,
+  s as RenderingManager
+};

package/dist/node_modules/@babylonjs/core/Rendering/screenSpaceReflections2Configuration.esm.js

@@ -0,0 +1,8 @@
+class s {
+  constructor() {
+    this.enabled = !1, this.name = "screenSpaceReflections2", this.texturesRequired = [6, 3, 5];
+  }
+}
+export {
+  s as ScreenSpaceReflections2Configuration
+};

package/dist/node_modules/@babylonjs/core/Rendering/screenSpaceReflectionsConfiguration.esm.js

@@ -0,0 +1,8 @@
+class s {
+  constructor() {
+    this.enabled = !1, this.name = "screenSpaceReflections", this.texturesRequired = [6, 3, 1];
+  }
+}
+export {
+  s as ScreenSpaceReflectionsConfiguration
+};

package/dist/node_modules/@babylonjs/core/Rendering/ssao2Configuration.esm.js

@@ -0,0 +1,8 @@
+class e {
+  constructor() {
+    this.enabled = !1, this.name = "ssao2", this.texturesRequired = [6, 5];
+  }
+}
+export {
+  e as SSAO2Configuration
+};

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/bakedVertexAnimation.esm.js

@@ -0,0 +1,48 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "bakedVertexAnimation", r = `#ifdef BAKED_VERTEX_ANIMATION_TEXTURE
+{
+#ifdef INSTANCES
+#define BVASNAME bakedVertexAnimationSettingsInstanced
+#else
+#define BVASNAME bakedVertexAnimationSettings
+#endif
+float VATStartFrame=BVASNAME.x;
+float VATEndFrame=BVASNAME.y;
+float VATOffsetFrame=BVASNAME.z;
+float VATSpeed=BVASNAME.w;
+float totalFrames=VATEndFrame-VATStartFrame+1.0;
+float time=bakedVertexAnimationTime*VATSpeed/totalFrames;
+float frameCorrection=time<1.0 ? 0.0 : 1.0;
+float numOfFrames=totalFrames-frameCorrection;
+float VATFrameNum=fract(time)*numOfFrames;
+VATFrameNum=mod(VATFrameNum+VATOffsetFrame,numOfFrames);
+VATFrameNum=floor(VATFrameNum);
+VATFrameNum+=VATStartFrame+frameCorrection;
+mat4 VATInfluence;
+VATInfluence=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[0],VATFrameNum)*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[1],VATFrameNum)*matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[2],VATFrameNum)*matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[3],VATFrameNum)*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[0],VATFrameNum)*matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[1],VATFrameNum)*matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[2],VATFrameNum)*matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+VATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[3],VATFrameNum)*matricesWeightsExtra[3];
+#endif
+finalWorld=finalWorld*VATInfluence;
+}
+#endif
+`;
+e.IncludesShadersStore[a] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/bakedVertexAnimationDeclaration.esm.js

@@ -0,0 +1,24 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "bakedVertexAnimationDeclaration", r = `#ifdef BAKED_VERTEX_ANIMATION_TEXTURE
+uniform float bakedVertexAnimationTime;
+uniform vec2 bakedVertexAnimationTextureSizeInverted;
+uniform vec4 bakedVertexAnimationSettings;
+uniform sampler2D bakedVertexAnimationTexture;
+#ifdef INSTANCES
+attribute vec4 bakedVertexAnimationSettingsInstanced;
+#endif
+#define inline
+mat4 readMatrixFromRawSamplerVAT(sampler2D smp,float index,float frame)
+{
+float offset=index*4.0;
+float frameUV=(frame+0.5)*bakedVertexAnimationTextureSizeInverted.y;
+float dx=bakedVertexAnimationTextureSizeInverted.x;
+vec4 m0=texture2D(smp,vec2(dx*(offset+0.5),frameUV));
+vec4 m1=texture2D(smp,vec2(dx*(offset+1.5),frameUV));
+vec4 m2=texture2D(smp,vec2(dx*(offset+2.5),frameUV));
+vec4 m3=texture2D(smp,vec2(dx*(offset+3.5),frameUV));
+return mat4(m0,m1,m2,m3);
+}
+#endif
+`;
+e.IncludesShadersStore[t] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/bonesDeclaration.esm.js

@@ -0,0 +1,35 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "bonesDeclaration", r = `#if NUM_BONE_INFLUENCERS>0
+attribute vec4 matricesIndices;
+attribute vec4 matricesWeights;
+#if NUM_BONE_INFLUENCERS>4
+attribute vec4 matricesIndicesExtra;
+attribute vec4 matricesWeightsExtra;
+#endif
+#ifndef BAKED_VERTEX_ANIMATION_TEXTURE
+#ifdef BONETEXTURE
+uniform sampler2D boneSampler;
+uniform float boneTextureWidth;
+#else
+uniform mat4 mBones[BonesPerMesh];
+#ifdef BONES_VELOCITY_ENABLED
+uniform mat4 mPreviousBones[BonesPerMesh];
+#endif
+#endif
+#ifdef BONETEXTURE
+#define inline
+mat4 readMatrixFromRawSampler(sampler2D smp,float index)
+{
+float offset=index *4.0;
+float dx=1.0/boneTextureWidth;
+vec4 m0=texture2D(smp,vec2(dx*(offset+0.5),0.));
+vec4 m1=texture2D(smp,vec2(dx*(offset+1.5),0.));
+vec4 m2=texture2D(smp,vec2(dx*(offset+2.5),0.));
+vec4 m3=texture2D(smp,vec2(dx*(offset+3.5),0.));
+return mat4(m0,m1,m2,m3);
+}
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStore[t] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/bonesVertex.esm.js

@@ -0,0 +1,56 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "bonesVertex", n = `#ifndef BAKED_VERTEX_ANIMATION_TEXTURE
+#if NUM_BONE_INFLUENCERS>0
+mat4 influence;
+#ifdef BONETEXTURE
+influence=readMatrixFromRawSampler(boneSampler,matricesIndices[0])*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndices[1])*matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndices[2])*matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndices[3])*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[0])*matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[1])*matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[2])*matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+influence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[3])*matricesWeightsExtra[3];
+#endif
+#else
+influence=mBones[int(matricesIndices[0])]*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+influence+=mBones[int(matricesIndices[1])]*matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+influence+=mBones[int(matricesIndices[2])]*matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+influence+=mBones[int(matricesIndices[3])]*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+influence+=mBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+influence+=mBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+influence+=mBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+influence+=mBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];
+#endif
+#endif
+finalWorld=finalWorld*influence;
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = n;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/boundingBoxRendererFragmentDeclaration.esm.js

@@ -0,0 +1,4 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "boundingBoxRendererFragmentDeclaration", o = `uniform vec4 color;
+`;
+e.IncludesShadersStore[r] = o;