@perceptimagery/dita-configurator-staging 0.1.6200 → 0.1.6300

package/dist/index.js

@@ -30,9 +30,9 @@ var __publicField = (obj, key, value) => {
       const expires = this.config.EXPIRES;
       if (!expires)
         return true;
-      const now = (/* @__PURE__ */ new Date()).getTime();
+      const now2 = (/* @__PURE__ */ new Date()).getTime();
       const expiresDate = new Date(expires).getTime();
-      const diff = expiresDate - now;
+      const diff = expiresDate - now2;
       return expires === "" || diff <= 0;
     }
     IsConfigExpired() {
@@ -111,7 +111,7 @@ var __publicField = (obj, key, value) => {
     host: "https://api.sprie.io"
   };
   const config = Object.freeze(Config$1);
-  const version = "0.1.6200";
+  const version = "0.1.6300";
   function modifyLensArr(arr, element) {
     const index = arr.findIndex((e) => e["sku"] === element["sku"]);
     if (index !== -1) {
@@ -30233,6 +30233,13 @@ var __publicField = (obj, key, value) => {
       this.image = images;
     }
   }
+  class RawShaderMaterial extends ShaderMaterial {
+    constructor(parameters) {
+      super(parameters);
+      this.isRawShaderMaterial = true;
+      this.type = "RawShaderMaterial";
+    }
+  }
   class MeshStandardMaterial extends Material {
     constructor(parameters) {
       super();
@@ -32056,6 +32063,47 @@ var __publicField = (obj, key, value) => {
       scope.manager.itemStart(url);
     }
   }
+  class Clock {
+    constructor(autoStart = true) {
+      this.autoStart = autoStart;
+      this.startTime = 0;
+      this.oldTime = 0;
+      this.elapsedTime = 0;
+      this.running = false;
+    }
+    start() {
+      this.startTime = now();
+      this.oldTime = this.startTime;
+      this.elapsedTime = 0;
+      this.running = true;
+    }
+    stop() {
+      this.getElapsedTime();
+      this.running = false;
+      this.autoStart = false;
+    }
+    getElapsedTime() {
+      this.getDelta();
+      return this.elapsedTime;
+    }
+    getDelta() {
+      let diff = 0;
+      if (this.autoStart && !this.running) {
+        this.start();
+        return 0;
+      }
+      if (this.running) {
+        const newTime = now();
+        diff = (newTime - this.oldTime) / 1e3;
+        this.oldTime = newTime;
+        this.elapsedTime += diff;
+      }
+      return diff;
+    }
+  }
+  function now() {
+    return (typeof performance === "undefined" ? Date : performance).now();
+  }
   const _RESERVED_CHARS_RE = "\\[\\]\\.:\\/";
   const _reservedRe = new RegExp("[" + _RESERVED_CHARS_RE + "]", "g");
   const _wordChar = "[^" + _RESERVED_CHARS_RE + "]";
@@ -36671,6 +36719,475 @@ var __publicField = (obj, key, value) => {
       return super.load(url, onLoadCallback, onProgress, onError);
     }
   }
+  const CopyShader = {
+    name: "CopyShader",
+    uniforms: {
+      "tDiffuse": { value: null },
+      "opacity": { value: 1 }
+    },
+    vertexShader: (
+      /* glsl */
+      `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 texel = texture2D( tDiffuse, vUv );
+			gl_FragColor = opacity * texel;
+
+
+		}`
+    )
+  };
+  class Pass {
+    constructor() {
+      this.isPass = true;
+      this.enabled = true;
+      this.needsSwap = true;
+      this.clear = false;
+      this.renderToScreen = false;
+    }
+    setSize() {
+    }
+    render() {
+      console.error("THREE.Pass: .render() must be implemented in derived pass.");
+    }
+    dispose() {
+    }
+  }
+  const _camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+  class FullscreenTriangleGeometry extends BufferGeometry {
+    constructor() {
+      super();
+      this.setAttribute("position", new Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3));
+      this.setAttribute("uv", new Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));
+    }
+  }
+  const _geometry = new FullscreenTriangleGeometry();
+  class FullScreenQuad {
+    constructor(material) {
+      this._mesh = new Mesh(_geometry, material);
+    }
+    dispose() {
+      this._mesh.geometry.dispose();
+    }
+    render(renderer) {
+      renderer.render(this._mesh, _camera);
+    }
+    get material() {
+      return this._mesh.material;
+    }
+    set material(value) {
+      this._mesh.material = value;
+    }
+  }
+  class ShaderPass extends Pass {
+    constructor(shader, textureID) {
+      super();
+      this.textureID = textureID !== void 0 ? textureID : "tDiffuse";
+      if (shader instanceof ShaderMaterial) {
+        this.uniforms = shader.uniforms;
+        this.material = shader;
+      } else if (shader) {
+        this.uniforms = UniformsUtils.clone(shader.uniforms);
+        this.material = new ShaderMaterial({
+          name: shader.name !== void 0 ? shader.name : "unspecified",
+          defines: Object.assign({}, shader.defines),
+          uniforms: this.uniforms,
+          vertexShader: shader.vertexShader,
+          fragmentShader: shader.fragmentShader
+        });
+      }
+      this.fsQuad = new FullScreenQuad(this.material);
+    }
+    render(renderer, writeBuffer, readBuffer) {
+      if (this.uniforms[this.textureID]) {
+        this.uniforms[this.textureID].value = readBuffer.texture;
+      }
+      this.fsQuad.material = this.material;
+      if (this.renderToScreen) {
+        renderer.setRenderTarget(null);
+        this.fsQuad.render(renderer);
+      } else {
+        renderer.setRenderTarget(writeBuffer);
+        if (this.clear)
+          renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil);
+        this.fsQuad.render(renderer);
+      }
+    }
+    dispose() {
+      this.material.dispose();
+      this.fsQuad.dispose();
+    }
+  }
+  class MaskPass extends Pass {
+    constructor(scene, camera) {
+      super();
+      this.scene = scene;
+      this.camera = camera;
+      this.clear = true;
+      this.needsSwap = false;
+      this.inverse = false;
+    }
+    render(renderer, writeBuffer, readBuffer) {
+      const context = renderer.getContext();
+      const state = renderer.state;
+      state.buffers.color.setMask(false);
+      state.buffers.depth.setMask(false);
+      state.buffers.color.setLocked(true);
+      state.buffers.depth.setLocked(true);
+      let writeValue, clearValue;
+      if (this.inverse) {
+        writeValue = 0;
+        clearValue = 1;
+      } else {
+        writeValue = 1;
+        clearValue = 0;
+      }
+      state.buffers.stencil.setTest(true);
+      state.buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);
+      state.buffers.stencil.setFunc(context.ALWAYS, writeValue, 4294967295);
+      state.buffers.stencil.setClear(clearValue);
+      state.buffers.stencil.setLocked(true);
+      renderer.setRenderTarget(readBuffer);
+      if (this.clear)
+        renderer.clear();
+      renderer.render(this.scene, this.camera);
+      renderer.setRenderTarget(writeBuffer);
+      if (this.clear)
+        renderer.clear();
+      renderer.render(this.scene, this.camera);
+      state.buffers.color.setLocked(false);
+      state.buffers.depth.setLocked(false);
+      state.buffers.color.setMask(true);
+      state.buffers.depth.setMask(true);
+      state.buffers.stencil.setLocked(false);
+      state.buffers.stencil.setFunc(context.EQUAL, 1, 4294967295);
+      state.buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);
+      state.buffers.stencil.setLocked(true);
+    }
+  }
+  class ClearMaskPass extends Pass {
+    constructor() {
+      super();
+      this.needsSwap = false;
+    }
+    render(renderer) {
+      renderer.state.buffers.stencil.setLocked(false);
+      renderer.state.buffers.stencil.setTest(false);
+    }
+  }
+  class EffectComposer {
+    constructor(renderer, renderTarget) {
+      this.renderer = renderer;
+      this._pixelRatio = renderer.getPixelRatio();
+      if (renderTarget === void 0) {
+        const size = renderer.getSize(new Vector2());
+        this._width = size.width;
+        this._height = size.height;
+        renderTarget = new WebGLRenderTarget(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType });
+        renderTarget.texture.name = "EffectComposer.rt1";
+      } else {
+        this._width = renderTarget.width;
+        this._height = renderTarget.height;
+      }
+      this.renderTarget1 = renderTarget;
+      this.renderTarget2 = renderTarget.clone();
+      this.renderTarget2.texture.name = "EffectComposer.rt2";
+      this.writeBuffer = this.renderTarget1;
+      this.readBuffer = this.renderTarget2;
+      this.renderToScreen = true;
+      this.passes = [];
+      this.copyPass = new ShaderPass(CopyShader);
+      this.copyPass.material.blending = NoBlending;
+      this.clock = new Clock();
+    }
+    swapBuffers() {
+      const tmp = this.readBuffer;
+      this.readBuffer = this.writeBuffer;
+      this.writeBuffer = tmp;
+    }
+    addPass(pass) {
+      this.passes.push(pass);
+      pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+    }
+    insertPass(pass, index) {
+      this.passes.splice(index, 0, pass);
+      pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+    }
+    removePass(pass) {
+      const index = this.passes.indexOf(pass);
+      if (index !== -1) {
+        this.passes.splice(index, 1);
+      }
+    }
+    isLastEnabledPass(passIndex) {
+      for (let i = passIndex + 1; i < this.passes.length; i++) {
+        if (this.passes[i].enabled) {
+          return false;
+        }
+      }
+      return true;
+    }
+    render(deltaTime) {
+      if (deltaTime === void 0) {
+        deltaTime = this.clock.getDelta();
+      }
+      const currentRenderTarget = this.renderer.getRenderTarget();
+      let maskActive = false;
+      for (let i = 0, il = this.passes.length; i < il; i++) {
+        const pass = this.passes[i];
+        if (pass.enabled === false)
+          continue;
+        pass.renderToScreen = this.renderToScreen && this.isLastEnabledPass(i);
+        pass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime, maskActive);
+        if (pass.needsSwap) {
+          if (maskActive) {
+            const context = this.renderer.getContext();
+            const stencil = this.renderer.state.buffers.stencil;
+            stencil.setFunc(context.NOTEQUAL, 1, 4294967295);
+            this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime);
+            stencil.setFunc(context.EQUAL, 1, 4294967295);
+          }
+          this.swapBuffers();
+        }
+        if (MaskPass !== void 0) {
+          if (pass instanceof MaskPass) {
+            maskActive = true;
+          } else if (pass instanceof ClearMaskPass) {
+            maskActive = false;
+          }
+        }
+      }
+      this.renderer.setRenderTarget(currentRenderTarget);
+    }
+    reset(renderTarget) {
+      if (renderTarget === void 0) {
+        const size = this.renderer.getSize(new Vector2());
+        this._pixelRatio = this.renderer.getPixelRatio();
+        this._width = size.width;
+        this._height = size.height;
+        renderTarget = this.renderTarget1.clone();
+        renderTarget.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+      }
+      this.renderTarget1.dispose();
+      this.renderTarget2.dispose();
+      this.renderTarget1 = renderTarget;
+      this.renderTarget2 = renderTarget.clone();
+      this.writeBuffer = this.renderTarget1;
+      this.readBuffer = this.renderTarget2;
+    }
+    setSize(width, height) {
+      this._width = width;
+      this._height = height;
+      const effectiveWidth = this._width * this._pixelRatio;
+      const effectiveHeight = this._height * this._pixelRatio;
+      this.renderTarget1.setSize(effectiveWidth, effectiveHeight);
+      this.renderTarget2.setSize(effectiveWidth, effectiveHeight);
+      for (let i = 0; i < this.passes.length; i++) {
+        this.passes[i].setSize(effectiveWidth, effectiveHeight);
+      }
+    }
+    setPixelRatio(pixelRatio) {
+      this._pixelRatio = pixelRatio;
+      this.setSize(this._width, this._height);
+    }
+    dispose() {
+      this.renderTarget1.dispose();
+      this.renderTarget2.dispose();
+      this.copyPass.dispose();
+    }
+  }
+  const OutputShader = {
+    name: "OutputShader",
+    uniforms: {
+      "tDiffuse": { value: null },
+      "toneMappingExposure": { value: 1 }
+    },
+    vertexShader: (
+      /* glsl */
+      `
+		precision highp float;
+
+		uniform mat4 modelViewMatrix;
+		uniform mat4 projectionMatrix;
+
+		attribute vec3 position;
+		attribute vec2 uv;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+	
+		precision highp float;
+
+		uniform sampler2D tDiffuse;
+
+		#include <tonemapping_pars_fragment>
+		#include <colorspace_pars_fragment>
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+
+			// tone mapping
+
+			#ifdef LINEAR_TONE_MAPPING
+
+				gl_FragColor.rgb = LinearToneMapping( gl_FragColor.rgb );
+
+			#elif defined( REINHARD_TONE_MAPPING )
+
+				gl_FragColor.rgb = ReinhardToneMapping( gl_FragColor.rgb );
+
+			#elif defined( CINEON_TONE_MAPPING )
+
+				gl_FragColor.rgb = OptimizedCineonToneMapping( gl_FragColor.rgb );
+
+			#elif defined( ACES_FILMIC_TONE_MAPPING )
+
+				gl_FragColor.rgb = ACESFilmicToneMapping( gl_FragColor.rgb );
+
+			#endif
+
+			// color space
+
+			#ifdef SRGB_TRANSFER
+
+				gl_FragColor = sRGBTransferOETF( gl_FragColor );
+
+			#endif
+
+		}`
+    )
+  };
+  class OutputPass extends Pass {
+    constructor() {
+      super();
+      const shader = OutputShader;
+      this.uniforms = UniformsUtils.clone(shader.uniforms);
+      this.material = new RawShaderMaterial({
+        name: shader.name,
+        uniforms: this.uniforms,
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader
+      });
+      this.fsQuad = new FullScreenQuad(this.material);
+      this._outputColorSpace = null;
+      this._toneMapping = null;
+    }
+    render(renderer, writeBuffer, readBuffer) {
+      this.uniforms["tDiffuse"].value = readBuffer.texture;
+      this.uniforms["toneMappingExposure"].value = renderer.toneMappingExposure;
+      if (this._outputColorSpace !== renderer.outputColorSpace || this._toneMapping !== renderer.toneMapping) {
+        this._outputColorSpace = renderer.outputColorSpace;
+        this._toneMapping = renderer.toneMapping;
+        this.material.defines = {};
+        if (ColorManagement.getTransfer(this._outputColorSpace) === SRGBTransfer)
+          this.material.defines.SRGB_TRANSFER = "";
+        if (this._toneMapping === LinearToneMapping)
+          this.material.defines.LINEAR_TONE_MAPPING = "";
+        else if (this._toneMapping === ReinhardToneMapping)
+          this.material.defines.REINHARD_TONE_MAPPING = "";
+        else if (this._toneMapping === CineonToneMapping)
+          this.material.defines.CINEON_TONE_MAPPING = "";
+        else if (this._toneMapping === ACESFilmicToneMapping)
+          this.material.defines.ACES_FILMIC_TONE_MAPPING = "";
+        this.material.needsUpdate = true;
+      }
+      if (this.renderToScreen === true) {
+        renderer.setRenderTarget(null);
+        this.fsQuad.render(renderer);
+      } else {
+        renderer.setRenderTarget(writeBuffer);
+        if (this.clear)
+          renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil);
+        this.fsQuad.render(renderer);
+      }
+    }
+    dispose() {
+      this.material.dispose();
+      this.fsQuad.dispose();
+    }
+  }
+  class RenderPass extends Pass {
+    constructor(scene, camera, overrideMaterial = null, clearColor = null, clearAlpha = null) {
+      super();
+      this.scene = scene;
+      this.camera = camera;
+      this.overrideMaterial = overrideMaterial;
+      this.clearColor = clearColor;
+      this.clearAlpha = clearAlpha;
+      this.clear = true;
+      this.clearDepth = false;
+      this.needsSwap = false;
+      this._oldClearColor = new Color();
+    }
+    render(renderer, writeBuffer, readBuffer) {
+      const oldAutoClear = renderer.autoClear;
+      renderer.autoClear = false;
+      let oldClearAlpha, oldOverrideMaterial;
+      if (this.overrideMaterial !== null) {
+        oldOverrideMaterial = this.scene.overrideMaterial;
+        this.scene.overrideMaterial = this.overrideMaterial;
+      }
+      if (this.clearColor !== null) {
+        renderer.getClearColor(this._oldClearColor);
+        renderer.setClearColor(this.clearColor);
+      }
+      if (this.clearAlpha !== null) {
+        oldClearAlpha = renderer.getClearAlpha();
+        renderer.setClearAlpha(this.clearAlpha);
+      }
+      if (this.clearDepth == true) {
+        renderer.clearDepth();
+      }
+      renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
+      if (this.clear === true) {
+        renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil);
+      }
+      renderer.render(this.scene, this.camera);
+      if (this.clearColor !== null) {
+        renderer.setClearColor(this._oldClearColor);
+      }
+      if (this.clearAlpha !== null) {
+        renderer.setClearAlpha(oldClearAlpha);
+      }
+      if (this.overrideMaterial !== null) {
+        this.scene.overrideMaterial = oldOverrideMaterial;
+      }
+      renderer.autoClear = oldAutoClear;
+    }
+  }
   const HorizontalBlurShader = {
     name: "HorizontalBlurShader",
     uniforms: {
@@ -36818,6 +37335,7 @@ var __publicField = (obj, key, value) => {
         antialias: true
       });
       this.renderer.setSize(newWidth, newHeight);
+      this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
     }
     cleanUp() {
       if (this.renderer) {
@@ -37000,13 +37518,17 @@ var __publicField = (obj, key, value) => {
       if (isRawGlbFile) {
         result = await loader.loadAsync(modelFileUrl);
       } else {
-        result = await this.LoadEncryptedGlb(loader, modelFileUrl, password).then((finalRes) => {
+        result = await this.LoadEncryptedGlb(
+          loader,
+          modelFileUrl,
+          password
+        ).then((finalRes) => {
           if (renderAsIs) {
             this.updateScene(finalRes.result);
           } else {
             this.updateMaterials(finalRes.result);
           }
-          this.setupAndRenderScene(finalRes.result.scene);
+          this.loadModelInsideScene(finalRes.result.scene);
         });
       }
       return result == null ? void 0 : result.scene;
@@ -37090,7 +37612,10 @@ var __publicField = (obj, key, value) => {
             if (lens.direction == "u") {
               optionContent.setAttribute("data-color", lens.color);
             } else {
-              optionContent.setAttribute("data-color", JSON.stringify(lens.gradientColors));
+              optionContent.setAttribute(
+                "data-color",
+                JSON.stringify(lens.gradientColors)
+              );
             }
             optionContent.setAttribute("data-direction", lens.direction);
             optionContent.setAttribute("data-opacity", `${lens.opacity}`);
@@ -37131,17 +37656,25 @@ var __publicField = (obj, key, value) => {
             selectedOption.style.background = "#f2f2f2";
             if (lensMaterial) {
               if (selectedOption.getAttribute("data-direction") == "u") {
-                lensMaterial.color = new Color(selectedOption.getAttribute("data-color"));
-                lensMaterial.opacity = selectedOption.getAttribute("data-opacity");
+                lensMaterial.color = new Color(
+                  selectedOption.getAttribute("data-color")
+                );
+                lensMaterial.opacity = selectedOption.getAttribute(
+                  "data-opacity"
+                );
                 gu.uAlpha.value = false;
                 const image = document.getElementById("LensdropdownImgD");
                 image.style.background = selectedOption.getAttribute("data-color");
               } else if (selectedOption.getAttribute("data-direction") == "tb") {
-                const gradientColors = JSON.parse(selectedOption.getAttribute("data-color"));
+                const gradientColors = JSON.parse(
+                  selectedOption.getAttribute("data-color")
+                );
                 gu.uAlpha.value = true;
                 let index = 0;
                 gradientColors.forEach(() => {
-                  gu.colors.value[index] = new Color(gradientColors[index].color);
+                  gu.colors.value[index] = new Color(
+                    gradientColors[index].color
+                  );
                   gu.positions.value[index] = gradientColors[index].position;
                   gu.opacities.value[index] = gradientColors[index].alpha;
                   index++;
@@ -37157,8 +37690,12 @@ var __publicField = (obj, key, value) => {
                 lensMaterial.clearcoat = 1;
                 lensMaterial.clearcoatRoughness = 0;
               }
-              lensMaterial.roughness = selectedOption.getAttribute("data-roughness");
-              lensMaterial.metalness = selectedOption.getAttribute("data-metalness");
+              lensMaterial.roughness = selectedOption.getAttribute(
+                "data-roughness"
+              );
+              lensMaterial.metalness = selectedOption.getAttribute(
+                "data-metalness"
+              );
               const name = document.getElementById("LensdropdownNameD");
               name.textContent = selectedOption.getAttribute("data-name");
               const desc = document.getElementById("LensdropdownSkuD");
@@ -37180,7 +37717,6 @@ var __publicField = (obj, key, value) => {
     }
     async setupLensDefault(response) {
       if (lensMaterial) {
-        console.log("leen", response);
         lensMaterial.color = new Color(response.customisation[0].color);
         lensMaterial.opacity = response.customisation[0].opacity;
         lensMaterial.metalness = response.customisation[0].metalness;
@@ -37199,6 +37735,7 @@ var __publicField = (obj, key, value) => {
     }
     setupLensMaterial(selectedLens) {
       if (lensMaterial) {
+        console.log(selectedLens);
         if (selectedLens.direction == "u") {
           lensMaterial.color = new Color(selectedLens.color);
           lensMaterial.opacity = selectedLens.opacity;
@@ -37228,137 +37765,18 @@ var __publicField = (obj, key, value) => {
         lensMaterial.metalness = selectedLens.metalness;
       }
     }
-    // createGuiControls(selectedLens: any, name: any) {
-    //   guiContainer!.innerHTML = '';
-    //   gui.destroy();
-    //   gui = new GUI({ autoPlace: false });
-    //   const datGuiContainer = document.createElement('div');
-    //   guiContainer!.appendChild(datGuiContainer);
-    //   datGuiContainer.appendChild(gui.domElement);
-    //   const opacityControl = gui
-    //     .add(selectedLens, 'opacity', 0, 1)
-    //     .name('Opacity');
-    //   opacityControl.onChange((opacity) => {
-    //     if (lensMaterial) {
-    //       lensMaterial.opacity = opacity;
-    //     }
-    //   });
-    //   const colorControl = gui.addColor(selectedLens, 'color').name(name);
-    //   colorControl.onChange((color) => {
-    //     if (lensMaterial) {
-    //       lensMaterial.color.set(color);
-    //     }
-    //   });
-    // }
-    // createGuiControlsGrad(selectedLens: any, name: any) {
-    //   guiContainer!.innerHTML = '';
-    //   gui.destroy();
-    //   gui = new GUI({ autoPlace: false });
-    //   const datGuiContainer = document.createElement('div');
-    //   guiContainer!.appendChild(datGuiContainer);
-    //   datGuiContainer.appendChild(gui.domElement);
-    //   const positionControl1 = gui
-    //     .add(selectedLens[0], 'position', 0, 1)
-    //     .name('position');
-    //   const positionControl2 = gui
-    //     .add(selectedLens[1], 'position', 0, 1)
-    //     .name('position');
-    //   const positionControl3 = gui
-    //     .add(selectedLens[2], 'position', 0, 1)
-    //     .name('position');
-    //   const positionControl4 = gui
-    //     .add(selectedLens[3], 'position', 0, 1)
-    //     .name('position');
-    //   positionControl1.onChange((position) => {
-    //     if (lensMaterial) {
-    //       gu.positions.value[0] = position;
-    //     }
-    //   });
-    //   positionControl2.onChange((position) => {
-    //     if (lensMaterial) {
-    //       gu.positions.value[1] = position;
-    //     }
-    //   });
-    //   positionControl3.onChange((position) => {
-    //     if (lensMaterial) {
-    //       gu.positions.value[2] = position;
-    //     }
-    //   });
-    //   positionControl4.onChange((position) => {
-    //     if (lensMaterial) {
-    //       gu.positions.value[3] = position;
-    //     }
-    //   });
-    //   const opacityControl1 = gui
-    //     .add(selectedLens[0], 'opacity', 0, 1)
-    //     .name('Opacity');
-    //   const opacityControl2 = gui
-    //     .add(selectedLens[1], 'opacity', 0, 1)
-    //     .name('Opacity');
-    //   const opacityControl3 = gui
-    //     .add(selectedLens[2], 'opacity', 0, 1)
-    //     .name('Opacity');
-    //   const opacityControl4 = gui
-    //     .add(selectedLens[3], 'opacity', 0, 1)
-    //     .name('Opacity');
-    //   opacityControl1.onChange((opacity) => {
-    //     if (lensMaterial) {
-    //       gu.opacities.value[0] = opacity;
-    //     }
-    //   });
-    //   opacityControl2.onChange((opacity) => {
-    //     if (lensMaterial) {
-    //       gu.opacities.value[1] = opacity;
-    //     }
-    //   });
-    //   opacityControl3.onChange((opacity) => {
-    //     if (lensMaterial) {
-    //       gu.opacities.value[2] = opacity;
-    //     }
-    //   });
-    //   opacityControl4.onChange((opacity) => {
-    //     if (lensMaterial) {
-    //       gu.opacities.value[3] = opacity;
-    //     }
-    //   });
-    //   const colorControl1 = gui.addColor(selectedLens[0], 'color').name(name);
-    //   const colorControl2 = gui.addColor(selectedLens[1], 'color').name(name);
-    //   const colorControl3 = gui.addColor(selectedLens[2], 'color').name(name);
-    //   const colorControl4 = gui.addColor(selectedLens[3], 'color').name(name);
-    //   colorControl1.onChange((color) => {
-    //     if (lensMaterial) {
-    //       gu.colors.value[0] = new THREE.Color(color);
-    //     }
-    //   });
-    //   colorControl2.onChange((color) => {
-    //     if (lensMaterial) {
-    //       gu.colors.value[1] = new THREE.Color(color);
-    //     }
-    //   });
-    //   colorControl3.onChange((color) => {
-    //     if (lensMaterial) {
-    //       gu.colors.value[2] = new THREE.Color(color);
-    //     }
-    //   });
-    //   colorControl4.onChange((color) => {
-    //     if (lensMaterial) {
-    //       gu.colors.value[3] = new THREE.Color(color);
-    //     }
-    //   });
-    // }
-    setupAndRenderScene(model) {
-      this.scene.remove(this.scene.children[0], this.scene.children[2]);
-      const Modelscene = model;
+    setupAndRenderScene() {
       const rgbeLoader = new RGBELoader();
       rgbeLoader.load(
         "https://sprie-jarvis-public.s3.eu-west-2.amazonaws.com/royal_esplanade_1k_desaturated.hdr",
         (environmentMap) => {
-          const env = environmentMap;
-          env.mapping = EquirectangularReflectionMapping;
-          this.scene.environment = env;
+          const pmremGenerator = new PMREMGenerator(this.renderer);
+          pmremGenerator.compileCubemapShader();
+          const hdrCubeRenderTarget = pmremGenerator.fromEquirectangular(environmentMap).texture;
+          this.scene.environment = hdrCubeRenderTarget;
+          pmremGenerator.dispose();
         }
       );
-      this.scene.add(Modelscene);
       if (!this.camera || !this.renderer)
         return;
       this.scene.add(this.camera);
@@ -37373,8 +37791,8 @@ var __publicField = (obj, key, value) => {
         2.2,
         4
       );
-      controls.minDistance = 3;
-      controls.maxDistance = 9;
+      controls.minDistance = 2;
+      controls.maxDistance = 7;
       controls.enableDamping = true;
       controls.dampingFactor = 0.2;
       controls.enablePan = true;
@@ -37474,6 +37892,14 @@ var __publicField = (obj, key, value) => {
       function updateShadowCamera() {
         shadowCamera.updateProjectionMatrix();
       }
+      const outputPass = new OutputPass();
+      const size = this.renderer.getDrawingBufferSize(new Vector2());
+      const renderTarget2 = new WebGLRenderTarget(size.width, size.height, { samples: 4, type: HalfFloatType });
+      const renderPass = new RenderPass(this.scene, this.camera);
+      renderPass.clearAlpha = 0;
+      let composer = new EffectComposer(this.renderer, renderTarget2);
+      composer.addPass(renderPass);
+      composer.addPass(outputPass);
       const animate = () => {
         controls.update();
         const initialBackground = this.scene.background;
@@ -37483,18 +37909,35 @@ var __publicField = (obj, key, value) => {
           return;
         const initialClearAlpha = this.renderer.getClearAlpha();
         this.renderer.setClearAlpha(0);
+        this.renderer.clear();
         this.renderer.setRenderTarget(renderTarget);
         this.renderer.render(this.scene, shadowCamera);
         this.scene.overrideMaterial = null;
         blurShadow(state.shadow.blur, this.renderer);
+        blurShadow(state.shadow.blur * 0.4, this.renderer);
         this.renderer.setRenderTarget(null);
         this.renderer.setClearAlpha(initialClearAlpha);
         this.scene.background = initialBackground;
-        this.renderer.render(this.scene, this.camera);
         requestAnimationFrame(animate);
+        composer.render();
       };
       animate();
     }
+    loadModelInsideScene(model) {
+      this.scene.traverse((node) => {
+        if (node.name == "Scene") {
+          this.scene.remove(node);
+          node.traverse((child) => {
+            if (child instanceof Mesh) {
+              child.geometry.dispose();
+              child.material.dispose();
+            }
+          });
+        }
+      });
+      const Modelscene = model;
+      this.scene.add(Modelscene);
+    }
   }
   const { warn } = console;
   class SDKServiceFactory {
@@ -38462,6 +38905,7 @@ var __publicField = (obj, key, value) => {
   }) {
     customRenderer = new CustomRenderer(apiService);
     customRenderer.intialize();
+    customRenderer.setupAndRenderScene();
     setLoading(true);
     const frame = frameList[0];
     const apiRes = await apiService.DownloadMA({
@@ -38547,16 +38991,20 @@ var __publicField = (obj, key, value) => {
             });
           }
         } else if (hasSpecialDefaultLens && lens.sku != "lens-default") {
-          setModelLoading(true);
-          if (currentFrame) {
-            const apiRes = await apiService.DownloadMA({
-              orgId,
-              assetsId: currentFrame._id
-            });
-            customRenderer.renderModel(apiRes.asset.cloudfrontUrl, renderAsIs, apiRes.decryptionKey).then(() => {
-              setModelLoading(false);
-              customRenderer.setupLensMaterial(lens);
-            });
+          if ((selectedLens == null ? void 0 : selectedLens.sku) == "lens-default") {
+            setModelLoading(true);
+            if (currentFrame) {
+              const apiRes = await apiService.DownloadMA({
+                orgId,
+                assetsId: currentFrame._id
+              });
+              customRenderer.renderModel(apiRes.asset.cloudfrontUrl, renderAsIs, apiRes.decryptionKey).then(() => {
+                setModelLoading(false);
+                customRenderer.setupLensMaterial(lens);
+              });
+            }
+          } else {
+            customRenderer.setupLensMaterial(lens);
           }
         } else if (!hasSpecialDefaultLens && lens.sku == "lens-default") {
           customRenderer.setupLensMaterial(includedLens);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perceptimagery/dita-configurator-staging",
-  "version": "0.1.6200",
+  "version": "0.1.6300",
   "author": "Abhishek Deb <abhishek@perceptimagery.com>",
   "license": "UNLICENSED",
   "main": "dist/index.js",