@combeenation/3d-viewer 12.4.1 → 13.0.0

package/src/api/util/globalTypes.ts

@@ -1,566 +0,0 @@
-// global accessible types imported from 3d-viewer
-type Viewer = import('../classes/viewer').Viewer;
-type Variant = import('../classes/variant').Variant;
-type VariantInstance = import('../classes/variantInstance').VariantInstance;
-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
- */
-type VariantElement = import('../classes/element').Element;
-type DottedPath = import('../classes/dottedPath').DottedPath;
-type ViewerLight = import('../classes/viewerLight').ViewerLight;
-type SceneManager = import('../manager/sceneManager').SceneManager;
-
-type FuzzyMap<K, V> = import('../classes/fuzzyMap').FuzzyMap<K, V>;
-
-// global accessible types imported from BabylonJS
-type Scene = import('@babylonjs/core/scene').Scene;
-type Vector3 = import('@babylonjs/core/Maths/math.vector').Vector3;
-type Color3 = import('@babylonjs/core/Maths/math.color').Color3;
-type Color4 = import('@babylonjs/core/Maths/math.color').Color4;
-type Material = import('@babylonjs/core/Materials/material').Material;
-type PBRMaterial = import('@babylonjs/core/Materials/PBR/pbrMaterial').PBRMaterial;
-type StandardMaterial = import('@babylonjs/core/Materials/standardMaterial').StandardMaterial;
-type BackgroundMaterial = import('@babylonjs/core/Materials/Background/backgroundMaterial').BackgroundMaterial;
-type NodeMaterial = import('@babylonjs/core/Materials/Node').NodeMaterial;
-type DynamicTexture = import('@babylonjs/core/Materials/Textures/dynamicTexture').DynamicTexture;
-type Mesh = import('@babylonjs/core/Meshes/mesh').Mesh;
-type AbstractMesh = import('@babylonjs/core/Meshes/abstractMesh').AbstractMesh;
-type InstancedMesh = import('@babylonjs/core/Meshes/instancedMesh').InstancedMesh;
-type TransformNode = import('@babylonjs/core/Meshes/transformNode').TransformNode;
-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).
- */
-type EngineOptions = import('@babylonjs/core/Engines/thinEngine').EngineOptions;
-
-type ArcRotateCamera = import('@babylonjs/core/Cameras/arcRotateCamera').ArcRotateCamera;
-type IScreenshotSize = import('@babylonjs/core/Misc/interfaces/screenshotSize').IScreenshotSize;
-type BabylonAnimation = import('@babylonjs/core/Animations/animation').Animation;
-type CubeTexture = import('@babylonjs/core/Materials/Textures/cubeTexture').CubeTexture;
-type MeshBuilder = typeof import('@babylonjs/core/Meshes/meshBuilder').MeshBuilder;
-type Texture = import('@babylonjs/core/Materials/Textures/texture').Texture;
-type HemisphericLight = import('@babylonjs/core/Lights/hemisphericLight').HemisphericLight;
-type DirectionalLight = import('@babylonjs/core/Lights/directionalLight').DirectionalLight;
-type IInspectorOptions = import('@babylonjs/core/Debug').IInspectorOptions;
-// Node is already defined in lib.dom.d.ts, so it can't be declared that way
-// type Node = import("@babylonjs/core/node").Node;
-
-type IExportOptions = import('@babylonjs/serializers/glTF/2.0').IExportOptions;
-
-type EventEmitter = import('eventemitter3');
-
-type Undefinable<T> = T | undefined;
-
-type Nullable<T> = T | null;
-
-// some more global accessible types
-type PathDefinitions = {
-  include: string[];
-  exclude?: string[];
-};
-
-type TraceableDefinition = {
-  path: string;
-};
-
-type TraceableDefinitions = {
-  [name: string]: TraceableDefinition;
-};
-
-type PaintableDefinition = {
-  path: string;
-  textureOptions:
-    | {
-        width: number;
-        height: number;
-      }
-    | number;
-};
-
-type PaintableDefinitions = {
-  [name: string]: PaintableDefinition;
-};
-
-type PaintableValue = {
-  src: string;
-  options?: PaintableOptions;
-};
-
-type PaintableOptions = {
-  uScale?: number;
-  uOffset?: number;
-  vScale?: number;
-  vOffset?: number;
-};
-
-type Asset = {
-  rootUrl: string;
-  fileName: string | undefined;
-};
-
-type ElementDefinitions = {
-  [name: string]: ElementDefinition | string[];
-};
-
-type ElementDefinition = {
-  paths: PathDefinitions;
-  traceables?: TraceableDefinitions;
-  paintables?: PaintableDefinitions;
-};
-
-type TransformationDefinition = {
-  scaling: Vector3;
-  position: Vector3;
-  rotation: Vector3;
-};
-
-type EnvironmentDefinition = {
-  environmentColor?: Color3;
-  environmentIntensity?: number;
-  environment?: string;
-  environmentBackground?: string;
-  environmentRotation?: number;
-  environmentUseDefault?: boolean;
-};
-
-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
- */
-type AutoSpecStructureJson = StructureJson & {
-  scene: AutoSpecSceneJson;
-  setup: SetupJson;
-  variants: { [id: string]: StructureJson };
-};
-
-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;
-};
-
-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
- */
-type AutoSpecSceneJson = SceneJson & {
-  engine: {
-    antialiasing: boolean;
-    options: EngineOptions;
-  };
-};
-
-type SceneDefinition = {
-  globals: SceneGlobals;
-  cameras?: CameraDefinitions;
-};
-
-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.
- */
-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.
- */
-type ExcludedGeometry = TransformNode | VariantInstance | Variant | VariantElement | TagManagerSubject;
-type ExcludedGeometryList = ExcludedGeometry[];
-
-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;
-};
-
-type LightDefinitions = {
-  [name: string]: LightDefinition | string;
-};
-
-type LightDefinition = {
-  type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot';
-  path?: string;
-  shadowGenerator?: ShadowGeneratorDefinition;
-};
-
-type ShadowGeneratorDefinition = {
-  mapSize: number;
-  [others: string]: any;
-  /**
-   * Further properties like `usePoissonSampling` are set directly on the ShadowGenerator object.
-   * [Shadows](https://doc.babylonjs.com/divingDeeper/lights/shadows)
-   */
-};
-
-type GroundDefinitions = {
-  [ground: string]: GroundDefinition;
-};
-
-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;
-};
-
-type CameraDefinitions = {
-  [camera: string]: CameraDefinition;
-};
-
-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;
-};
-
-type VariantInstanceDefinition = {
-  name?: string;
-  variant: DottedPathArgument;
-  parameters?: ParameterBag;
-  lazy?: boolean;
-};
-
-type SetupJson = {
-  instances: VariantInstanceDefinition[];
-};
-
-type ParameterDeclarations = {
-  [name: string]: ParameterDeclaration;
-};
-
-type ParameterDeclaration = {
-  type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl' | 'paintable';
-  parser?: any;
-  options?: ParameterValue[];
-};
-
-type ParameterValue = string | number | boolean;
-
-type ParameterBag = {
-  [name: string]: ParameterValue;
-};
-
-type ParsedParameterBag = {
-  [name: string]: any;
-};
-
-type DottedPathArgument = string | string[] | DottedPath;
-
-type ParameterObserverResult = boolean | void;
-
-type ParameterObserver = (
-  object: any,
-  oldValue: Undefinable<ParameterValue>,
-  newValue: ParameterValue
-) => Promise<ParameterObserverResult>;
-
-type PlacementDefinitions = {
-  [name: string]: PlacementDefinition;
-};
-
-type PlacementDefinition = {
-  position?: string | Vector3;
-  alpha?: number;
-  beta?: number;
-  radius?: number;
-  target?: string | Vector3;
-};
-
-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,
- *     },
- *   },
- *   // ...
- * }
- * // ...
- * ```
- */
-type AnimationDefinition = GSAPTweenVars & { shortestWay?: boolean };
-
-type SpecGenerationData = {
-  name: string;
-  url: string;
-};
-
-/**
- * Key = Old tag name\
- * Value = New tag name
- */
-type TagMapping = {
-  [tagName: string]: string;
-};
-
-type TagManagerSubject = {
-  tagName?: string;
-  nodeName?: string;
-  materialName?: string;
-};
-
-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.
- */
-type TagManagerParameterObserver = (
-  payload: TagManagerParameterObserverPayload
-) => Promise<TagManagerParameterObserverResult>;
-
-type TagManagerParameterBag = FuzzyMap<TagManagerSubject, ParameterBag>;
-
-type TagManagerParameterObserverBag = Map<string, TagManagerParameterObserver>;
-
-type TagManagerParameterObserverPayload = {
-  subject: TagManagerSubject;
-  nodes: TransformNode[];
-  materials: Material[];
-  newValue: ParameterValue;
-  oldValue: Undefinable<ParameterValue>;
-};
-
-type TagManagerParameterValue = {
-  tagName?: string;
-  nodeName?: string;
-  materialName?: string;
-  parameterName: string;
-  value: ParameterValue;
-};
-
-type TagManagerParameterObserverResultBag = {
-  subject: TagManagerSubject;
-  parameter: string;
-  nodes: TransformNode[];
-  materials: Material[];
-  oldValue: ParameterValue;
-  newValue: ParameterValue;
-  parameterObserverResult: TagManagerParameterObserverResult;
-};
-
-type NodeNamingStrategyPayload = {
-  variantInstance: VariantInstance;
-  variant: Variant;
-  variantParameterizable: VariantParameterizable;
-};
-
-type NodeNamingStrategyHandler = (node: TransformNode, payload: NodeNamingStrategyPayload) => string;
-
-type NodeNamingStrategy = {
-  handler: NodeNamingStrategyHandler;
-  payload: NodeNamingStrategyPayload;
-};