@itwin/core-frontend/lib/cjs/common/internal/render/MeshBuilderMap.d.ts

iTwin.js frontend components

/** @packageDocumentation
 * @module Rendering
 */
import { Dictionary, Id64String } from "@itwin/core-bentley";
import { Range3d } from "@itwin/core-geometry";
import { Feature, FeatureTable } from "@itwin/core-common";
import { DisplayParams } from "./DisplayParams";
import { MeshPrimitiveType } from "./MeshPrimitive";
import { GeometryList } from "./GeometryList";
import { Geometry } from "./GeometryPrimitives";
import { PolyfacePrimitive } from "./Polyface";
import { GeometryOptions } from "./Primitives";
import { StrokesPrimitive } from "./Strokes";
import { MeshBuilder } from "./MeshBuilder";
import { Mesh, MeshList } from "./MeshPrimitives";
/** @internal */
export declare class MeshBuilderMap extends Dictionary<MeshBuilderMap.Key, MeshBuilder> {
    readonly range: Range3d;
    readonly vertexTolerance: number;
    readonly facetAreaTolerance: number;
    readonly tolerance: number;
    readonly is2d: boolean;
    readonly features?: FeatureTable;
    readonly options: GeometryOptions;
    private readonly _isVolumeClassifier;
    private _keyOrder;
    constructor(tolerance: number, range: Range3d, is2d: boolean, options: GeometryOptions, pickable: {
        isVolumeClassifier?: boolean;
        modelId?: Id64String;
    } | undefined);
    static createFromGeometries(geometries: GeometryList, tolerance: number, range: Range3d, is2d: boolean, options: GeometryOptions, pickable: {
        isVolumeClassifier?: boolean;
        modelId?: Id64String;
    } | undefined): MeshBuilderMap;
    toMeshes(): MeshList;
    /**
     * extract polyfaces and strokes from geometry into MeshBuilder stored in builderMap
     * @param geom Geometry instance to extract polyfaces and strokes from
     */
    loadGeometry(geom: Geometry): void;
    /**
     * extract polyface primitives from geometry in meshBuilder stored in builderMap
     * @param geom Geometry instance to extract polyfaces from
     */
    loadPolyfacePrimitiveList(geom: Geometry): void;
    /**
     * extract indexed polyfaces into meshBuilder stored in builderMap
     * @param polyface PolyfacePrimitive to extract indexed polyfaces from
     */
    loadIndexedPolyface(polyface: PolyfacePrimitive, feature: Feature | undefined): void;
    /**
     * extract stroke primitives from geometry in meshBuilder stored in builderMap
     * @param geom Geometry instance to extract strokes from
     */
    loadStrokePrimitiveList(geom: Geometry): void;
    /**
     * extract strokes primitive into meshBuilder stored in builderMap
     * @param strokePrimitive StrokesPrimitive instance to extractfrom
     */
    loadStrokesPrimitive(strokePrimitive: StrokesPrimitive, feature: Feature | undefined): void;
    getBuilder(displayParams: DisplayParams, type: MeshPrimitiveType, hasNormals: boolean, isPlanar: boolean): MeshBuilder;
    getKey(displayParams: DisplayParams, type: MeshPrimitiveType, hasNormals: boolean, isPlanar: boolean): MeshBuilderMap.Key;
    /**
     * gets builder associated with key if defined, otherwise creates a new builder and sets that with key
     * @param key MeshBuilderMap.Key to associate with builder
     * @param props MeshBuilder.Props required to create builder if it does not already exist
     * @returns builder reference, changes will update instance stored in builderMap
     */
    getBuilderFromKey(key: MeshBuilderMap.Key, props: MeshBuilder.Props): MeshBuilder;
}
/** @internal */
export declare namespace MeshBuilderMap {
    class Key {
        order: number;
        readonly params: DisplayParams;
        readonly type: MeshPrimitiveType;
        readonly hasNormals: boolean;
        readonly isPlanar: boolean;
        constructor(params: DisplayParams, type: MeshPrimitiveType, hasNormals: boolean, isPlanar: boolean);
        static createFromMesh(mesh: Mesh): Key;
        compare(rhs: Key): number;
        equals(rhs: Key): boolean;
    }
}
//# sourceMappingURL=MeshBuilderMap.d.ts.map