vim-web 0.3.23 → 0.3.25

package/dist/types/webgl-viewer/vim-loader/geometry.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { G3d, MeshSection } from 'vim-format';
+export type MergeArgs = {
+    matrix: THREE.Matrix4;
+    section: MeshSection;
+    legacyInstances: number[];
+    legacyLoadRooms: boolean;
+    transparent: boolean;
+};
+export declare namespace Transparency {
+    /**
+     * Determines how to draw (or not) transparent and opaque objects
+     */
+    type Mode = 'opaqueOnly' | 'transparentOnly' | 'allAsOpaque' | 'all';
+    /**
+     * Returns true if the transparency mode is one of the valid values
+     */
+    function isValid(value: string | undefined | null): value is Mode;
+    /**
+     * Returns true if the transparency mode requires to use RGBA colors
+     */
+    function requiresAlpha(mode: Mode): mode is "all" | "transparentOnly";
+}
+export declare namespace Geometry {
+    /**
+     * Creates a BufferGeometry with all given instances merged
+     * @param instances indices of the instances from the g3d to merge
+     * @returns a BufferGeometry
+     */
+    function createGeometryFromInstances(g3d: G3d, args: MergeArgs): THREE.BufferGeometry;
+    /**
+     * Creates a BufferGeometry from a given mesh index in the g3d
+     * @param mesh g3d mesh index
+     * @param transparent specify to use RGB or RGBA for colors
+     */
+    function createGeometryFromMesh(g3d: G3d, mesh: number, section: MeshSection, transparent: boolean): THREE.BufferGeometry;
+    /**
+     * Returns a THREE.Matrix4 from the g3d for given instance
+     * @param instance g3d instance index
+     * @param target matrix where the data will be copied, a new matrix will be created if none provided.
+     */
+    function getInstanceMatrix(g3d: G3d, instance: number, target?: THREE.Matrix4): THREE.Matrix4;
+    /**
+     * Creates a BufferGeometry from given geometry data arrays
+     * @param vertices vertex data with 3 number per vertex (XYZ)
+     * @param indices index data with 3 indices per face
+     * @param vertexColors color data with 3 or 4 number per vertex. RBG or RGBA
+     * @param colorSize specify whether to treat colors as RGB or RGBA
+     * @returns a BufferGeometry
+     */
+    function createGeometryFromArrays(vertices: Float32Array, indices: Uint32Array, vertexColors?: Float32Array | undefined, colorSize?: number): THREE.BufferGeometry;
+    /**
+     * Returns a merged mesh of all meshes related to given instances along with picking related metadata
+     * Returns undefined if mesh would be empty
+     * @param section mesh sections to include in the merged mesh.
+     * @param transparent true to use a transparent material.
+     * @param instances instances for which to merge meshes.
+     */
+    function mergeInstanceMeshes(g3d: G3d, mergeArgs: MergeArgs): MergeResult;
+    /**
+     * Returns a merged mesh of all unique meshes along with picking related metadata
+     * @param section mesh sections to include in the merged mesh.
+     * @param transparent true to use a transparent material.
+     * @param instances instances for which to merge meshes.
+     */
+    function mergeUniqueMeshes(g3d: G3d, args: MergeArgs): MergeResult;
+    /**
+     * Holds the info that needs to be precomputed for a merge.
+     */
+    class MergeInfo {
+        section: MeshSection;
+        transparent: boolean;
+        instances: number[];
+        indexCount: number;
+        vertexCount: number;
+        constructor(section: MeshSection, transparent: boolean, instance: number[], indexCount: number, vertexCount: number);
+        createBuffer(): MergeBuffer;
+    }
+    /**
+     * Allocates and holds all arrays needed to merge meshes.
+     */
+    class MergeBuffer {
+        indices: Uint32Array;
+        vertices: Float32Array;
+        colors: Float32Array;
+        groups: number[];
+        colorSize: number;
+        boxes: THREE.Box3[];
+        constructor(info: MergeInfo, positionSize: number, colorSize: number);
+        toBufferGeometry(): THREE.BufferGeometry;
+    }
+    /**
+     * Holds the result from a merge operation.
+     */
+    class MergeResult {
+        geometry: THREE.BufferGeometry;
+        instances: number[];
+        submeshes: number[];
+        boxes: THREE.Box3[];
+        constructor(geometry: THREE.BufferGeometry, instance: number[], submeshes: number[], boxes: THREE.Box3[]);
+    }
+}

package/dist/types/webgl-viewer/vim-loader/materials/isolationMaterial.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/**
+ * Material for isolation mode
+ * Non visible item appear as transparent.
+ * Visible items are flat shaded with a basic pseudo lighting.
+ * Supports object coloring for visible objects.
+ * Non-visible objects use fillColor.
+ */
+export declare function createIsolationMaterial(): THREE.ShaderMaterial;

package/dist/types/webgl-viewer/vim-loader/materials/maskMaterial.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/**
+ * Material used for selection outline it only renders selection in white and discards the rests.
+ */
+export declare function createMaskMaterial(): THREE.ShaderMaterial;

package/dist/types/webgl-viewer/vim-loader/materials/mergeMaterial.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+export declare class MergeMaterial {
+    material: THREE.ShaderMaterial;
+    constructor();
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get sourceA(): THREE.Texture;
+    set sourceA(value: THREE.Texture);
+    get sourceB(): THREE.Texture;
+    set sourceB(value: THREE.Texture);
+}
+/**
+ * Material that Merges current fragment with a source texture.
+ */
+export declare function createMergeMaterial(): THREE.ShaderMaterial;

package/dist/types/webgl-viewer/vim-loader/materials/outlineMaterial.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/** Outline Material based on edge detection. */
+export declare class OutlineMaterial {
+    material: THREE.ShaderMaterial;
+    private _camera;
+    private _resolution;
+    constructor(options?: Partial<{
+        sceneBuffer: THREE.Texture;
+        resolution: THREE.Vector2;
+        camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    }>);
+    get resolution(): THREE.Vector2;
+    set resolution(value: THREE.Vector2);
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera | undefined;
+    set camera(value: THREE.PerspectiveCamera | THREE.OrthographicCamera | undefined);
+    get strokeBlur(): number;
+    set strokeBlur(value: number);
+    get strokeBias(): number;
+    set strokeBias(value: number);
+    get strokeMultiplier(): number;
+    set strokeMultiplier(value: number);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get sceneBuffer(): THREE.Texture;
+    set sceneBuffer(value: THREE.Texture);
+    get depthBuffer(): THREE.Texture;
+    set depthBuffer(value: THREE.Texture);
+    dispose(): void;
+}
+/**
+ * This material =computes outline using the depth buffer and combines it with the scene buffer to create a final scene.
+ */
+export declare function createOutlineMaterial(): THREE.ShaderMaterial;

package/dist/types/webgl-viewer/vim-loader/materials/simpleMaterial.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/**
+ * Material for isolation mode
+ * Non visible item appear as transparent.
+ * Visible items are flat shaded with a basic pseudo lighting.
+ * Supports object coloring for visible objects.
+ * Non-visible objects use fillColor.
+ */
+export declare function createSimpleMaterial(): THREE.ShaderMaterial;

package/dist/types/webgl-viewer/vim-loader/materials/skyboxMaterial.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/**
+ * Material for the skybox
+ */
+export declare class SkyboxMaterial extends THREE.ShaderMaterial {
+    get skyColor(): THREE.Color;
+    set skyColor(value: THREE.Color);
+    get groundColor(): THREE.Color;
+    set groundColor(value: THREE.Color);
+    get sharpness(): number;
+    set sharpness(value: number);
+    constructor(skyColor?: THREE.Color, groundColor?: THREE.Color, sharpness?: number);
+}

package/dist/types/webgl-viewer/vim-loader/materials/standardMaterial.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/**
+ * Type alias for THREE uniforms
+ */
+export type ShaderUniforms = {
+    [uniform: string]: THREE.IUniform<any>;
+};
+export declare function createOpaque(): StandardMaterial;
+export declare function createTransparent(): StandardMaterial;
+/**
+ * Creates a new instance of the default loader opaque material.
+ * @returns {THREE.MeshPhongMaterial} A new instance of MeshPhongMaterial with transparency.
+ */
+export declare function createBasicOpaque(): THREE.MeshPhongMaterial;
+/**
+ * Creates a new instance of the default loader transparent material.
+ * @returns {THREE.MeshPhongMaterial} A new instance of MeshPhongMaterial with transparency.
+ */
+export declare function createBasicTransparent(): THREE.MeshPhongMaterial;
+/**
+ * Material used for both opaque and tranparent surfaces of a VIM model.
+ */
+export declare class StandardMaterial {
+    material: THREE.MeshPhongMaterial;
+    uniforms: ShaderUniforms | undefined;
+    _focusIntensity: number;
+    _focusColor: THREE.Color;
+    _sectionStrokeWitdh: number;
+    _sectionStrokeFallof: number;
+    _sectionStrokeColor: THREE.Color;
+    constructor(material: THREE.MeshPhongMaterial);
+    get color(): THREE.Color;
+    set color(color: THREE.Color);
+    get focusIntensity(): number;
+    set focusIntensity(value: number);
+    get focusColor(): THREE.Color;
+    set focusColor(value: THREE.Color);
+    get sectionStrokeWitdh(): number;
+    set sectionStrokeWitdh(value: number);
+    get sectionStrokeFallof(): number;
+    set sectionStrokeFallof(value: number);
+    get sectionStrokeColor(): THREE.Color;
+    set sectionStrokeColor(value: THREE.Color);
+    get clippingPlanes(): THREE.Plane[] | null;
+    set clippingPlanes(value: THREE.Plane[] | null);
+    dispose(): void;
+    /**
+     * Patches phong shader to be able to control when lighting should be applied to resulting color.
+     * Instanced meshes ignore light when InstanceColor is defined
+     * Instanced meshes ignore vertex color when instance attribute useVertexColor is 0
+     * Regular meshes ignore light in favor of vertex color when uv.y = 0
+     */
+    patchShader(material: THREE.Material): void;
+}

package/dist/types/webgl-viewer/vim-loader/materials/transferMaterial.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+/**
+ * This material simply sample and returns the value at each texel position of the texture.
+ */
+export declare function createTransferMaterial(): THREE.ShaderMaterial;

package/dist/types/webgl-viewer/vim-loader/materials/viewerMaterials.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @module vim-loader/materials
+ */
+import * as THREE from 'three';
+import { StandardMaterial } from './standardMaterial';
+import { OutlineMaterial } from './outlineMaterial';
+import { ViewerSettings } from '../../vim-webgl-viewer/settings/viewerSettings';
+import { MergeMaterial } from './mergeMaterial';
+import { SkyboxMaterial } from './skyboxMaterial';
+/**
+ * Defines the materials to be used by the vim loader and allows for material injection.
+ */
+export declare class ViewerMaterials {
+    static instance: ViewerMaterials;
+    static createInstance(instance: ViewerMaterials): void;
+    static getInstance(): ViewerMaterials;
+    /**
+     * Material used for opaque model geometry.
+     */
+    readonly opaque: StandardMaterial;
+    /**
+     * Material used for transparent model geometry.
+     */
+    readonly transparent: StandardMaterial;
+    /**
+     * Material used for maximum performance.
+     */
+    readonly simple: THREE.Material;
+    /**
+     * Material used when creating wireframe geometry of the model.
+     */
+    readonly wireframe: THREE.LineBasicMaterial;
+    /**
+     * Material used to show traces of hidden objects.
+     */
+    readonly isolation: THREE.Material;
+    /**
+     * Material used to filter out what is not selected for selection outline effect.
+     */
+    readonly mask: THREE.ShaderMaterial;
+    /**
+     * Material used for selection outline effect.
+     */
+    readonly outline: OutlineMaterial;
+    /**
+     * Material used for the skybox effect.
+     */
+    readonly skyBox: SkyboxMaterial;
+    /**
+     * Material used to merge outline effect with scene render.
+     */
+    readonly merge: MergeMaterial;
+    private _clippingPlanes;
+    private _sectionStrokeWitdh;
+    private _sectionStrokeFallof;
+    private _sectionStrokeColor;
+    private _focusIntensity;
+    private _focusColor;
+    private _onUpdate;
+    constructor(opaque?: StandardMaterial, transparent?: StandardMaterial, simple?: THREE.Material, wireframe?: THREE.LineBasicMaterial, isolation?: THREE.Material, mask?: THREE.ShaderMaterial, outline?: OutlineMaterial, merge?: MergeMaterial, skyBox?: SkyboxMaterial);
+    /**
+     * Updates material settings based on the provided configuration.
+     * @param {ViewerSettings} settings - The settings to apply to the materials.
+     */
+    applySettings(settings: ViewerSettings): void;
+    /**
+     * A signal dispatched whenever a material is modified.
+     */
+    get onUpdate(): import("ste-signals").ISignal;
+    /**
+     * Determines the color of the model regular opaque and transparent materials.
+     */
+    get modelColor(): THREE.Color;
+    set modelColor(color: THREE.Color);
+    /**
+     * Determines the opacity of the isolation material.
+     */
+    get isolationOpacity(): number;
+    set isolationOpacity(opacity: number);
+    /**
+     * Determines the color of the isolation material.
+     */
+    get isolationColor(): THREE.Color;
+    set isolationColor(color: THREE.Color);
+    /**
+     * Determines the color intensity of the highlight effect on mouse hover.
+     */
+    get focusIntensity(): number;
+    set focusIntensity(value: number);
+    /**
+     * Determines the color of the highlight effect on mouse hover.
+     */
+    get focusColor(): THREE.Color;
+    set focusColor(value: THREE.Color);
+    /**
+     * Determines the color of wireframe meshes.
+     */
+    get wireframeColor(): THREE.Color;
+    set wireframeColor(value: THREE.Color);
+    /**
+     * Determines the opacity of wireframe meshes.
+     */
+    get wireframeOpacity(): number;
+    set wireframeOpacity(value: number);
+    /**
+     * The clipping planes applied to all relevent materials
+     */
+    get clippingPlanes(): THREE.Plane[] | undefined;
+    set clippingPlanes(value: THREE.Plane[] | undefined);
+    /**
+     * The width of the stroke effect where the section box intersects the model.
+     */
+    get sectionStrokeWitdh(): number;
+    set sectionStrokeWitdh(value: number);
+    /**
+     * Gradient of the stroke effect where the section box intersects the model.
+     */
+    get sectionStrokeFallof(): number;
+    set sectionStrokeFallof(value: number);
+    /**
+     * Color of the stroke effect where the section box intersects the model.
+     */
+    get sectionStrokeColor(): THREE.Color;
+    set sectionStrokeColor(value: THREE.Color);
+    /**
+     * Color of the selection outline effect.
+     */
+    get outlineColor(): THREE.Color;
+    set outlineColor(value: THREE.Color);
+    /**
+     * Size of the blur convolution on the selection outline effect.
+     */
+    get outlineBlur(): number;
+    set outlineBlur(value: number);
+    /**
+     * Gradient of the the selection outline effect.
+     */
+    get outlineFalloff(): number;
+    set outlineFalloff(value: number);
+    /**
+     * Intensity of the the selection outline effect.
+     */
+    get outlineIntensity(): number;
+    set outlineIntensity(value: number);
+    get skyboxSkyColor(): THREE.Color;
+    set skyboxSkyColor(value: THREE.Color);
+    get skyboxGroundColor(): THREE.Color;
+    set skyboxGroundColor(value: THREE.Color);
+    get skyboxSharpness(): number;
+    set skyboxSharpness(value: number);
+    /** dispose all materials. */
+    dispose(): void;
+}
+/**
+ * Creates a new instance of the default wireframe material.
+ * @returns {THREE.LineBasicMaterial} A new instance of LineBasicMaterial.
+ */
+export declare function createWireframe(): THREE.LineBasicMaterial;

package/dist/types/webgl-viewer/vim-loader/mesh.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { InsertableSubmesh } from './progressive/insertableSubmesh';
+import { Vim } from './vim';
+import { InstancedSubmesh } from './progressive/instancedSubmesh';
+/**
+ * Wrapper around THREE.Mesh
+ * Keeps track of what VIM instances are part of this mesh.
+ * Is either merged on instanced.
+ */
+export declare class Mesh {
+    /**
+     * the wrapped THREE mesh
+     */
+    mesh: THREE.Mesh;
+    /**
+     * Vim file from which this mesh was created.
+     */
+    vim: Vim | undefined;
+    /**
+     * Whether the mesh is merged or not.
+     */
+    merged: boolean;
+    /**
+     * Indices of the g3d instances that went into creating the mesh
+     */
+    instances: number[];
+    /**
+     * startPosition of each submesh on a merged mesh.
+     */
+    submeshes: number[];
+    /**
+     * bounding box of each instance
+     */
+    boxes: THREE.Box3[];
+    /**
+     * Set to true to ignore SetMaterial calls.
+     */
+    ignoreSceneMaterial: boolean;
+    /**
+     * Total bounding box for this mesh.
+     */
+    boundingBox: THREE.Box3;
+    /**
+     * initial material.
+     */
+    private _material;
+    private constructor();
+    static createMerged(mesh: THREE.Mesh, instances: number[], boxes: THREE.Box3[], submeshes: number[]): Mesh;
+    static createInstanced(mesh: THREE.Mesh, instances: number[], boxes: THREE.Box3[]): Mesh;
+    /**
+     * Overrides mesh material, set to undefine to restore initial material.
+     */
+    setMaterial(value: THREE.Material): void;
+    /**
+     * Returns submesh for given index.
+     */
+    getSubMesh(index: number): StandardSubmesh;
+    /**
+     * Returns submesh corresponding to given face on a merged mesh.
+     */
+    getSubmeshFromFace(faceIndex: number): StandardSubmesh;
+    /**
+     *
+     * @returns Returns all submeshes
+     */
+    getSubmeshes(): StandardSubmesh[];
+    private binarySearch;
+    private unionAllBox;
+}
+export type MergedSubmesh = StandardSubmesh | InsertableSubmesh;
+export type Submesh = MergedSubmesh | InstancedSubmesh;
+export declare class SimpleInstanceSubmesh {
+    mesh: THREE.InstancedMesh;
+    get three(): THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>;
+    index: number;
+    readonly merged = false;
+    constructor(mesh: THREE.InstancedMesh, index: number);
+}
+export declare class StandardSubmesh {
+    mesh: Mesh;
+    index: number;
+    constructor(mesh: Mesh, index: number);
+    equals(other: Submesh): boolean;
+    /**
+     * Returns parent three mesh.
+     */
+    get three(): THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>;
+    /**
+     * True if parent mesh is merged.
+     */
+    get merged(): boolean;
+    /**
+     * Returns vim instance associated with this submesh.
+     */
+    get instance(): number;
+    /**
+     * Returns bounding box for this submesh.
+     */
+    get boundingBox(): THREE.Box3;
+    /**
+     * Returns starting position in parent mesh for merged mesh.
+     */
+    get meshStart(): number;
+    /**
+     * Returns ending position in parent mesh for merged mesh.
+     */
+    get meshEnd(): number;
+    /**
+     * Returns vim object for this submesh.
+     */
+    get object(): import("./object3D").Object3D;
+}

package/dist/types/webgl-viewer/vim-loader/object3D.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { Vim } from './vim';
+import { IElement, VimHelpers } from 'vim-format';
+import { Submesh } from './mesh';
+/**
+ * High level api to interact with the loaded vim geometry and data.
+ */
+export declare class Object3D {
+    private _color;
+    private _boundingBox;
+    private _meshes;
+    private _outlineAttribute;
+    private _visibleAttribute;
+    private _coloredAttribute;
+    private _focusedAttribute;
+    private _colorAttribute;
+    /**
+     * Indicate whether this object is architectural or markup.
+     */
+    readonly type = "Object3D";
+    /**
+     * The vim object from which this object came from.
+     */
+    readonly vim: Vim;
+    /**
+     * The bim element index associated with this object.
+     */
+    readonly element: number;
+    /**
+     * The ID of the element associated with this object.
+     */
+    get elementId(): bigint;
+    /**
+     * The geometry instances  associated with this object.
+     */
+    readonly instances: number[] | undefined;
+    /**
+     * Checks if this object has associated geometry.
+     * @returns {boolean} True if this object has geometry, otherwise false.
+     */
+    get hasMesh(): boolean;
+    /**
+     * Determines whether to render selection outline for this object or not.
+     */
+    get outline(): boolean;
+    set outline(value: boolean);
+    /**
+     * Determines whether to render focus highlight for this object or not.
+     */
+    get focused(): boolean;
+    set focused(value: boolean);
+    /**
+     * Determines whether to render this object or not.
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * Gets or sets the display color of this object.
+     * @param {THREE.Color | undefined} color The color to apply. Pass undefined to revert to the default color.
+     * @returns {THREE.Color} The current color of the object.
+     */
+    get color(): THREE.Color | undefined;
+    set color(color: THREE.Color | undefined);
+    /**
+     * Constructs a new instance of Object.
+     * @param {Vim} vim The Vim instance.
+     * @param {number} element The element index.
+     * @param {number[] | undefined} instances An optional array of instance numbers.
+     * @param {Submesh[] | undefined} meshes An optional array of submeshes.
+     */
+    constructor(vim: Vim, element: number, instances: number[] | undefined, meshes: Submesh[] | undefined);
+    /**
+     * Asynchronously retrieves Bim data for the element associated with this object.
+     * @returns {IElement} An object containing the bim data for this element.
+     */
+    getBimElement(): Promise<IElement>;
+    /**
+     * Asynchronously retrieves Bim parameters for the element associated with this object.
+     * @returns {VimHelpers.ElementParameter[]} An array of all bim parameters for this elements.
+     */
+    getBimParameters(): Promise<VimHelpers.ElementParameter[]>;
+    /**
+     * Retrieves the bounding box of the object from cache or computes it if needed.
+     * Returns undefined if the object has no geometry.
+     * @returns {THREE.Box3 | undefined} The bounding box of the object, or undefined if the object has no geometry.
+     */
+    getBoundingBox(): THREE.Box3;
+    /**
+     * Retrieves the center position of this object.
+     * @param {THREE.Vector3} [target=new THREE.Vector3()] Optional parameter specifying where to copy the center position data.
+     * A new instance is created if none is provided.
+     * @returns {THREE.Vector3 | undefined} The center position of the object, or undefined if the object has no geometry.
+     */
+    getCenter(target?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Internal method used to replace this object's meshes and apply color as needed.
+     * @param {Submesh} mesh The new mesh to be added.
+     * @throws {Error} Throws an error if the provided mesh instance does not match any existing instances.
+     */
+    _addMesh(mesh: Submesh): void;
+    private updateMeshes;
+}

package/dist/types/webgl-viewer/vim-loader/objectAttributes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module vim-loader
+ */
+import { SimpleInstanceSubmesh, Submesh } from './mesh';
+export type AttributeTarget = Submesh | SimpleInstanceSubmesh;
+export declare class ObjectAttribute<T> {
+    readonly vertexAttribute: string;
+    readonly instanceAttribute: string;
+    readonly defaultValue: T;
+    readonly toNumber: (value: T) => number;
+    private _value;
+    private _meshes;
+    constructor(value: T, vertexAttribute: string, instanceAttribute: string, meshes: AttributeTarget[] | undefined, toNumber: (value: T) => number);
+    updateMeshes(meshes: AttributeTarget[] | undefined): void;
+    get value(): T;
+    apply(value: T): boolean;
+    private applyInstanced;
+    private applyMerged;
+}