@combeenation/3d-viewer 12.4.1 → 13.0.0

package/dist/lib-cjs/api/util/globalTypes.d.ts

@@ -1,490 +0,0 @@
-/// <reference types="gsap" />
-declare type Viewer = import('../classes/viewer').Viewer;
-declare type Variant = import('../classes/variant').Variant;
-declare type VariantInstance = import('../classes/variantInstance').VariantInstance;
-declare type VariantParameterizable = import('../classes/variantParameterizable').VariantParameterizable;
-/**
- * Alias for {@link Element} which can be used to prevent name clashes with the web APIs
- * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
- */
-declare type VariantElement = import('../classes/element').Element;
-declare type DottedPath = import('../classes/dottedPath').DottedPath;
-declare type ViewerLight = import('../classes/viewerLight').ViewerLight;
-declare type SceneManager = import('../manager/sceneManager').SceneManager;
-declare type FuzzyMap<K, V> = import('../classes/fuzzyMap').FuzzyMap<K, V>;
-declare type Scene = import('@babylonjs/core/scene').Scene;
-declare type Vector3 = import('@babylonjs/core/Maths/math.vector').Vector3;
-declare type Color3 = import('@babylonjs/core/Maths/math.color').Color3;
-declare type Color4 = import('@babylonjs/core/Maths/math.color').Color4;
-declare type Material = import('@babylonjs/core/Materials/material').Material;
-declare type PBRMaterial = import('@babylonjs/core/Materials/PBR/pbrMaterial').PBRMaterial;
-declare type StandardMaterial = import('@babylonjs/core/Materials/standardMaterial').StandardMaterial;
-declare type BackgroundMaterial = import('@babylonjs/core/Materials/Background/backgroundMaterial').BackgroundMaterial;
-declare type NodeMaterial = import('@babylonjs/core/Materials/Node').NodeMaterial;
-declare type DynamicTexture = import('@babylonjs/core/Materials/Textures/dynamicTexture').DynamicTexture;
-declare type Mesh = import('@babylonjs/core/Meshes/mesh').Mesh;
-declare type AbstractMesh = import('@babylonjs/core/Meshes/abstractMesh').AbstractMesh;
-declare type InstancedMesh = import('@babylonjs/core/Meshes/instancedMesh').InstancedMesh;
-declare type TransformNode = import('@babylonjs/core/Meshes/transformNode').TransformNode;
-declare type Engine = import('@babylonjs/core/Engines/engine').Engine;
-/**
- * See Babylon JS docs for more information about available [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
- */
-declare type EngineOptions = import('@babylonjs/core/Engines/thinEngine').EngineOptions;
-declare type ArcRotateCamera = import('@babylonjs/core/Cameras/arcRotateCamera').ArcRotateCamera;
-declare type IScreenshotSize = import('@babylonjs/core/Misc/interfaces/screenshotSize').IScreenshotSize;
-declare type BabylonAnimation = import('@babylonjs/core/Animations/animation').Animation;
-declare type CubeTexture = import('@babylonjs/core/Materials/Textures/cubeTexture').CubeTexture;
-declare type MeshBuilder = typeof import('@babylonjs/core/Meshes/meshBuilder').MeshBuilder;
-declare type Texture = import('@babylonjs/core/Materials/Textures/texture').Texture;
-declare type HemisphericLight = import('@babylonjs/core/Lights/hemisphericLight').HemisphericLight;
-declare type DirectionalLight = import('@babylonjs/core/Lights/directionalLight').DirectionalLight;
-declare type IInspectorOptions = import('@babylonjs/core/Debug').IInspectorOptions;
-declare type IExportOptions = import('@babylonjs/serializers/glTF/2.0').IExportOptions;
-declare type EventEmitter = import('eventemitter3');
-declare type Undefinable<T> = T | undefined;
-declare type Nullable<T> = T | null;
-declare type PathDefinitions = {
-    include: string[];
-    exclude?: string[];
-};
-declare type TraceableDefinition = {
-    path: string;
-};
-declare type TraceableDefinitions = {
-    [name: string]: TraceableDefinition;
-};
-declare type PaintableDefinition = {
-    path: string;
-    textureOptions: {
-        width: number;
-        height: number;
-    } | number;
-};
-declare type PaintableDefinitions = {
-    [name: string]: PaintableDefinition;
-};
-declare type PaintableValue = {
-    src: string;
-    options?: PaintableOptions;
-};
-declare type PaintableOptions = {
-    uScale?: number;
-    uOffset?: number;
-    vScale?: number;
-    vOffset?: number;
-};
-declare type Asset = {
-    rootUrl: string;
-    fileName: string | undefined;
-};
-declare type ElementDefinitions = {
-    [name: string]: ElementDefinition | string[];
-};
-declare type ElementDefinition = {
-    paths: PathDefinitions;
-    traceables?: TraceableDefinitions;
-    paintables?: PaintableDefinitions;
-};
-declare type TransformationDefinition = {
-    scaling: Vector3;
-    position: Vector3;
-    rotation: Vector3;
-};
-declare type EnvironmentDefinition = {
-    environmentColor?: Color3;
-    environmentIntensity?: number;
-    environment?: string;
-    environmentBackground?: string;
-    environmentRotation?: number;
-    environmentUseDefault?: boolean;
-};
-declare type StructureJson = {
-    /**
-     * `scene` describes the visualisation of the babylon `scene` such as the incidence of light and camera position. If a
-     * string is given, the {@link Viewer} will resolve the URL or path and pass the parsed JSON to this property.
-     */
-    scene?: string | SceneJson;
-    /**
-     * `setup` is a kind of construction plan for the {@link Viewer}. You can pass a {@link SetupJson} or a string, which
-     * must represent a valid URL or path. If a string is given, the {@link Viewer} will resolve the URL or path and pass
-     * the parsed JSON to this property. The {@link SetupJson} is responsible for managing a list of
-     * {@link VariantInstanceDefinition}s. These definitions define the instances that should be instantiated during the
-     * bootstrapping process. Each instance has a name and a reference to it's {@link Variant}.
-     */
-    setup?: string | SetupJson;
-    file?: string;
-    glTF?: Asset | string;
-    parameterDeclaration?: ParameterDeclarations;
-    parameters?: ParameterBag;
-    elements?: ElementDefinitions;
-    lights?: LightDefinitions;
-    grounds?: GroundDefinitions;
-    /**
-     * `variants` is a declarative description of 3D-model variations in the configurator. Each variant itself is a
-     * {@link StructureJson} which must at least define a `name` in the key of the list and the properties `glTF` and
-     * `elements` in the value. FYI: Babylon.js's sandbox can show you the path of the 3D-model to properly define the
-     * `paths`.
-     *
-     * Example Code
-     * ```js
-     * variants: {
-     *     'My Pretty Variant' {
-     *         glTF: {
-     *             rootUrl: 'https:/my.awesome.domain/path/to/my/project/',
-     *             fileName: 'my_3d_model_file.glb',
-     *         },
-     *         elements: {
-     *             'My Little Element': {
-     *                 paths: {
-     *                     includes: ['__root__.MeshName']
-     *                 }
-     *             }
-     *         }
-     *     }
-     * }
-     * ```
-     * `MeshName` has to be identical to the path in the glb-file of the 3D-model.
-     */
-    variants?: {
-        [id: string]: StructureJson;
-    };
-};
-/**
- * Extends the `StructureJson` by removing the optional flag from some properties which surely exist in the auto
- * generated spec
- */
-declare type AutoSpecStructureJson = StructureJson & {
-    scene: AutoSpecSceneJson;
-    setup: SetupJson;
-    variants: {
-        [id: string]: StructureJson;
-    };
-};
-declare type SceneJson = {
-    parameterDeclaration?: ParameterDeclarations;
-    parameters?: ParameterBag;
-    meshPicking?: boolean;
-    engine?: {
-        antialiasing?: boolean;
-        options?: EngineOptions;
-        adaptToDeviceRatio?: boolean;
-        /**
-         * Possibility to limit the size of textures when getting loaded by the engine.
-         * Activating this feature potentially saves a lot of memory and can be used to avoid crashes when loading expensive
-         * models on weaker devices.
-         * In praxis this has been an issue with iPhones a lot, therefore it's possible to activate this feature for iPhones
-         * only as well.
-         */
-        limitTextureSize?: LimitTextureSizeConfig | false;
-        /**
-         * See this forum entry for description of parallel shader compilition effect:
-         * https://forum.babylonjs.com/t/scene-flickering-when-turning-off-light/48733.
-         * Parallel shading compilition generally improves the speed of material compilition and helps when switching
-         * materials while objects are moving (eg: animations).
-         * Deactivating parallel shading compilition is benefitial when switching lights and materials in static scenarios.
-         * It's activated by default due to compatibility reasons but can be overwritten with this flag.
-         */
-        useParallelShaderCompile?: boolean;
-    };
-    scene: SceneDefinition;
-    animations?: AnimationDefinitions;
-    placements?: PlacementDefinitions;
-    /**
-     * Information about [material cloning](pages/Release%20Notes/releases/4-3-0.html#material-cloning-on-mutation).
-     * Default value is `false`.
-     */
-    cloneMaterialsOnMutation?: boolean;
-};
-declare type LimitTextureSizeConfig = {
-    size: 512 | 1024;
-    devices: 'iPhone' | 'all';
-};
-/**
- * Extends the `SceneJson` by removing the optional flag from some properties which surely exist in the auto generated
- * spec
- */
-declare type AutoSpecSceneJson = SceneJson & {
-    engine: {
-        antialiasing: boolean;
-        options: EngineOptions;
-    };
-};
-declare type SceneDefinition = {
-    globals: SceneGlobals;
-    cameras?: CameraDefinitions;
-};
-declare type SceneGlobals = {
-    'shadows'?: {
-        enabled: boolean;
-        type: 'contact';
-        settings: [];
-        generator: [];
-        receiver: [];
-    };
-    /**
-     * `aa` or anti aliasing is not needed if hard edges are desired.\
-     * FYI: aa smooths edges and avoids stairs-effects.
-     */
-    'aa'?: 'fxaa';
-    'tone-mapping'?: boolean;
-    /**
-     * @bloom is widely known as glow. There you can define it’s size (Specifies the size of the bloom blur kernel,
-     * relative to the final output size) and threshold (The luminance threshold to find bright areas of the image to
-     * bloom).
-     * Further Information under [BloomEffect](https://doc.babylonjs.com/typedoc/classes/babylon.bloomeffect).
-     *
-     * @dof short for "depth-of-field" defines the focus in the view. Parameters in settings are listed in [Depth of Field and Other Lens Effects link](https://doc.babylonjs.com/divingDeeper/postProcesses/dofLenseEffects).
-     * @exposure specifies the intensity of the lightning of the view (not 3D-Model).
-     * @sharpen´s parameter `settings` are listed in [Default Rendering Pipeline Sharpening link](https://doc.babylonjs.com/divingDeeper/postProcesses/defaultRenderingPipeline#sharpening).
-     */
-    'camera-settings'?: {
-        contrast: number;
-        exposure: number;
-        bloom?: {
-            enabled: boolean;
-            size?: number;
-            threshold?: number;
-        };
-        dof?: {
-            enabled: boolean;
-            settings: {};
-        };
-        sharpen?: {
-            enabled: boolean;
-            settings: {};
-        };
-    };
-};
-/**
- * {@link Viewer.screenshot} internally uses Babylon.js [ScreenshotTools.CreateScreenshotUsingRenderTarget](https://doc.babylonjs.com/typedoc/classes/babylon.screenshottools#createscreenshotusingrendertarget). \
- * See this link for additional info about the properties.
- */
-declare type ScreenshotSettings = {
-    /** Defaults to canvas width & height */
-    size?: IScreenshotSize;
-    /**
-     * Default `image/png`
-     *
-     * **Info regarding JPEG:** \
-     * Use mimeType `image/jpeg` (**not** `image/jpg`) when creating jpeg's. \
-     * Also ensure that {@link Scene.clearColor | viewer.scene.clearColor} has an alpha value of `1` as jpeg's don't
-     * support transparency. Otherwise background will always be black for jpeg's.
-     */
-    mimeType?: string;
-    /** Default `1` */
-    samples?: number;
-    /** Default `false` */
-    antialiasing?: boolean;
-    /** NOTE: after update to Babylon.js V6: if file name is given, the screenshot image will be downloaded and the base64
-     * string will NOT be returned! */
-    fileName?: string;
-    /** Default `false` */
-    renderSprites?: boolean;
-};
-/**
- * Use this to define geometry to be excluded from autofocus, GLB export, etc.
- */
-declare type ExcludedGeometry = TransformNode | VariantInstance | Variant | VariantElement | TagManagerSubject;
-declare type ExcludedGeometryList = ExcludedGeometry[];
-declare type AutofocusSettings = {
-    /**
-     * Can be used to customize the margins shown around the 3d model when calling {@link Viewer.autofocusActiveCamera}.\
-     * Defaults to 1.5 when not set explicitly.
-     */
-    radiusFactor?: number;
-    adjustWheelPrecision?: boolean;
-    adjustPanningSensibility?: boolean;
-    adjustPinchPrecision?: boolean;
-    /** Desired horizontal camera angle, this won't be overwritten by the autofocus function */
-    alpha?: number;
-    /** Desired vertical camera angle, this won't be overwritten by the autofocus function */
-    beta?: number;
-    /** Optional animation for the focusing camera movement */
-    animation?: string | AnimationDefinition;
-    /** Optional list of geometry to be excluded from consideration */
-    exclude?: ExcludedGeometryList;
-};
-declare type LightDefinitions = {
-    [name: string]: LightDefinition | string;
-};
-declare type LightDefinition = {
-    type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot';
-    path?: string;
-    shadowGenerator?: ShadowGeneratorDefinition;
-};
-declare type ShadowGeneratorDefinition = {
-    mapSize: number;
-    [others: string]: any;
-};
-declare type GroundDefinitions = {
-    [ground: string]: GroundDefinition;
-};
-declare type GroundDefinition = {
-    type: 'baked' | 'ground' | 'heightmap';
-    meshId?: string;
-    url?: string;
-    width?: number;
-    height?: number;
-    subdivisions?: number;
-    receiveShadows?: boolean;
-    minHeight?: number;
-    maxHeight?: number;
-    alphaFilter?: number;
-    onReady?: any;
-};
-declare type CameraDefinitions = {
-    [camera: string]: CameraDefinition;
-};
-declare type CameraDefinition = {
-    /**
-     * `fov` or "Field Of View" defines as it says the view of the scene. Further information about its [theory](https://en.wikipedia.org/wiki/Field_of_view) and [implementation](https://doc.babylonjs.com/typedoc/classes/babylon.camera#fov).
-     */
-    fov?: number;
-    active?: boolean;
-    /**
-     * `arc` is a default camera position where the 3D-model is the center and the camera rotates around the 3D-model.
-     * More Information about `arc` in [ArcRotateCamera](https://doc.babylonjs.com/typedoc/classes/babylon.arcrotatecamera).
-     *
-     * NOTE: While "baked" camera definitions from a GLB or babylon file can currently not be instatiated within the
-     * `Specification`, it's still possible to use them in the viewer.\
-     * For the moment all camera definitions inside these files are automatically added to the scene and can be actived
-     * using the {@link Viewer.switchCamera} function.\
-     * The `newCamera` input has to match the name of the camera node inside the GLB/babylon file.
-     */
-    type: 'arc';
-    /**
-     * `target` overrides `arc`´s position and repositions the camera. The string has the syntax (x?: number, y?: number, z?: number) like [Vector3](https://doc.babylonjs.com/typedoc/classes/babylon.vector3).
-     */
-    target?: string;
-};
-declare type VariantInstanceDefinition = {
-    name?: string;
-    variant: DottedPathArgument;
-    parameters?: ParameterBag;
-    lazy?: boolean;
-};
-declare type SetupJson = {
-    instances: VariantInstanceDefinition[];
-};
-declare type ParameterDeclarations = {
-    [name: string]: ParameterDeclaration;
-};
-declare type ParameterDeclaration = {
-    type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl' | 'paintable';
-    parser?: any;
-    options?: ParameterValue[];
-};
-declare type ParameterValue = string | number | boolean;
-declare type ParameterBag = {
-    [name: string]: ParameterValue;
-};
-declare type ParsedParameterBag = {
-    [name: string]: any;
-};
-declare type DottedPathArgument = string | string[] | DottedPath;
-declare type ParameterObserverResult = boolean | void;
-declare type ParameterObserver = (object: any, oldValue: Undefinable<ParameterValue>, newValue: ParameterValue) => Promise<ParameterObserverResult>;
-declare type PlacementDefinitions = {
-    [name: string]: PlacementDefinition;
-};
-declare type PlacementDefinition = {
-    position?: string | Vector3;
-    alpha?: number;
-    beta?: number;
-    radius?: number;
-    target?: string | Vector3;
-};
-declare type AnimationDefinitions = {
-    [name: string]: AnimationDefinition;
-};
-/**
- * See [GSAP API Docs](https://greensock.com/docs/v3/GSAP/Tween/vars) for description of `GSAPTWeenVars`.
- *
- * You can use the [GreenSock Ease Visualizer](https://greensock.com/ease-visualizer/) to create an animation of your
- * liking and simply copy the `ease` function shown at the bottom of the visualizer into the `ease` property of your
- * {@link AnimationDefinition}.
- *
- * The `GSAPTWeenVars` are extended by the `shortestWay` property.\
- * This property defines if the camera should move to the target position within the shortest possible distance.\
- * If `shortestWay` is `false`, the camera moves the whole difference between the current camera position and the target
- * position and that could be > 360, which can appear very unconvenient to the operator.\
- * The default value of this flag is `true`.
- *
- * Example usage in {@link SceneJson | SceneJson.animations}:
- *
- * ```js
- * // ...
- * scene: {
- *   // ...
- *   animations: {
- *     DefaultCameraAnimation: {
- *       ease: 'Power3.easeInOut',
- *       duration: 0.8,
- *     },
- *   },
- *   // ...
- * }
- * // ...
- * ```
- */
-declare type AnimationDefinition = GSAPTweenVars & {
-    shortestWay?: boolean;
-};
-declare type SpecGenerationData = {
-    name: string;
-    url: string;
-};
-/**
- * Key = Old tag name\
- * Value = New tag name
- */
-declare type TagMapping = {
-    [tagName: string]: string;
-};
-declare type TagManagerSubject = {
-    tagName?: string;
-    nodeName?: string;
-    materialName?: string;
-};
-declare type TagManagerParameterObserverResult = ParameterObserverResult;
-/**
- * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
- * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
- */
-declare type TagManagerParameterObserver = (payload: TagManagerParameterObserverPayload) => Promise<TagManagerParameterObserverResult>;
-declare type TagManagerParameterBag = FuzzyMap<TagManagerSubject, ParameterBag>;
-declare type TagManagerParameterObserverBag = Map<string, TagManagerParameterObserver>;
-declare type TagManagerParameterObserverPayload = {
-    subject: TagManagerSubject;
-    nodes: TransformNode[];
-    materials: Material[];
-    newValue: ParameterValue;
-    oldValue: Undefinable<ParameterValue>;
-};
-declare type TagManagerParameterValue = {
-    tagName?: string;
-    nodeName?: string;
-    materialName?: string;
-    parameterName: string;
-    value: ParameterValue;
-};
-declare type TagManagerParameterObserverResultBag = {
-    subject: TagManagerSubject;
-    parameter: string;
-    nodes: TransformNode[];
-    materials: Material[];
-    oldValue: ParameterValue;
-    newValue: ParameterValue;
-    parameterObserverResult: TagManagerParameterObserverResult;
-};
-declare type NodeNamingStrategyPayload = {
-    variantInstance: VariantInstance;
-    variant: Variant;
-    variantParameterizable: VariantParameterizable;
-};
-declare type NodeNamingStrategyHandler = (node: TransformNode, payload: NodeNamingStrategyPayload) => string;
-declare type NodeNamingStrategy = {
-    handler: NodeNamingStrategyHandler;
-    payload: NodeNamingStrategyPayload;
-};

package/dist/lib-cjs/api/util/globalTypes.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=globalTypes.js.map

package/dist/lib-cjs/api/util/globalTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalTypes.js","sourceRoot":"","sources":["../../../../src/api/util/globalTypes.ts"],"names":[],"mappings":""}

package/dist/lib-cjs/api/util/resourceHelper.d.ts

@@ -1,58 +0,0 @@
-/**
- * Sleeps for a certain amount of microseconds.
- */
-declare const sleep: (ms: number) => Promise<unknown>;
-/**
- * Loads a JSON from a given path.
- * @emits {@link Event.LOADING_START}
- * @emits {@link Event.LOADING_END}
- */
-declare const loadJson: <T>(path: string) => Promise<T>;
-/**
- * Loads a Text from a given path.
- * @emits {@link Event.LOADING_START}
- * @emits {@link Event.LOADING_END}
- */
-declare const loadText: (path: string) => Promise<string>;
-/**
- * Loads a Javascript ressource.\
- * Usefull for including packages via CDN (eg: Babylon.js Inspector)
- */
-declare const loadJavascript: (url: string) => Promise<void>;
-/**
- * Debounces: it limits the rate at which a function can fire.
- */
-declare const debounce: (func: Function, wait: number, immediate?: boolean) => () => void;
-/**
- * Merges multiple maps.
- */
-declare const mergeMaps: <TKey, TValue>(...maps: Map<TKey, TValue>[]) => Map<TKey, TValue>;
-/**
- * Creates a HTML image element based on a SVG string, whereas all the embedded assets in the SVG (eg: fonts, images)
- * are already loaded and exchanged by their base64 representation.\
- * There the output image can exist as "standalone" image and may be used for example as a paintable.
- *
- * !!CAUTION!!: The used functions within this code section are very well evaluated since most alternatives
- * somehow don't work in Safari, as mentioned in the following BJS forum entries:
- * - https://forum.babylonjs.com/t/drawing-svg-content-text-into-dynamictexture-doesnt-work-in-safari-v15/25048
- * - https://forum.babylonjs.com/t/texture-createfrombase64string-doesnt-seem-to-work-for-ios-devices-initially/25502
- */
-declare const createImageFromSvg: (svgSrc: string) => Promise<HTMLImageElement>;
-/**
- * Creates an HTML image element from a dedicated image source.\
- * Also waits until the image has loaded.
- *
- * !!CAUTION!!: The `setTimeout` after loading is finished is required due to a Safari bug:
- * - https://bugs.webkit.org/show_bug.cgi?id=39059
- * - https://bugs.webkit.org/show_bug.cgi?id=219770
- *
- * It's not 100% ensured that the timeout solves the issue in every case, but there is no other way unfortunately.\
- * => Keep an eye on it in future projects
- *
- * @param imgSrc Theoretically every source is valid which is also supported by
- *               [HTMLImageElement.src](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/src).\
- *               Known exceptions are SVGs with embedded assets that are provided as object URL. See comments in
- *               {@link createImageFromSvg} for further details.
- */
-declare const createImageFromImgSrc: (imgSrc: string) => Promise<HTMLImageElement>;
-export { sleep, loadJson, loadText, loadJavascript, debounce, mergeMaps, createImageFromSvg, createImageFromImgSrc };