@shapediver/viewer.features.attribute-visualization 3.3.4 → 3.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapediver/viewer.features.attribute-visualization",
-  "version": "3.3.4",
+  "version": "3.3.7",
   "description": "",
   "keywords": [],
   "author": "Michael Oppitz <michael@shapediver.com>",
@@ -10,11 +10,10 @@
     "test": "__tests__"
   },
   "files": [
-    "dist",
-    "src",
     "package.json",
+    "dist/",
     "README.md",
-    "tsconfig.json"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -28,7 +27,7 @@
     "build": "bash ../../scripts/building/build.sh",
     "build-watch": "bash ../../scripts/building/build-watch.sh",
     "build-dep": "bash ../../scripts/building/build-dep.sh",
-    "build-current": "npm run build",
+    "build-all": "npm run build",
     "doc": "typedoc"
   },
   "bugs": {
@@ -41,13 +40,13 @@
     "testEnvironment": "node"
   },
   "devDependencies": {
-    "@shapediver/viewer": "3.3.4",
-    "@shapediver/viewer.shared.services": "3.3.4",
-    "@shapediver/viewer.shared.types": "3.3.4"
+    "@shapediver/viewer": "3.3.7",
+    "@shapediver/viewer.shared.services": "3.3.7",
+    "@shapediver/viewer.shared.types": "3.3.7"
   },
   "dependencies": {
     "detect-it": "4.0.1",
     "gl-matrix": "3.3.0"
   },
-  "gitHead": "8193da527b4e3fc4d90181018bd60d6ac70be3e8"
+  "gitHead": "112787d5c5226cca5e89d08102d0b1a3dd4a1d71"
 }

package/src/implementation/AttributeVisualizationEngine.ts

@@ -1,345 +0,0 @@
-/* eslint-disable no-case-declarations */
-import { ILayer } from '../interfaces/ILayer';
-import { addListener, ITreeNode, IViewportApi, sceneTree } from '@shapediver/viewer';
-import { IAttribute, IDefaultAttribute, INumberAttribute, IStringAttribute } from '../interfaces/IAttribute';
-import { mat4 } from 'gl-matrix';
-import { Converter, EVENTTYPE, UuidGenerator } from '@shapediver/viewer.shared.services';
-import { IAttributeVisualizationEngine } from '../interfaces/IAttributeVisualizationEngine';
-import { IMaterialAbstractData, ISDTFItemData, ISDTFOverview, MaterialGemData, MaterialShadowData, MaterialSpecularGlossinessData, MaterialStandardData, MaterialUnlitData, SDTFItemData, SdtfPrimitiveTypeGuard } from '@shapediver/viewer.shared.types';
-import { AttributeVisualizationUtils } from './AttributeVisualizationUtils';
-
-export class AttributeVisualizationEngine implements IAttributeVisualizationEngine {
-    // #region Properties (7)
-
-    readonly #uuidGenerator: UuidGenerator = UuidGenerator.instance;
-    readonly #viewport: IViewportApi;
-
-    #attributes: IAttribute[] = [];
-    #defaultMaterial: IMaterialAbstractData = new MaterialUnlitData({ color: '#000000', opacity: 1 });
-    #defaultLayer: ILayer = {
-        color: '#000000',
-        opacity: 1,
-        enabled: true
-    };
-    #layers: {
-        [key: string]: ILayer
-    } = {};
-    #overview: ISDTFOverview;
-    #listeners: {
-        [key: string]: () => void
-    } = {};
-    #visualizedMaterialType: 'unlit' | 'standard' = 'unlit';
-    #layerMaterialType: 'unlit' | 'standard' = 'unlit';
-    #nodesWithAttributeData: ITreeNode[] = [];
-
-    // #endregion Properties (7)
-
-    // #region Constructors (1)
-
-    constructor(viewport: IViewportApi) {
-        this.#viewport = viewport;
-
-        this.#overview = this.#viewport.createSDTFOverview(sceneTree.root);
-        this.createLayers();
-        this.constructAttributeVisualization();
-        this.gatherNodesWithAttributeData();
-        this.#nodesWithAttributeData.forEach(n => this.#viewport.updateNode(n));
-
-        addListener(EVENTTYPE.SESSION.SESSION_CUSTOMIZED, () => {
-            this.#overview = this.#viewport.createSDTFOverview(sceneTree.root);
-            
-            const layers = this.#layers;
-            this.createLayers();
-            for (const l in layers) {
-                if (this.#layers[l])
-                    this.#layers[l] = layers[l];
-            }
-
-            this.constructAttributeVisualization();
-            this.gatherNodesWithAttributeData();
-
-            for (const l in this.#listeners)
-                this.#listeners[l]();
-        });
-    }
-
-    // #endregion Constructors (1)
-
-    // #region Public Accessors (3)
-
-    private gatherNodesWithAttributeData() {
-        this.#nodesWithAttributeData = [];
-
-        sceneTree.root.traverse((node: ITreeNode) => {
-            if (node.data.some(d => d instanceof SDTFItemData)) {
-                this.#nodesWithAttributeData.push(node);
-            }
-        });
-    }
-
-    public get defaultMaterial(): IMaterialAbstractData {
-        return this.#defaultMaterial;
-    }
-
-    public get defaultLayer(): ILayer {
-        return this.#defaultLayer;
-    }
-
-    public get layers(): { [key: string]: ILayer } {
-        return this.#layers;
-    }
-
-    public get layerMaterialType(): 'unlit' | 'standard' {
-        return this.#layerMaterialType;
-    }
-
-    public get visualizedMaterialType(): 'unlit' | 'standard' {
-        return this.#visualizedMaterialType;
-    }
-
-    public get overview(): ISDTFOverview {
-        return this.#overview;
-    }
-
-    // #endregion Public Accessors (3)
-
-    // #region Public Methods (3)
-
-    public updateAttributes(attributes: IAttribute[]) {
-        this.#attributes = attributes;
-        this.constructAttributeVisualization();
-    }
-
-    public updateDefaultLayer(layer: ILayer) {
-        this.#defaultLayer = layer;
-        this.constructAttributeVisualization();
-    }
-
-    public updateDefaultMaterial(material: IMaterialAbstractData) {
-        this.#defaultMaterial = material;
-        this.constructAttributeVisualization();
-    }
-    
-    public updateLayerMaterialType(type: 'unlit' | 'standard') {
-        this.#layerMaterialType = type;
-        this.createLayers();
-        this.constructAttributeVisualization();
-    }
-
-    public updateVisualizedMaterialType(type: 'unlit' | 'standard') {
-        this.#visualizedMaterialType = type;
-        this.createLayers();
-        this.constructAttributeVisualization();
-    }
-
-    public updateLayers(layers: { [key: string]: ILayer }) {
-        this.#layers = layers;
-        this.constructAttributeVisualization();
-    }
-
-    public addListener(cb: () => void): string {
-        const token = this.#uuidGenerator.create();
-        this.#listeners[token] = cb;
-        return token;
-    }
-
-    public removeListener(token: string): boolean {
-        if (!this.#listeners[token]) return false;
-        delete this.#listeners[token];
-        return true;
-    }
-
-    // #endregion Public Methods (3)
-
-    // #region Private Methods (2)
-
-    private constructAttributeVisualization() {
-        this.#viewport.visualizeAttributes = (overview: ISDTFOverview, itemData?: ISDTFItemData) => {
-            // early out if there are not attributes in this itemData
-            if (!itemData || !itemData.attributes) {
-                if (this.#attributes.length === 0) {
-                    // return default layer material
-                    let material;
-                    if(this.#layerMaterialType === 'unlit') {
-                        material = new MaterialUnlitData({
-                            opacity: this.#defaultLayer.enabled ? this.#defaultLayer.opacity : 0,
-                            color: this.#defaultLayer.color
-                        });
-                    } else {
-                        material = new MaterialStandardData({
-                            opacity: this.#defaultLayer.enabled ? this.#defaultLayer.opacity : 0,
-                            color: this.#defaultLayer.color
-                        });
-                    }
-                    return {
-                        matrix: mat4.create(),
-                        material
-                    };
-                } else {
-                    // return default layer material
-                    let material;
-                    if(this.#layerMaterialType === 'unlit') {
-                        material = new MaterialUnlitData({
-                            opacity: this.#defaultLayer.enabled ? this.#defaultLayer.opacity * this.#defaultMaterial.opacity : 0,
-                            color: this.#defaultMaterial.color
-                        });
-                    } else {
-                        material = new MaterialStandardData({
-                            opacity: this.#defaultLayer.enabled ? this.#defaultLayer.opacity * this.#defaultMaterial.opacity : 0,
-                            color: this.#defaultMaterial.color
-                        });
-                    }
-                    return {
-                        matrix: mat4.create(),
-                        material
-                    };
-                }
-            }
-
-            // search for the responsible layer property, if none is found, default layer is assigned
-            let layer: ILayer = this.defaultLayer;
-            if (itemData.attributes['layer'] && SdtfPrimitiveTypeGuard.isStringType(itemData.attributes['layer'].typeHint)) {
-                const layerAttributes = itemData.attributes['layer'];
-                layer = this.#layers[layerAttributes.value];
-            }
-
-            // early out, layer is not enabled
-            if (layer.enabled === false) {
-                const mat = this.createMaterialCopy(this.#defaultMaterial);
-                mat.opacity = 0;
-                return {
-                    matrix: mat4.create(),
-                    material: mat
-                };
-            }
-
-            if (this.#attributes.length === 0) {
-                // no attributes are specified, we go into layer visualization mode
-                let material;
-                if(this.#layerMaterialType === 'unlit') {
-                    material = new MaterialUnlitData({
-                        opacity: layer.opacity,
-                        color: layer.color
-                    });
-                } else {
-                    material = new MaterialStandardData({
-                        opacity: layer.opacity,
-                        color: layer.color
-                    });
-                }
-
-                return {
-                    matrix: mat4.create(),
-                    material
-                };
-            } else {
-                // attributes are specified, we go into attribute visualization mode
-                const material = this.#visualizedMaterialType === 'unlit' ? new MaterialUnlitData() : new MaterialStandardData();
-                for (let i = 0; i < this.#attributes.length; i++) {
-                    const a = this.#attributes[i];
-                    if (itemData.attributes[a.key] && itemData.attributes[a.key].typeHint === a.type) {
-                        const itemDataAttribute = itemData.attributes[a.key];
-                        const itemDataAttributeOverview = overview[a.key].filter(o => o.typeHint === a.type)[0];
-
-                        switch (true) {
-                            case SdtfPrimitiveTypeGuard.isColorType(a.type):
-                                // multiply each color values with 255 to convert them to the range [0, 255]
-                                const convertedValue = itemDataAttribute.value.map((v: number) => v * 255);
-                                material.color = convertedValue;
-                                material.opacity *= layer.opacity;
-                                return {
-                                    matrix: mat4.create(),
-                                    material
-                                };
-                            case SdtfPrimitiveTypeGuard.isNumberType(a.type):
-                                const numberAttribute = <INumberAttribute>a;
-                                const numberVisualizationData = AttributeVisualizationUtils.numberVisualization(
-                                    itemDataAttribute.value,
-                                    (numberAttribute.min !== undefined ? numberAttribute.min : itemDataAttributeOverview.min)!,
-                                    (numberAttribute.max !== undefined ? numberAttribute.max : itemDataAttributeOverview.max)!,
-                                    numberAttribute.visualization,
-                                    this.#visualizedMaterialType,
-                                    this.#defaultMaterial
-                                );
-                                numberVisualizationData.material.opacity *= layer.opacity;
-                                return numberVisualizationData;
-                            case SdtfPrimitiveTypeGuard.isStringType(a.type):
-                                const stringAttribute = <IStringAttribute>a;
-                                const stringVisualizationData = AttributeVisualizationUtils.stringVisualization(
-                                    itemDataAttribute.value,
-                                    stringAttribute.values || itemDataAttributeOverview.values,
-                                    stringAttribute.visualization,
-                                    this.#visualizedMaterialType,
-                                    this.#defaultMaterial
-                                );
-
-                                stringVisualizationData.material.opacity *= layer.opacity;
-                                return stringVisualizationData;
-                            default:
-                                const defaultAttribute = <IDefaultAttribute>a;
-                                material.color = defaultAttribute.color;
-                                material.opacity *= layer.opacity;
-                                return {
-                                    matrix: mat4.create(),
-                                    material
-                                };
-                        }
-                    }
-                }
-
-                // no attributes were found, return the default material adjusted by the layer opacity
-                const mat = this.createMaterialCopy(this.#defaultMaterial);
-                mat.opacity *= layer.opacity;
-                return {
-                    matrix: mat4.create(),
-                    material: mat
-                };
-            }
-        };
-        this.#nodesWithAttributeData.forEach(n => this.#viewport.updateNode(n));
-    }
-
-    private createMaterialCopy(material: IMaterialAbstractData): IMaterialAbstractData {
-        if(material instanceof MaterialGemData) {
-            const newMaterial = new MaterialGemData();
-            newMaterial.copy(material);
-            return newMaterial;
-        } else if(material instanceof MaterialShadowData) {
-            const newMaterial = new MaterialShadowData();
-            newMaterial.copy(material);
-            return newMaterial;
-        } else if(material instanceof MaterialSpecularGlossinessData) {
-            const newMaterial = new MaterialSpecularGlossinessData();
-            newMaterial.copy(material);
-            return newMaterial;
-        } else if(material instanceof MaterialStandardData) {
-            const newMaterial = new MaterialStandardData();
-            newMaterial.copy(material);
-            return newMaterial;
-        } else if(material instanceof MaterialUnlitData) {
-            const newMaterial = new MaterialUnlitData();
-            newMaterial.copy(material);
-            return newMaterial;
-        } else {
-            return new MaterialStandardData();
-        }
-    }
-
-    private createLayers() {
-        this.#layers = {};
-        if (this.#overview['layer']) {
-            const layerStringAttributeOverview = this.#overview['layer'].find(a => a.typeHint === 'string');
-            if (layerStringAttributeOverview && layerStringAttributeOverview.values) {
-                for (let i = 0; i < layerStringAttributeOverview.values.length; i++) {
-                    this.#layers[layerStringAttributeOverview.values[i]] = {
-                        enabled: true,
-                        opacity: 1,
-                        color: this.defaultMaterial.color
-                    };
-                }
-            }
-        }
-    }
-
-    // #endregion Private Methods (2)
-}

package/src/implementation/AttributeVisualizationUtils.ts

@@ -1,196 +0,0 @@
-import { IMaterialAbstractData, ISDTFAttributeVisualizationData, MaterialStandardData, MaterialUnlitData } from "@shapediver/viewer.shared.types";
-import { mat4 } from "gl-matrix";
-import { ATTRIBUTE_VISUALIZATION } from "../interfaces/IAttribute";
-
-
-const grayscaleVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    const color = Math.floor(factor * 255.0);
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + color + ', '  + color + ', ' + color + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + color + ', '  + color + ', ' + color + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const opacityVisualization = (factor: number, materialType: 'unlit' | 'standard', defaultMaterial: IMaterialAbstractData): ISDTFAttributeVisualizationData => {
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: defaultMaterial.color, opacity: factor}) : new MaterialStandardData({color: defaultMaterial.color, opacity: factor}),
-        matrix: mat4.create()
-    }
-}
-
-const blueRedVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    const red = factor * 255.0;
-    const blue = (1 - factor) * 255.0;
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(0) + ', ' + Math.floor(blue) + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(0) + ', ' + Math.floor(blue) + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const blueWhiteRedVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    let red = 255, green = 255, blue = 255;
-
-    if(factor < 0.5) {
-        const remappedFactor = factor / 0.5;
-        red = 255.0 * remappedFactor;
-        green = 255.0 * remappedFactor;
-        blue = 255.0;
-    } else {
-        const remappedFactor = (factor - 0.5) / 0.5;
-        red = 255.0;
-        green = 255.0 * (1 - remappedFactor);
-        blue = 255.0 * (1 - remappedFactor);
-    } 
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const greenRedVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    const red = factor * 255.0;
-    const green = (1 - factor) * 255.0;
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(0) + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(0) + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const greenWhiteRedVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    let red = 255, green = 255, blue = 255;
-
-    if(factor < 0.5) {
-        const remappedFactor = factor / 0.5;
-        red = 255.0 * remappedFactor;
-        green = 255.0;
-        blue = 255.0 * remappedFactor;
-    } else {
-        const remappedFactor = (factor - 0.5) / 0.5;
-        red = 255.0;
-        green = 255.0 * (1 - remappedFactor);
-        blue = 255.0 * (1 - remappedFactor);
-    } 
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const blueGreenRedVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    let red = 255, green = 255, blue = 255;
-
-    if(factor < 0.5) {
-        const remappedFactor = factor / 0.5;
-        red = 0;
-        green = 255.0 * remappedFactor;
-        blue = 255.0 * (1 - remappedFactor);
-    } else {
-        const remappedFactor = (factor - 0.5) / 0.5;
-        red = 255.0 * remappedFactor;
-        green = 255.0 * (1 - remappedFactor);
-        blue = 0;
-    } 
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const blueGreenYellowRedPurpleWhiteVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    let red = 255, green = 255, blue = 255;
-
-    if(factor < 0.2) {
-        const remappedFactor = factor / 0.2;
-        red = 0;
-        green = 255.0 * remappedFactor;
-        blue = 255.0 * (1 - remappedFactor);
-    } else if(factor < 0.4) {
-        const remappedFactor = (factor - 0.2) / 0.2;
-        red = 255.0 * remappedFactor;
-        green = 255.0;
-        blue = 0.0;
-    } else if(factor < 0.6) {
-        const remappedFactor = (factor - 0.4) / 0.2;
-        red = 255.0;
-        green = 255.0 * (1 - remappedFactor)
-        blue = 0.0;
-    } else if(factor < 0.8) {
-        const remappedFactor = (factor - 0.6) / 0.2;
-        red = 255.0;
-        green = 0.0;
-        blue = 255.0 * remappedFactor;
-    } else {
-        const remappedFactor = (factor - 0.8) / 0.2;
-        red = 255.0;
-        green = 255.0 * remappedFactor;
-        blue = 255.0;
-    } 
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}) : new MaterialStandardData({color: 'rgb(' + Math.floor(red) + ', '  + Math.floor(green) + ', ' + Math.floor(blue) + ')', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const hslVisualization = (factor: number, materialType: 'unlit' | 'standard'): ISDTFAttributeVisualizationData => {
-    const hue = factor * 359.99;
-    return {
-        material: materialType === 'unlit' ? new MaterialUnlitData({color: 'hsl(' + Math.floor(hue) + ', 100%, 50%)', opacity: 1}) : new MaterialStandardData({color: 'hsl(' + Math.floor(hue) + ', 100%, 50%)', opacity: 1}),
-        matrix: mat4.create()
-    }
-}
-
-const numberVisualization = (value: number, min: number, max: number, type: ATTRIBUTE_VISUALIZATION, materialType: 'unlit' | 'standard', defaultMaterial: IMaterialAbstractData): ISDTFAttributeVisualizationData => {
-    let factor = (value - min) / (max - min);
-    factor = Math.min(1, Math.max(0, factor))
-
-    switch(type) {
-        case ATTRIBUTE_VISUALIZATION.GRAYSCALE:
-            return grayscaleVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.OPACITY:
-            return opacityVisualization(factor, materialType, defaultMaterial);
-        case ATTRIBUTE_VISUALIZATION.BLUE_RED:
-            return blueRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.BLUE_WHITE_RED:
-            return blueWhiteRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.GREEN_RED:
-            return greenRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.GREEN_WHITE_RED:
-            return greenWhiteRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.BLUE_GREEN_RED:
-            return blueGreenRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.BLUE_GREEN_YELLOW_RED_PURPLE_WHITE:
-            return blueGreenYellowRedPurpleWhiteVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.HSL:
-            return hslVisualization(factor, materialType);
-    }
-}
-
-const stringVisualization = (value: string, values: string[], type: ATTRIBUTE_VISUALIZATION, materialType: 'unlit' | 'standard', defaultMaterial: IMaterialAbstractData): ISDTFAttributeVisualizationData => {
-    let factor = values.indexOf(value) / (values.length - 1);
-    factor = Math.min(1, Math.max(0, factor))
-    switch(type) {
-        case ATTRIBUTE_VISUALIZATION.GRAYSCALE:
-            return grayscaleVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.OPACITY:
-            return opacityVisualization(factor, materialType, defaultMaterial);
-        case ATTRIBUTE_VISUALIZATION.BLUE_RED:
-            return blueRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.BLUE_WHITE_RED:
-            return blueWhiteRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.GREEN_RED:
-            return greenRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.GREEN_WHITE_RED:
-            return greenWhiteRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.BLUE_GREEN_RED:
-            return blueGreenRedVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.BLUE_GREEN_YELLOW_RED_PURPLE_WHITE:
-            return blueGreenYellowRedPurpleWhiteVisualization(factor, materialType);
-        case ATTRIBUTE_VISUALIZATION.HSL:
-            return hslVisualization(factor, materialType);
-    }
-}
-
-export const AttributeVisualizationUtils = {
-    numberVisualization,
-    stringVisualization
-};

package/src/index.ts

@@ -1,21 +0,0 @@
-import { AttributeVisualizationEngine } from "./implementation/AttributeVisualizationEngine";
-import { IAttribute, IColorAttribute, IStringAttribute, INumberAttribute, IDefaultAttribute, ATTRIBUTE_VISUALIZATION } from "./interfaces/IAttribute";
-import { IAttributeVisualizationEngine } from "./interfaces/IAttributeVisualizationEngine";
-import { ILayer } from "./interfaces/ILayer";
-
-export {
-    IAttributeVisualizationEngine, AttributeVisualizationEngine
-}
-
-export {
-    ILayer,
-    IAttribute,
-    IColorAttribute,
-    IStringAttribute,
-    INumberAttribute,
-    IDefaultAttribute
-}
-
-export {
-    ATTRIBUTE_VISUALIZATION
-}

package/src/interfaces/IAttribute.ts

@@ -1,34 +0,0 @@
-import { SDTF_TYPEHINT } from "@shapediver/viewer.shared.types";
-import { vec3 } from "gl-matrix";
-
-export enum ATTRIBUTE_VISUALIZATION {
-    GRAYSCALE = 'grayscale',
-    OPACITY = 'opacity',
-    BLUE_RED = 'blue_red',
-    BLUE_WHITE_RED = 'blue_white_red',
-    GREEN_RED = 'green_red',
-    GREEN_WHITE_RED = 'green_white_red',
-    BLUE_GREEN_RED = 'blue_green_red',
-    BLUE_GREEN_YELLOW_RED_PURPLE_WHITE = 'blue_green_yellow_red_purple_white',
-    HSL = 'hsl'
-}
-export interface IAttribute {
-    key: string,
-    type: SDTF_TYPEHINT,    
-};
-
-export interface IColorAttribute extends IAttribute {};
-
-export interface INumberAttribute extends IAttribute {
-    min: number,
-    max: number,
-    visualization: ATTRIBUTE_VISUALIZATION
-}
-
-export interface IStringAttribute extends IAttribute {
-    values: string[],
-    visualization: ATTRIBUTE_VISUALIZATION
-}
-export interface IDefaultAttribute extends IAttribute {
-    color: string | vec3 | number[]
-}

package/src/interfaces/IAttributeVisualizationEngine.ts

@@ -1,49 +0,0 @@
-import { IMaterialAbstractData, ISDTFOverview } from "@shapediver/viewer.shared.types";
-import { IAttribute } from "./IAttribute";
-import { ILayer } from "./ILayer";
-
-export interface IAttributeVisualizationEngine {
-    // #region Properties (3)
-
-    readonly defaultMaterial: IMaterialAbstractData;
-    readonly layers: { [key: string]: ILayer };
-    readonly overview: ISDTFOverview;
-
-    // #endregion Properties (3)
-
-    // #region Public Methods (5)
-
-    /**
-     * Add a listener that will be called whenever there was an update to the attributes.
-     * Use this listener to update your menu.
-     * @param cb 
-     */
-    addListener(cb: () => void): string;
-
-    /**
-     * Remove a listener.
-     * @param token 
-     */
-    removeListener(token: string): boolean;
-
-    /**
-     * Update the attributes that are used to visualize the geometry.
-     * If an object is present in multiple of the attributes, only the first one will be used.
-     * @param attributes 
-     */
-    updateAttributes(attributes: IAttribute[]): void;
-
-    /**
-     * Update the default material that is used to visualize objects without attributes.
-     * @param material 
-     */
-    updateDefaultMaterial(material: IMaterialAbstractData): void;
-
-    /**
-     * Update the layers, the opacity is multiplied with the attribute visualization opacity.
-     * @param layers 
-     */
-    updateLayers(layers: { [key: string]: ILayer }): void;
-
-    // #endregion Public Methods (5)
-}

package/src/interfaces/ILayer.ts

@@ -1,11 +0,0 @@
-import { Color } from "@shapediver/viewer.shared.types";
-
-export interface ILayer {
-    // #region Properties (2)
-
-    enabled: boolean;
-    opacity: number;
-    color: Color
-
-    // #endregion Properties (2)
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "include": [
-        "./**/*.ts"
-    ],
-    "compilerOptions": {
-        "rootDir": "src",
-        "outDir": "dist"
-    },
-    "exclude": [
-        "__tests__",
-        "node_modules",
-        "dist",
-        "dist-dev",
-        "dist-prod"
-    ]
-}