@itwin/core-frontend/lib/esm/internal/render/webgl/InstancedGeometry.d.ts

iTwin.js frontend components

/** @packageDocumentation
 * @module WebGL
 */
import { Point3d, Range3d, Transform, XYAndZ } from "@itwin/core-geometry";
import { InstancedGraphicParams, InstancedGraphicProps, PatternGraphicParams } from "../../../common/render/InstancedGraphicParams";
import { RenderMemory } from "../../../render/RenderMemory";
import { CachedGeometry, LUTGeometry } from "./CachedGeometry";
import { ShaderProgramParams } from "./DrawCommand";
import { BufferHandle, BufferParameters } from "./AttributeBuffers";
import { Target } from "./Target";
import { TechniqueId } from "./TechniqueId";
import { Matrix4 } from "./Matrix";
import { RenderInstances } from "../../../render/RenderSystem";
import { _implementationProhibited } from "../../../common/internal/Symbols";
import { RenderInstancesParamsImpl } from "../../../internal/render/RenderInstancesParamsImpl";
/** @internal */
export declare function isInstancedGraphicParams(params: any): params is InstancedGraphicParams;
declare class InstanceData {
    readonly numInstances: number;
    private readonly _rtcOnlyTransform;
    private readonly _rtcModelTransform;
    private readonly _modelMatrix;
    protected constructor(numInstances: number, rtcCenter: Point3d);
    getRtcModelTransform(modelMatrix: Transform): Transform;
    getRtcOnlyTransform(): Transform;
    private static readonly _noFeatureId;
    get patternFeatureId(): Float32Array;
}
/** @internal */
export interface PatternTransforms {
    readonly orgTransform: Matrix4;
    readonly localToModel: Matrix4;
    readonly symbolToLocal: Matrix4;
    readonly origin: Float32Array;
}
/** @internal */
export declare class InstanceBuffersData extends InstanceData {
    readonly transforms: BufferHandle;
    readonly featureIds?: BufferHandle;
    readonly symbology?: BufferHandle;
    private _noDispose;
    private constructor();
    static create(params: InstancedGraphicParams | InstancedGraphicProps, disableDisposal?: boolean): InstanceBuffersData | undefined;
    [Symbol.dispose](): void;
    get isDisposed(): boolean;
}
/** @internal */
export interface RenderInstancesImpl extends RenderInstances {
    readonly buffers: InstanceBuffersData;
}
/** @internal */
export declare namespace RenderInstancesImpl {
    function create(params: RenderInstancesParamsImpl): RenderInstancesImpl | undefined;
}
/** @internal */
export declare class InstanceBuffers {
    private static readonly _patternParams;
    private readonly _data;
    readonly patternParams: Float32Array;
    readonly patternTransforms: undefined;
    readonly viewIndependentOrigin: undefined;
    readonly range: Range3d;
    get numInstances(): number;
    get transforms(): BufferHandle;
    get featureIds(): BufferHandle | undefined;
    get symbology(): BufferHandle | undefined;
    get hasFeatures(): boolean;
    get patternFeatureId(): Float32Array;
    getRtcModelTransform(modelMatrix: Transform): Transform;
    getRtcOnlyTransform(): Transform;
    private constructor();
    static createTransformBufferParameters(techniqueId: TechniqueId): BufferParameters[];
    static fromParams(params: InstancedGraphicParams, computeReprRange: () => Range3d): InstanceBuffers | undefined;
    static fromRenderInstances(arg: RenderInstances, reprRange: Range3d): InstanceBuffers;
    [Symbol.dispose](): void;
    get isDisposed(): boolean;
    collectStatistics(stats: RenderMemory.Statistics): void;
    private static extendTransformedRange;
    static computeRange(reprRange: Range3d, tfs: Float32Array, rtcCenter: XYAndZ, out?: Range3d): Range3d;
}
/** @internal */
export declare class PatternBuffers extends InstanceData {
    readonly range: Range3d;
    readonly patternParams: Float32Array;
    readonly origin: Float32Array;
    readonly orgTransform: Matrix4;
    readonly localToModel: Matrix4;
    readonly symbolToLocal: Matrix4;
    readonly offsets: BufferHandle;
    readonly viewIndependentOrigin: Point3d | undefined;
    private readonly _featureId?;
    readonly [_implementationProhibited] = "renderAreaPattern";
    private constructor();
    static create(params: PatternGraphicParams): PatternBuffers | undefined;
    readonly patternTransforms: PatternTransforms;
    get hasFeatures(): boolean;
    get patternFeatureId(): Float32Array;
    get isDisposed(): boolean;
    [Symbol.dispose](): void;
    collectStatistics(stats: RenderMemory.Statistics): void;
}
/** @internal */
export declare class InstancedGeometry extends CachedGeometry {
    private readonly _buffersContainer;
    private readonly _buffers;
    private readonly _repr;
    private readonly _ownsBuffers;
    getRtcModelTransform(modelMatrix: Transform): Transform;
    getRtcOnlyTransform(): Transform;
    get viewIndependentOrigin(): Point3d | undefined;
    get asInstanced(): this;
    get asLUT(): LUTGeometry;
    get asMesh(): import("./MeshGeometry").MeshGeometry | undefined;
    get asSurface(): import("./SurfaceGeometry").SurfaceGeometry | undefined;
    get asEdge(): import("./EdgeGeometry").EdgeGeometry | undefined;
    get asSilhouette(): import("./EdgeGeometry").SilhouetteEdgeGeometry | undefined;
    get asIndexedEdge(): import("./IndexedEdgeGeometry").IndexedEdgeGeometry | undefined;
    get renderOrder(): import("./RenderFlags").RenderOrder;
    get isLitSurface(): boolean;
    get hasBakedLighting(): boolean;
    get hasAnimation(): boolean;
    get usesQuantizedPositions(): boolean;
    get qOrigin(): Float32Array;
    get qScale(): Float32Array;
    get materialInfo(): import("./Material").MaterialInfo | undefined;
    get polylineBuffers(): import("./CachedGeometry").PolylineBuffers | undefined;
    get isEdge(): boolean;
    get hasFeatures(): boolean;
    get techniqueId(): TechniqueId;
    get supportsThematicDisplay(): boolean;
    getPass(target: Target): import("./RenderFlags").Pass;
    wantWoWReversal(params: ShaderProgramParams): boolean;
    getLineCode(params: ShaderProgramParams): number;
    getLineWeight(params: ShaderProgramParams): number;
    wantMonochrome(target: Target): boolean;
    wantMixMonochromeColor(target: Target): boolean;
    static create(repr: LUTGeometry, ownsBuffers: boolean, buffers: InstanceBuffers): InstancedGeometry;
    static createPattern(repr: LUTGeometry, ownsBuffers: boolean, buffers: PatternBuffers): InstancedGeometry;
    private constructor();
    get isDisposed(): boolean;
    [Symbol.dispose](): void;
    protected _wantWoWReversal(_target: Target): boolean;
    draw(): void;
    computeRange(output?: Range3d): Range3d;
    collectStatistics(stats: RenderMemory.Statistics): void;
    get patternParams(): Float32Array;
    get patternTransforms(): PatternTransforms | undefined;
    get patternFeatureId(): Float32Array;
}
export {};
//# sourceMappingURL=InstancedGeometry.d.ts.map