@maqiuyao/dxf-viewer 0.1.0

package/dist/src/dxfViewer/core/dxf-parser/objects/common.d.ts

@@ -0,0 +1,15 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+export interface IObject {
+    type: string;
+    handle: string;
+    ownerHandle: string;
+    extendedData?: {
+        customStrings?: string[];
+        applicationName?: string;
+    };
+}
+export type ObjectName = "ACAD_PROXY_OBJECT" | "ACDBDICTIONARYWDFLT" | "ACDBPLACEHOLDER" | "DATATABLE" | "DICTIONARY" | "DICTIONARYVAR" | "DIMASSOC" | "FIELD" | "GEODATA" | "IDBUFFER" | "IMAGEDEF" | "IMAGEDEF_REACTOR" | "LAYER_INDEX" | "LAYER_FILTER" | "LAYOUT" | "LIGHTLIST" | "MATERIAL" | "MLINESTYLE" | "OBJECT_PTR" | "PLOTSETTINGS" | "RASTERVARIABLES" | "RENDER" | "SECTION" | "SPATIAL_INDEX" | "SPATIAL_FILTER" | "SORTENTSTABLE" | "TABLESTYLE" | "UNDERLAYDEFINITION" | "VISUALSTYLE" | "VBA_PROJECT" | "WIPEOUTVARIABLES" | "XRECORD";
+export interface IObjectParser {
+    ForObjectName: ObjectName;
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IObject;
+}

package/dist/src/dxfViewer/core/dxf-parser/objects/dictionary.d.ts

@@ -0,0 +1,19 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IObject, IObjectParser } from './common';
+export declare enum DictionaryCloningFlags {
+    NotApplicable = 0,
+    KeepExisting = 1,
+    UseClone = 2,
+    XrefName = 3,
+    Name = 4,
+    UnmangleName = 5
+}
+export interface IDictionaryObject extends IObject {
+    entries: Record<string, string>;
+    isHardOwner: boolean;
+    cloningFlag: DictionaryCloningFlags;
+}
+export default class Dictionary implements IObjectParser {
+    ForObjectName: "DICTIONARY";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IDictionaryObject;
+}

package/dist/src/dxfViewer/core/dxf-parser/objects/imagedef.d.ts

@@ -0,0 +1,24 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IPoint } from '../entities/geomtry';
+import { IObject, IObjectParser } from './common';
+export declare enum ImgaeDefLoaded {
+    Unloaded = 0,
+    Loaded = 1
+}
+export declare enum ImageDefResolutionUnits {
+    NoUnits = 0,
+    Centimeters = 2,
+    Inches = 5
+}
+export interface IImageDefObject extends IObject {
+    classVersion: number;
+    filename: string;
+    imageSize: IPoint;
+    pixelSize: IPoint;
+    loaded: ImgaeDefLoaded;
+    resolutionUnits: ImageDefResolutionUnits;
+}
+export default class ImageDef implements IObjectParser {
+    ForObjectName: "IMAGEDEF";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IImageDefObject;
+}

package/dist/src/dxfViewer/core/dxf-parser/objects/layout.d.ts

@@ -0,0 +1,26 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IPoint } from '../entities/geomtry';
+import { IObject, IObjectParser } from './common';
+export interface ILayoutObject extends IObject {
+    plotSettings?: object;
+    layoutName: string;
+    flag: number;
+    tabOrder: number;
+    minLimit: IPoint;
+    maxLimit: IPoint;
+    basePoint: IPoint;
+    minExtent: IPoint;
+    maxExtent: IPoint;
+    elevation: number;
+    origin: IPoint;
+    XAxis: IPoint;
+    YAxis: IPoint;
+    orthographicType: number;
+    blockTableHandle: string;
+    viewportHandle: string;
+    associatedBlockName: string;
+}
+export default class Layout implements IObjectParser {
+    ForObjectName: "LAYOUT";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): ILayoutObject;
+}

package/dist/src/dxfViewer/core/dxf-parser/objects/sortentstable.d.ts

@@ -0,0 +1,12 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IObject, IObjectParser } from './common';
+export interface ISortEntsObject extends IObject {
+    entityHandles: string[][];
+}
+export interface ISortEntsTableObject extends IObject {
+    sortEntsObject: ISortEntsObject;
+}
+export default class SortEntsTable implements IObjectParser {
+    ForObjectName: "SORTENTSTABLE";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): ISortEntsTableObject;
+}

package/dist/src/dxfViewer/core/dxf-parser/objects/spatialfilter.d.ts

@@ -0,0 +1,22 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IPoint } from '../entities/geomtry';
+import { IObject, IObjectParser } from './common';
+export interface ISpatialFilterObject extends IObject {
+    origin: IPoint;
+    numberOfPointsOnClipBoundary: number;
+    vertices: IPoint[];
+    extrusionDirectionX: number;
+    extrusionDirectionY: number;
+    extrusionDirectionZ: number;
+    clipBoundaryVisible: boolean;
+    frontClippingPlaneFlag: boolean;
+    frontClippingPlaneDistance: number;
+    backClippingPlaneFlag: boolean;
+    backClippingPlaneDistance: number;
+    matrix: number[];
+    invertBlockMatrix: number[];
+}
+export default class SpatialFilter implements IObjectParser {
+    ForObjectName: "SPATIAL_FILTER";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): ISpatialFilterObject;
+}

package/dist/src/dxfViewer/core/dxf-parser/objects/xrecord.d.ts

@@ -0,0 +1,11 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IObject, IObjectParser } from './common';
+import { DictionaryCloningFlags } from './dictionary';
+export interface IXRecord extends IObject {
+    binaryData: string | undefined;
+    cloningFlag: DictionaryCloningFlags;
+}
+export default class XRecord implements IObjectParser {
+    ForObjectName: "XRECORD";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IXRecord;
+}

package/dist/src/dxfViewer/core/effect/EffectManager.d.ts

@@ -0,0 +1,43 @@
+import { BaseViewer } from '../viewers';
+import * as THREE from "three";
+/**
+ * Visual effect manager for viewers.
+ */
+export declare class EffectManager {
+    private viewer;
+    private composerEnabled;
+    private composer?;
+    private renderPass?;
+    private effectFxaaPass?;
+    private saoPass?;
+    private ssaoPass?;
+    private outlinePass?;
+    private ssaaRenderPass?;
+    private bloomPass?;
+    private unrealBloomPass?;
+    private vertexNormalsHelpers?;
+    constructor(viewer: BaseViewer);
+    get enabled(): boolean;
+    set enabled(enable: boolean);
+    get renderPassEnabled(): boolean;
+    set renderPassEnabled(enable: boolean);
+    get fxaaPassEnabled(): boolean;
+    set fxaaPassEnabled(enable: boolean);
+    get saoPassEnabled(): boolean;
+    set saoPassEnabled(enable: boolean);
+    get ssaoPassEnabled(): boolean;
+    set ssaoPassEnabled(enable: boolean);
+    get outlinePassEnabled(): boolean;
+    set outlinePassEnabled(enable: boolean);
+    get ssaaPassEnabled(): boolean;
+    set ssaaPassEnabled(enable: boolean);
+    get bloomPassEnabled(): boolean;
+    set bloomPassEnabled(enable: boolean);
+    get unrealBloomPassEnabled(): boolean;
+    set unrealBloomPassEnabled(enable: boolean);
+    setOutlinePassSelectObjects(objects: THREE.Object3D[]): void;
+    enableModelEdges(enable: boolean): void;
+    showVertexNormals(show: boolean, size?: number): void;
+    render(): void;
+    destroy(): void;
+}

package/dist/src/dxfViewer/core/effect/index.d.ts

@@ -0,0 +1 @@
+export * from './EffectManager';

package/dist/src/dxfViewer/core/font/BaseFont.d.ts

@@ -0,0 +1,41 @@
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+import { FontDataTableRecord } from '../indexeddb/FontDataTable';
+import { Orientation } from './shx';
+import * as THREE from "three";
+export declare abstract class BaseFont extends Font {
+    info: string;
+    orientation: Orientation;
+    baseUp: number;
+    baseDown: number;
+    fileHeader: string;
+    fileVersion: string;
+    fileName: string;
+    data: any;
+    order: number;
+    unsupportedChars: Record<string, number>;
+    constructor(fileName: string, fileData: any);
+    abstract getCharShape(char: string, size: number): THREE.Shape | undefined;
+    abstract getNotFoundTextShape(size: number): THREE.Shape | undefined;
+    /**
+     * Just for log usage
+     */
+    protected addUnsupportedChar(char: string): void;
+    protected getFontFile(): {
+        order: number;
+        data: any;
+        info: string;
+        orientation: Orientation;
+        baseUp: number;
+        baseDown: number;
+        fileName: string;
+        fileHeader: string;
+        fileVersion: string;
+    };
+    setFontFile(data: FontDataTableRecord): void;
+    /**
+     * Catches dxf data into indexedDb
+     */
+    setFontDataToIndexedDb(): Promise<void>;
+    getFontDataByIndexedDb(): Promise<FontDataTableRecord>;
+    releaseFontData(): void;
+}

package/dist/src/dxfViewer/core/font/FontManager.d.ts

@@ -0,0 +1,52 @@
+import { BaseFont } from './BaseFont';
+import * as THREE from "three";
+export declare class FontManager {
+    private loader;
+    protected fontMap: Map<string, BaseFont>;
+    protected fileNames?: string[];
+    unsupportedChars: Record<string, number>;
+    missingFonts: Record<string, number>;
+    enableFontCache: boolean;
+    constructor();
+    /**
+     *
+     * @param urls The order represents the priority
+     * @returns
+     * @description The best fonts order is: Load linear fonts first followed by ttf fonts, font types load Western fonts first in loaded chinese fonts.
+     * @description Microsoft Yahei is the most worthy choice of Chinese font on the Win platform, but it is not the default viewer and needs to be set; Sans-serif fonts such as Arial and Tahoma are the main fonts for Western fonts.
+     * @description At present, the latest font launched by Apple and San Francisco for Apple, the display effect is also the most elegant, but only the latest system can support, while blackface - Jane and Helvetica can get more system version support, the display effect is also similar, can be accepted.
+     * @example font-family: Helvetica, Tahoma, Arial, "PingFang SC", "Hiragino Sans GB", "Heiti SC", "Microsoft YaHei", "WenQuanYi Micro Hei", sans-serif;
+     */
+    loadFonts(urls: string[]): Promise<void>;
+    /**
+     *
+     * @param text
+     * @param fontName
+     * @param size
+     * @returns
+     * @description Gets text shape by fontName and size.
+     */
+    getTextShape(text: string, fontName: string, size: number): THREE.Shape[] | undefined;
+    /**
+     *
+     * @param fontName
+     * @param char
+     * @param size
+     * @returns
+     */
+    getCharShape(char: string, fontName: string, size: number): THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined;
+    getNotFoundTextShape(size: number): THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined;
+    private checkAllFontsLoaded;
+    getFontFromIndexeddb(): Promise<void>;
+    isShxFont(fontName: string): boolean | undefined;
+    /**
+     * Just for log usage
+     */
+    getUnsupportedChar(): Record<string, number>;
+    releaseFontData(): void;
+    destroy(): void;
+    static isShxFile(url: string): boolean;
+    static isTtfFile(url: string): boolean;
+    static isJsonFile(url: string): boolean;
+    static getFileName(url: string): string;
+}

package/dist/src/dxfViewer/core/font/MeshFont.d.ts

@@ -0,0 +1,14 @@
+import { BaseFont } from './BaseFont';
+import { FontDataTableRecord } from '../indexeddb';
+import * as THREE from "three";
+export declare class MeshFont extends BaseFont {
+    reversed: boolean;
+    constructor(fileName: string, fileData: object | FontDataTableRecord | ArrayBuffer);
+    generateShapes(text: string, size: number): THREE.Shape[];
+    getCharShape(char: string, size: number): THREE.Shape | undefined;
+    /**
+     * For an unsupported char, use "？" as a replacement.
+     */
+    getNotFoundTextShape(size: number): THREE.Shape | undefined;
+    private parseTTF;
+}

package/dist/src/dxfViewer/core/font/ShxFont.d.ts

@@ -0,0 +1,49 @@
+import { BaseFont } from './BaseFont';
+import { TextShape } from './shx/TextShape';
+import { ShxFontType } from './shx/Shx.constants';
+import { FontDataTableRecord } from '../indexeddb';
+import * as THREE from "three";
+export declare class ShxFont extends BaseFont {
+    static readonly DEFAULT_SIZE = 12;
+    isExtend: boolean;
+    isUniCode: boolean;
+    isEmbedded: boolean;
+    fontType: ShxFontType;
+    private textShapesCache;
+    private graphicData;
+    constructor(fileName: string, fileData: ArrayBuffer | FontDataTableRecord);
+    generateShapes(text: string, size: number): TextShape[];
+    /**
+     * Gets TextShape by a char
+     */
+    getCharShape(char: string, textHeight: number): TextShape | undefined;
+    /**
+     * Gets TextShape by a char code
+     */
+    getGraphicDataByCode(code: number, size: number): TextShape | undefined;
+    /**
+     * Gets TextShape by char's code, font size and offset
+     */
+    getGraphicDataByCodeWithOffset(code: number, size: number, translate: THREE.Vector2): TextShape | undefined;
+    private parseBigFont;
+    private parseUniFont;
+    private parseShapeFont;
+    /**
+     * For an unsupported char, use "？" as a replacement.
+     */
+    getNotFoundTextShape(size: number): TextShape | undefined;
+    protected getFontFile(): {
+        fontType: ShxFontType;
+        order: number;
+        data: any;
+        info: string;
+        orientation: number;
+        baseUp: number;
+        baseDown: number;
+        fileName: string;
+        fileHeader: string;
+        fileVersion: string;
+    };
+    setFontFile(data: FontDataTableRecord): void;
+    releaseFontData(): void;
+}

package/dist/src/dxfViewer/core/font/index.d.ts

@@ -0,0 +1 @@
+export * from './FontManager';

package/dist/src/dxfViewer/core/font/shx/ExtraLettersTemplate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extra letters/chars that don't exist in any font file can be defined here.
+ */
+export declare const ExtraLetters: Record<string, Array<Array<Array<number>>>>;

package/dist/src/dxfViewer/core/font/shx/Shx.constants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Text orientation.
+ */
+export declare enum Orientation {
+    Horizontal = 0,
+    Vertical = 1,
+    All = 2
+}
+/**
+ * Shx font type.
+ */
+export declare enum ShxFontType {
+    Shapes = 0,
+    Bigfont = 1,
+    Unifont = 2
+}
+/**
+ * Default font size.
+ */
+export declare const DefaultFontSize = 12;

package/dist/src/dxfViewer/core/font/shx/ShxParser.d.ts

@@ -0,0 +1,18 @@
+import { TextShape } from './TextShape';
+import { BinaryReader } from '../../helpers/BinaryReader';
+import { ShxFont } from '../ShxFont';
+export declare class ShxParser {
+    static readonly FILE_STOP_FLAG: string[];
+    static readonly CIRCLE_SPAN: number;
+    static parserHeader(reader: BinaryReader, stopMatch: string[]): string;
+    /**
+     * Gets code id of a char.
+     */
+    static getCode(char: string): number;
+    /**
+     * Parses code data and generates TextShape.
+     */
+    static parserCode(file: ShxFont, data: Uint8Array, scale: number): TextShape;
+    private static skipCode;
+    private static generateArcPoints;
+}

package/dist/src/dxfViewer/core/font/shx/TextShape.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+/**
+ * Text shape, to describe a specific character.
+ */
+export declare class TextShape extends THREE.Shape {
+    width: number;
+    lastPoint: THREE.Vector2;
+    polylines: Array<Array<THREE.Vector2>>;
+    private bounds;
+    constructor(lastPoint: THREE.Vector2, polylines: Array<Array<THREE.Vector2>>);
+    /**
+     * Gets an offsetted new TextShape
+     */
+    offset(vector: THREE.Vector2): TextShape;
+    /**
+     * Gets an transformed new TextShape
+     */
+    transform(matrix: THREE.Matrix3): TextShape;
+    protected calcWidth(polylines: THREE.Vector2[][]): number;
+    /**
+     * Converts a TextShape to THREE.BufferGeometry
+     */
+    toThreeGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+}

package/dist/src/dxfViewer/core/font/shx/gbk/index.d.ts

@@ -0,0 +1,3 @@
+export declare function encode(str: string): Uint8Array;
+export declare function traditionalChineseToSimpliled(text: string): string;
+export declare function isTraditionalChinese(text: string): boolean;

package/dist/src/dxfViewer/core/font/shx/index.d.ts

@@ -0,0 +1 @@
+export * from './Shx.constants';

package/dist/src/dxfViewer/core/font/shx/util/BitConverter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * C# 风格的字节转换工具类
+ */
+export declare class BitConverter {
+    static GetBytes(value: string | number | boolean | []): Uint8Array;
+    static Get1Bytes(value: number | boolean | []): Uint8Array;
+    static byteTosbyte(byte: number): number;
+    static ToBoolean(value: Uint8Array, startIndex: number): boolean;
+    static ToInt8(value: Uint8Array, startIndex: number): number;
+    static ToUInt8(value: Uint8Array, startIndex: number): number;
+    static ToInt16(value: Uint8Array, startIndex: number): number;
+    static ToInt32(value: Uint8Array, startIndex: number): number;
+    static ToUInt16(value: Uint8Array, startIndex: number): number;
+    static ToUInt32(value: Uint8Array, startIndex: number): number;
+    static ToChar(value: Uint8Array, startIndex: number): string;
+    static ToAscii(value: Uint8Array, startIndex: number): string;
+    static ToAsciiString(value: Uint8Array, startIndex: number, length: number): string;
+    static ToUTF16String(value: Uint8Array, startIndex: number, length: number): string;
+    static ToFloat32(value: Uint8Array, startIndex: number): number;
+    static ToFloat64(value: Uint8Array, startIndex: number): number;
+}

package/dist/src/dxfViewer/core/geometry-offset/Edge.d.ts

@@ -0,0 +1,27 @@
+import { Pair } from 'polygon-clipping';
+/**
+ * Offset edge
+ * @internal
+ */
+export declare class Edge {
+    current: Pair;
+    next: Pair;
+    inNormal: Pair;
+    outNormal: Pair;
+    constructor(current: Pair, next: Pair);
+    /**
+     * Creates outwards normal
+     */
+    private outwardsNormal;
+    /**
+     * Creates inwards normal
+     */
+    private inwardsNormal;
+    /**
+     * Offsets the edge by dx, dy
+     */
+    offset(dx: number, dy: number): Edge;
+    inverseOffset(dx: number, dy: number): Edge;
+    inverse(): Edge;
+    static offsetEdge(current: Pair, next: Pair, dx: number, dy: number): Edge;
+}

package/dist/src/dxfViewer/core/geometry-offset/Offset.d.ts

@@ -0,0 +1,46 @@
+import { MultiPolygon, Pair, Polygon, Ring } from 'polygon-clipping';
+import { Edge } from './Edge';
+/**
+ * Offset builder
+ * @internal
+ */
+export declare class Offset {
+    vertices: Pair | Ring | Polygon;
+    edges: Edge[] | Edge[][];
+    private arcSegments;
+    private distance;
+    constructor(vertices: Pair | Ring | Polygon, arcSegments?: number);
+    /**
+     * Recursively process contour to create normals
+     */
+    private processContour;
+    setArcSegments(arcSegments: number): this;
+    /**
+     * Creates arch between two edges
+     *
+     * @param  {Array.<Object>} vertices
+     * @param  {Object}         center
+     * @param  {Number}         radius
+     * @param  {Object}         startVertex
+     * @param  {Object}         endVertex
+     * @param  {Number}         segments
+     * @param  {Boolean}        bOutwards
+     */
+    private createArc;
+    setDistance(dist: number): this;
+    private ensureLastPoint;
+    /**
+     * Decides by the sign if it's a padding or a margin
+     */
+    offset(dist: number): Pair | Ring | Polygon | MultiPolygon;
+    private offsetSegment;
+    private margin;
+    private padding;
+    offsetLine(dist: number): Pair | Ring | Polygon | MultiPolygon;
+    /**
+     * Just offsets lines, no fill
+     */
+    private offsetLines;
+    private offsetContour;
+    offsetPoint(distance: number): MultiPolygon;
+}

package/dist/src/dxfViewer/core/geometry-offset/index.d.ts

@@ -0,0 +1 @@
+export * from './Offset';

package/dist/src/dxfViewer/core/helpers/BinaryReader.d.ts

@@ -0,0 +1,23 @@
+export declare class BinaryReader {
+    private endian;
+    private position;
+    private data;
+    private decoder;
+    constructor(arraybuffer: ArrayBuffer, endian?: string);
+    readAsciiString(length: number): string;
+    readUtf8String(length: number): string;
+    readBytes(length?: number): Uint8Array;
+    readUint8(): number;
+    readInt8(): number;
+    readUint16(): number;
+    readInt16(): number;
+    readUint32(): number;
+    readInt32(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt64(): number;
+    readUint64(): number;
+    getPosition(): number;
+    setPosition(position: number): void;
+    isEnd(): boolean;
+}

package/dist/src/dxfViewer/core/helpers/BoxSelectHelper.d.ts

@@ -0,0 +1,44 @@
+import { Tooltip } from '../../components/tool-tip';
+import { mouseButtonAction, singleTouchAction } from '../../core/camera-controls/types';
+import { EventInfo, InputManager } from '../../core/input-manager/InputManager';
+import { BaseViewer } from '../../core/viewers';
+import * as THREE from "three";
+/**
+ * Box select an area in screen coordinate.
+ * @internal
+ */
+export declare class BoxSelectHelper {
+    static readonly BORDER_COLOR = "#fff000";
+    static readonly BORDER_WIDTH = "2px";
+    protected viewer: BaseViewer;
+    protected input: InputManager;
+    protected mouseDown: boolean;
+    protected mouseMove: boolean;
+    protected mouseDownPositionX: number;
+    protected mouseDownPositionY: number;
+    protected tempKey?: mouseButtonAction;
+    protected tempTouch?: singleTouchAction;
+    protected tempEnableRotate: boolean;
+    protected rectDom?: HTMLDivElement;
+    protected tooltip?: Tooltip;
+    private active;
+    protected resolve?: (value: THREE.Box2 | PromiseLike<THREE.Box2> | undefined) => void;
+    protected reject?: (reason: any) => void;
+    protected isResolvedOrRejected: boolean;
+    private mousedown;
+    private mousemove;
+    private mouseup;
+    keydown: (e: EventInfo) => void;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    private drawRect;
+    private setRectDomVisible;
+    /**
+     * Starts to select a box area
+     */
+    select(): Promise<THREE.Box2 | undefined>;
+    destroy(): void;
+}

package/dist/src/dxfViewer/core/helpers/InstantiateHelper.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+/**
+ * InstantiateHelper class is used to instantiate child objects for a given object
+ * @internal
+ */
+export declare class InstantiateHelper {
+    object: THREE.Object3D;
+    constructor(object: THREE.Object3D);
+    /**
+     * Instatiates child objects for given object.
+     */
+    instantiate(): void;
+    /**
+     * Instatiates child objects of given object.
+     * If objects' geometry and material are the same, they can be instanced.
+     */
+    private instantiateInner;
+    /**
+     * Removes a number from array
+     */
+    removeFromArray(arr: number[], toBeRemoved: number): void;
+    /**
+     * Checks if two geometries equal
+     */
+    private geometryEquals;
+}