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

package/dist/node_modules/@babylonjs/core/PostProcesses/screenSpaceReflectionPostProcess.esm.js

@@ -0,0 +1,147 @@
+import { __decorate as s } from "../tslib.es6.esm.js";
+import { PostProcess as y } from "./postProcess.esm.js";
+import { GeometryBufferRenderer as S } from "../Rendering/geometryBufferRenderer.esm.js";
+import { serialize as n, SerializationHelper as P } from "../Misc/decorators.esm.js";
+import { ScreenSpaceReflectionsConfiguration as B } from "../Rendering/screenSpaceReflectionsConfiguration.esm.js";
+import "../Shaders/screenSpaceReflection.fragment.esm.js";
+import { RegisterClass as F } from "../Misc/typeStore.esm.js";
+class r extends y {
+  get _geometryBufferRenderer() {
+    return this._forceGeometryBuffer ? this._scene.geometryBufferRenderer : null;
+  }
+  get _prePassRenderer() {
+    return this._forceGeometryBuffer ? null : this._scene.prePassRenderer;
+  }
+  /**
+   * Gets a string identifying the name of the class
+   * @returns "ScreenSpaceReflectionPostProcess" string
+   */
+  getClassName() {
+    return "ScreenSpaceReflectionPostProcess";
+  }
+  /**
+   * Creates a new instance of ScreenSpaceReflectionPostProcess.
+   * @param name The name of the effect.
+   * @param scene The scene containing the objects to calculate reflections.
+   * @param options The required width/height ratio to downsize to before computing the render pass.
+   * @param camera The camera to apply the render pass to.
+   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
+   * @param engine The engine which the post process will be applied. (default: current engine)
+   * @param reusable If the post process can be reused on the same frame. (default: false)
+   * @param textureType Type of textures used when performing the post process. (default: 0)
+   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: true)
+   * @param forceGeometryBuffer If this post process should use geometry buffer instead of prepass (default: false)
+   */
+  constructor(e, l, f, a, m, c, d, _ = 0, g = !1, R = !1) {
+    if (super(e, "screenSpaceReflection", ["projection", "view", "threshold", "reflectionSpecularFalloffExponent", "strength", "stepSize", "roughnessFactor"], ["textureSampler", "normalSampler", "positionSampler", "reflectivitySampler"], f, a, m, c, d, `#define SSR_SUPPORTED
+#define REFLECTION_SAMPLES 64
+#define SMOOTH_STEPS 5
+`, _, void 0, null, g), this.threshold = 1.2, this.strength = 1, this.reflectionSpecularFalloffExponent = 3, this.step = 1, this.roughnessFactor = 0.2, this._forceGeometryBuffer = !1, this._enableSmoothReflections = !1, this._reflectionSamples = 64, this._smoothSteps = 5, this._forceGeometryBuffer = R, this._forceGeometryBuffer) {
+      const t = l.enableGeometryBufferRenderer();
+      t && t.isSupported && (t.enablePosition = !0, t.enableReflectivity = !0);
+    } else {
+      const t = l.enablePrePassRenderer();
+      t == null || t.markAsDirty(), this._prePassEffectConfiguration = new B();
+    }
+    this._updateEffectDefines(), this.onApply = (t) => {
+      const i = this._geometryBufferRenderer, o = this._prePassRenderer;
+      if (!o && !i)
+        return;
+      if (i) {
+        const h = i.getTextureIndex(S.POSITION_TEXTURE_TYPE), u = i.getTextureIndex(S.REFLECTIVITY_TEXTURE_TYPE);
+        t.setTexture("normalSampler", i.getGBuffer().textures[1]), t.setTexture("positionSampler", i.getGBuffer().textures[h]), t.setTexture("reflectivitySampler", i.getGBuffer().textures[u]);
+      } else if (o) {
+        const h = o.getIndex(1), u = o.getIndex(3), T = o.getIndex(6);
+        t.setTexture("normalSampler", o.getRenderTarget().textures[T]), t.setTexture("positionSampler", o.getRenderTarget().textures[h]), t.setTexture("reflectivitySampler", o.getRenderTarget().textures[u]);
+      }
+      const p = l.activeCamera;
+      if (!p)
+        return;
+      const x = p.getViewMatrix(!0), E = p.getProjectionMatrix(!0);
+      t.setMatrix("projection", E), t.setMatrix("view", x), t.setFloat("threshold", this.threshold), t.setFloat("reflectionSpecularFalloffExponent", this.reflectionSpecularFalloffExponent), t.setFloat("strength", this.strength), t.setFloat("stepSize", this.step), t.setFloat("roughnessFactor", this.roughnessFactor);
+    }, this._isSceneRightHanded = l.useRightHandedSystem;
+  }
+  /**
+   * Gets whether or not smoothing reflections is enabled.
+   * Enabling smoothing will require more GPU power and can generate a drop in FPS.
+   */
+  get enableSmoothReflections() {
+    return this._enableSmoothReflections;
+  }
+  /**
+   * Sets whether or not smoothing reflections is enabled.
+   * Enabling smoothing will require more GPU power and can generate a drop in FPS.
+   */
+  set enableSmoothReflections(e) {
+    e !== this._enableSmoothReflections && (this._enableSmoothReflections = e, this._updateEffectDefines());
+  }
+  /**
+   * Gets the number of samples taken while computing reflections. More samples count is high,
+   * more the post-process wil require GPU power and can generate a drop in FPS. Basically in interval [25, 100].
+   */
+  get reflectionSamples() {
+    return this._reflectionSamples;
+  }
+  /**
+   * Sets the number of samples taken while computing reflections. More samples count is high,
+   * more the post-process wil require GPU power and can generate a drop in FPS. Basically in interval [25, 100].
+   */
+  set reflectionSamples(e) {
+    e !== this._reflectionSamples && (this._reflectionSamples = e, this._updateEffectDefines());
+  }
+  /**
+   * Gets the number of samples taken while smoothing reflections. More samples count is high,
+   * more the post-process will require GPU power and can generate a drop in FPS.
+   * Default value (5.0) work pretty well in all cases but can be adjusted.
+   */
+  get smoothSteps() {
+    return this._smoothSteps;
+  }
+  /*
+   * Sets the number of samples taken while smoothing reflections. More samples count is high,
+   * more the post-process will require GPU power and can generate a drop in FPS.
+   * Default value (5.0) work pretty well in all cases but can be adjusted.
+   */
+  set smoothSteps(e) {
+    e !== this._smoothSteps && (this._smoothSteps = e, this._updateEffectDefines());
+  }
+  _updateEffectDefines() {
+    const e = [];
+    (this._geometryBufferRenderer || this._prePassRenderer) && e.push("#define SSR_SUPPORTED"), this._enableSmoothReflections && e.push("#define ENABLE_SMOOTH_REFLECTIONS"), this._isSceneRightHanded && e.push("#define RIGHT_HANDED_SCENE"), e.push("#define REFLECTION_SAMPLES " + (this._reflectionSamples >> 0)), e.push("#define SMOOTH_STEPS " + (this._smoothSteps >> 0)), this.updateEffect(e.join(`
+`));
+  }
+  /**
+   * @internal
+   */
+  static _Parse(e, l, f, a) {
+    return P.Parse(() => new r(e.name, f, e.options, l, e.renderTargetSamplingMode, f.getEngine(), e.textureType, e.reusable), e, f, a);
+  }
+}
+s([
+  n()
+], r.prototype, "threshold", void 0);
+s([
+  n()
+], r.prototype, "strength", void 0);
+s([
+  n()
+], r.prototype, "reflectionSpecularFalloffExponent", void 0);
+s([
+  n()
+], r.prototype, "step", void 0);
+s([
+  n()
+], r.prototype, "roughnessFactor", void 0);
+s([
+  n()
+], r.prototype, "enableSmoothReflections", null);
+s([
+  n()
+], r.prototype, "reflectionSamples", null);
+s([
+  n()
+], r.prototype, "smoothSteps", null);
+F("BABYLON.ScreenSpaceReflectionPostProcess", r);
+export {
+  r as ScreenSpaceReflectionPostProcess
+};

package/dist/node_modules/@babylonjs/core/PostProcesses/sharpenPostProcess.esm.js

@@ -0,0 +1,46 @@
+import { __decorate as s } from "../tslib.es6.esm.js";
+import { PostProcess as h } from "./postProcess.esm.js";
+import "../Shaders/sharpen.fragment.esm.js";
+import { RegisterClass as g } from "../Misc/typeStore.esm.js";
+import { serialize as l, SerializationHelper as A } from "../Misc/decorators.esm.js";
+class t extends h {
+  /**
+   * Gets a string identifying the name of the class
+   * @returns "SharpenPostProcess" string
+   */
+  getClassName() {
+    return "SharpenPostProcess";
+  }
+  /**
+   * Creates a new instance ConvolutionPostProcess
+   * @param name The name of the effect.
+   * @param options The required width/height ratio to downsize to before computing the render pass.
+   * @param camera The camera to apply the render pass to.
+   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
+   * @param engine The engine which the post process will be applied. (default: current engine)
+   * @param reusable If the post process can be reused on the same frame. (default: false)
+   * @param textureType Type of textures used when performing the post process. (default: 0)
+   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
+   */
+  constructor(e, r, o, n, m, u, a = 0, p = !1) {
+    super(e, "sharpen", ["sharpnessAmounts", "screenSize"], null, r, o, n, m, u, null, a, void 0, null, p), this.colorAmount = 1, this.edgeAmount = 0.3, this.onApply = (i) => {
+      i.setFloat2("screenSize", this.width, this.height), i.setFloat2("sharpnessAmounts", this.edgeAmount, this.colorAmount);
+    };
+  }
+  /**
+   * @internal
+   */
+  static _Parse(e, r, o, n) {
+    return A.Parse(() => new t(e.name, e.options, r, e.renderTargetSamplingMode, o.getEngine(), e.textureType, e.reusable), e, o, n);
+  }
+}
+s([
+  l()
+], t.prototype, "colorAmount", void 0);
+s([
+  l()
+], t.prototype, "edgeAmount", void 0);
+g("BABYLON.SharpenPostProcess", t);
+export {
+  t as SharpenPostProcess
+};

package/dist/node_modules/@babylonjs/core/Probes/reflectionProbe.esm.js

@@ -0,0 +1,184 @@
+import { __decorate as p } from "../tslib.es6.esm.js";
+import { serializeAsMeshReference as x, serializeAsVector3 as b, SerializationHelper as g } from "../Misc/decorators.esm.js";
+import { RenderTargetTexture as v } from "../Materials/Textures/renderTargetTexture.esm.js";
+import { Matrix as h, Vector3 as f } from "../Maths/math.vector.esm.js";
+import { AbstractScene as m } from "../abstractScene.esm.js";
+m.prototype.removeReflectionProbe = function(c) {
+  if (!this.reflectionProbes)
+    return -1;
+  const e = this.reflectionProbes.indexOf(c);
+  return e !== -1 && this.reflectionProbes.splice(e, 1), e;
+};
+m.prototype.addReflectionProbe = function(c) {
+  this.reflectionProbes || (this.reflectionProbes = []), this.reflectionProbes.push(c);
+};
+class d {
+  /**
+   * Creates a new reflection probe
+   * @param name defines the name of the probe
+   * @param size defines the texture resolution (for each face)
+   * @param scene defines the hosting scene
+   * @param generateMipMaps defines if mip maps should be generated automatically (true by default)
+   * @param useFloat defines if HDR data (float data) should be used to store colors (false by default)
+   * @param linearSpace defines if the probe should be generated in linear space or not (false by default)
+   */
+  constructor(e, r, t, s = !0, o = !1, n = !1) {
+    if (this.name = e, this._viewMatrix = h.Identity(), this._target = f.Zero(), this._add = f.Zero(), this._invertYAxis = !1, this.position = f.Zero(), this.metadata = null, this._parentContainer = null, this._scene = t, t.getEngine().supportsUniformBuffers) {
+      this._sceneUBOs = [];
+      for (let i = 0; i < 6; ++i)
+        this._sceneUBOs.push(t.createSceneUniformBuffer(`Scene for Reflection Probe (name "${e}") face #${i}`));
+    }
+    this._scene.reflectionProbes || (this._scene.reflectionProbes = new Array()), this._scene.reflectionProbes.push(this);
+    let u = 0;
+    if (o) {
+      const i = this._scene.getEngine().getCaps();
+      i.textureHalfFloatRender ? u = 2 : i.textureFloatRender && (u = 1);
+    }
+    this._renderTargetTexture = new v(e, r, t, s, !0, u, !0), this._renderTargetTexture.gammaSpace = !n, this._renderTargetTexture.invertZ = t.useRightHandedSystem;
+    const l = t.getEngine().useReverseDepthBuffer;
+    this._renderTargetTexture.onBeforeRenderObservable.add((i) => {
+      switch (this._sceneUBOs && (t.setSceneUniformBuffer(this._sceneUBOs[i]), t.getSceneUniformBuffer().unbindEffect()), i) {
+        case 0:
+          this._add.copyFromFloats(1, 0, 0);
+          break;
+        case 1:
+          this._add.copyFromFloats(-1, 0, 0);
+          break;
+        case 2:
+          this._add.copyFromFloats(0, this._invertYAxis ? 1 : -1, 0);
+          break;
+        case 3:
+          this._add.copyFromFloats(0, this._invertYAxis ? -1 : 1, 0);
+          break;
+        case 4:
+          this._add.copyFromFloats(0, 0, t.useRightHandedSystem ? -1 : 1);
+          break;
+        case 5:
+          this._add.copyFromFloats(0, 0, t.useRightHandedSystem ? 1 : -1);
+          break;
+      }
+      this._attachedMesh && this.position.copyFrom(this._attachedMesh.getAbsolutePosition()), this.position.addToRef(this._add, this._target);
+      const a = t.useRightHandedSystem ? h.LookAtRHToRef : h.LookAtLHToRef, T = t.useRightHandedSystem ? h.PerspectiveFovRH : h.PerspectiveFovLH;
+      a(this.position, this._target, f.Up(), this._viewMatrix), t.activeCamera && (this._projectionMatrix = T(Math.PI / 2, 1, l ? t.activeCamera.maxZ : t.activeCamera.minZ, l ? t.activeCamera.minZ : t.activeCamera.maxZ, this._scene.getEngine().isNDCHalfZRange), t.setTransformMatrix(this._viewMatrix, this._projectionMatrix), t.activeCamera.isRigCamera && !this._renderTargetTexture.activeCamera && (this._renderTargetTexture.activeCamera = t.activeCamera.rigParent || null)), t._forcedViewPosition = this.position;
+    });
+    let _;
+    this._renderTargetTexture.onBeforeBindObservable.add(() => {
+      var i, a;
+      this._currentSceneUBO = t.getSceneUniformBuffer(), (a = (i = t.getEngine())._debugPushGroup) === null || a === void 0 || a.call(i, `reflection probe generation for ${e}`, 1), _ = this._scene.imageProcessingConfiguration.applyByPostProcess, n && (t.imageProcessingConfiguration.applyByPostProcess = !0);
+    }), this._renderTargetTexture.onAfterUnbindObservable.add(() => {
+      var i, a;
+      t.imageProcessingConfiguration.applyByPostProcess = _, t._forcedViewPosition = null, this._sceneUBOs && t.setSceneUniformBuffer(this._currentSceneUBO), t.updateTransformMatrix(!0), (a = (i = t.getEngine())._debugPopGroup) === null || a === void 0 || a.call(i, 1);
+    });
+  }
+  /** Gets or sets the number of samples to use for multi-sampling (0 by default). Required WebGL2 */
+  get samples() {
+    return this._renderTargetTexture.samples;
+  }
+  set samples(e) {
+    this._renderTargetTexture.samples = e;
+  }
+  /** Gets or sets the refresh rate to use (on every frame by default) */
+  get refreshRate() {
+    return this._renderTargetTexture.refreshRate;
+  }
+  set refreshRate(e) {
+    this._renderTargetTexture.refreshRate = e;
+  }
+  /**
+   * Gets the hosting scene
+   * @returns a Scene
+   */
+  getScene() {
+    return this._scene;
+  }
+  /** Gets the internal CubeTexture used to render to */
+  get cubeTexture() {
+    return this._renderTargetTexture;
+  }
+  /** Gets the list of meshes to render */
+  get renderList() {
+    return this._renderTargetTexture.renderList;
+  }
+  /**
+   * Attach the probe to a specific mesh (Rendering will be done from attached mesh's position)
+   * @param mesh defines the mesh to attach to
+   */
+  attachToMesh(e) {
+    this._attachedMesh = 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.
+   */
+  setRenderingAutoClearDepthStencil(e, r) {
+    this._renderTargetTexture.setRenderingAutoClearDepthStencil(e, r);
+  }
+  /**
+   * Clean all associated resources
+   */
+  dispose() {
+    const e = this._scene.reflectionProbes.indexOf(this);
+    if (e !== -1 && this._scene.reflectionProbes.splice(e, 1), this._parentContainer) {
+      const r = this._parentContainer.reflectionProbes.indexOf(this);
+      r > -1 && this._parentContainer.reflectionProbes.splice(r, 1), this._parentContainer = null;
+    }
+    if (this._renderTargetTexture && (this._renderTargetTexture.dispose(), this._renderTargetTexture = null), this._sceneUBOs) {
+      for (const r of this._sceneUBOs)
+        r.dispose();
+      this._sceneUBOs = [];
+    }
+  }
+  /**
+   * Converts the reflection probe information to a readable string for debug purpose.
+   * @param fullDetails Supports for multiple levels of logging within scene loading
+   * @returns the human readable reflection probe info
+   */
+  toString(e) {
+    let r = "Name: " + this.name;
+    return e && (r += ", position: " + this.position.toString(), this._attachedMesh && (r += ", attached mesh: " + this._attachedMesh.name)), r;
+  }
+  /**
+   * Get the class name of the refection probe.
+   * @returns "ReflectionProbe"
+   */
+  getClassName() {
+    return "ReflectionProbe";
+  }
+  /**
+   * Serialize the reflection probe to a JSON representation we can easily use in the respective Parse function.
+   * @returns The JSON representation of the texture
+   */
+  serialize() {
+    const e = g.Serialize(this, this._renderTargetTexture.serialize());
+    return e.isReflectionProbe = !0, e.metadata = this.metadata, e;
+  }
+  /**
+   * Parse the JSON representation of a reflection probe in order to recreate the reflection probe in the given scene.
+   * @param parsedReflectionProbe Define the JSON representation of the reflection probe
+   * @param scene Define the scene the parsed reflection probe should be instantiated in
+   * @param rootUrl Define the root url of the parsing sequence in the case of relative dependencies
+   * @returns The parsed reflection probe if successful
+   */
+  static Parse(e, r, t) {
+    let s = null;
+    if (r.reflectionProbes)
+      for (let o = 0; o < r.reflectionProbes.length; o++) {
+        const n = r.reflectionProbes[o];
+        if (n.name === e.name) {
+          s = n;
+          break;
+        }
+      }
+    return s = g.Parse(() => s || new d(e.name, e.renderTargetSize, r, e._generateMipMaps), e, r, t), s.cubeTexture._waitingRenderList = e.renderList, e._attachedMesh && s.attachToMesh(r.getMeshById(e._attachedMesh)), e.metadata && (s.metadata = e.metadata), s;
+  }
+}
+p([
+  x()
+], d.prototype, "_attachedMesh", void 0);
+p([
+  b()
+], d.prototype, "position", void 0);
+export {
+  d as ReflectionProbe
+};

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

@@ -0,0 +1,170 @@
+import { Scene as v } from "../scene.esm.js";
+import { VertexBuffer as s } from "../Buffers/buffer.esm.js";
+import { AbstractMesh as O } from "../Meshes/abstractMesh.esm.js";
+import { Matrix as B } from "../Maths/math.vector.esm.js";
+import { SmartArray as I } from "../Misc/smartArray.esm.js";
+import { SceneComponentConstants as h } from "../sceneComponent.esm.js";
+import { Material as p } from "../Materials/material.esm.js";
+import { ShaderMaterial as R } from "../Materials/shaderMaterial.esm.js";
+import { Color3 as E } from "../Maths/math.color.esm.js";
+import { Observable as g } from "../Misc/observable.esm.js";
+import { DrawWrapper as w } from "../Materials/drawWrapper.esm.js";
+import { UniformBuffer as S } from "../Materials/uniformBuffer.esm.js";
+import { CreateBoxVertexData as F } from "../Meshes/Builders/boxBuilder.esm.js";
+import "../Shaders/boundingBoxRenderer.fragment.esm.js";
+import "../Shaders/boundingBoxRenderer.vertex.esm.js";
+Object.defineProperty(v.prototype, "forceShowBoundingBoxes", {
+  get: function() {
+    return this._forceShowBoundingBoxes || !1;
+  },
+  set: function(d) {
+    this._forceShowBoundingBoxes = d, d && this.getBoundingBoxRenderer();
+  },
+  enumerable: !0,
+  configurable: !0
+});
+v.prototype.getBoundingBoxRenderer = function() {
+  return this._boundingBoxRenderer || (this._boundingBoxRenderer = new y(this)), this._boundingBoxRenderer;
+};
+Object.defineProperty(O.prototype, "showBoundingBox", {
+  get: function() {
+    return this._showBoundingBox || !1;
+  },
+  set: function(d) {
+    this._showBoundingBox = d, d && this.getScene().getBoundingBoxRenderer();
+  },
+  enumerable: !0,
+  configurable: !0
+});
+class y {
+  /**
+   * Instantiates a new bounding box renderer in a scene.
+   * @param scene the scene the  renderer renders in
+   */
+  constructor(e) {
+    this.name = h.NAME_BOUNDINGBOXRENDERER, this.frontColor = new E(1, 1, 1), this.backColor = new E(0.1, 0.1, 0.1), this.showBackLines = !0, this.onBeforeBoxRenderingObservable = new g(), this.onAfterBoxRenderingObservable = new g(), this.onResourcesReadyObservable = new g(), this.enabled = !0, this.renderList = new I(32), this._vertexBuffers = {}, this._fillIndexBuffer = null, this._fillIndexData = null, this.scene = e, e._addComponent(this), this._uniformBufferFront = new S(this.scene.getEngine(), void 0, void 0, "BoundingBoxRendererFront", !this.scene.getEngine().isWebGPU), this._buildUniformLayout(this._uniformBufferFront), this._uniformBufferBack = new S(this.scene.getEngine(), void 0, void 0, "BoundingBoxRendererBack", !this.scene.getEngine().isWebGPU), this._buildUniformLayout(this._uniformBufferBack);
+  }
+  _buildUniformLayout(e) {
+    e.addUniform("color", 4), e.addUniform("world", 16), e.addUniform("viewProjection", 16), e.addUniform("viewProjectionR", 16), e.create();
+  }
+  /**
+   * Registers the component in a given scene
+   */
+  register() {
+    this.scene._beforeEvaluateActiveMeshStage.registerStep(h.STEP_BEFOREEVALUATEACTIVEMESH_BOUNDINGBOXRENDERER, this, this.reset), this.scene._preActiveMeshStage.registerStep(h.STEP_PREACTIVEMESH_BOUNDINGBOXRENDERER, this, this._preActiveMesh), this.scene._evaluateSubMeshStage.registerStep(h.STEP_EVALUATESUBMESH_BOUNDINGBOXRENDERER, this, this._evaluateSubMesh), this.scene._afterRenderingGroupDrawStage.registerStep(h.STEP_AFTERRENDERINGGROUPDRAW_BOUNDINGBOXRENDERER, this, this.render);
+  }
+  _evaluateSubMesh(e, r) {
+    if (e.showSubMeshesBoundingBox) {
+      const i = r.getBoundingInfo();
+      i != null && (i.boundingBox._tag = e.renderingGroupId, this.renderList.push(i.boundingBox));
+    }
+  }
+  _preActiveMesh(e) {
+    if (e.showBoundingBox || this.scene.forceShowBoundingBoxes) {
+      const r = e.getBoundingInfo();
+      r.boundingBox._tag = e.renderingGroupId, this.renderList.push(r.boundingBox);
+    }
+  }
+  _prepareResources() {
+    if (this._colorShader)
+      return;
+    this._colorShader = new R("colorShader", this.scene, "boundingBoxRenderer", {
+      attributes: [s.PositionKind],
+      uniforms: ["world", "viewProjection", "viewProjectionR", "color"],
+      uniformBuffers: ["BoundingBoxRenderer"]
+    }, !1), this._colorShader.doNotSerialize = !0, this._colorShader.reservedDataStore = {
+      hidden: !0
+    }, this._colorShaderForOcclusionQuery = new R("colorShaderOccQuery", this.scene, "boundingBoxRenderer", {
+      attributes: [s.PositionKind],
+      uniforms: ["world", "viewProjection", "viewProjectionR", "color"],
+      uniformBuffers: ["BoundingBoxRenderer"]
+    }, !0), this._colorShaderForOcclusionQuery.doNotSerialize = !0, this._colorShaderForOcclusionQuery.reservedDataStore = {
+      hidden: !0
+    };
+    const e = this.scene.getEngine(), r = F({ size: 1 });
+    this._vertexBuffers[s.PositionKind] = new s(e, r.positions, s.PositionKind, !1), this._createIndexBuffer(), this._fillIndexData = r.indices, this.onResourcesReadyObservable.notifyObservers(this);
+  }
+  _createIndexBuffer() {
+    const e = this.scene.getEngine();
+    this._indexBuffer = e.createIndexBuffer([0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 7, 1, 6, 2, 5, 3, 4]);
+  }
+  /**
+   * Rebuilds the elements related to this component in case of
+   * context lost for instance.
+   */
+  rebuild() {
+    const e = this._vertexBuffers[s.PositionKind];
+    e && e._rebuild(), this._createIndexBuffer();
+  }
+  /**
+   * @internal
+   */
+  reset() {
+    this.renderList.reset();
+  }
+  /**
+   * Render the bounding boxes of a specific rendering group
+   * @param renderingGroupId defines the rendering group to render
+   */
+  render(e) {
+    var r, i;
+    if (this.renderList.length === 0 || !this.enabled || (this._prepareResources(), !this._colorShader.isReady()))
+      return;
+    const t = this.scene.getEngine();
+    t.setDepthWrite(!1);
+    const l = this.scene.getTransformMatrix();
+    for (let f = 0; f < this.renderList.length; f++) {
+      const n = this.renderList.data[f];
+      if (n._tag !== e)
+        continue;
+      this._createWrappersForBoundingBox(n), this.onBeforeBoxRenderingObservable.notifyObservers(n);
+      const _ = n.minimum, o = n.maximum.subtract(_), c = _.add(o.scale(0.5)), u = B.Scaling(o.x, o.y, o.z).multiply(B.Translation(c.x, c.y, c.z)).multiply(n.getWorldMatrix()), x = t.useReverseDepthBuffer;
+      if (this.showBackLines) {
+        const b = (r = n._drawWrapperBack) !== null && r !== void 0 ? r : this._colorShader._getDrawWrapper();
+        this._colorShader._preBind(b), t.bindBuffers(this._vertexBuffers, this._indexBuffer, this._colorShader.getEffect()), x ? t.setDepthFunctionToLessOrEqual() : t.setDepthFunctionToGreaterOrEqual(), this._uniformBufferBack.bindToEffect(b.effect, "BoundingBoxRenderer"), this._uniformBufferBack.updateColor4("color", this.backColor, 1), this._uniformBufferBack.updateMatrix("world", u), this._uniformBufferBack.updateMatrix("viewProjection", l), this._uniformBufferBack.update(), t.drawElementsType(p.LineListDrawMode, 0, 24);
+      }
+      const m = (i = n._drawWrapperFront) !== null && i !== void 0 ? i : this._colorShader._getDrawWrapper();
+      this._colorShader._preBind(m), t.bindBuffers(this._vertexBuffers, this._indexBuffer, this._colorShader.getEffect()), x ? t.setDepthFunctionToGreater() : t.setDepthFunctionToLess(), this._uniformBufferFront.bindToEffect(m.effect, "BoundingBoxRenderer"), this._uniformBufferFront.updateColor4("color", this.frontColor, 1), this._uniformBufferFront.updateMatrix("world", u), this._uniformBufferFront.updateMatrix("viewProjection", l), this._uniformBufferFront.update(), t.drawElementsType(p.LineListDrawMode, 0, 24), this.onAfterBoxRenderingObservable.notifyObservers(n);
+    }
+    this._colorShader.unbind(), t.setDepthFunctionToLessOrEqual(), t.setDepthWrite(!0);
+  }
+  _createWrappersForBoundingBox(e) {
+    if (!e._drawWrapperFront) {
+      const r = this.scene.getEngine();
+      e._drawWrapperFront = new w(r), e._drawWrapperBack = new w(r), e._drawWrapperFront.setEffect(this._colorShader.getEffect()), e._drawWrapperBack.setEffect(this._colorShader.getEffect());
+    }
+  }
+  /**
+   * In case of occlusion queries, we can render the occlusion bounding box through this method
+   * @param mesh Define the mesh to render the occlusion bounding box for
+   */
+  renderOcclusionBoundingBox(e) {
+    const r = this.scene.getEngine();
+    this._renderPassIdForOcclusionQuery === void 0 && (this._renderPassIdForOcclusionQuery = r.createRenderPassId("Render pass for occlusion query"));
+    const i = r.currentRenderPassId;
+    r.currentRenderPassId = this._renderPassIdForOcclusionQuery, this._prepareResources();
+    const t = e.subMeshes[0];
+    if (!this._colorShaderForOcclusionQuery.isReady(e, void 0, t) || !e.hasBoundingInfo) {
+      r.currentRenderPassId = i;
+      return;
+    }
+    this._fillIndexBuffer || (this._fillIndexBuffer = r.createIndexBuffer(this._fillIndexData));
+    const l = r.useReverseDepthBuffer;
+    r.setDepthWrite(!1), r.setColorWrite(!1);
+    const f = e.getBoundingInfo().boundingBox, n = f.minimum, a = f.maximum.subtract(n), o = n.add(a.scale(0.5)), c = B.Scaling(a.x, a.y, a.z).multiply(B.Translation(o.x, o.y, o.z)).multiply(f.getWorldMatrix()), u = t._drawWrapper;
+    this._colorShaderForOcclusionQuery._preBind(u), r.bindBuffers(this._vertexBuffers, this._fillIndexBuffer, u.effect), l ? r.setDepthFunctionToGreater() : r.setDepthFunctionToLess(), this.scene.resetCachedMaterial(), this._uniformBufferFront.bindToEffect(u.effect, "BoundingBoxRenderer"), this._uniformBufferFront.updateMatrix("world", c), this._uniformBufferFront.updateMatrix("viewProjection", this.scene.getTransformMatrix()), this._uniformBufferFront.update(), r.drawElementsType(p.TriangleFillMode, 0, 36), this._colorShaderForOcclusionQuery.unbind(), r.setDepthFunctionToLessOrEqual(), r.setDepthWrite(!0), r.setColorWrite(!0), r.currentRenderPassId = i;
+  }
+  /**
+   * Dispose and release the resources attached to this renderer.
+   */
+  dispose() {
+    if (this._renderPassIdForOcclusionQuery !== void 0 && (this.scene.getEngine().releaseRenderPassId(this._renderPassIdForOcclusionQuery), this._renderPassIdForOcclusionQuery = void 0), !this._colorShader)
+      return;
+    this.onBeforeBoxRenderingObservable.clear(), this.onAfterBoxRenderingObservable.clear(), this.onResourcesReadyObservable.clear(), this.renderList.dispose(), this._colorShader.dispose(), this._colorShaderForOcclusionQuery.dispose(), this._uniformBufferFront.dispose(), this._uniformBufferBack.dispose();
+    const e = this._vertexBuffers[s.PositionKind];
+    e && (e.dispose(), this._vertexBuffers[s.PositionKind] = null), this.scene.getEngine()._releaseBuffer(this._indexBuffer), this._fillIndexBuffer && (this.scene.getEngine()._releaseBuffer(this._fillIndexBuffer), this._fillIndexBuffer = null);
+  }
+}
+export {
+  y as BoundingBoxRenderer
+};