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

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

@@ -1,147 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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
-};