@combeenation/3d-viewer 14.0.0 → 14.0.1-rc1

package/dist/lib-cjs/internal/geometry-helper.js

@@ -1,146 +1,146 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetTransformation = exports.bakeGeometryOfMesh = exports.createMeshFromInstancedMesh = exports.isNodeExcluded = void 0;
-const index_1 = require("../index");
-const metadata_helper_1 = require("./metadata-helper");
-const tags_helper_1 = require("./tags-helper");
-/**
- * Find out if a node is part of a list of excluded geometry
- * @param node BJS node
- * @param list list of excluded geometry
- * @returns boolean based on whether node (or one of its parents) was found in list
- */
-function isNodeExcluded(nodeToCheck, list) {
-    // CAUTION: node has to be the same instance
-    const checkNode = (excludedNode) => excludedNode === nodeToCheck;
-    const checkTagManagerSubject = (excludedSubject) => {
-        const nameMatches = !!excludedSubject.nodeName && excludedSubject.nodeName === nodeToCheck.name;
-        const tagMatches = !!excludedSubject.tagName && (0, tags_helper_1.hasTag)(nodeToCheck, excludedSubject.tagName);
-        return nameMatches || tagMatches;
-    };
-    const check = (geometryToExclude) => {
-        if (geometryToExclude instanceof index_1.TransformNode) {
-            return checkNode(geometryToExclude);
-        }
-        if (geometryToExclude.tagName || geometryToExclude.nodeName) {
-            return checkTagManagerSubject(geometryToExclude);
-        }
-        return false;
-    };
-    let isExcluded = list.some(geometryToExclude => check(geometryToExclude));
-    // consider parent as well
-    if (!isExcluded && nodeToCheck.parent instanceof index_1.TransformNode) {
-        isExcluded = isNodeExcluded(nodeToCheck.parent, list);
-    }
-    return isExcluded;
-}
-exports.isNodeExcluded = isNodeExcluded;
-/**
- * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
- */
-function createMeshFromInstancedMesh(instancedMesh, newName, clonedParent) {
-    // first create a clone of the source mesh
-    const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
-    (0, metadata_helper_1.cloneInternalMetadata)(instancedMesh.sourceMesh, newMesh);
-    // apply the transformation data, it's important to create clones of the transformations to not touch the original
-    // transformation when applying changes (eg: geometry baking)
-    newMesh.position = instancedMesh.position.clone();
-    newMesh.rotation = instancedMesh.rotation.clone();
-    newMesh.scaling = instancedMesh.scaling.clone();
-    // rotation quaternion is optional
-    if (instancedMesh.rotationQuaternion) {
-        newMesh.rotationQuaternion = instancedMesh.rotationQuaternion.clone();
-    }
-    // also sync the enabled state from the original instanced mesh
-    newMesh.setEnabled(instancedMesh.isEnabled(false));
-    return newMesh;
-}
-exports.createMeshFromInstancedMesh = createMeshFromInstancedMesh;
-/**
- * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
- * Also considers the geometry change from morph targets.
- */
-function bakeGeometryOfMesh(mesh) {
-    if (!mesh.geometry) {
-        // no geometry available, nothing to do
-        return;
-    }
-    // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
-    mesh.makeGeometryUnique();
-    // Babylon.js already provides a function for baking the current skeleton changes into the geometry
-    if (mesh.skeleton) {
-        mesh.applySkeleton(mesh.skeleton);
-        mesh.skeleton = null;
-    }
-    // NOTE: in difference to skeletons and transformations there is no baking function for morph targets (yet)
-    // however another approach could be to re-apply the position and normals data, as there are nice functions for it
-    // - `getPositionData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-    // - `getNormalsData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-    // you can decide if skeletons and morph targets can be added, which is exactly what we want
-    // I'm still hesitant to use it because "tangent" and "UV" kinds are not supported, whereas I'm not sure if it's
-    // required
-    // => try it out when there is enough time for detailed regression tests!
-    const morphTargetManager = mesh.morphTargetManager;
-    const geometry = mesh.geometry;
-    if (morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets) {
-        // apply morph target vertices data to mesh geometry
-        // mostly only the "PositionKind" is implemented
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.PositionKind, morphTargetManager, geometry);
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.NormalKind, morphTargetManager, geometry);
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.TangentKind, morphTargetManager, geometry);
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.UVKind, morphTargetManager, geometry);
-        // remove morph target manager with all it's morph targets
-        mesh.morphTargetManager = null;
-    }
-    // bake the transformation data in the mesh geometry, fortunately there is already a help function from Babylon.js
-    mesh.bakeCurrentTransformIntoVertices();
-}
-exports.bakeGeometryOfMesh = bakeGeometryOfMesh;
-/**
- * Resets transformation to initial state
- */
-function resetTransformation(node) {
-    node.position = new index_1.Vector3(0, 0, 0);
-    node.rotation = new index_1.Vector3(0, 0, 0);
-    node.rotationQuaternion = null;
-    node.scaling = new index_1.Vector3(1, 1, 1);
-}
-exports.resetTransformation = resetTransformation;
-/**
- * @param kind morph targets can affect various vertices kinds, whereas "position" is the most common one
- * still other kinds (like normals or tangents) can be affected as well and can be provided on this input
- */
-function _bakeMorphTargetManagerIntoVertices(kind, morphTargetManager, geometry) {
-    const origVerticesData = geometry.getVerticesData(kind);
-    if (!origVerticesData) {
-        // no vertices data for this kind availabe on the mesh geometry
-        return;
-    }
-    let verticesData = [...origVerticesData];
-    for (let i = 0; i < morphTargetManager.numTargets; i++) {
-        const target = morphTargetManager.getTarget(i);
-        const targetVerticesData = _getVerticesDataFromMorphTarget(kind, target);
-        if (targetVerticesData) {
-            // vertices data of this kind are implemented on the morph target
-            // add the influence of this morph target to the vertices data
-            // formula is taken from: https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets#basics
-            verticesData = verticesData.map((oldVal, idx) => oldVal + (targetVerticesData[idx] - origVerticesData[idx]) * target.influence);
-        }
-    }
-    // apply the updated vertices data
-    geometry.setVerticesData(kind, verticesData);
-}
-function _getVerticesDataFromMorphTarget(kind, morphTarget) {
-    switch (kind) {
-        case index_1.VertexBuffer.PositionKind:
-            return morphTarget.getPositions();
-        case index_1.VertexBuffer.NormalKind:
-            return morphTarget.getNormals();
-        case index_1.VertexBuffer.TangentKind:
-            return morphTarget.getTangents();
-        case index_1.VertexBuffer.UVKind:
-            return morphTarget.getUVs();
-    }
-    return null;
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetTransformation = exports.bakeGeometryOfMesh = exports.createMeshFromInstancedMesh = exports.isNodeExcluded = void 0;
+const index_1 = require("../index");
+const metadata_helper_1 = require("./metadata-helper");
+const tags_helper_1 = require("./tags-helper");
+/**
+ * Find out if a node is part of a list of excluded geometry
+ * @param node BJS node
+ * @param list list of excluded geometry
+ * @returns boolean based on whether node (or one of its parents) was found in list
+ */
+function isNodeExcluded(nodeToCheck, list) {
+    // CAUTION: node has to be the same instance
+    const checkNode = (excludedNode) => excludedNode === nodeToCheck;
+    const checkTagManagerSubject = (excludedSubject) => {
+        const nameMatches = !!excludedSubject.nodeName && excludedSubject.nodeName === nodeToCheck.name;
+        const tagMatches = !!excludedSubject.tagName && (0, tags_helper_1.hasTag)(nodeToCheck, excludedSubject.tagName);
+        return nameMatches || tagMatches;
+    };
+    const check = (geometryToExclude) => {
+        if (geometryToExclude instanceof index_1.TransformNode) {
+            return checkNode(geometryToExclude);
+        }
+        if (geometryToExclude.tagName || geometryToExclude.nodeName) {
+            return checkTagManagerSubject(geometryToExclude);
+        }
+        return false;
+    };
+    let isExcluded = list.some(geometryToExclude => check(geometryToExclude));
+    // consider parent as well
+    if (!isExcluded && nodeToCheck.parent instanceof index_1.TransformNode) {
+        isExcluded = isNodeExcluded(nodeToCheck.parent, list);
+    }
+    return isExcluded;
+}
+exports.isNodeExcluded = isNodeExcluded;
+/**
+ * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
+ */
+function createMeshFromInstancedMesh(instancedMesh, newName, clonedParent) {
+    // first create a clone of the source mesh
+    const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
+    (0, metadata_helper_1.cloneInternalMetadata)(instancedMesh.sourceMesh, newMesh);
+    // apply the transformation data, it's important to create clones of the transformations to not touch the original
+    // transformation when applying changes (eg: geometry baking)
+    newMesh.position = instancedMesh.position.clone();
+    newMesh.rotation = instancedMesh.rotation.clone();
+    newMesh.scaling = instancedMesh.scaling.clone();
+    // rotation quaternion is optional
+    if (instancedMesh.rotationQuaternion) {
+        newMesh.rotationQuaternion = instancedMesh.rotationQuaternion.clone();
+    }
+    // also sync the enabled state from the original instanced mesh
+    newMesh.setEnabled(instancedMesh.isEnabled(false));
+    return newMesh;
+}
+exports.createMeshFromInstancedMesh = createMeshFromInstancedMesh;
+/**
+ * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
+ * Also considers the geometry change from morph targets.
+ */
+function bakeGeometryOfMesh(mesh) {
+    if (!mesh.geometry) {
+        // no geometry available, nothing to do
+        return;
+    }
+    // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
+    mesh.makeGeometryUnique();
+    // Babylon.js already provides a function for baking the current skeleton changes into the geometry
+    if (mesh.skeleton) {
+        mesh.applySkeleton(mesh.skeleton);
+        mesh.skeleton = null;
+    }
+    // NOTE: in difference to skeletons and transformations there is no baking function for morph targets (yet)
+    // however another approach could be to re-apply the position and normals data, as there are nice functions for it
+    // - `getPositionData(applySkeleton: boolean = false, applyMorph: boolean = false)`
+    // - `getNormalsData(applySkeleton: boolean = false, applyMorph: boolean = false)`
+    // you can decide if skeletons and morph targets can be added, which is exactly what we want
+    // I'm still hesitant to use it because "tangent" and "UV" kinds are not supported, whereas I'm not sure if it's
+    // required
+    // => try it out when there is enough time for detailed regression tests!
+    const morphTargetManager = mesh.morphTargetManager;
+    const geometry = mesh.geometry;
+    if (morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets) {
+        // apply morph target vertices data to mesh geometry
+        // mostly only the "PositionKind" is implemented
+        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.PositionKind, morphTargetManager, geometry);
+        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.NormalKind, morphTargetManager, geometry);
+        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.TangentKind, morphTargetManager, geometry);
+        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.UVKind, morphTargetManager, geometry);
+        // remove morph target manager with all it's morph targets
+        mesh.morphTargetManager = null;
+    }
+    // bake the transformation data in the mesh geometry, fortunately there is already a help function from Babylon.js
+    mesh.bakeCurrentTransformIntoVertices();
+}
+exports.bakeGeometryOfMesh = bakeGeometryOfMesh;
+/**
+ * Resets transformation to initial state
+ */
+function resetTransformation(node) {
+    node.position = new index_1.Vector3(0, 0, 0);
+    node.rotation = new index_1.Vector3(0, 0, 0);
+    node.rotationQuaternion = null;
+    node.scaling = new index_1.Vector3(1, 1, 1);
+}
+exports.resetTransformation = resetTransformation;
+/**
+ * @param kind morph targets can affect various vertices kinds, whereas "position" is the most common one
+ * still other kinds (like normals or tangents) can be affected as well and can be provided on this input
+ */
+function _bakeMorphTargetManagerIntoVertices(kind, morphTargetManager, geometry) {
+    const origVerticesData = geometry.getVerticesData(kind);
+    if (!origVerticesData) {
+        // no vertices data for this kind availabe on the mesh geometry
+        return;
+    }
+    let verticesData = [...origVerticesData];
+    for (let i = 0; i < morphTargetManager.numTargets; i++) {
+        const target = morphTargetManager.getTarget(i);
+        const targetVerticesData = _getVerticesDataFromMorphTarget(kind, target);
+        if (targetVerticesData) {
+            // vertices data of this kind are implemented on the morph target
+            // add the influence of this morph target to the vertices data
+            // formula is taken from: https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets#basics
+            verticesData = verticesData.map((oldVal, idx) => oldVal + (targetVerticesData[idx] - origVerticesData[idx]) * target.influence);
+        }
+    }
+    // apply the updated vertices data
+    geometry.setVerticesData(kind, verticesData);
+}
+function _getVerticesDataFromMorphTarget(kind, morphTarget) {
+    switch (kind) {
+        case index_1.VertexBuffer.PositionKind:
+            return morphTarget.getPositions();
+        case index_1.VertexBuffer.NormalKind:
+            return morphTarget.getNormals();
+        case index_1.VertexBuffer.TangentKind:
+            return morphTarget.getTangents();
+        case index_1.VertexBuffer.UVKind:
+            return morphTarget.getUVs();
+    }
+    return null;
+}
 //# sourceMappingURL=geometry-helper.js.map

package/dist/lib-cjs/internal/metadata-helper.d.ts

@@ -1,26 +1,26 @@
-import { BaseTexture, Material, Node } from '../index';
-declare type MetadataValue = string | number | boolean | undefined;
-declare type MetadataTarget = Node | Material | BaseTexture;
-declare type MetadataKeys = 'deferredMaterial' | 'materialToBeSet' | 'exportNode' | 'deleteAfterExport' | 'exchangeMaterialWith' | 'cloneSource' | 'cloneTarget';
-/**
- * Sets certain metadata on the objects INTERNAL metadata storage.
- * "object._internalMetadata.cbn" is reserved for CBN specific metadata information.
- * The objects public metadata ("object.metadata") is not affected and should therefore not interfere with metadata
- * that is used in consumer projects.
- */
-export declare function setInternalMetadataValue(object: MetadataTarget, key: MetadataKeys, value: MetadataValue): void;
-export declare function clearInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): void;
-export declare function getInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): MetadataValue;
-/**
- * Creates a deep clone from the source objects internal metadata and assigns it to the target objects metadata.
- * This is required as Babylon.js only creates shallow clones of the internal metadata, which would be problematic for
- * our needs.
- */
-export declare function cloneInternalMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void;
-/**
- * Clones the metadata from one object to another.
- * CAUTION: this is now the public available "object.metadata" object.
- * We need this function internally when cloning instanced meshes.
- */
-export declare function cloneMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void;
-export {};
+import { BaseTexture, Material, Node } from '../index';
+declare type MetadataValue = string | number | boolean | undefined;
+declare type MetadataTarget = Node | Material | BaseTexture;
+declare type MetadataKeys = 'deferredMaterial' | 'materialToBeSet' | 'exportNode' | 'deleteAfterExport' | 'exchangeMaterialWith' | 'cloneSource' | 'cloneTarget';
+/**
+ * Sets certain metadata on the objects INTERNAL metadata storage.
+ * "object._internalMetadata.cbn" is reserved for CBN specific metadata information.
+ * The objects public metadata ("object.metadata") is not affected and should therefore not interfere with metadata
+ * that is used in consumer projects.
+ */
+export declare function setInternalMetadataValue(object: MetadataTarget, key: MetadataKeys, value: MetadataValue): void;
+export declare function clearInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): void;
+export declare function getInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): MetadataValue;
+/**
+ * Creates a deep clone from the source objects internal metadata and assigns it to the target objects metadata.
+ * This is required as Babylon.js only creates shallow clones of the internal metadata, which would be problematic for
+ * our needs.
+ */
+export declare function cloneInternalMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void;
+/**
+ * Clones the metadata from one object to another.
+ * CAUTION: this is now the public available "object.metadata" object.
+ * We need this function internally when cloning instanced meshes.
+ */
+export declare function cloneMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void;
+export {};

package/dist/lib-cjs/internal/metadata-helper.js

@@ -1,51 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cloneMetadata = exports.cloneInternalMetadata = exports.getInternalMetadataValue = exports.clearInternalMetadataValue = exports.setInternalMetadataValue = void 0;
-const lodash_es_1 = require("lodash-es");
-// TODO WTT: use generics or some kind of logic that is able to type the metadata according to their key
-/**
- * Sets certain metadata on the objects INTERNAL metadata storage.
- * "object._internalMetadata.cbn" is reserved for CBN specific metadata information.
- * The objects public metadata ("object.metadata") is not affected and should therefore not interfere with metadata
- * that is used in consumer projects.
- */
-function setInternalMetadataValue(object, key, value) {
-    if (!object._internalMetadata) {
-        object._internalMetadata = {};
-    }
-    if (!object._internalMetadata.cbn) {
-        object._internalMetadata.cbn = {};
-    }
-    object._internalMetadata.cbn[key] = value;
-}
-exports.setInternalMetadataValue = setInternalMetadataValue;
-function clearInternalMetadataValue(object, key) {
-    var _a, _b;
-    (_b = (_a = object._internalMetadata) === null || _a === void 0 ? void 0 : _a.cbn) === null || _b === void 0 ? true : delete _b[key];
-}
-exports.clearInternalMetadataValue = clearInternalMetadataValue;
-function getInternalMetadataValue(object, key) {
-    var _a, _b;
-    return (_b = (_a = object._internalMetadata) === null || _a === void 0 ? void 0 : _a.cbn) === null || _b === void 0 ? void 0 : _b[key];
-}
-exports.getInternalMetadataValue = getInternalMetadataValue;
-/**
- * Creates a deep clone from the source objects internal metadata and assigns it to the target objects metadata.
- * This is required as Babylon.js only creates shallow clones of the internal metadata, which would be problematic for
- * our needs.
- */
-function cloneInternalMetadata(sourceObject, targetObject) {
-    targetObject._internalMetadata = (0, lodash_es_1.cloneDeep)(sourceObject._internalMetadata);
-}
-exports.cloneInternalMetadata = cloneInternalMetadata;
-/**
- * Clones the metadata from one object to another.
- * CAUTION: this is now the public available "object.metadata" object.
- * We need this function internally when cloning instanced meshes.
- */
-function cloneMetadata(sourceObject, targetObject) {
-    const clonedMetadata = (0, lodash_es_1.cloneDeep)(sourceObject.metadata);
-    targetObject.metadata = clonedMetadata;
-}
-exports.cloneMetadata = cloneMetadata;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneMetadata = exports.cloneInternalMetadata = exports.getInternalMetadataValue = exports.clearInternalMetadataValue = exports.setInternalMetadataValue = void 0;
+const lodash_es_1 = require("lodash-es");
+// TODO WTT: use generics or some kind of logic that is able to type the metadata according to their key
+/**
+ * Sets certain metadata on the objects INTERNAL metadata storage.
+ * "object._internalMetadata.cbn" is reserved for CBN specific metadata information.
+ * The objects public metadata ("object.metadata") is not affected and should therefore not interfere with metadata
+ * that is used in consumer projects.
+ */
+function setInternalMetadataValue(object, key, value) {
+    if (!object._internalMetadata) {
+        object._internalMetadata = {};
+    }
+    if (!object._internalMetadata.cbn) {
+        object._internalMetadata.cbn = {};
+    }
+    object._internalMetadata.cbn[key] = value;
+}
+exports.setInternalMetadataValue = setInternalMetadataValue;
+function clearInternalMetadataValue(object, key) {
+    var _a, _b;
+    (_b = (_a = object._internalMetadata) === null || _a === void 0 ? void 0 : _a.cbn) === null || _b === void 0 ? true : delete _b[key];
+}
+exports.clearInternalMetadataValue = clearInternalMetadataValue;
+function getInternalMetadataValue(object, key) {
+    var _a, _b;
+    return (_b = (_a = object._internalMetadata) === null || _a === void 0 ? void 0 : _a.cbn) === null || _b === void 0 ? void 0 : _b[key];
+}
+exports.getInternalMetadataValue = getInternalMetadataValue;
+/**
+ * Creates a deep clone from the source objects internal metadata and assigns it to the target objects metadata.
+ * This is required as Babylon.js only creates shallow clones of the internal metadata, which would be problematic for
+ * our needs.
+ */
+function cloneInternalMetadata(sourceObject, targetObject) {
+    targetObject._internalMetadata = (0, lodash_es_1.cloneDeep)(sourceObject._internalMetadata);
+}
+exports.cloneInternalMetadata = cloneInternalMetadata;
+/**
+ * Clones the metadata from one object to another.
+ * CAUTION: this is now the public available "object.metadata" object.
+ * We need this function internally when cloning instanced meshes.
+ */
+function cloneMetadata(sourceObject, targetObject) {
+    const clonedMetadata = (0, lodash_es_1.cloneDeep)(sourceObject.metadata);
+    targetObject.metadata = clonedMetadata;
+}
+exports.cloneMetadata = cloneMetadata;
 //# sourceMappingURL=metadata-helper.js.map

package/dist/lib-cjs/internal/paintable-helper.d.ts

@@ -1,40 +1,40 @@
-import { Material, ParameterValue, Scene } from '../index';
-declare type PaintableValue = {
-    src: string;
-    options?: PaintableOptions;
-};
-declare type PaintableOptions = {
-    uScale?: number;
-    uOffset?: number;
-    vScale?: number;
-    vOffset?: number;
-};
-/**
- * Observer implementation for "paintable" parameter.
- * Basically creates a dynamic texture from the source image and assigns it as albedo (or diffuse) texture.
- */
-export declare function paintableParameterObserver(newValue: ParameterValue, materials: Material[], scene: Scene): Promise<void>;
-/**
- * Parser for paintable value.
- * ATM this is only used internally, but it could theoretically be used to create ones own paintable implementation.
- *
- * @param value The value to parse. Examples:
- *              ```ts
- *              // Default definition as JSON object:
- *              '{ "src": "https://path.to/image.jpg", "uScale": 0.5 }'
- *
- *              // Short hand definition, only contains source string:
- *              'https://path.to/image.jpg'
- *
- *              // Full content, paintable texture is flipped in both directions
- *              '{ "src": "https://path.to/image.jpg", "uScale": -1, "vScale": -1, "uOffset": 0, "vOffset": 0 }'
- *
- *              // SVG content can be used directly:
- *              '<svg>...</svg>'
- *
- *              // SVG in src property works as well:
- *              '{ "src": "<svg>...</svg>", "uScale": 0.5 }'
- *              ```
- */
-export declare function parsePaintable(value: ParameterValue): PaintableValue;
-export {};
+import { Material, ParameterValue, Scene } from '../index';
+declare type PaintableValue = {
+    src: string;
+    options?: PaintableOptions;
+};
+declare type PaintableOptions = {
+    uScale?: number;
+    uOffset?: number;
+    vScale?: number;
+    vOffset?: number;
+};
+/**
+ * Observer implementation for "paintable" parameter.
+ * Basically creates a dynamic texture from the source image and assigns it as albedo (or diffuse) texture.
+ */
+export declare function paintableParameterObserver(newValue: ParameterValue, materials: Material[], scene: Scene): Promise<void>;
+/**
+ * Parser for paintable value.
+ * ATM this is only used internally, but it could theoretically be used to create ones own paintable implementation.
+ *
+ * @param value The value to parse. Examples:
+ *              ```ts
+ *              // Default definition as JSON object:
+ *              '{ "src": "https://path.to/image.jpg", "uScale": 0.5 }'
+ *
+ *              // Short hand definition, only contains source string:
+ *              'https://path.to/image.jpg'
+ *
+ *              // Full content, paintable texture is flipped in both directions
+ *              '{ "src": "https://path.to/image.jpg", "uScale": -1, "vScale": -1, "uOffset": 0, "vOffset": 0 }'
+ *
+ *              // SVG content can be used directly:
+ *              '<svg>...</svg>'
+ *
+ *              // SVG in src property works as well:
+ *              '{ "src": "<svg>...</svg>", "uScale": 0.5 }'
+ *              ```
+ */
+export declare function parsePaintable(value: ParameterValue): PaintableValue;
+export {};