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

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

@@ -0,0 +1,185 @@
+import { Color4 as O } from "../Maths/math.color.esm.js";
+import { VertexBuffer as _ } from "../Buffers/buffer.esm.js";
+import { Texture as R } from "../Materials/Textures/texture.esm.js";
+import { RenderTargetTexture as L } from "../Materials/Textures/renderTargetTexture.esm.js";
+import { MaterialHelper as F } from "../Materials/materialHelper.esm.js";
+import { Camera as W } from "../Cameras/camera.esm.js";
+import "../Shaders/depth.fragment.esm.js";
+import "../Shaders/depth.vertex.esm.js";
+import { _WarnImport as k } from "../Misc/devTools.esm.js";
+import { prepareStringDefinesForClipPlanes as H, addClipPlaneUniforms as V, bindClipPlane as Z } from "../Materials/clipPlaneMaterialHelper.esm.js";
+class w {
+  /**
+   * Sets a specific material to be used to render a mesh/a list of meshes by the depth renderer
+   * @param mesh mesh or array of meshes
+   * @param material material to use by the depth render when rendering the mesh(es). If undefined is passed, the specific material created by the depth renderer will be used.
+   */
+  setMaterialForRendering(d, l) {
+    this._depthMap.setMaterialForRendering(d, l);
+  }
+  /**
+   * Instantiates a depth renderer
+   * @param scene The scene the renderer belongs to
+   * @param type The texture type of the depth map (default: Engine.TEXTURETYPE_FLOAT)
+   * @param camera The camera to be used to render the depth map (default: scene's active camera)
+   * @param storeNonLinearDepth Defines whether the depth is stored linearly like in Babylon Shadows or directly like glFragCoord.z
+   * @param samplingMode The sampling mode to be used with the render target (Linear, Nearest...) (default: TRILINEAR_SAMPLINGMODE)
+   * @param storeCameraSpaceZ Defines whether the depth stored is the Z coordinate in camera space. If true, storeNonLinearDepth has no effect. (Default: false)
+   * @param name Name of the render target (default: DepthRenderer)
+   */
+  constructor(d, l = 1, m = null, v = !1, i = R.TRILINEAR_SAMPLINGMODE, x = !1, M) {
+    this.enabled = !0, this.forceDepthWriteTransparentMeshes = !1, this.useOnlyInActiveCamera = !1, this.reverseCulling = !1, this._scene = d, this._storeNonLinearDepth = v, this._storeCameraSpaceZ = x, this.isPacked = l === 0, this.isPacked ? this.clearColor = new O(1, 1, 1, 1) : this.clearColor = new O(x ? 1e8 : 1, 0, 0, 1), w._SceneComponentInitialization(this._scene);
+    const s = d.getEngine();
+    this._camera = m, i !== R.NEAREST_SAMPLINGMODE && (l === 1 && !s._caps.textureFloatLinearFiltering && (i = R.NEAREST_SAMPLINGMODE), l === 2 && !s._caps.textureHalfFloatLinearFiltering && (i = R.NEAREST_SAMPLINGMODE));
+    const n = this.isPacked || !s._features.supportExtendedTextureFormats ? 5 : 6;
+    this._depthMap = new L(M ?? "DepthRenderer", { width: s.getRenderWidth(), height: s.getRenderHeight() }, this._scene, !1, !0, l, !1, i, void 0, void 0, void 0, n), this._depthMap.wrapU = R.CLAMP_ADDRESSMODE, this._depthMap.wrapV = R.CLAMP_ADDRESSMODE, this._depthMap.refreshRate = 1, this._depthMap.renderParticles = !1, this._depthMap.renderList = null, this._depthMap.noPrePassRenderer = !0, this._depthMap.activeCamera = this._camera, this._depthMap.ignoreCameraViewport = !0, this._depthMap.useCameraPostProcesses = !1, this._depthMap.onClearObservable.add((t) => {
+      t.clear(this.clearColor, !0, !0, !0);
+    }), this._depthMap.onBeforeBindObservable.add(() => {
+      var t;
+      (t = s._debugPushGroup) === null || t === void 0 || t.call(s, "depth renderer", 1);
+    }), this._depthMap.onAfterUnbindObservable.add(() => {
+      var t;
+      (t = s._debugPopGroup) === null || t === void 0 || t.call(s, 1);
+    }), this._depthMap.customIsReadyFunction = (t, p, c) => {
+      if ((c || p === 0) && t.subMeshes)
+        for (let r = 0; r < t.subMeshes.length; ++r) {
+          const e = t.subMeshes[r], a = e.getRenderingMesh(), o = a._getInstancesRenderList(e._id, !!e.getReplacementMesh()), u = s.getCaps().instancedArrays && (o.visibleInstances[e._id] !== null && o.visibleInstances[e._id] !== void 0 || a.hasThinInstances);
+          if (!this.isReady(e, u))
+            return !1;
+        }
+      return !0;
+    };
+    const h = (t) => {
+      var p, c;
+      const r = t.getRenderingMesh(), e = t.getEffectiveMesh(), a = this._scene, o = a.getEngine(), u = t.getMaterial();
+      if (e._internalAbstractMeshDataInfo._isActiveIntermediate = !1, !u || e.infiniteDistance || u.disableDepthWrite || t.verticesCount === 0 || t._renderId === a.getRenderId())
+        return;
+      const U = e._getWorldMatrixDeterminant() < 0;
+      let P = (p = r.overrideMaterialSideOrientation) !== null && p !== void 0 ? p : u.sideOrientation;
+      U && (P = P === 0 ? 1 : 0);
+      const B = P === 0;
+      o.setState(u.backFaceCulling, 0, !1, B, this.reverseCulling ? !u.cullBackFaces : u.cullBackFaces);
+      const D = r._getInstancesRenderList(t._id, !!t.getReplacementMesh());
+      if (D.mustReturn)
+        return;
+      const N = o.getCaps().instancedArrays && (D.visibleInstances[t._id] !== null && D.visibleInstances[t._id] !== void 0 || r.hasThinInstances), T = this._camera || a.activeCamera;
+      if (this.isReady(t, N) && T) {
+        t._renderId = a.getRenderId();
+        const I = (c = e._internalAbstractMeshDataInfo._materialForRenderPass) === null || c === void 0 ? void 0 : c[o.currentRenderPassId];
+        let E = t._getDrawWrapper();
+        !E && I && (E = I._getDrawWrapper());
+        const b = T.mode === W.ORTHOGRAPHIC_CAMERA;
+        if (!E)
+          return;
+        const f = E.effect;
+        o.enableEffect(E), N || r._bind(t, f, u.fillMode), I ? I.bindForSubMesh(e.getWorldMatrix(), e, t) : (f.setMatrix("viewProjection", a.getTransformMatrix()), f.setMatrix("world", e.getWorldMatrix()), this._storeCameraSpaceZ && f.setMatrix("view", a.getViewMatrix()));
+        let A, S;
+        if (b ? (A = !o.useReverseDepthBuffer && o.isNDCHalfZRange ? 0 : 1, S = o.useReverseDepthBuffer && o.isNDCHalfZRange ? 0 : 1) : (A = o.useReverseDepthBuffer && o.isNDCHalfZRange ? T.minZ : o.isNDCHalfZRange ? 0 : T.minZ, S = o.useReverseDepthBuffer && o.isNDCHalfZRange ? 0 : T.maxZ), f.setFloat2("depthValues", A, A + S), !I) {
+          if (u.needAlphaTesting()) {
+            const g = u.getAlphaTestTexture();
+            g && (f.setTexture("diffuseSampler", g), f.setMatrix("diffuseMatrix", g.getTextureMatrix()));
+          }
+          if (r.useBones && r.computeBonesUsingShaders && r.skeleton) {
+            const g = r.skeleton;
+            if (g.isUsingTextureForMatrices) {
+              const C = g.getTransformMatrixTexture(r);
+              if (!C)
+                return;
+              f.setTexture("boneSampler", C), f.setFloat("boneTextureWidth", 4 * (g.bones.length + 1));
+            } else
+              f.setMatrices("mBones", g.getTransformMatrices(r));
+          }
+          Z(f, u, a), F.BindMorphTargetParameters(r, f), r.morphTargetManager && r.morphTargetManager.isUsingTextureForTargets && r.morphTargetManager._bind(f);
+        }
+        r._processRendering(e, t, f, u.fillMode, D, N, (g, C) => f.setMatrix("world", C));
+      }
+    };
+    this._depthMap.customRenderFunction = (t, p, c, r) => {
+      let e;
+      if (r.length)
+        for (e = 0; e < r.length; e++)
+          h(r.data[e]);
+      for (e = 0; e < t.length; e++)
+        h(t.data[e]);
+      for (e = 0; e < p.length; e++)
+        h(p.data[e]);
+      if (this.forceDepthWriteTransparentMeshes)
+        for (e = 0; e < c.length; e++)
+          h(c.data[e]);
+      else
+        for (e = 0; e < c.length; e++)
+          c.data[e].getEffectiveMesh()._internalAbstractMeshDataInfo._isActiveIntermediate = !1;
+    };
+  }
+  /**
+   * Creates the depth rendering effect and checks if the effect is ready.
+   * @param subMesh The submesh to be used to render the depth map of
+   * @param useInstances If multiple world instances should be used
+   * @returns if the depth renderer is ready to render the depth map
+   */
+  isReady(d, l) {
+    var m;
+    const v = this._scene.getEngine(), i = d.getMesh(), x = i.getScene(), M = (m = i._internalAbstractMeshDataInfo._materialForRenderPass) === null || m === void 0 ? void 0 : m[v.currentRenderPassId];
+    if (M)
+      return M.isReadyForSubMesh(i, d, l);
+    const s = d.getMaterial();
+    if (!s || s.disableDepthWrite)
+      return !1;
+    const n = [], h = [_.PositionKind];
+    if (s && s.needAlphaTesting() && s.getAlphaTestTexture() && (n.push("#define ALPHATEST"), i.isVerticesDataPresent(_.UVKind) && (h.push(_.UVKind), n.push("#define UV1")), i.isVerticesDataPresent(_.UV2Kind) && (h.push(_.UV2Kind), n.push("#define UV2"))), i.useBones && i.computeBonesUsingShaders) {
+      h.push(_.MatricesIndicesKind), h.push(_.MatricesWeightsKind), i.numBoneInfluencers > 4 && (h.push(_.MatricesIndicesExtraKind), h.push(_.MatricesWeightsExtraKind)), n.push("#define NUM_BONE_INFLUENCERS " + i.numBoneInfluencers), n.push("#define BonesPerMesh " + (i.skeleton ? i.skeleton.bones.length + 1 : 0));
+      const a = d.getRenderingMesh().skeleton;
+      a != null && a.isUsingTextureForMatrices && n.push("#define BONETEXTURE");
+    } else
+      n.push("#define NUM_BONE_INFLUENCERS 0");
+    const t = i.morphTargetManager;
+    let p = 0;
+    t && t.numInfluencers > 0 && (p = t.numInfluencers, n.push("#define MORPHTARGETS"), n.push("#define NUM_MORPH_INFLUENCERS " + p), t.isUsingTextureForTargets && n.push("#define MORPHTARGETS_TEXTURE"), F.PrepareAttributesForMorphTargetsInfluencers(h, i, p)), l && (n.push("#define INSTANCES"), F.PushAttributesForInstances(h), d.getRenderingMesh().hasThinInstances && n.push("#define THIN_INSTANCES")), this._storeNonLinearDepth && n.push("#define NONLINEARDEPTH"), this._storeCameraSpaceZ && n.push("#define STORE_CAMERASPACE_Z"), this.isPacked && n.push("#define PACKED"), H(s, x, n);
+    const c = d._getDrawWrapper(void 0, !0), r = c.defines, e = n.join(`
+`);
+    if (r !== e) {
+      const a = [
+        "world",
+        "mBones",
+        "boneTextureWidth",
+        "viewProjection",
+        "view",
+        "diffuseMatrix",
+        "depthValues",
+        "morphTargetInfluences",
+        "morphTargetTextureInfo",
+        "morphTargetTextureIndices"
+      ];
+      V(a), c.setEffect(v.createEffect("depth", h, a, ["diffuseSampler", "morphTargets", "boneSampler"], e, void 0, void 0, void 0, {
+        maxSimultaneousMorphTargets: p
+      }), e);
+    }
+    return c.effect.isReady();
+  }
+  /**
+   * Gets the texture which the depth map will be written to.
+   * @returns The depth map texture
+   */
+  getDepthMap() {
+    return this._depthMap;
+  }
+  /**
+   * Disposes of the depth renderer.
+   */
+  dispose() {
+    const d = [];
+    for (const l in this._scene._depthRenderer)
+      this._scene._depthRenderer[l] === this && d.push(l);
+    if (d.length > 0) {
+      this._depthMap.dispose();
+      for (const l of d)
+        delete this._scene._depthRenderer[l];
+    }
+  }
+}
+w._SceneComponentInitialization = (K) => {
+  throw k("DepthRendererSceneComponent");
+};
+export {
+  w as DepthRenderer
+};

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

@@ -0,0 +1,65 @@
+import { Scene as h } from "../scene.esm.js";
+import { DepthRenderer as p } from "./depthRenderer.esm.js";
+import { SceneComponentConstants as i } from "../sceneComponent.esm.js";
+h.prototype.enableDepthRenderer = function(e, t = !1, n = !1, r = 3, R = !1) {
+  if (e = e || this.activeCamera, !e)
+    throw "No camera available to enable depth renderer";
+  if (this._depthRenderer || (this._depthRenderer = {}), !this._depthRenderer[e.id]) {
+    const d = !!this.getEngine().getCaps().textureFloatRender;
+    let s = 0;
+    this.getEngine().getCaps().textureHalfFloatRender && (!n || !d) ? s = 2 : d ? s = 1 : s = 0, this._depthRenderer[e.id] = new p(this, s, e, t, r, R);
+  }
+  return this._depthRenderer[e.id];
+};
+h.prototype.disableDepthRenderer = function(e) {
+  e = e || this.activeCamera, !(!e || !this._depthRenderer || !this._depthRenderer[e.id]) && this._depthRenderer[e.id].dispose();
+};
+class o {
+  /**
+   * Creates a new instance of the component for the given scene
+   * @param scene Defines the scene to register the component in
+   */
+  constructor(t) {
+    this.name = i.NAME_DEPTHRENDERER, this.scene = t;
+  }
+  /**
+   * Registers the component in a given scene
+   */
+  register() {
+    this.scene._gatherRenderTargetsStage.registerStep(i.STEP_GATHERRENDERTARGETS_DEPTHRENDERER, this, this._gatherRenderTargets), this.scene._gatherActiveCameraRenderTargetsStage.registerStep(i.STEP_GATHERACTIVECAMERARENDERTARGETS_DEPTHRENDERER, this, this._gatherActiveCameraRenderTargets);
+  }
+  /**
+   * Rebuilds the elements related to this component in case of
+   * context lost for instance.
+   */
+  rebuild() {
+  }
+  /**
+   * Disposes the component and the associated resources
+   */
+  dispose() {
+    for (const t in this.scene._depthRenderer)
+      this.scene._depthRenderer[t].dispose();
+  }
+  _gatherRenderTargets(t) {
+    if (this.scene._depthRenderer)
+      for (const n in this.scene._depthRenderer) {
+        const r = this.scene._depthRenderer[n];
+        r.enabled && !r.useOnlyInActiveCamera && t.push(r.getDepthMap());
+      }
+  }
+  _gatherActiveCameraRenderTargets(t) {
+    if (this.scene._depthRenderer)
+      for (const n in this.scene._depthRenderer) {
+        const r = this.scene._depthRenderer[n];
+        r.enabled && r.useOnlyInActiveCamera && this.scene.activeCamera.id === n && t.push(r.getDepthMap());
+      }
+  }
+}
+p._SceneComponentInitialization = (e) => {
+  let t = e._getComponent(i.NAME_DEPTHRENDERER);
+  t || (t = new o(e), e._addComponent(t));
+};
+export {
+  o as DepthRendererSceneComponent
+};

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

@@ -0,0 +1,353 @@
+import { Matrix as F } from "../Maths/math.vector.esm.js";
+import { VertexBuffer as T } from "../Buffers/buffer.esm.js";
+import { Texture as L } from "../Materials/Textures/texture.esm.js";
+import { MultiRenderTarget as V } from "../Materials/Textures/multiRenderTarget.esm.js";
+import { MaterialHelper as b } from "../Materials/materialHelper.esm.js";
+import { Color4 as O } from "../Maths/math.color.esm.js";
+import { _WarnImport as N } from "../Misc/devTools.esm.js";
+import { Material as v } from "../Materials/material.esm.js";
+import "../Shaders/geometry.fragment.esm.js";
+import "../Shaders/geometry.vertex.esm.js";
+import { MaterialFlags as A } from "../Materials/materialFlags.esm.js";
+import { addClipPlaneUniforms as D, prepareStringDefinesForClipPlanes as B, bindClipPlane as W } from "../Materials/clipPlaneMaterialHelper.esm.js";
+const y = [
+  "world",
+  "mBones",
+  "viewProjection",
+  "diffuseMatrix",
+  "view",
+  "previousWorld",
+  "previousViewProjection",
+  "mPreviousBones",
+  "bumpMatrix",
+  "reflectivityMatrix",
+  "albedoMatrix",
+  "reflectivityColor",
+  "albedoColor",
+  "metallic",
+  "glossiness",
+  "vTangentSpaceParams",
+  "vBumpInfos",
+  "morphTargetInfluences",
+  "morphTargetTextureInfo",
+  "morphTargetTextureIndices"
+];
+D(y);
+class f {
+  /**
+   * @internal
+   * Sets up internal structures to share outputs with PrePassRenderer
+   * This method should only be called by the PrePassRenderer itself
+   */
+  _linkPrePassRenderer(i) {
+    this._linkedWithPrePass = !0, this._prePassRenderer = i, this._multiRenderTarget && (this._multiRenderTarget.onClearObservable.clear(), this._multiRenderTarget.onClearObservable.add(() => {
+    }));
+  }
+  /**
+   * @internal
+   * Separates internal structures from PrePassRenderer so the geometry buffer can now operate by itself.
+   * This method should only be called by the PrePassRenderer itself
+   */
+  _unlinkPrePassRenderer() {
+    this._linkedWithPrePass = !1, this._createRenderTargets();
+  }
+  /**
+   * @internal
+   * Resets the geometry buffer layout
+   */
+  _resetLayout() {
+    this._enablePosition = !1, this._enableReflectivity = !1, this._enableVelocity = !1, this._attachmentsFromPrePass = [];
+  }
+  /**
+   * @internal
+   * Replaces a texture in the geometry buffer renderer
+   * Useful when linking textures of the prepass renderer
+   */
+  _forceTextureType(i, u) {
+    i === f.POSITION_TEXTURE_TYPE ? (this._positionIndex = u, this._enablePosition = !0) : i === f.VELOCITY_TEXTURE_TYPE ? (this._velocityIndex = u, this._enableVelocity = !0) : i === f.REFLECTIVITY_TEXTURE_TYPE ? (this._reflectivityIndex = u, this._enableReflectivity = !0) : i === f.DEPTH_TEXTURE_TYPE ? this._depthIndex = u : i === f.NORMAL_TEXTURE_TYPE && (this._normalIndex = u);
+  }
+  /**
+   * @internal
+   * Sets texture attachments
+   * Useful when linking textures of the prepass renderer
+   */
+  _setAttachments(i) {
+    this._attachmentsFromPrePass = i;
+  }
+  /**
+   * @internal
+   * Replaces the first texture which is hard coded as a depth texture in the geometry buffer
+   * Useful when linking textures of the prepass renderer
+   */
+  _linkInternalTexture(i) {
+    this._multiRenderTarget.setInternalTexture(i, 0, !1);
+  }
+  /**
+   * Gets the render list (meshes to be rendered) used in the G buffer.
+   */
+  get renderList() {
+    return this._multiRenderTarget.renderList;
+  }
+  /**
+   * Set the render list (meshes to be rendered) used in the G buffer.
+   */
+  set renderList(i) {
+    this._multiRenderTarget.renderList = i;
+  }
+  /**
+   * Gets whether or not G buffer are supported by the running hardware.
+   * This requires draw buffer supports
+   */
+  get isSupported() {
+    return this._multiRenderTarget.isSupported;
+  }
+  /**
+   * Returns the index of the given texture type in the G-Buffer textures array
+   * @param textureType The texture type constant. For example GeometryBufferRenderer.POSITION_TEXTURE_INDEX
+   * @returns the index of the given texture type in the G-Buffer textures array
+   */
+  getTextureIndex(i) {
+    switch (i) {
+      case f.POSITION_TEXTURE_TYPE:
+        return this._positionIndex;
+      case f.VELOCITY_TEXTURE_TYPE:
+        return this._velocityIndex;
+      case f.REFLECTIVITY_TEXTURE_TYPE:
+        return this._reflectivityIndex;
+      default:
+        return -1;
+    }
+  }
+  /**
+   * Gets a boolean indicating if objects positions are enabled for the G buffer.
+   */
+  get enablePosition() {
+    return this._enablePosition;
+  }
+  /**
+   * Sets whether or not objects positions are enabled for the G buffer.
+   */
+  set enablePosition(i) {
+    this._enablePosition = i, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * Gets a boolean indicating if objects velocities are enabled for the G buffer.
+   */
+  get enableVelocity() {
+    return this._enableVelocity;
+  }
+  /**
+   * Sets whether or not objects velocities are enabled for the G buffer.
+   */
+  set enableVelocity(i) {
+    this._enableVelocity = i, i || (this._previousTransformationMatrices = {}), this._linkedWithPrePass || (this.dispose(), this._createRenderTargets()), this._scene.needsPreviousWorldMatrices = i;
+  }
+  /**
+   * Gets a boolean indicating if objects reflectivity are enabled in the G buffer.
+   */
+  get enableReflectivity() {
+    return this._enableReflectivity;
+  }
+  /**
+   * Sets whether or not objects reflectivity are enabled for the G buffer.
+   * For Metallic-Roughness workflow with ORM texture, we assume that ORM texture is defined according to the default layout:
+   * pbr.useRoughnessFromMetallicTextureAlpha = false;
+   * pbr.useRoughnessFromMetallicTextureGreen = true;
+   * pbr.useMetallnessFromMetallicTextureBlue = true;
+   */
+  set enableReflectivity(i) {
+    this._enableReflectivity = i, this._linkedWithPrePass || (this.dispose(), this._createRenderTargets());
+  }
+  /**
+   * Gets the scene associated with the buffer.
+   */
+  get scene() {
+    return this._scene;
+  }
+  /**
+   * Gets the ratio used by the buffer during its creation.
+   * How big is the buffer related to the main canvas.
+   */
+  get ratio() {
+    return this._ratio;
+  }
+  /**
+   * Creates a new G Buffer for the scene
+   * @param scene The scene the buffer belongs to
+   * @param ratio How big is the buffer related to the main canvas (default: 1)
+   * @param depthFormat Format of the depth texture (default: 15)
+   */
+  constructor(i, u = 1, s = 15) {
+    this._previousTransformationMatrices = {}, this._previousBonesTransformationMatrices = {}, this.excludedSkinnedMeshesFromVelocity = [], this.renderTransparentMeshes = !0, this._resizeObserver = null, this._enablePosition = !1, this._enableVelocity = !1, this._enableReflectivity = !1, this._clearColor = new O(0, 0, 0, 0), this._clearDepthColor = new O(1e8, 0, 0, 1), this._positionIndex = -1, this._velocityIndex = -1, this._reflectivityIndex = -1, this._depthIndex = -1, this._normalIndex = -1, this._linkedWithPrePass = !1, this.useSpecificClearForDepthTexture = !1, this._scene = i, this._ratio = u, this._useUbo = i.getEngine().supportsUniformBuffers, this._depthFormat = s, f._SceneComponentInitialization(this._scene), this._createRenderTargets();
+  }
+  /**
+   * Checks whether everything is ready to render a submesh to the G buffer.
+   * @param subMesh the submesh to check readiness for
+   * @param useInstances is the mesh drawn using instance or not
+   * @returns true if ready otherwise false
+   */
+  isReady(i, u) {
+    const s = i.getMaterial();
+    if (s && s.disableDepthWrite)
+      return !1;
+    const e = [], d = [T.PositionKind, T.NormalKind], h = i.getMesh();
+    if (s) {
+      let n = !1;
+      if (s.needAlphaTesting() && s.getAlphaTestTexture() && (e.push("#define ALPHATEST"), e.push(`#define ALPHATEST_UV${s.getAlphaTestTexture().coordinatesIndex + 1}`), n = !0), s.bumpTexture && A.BumpTextureEnabled && (e.push("#define BUMP"), e.push(`#define BUMP_UV${s.bumpTexture.coordinatesIndex + 1}`), n = !0), this._enableReflectivity) {
+        let o = !1;
+        s.getClassName() === "PBRMetallicRoughnessMaterial" ? (s.metallicRoughnessTexture !== null && (e.push("#define ORMTEXTURE"), e.push(`#define REFLECTIVITY_UV${s.metallicRoughnessTexture.coordinatesIndex + 1}`), e.push("#define METALLICWORKFLOW"), n = !0, o = !0), s.metallic !== null && (e.push("#define METALLIC"), e.push("#define METALLICWORKFLOW"), o = !0), s.roughness !== null && (e.push("#define ROUGHNESS"), e.push("#define METALLICWORKFLOW"), o = !0), o && (s.baseTexture !== null && (e.push("#define ALBEDOTEXTURE"), e.push(`#define ALBEDO_UV${s.baseTexture.coordinatesIndex + 1}`), s.baseTexture.gammaSpace && e.push("#define GAMMAALBEDO"), n = !0), s.baseColor !== null && e.push("#define ALBEDOCOLOR"))) : s.getClassName() === "PBRSpecularGlossinessMaterial" ? (s.specularGlossinessTexture !== null ? (e.push("#define SPECULARGLOSSINESSTEXTURE"), e.push(`#define REFLECTIVITY_UV${s.specularGlossinessTexture.coordinatesIndex + 1}`), n = !0, s.specularGlossinessTexture.gammaSpace && e.push("#define GAMMAREFLECTIVITYTEXTURE")) : s.specularColor !== null && e.push("#define REFLECTIVITYCOLOR"), s.glossiness !== null && e.push("#define GLOSSINESS")) : s.getClassName() === "PBRMaterial" ? (s.metallicTexture !== null && (e.push("#define ORMTEXTURE"), e.push(`#define REFLECTIVITY_UV${s.metallicTexture.coordinatesIndex + 1}`), e.push("#define METALLICWORKFLOW"), n = !0, o = !0), s.metallic !== null && (e.push("#define METALLIC"), e.push("#define METALLICWORKFLOW"), o = !0), s.roughness !== null && (e.push("#define ROUGHNESS"), e.push("#define METALLICWORKFLOW"), o = !0), o ? (s.albedoTexture !== null && (e.push("#define ALBEDOTEXTURE"), e.push(`#define ALBEDO_UV${s.albedoTexture.coordinatesIndex + 1}`), s.albedoTexture.gammaSpace && e.push("#define GAMMAALBEDO"), n = !0), s.albedoColor !== null && e.push("#define ALBEDOCOLOR")) : (s.reflectivityTexture !== null ? (e.push("#define SPECULARGLOSSINESSTEXTURE"), e.push(`#define REFLECTIVITY_UV${s.reflectivityTexture.coordinatesIndex + 1}`), s.reflectivityTexture.gammaSpace && e.push("#define GAMMAREFLECTIVITYTEXTURE"), n = !0) : s.reflectivityColor !== null && e.push("#define REFLECTIVITYCOLOR"), s.microSurface !== null && e.push("#define GLOSSINESS"))) : s.getClassName() === "StandardMaterial" && (s.specularTexture !== null && (e.push("#define REFLECTIVITYTEXTURE"), e.push(`#define REFLECTIVITY_UV${s.specularTexture.coordinatesIndex + 1}`), s.specularTexture.gammaSpace && e.push("#define GAMMAREFLECTIVITYTEXTURE"), n = !0), s.specularColor !== null && e.push("#define REFLECTIVITYCOLOR"));
+      }
+      n && (e.push("#define NEED_UV"), h.isVerticesDataPresent(T.UVKind) && (d.push(T.UVKind), e.push("#define UV1")), h.isVerticesDataPresent(T.UV2Kind) && (d.push(T.UV2Kind), e.push("#define UV2")));
+    }
+    this._linkedWithPrePass && (e.push("#define PREPASS"), this._depthIndex !== -1 && (e.push("#define DEPTH_INDEX " + this._depthIndex), e.push("#define PREPASS_DEPTH")), this._normalIndex !== -1 && (e.push("#define NORMAL_INDEX " + this._normalIndex), e.push("#define PREPASS_NORMAL"))), this._enablePosition && (e.push("#define POSITION"), e.push("#define POSITION_INDEX " + this._positionIndex)), this._enableVelocity && (e.push("#define VELOCITY"), e.push("#define VELOCITY_INDEX " + this._velocityIndex), this.excludedSkinnedMeshesFromVelocity.indexOf(h) === -1 && e.push("#define BONES_VELOCITY_ENABLED")), this._enableReflectivity && (e.push("#define REFLECTIVITY"), e.push("#define REFLECTIVITY_INDEX " + this._reflectivityIndex)), h.useBones && h.computeBonesUsingShaders ? (d.push(T.MatricesIndicesKind), d.push(T.MatricesWeightsKind), h.numBoneInfluencers > 4 && (d.push(T.MatricesIndicesExtraKind), d.push(T.MatricesWeightsExtraKind)), e.push("#define NUM_BONE_INFLUENCERS " + h.numBoneInfluencers), e.push("#define BonesPerMesh " + (h.skeleton ? h.skeleton.bones.length + 1 : 0))) : e.push("#define NUM_BONE_INFLUENCERS 0");
+    const p = h.morphTargetManager;
+    let _ = 0;
+    p && p.numInfluencers > 0 && (_ = p.numInfluencers, e.push("#define MORPHTARGETS"), e.push("#define NUM_MORPH_INFLUENCERS " + _), p.isUsingTextureForTargets && e.push("#define MORPHTARGETS_TEXTURE"), b.PrepareAttributesForMorphTargetsInfluencers(d, h, _)), u && (e.push("#define INSTANCES"), b.PushAttributesForInstances(d, this._enableVelocity), i.getRenderingMesh().hasThinInstances && e.push("#define THIN_INSTANCES")), this._linkedWithPrePass ? e.push("#define RENDER_TARGET_COUNT " + this._attachmentsFromPrePass.length) : e.push("#define RENDER_TARGET_COUNT " + this._multiRenderTarget.textures.length), B(s, this._scene, e);
+    const C = this._scene.getEngine(), M = i._getDrawWrapper(void 0, !0), E = M.defines, a = e.join(`
+`);
+    return E !== a && M.setEffect(C.createEffect("geometry", {
+      attributes: d,
+      uniformsNames: y,
+      samplers: ["diffuseSampler", "bumpSampler", "reflectivitySampler", "albedoSampler", "morphTargets"],
+      defines: a,
+      onCompiled: null,
+      fallbacks: null,
+      onError: null,
+      uniformBuffersNames: ["Scene"],
+      indexParameters: { buffersCount: this._multiRenderTarget.textures.length - 1, maxSimultaneousMorphTargets: _ }
+    }, C), a), M.effect.isReady();
+  }
+  /**
+   * Gets the current underlying G Buffer.
+   * @returns the buffer
+   */
+  getGBuffer() {
+    return this._multiRenderTarget;
+  }
+  /**
+   * Gets the number of samples used to render the buffer (anti aliasing).
+   */
+  get samples() {
+    return this._multiRenderTarget.samples;
+  }
+  /**
+   * Sets the number of samples used to render the buffer (anti aliasing).
+   */
+  set samples(i) {
+    this._multiRenderTarget.samples = i;
+  }
+  /**
+   * Disposes the renderer and frees up associated resources.
+   */
+  dispose() {
+    this._resizeObserver && (this._scene.getEngine().onResizeObservable.remove(this._resizeObserver), this._resizeObserver = null), this.getGBuffer().dispose();
+  }
+  _assignRenderTargetIndices() {
+    const i = [];
+    let u = 2;
+    return i.push("gBuffer_Depth", "gBuffer_Normal"), this._enablePosition && (this._positionIndex = u, u++, i.push("gBuffer_Position")), this._enableVelocity && (this._velocityIndex = u, u++, i.push("gBuffer_Velocity")), this._enableReflectivity && (this._reflectivityIndex = u, u++, i.push("gBuffer_Reflectivity")), [u, i];
+  }
+  _createRenderTargets() {
+    const i = this._scene.getEngine(), [u, s] = this._assignRenderTargetIndices();
+    let e = 0;
+    if (i._caps.textureFloat && i._caps.textureFloatLinearFiltering ? e = 1 : i._caps.textureHalfFloat && i._caps.textureHalfFloatLinearFiltering && (e = 2), this._multiRenderTarget = new V("gBuffer", { width: i.getRenderWidth() * this._ratio, height: i.getRenderHeight() * this._ratio }, u, this._scene, { generateMipMaps: !1, generateDepthTexture: !0, defaultType: e, depthTextureFormat: this._depthFormat }, s.concat("gBuffer_DepthBuffer")), !this.isSupported)
+      return;
+    this._multiRenderTarget.wrapU = L.CLAMP_ADDRESSMODE, this._multiRenderTarget.wrapV = L.CLAMP_ADDRESSMODE, this._multiRenderTarget.refreshRate = 1, this._multiRenderTarget.renderParticles = !1, this._multiRenderTarget.renderList = null;
+    const d = [!0], h = [!1], p = [!0];
+    for (let a = 1; a < u; ++a)
+      d.push(!0), p.push(!1), h.push(!0);
+    const _ = i.buildTextureLayout(d), C = i.buildTextureLayout(h), M = i.buildTextureLayout(p);
+    this._multiRenderTarget.onClearObservable.add((a) => {
+      a.bindAttachments(this.useSpecificClearForDepthTexture ? C : _), a.clear(this._clearColor, !0, !0, !0), this.useSpecificClearForDepthTexture && (a.bindAttachments(M), a.clear(this._clearDepthColor, !0, !0, !0)), a.bindAttachments(_);
+    }), this._resizeObserver = i.onResizeObservable.add(() => {
+      this._multiRenderTarget && this._multiRenderTarget.resize({ width: i.getRenderWidth() * this._ratio, height: i.getRenderHeight() * this._ratio });
+    });
+    const E = (a) => {
+      const n = a.getRenderingMesh(), o = a.getEffectiveMesh(), c = this._scene, l = c.getEngine(), t = a.getMaterial();
+      if (!t)
+        return;
+      if (o._internalAbstractMeshDataInfo._isActiveIntermediate = !1, this._enableVelocity && !this._previousTransformationMatrices[o.uniqueId] && (this._previousTransformationMatrices[o.uniqueId] = {
+        world: F.Identity(),
+        viewProjection: c.getTransformMatrix()
+      }, n.skeleton)) {
+        const m = n.skeleton.getTransformMatrices(n);
+        this._previousBonesTransformationMatrices[n.uniqueId] = this._copyBonesTransformationMatrices(m, new Float32Array(m.length));
+      }
+      const R = n._getInstancesRenderList(a._id, !!a.getReplacementMesh());
+      if (R.mustReturn)
+        return;
+      const I = l.getCaps().instancedArrays && (R.visibleInstances[a._id] !== null || n.hasThinInstances), P = o.getWorldMatrix();
+      if (this.isReady(a, I)) {
+        const m = a._getDrawWrapper();
+        if (!m)
+          return;
+        const r = m.effect;
+        l.enableEffect(m), I || n._bind(a, r, t.fillMode), this._useUbo ? (b.BindSceneUniformBuffer(r, this._scene.getSceneUniformBuffer()), this._scene.finalizeSceneUbo()) : (r.setMatrix("viewProjection", c.getTransformMatrix()), r.setMatrix("view", c.getViewMatrix()));
+        let g;
+        const S = n._instanceDataStorage;
+        if (!S.isFrozen && (t.backFaceCulling || n.overrideMaterialSideOrientation !== null)) {
+          const x = o._getWorldMatrixDeterminant();
+          g = n.overrideMaterialSideOrientation, g === null && (g = t.sideOrientation), x < 0 && (g = g === v.ClockWiseSideOrientation ? v.CounterClockWiseSideOrientation : v.ClockWiseSideOrientation);
+        } else
+          g = S.sideOrientation;
+        if (t._preBind(m, g), t.needAlphaTesting()) {
+          const x = t.getAlphaTestTexture();
+          x && (r.setTexture("diffuseSampler", x), r.setMatrix("diffuseMatrix", x.getTextureMatrix()));
+        }
+        t.bumpTexture && c.getEngine().getCaps().standardDerivatives && A.BumpTextureEnabled && (r.setFloat3("vBumpInfos", t.bumpTexture.coordinatesIndex, 1 / t.bumpTexture.level, t.parallaxScaleBias), r.setMatrix("bumpMatrix", t.bumpTexture.getTextureMatrix()), r.setTexture("bumpSampler", t.bumpTexture), r.setFloat2("vTangentSpaceParams", t.invertNormalMapX ? -1 : 1, t.invertNormalMapY ? -1 : 1)), this._enableReflectivity && (t.getClassName() === "PBRMetallicRoughnessMaterial" ? (t.metallicRoughnessTexture !== null && (r.setTexture("reflectivitySampler", t.metallicRoughnessTexture), r.setMatrix("reflectivityMatrix", t.metallicRoughnessTexture.getTextureMatrix())), t.metallic !== null && r.setFloat("metallic", t.metallic), t.roughness !== null && r.setFloat("glossiness", 1 - t.roughness), t.baseTexture !== null && (r.setTexture("albedoSampler", t.baseTexture), r.setMatrix("albedoMatrix", t.baseTexture.getTextureMatrix())), t.baseColor !== null && r.setColor3("albedoColor", t.baseColor)) : t.getClassName() === "PBRSpecularGlossinessMaterial" ? (t.specularGlossinessTexture !== null ? (r.setTexture("reflectivitySampler", t.specularGlossinessTexture), r.setMatrix("reflectivityMatrix", t.specularGlossinessTexture.getTextureMatrix())) : t.specularColor !== null && r.setColor3("reflectivityColor", t.specularColor), t.glossiness !== null && r.setFloat("glossiness", t.glossiness)) : t.getClassName() === "PBRMaterial" ? (t.metallicTexture !== null && (r.setTexture("reflectivitySampler", t.metallicTexture), r.setMatrix("reflectivityMatrix", t.metallicTexture.getTextureMatrix())), t.metallic !== null && r.setFloat("metallic", t.metallic), t.roughness !== null && r.setFloat("glossiness", 1 - t.roughness), t.roughness !== null || t.metallic !== null || t.metallicTexture !== null ? (t.albedoTexture !== null && (r.setTexture("albedoSampler", t.albedoTexture), r.setMatrix("albedoMatrix", t.albedoTexture.getTextureMatrix())), t.albedoColor !== null && r.setColor3("albedoColor", t.albedoColor)) : (t.reflectivityTexture !== null ? (r.setTexture("reflectivitySampler", t.reflectivityTexture), r.setMatrix("reflectivityMatrix", t.reflectivityTexture.getTextureMatrix())) : t.reflectivityColor !== null && r.setColor3("reflectivityColor", t.reflectivityColor), t.microSurface !== null && r.setFloat("glossiness", t.microSurface))) : t.getClassName() === "StandardMaterial" && (t.specularTexture !== null && (r.setTexture("reflectivitySampler", t.specularTexture), r.setMatrix("reflectivityMatrix", t.specularTexture.getTextureMatrix())), t.specularColor !== null && r.setColor3("reflectivityColor", t.specularColor))), W(r, t, this._scene), n.useBones && n.computeBonesUsingShaders && n.skeleton && (r.setMatrices("mBones", n.skeleton.getTransformMatrices(n)), this._enableVelocity && r.setMatrices("mPreviousBones", this._previousBonesTransformationMatrices[n.uniqueId])), b.BindMorphTargetParameters(n, r), n.morphTargetManager && n.morphTargetManager.isUsingTextureForTargets && n.morphTargetManager._bind(r), this._enableVelocity && (r.setMatrix("previousWorld", this._previousTransformationMatrices[o.uniqueId].world), r.setMatrix("previousViewProjection", this._previousTransformationMatrices[o.uniqueId].viewProjection)), I && n.hasThinInstances && r.setMatrix("world", P), n._processRendering(o, a, r, t.fillMode, R, I, (x, U) => {
+          x || r.setMatrix("world", U);
+        });
+      }
+      this._enableVelocity && (this._previousTransformationMatrices[o.uniqueId].world = P.clone(), this._previousTransformationMatrices[o.uniqueId].viewProjection = this._scene.getTransformMatrix().clone(), n.skeleton && this._copyBonesTransformationMatrices(n.skeleton.getTransformMatrices(n), this._previousBonesTransformationMatrices[o.uniqueId]));
+    };
+    this._multiRenderTarget.customIsReadyFunction = (a, n, o) => {
+      if ((o || n === 0) && a.subMeshes)
+        for (let c = 0; c < a.subMeshes.length; ++c) {
+          const l = a.subMeshes[c], t = l.getMaterial(), R = l.getRenderingMesh();
+          if (!t)
+            continue;
+          const I = R._getInstancesRenderList(l._id, !!l.getReplacementMesh()), P = i.getCaps().instancedArrays && (I.visibleInstances[l._id] !== null || R.hasThinInstances);
+          if (!this.isReady(l, P))
+            return !1;
+        }
+      return !0;
+    }, this._multiRenderTarget.customRenderFunction = (a, n, o, c) => {
+      let l;
+      if (this._linkedWithPrePass) {
+        if (!this._prePassRenderer.enabled)
+          return;
+        this._scene.getEngine().bindAttachments(this._attachmentsFromPrePass);
+      }
+      if (c.length) {
+        for (i.setColorWrite(!1), l = 0; l < c.length; l++)
+          E(c.data[l]);
+        i.setColorWrite(!0);
+      }
+      for (l = 0; l < a.length; l++)
+        E(a.data[l]);
+      for (i.setDepthWrite(!1), l = 0; l < n.length; l++)
+        E(n.data[l]);
+      if (this.renderTransparentMeshes)
+        for (l = 0; l < o.length; l++)
+          E(o.data[l]);
+      i.setDepthWrite(!0);
+    };
+  }
+  // Copies the bones transformation matrices into the target array and returns the target's reference
+  _copyBonesTransformationMatrices(i, u) {
+    for (let s = 0; s < i.length; s++)
+      u[s] = i[s];
+    return u;
+  }
+}
+f.DEPTH_TEXTURE_TYPE = 0;
+f.NORMAL_TEXTURE_TYPE = 1;
+f.POSITION_TEXTURE_TYPE = 2;
+f.VELOCITY_TEXTURE_TYPE = 3;
+f.REFLECTIVITY_TEXTURE_TYPE = 4;
+f._SceneComponentInitialization = (Y) => {
+  throw N("GeometryBufferRendererSceneComponent");
+};
+export {
+  f as GeometryBufferRenderer
+};