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

package/dist/bumpVertex.esm.js

@@ -0,0 +1,497 @@
+import { E as Engine, e as ShaderStore } from './engine.esm.js';
+
+/**
+ * This groups all the flags used to control the materials channel.
+ */
+class MaterialFlags {
+    /**
+     * Are diffuse textures enabled in the application.
+     */
+    static get DiffuseTextureEnabled() {
+        return this._DiffuseTextureEnabled;
+    }
+    static set DiffuseTextureEnabled(value) {
+        if (this._DiffuseTextureEnabled === value) {
+            return;
+        }
+        this._DiffuseTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are detail textures enabled in the application.
+     */
+    static get DetailTextureEnabled() {
+        return this._DetailTextureEnabled;
+    }
+    static set DetailTextureEnabled(value) {
+        if (this._DetailTextureEnabled === value) {
+            return;
+        }
+        this._DetailTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are decal maps enabled in the application.
+     */
+    static get DecalMapEnabled() {
+        return this._DecalMapEnabled;
+    }
+    static set DecalMapEnabled(value) {
+        if (this._DecalMapEnabled === value) {
+            return;
+        }
+        this._DecalMapEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are ambient textures enabled in the application.
+     */
+    static get AmbientTextureEnabled() {
+        return this._AmbientTextureEnabled;
+    }
+    static set AmbientTextureEnabled(value) {
+        if (this._AmbientTextureEnabled === value) {
+            return;
+        }
+        this._AmbientTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are opacity textures enabled in the application.
+     */
+    static get OpacityTextureEnabled() {
+        return this._OpacityTextureEnabled;
+    }
+    static set OpacityTextureEnabled(value) {
+        if (this._OpacityTextureEnabled === value) {
+            return;
+        }
+        this._OpacityTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are reflection textures enabled in the application.
+     */
+    static get ReflectionTextureEnabled() {
+        return this._ReflectionTextureEnabled;
+    }
+    static set ReflectionTextureEnabled(value) {
+        if (this._ReflectionTextureEnabled === value) {
+            return;
+        }
+        this._ReflectionTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are emissive textures enabled in the application.
+     */
+    static get EmissiveTextureEnabled() {
+        return this._EmissiveTextureEnabled;
+    }
+    static set EmissiveTextureEnabled(value) {
+        if (this._EmissiveTextureEnabled === value) {
+            return;
+        }
+        this._EmissiveTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are specular textures enabled in the application.
+     */
+    static get SpecularTextureEnabled() {
+        return this._SpecularTextureEnabled;
+    }
+    static set SpecularTextureEnabled(value) {
+        if (this._SpecularTextureEnabled === value) {
+            return;
+        }
+        this._SpecularTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are bump textures enabled in the application.
+     */
+    static get BumpTextureEnabled() {
+        return this._BumpTextureEnabled;
+    }
+    static set BumpTextureEnabled(value) {
+        if (this._BumpTextureEnabled === value) {
+            return;
+        }
+        this._BumpTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are lightmap textures enabled in the application.
+     */
+    static get LightmapTextureEnabled() {
+        return this._LightmapTextureEnabled;
+    }
+    static set LightmapTextureEnabled(value) {
+        if (this._LightmapTextureEnabled === value) {
+            return;
+        }
+        this._LightmapTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are refraction textures enabled in the application.
+     */
+    static get RefractionTextureEnabled() {
+        return this._RefractionTextureEnabled;
+    }
+    static set RefractionTextureEnabled(value) {
+        if (this._RefractionTextureEnabled === value) {
+            return;
+        }
+        this._RefractionTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are color grading textures enabled in the application.
+     */
+    static get ColorGradingTextureEnabled() {
+        return this._ColorGradingTextureEnabled;
+    }
+    static set ColorGradingTextureEnabled(value) {
+        if (this._ColorGradingTextureEnabled === value) {
+            return;
+        }
+        this._ColorGradingTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are fresnels enabled in the application.
+     */
+    static get FresnelEnabled() {
+        return this._FresnelEnabled;
+    }
+    static set FresnelEnabled(value) {
+        if (this._FresnelEnabled === value) {
+            return;
+        }
+        this._FresnelEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(4);
+    }
+    /**
+     * Are clear coat textures enabled in the application.
+     */
+    static get ClearCoatTextureEnabled() {
+        return this._ClearCoatTextureEnabled;
+    }
+    static set ClearCoatTextureEnabled(value) {
+        if (this._ClearCoatTextureEnabled === value) {
+            return;
+        }
+        this._ClearCoatTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are clear coat bump textures enabled in the application.
+     */
+    static get ClearCoatBumpTextureEnabled() {
+        return this._ClearCoatBumpTextureEnabled;
+    }
+    static set ClearCoatBumpTextureEnabled(value) {
+        if (this._ClearCoatBumpTextureEnabled === value) {
+            return;
+        }
+        this._ClearCoatBumpTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are clear coat tint textures enabled in the application.
+     */
+    static get ClearCoatTintTextureEnabled() {
+        return this._ClearCoatTintTextureEnabled;
+    }
+    static set ClearCoatTintTextureEnabled(value) {
+        if (this._ClearCoatTintTextureEnabled === value) {
+            return;
+        }
+        this._ClearCoatTintTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are sheen textures enabled in the application.
+     */
+    static get SheenTextureEnabled() {
+        return this._SheenTextureEnabled;
+    }
+    static set SheenTextureEnabled(value) {
+        if (this._SheenTextureEnabled === value) {
+            return;
+        }
+        this._SheenTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are anisotropic textures enabled in the application.
+     */
+    static get AnisotropicTextureEnabled() {
+        return this._AnisotropicTextureEnabled;
+    }
+    static set AnisotropicTextureEnabled(value) {
+        if (this._AnisotropicTextureEnabled === value) {
+            return;
+        }
+        this._AnisotropicTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are thickness textures enabled in the application.
+     */
+    static get ThicknessTextureEnabled() {
+        return this._ThicknessTextureEnabled;
+    }
+    static set ThicknessTextureEnabled(value) {
+        if (this._ThicknessTextureEnabled === value) {
+            return;
+        }
+        this._ThicknessTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are refraction intensity textures enabled in the application.
+     */
+    static get RefractionIntensityTextureEnabled() {
+        return this._ThicknessTextureEnabled;
+    }
+    static set RefractionIntensityTextureEnabled(value) {
+        if (this._RefractionIntensityTextureEnabled === value) {
+            return;
+        }
+        this._RefractionIntensityTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are translucency intensity textures enabled in the application.
+     */
+    static get TranslucencyIntensityTextureEnabled() {
+        return this._ThicknessTextureEnabled;
+    }
+    static set TranslucencyIntensityTextureEnabled(value) {
+        if (this._TranslucencyIntensityTextureEnabled === value) {
+            return;
+        }
+        this._TranslucencyIntensityTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+    /**
+     * Are translucency intensity textures enabled in the application.
+     */
+    static get IridescenceTextureEnabled() {
+        return this._IridescenceTextureEnabled;
+    }
+    static set IridescenceTextureEnabled(value) {
+        if (this._IridescenceTextureEnabled === value) {
+            return;
+        }
+        this._IridescenceTextureEnabled = value;
+        Engine.MarkAllMaterialsAsDirty(1);
+    }
+}
+// Flags used to enable or disable a type of texture for all Standard Materials
+MaterialFlags._DiffuseTextureEnabled = true;
+MaterialFlags._DetailTextureEnabled = true;
+MaterialFlags._DecalMapEnabled = true;
+MaterialFlags._AmbientTextureEnabled = true;
+MaterialFlags._OpacityTextureEnabled = true;
+MaterialFlags._ReflectionTextureEnabled = true;
+MaterialFlags._EmissiveTextureEnabled = true;
+MaterialFlags._SpecularTextureEnabled = true;
+MaterialFlags._BumpTextureEnabled = true;
+MaterialFlags._LightmapTextureEnabled = true;
+MaterialFlags._RefractionTextureEnabled = true;
+MaterialFlags._ColorGradingTextureEnabled = true;
+MaterialFlags._FresnelEnabled = true;
+MaterialFlags._ClearCoatTextureEnabled = true;
+MaterialFlags._ClearCoatBumpTextureEnabled = true;
+MaterialFlags._ClearCoatTintTextureEnabled = true;
+MaterialFlags._SheenTextureEnabled = true;
+MaterialFlags._AnisotropicTextureEnabled = true;
+MaterialFlags._ThicknessTextureEnabled = true;
+MaterialFlags._RefractionIntensityTextureEnabled = true;
+MaterialFlags._TranslucencyIntensityTextureEnabled = true;
+MaterialFlags._IridescenceTextureEnabled = true;
+
+// Do not edit.
+const name$7 = "sceneUboDeclaration";
+const shader$7 = `layout(std140,column_major) uniform;
+mat4 viewProjectionR;
+mat4 view;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$7] = shader$7;
+
+// Do not edit.
+const name$6 = "samplerFragmentDeclaration";
+const shader$6 = `#ifdef _DEFINENAME_
+#if _DEFINENAME_DIRECTUV==1
+#define v_VARYINGNAME_UV vMainUV1
+#elif _DEFINENAME_DIRECTUV==2
+#define v_VARYINGNAME_UV vMainUV2
+#elif _DEFINENAME_DIRECTUV==3
+#define v_VARYINGNAME_UV vMainUV3
+#elif _DEFINENAME_DIRECTUV==4
+#define v_VARYINGNAME_UV vMainUV4
+#elif _DEFINENAME_DIRECTUV==5
+#define v_VARYINGNAME_UV vMainUV5
+#elif _DEFINENAME_DIRECTUV==6
+#define v_VARYINGNAME_UV vMainUV6
+#else
+varying vec2 v_VARYINGNAME_UV;
+uniform sampler2D _SAMPLERNAME_Sampler;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$6] = shader$6;
+
+// Do not edit.
+const name$5 = "imageProcessingDeclaration";
+const shader$5 = `#ifdef EXPOSURE
+uniform float exposureLinear;
+#ifdef CONTRAST
+uniform float contrast;
+#if defined(VIGNETTE) || defined(DITHER)
+uniform vec2 vInverseScreenSize;
+#ifdef VIGNETTE
+uniform vec4 vignetteSettings1;
+#ifdef COLORCURVES
+uniform vec4 vCameraColorCurveNegative;
+#ifdef COLORGRADING
+#ifdef COLORGRADING3D
+uniform highp sampler3D txColorTransform;
+uniform sampler2D txColorTransform;
+uniform vec4 colorTransformSettings;
+#ifdef DITHER
+uniform float ditherIntensity;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$5] = shader$5;
+
+// Do not edit.
+const name$4 = "imageProcessingFunctions";
+const shader$4 = `#if defined(COLORGRADING) && !defined(COLORGRADING3D)
+/** 
+vec3 sampleTexture3D(sampler2D colorTransform,vec3 color,vec2 sampler3dSetting)
+float sliceContinuous=(color.g-sampler3dSetting.x)*sampler3dSetting.y;
+float sliceContinuous=(color.b-sampler3dSetting.x)*sampler3dSetting.y;
+float sliceInteger=floor(sliceContinuous);
+vec2 sliceUV=color.rb;
+vec2 sliceUV=color.rg;
+sliceUV.x*=sliceSize;
+color.rgb=result.rgb;
+color.rgb=result.bgr;
+return color;
+#ifdef TONEMAPPING_ACES
+const mat3 ACESInputMat=mat3(
+#define CUSTOM_IMAGEPROCESSINGFUNCTIONS_DEFINITIONS
+vec4 applyImageProcessing(vec4 result) {
+#ifdef EXPOSURE
+result.rgb*=exposureLinear;
+#ifdef VIGNETTE
+vec2 viewportXY=gl_FragCoord.xy*vInverseScreenSize;
+vec3 vignetteColorMultiplier=mix(vignetteColor,vec3(1,1,1),vignette);
+#ifdef VIGNETTEBLENDMODEOPAQUE
+result.rgb=mix(vignetteColor,result.rgb,vignette);
+#endif
+#ifdef TONEMAPPING
+#ifdef TONEMAPPING_ACES
+result.rgb=ACESFitted(result.rgb);
+const float tonemappingCalibration=1.590579;
+#endif
+result.rgb=toGammaSpace(result.rgb);
+vec3 resultHighContrast=result.rgb*result.rgb*(3.0-2.0*result.rgb);
+#ifdef COLORGRADING
+vec3 colorTransformInput=result.rgb*colorTransformSettings.xxx+colorTransformSettings.yyy;
+vec3 colorTransformOutput=texture(txColorTransform,colorTransformInput).rgb;
+vec3 colorTransformOutput=sampleTexture3D(txColorTransform,colorTransformInput,colorTransformSettings.yz).rgb;
+result.rgb=mix(result.rgb,colorTransformOutput,colorTransformSettings.www);
+#ifdef COLORCURVES
+float luma=getLuminance(result.rgb);
+#ifdef DITHER
+float rand=getRand(gl_FragCoord.xy*vInverseScreenSize);
+#define CUSTOM_IMAGEPROCESSINGFUNCTIONS_UPDATERESULT_ATEND
+return result;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$4] = shader$4;
+
+// Do not edit.
+const name$3 = "bumpFragmentMainFunctions";
+const shader$3 = `#if defined(BUMP) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(DETAIL)
+#if defined(TANGENT) && defined(NORMAL) 
+varying mat3 vTBN;
+#ifdef OBJECTSPACE_NORMALMAP
+uniform mat4 normalMatrix;
+mat4 toNormalMatrix(mat4 wMatrix)
+mat4 toNormalMatrix(mat4 m)
+#endif
+vec3 perturbNormalBase(mat3 cotangentFrame,vec3 normal,float scale)
+normal=normalize(normal*vec3(scale,scale,1.0));
+return normalize(cotangentFrame*normal);
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$3] = shader$3;
+
+// Do not edit.
+const name$2 = "bumpFragmentFunctions";
+const shader$2 = `#if defined(BUMP)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_SAMPLERNAME_,bump)
+#endif
+#if defined(DETAIL)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_SAMPLERNAME_,detail)
+#endif
+#if defined(BUMP) && defined(PARALLAX)
+const float minSamples=4.;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$2] = shader$2;
+
+// Do not edit.
+const name$1 = "bumpFragment";
+const shader$1 = `vec2 uvOffset=vec2(0.0,0.0);
+#ifdef NORMALXYSCALE
+float normalScale=1.0;
+float normalScale=vBumpInfos.y;
+float normalScale=1.0;
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBN=vTBN;
+vec2 TBNUV=gl_FrontFacing ? vBumpUV : -vBumpUV;
+vec2 TBNUV=gl_FrontFacing ? vDetailUV : -vDetailUV;
+#elif defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBN=vTBN;
+vec2 TBNUV=gl_FrontFacing ? vMainUV1 : -vMainUV1;
+#endif
+#ifdef PARALLAX
+mat3 invTBN=transposeMat3(TBN);
+uvOffset=parallaxOcclusion(invTBN*-viewDirectionW,invTBN*normalW,vBumpUV,vBumpInfos.z);
+uvOffset=parallaxOffset(invTBN*viewDirectionW,vBumpInfos.z);
+#endif
+#ifdef DETAIL
+vec4 detailColor=texture2D(detailSampler,vDetailUV+uvOffset);
+#ifdef BUMP
+#ifdef OBJECTSPACE_NORMALMAP
+#define CUSTOM_FRAGMENT_BUMP_FRAGMENT
+normalW=normalize(texture2D(bumpSampler,vBumpUV).xyz *2.0-1.0);
+normalW=perturbNormal(TBN,texture2D(bumpSampler,vBumpUV+uvOffset).xyz,vBumpInfos.y);
+vec3 bumpNormal=texture2D(bumpSampler,vBumpUV+uvOffset).xyz*2.0-1.0;
+detailNormal.xy*=vDetailInfos.z;
+detailNormal.xy*=vDetailInfos.z;
+normalW=perturbNormalBase(TBN,blendedNormal,vBumpInfos.y);
+#elif defined(DETAIL)
+detailNormal.xy*=vDetailInfos.z;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$1] = shader$1;
+
+// Do not edit.
+const name = "bumpVertex";
+const shader = `#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+vec3 tbnNormal=normalize(normalUpdated);
+#endif
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name] = shader;
+
+export { MaterialFlags as M };

package/dist/compatibilityOptions.esm.js

@@ -0,0 +1,68 @@
+/**
+ * Class used to represent a viewport on screen
+ */
+class Viewport {
+    /**
+     * Creates a Viewport object located at (x, y) and sized (width, height)
+     * @param x defines viewport left coordinate
+     * @param y defines viewport top coordinate
+     * @param width defines the viewport width
+     * @param height defines the viewport height
+     */
+    constructor(
+    /** viewport left coordinate */
+    x, 
+    /** viewport top coordinate */
+    y, 
+    /**viewport width */
+    width, 
+    /** viewport height */
+    height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+    /**
+     * Creates a new viewport using absolute sizing (from 0-> width, 0-> height instead of 0->1)
+     * @param renderWidth defines the rendering width
+     * @param renderHeight defines the rendering height
+     * @returns a new Viewport
+     */
+    toGlobal(renderWidth, renderHeight) {
+        return new Viewport(this.x * renderWidth, this.y * renderHeight, this.width * renderWidth, this.height * renderHeight);
+    }
+    /**
+     * Stores absolute viewport value into a target viewport (from 0-> width, 0-> height instead of 0->1)
+     * @param renderWidth defines the rendering width
+     * @param renderHeight defines the rendering height
+     * @param ref defines the target viewport
+     * @returns the current viewport
+     */
+    toGlobalToRef(renderWidth, renderHeight, ref) {
+        ref.x = this.x * renderWidth;
+        ref.y = this.y * renderHeight;
+        ref.width = this.width * renderWidth;
+        ref.height = this.height * renderHeight;
+        return this;
+    }
+    /**
+     * Returns a new Viewport copied from the current one
+     * @returns a new Viewport
+     */
+    clone() {
+        return new Viewport(this.x, this.y, this.width, this.height);
+    }
+}
+
+/**
+ * Options used to control default behaviors regarding compatibility support
+ */
+class CompatibilityOptions {
+}
+/**
+ * Defines if the system should use OpenGL convention for UVs when creating geometry or loading .babylon files (false by default)
+ */
+CompatibilityOptions.UseOpenGLOrientationForUV = false;
+
+export { CompatibilityOptions as C, Viewport as V };

package/dist/configuration.esm.js

@@ -0,0 +1,121 @@
+import { C as Color4, a as Color3 } from './math.color.esm.js';
+
+/**
+ * Configuration for the preview. Optionally, you can provide a custom configuration. (from a workflow for example) Sensible
+ * defaults will be specified for all properties otherwise.
+ */
+class Configuration {
+    constructor(options) {
+        /**
+         * Will return clear color based on custom configuration or a sensible default.
+         * @returns A Color4 object for use as a clear color.
+         */
+        this.getSceneClearColor = () => {
+            var _a, _b, _c, _d;
+            // It looks like the browser combines RGB values with background elements regardless of the alpha value.
+            // To counteract this we set RGB to black in the case of transparency.
+            const alpha = ((_a = this.customOptions) === null || _a === void 0 ? void 0 : _a.transparentBackground) ||
+                ((_b = this.customOptions) === null || _b === void 0 ? void 0 : _b.backgroundImage)
+                ? 0
+                : 1;
+            if ((this.customOptions && ((_c = this.customOptions) === null || _c === void 0 ? void 0 : _c.transparentBackground)) ||
+                ((_d = this.customOptions) === null || _d === void 0 ? void 0 : _d.backgroundImage)) {
+                return new Color4(0, 0, 0, alpha).toLinearSpace();
+            }
+            if (this.customOptions && this.customOptions.backgroundColor) {
+                const parsedColor = Color3.FromHexString(this.customOptions.backgroundColor);
+                return new Color4(parsedColor.r, parsedColor.g, parsedColor.b, alpha).toLinearSpace();
+            }
+            return new Color4(0.98, 0.98, 0.98, alpha).toLinearSpace();
+        };
+        this.highlightColorFromConfig = () => {
+            if (this.customOptions && this.customOptions.highlightColor) {
+                return this.hexToColor4(this.customOptions.highlightColor);
+            }
+            return new Color4(0.98, 0.98, 0.98, 1).toLinearSpace();
+        };
+        this.hexToColor4 = (hex, alpha = 1) => {
+            const parsedColor = Color3.FromHexString(hex);
+            return new Color4(parsedColor.r, parsedColor.g, parsedColor.b, alpha).toLinearSpace();
+        };
+        this.customOptions = options;
+    }
+    createCanvas() {
+        if (this.customOptions.createCanvas) {
+            return this.customOptions.createCanvas();
+        }
+        return document.createElement('canvas');
+    }
+    get options() {
+        return this.customOptions;
+    }
+    /**
+     * Configuration related to the scene
+     */
+    get scene() {
+        var _a, _b, _c, _d;
+        return {
+            clearColor: this.getSceneClearColor(),
+            transparentBackground: ((_a = this.customOptions) === null || _a === void 0 ? void 0 : _a.transparentBackground) ||
+                ((_b = this.customOptions) === null || _b === void 0 ? void 0 : _b.backgroundImage),
+            environmentFile: (_d = (_c = this.customOptions) === null || _c === void 0 ? void 0 : _c.environmentFile) !== null && _d !== void 0 ? _d : 'assets/model-viewer/default.env',
+        };
+    }
+    /**
+     * Configuration related to the camera used to view and interact with the scene.
+     */
+    get camera() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        return {
+            autoOrientation: (_b = (_a = this.customOptions) === null || _a === void 0 ? void 0 : _a.disableAutomaticOrientation) !== null && _b !== void 0 ? _b : true,
+            autoRotation: {
+                enabled: (_d = (_c = this.customOptions) === null || _c === void 0 ? void 0 : _c.autoRotation) !== null && _d !== void 0 ? _d : false,
+                idleTimeMs: (_f = (_e = this.customOptions) === null || _e === void 0 ? void 0 : _e.idleTimeBeforeRotation) !== null && _f !== void 0 ? _f : 5000,
+            },
+            limits: {
+                min: {
+                    alpha: ((_g = this.customOptions) === null || _g === void 0 ? void 0 : _g.lowerAlphaLimitDeg)
+                        ? (((_h = this.customOptions) === null || _h === void 0 ? void 0 : _h.lowerAlphaLimitDeg) * Math.PI) / 180
+                        : undefined,
+                    beta: ((_j = this.customOptions) === null || _j === void 0 ? void 0 : _j.lowerBetaLimitDeg)
+                        ? (((_k = this.customOptions) === null || _k === void 0 ? void 0 : _k.lowerBetaLimitDeg) * Math.PI) / 180
+                        : undefined,
+                    radius: (_l = this.customOptions) === null || _l === void 0 ? void 0 : _l.minZoomOverride,
+                },
+                max: {
+                    alpha: ((_m = this.customOptions) === null || _m === void 0 ? void 0 : _m.upperAlphaLimitDeg)
+                        ? (((_o = this.customOptions) === null || _o === void 0 ? void 0 : _o.upperAlphaLimitDeg) * Math.PI) / 180
+                        : undefined,
+                    beta: ((_p = this.customOptions) === null || _p === void 0 ? void 0 : _p.upperBetaLimitDeg)
+                        ? (((_q = this.customOptions) === null || _q === void 0 ? void 0 : _q.upperBetaLimitDeg) * Math.PI) / 180
+                        : undefined,
+                    radius: (_r = this.customOptions) === null || _r === void 0 ? void 0 : _r.maxZoomOverride,
+                },
+            },
+        };
+    }
+    /**
+     * Configuration related to the highlighting system. Highlights are used to add
+     * a visual cue to the user that something is moused over in the preview.
+     */
+    get highlights() {
+        var _a, _b;
+        return {
+            enabled: (_b = (_a = this.customOptions) === null || _a === void 0 ? void 0 : _a.highlightOnMaterialHover) !== null && _b !== void 0 ? _b : false,
+            color: this.highlightColorFromConfig(),
+        };
+    }
+    get lighting() {
+        var _a, _b, _c, _d, _e, _f;
+        return {
+            exposure: (_c = (_b = (_a = this.customOptions) === null || _a === void 0 ? void 0 : _a.lighting) === null || _b === void 0 ? void 0 : _b.exposure) !== null && _c !== void 0 ? _c : 0.9,
+            contrast: (_f = (_e = (_d = this.customOptions) === null || _d === void 0 ? void 0 : _d.lighting) === null || _e === void 0 ? void 0 : _e.contrast) !== null && _f !== void 0 ? _f : 1.6,
+        };
+    }
+    get emissiveGlowIntensity() {
+        var _a, _b;
+        return (_b = (_a = this.customOptions) === null || _a === void 0 ? void 0 : _a.emissiveGlowIntensity) !== null && _b !== void 0 ? _b : 0.5;
+    }
+}
+
+export { Configuration };