@shapediver/viewer.shared.types 1.15.7 → 2.0.0

package/src/implementation/material/MaterialUnlitData.ts

@@ -0,0 +1,91 @@
+import { ITreeNodeData } from "@shapediver/viewer.shared.node-tree";
+import { MATERIAL_ALPHA, MATERIAL_SHADING, MATERIAL_SIDE } from "../../interfaces/data/material/IMaterialAbstractData";
+import { IMaterialUnlitData, IMaterialUnlitDataProperties } from "../../interfaces/data/material/IMaterialUnlitData";
+import { AbstractMaterialData } from "./AbstractMaterialData";
+
+
+export class MaterialUnlitData extends AbstractMaterialData implements IMaterialUnlitData {
+    // #region Constructors (1)
+
+    /**
+     * Creates a material data object.
+     * 
+     * @param _attributes the attributes of the material
+     * @param id the id
+     */
+    constructor(
+        properties?: IMaterialUnlitDataProperties,
+        id?: string
+    ) {
+        super(properties, id);
+        if (!properties) return;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Methods (1)
+
+    public reset(): void {
+        this.alphaCutoff = 0;
+        this.alphaMap = undefined;
+        this.alphaMode = MATERIAL_ALPHA.OPAQUE;
+        this.aoMap = undefined;
+        this.aoMapIntensity = 1.0;
+        this.bumpMap = undefined;
+        this.bumpScale = 1.0;
+        this.color = '#ffffff';
+        this.emissiveMap = undefined;
+        this.emissiveness = '#000000';
+        this.materialOutput = false;
+        this.map = undefined;
+        this.normalMap = undefined;
+        this.normalScale = 1.0;
+        this.opacity = 1.0;
+        this.shading = MATERIAL_SHADING.SMOOTH;
+        this.side = MATERIAL_SIDE.DOUBLE;  
+    }
+
+    public clone(): IMaterialUnlitData {
+        return new MaterialUnlitData({
+            alphaMap: this.alphaMap,
+            alphaCutoff: this.alphaCutoff,
+            alphaMode: this.alphaMode,
+            aoMap: this.aoMap,
+            aoMapIntensity: this.aoMapIntensity,
+            bumpMap: this.bumpMap,
+            bumpScale: this.bumpScale,
+            color: this.color,
+            emissiveMap: this.emissiveMap,
+            emissiveness: this.emissiveness,
+            shading: this.shading,
+            map: this.map,
+            name: this.name,
+            normalMap: this.normalMap,
+            normalScale: this.normalScale,
+            opacity: this.opacity,
+            side: this.side,
+        }, this.id);
+    }
+
+    public copy(source: MaterialUnlitData): void {
+        this.alphaCutoff = source.alphaCutoff;
+        this.alphaMap = source.alphaMap;
+        this.alphaMode = source.alphaMode;
+        this.aoMap = source.aoMap;
+        this.aoMapIntensity = source.aoMapIntensity;
+        this.bumpMap = source.bumpMap;
+        this.bumpScale = source.bumpScale;
+        this.color = source.color;
+        this.emissiveMap = source.emissiveMap;
+        this.emissiveness = source.emissiveness;
+        this.materialOutput = source.materialOutput;
+        this.map = source.map;
+        this.normalMap = source.normalMap;
+        this.normalScale = source.normalScale;
+        this.opacity = source.opacity;
+        this.shading = source.shading;
+        this.side = source.side;
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/material/MaterialVariantsData.ts

@@ -0,0 +1,60 @@
+import { AbstractTreeNodeData, ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+import { IMaterialVariantsData } from '../../interfaces/data/material/IMaterialVariantsData';
+import { PrimitiveData } from '../data/GeometryData';
+
+export class MaterialVariantsData extends AbstractTreeNodeData implements IMaterialVariantsData {
+    // #region Properties (1)
+
+    readonly #variants: string[] = [];
+    readonly #primitiveData: PrimitiveData[] = [];
+    #variantIndex?: number;
+
+    // #endregion Properties (1)
+
+    // #region Constructors (1)
+
+    constructor(id?: string) {
+        super(id);
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (2)
+
+    public get primitiveData(): PrimitiveData[] {
+        return this.#primitiveData;
+    }
+
+    public get variants(): string[] {
+        return this.#variants;
+    }
+
+    public get variantIndex(): number | undefined {
+        return this.#variantIndex;
+    }
+
+    public set variantIndex(value: number | undefined) {
+        this.#variantIndex = value;
+        for(let i = 0; i < this.primitiveData.length; i++) {            
+            const variant = this.primitiveData[i].materialVariants.find(v => v.variant === this.#variantIndex);
+            if(variant) {
+                this.primitiveData[i].material = variant.material;
+            } else {
+                this.primitiveData[i].material = this.primitiveData[i].standardMaterial;
+            }
+        }
+    }
+
+    // #endregion Public Accessors (2)
+
+    // #region Public Methods (1)
+
+    /**
+     * Clones the scene graph data.
+     */
+    public clone(): IMaterialVariantsData {
+        return new MaterialVariantsData(this.id);
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/sdtf/SDTFAttributesData.ts

@@ -0,0 +1,118 @@
+import { AbstractTreeNodeData, ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+import { ISDTFAttributeData, ISDTFAttributesData } from '../../interfaces/sdtf/ISDTFAttributesData';
+import { SdtfTypeHintName } from '@shapediver/sdk.sdtf-v1'
+
+export class SDTFAttributeData implements ISDTFAttributeData {
+    // #region Properties (2)
+
+    readonly #typeHint;
+    readonly #value;
+
+    // #endregion Properties (2)
+
+    // #region Constructors (1)
+
+    constructor(
+        typeHint: SdtfTypeHintName | string,
+        value: any
+    ) {
+        this.#typeHint = typeHint;
+        this.#value = value;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (2)
+
+    public get typeHint(): SdtfTypeHintName | string {
+        return this.#typeHint;
+    }
+
+    public get value(): any {
+        return this.#value;
+    }
+
+    // #endregion Public Accessors (2)
+}
+
+// export class SDTFAttributeAsyncData {
+//     // #region Properties (2)
+
+//     readonly #typeHint;
+//     readonly #accessor;
+//     private _value: Promise<any> | undefined;
+//     private readonly _loadAccessor: (accessorID: number) => Promise<any>
+
+//     // #endregion Properties (2)
+
+//     // #region Constructors (1)
+
+//     constructor(
+//             typeHint: string,
+//             accessor: number,
+//         private readonly _loadAccessor: (accessorID: number) => Promise<any>
+//     ) {
+//         this._typeHint = typeHint;
+//         this._accessor = accessor;
+//     }
+
+//     public get value(): Promise<any> {
+//         if (this.value !== undefined) {
+//             return this._value!;
+//         } else {
+//             this._value = this._loadAccessor!(this._accessor!);
+//             return this._value;
+//         }
+//     }
+
+//     public get typeHint(): string {
+//         return this._typeHint;
+//     }
+
+//     // #endregion Constructors (1)
+// }
+
+export class SDTFAttributesData extends AbstractTreeNodeData implements ISDTFAttributesData {
+    // #region Properties (1)
+
+    readonly #attributes: {
+        [key: string]: SDTFAttributeData
+    } = {};
+
+    // #endregion Properties (1)
+
+    // #region Constructors (1)
+
+    constructor(
+        attributes: {
+            [key: string]: SDTFAttributeData
+        } = {},
+        id?: string
+    ) {
+        super(id);
+        this.#attributes = attributes;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (1)
+
+    public get attributes(): {
+        [key: string]: SDTFAttributeData
+    } {
+        return this.#attributes;
+    }
+
+    // #endregion Public Accessors (1)
+
+    // #region Public Methods (1)
+
+    /**
+     * Clones the scene graph data.
+     */
+    public clone(): ISDTFAttributesData {
+        return new SDTFAttributesData(this.attributes, this.id);
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/sdtf/SDTFItemData.ts

@@ -0,0 +1,64 @@
+import { AbstractTreeNodeData, ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+import { ISDTFAttributeData } from '../../interfaces/sdtf/ISDTFAttributesData';
+import { ISDTFItemData } from '../../interfaces/sdtf/ISDTFItemData';
+import { SdtfTypeHintName } from '@shapediver/sdk.sdtf-v1'
+
+export class SDTFItemData extends AbstractTreeNodeData implements ISDTFItemData {
+    // #region Properties (3)
+
+    readonly #typeHint;
+    readonly #value;
+
+    #attributes: {
+        [key: string]: ISDTFAttributeData
+    } = {};
+
+    // #endregion Properties (3)
+
+    // #region Constructors (1)
+
+    constructor(
+        typeHint: SdtfTypeHintName | string,
+        value: any,
+        attributes: {
+            [key: string]: ISDTFAttributeData
+        },
+        id?: string
+    ) {
+        super(id);
+        this.#attributes = attributes;
+        this.#typeHint = typeHint;
+        this.#value = value;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (3)
+
+    public get attributes(): {
+        [key: string]: ISDTFAttributeData
+    } {
+        return this.#attributes;
+    }
+
+    public get typeHint(): SdtfTypeHintName | string {
+        return this.#typeHint;
+    }
+
+    public get value(): any {
+        return this.#value;
+    }
+
+    // #endregion Public Accessors (3)
+
+    // #region Public Methods (1)
+
+    /**
+     * Clones the scene graph data.
+     */
+    public clone(): ISDTFItemData {
+        return new SDTFItemData(this.typeHint, this.value, this.attributes, this.id);
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/sdtf/SDTFOverviewData.ts

@@ -0,0 +1,79 @@
+import { AbstractTreeNodeData, ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+import { ISDTFOverview, ISDTFOverviewData } from '../../interfaces/sdtf/ISDTFOverviewData';
+import { SdtfPrimitiveTypeGuard } from '@shapediver/sdk.sdtf-primitives'
+
+export class SDTFOverviewData extends AbstractTreeNodeData implements ISDTFOverviewData {
+    // #region Properties (1)
+
+    #overview: ISDTFOverview = {};
+
+    // #endregion Properties (1)
+
+    // #region Constructors (1)
+
+    constructor(
+        overview: ISDTFOverview,
+        id?: string
+    ) {
+        super(id);
+        this.#overview = overview;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (1)
+
+    public get overview(): ISDTFOverview {
+        return this.#overview;
+    }
+
+    // #endregion Public Accessors (1)
+
+    // #region Public Methods (1)
+
+    /**
+     * Clones the scene graph data.
+     */
+    public clone(): ISDTFOverviewData {
+        return new SDTFOverviewData(this.#overview, this.id);
+    }
+
+    public merge(data: ISDTFOverviewData) {
+        for (let overviewKey in data.overview) {
+            for(let i = 0; i < data.overview[overviewKey].length; i++){
+                const dataToCopy = data.overview[overviewKey][i];
+                const existingEntries = this.overview[overviewKey] ? this.overview[overviewKey].filter(o => o.typeHint === dataToCopy.typeHint) : [];
+                if(this.overview[overviewKey] && existingEntries.length > 0) {
+                    const entry = existingEntries[0];
+                    entry.count++;
+                    if (SdtfPrimitiveTypeGuard.isStringType(dataToCopy.typeHint)) {
+                        entry.values = entry.values?.concat(dataToCopy.values!.filter((item) => entry.values!.indexOf(item) < 0))
+                    }
+                    if (SdtfPrimitiveTypeGuard.isNumberType(dataToCopy.typeHint)) {
+                    entry.min = Math.min(dataToCopy.min!, entry.min!);
+                    entry.max = Math.max(dataToCopy.max!, entry.max!);
+                    }
+
+                } else if(this.overview[overviewKey]) {
+                    this.overview[overviewKey].push({
+                        typeHint: dataToCopy.typeHint,
+                        count: dataToCopy.count,
+                        values: dataToCopy.values,
+                        min: dataToCopy.min,
+                        max: dataToCopy.max,
+                    })
+                } else {
+                    this.overview[overviewKey] = [{
+                        typeHint: dataToCopy.typeHint,
+                        count: dataToCopy.count,
+                        values: dataToCopy.values,
+                        min: dataToCopy.min,
+                        max: dataToCopy.max,
+                    }]
+                }
+            }
+        }
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/index.ts

@@ -0,0 +1,72 @@
+import { CustomData } from './implementation/data/CustomData'
+import { AttributeData, GeometryData, PrimitiveData } from './implementation/data/GeometryData'
+import {
+  MaterialStandardData,
+} from './implementation/material/MaterialStandardData'
+import { HTMLElementAnchorCustomData, HTMLElementAnchorData, HTMLElementAnchorImageData, HTMLElementAnchorTextData } from './implementation/data/HTMLElementAnchorData'
+import { SDTFItemData } from './implementation/sdtf/SDTFItemData'
+import { AnimationData } from './implementation/data/AnimationData'
+import { IViewportEvent } from './interfaces/events/IViewportEvent'
+import { ISessionEvent } from './interfaces/events/ISessionEvent'
+import { ICameraEvent } from './interfaces/events/ICameraEvent'
+import { ISceneEvent } from './interfaces/events/ISceneEvent'
+import { ITaskEvent, TASK_TYPE } from './interfaces/events/ITaskEvent'
+import { MaterialVariantsData } from './implementation/material/MaterialVariantsData'
+import { MapData } from './implementation/material/MapData'
+import { MaterialSpecularGlossinessData } from './implementation/material/MaterialSpecularGlossinessData'
+import { MaterialUnlitData } from './implementation/material/MaterialUnlitData'
+import { IAnchorDataImage, IAnchorDataText, IHTMLElementAnchorData } from './interfaces/data/IHTMLElementAnchorData'
+import { IMaterialAbstractData, IMaterialAbstractDataProperties, MATERIAL_ALPHA, MATERIAL_SHADING, MATERIAL_SIDE } from './interfaces/data/material/IMaterialAbstractData'
+import { IAttributeData, IGeometryData, IPrimitiveData, PRIMITIVE_MODE } from './interfaces/data/IGeometryData'
+import { TEXTURE_WRAPPING, TEXTURE_FILTERING, IMapData } from './interfaces/data/material/IMapData'
+import { IMaterialSpecularGlossinessData, IMaterialSpecularGlossinessDataProperties } from './interfaces/data/material/IMaterialSpecularGlossinessDataProperties'
+import { IMaterialStandardData, IMaterialStandardDataProperties } from './interfaces/data/material/IMaterialStandardData'
+import { IMaterialUnlitData, IMaterialUnlitDataProperties } from './interfaces/data/material/IMaterialUnlitData'
+import { IMaterialVariantsData } from './interfaces/data/material/IMaterialVariantsData'
+import { IAnimationData, IAnimationTrack } from './interfaces/data/IAnimationData'
+import { ICustomData } from './interfaces/data/ICustomData'
+import { AbstractMaterialData } from './implementation/material/AbstractMaterialData'
+import { ISDTFOverview, ISDTFOverviewData } from './interfaces/sdtf/ISDTFOverviewData'
+import { SDTFAttributeData, SDTFAttributesData } from './implementation/sdtf/SDTFAttributesData'
+import { SDTFOverviewData } from './implementation/sdtf/SDTFOverviewData'
+import { ISDTFAttributesData, ISDTFAttributeData } from './interfaces/sdtf/ISDTFAttributesData'
+import { ISDTFItemData } from './interfaces/sdtf/ISDTFItemData'
+import { ISDTFAttributeVisualizationData } from './interfaces/sdtf/ISDTFAttributeVisualizationData'
+import { EventResponseMapping } from './interfaces/events/EventResponseMapping'
+import { IDragEvent } from './interfaces/events/IDragEvent'
+import { IHoverEvent } from './interfaces/events/IHoverEvent'
+import { ISelectEvent } from './interfaces/events/ISelectEvent'
+import { IMultiSelectEvent } from './interfaces/events/IMultiSelectEvent'
+import { IBoneData } from './interfaces/data/IBoneData'
+import { BoneData } from './implementation/data/BoneData'
+import { SdtfTypeHintName } from '@shapediver/sdk.sdtf-v1'
+import { SdtfPrimitiveTypeGuard } from '@shapediver/sdk.sdtf-primitives'
+
+export {
+  IMaterialStandardData, MaterialStandardData, IMaterialStandardDataProperties, 
+  IMaterialAbstractData, IMaterialAbstractDataProperties, AbstractMaterialData,
+  IMaterialUnlitData, MaterialUnlitData, IMaterialUnlitDataProperties, 
+  IMaterialSpecularGlossinessData, MaterialSpecularGlossinessData, IMaterialSpecularGlossinessDataProperties, 
+  IMapData, MapData, MATERIAL_SIDE, MATERIAL_ALPHA, MATERIAL_SHADING, TEXTURE_WRAPPING, TEXTURE_FILTERING
+}
+
+export {
+  IAnimationData, AnimationData, IAnimationTrack, IGeometryData, IAttributeData, IPrimitiveData, IMaterialVariantsData, GeometryData, AttributeData, PrimitiveData, MaterialVariantsData, PRIMITIVE_MODE
+}
+
+export {
+  IAnchorDataImage, IAnchorDataText, IHTMLElementAnchorData, HTMLElementAnchorCustomData, HTMLElementAnchorTextData, HTMLElementAnchorImageData, HTMLElementAnchorData
+}
+
+export {
+  ICustomData, CustomData, IBoneData, BoneData
+}
+
+export {
+  EventResponseMapping, IViewportEvent, ISessionEvent, ICameraEvent, IDragEvent, IHoverEvent, ISelectEvent, IMultiSelectEvent, ISceneEvent, ITaskEvent, TASK_TYPE
+}
+
+export {
+  ISDTFOverviewData, SDTFOverviewData, ISDTFOverview, SDTFAttributesData, ISDTFAttributesData, ISDTFAttributeData, SDTFAttributeData, SDTFItemData, ISDTFItemData, ISDTFAttributeVisualizationData,
+  SdtfTypeHintName as SDTF_TYPEHINT, SdtfPrimitiveTypeGuard
+}

package/src/interfaces/data/IAnimationData.ts

@@ -0,0 +1,42 @@
+import { ITransformation, ITreeNode, ITreeNodeData } from "@shapediver/viewer.shared.node-tree";
+import { vec3 } from "gl-matrix";
+
+export interface IAnimationTrack {
+    // #region Properties (6)
+
+    interpolation: 'linear' | 'step';
+    node: ITreeNode,
+    path: 'scale' | 'translation' | 'rotation';
+    previousMatrix?: ITransformation;
+    pivot?: vec3;
+    times: Float32Array | Uint8Array | Uint16Array | Int8Array | Int16Array | Uint32Array | number[];
+    values: Float32Array | Uint8Array | Uint16Array | Int8Array | Int16Array | Uint32Array | number[];
+
+    // #endregion Properties (6)
+}
+
+export interface IAnimationData extends ITreeNodeData {
+    // #region Properties (8)
+
+    readonly animate: boolean;
+    readonly duration: number;
+    readonly name: string;
+    readonly start: number;
+    readonly tracks: IAnimationTrack[];
+
+    animationTime: number;
+    repeat: boolean;
+    reset: boolean;
+
+    // #endregion Properties (8)
+
+    // #region Public Methods (5)
+
+    clone(): IAnimationData;
+    continueAnimation(): void;
+    pauseAnimation(): void;
+    startAnimation(): void;
+    stopAnimation(): void;
+
+    // #endregion Public Methods (5)
+}

package/src/interfaces/data/IBoneData.ts

@@ -0,0 +1,9 @@
+import { ITreeNodeData } from "@shapediver/viewer.shared.node-tree";
+
+export interface IBoneData extends ITreeNodeData {
+    // #region Public Methods (1)
+
+    clone(): IBoneData;
+
+    // #endregion Public Methods (1)
+}

package/src/interfaces/data/ICustomData.ts

@@ -0,0 +1,15 @@
+import { ITreeNodeData } from "@shapediver/viewer.shared.node-tree";
+
+export interface ICustomData extends ITreeNodeData {
+    // #region Properties (1)
+
+    data: { [key: string]: any };
+
+    // #endregion Properties (1)
+
+    // #region Public Methods (1)
+
+    clone(): ICustomData;
+
+    // #endregion Public Methods (1)
+}

package/src/interfaces/data/IGeometryData.ts

@@ -0,0 +1,87 @@
+import { ITreeNode, ITreeNodeData } from "@shapediver/viewer.shared.node-tree";
+import { IBox } from "@shapediver/viewer.shared.math";
+import { IMaterialAbstractData } from "./material/IMaterialAbstractData";
+import { mat4 } from "gl-matrix";
+
+export enum PRIMITIVE_MODE {
+    POINTS = 0,
+    LINES = 1,
+    LINE_LOOP = 2,
+    LINE_STRIP = 3,
+    TRIANGLES = 4,
+    TRIANGLE_STRIP = 5,
+    TRIANGLE_FAN = 6
+}
+
+export interface IAttributeData extends ITreeNodeData {
+    // #region Properties (14)
+
+    readonly array: Int8Array | Uint8Array | Int16Array | Uint16Array | Uint32Array | Float32Array;
+    readonly byteOffset: number;
+    readonly byteStride?: number;
+    readonly count: number;
+    readonly elementBytes: number;
+    readonly itemBytes: number;
+    readonly itemSize: number;
+    readonly max: number[];
+    readonly min: number[];
+    readonly morphAttributeData: IAttributeData[];
+    readonly normalized: boolean;
+    readonly sparse?: boolean;
+    readonly sparseIndices?: Int8Array | Uint8Array | Int16Array | Uint16Array | Uint32Array | Float32Array;
+    readonly sparseValues?: Int8Array | Uint8Array | Int16Array | Uint16Array | Uint32Array | Float32Array;
+
+    // #endregion Properties (14)
+
+    // #region Public Methods (1)
+
+    clone(): IAttributeData;
+
+    // #endregion Public Methods (1)
+}
+
+export interface IPrimitiveData extends ITreeNodeData {
+    // #region Properties (9)
+
+    readonly attributes: {
+        [key: string]: IAttributeData
+    };
+    readonly mode: PRIMITIVE_MODE;
+
+    attributeMaterial: IMaterialAbstractData | null;
+    boundingBox: IBox;
+    effectMaterials: { material: IMaterialAbstractData, token: string }[];
+    indices: IAttributeData | null;
+    material: IMaterialAbstractData | null;
+    materialVariants: { material: IMaterialAbstractData, variant: number }[];
+    standardMaterial: IMaterialAbstractData | null;
+
+    // #endregion Properties (9)
+
+    // #region Public Methods (1)
+
+    clone(): IPrimitiveData;
+
+    // #endregion Public Methods (1)
+}
+
+export interface IGeometryData extends ITreeNodeData {
+    // #region Properties (7)
+
+    readonly matrix: mat4;
+    readonly primitive: IPrimitiveData;
+
+    boneInverses: mat4[];
+    bones: ITreeNode[];
+    boundingBox: IBox;
+    morphWeights: number[];
+    renderOrder: number;
+
+    // #endregion Properties (7)
+
+    // #region Public Methods (1)
+
+    clone(): IGeometryData;
+
+    // #endregion Public Methods (1)
+}