///
///
///
/*!
* @maptalks/gl v0.124.4
* LICENSE : UNLICENSED
* (c) 2016-2026 maptalks.com
*/
import * as REGL from '@maptalks/regl';
import REGL__default, { Texture, Texture2DOptions, TextureImageData, Regl, Texture2D as Texture2D$1, Uniforms } from '@maptalks/regl';
export { default as createREGL } from '@maptalks/regl';
import * as gl_matrix from 'gl-matrix';
import { vec3, mat4, glMatrix, mat2, mat2d, mat3, quat, quat2, vec2, vec4 } from 'gl-matrix';
export { mat2, mat2d, mat3, mat4, quat, quat2, vec2, vec3, vec4 } from 'gl-matrix';
import * as maptalks from 'maptalks';
import { Polygon, LayerJSONType, renderer, Layer, MixinConstructor, Extent } from 'maptalks';
export { GLContext } from '@maptalks/fusiongl';
export { default as earcut } from 'earcut';
export { default as color } from 'color';
declare const TerrainLayer_base: {
new (...args: any[]): {
_maskProjViewMatrix: gl_matrix.mat4;
_maskExtentInWorld: [number, number, number, number];
removeMask(masks: any): any;
setMask(masks: any): any;
onAdd(): void;
getMasks(): any;
onGeometryEvent(param: any): void;
identifyMask(point: any, options: any): any[];
remove(): void;
updateMask(extent: any): {
projViewMatrix: gl_matrix.mat4;
extentInWorld: [number, number, number, number];
};
getProjViewMatrixInOrtho(extent: any): {
mapExtent: any;
projViewMatrix: gl_matrix.mat4;
};
updateMaskExtent(): void;
getMaskExtent(): {
extent: maptalks.Extent;
ratio: number;
minHeight: any;
};
};
} & typeof maptalks.TileLayer;
declare class TerrainLayer extends TerrainLayer_base {
constructor(id: any, options: any);
onAdd(): void;
getTileUrl(x: any, y: any, z: any): string;
_skuToken: string;
_createSkuToken(): string;
_getExaggeration(): any;
setSkinLayers(skinLayers: any): void;
_skinLayers: any;
getSkinTiles(layer: any): {
tileGrids: any[];
count: number;
};
getSkinLayer(index: any): any;
getSkinLayerById(id: any): any;
getSkinLayers(): any;
getSkinCount(): any;
queryTerrainByProjCoord(prjCoord: any, out: any): any;
queryTileTerrainByProjCoord(prjCoord: any, tileId: any, tileIndex: any, out: any): any;
queryTileTerrainByPointAtRes(point: any, res: any, tileId: any, tileIndex: any, out: any): any;
queryTerrain(coordinate: any, out: any): any;
queryTileMesh(tile: any, cb: any): void;
getTerrainTiles(layer: any, tileInfo: any): any;
isTerrainTileLoaded(tileId: any): boolean;
updateMaterial(mat: any): void;
setMaterial(mat: any): void;
_createTileNode(x: any, y: any, z: any, idx: any, idy: any, res: any, error: any, parentId: any, extent2d: any, tileId: any): {
parent: any;
layer: string;
x: any;
y: any;
z: any;
idx: any;
idy: any;
res: any;
extent2d: any;
id: any;
url: string;
offset: any;
error: any;
children: any[];
};
_getErrorScale(): number;
}
declare class GraphicsFramebuffer {
device: GraphicsDevice;
options: any;
width: number;
height: number;
constructor(device: any, options: any);
get color(): GraphicsTexture[];
resize(width: any, height: any): void;
getCommandKey(): string;
_update(): void;
getRenderPassDescriptor(): GPURenderPassDescriptor;
setClearOptions(options: any): void;
resetClearOptions(): void;
destroy(): void;
isDestroyed(): boolean;
}
declare class GraphicsCubeTexture extends GraphicsTexture {
get arrayLayers(): number;
getMipLevelCount(): any;
fillData(texture: any, width: any, height: any): void;
}
declare class GraphicsDevice {
wgpu: GPUDevice;
context: GPUCanvasContext;
adapter: GPUAdapter;
gltfManager?: any;
constructor(device: GPUDevice, context: GPUCanvasContext, adapter: GPUAdapter);
hasExtension(extension: any): boolean;
getCommandEncoder(): GPUCommandEncoder;
endCommandEncoder(): void;
getDefaultFramebuffer(): GraphicsFramebuffer;
getRenderPassEncoder(fbo: GraphicsFramebuffer): GPURenderPassEncoder;
addCommandBuffer(commandBuffer: GPUCommandBuffer, front: boolean): void;
submit(): void;
addToDestroyList(texture: GPUTexture): void;
preserveDrawingBuffer(canvas: any): void;
buffer(options: any): any;
elements(options: any): any;
framebuffer(width: any, height: any): GraphicsFramebuffer;
texture(width: any, height?: any): GraphicsTexture;
cube(options: REGL__default.TextureCubeOptions): GraphicsCubeTexture;
clear(options: any): void;
read(options: any): any;
destroy(): void;
incrDrawCall(): void;
resetDrawCalls(): void;
getDrawCalls(): 0;
_renderToClear(fbo: any): void;
_getClearPipeline(fbo: any): GPURenderPipeline;
}
declare class GraphicsTexture {
texture: GPUTexture;
device: GraphicsDevice;
config: any;
version: number;
constructor(device: GraphicsDevice, config: any);
get width(): any;
get height(): any;
get arrayLayers(): number;
updateFilter(): void;
resize(width: any, height: any): void;
update(config: any): void;
_updateTexture(): void;
_isDirty(newConfig: any): boolean;
_getSize(config: any): {
width: any;
height: any;
};
getMipLevelCount(data?: any): any;
fillData(texture: any, width: any, height: any): void;
fillImageData(texture: any, data: any, width: any, height: any, origin: any): void;
fillArrayData(texture: any, data: any, width: any, height: any, origin: any): void;
_fillMipmap(texture: any, mipLevel: any, data: any, width: any, height: any, origin: any): void;
formatTextureArray(data: any, arrayBuffer: any, width: any, height: any): any;
isArrayData(data: any): boolean;
getView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
destroy(): void;
}
type UrlModifierFunction = (url: string) => string;
type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Float32Array;
type NumberArray = TypedArray | number[];
type AttributeData = NumberArray | any;
type GeometryDesc = {
'positionSize'?: number;
'primitive'?: REGL__default.PrimitiveType;
'positionAttribute'?: string;
'normalAttribute'?: string;
'uv0Attribute'?: string;
'uv1Attribute'?: string;
'color0Attribute'?: string;
'colorAttribute'?: string;
'tangentAttribute'?: string;
'pickingIdAttribute'?: string;
'textureCoordMatrixAttribute'?: string;
'altitudeAttribute'?: string;
'fillEmptyDataInMissingAttribute'?: boolean;
'static'?: boolean;
};
type AttributeKey = {
key: string;
};
type ActiveAttributes = {
name: string;
type: number;
}[] & AttributeKey;
type ShaderUniformValue = number | boolean | string | NumberArray | null | ShaderUniformTexture;
type ShaderUniformTexture = AbstractTexture | Texture | GraphicsTexture;
type ShaderUniforms = {
meshConfig?: MeshOptions;
primitive?: REGL__default.PrimitiveType;
} & {
[_: string]: ShaderUniformValue;
};
type ShaderDefines = {
[_: string]: number | string;
};
type MeshOptions = {
transparent?: boolean;
bloom?: boolean;
ssr?: boolean;
castShadow?: boolean;
picking?: boolean;
disableVAO?: boolean;
};
type AttributeBufferData = {
buffer?: REGL__default.Buffer;
data?: NumberArray;
divisor?: number;
};
type AttributeType = NumberArray | REGL__default.Buffer | AttributeBufferData;
type InstancedAttribute = Record;
type ImageObject = {
array: TextureImageData;
width: number;
height: number;
};
type TextureConfig = {
url?: string;
image?: ImageObject;
hdr?: boolean;
/**
* hdr 纹理的最大 RGBMRange，默认为9
* @english
* max RGBMRange for hdr texture, default is 9
*/
maxRange?: number;
promise?: Promise;
persistent?: boolean;
compare?: GPUCompareFunction;
} & Texture2DOptions;
type HandlerFnResultType = {
type: string;
target: any;
[propName: string]: any;
};
type BaseEventParamsType = {
type?: string;
target?: any;
[propName: string]: any;
};
type HandlerFn = (result?: HandlerFnResultType) => void | boolean;
type CachedResource = {
image: any;
count: number;
};
type PromiseResource = {
url: string;
data: any;
};
declare class InnerResourceLoader {
defaultTexture?: Uint8Array;
defaultCubeTexture: number[];
urlModifier?: UrlModifierFunction;
resources: Record;
constructor(DEFAULT_TEXTURE: Uint8Array, urlModifier?: UrlModifierFunction);
setURLModifier(urlModifier: UrlModifierFunction): void;
get(url: string | string[]): Promise | Promise;
getArrayBuffer(url: string | string[]): Promise;
disposeRes(url: string | string[]): this;
isLoading(): boolean;
getDefaultTexture(url: string | string[]): Uint8Array | number[];
}
declare const ResourceLoader_base: {
new (...args: any[]): {
_events: Record;
on(type: string, handler: HandlerFn): any;
once(type: string, handler: HandlerFn): any;
off(type: string, handler: HandlerFn): any;
fire(type: string, params?: BaseEventParamsType): any;
_wrapOnce(type: string, handler: HandlerFn): (params: any) => void;
};
} & typeof InnerResourceLoader;
declare class ResourceLoader extends ResourceLoader_base {
}
//# sourceMappingURL=ResourceLoader.d.ts.map
declare class Base$1 {
}
declare const AbstractTexture_base: {
new (...args: any[]): {
_events: Record;
on(type: string, handler: HandlerFn): any;
once(type: string, handler: HandlerFn): any;
off(type: string, handler: HandlerFn): any;
fire(type: string, params?: BaseEventParamsType): any;
_wrapOnce(type: string, handler: HandlerFn): (params: any) => void;
};
} & typeof Base$1;
/**
* Abstract Texture
* Common methods for Texture2D and TextureCube
* @abstract
*/
declare class AbstractTexture extends AbstractTexture_base {
config: TextureConfig;
promise?: Promise;
resLoader: ResourceLoader;
dirty?: boolean;
constructor(config: any, resLoader?: any);
onLoad(data: any): void;
isReady(): boolean;
set(k: string, v: any): this;
get(k: string): any;
createREGLTexture(regl: Regl): null | Texture2D$1;
getREGLTexture(regl: any): any;
getMemorySize(): number;
_update(): void;
dispose(): void;
}
declare class BoundingBox {
min: vec3;
max: vec3;
vertex?: vec3[];
center: vec3;
constructor(min?: vec3, max?: vec3);
static copy(out: BoundingBox, bbox: BoundingBox): BoundingBox;
combine(bbox: number[] | BoundingBox): this;
dirty(): this;
/**
* Get center of the bounding box
* @returns {Number[]} center
*/
getCenter(): vec3;
/**
* 判断BBox是否包含给定的坐标
* @english
* If contain point entirely
* @param point
*/
containPoint(p: number): boolean;
/**
* BBox的值是否是Infinite
* @english
* If bounding box is finite
*/
isFinite(): boolean;
updateVertex(): vec3[];
copy(out: BoundingBox): BoundingBox;
equals(box: BoundingBox): boolean;
transform(positionMatrix: any, modelMatrix: any): this;
}
//# sourceMappingURL=BoundingBox.d.ts.map
declare class Geometry {
static padGPUGLTFAttribute(attribute: any): any;
static createElementBuffer(device: any, elements: any): any;
static createBuffer(device: any, data: any, name?: string): any;
static padGPUBufferAlignment(array: TypedArray, vertexCount: number, transient?: boolean): TypedArray;
data: Record;
elements: any;
desc: GeometryDesc;
semantic: Record;
count: number;
properties: any;
indices: NumberArray;
boundingBox: BoundingBox;
count1?: number;
offset?: number;
constructor(data: AttributeData, elements: any, count?: number, desc?: GeometryDesc);
set version(v: number);
get version(): number;
getBuffer(name: string): any;
getAttrData(activeAttributes: ActiveAttributes): any;
getREGLData(regl: any, activeAttributes: ActiveAttributes, disableVAO: boolean): AttributeData;
generateBuffers(device: any): void;
isBufferGenerated(): boolean;
getVertexCount(): number;
getColor0Size(): number;
/**
* 手动设置geometry的buffer，用于多个属性共用一个ArrayBuffer(interleaved)
* @param {String} key - 属性
* @param {ArrayBuffer|REGLBuffer} data - 数据
*/
deleteData(name: string): this;
/**
* Replace data or refill attribute data buffer
* @param {String} name - data's name
* @param {Number[] | Object} data - data to update
* @returns this
*/
updateData(name: string, data: AttributeData): this;
_updateGPUBuffer(buffer: GPUBuffer, data: AttributeData, offset: number, byteLength: number): any;
updateSubData(name: string, data: AttributeData, offset: number): this;
getPrimitive(): REGL__default.PrimitiveType;
getElements(): any;
setElements(elements: any, count: number): this;
isIndexedElements(): boolean;
deleteElements(): this;
setDrawCount(count: number): this;
getDrawCount(): number;
setDrawOffset(offset: number): this;
getDrawOffset(): number;
dispose(): void;
isDisposed(): boolean;
/**
* Update boundingBox of Geometry
*/
updateBoundingBox(): void;
createTangent(name?: string, tangentsDataArray?: Float32Array | Array): void;
createNormal(name?: string): void;
/**
* Create barycentric attribute data
* @param {String} name - attribute name for barycentric attribute
*/
createBarycentric(name?: string): void;
/**
* Build unique vertex data for each attribute
*/
buildUniqueVertex(): void;
getMemorySize(): number;
getElementsType(elements: NumberArray): "uint8" | "uint32" | "uint16";
getCommandKey(device: any): string;
getBufferDescriptor(vertexInfo: any): any[];
}
declare class EdgeGeometry extends Geometry {
constructor(data: AttributeData, elements: any, count: number, desc?: GeometryDesc);
}
declare class Base {
}
declare const Material_base: {
new (...args: any[]): {
_events: Record;
on(type: string, handler: HandlerFn): any;
once(type: string, handler: HandlerFn): any;
off(type: string, handler: HandlerFn): any;
fire(type: string, params?: BaseEventParamsType): any;
_wrapOnce(type: string, handler: HandlerFn): (params: any) => void;
};
} & typeof Base;
declare class Material extends Material_base {
uniforms: ShaderUniforms;
refCount: number;
unlit: boolean;
constructor(uniforms?: ShaderUniforms, defaultUniforms?: ShaderUniforms);
set version(v: number);
get version(): number;
get propVersion(): number;
get textureVersion(): number;
set doubleSided(value: boolean);
get doubleSided(): boolean;
getUniforms(device: any): ShaderUniforms;
getMemorySize(): number;
isReady(): boolean;
hasUniform(k: string): any;
setUniform(k: string, v: ShaderUniformValue): this;
getUniform(k: string): ShaderUniformValue;
set(k: string, v: ShaderUniformValue, isDispose?: boolean): this;
setFunctionUniform(k: string, fn: () => ShaderUniformValue): this;
hasFunctionUniform(k: string): boolean;
get(k: string): ShaderUniformValue;
isDirty(): boolean;
/**
* Get shader defines
* @return {Object}
*/
appendDefines(defines: ShaderDefines, _geometry: Geometry): ShaderDefines;
hasSkinAnimation(): boolean;
isTexture(k: string): boolean;
dispose(): void;
isDisposed(): boolean;
getUniformKeys(): string;
}
declare class WireFrameMaterial extends Material {
constructor(uniforms: ShaderUniforms);
}
//# sourceMappingURL=WireFrameMaterial.d.ts.map
declare class StandardMaterial extends Material {
constructor(uniforms: ShaderUniforms);
appendDefines(defines: ShaderDefines, geometry: Geometry): ShaderDefines;
}
//# sourceMappingURL=StandardMaterial.d.ts.map
declare class PhongMaterial extends Material {
constructor(uniforms: ShaderUniforms);
static convertFrom(standardMaterial: StandardMaterial): PhongMaterial;
appendDefines(defines: ShaderDefines, geometry: Geometry): ShaderDefines;
}
//# sourceMappingURL=PhongMaterial.d.ts.map
declare class StandardLiteMaterial extends Material {
constructor(uniforms: ShaderUniforms);
appendDefines(defines: ShaderDefines, geometry: Geometry): ShaderDefines;
}
//# sourceMappingURL=StandardLiteMaterial.d.ts.map
declare const PhongSpecularGlossinessMaterial_base: {
new (...args: any[]): {
appendDefines(defines: ShaderDefines, geometry: Geometry): ShaderDefines;
};
} & typeof PhongMaterial;
declare class PhongSpecularGlossinessMaterial extends PhongSpecularGlossinessMaterial_base {
}
//# sourceMappingURL=PhongSpecularGlossinessMaterial.d.ts.map
type DynamicBufferAllocation = {
storage?: ArrayBuffer;
gpuBuffer?: GPUBuffer;
offset?: number;
size?: number;
};
declare class DynamicBufferPool {
/**
* Allocation size of the underlying buffers.
*
*/
bufferSize: number;
/**
* Internally allocated gpu buffers.
*
*/
poolBuffers: DynamicBufferAllocation[];
usedBuffers: DynamicBufferAllocation[];
/**
* @type {DynamicBufferAllocation|null}
*/
activeBuffer: DynamicBufferAllocation;
device: GPUDevice;
bufferAlignment: number;
/**
* Create the system of dynamic buffers.
*
* @param device - The graphics device.
* @param bufferSize - The size of the underlying large buffers.
* @param bufferAlignment - Alignment of each allocation.
*/
constructor(device: GPUDevice, bufferSize: number, bufferAlignment: number);
/**
* Destroy the system of dynamic buffers.
*/
destroy(): void;
/**
* Allocate an aligned space of the given size from a dynamic buffer.
*
* @param {DynamicBufferAllocation} allocation - The allocation info to fill.
* @param {number} size - The size of the allocation.
*/
alloc(allocation: any, size: any): void;
createBuffer(device: GPUDevice, size: number): GPUBuffer;
scheduleSubmit(): void;
submit(): void;
}
declare class DynamicOffsets {
items: any[];
offsets: number[];
index: number;
constructor();
reset(): void;
addItem(binding: any, offset: any): void;
addItems(items: any[]): void;
getItems(): any[];
getDynamicOffsets(): number[];
}
declare class DynamicBuffer {
bindgroupMapping: any;
dynamicOffsets: number[];
pool: DynamicBufferPool;
allocation: DynamicBufferAllocation;
version: number;
constructor(bindgroupMapping: any, pool: DynamicBufferPool);
writeBuffer(uniformValues: Record, dynamicOffsets: DynamicOffsets): void;
_fillValue(type: any, buffer: any, offset: any, size: any, value: any): void;
dispose(): void;
}
type BindGroupResult = {
bindGroup: GPUBindGroup;
uniformTextures?: any;
};
declare class BindGroupFormat {
bytes: number;
uuid: number;
name: string;
constructor(name: any, bindGroupMapping: any, minUniformBufferOffsetAlignment: any);
getShaderUniforms(): any;
getMeshUniforms(): any;
_parse(bindGroupMapping: any): void;
createFormatBindGroup(device: GraphicsDevice, mesh: Mesh$1, shaderUniforms: ShaderUniforms, layout: GPUBindGroupLayout, shaderBuffer: DynamicBuffer, meshBuffer: DynamicBuffer): BindGroupResult;
copyTextures(bindGroup: BindGroupResult, props: any): void;
dispose(): void;
}
/**
* Config:
* transparent, castShadow
*/
declare class Mesh$1 {
uuid: number;
transparent: boolean;
bloom: boolean;
ssr: boolean;
needUpdateShadow: boolean;
picking: boolean;
disableVAO: boolean;
properties: any;
uniforms: ShaderUniforms;
dirtyDefines?: boolean;
parent?: Mesh$1;
constructor(geometry: Geometry, material?: Material, config?: MeshOptions);
set material(v: Material);
get material(): Material;
set version(v: number);
get version(): number;
get textureVersion(): number;
get geometry(): Geometry;
set geometry(geo: Geometry);
set localTransform(m: mat4);
get localTransform(): mat4;
set positionMatrix(m: mat4);
get positionMatrix(): mat4;
get config(): MeshOptions;
get defines(): ShaderDefines;
set defines(v: ShaderDefines);
get castShadow(): boolean;
set castShadow(v: boolean);
setMaterial(material: Material): this;
setParent(parent: Mesh$1): this;
setLocalTransform(transform: mat4): this;
setPositionMatrix(matrix: mat4): void;
setUniform(k: string, v: ShaderUniformValue): this;
setFunctionUniform(k: string, fn: () => ShaderUniformValue): this;
hasFunctionUniform(k: string): boolean;
hasUniform(k: string): boolean;
getUniform(k: string): ShaderUniformValue;
getDefines(): ShaderDefines;
setDefines(defines: ShaderDefines): this;
hasSkinAnimation(): boolean;
getCommandKey(device: any): string;
getRenderProps(device: any): ShaderUniforms;
appendGeoAttributes(props: any, device: any, activeAttributes: any): void;
getUniforms(device: any): ShaderUniforms;
getMaterial(): Material;
getElements(): any;
dispose(): this;
isValid(): boolean;
getBoundingBox(): [vec3, vec3];
updateBoundingBox(): void;
getMemorySize(): number;
getWorldTransform(): any;
_meshBuffer: Record;
writeDynamicBuffer(commandUID: string, renderProps: any, bindGroupMapping: BindGroupFormat, pool: DynamicBufferPool, dynamicOffsets: DynamicOffsets): DynamicBuffer;
getBindGroup(key: any): BindGroupResult;
setBindGroup(key: any, bindGroup: any): this;
getShaderFnValues(shaderUID: number): GPUBindGroup;
setShaderFnValues(shaderUID: number, fnValues: any): this;
}
declare class InstancedMesh extends Mesh$1 {
instancedData: InstancedAttribute;
constructor(instancedData: InstancedAttribute, instanceCount: number, geometry: Geometry, material?: Material, config?: MeshOptions);
get instanceCount(): number;
set instanceCount(count: number);
getMemorySize(): number;
getDefines(): ShaderDefines;
getCommandKey(device: any): string;
updateInstancedData(name: string, data: any): this;
getInstancedBuffer(name: string): any;
generateInstancedBuffers(device: any): this;
getRenderProps(regl: Regl): ShaderUniforms;
disposeInstancedData(): void;
getBufferDescriptor(vertexInfo: any): any[];
}
declare class Scene {
sortedMeshes: {
opaques?: Mesh$1[];
transparents?: Mesh$1[];
};
sortFunction?: (a: Mesh$1, b: Mesh$1) => number;
meshes?: Mesh$1[];
constructor(meshes: any);
setMeshes(meshes?: Mesh$1 | Mesh$1[]): this;
addMesh(mesh: Mesh$1 | Mesh$1[]): this;
removeMesh(mesh?: Mesh$1 | Mesh$1[]): this;
getMeshes(): Mesh$1[];
clear(): this;
dirty(): this;
sortMeshes(cameraPosition?: vec3): void;
getSortedMeshes(): {
opaques?: Mesh$1[];
transparents?: Mesh$1[];
};
}
//# sourceMappingURL=Scene.d.ts.map
/**
* A basic renderer to render meshes in fashion of forward rendering
*/
declare class Renderer {
device: any;
constructor(device: any);
render(shader: any, uniforms: Uniforms, scene: Scene, framebuffer: REGL__default.Framebuffer): number;
clear(options: REGL__default.ClearOptions): void;
isWebGPU(): boolean;
}
//# sourceMappingURL=Renderer.d.ts.map
/**
* config properties:
* https://github.com/regl-project/regl/blob/gh-pages/API.md#textures
*/
declare class Texture2D extends AbstractTexture {
_version: number;
get version(): number;
set version(version: number);
onLoad({ data }: {
data: any;
}): void;
setConfig(config: any): void;
setMinFilter(value: number): void;
setMagFilter(value: number): void;
createREGLTexture(regl: Regl): REGL__default.Texture2D;
_checkNPOT(regl: any): void;
}
declare class Plane extends Geometry {
constructor(z?: number);
}
//# sourceMappingURL=Plane.d.ts.map
/**
* 对象是否是字符串
* @english
* Check whether the object is a string
* @param obj
*/
declare function isString(obj: any): boolean;
/**
* 对象是否是null或undefined
* @english
* Whether the object is null or undefined.
* @param obj - object
*/
declare function isNil(obj: any): boolean;
declare function defined(obj: any): boolean;
/**
* 对象是否是函数
* @english
* Check whether the object is a function
* @param obj
*/
declare function isFunction(obj: any): boolean;
/**
* 将后续所有对象属性合并到第一个dest对象中
* @english
* Merges the properties of sources into destination object.
* @param dest - object to extend
* @param src - sources
*/
declare function extend(dest: any, ...src: any[]): any;
/**
* 将后续所有对象属性合并到第一个dest对象中，但忽略undefined或null的属性
* @english
* Merges the properties of sources into destination object without nil properties.
* @param dest - object to extend
* @param src - sources
*/
declare function extendWithoutNil(dest: any, ...args: any[]): any;
/**
* 检查是否是个数值
* @english
* Whether val is a number and not a NaN.
* @param val - val
*/
declare function isNumber(val: any): boolean;
/**
* 计算值的log2
* @english
* compute value's log2
* @param x - value to log
* @returns
*/
declare function log2(x: number): number;
/**
* 归一化数组
* @english
* normalize a number array
* @param out - array receives result
* @param arr - array
* @returns out
*/
declare function normalize(out: NumberArray, arr: ArrayLike): NumberArray;
/**
* 两个数值之间的比例推算
*
* @english
* Interpolate between two number.
*
* @param from - from value
* @param to - to value
* @param t - interpolation factor between 0 and 1
* @returns interpolated value
*/
declare function interpolate(a: number, b: number, t: number): number;
/**
* 检查对象是否是数组或者类型数组
* @english
* Check if is an Array or a TypedArray
* @param arr - input object
* @returns
*/
declare function isArray(arr: any): boolean;
declare function getArrayCtor(arr: any): ArrayConstructor | Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
/**
* 对两个矢量执行线性推算
*
* @english
* Performs a linear interpolation between two number's
*
* @param out - the receiving vector
* @param a - the first operand
* @param b - the second operand
* @param t - interpolation amount, in the range [0-1], between the two inputs
* @returns out
*/
declare function lerp(out: NumberArray, a: NumberArray, b: NumberArray, t: number): NumberArray;
/**
* 将input数组的值设置给out
* @english
* Set input array's value to out
* @param out - the receiving array
* @param input - input array
* @returns out
*/
declare function set(out: NumberArray, input: NumberArray): NumberArray;
/**
* 根据Position的最大值，选择一个合适的TypedArray
* @english
* Choose a TypedArray for position according to its max value
* @param max - position's max value
* @returns
*/
declare function getPosArrayType(max: number): Int8ArrayConstructor | Int16ArrayConstructor | Float32ArrayConstructor;
/**
* n大于max时返回max，n小于min时返回min，否则返回n
* @english
* Clamp input value between min and max
* @param n - input value
* @param min - min value
* @param max - max value
*/
declare function clamp(n: number, min: number, max: number): number;
declare function isSupportVAO(regl: any): any;
/**
* Object.hasOwnProperty的包装方法
* @english
* Check if object hasOwnProperty of property
* @param obj - object
* @param prop - property
* @returns
*/
declare function hasOwn(obj: any, prop: string): any;
/**
* 获取buffer的byte大小
* @english
* Get buffer's size in bytes
* @param buffer
*/
declare function getBufferSize(buffer: AttributeBufferData | AttributeType): number;
/**
* 获取regl texture对象的bytes大小
* @english
* Get regl texture size in bytes
* @param tex - regl rexture
* @returns
*/
declare function getTexMemorySize(tex: REGL__default.Texture): number;
/**
* 获取regl texture的byte width
* @english
* Get regl texture's byte width
* @param type - regl texture's type
* @returns
*/
declare function getTextureByteWidth(type: any): 4 | 1 | 2 | 0;
/**
* 获取regl texture 的channels数量
* @english
* Get regl texture's number of channels
* @param format - regl texture's format
* @returns
*/
declare function getTextureChannels(format: any): 4 | 1 | 2 | 3;
/**
* 检查该attribute数据是否处于interleaved数据中
* @english
* Check if this attribute data is in interleaved stride
* @param dataObj attribute object
* @returns
*/
declare function isInStride(dataObj: any): boolean;
/**
* 检查该attribute数据是否是interleaved
* @english
* Check if this attribute data is an interleaved data
* @param dataObj attribute object
* @returns
*/
declare function isInterleaved(dataObj: any): boolean;
/**
* 获取该webgl上下文支持的压缩纹理格式
* @english
* Get webgl context's supported formats for compressed texture
* @param gl
* @returns
*/
declare function getSupportedFormats(gl: WebGL2RenderingContext | WebGLRenderingContext | GPUDevice): {
etc: boolean;
etc1: boolean;
s3tc: boolean;
pvrtc: boolean;
astc: boolean;
bc7: boolean;
};
/**
* 获取字符串的hash值
* @english
* Get string's hash code
* @param s input string
* @returns
*/
declare function hashCode(s: string): number;
/**
* 值是否是2的n次幂
* @english
* Get the nearest power of 2 that is less than this value
* @param value - input value
* @returns
*/
declare function isPowerOfTwo(value: number): boolean;
declare function resizeToPowerOfTwo(image: HTMLImageElement | NumberArray, width?: number, height?: number): NumberArray | HTMLCanvasElement | HTMLImageElement;
declare function supportNPOT(regl: any): boolean;
declare function isTextureDestroyed(texture: any): boolean;
declare function isTextureLike(texture: any): any;
declare const Util_d_clamp: typeof clamp;
declare const Util_d_defined: typeof defined;
declare const Util_d_extend: typeof extend;
declare const Util_d_extendWithoutNil: typeof extendWithoutNil;
declare const Util_d_getArrayCtor: typeof getArrayCtor;
declare const Util_d_getBufferSize: typeof getBufferSize;
declare const Util_d_getPosArrayType: typeof getPosArrayType;
declare const Util_d_getSupportedFormats: typeof getSupportedFormats;
declare const Util_d_getTexMemorySize: typeof getTexMemorySize;
declare const Util_d_getTextureByteWidth: typeof getTextureByteWidth;
declare const Util_d_getTextureChannels: typeof getTextureChannels;
declare const Util_d_hasOwn: typeof hasOwn;
declare const Util_d_hashCode: typeof hashCode;
declare const Util_d_interpolate: typeof interpolate;
declare const Util_d_isArray: typeof isArray;
declare const Util_d_isFunction: typeof isFunction;
declare const Util_d_isInStride: typeof isInStride;
declare const Util_d_isInterleaved: typeof isInterleaved;
declare const Util_d_isNil: typeof isNil;
declare const Util_d_isNumber: typeof isNumber;
declare const Util_d_isPowerOfTwo: typeof isPowerOfTwo;
declare const Util_d_isString: typeof isString;
declare const Util_d_isSupportVAO: typeof isSupportVAO;
declare const Util_d_isTextureDestroyed: typeof isTextureDestroyed;
declare const Util_d_isTextureLike: typeof isTextureLike;
declare const Util_d_lerp: typeof lerp;
declare const Util_d_log2: typeof log2;
declare const Util_d_normalize: typeof normalize;
declare const Util_d_resizeToPowerOfTwo: typeof resizeToPowerOfTwo;
declare const Util_d_set: typeof set;
declare const Util_d_supportNPOT: typeof supportNPOT;
declare namespace Util_d {
export { Util_d_clamp as clamp, Util_d_defined as defined, Util_d_extend as extend, Util_d_extendWithoutNil as extendWithoutNil, Util_d_getArrayCtor as getArrayCtor, Util_d_getBufferSize as getBufferSize, Util_d_getPosArrayType as getPosArrayType, Util_d_getSupportedFormats as getSupportedFormats, Util_d_getTexMemorySize as getTexMemorySize, Util_d_getTextureByteWidth as getTextureByteWidth, Util_d_getTextureChannels as getTextureChannels, Util_d_hasOwn as hasOwn, Util_d_hashCode as hashCode, Util_d_interpolate as interpolate, Util_d_isArray as isArray, Util_d_isFunction as isFunction, Util_d_isInStride as isInStride, Util_d_isInterleaved as isInterleaved, Util_d_isNil as isNil, Util_d_isNumber as isNumber, Util_d_isPowerOfTwo as isPowerOfTwo, Util_d_isString as isString, Util_d_isSupportVAO as isSupportVAO, Util_d_isTextureDestroyed as isTextureDestroyed, Util_d_isTextureLike as isTextureLike, Util_d_lerp as lerp, Util_d_log2 as log2, Util_d_normalize as normalize, Util_d_resizeToPowerOfTwo as resizeToPowerOfTwo, Util_d_set as set, Util_d_supportNPOT as supportNPOT };
}
declare function parseRGBE(arrayBuffer: ArrayBufferLike, exposure?: number): {
width: number;
height: number;
pixels: any;
};
//# sourceMappingURL=HDR.d.ts.map
declare const GL_NEAREST = 9728;
declare const GL_LINEAR = 9729;
declare const GL_LINEAR_MIPMAP_LINEAR = 9987;
declare const MAG_FILTER = 10240;
declare const MIN_FILTER = 10241;
declare const WebGLConstants_d_GL_LINEAR: typeof GL_LINEAR;
declare const WebGLConstants_d_GL_LINEAR_MIPMAP_LINEAR: typeof GL_LINEAR_MIPMAP_LINEAR;
declare const WebGLConstants_d_GL_NEAREST: typeof GL_NEAREST;
declare const WebGLConstants_d_MAG_FILTER: typeof MAG_FILTER;
declare const WebGLConstants_d_MIN_FILTER: typeof MIN_FILTER;
declare namespace WebGLConstants_d {
export { WebGLConstants_d_GL_LINEAR as GL_LINEAR, WebGLConstants_d_GL_LINEAR_MIPMAP_LINEAR as GL_LINEAR_MIPMAP_LINEAR, WebGLConstants_d_GL_NEAREST as GL_NEAREST, WebGLConstants_d_MAG_FILTER as MAG_FILTER, WebGLConstants_d_MIN_FILTER as MIN_FILTER };
}
declare namespace _default$2 {
/**
* Register a new shader segment for includes for 3rd parties
* @param {String} name key name
* @param {String} source shader segment source
*/
function register(name: string, source: string): void;
/**
* Compile the given source, replace #include with registered shader sources
* @param {String} source source to compile
*/
function compile(source: string): any;
function get(name: any): any;
}
//# sourceMappingURL=ShaderLib.d.ts.map
declare const _default$1: {
register(name: any, segment: any): void;
/**
* Compile the given source, replace #include with registered shader sources
* @param {String} source source to compile
*/
compile(source: any, defines: any): any;
get(name: any): any;
};
//# sourceMappingURL=WgslShaderLib.d.ts.map
type CommandStruct = {
uid: string;
layout: GPUBindGroupLayout;
pipeline: GPURenderPipeline;
vertexInfo: any;
bindGroupFormat: BindGroupFormat;
bindGroupMapping: any;
activeAttributes: ActiveAttributes;
};
declare class GLShader {
vert: string;
frag: string;
wgslVert: string;
wgslFrag: string;
uid: number;
commandId: number;
version: number;
extraCommandProps: any;
name: string;
constructor({ vert, frag, wgslVert, wgslFrag, uniforms, defines, extraCommandProps, name }: {
vert: any;
frag: any;
wgslVert: any;
wgslFrag: any;
uniforms: any;
defines: any;
extraCommandProps: any;
name: any;
});
set shaderDefines(defines: Record);
get shaderDefines(): Record;
setDefines(defines: any): void;
/**
* The framebuffer object to render to
* Set to null to render to default display
* @param framebuffer
*/
setFramebuffer(framebuffer: any): this;
run(regl: any, command: any, props: any): any;
getShaderCommandKey(device: any, mesh: any, uniformValues: any): string;
getVersion(regl: any, source: any): "" | "#version 300 es\n" | "#version 100\n";
getActiveVars(regl: any, vert: any, frag: any, hash: any): any;
_insertDefines(source: any, defines: any): string;
createMeshCommand(regl: any, mesh: any, commandProps?: {}, _uniformValues?: any): any;
dispose(): void;
/**
* Get shader's context uniforms values
* @param {Object} meshProps - mesh uniforms
*/
appendDescUniforms(regl: any, meshProps: any): any;
/**
* Set or get context uniform to or from the shader
* @returns {this}
*/
setUniforms(uniforms: any): this;
_compileSource(): void;
}
declare class GPUShader extends GLShader {
getShaderCommandKey(device: any, mesh: any, renderProps: any): string;
createMeshCommand(device: any, mesh: Mesh$1, commandProps: any, renderProps: any): any;
_compileWGSLSource(defines: any): {
vert: any;
frag: any;
};
run(deviceOrRegl: any, command: CommandStruct, props: any): any;
_checkBindGroupOutdated(bindGroup: BindGroupResult, props: any): boolean;
_getCurrentRenderPassEncoder(device: GraphicsDevice): GPURenderPassEncoder;
setFramebuffer(framebuffer: any): this;
dispose(): void;
}
declare class MeshShader extends GPUShader {
draw(device: any, meshes: any): number;
_ensureContextDefines(v: any): void;
_runFilter(m: any): any;
getMeshCommand(device: any, mesh: any, renderProps: any): any;
_cmdKeys: {};
}
//# sourceMappingURL=MeshShader.d.ts.map
declare class WireframeShader extends MeshShader {
constructor(config?: {});
}
//# sourceMappingURL=WireframeShader.d.ts.map
declare class PhongShader extends MeshShader {
constructor(config?: {});
getGeometryDefines(geometry: any): {
HAS_TANGENT: number;
HAS_NORMAL: number;
};
}
//# sourceMappingURL=PhongShader.d.ts.map
declare class PointLineShader extends MeshShader {
constructor(config?: {});
}
//# sourceMappingURL=PointLineShader.d.ts.map
declare class QuadShader extends MeshShader {
constructor(config: any);
draw(regl: any): number;
_createQuadMesh(regl: any): void;
_quadMesh: Mesh$1[];
}
//# sourceMappingURL=QuadShader.d.ts.map
declare class FxaaShader extends QuadShader {
constructor();
}
//# sourceMappingURL=FxaaShader.d.ts.map
declare class BoxBlurShader extends QuadShader {
constructor({ blurOffset }: {
blurOffset: any;
});
_blurOffset: any;
getMeshCommand(regl: any, mesh: any): any;
}
//# sourceMappingURL=BoxBlurShader.d.ts.map
declare class ImageShader extends MeshShader {
constructor(config: any);
}
//# sourceMappingURL=ImageShader.d.ts.map
declare class PostProcessShader extends QuadShader {
constructor();
getMeshCommand(regl: any, mesh: any): any;
}
//# sourceMappingURL=PostProcessShader.d.ts.map
declare class Jitter {
constructor(ratio: any);
_frameNum: number;
_ratio: any;
_avg: number[];
getRatio(): any;
setRatio(ratio: any): void;
getAverage(): number[];
reset(): void;
getJitter(out: any): any;
frame(): void;
getSampleCount(): number;
}
//# sourceMappingURL=Jitter.d.ts.map
declare class BlurPass {
constructor(regl: any, inputRGBM: any, level?: number);
_regl: any;
_renderer: Renderer;
_inputRGBM: any;
_level: number;
render(sourceTex: any, luminThreshold: any): {
blurTex0: any;
blurTex1: any;
blurTex2: any;
blurTex3: any;
blurTex4: any;
};
_blur(curTex: any, luminThreshold: any): void;
_blurUniforms: {
rgbmRange: number;
blurDir: number[];
outSize: number[];
pixelRatio: number[];
outputSize: number[];
};
_blurOnce(shader: any, inputTex: any, output0: any, output1: any, sizeRatio: any, luminThreshold: any): void;
dispose(): void;
_createTextures(tex: any): void;
_blur00Tex: any;
_blur00FBO: any;
_blur01Tex: any;
_blur01FBO: any;
_blur10Tex: any;
_blur10FBO: any;
_blur11Tex: any;
_blur11FBO: any;
_blur20Tex: any;
_blur20FBO: any;
_blur21Tex: any;
_blur21FBO: any;
_blur30Tex: any;
_blur30FBO: any;
_blur31Tex: any;
_blur31FBO: any;
_blur40Tex: any;
_blur40FBO: any;
_blur41Tex: any;
_blur41FBO: any;
_blur50Tex: any;
_blur50FBO: any;
_blur51Tex: any;
_blur51FBO: any;
_blur60Tex: any;
_blur60FBO: any;
_blur61Tex: any;
_blur61FBO: any;
_createColorTex(curTex: any, w: any, h: any): any;
_createBlurFBO(tex: any): any;
_initShaders(): void;
_blur0Shader: QuadShader;
_blur1Shader: QuadShader;
_blur2Shader: QuadShader;
_blur3Shader: QuadShader;
_blur4Shader: QuadShader;
_blur5Shader: QuadShader;
_blur6Shader: QuadShader;
}
//# sourceMappingURL=BlurPass.d.ts.map
declare class BloomPass {
constructor(regl: any);
_regl: any;
_renderer: Renderer;
render(sourceTex: any, bloomTex: any, bloomThreshold: any, bloomFactor: any, bloomRadius: any, noAaSource: any, pointSource: any, enableAA: any, paintToScreen: any): any;
_combine(sourceTex: any, blurTexes: any, inputTex: any, bloomFactor: any, bloomRadius: any, noAaSource: any, pointSource: any, enableAA: any, paintToScreen: any): any;
_combineUniforms: {
bloomFactor: number;
bloomRadius: number;
rgbmRange: number;
TextureBloomBlur1: any;
TextureBloomBlur2: any;
TextureBloomBlur3: any;
TextureBloomBlur4: any;
TextureBloomBlur5: any;
TextureInput: any;
TextureSource: any;
outputSize: number[];
};
dispose(): void;
_createTextures(tex: any): void;
_combineTex: any;
_combineFBO: any;
_createColorTex(curTex: any, w: any, h: any, dataType: any): any;
_createBlurFBO(tex: any): any;
_initShaders(): void;
_blurPass: BlurPass;
_combineShader: QuadShader;
}
//# sourceMappingURL=BloomPass.d.ts.map
declare class CopyDepthShader extends QuadShader {
constructor();
getMeshCommand(regl: any, mesh: any): any;
}
//# sourceMappingURL=CopyDepthShader.d.ts.map
declare class SsrPass {
static getUniformDeclares(): ({
name: string;
type: string;
fn: (context: any, props: any) => mat4;
length?: undefined;
} | {
name: string;
type: string;
length: number;
fn: (context: any, props: any) => number[][];
})[];
static getDefines(): {
HAS_SSR: number;
};
constructor(regl: any);
_regl: any;
_renderer: Renderer;
_inputRGBM: number;
setup(sourceTex: any): void;
getSSRUniforms(map: any, factor: any, quality: any): {
TextureDepth: any;
TextureReflected: any;
ssrFactor: any;
ssrQuality: any;
outSize: any[];
fov: number;
prevProjViewMatrix: any;
cameraWorldMatrix: any;
};
genMipMap(sourceTex: any, depthTex: any, projViewMatrix: any): any;
_projViewMatrix: any[];
getPrevProjViewMatrix(): any[];
copyDepthTex(depthTex: any): any;
_depthCopy: any;
_depthCopyFBO: any;
_depthCopied: boolean;
_mipmap(inputTex: any): void;
_blurUniforms: {
rgbmRange: number;
outputSize: number[];
inputSize: number[];
};
getMipmapTexture(): any;
_outputTex: any;
dispose(): void;
_initShaders(): void;
_copyDepthShader: CopyDepthShader;
_ssrQuadShader: QuadShader;
_createTextures(sourceTex: any): void;
_targetFBO: any;
}
//# sourceMappingURL=SsrPass.d.ts.map
declare class HeatmapShader extends MeshShader {
constructor(config: any);
}
//# sourceMappingURL=HeatmapShader.d.ts.map
declare class SkyboxShader extends MeshShader {
constructor();
/**
* @param inputRGBM 输入的cubemap是否是rgbm格式
* @param mode 模式，0： ambient模式， 1: lod模式
*/
setMode(toneMapping: any, mode: any): this;
_meshDefines: {
TONE_MAPPING: number;
USE_AMBIENT: number;
};
draw(regl: any): number;
_createSkyboxMesh(regl: any): void;
_skyboxMesh: Mesh$1[];
}
//# sourceMappingURL=SkyboxShader.d.ts.map
declare class HeatmapDisplayShader extends MeshShader {
constructor(viewport: any, config: any);
}
declare class WaterShader extends MeshShader {
constructor(config?: {});
}
//# sourceMappingURL=WaterShader.d.ts.map
declare class CopyShader extends QuadShader {
constructor();
getMeshCommand(regl: any, mesh: any): any;
}
//# sourceMappingURL=CopyShader.d.ts.map
declare class EdgeShader extends MeshShader {
constructor(config?: {});
}
//# sourceMappingURL=EdgeShader.d.ts.map
declare class StandardLiteShader extends MeshShader {
constructor(config?: {});
}
//# sourceMappingURL=StandardLiteShader.d.ts.map
declare class EffectShader extends QuadShader {
constructor();
}
//# sourceMappingURL=EffectShader.d.ts.map
declare class FogPass {
constructor(regl: any, viewport: any, layer: any);
_regl: any;
_layer: any;
_viewport: any;
_init(): void;
_shader: MeshShader;
_fbo: any;
_scene: Scene;
renderer: Renderer;
render(meshes: any, options: any): any;
dispose(): void;
_resize(): void;
}
//# sourceMappingURL=FogPass.d.ts.map
declare class FogShader extends QuadShader {
constructor();
}
//# sourceMappingURL=FogShader.d.ts.map
declare class RainRipplePass {
constructor(regl: any, viewport: any);
_regl: any;
_viewport: any;
_init(): void;
_shader: MeshShader;
_fbo: any;
_scene: Scene;
renderer: Renderer;
_transformRipples(map: any): void;
_createRipplesMask(map: any): Mesh$1;
_fixZoom: any;
render(map: any, options: any): any;
_mesh: any;
dispose(): void;
_resize(): void;
}
declare class ExtentPass {
constructor(regl: any, viewport: any);
regl: any;
_viewport: any;
renderer: Renderer;
_init(): void;
_maskColorFbo: any;
_maskModeFbo: any;
_maskColorShader: MeshShader;
_maskModeShader: MeshShader;
_scene: Scene;
render(meshes: any, projViewMatrix: any): {
colorExtent: any;
modeExtent: any;
};
_resize(): void;
dispose(): void;
}
//# sourceMappingURL=ExtentPass.d.ts.map
declare class ScanEffectPass {
constructor(regl: any, viewport: any, layer: any);
_regl: any;
_layer: any;
_viewport: any;
_effectsLength: number;
_init(): void;
_fbo: any;
_scene: Scene;
renderer: Renderer;
render(meshes: any, options: any): any;
_shader: MeshShader;
_createFragSource(effectInfos: any): string;
_updateUniforms(uniforms: any, effectInfos: any): void;
dispose(): void;
_resize(): void;
}
//# sourceMappingURL=ScanEffectPass.d.ts.map
declare class GLTFPack {
constructor(gltf: any, regl: any);
gltf: any;
regl: any;
geometries: any[];
_emptyTexture: any;
getMeshesInfo(): any[];
getGLTFBBox(transform: any): BoundingBox;
_createSkins(skins: any): void;
_skinMap: {};
_createTextures(textures: any): void;
_textureMap: {};
_checkBaseColorFactor(): void;
_checkBaseColorFactorAlpha(): boolean;
dispose(): void;
updateAnimation(time: any, loop: any, speed: any, animationName: any, startTime: any, nodeMatrixMap: any, skinMap: any, animationNodes: any): void;
_isFirstLoop(time: any, speed: any, animationName: any, startTime: any): boolean;
hasSkinAnimation(): boolean;
_updateNodeMatrix(animationName: any, time: any, node: any, parentNodeMatrix: any, nodeMatrixMap: any, animationNodes: any): void;
_updateNodeTRS(node: any, time: any, animationName: any): void;
_updateMorph(node: any, weights: any): void;
_parserNode(node: any, geometries: any, parentNodeMatrix: any): void;
_isAnimation: boolean;
_createMaterialInfo(materialIndex: any): {
baseColorTexture: any;
khr_offset: any;
khr_rotation: any;
khr_scale: any;
baseColorFactor: any;
metallicRoughnessTexture: any;
metallicFactor: any;
roughnessFactor: any;
name: string;
normalTexture: any;
occlusionTexture: any;
emissiveTexture: any;
emissiveFactor: any;
alphaCutoff: any;
doubleSided: any;
alphaMode: any;
};
_createExtralInfo(material: any): {
doubleSided: any;
alphaMode: any;
};
_getTexture(texInfo: any): any;
_toTexture(texture: any): any;
/**
*
* @param map
* @param from
* @param to
* @param dist
* @param rotationZ 模型绕Z轴旋转角度，弧度
* @param rotationXY 模型绕Z轴与线段的交叉轴的旋转角度，弧度
* @param gltfScale
* @param projectionScale
* @param options
* @returns
*/
arrangeAlongLine(from: any, to: any, xyDist: any, gltfScale: any, projectionScale: any, rotationScaleMat: any, options: any): {
coordinates: any;
t: number;
scale: number[];
rotation: number[];
rotationZ: number;
rotationXY: number;
}[];
calModelHeightScale(out: any, modelHeight: any): vec3;
_calBoxWidth(scale: any, rotationScaleMat: any, options: any): any;
_getRotationZ(from: any, to: any): number;
_getRotationXY(xyDist: any, zDist: any): number;
}
declare function load(url: any, options: any): any;
declare function exportGLTFPack(gltf: any, regl: any): GLTFPack;
declare function loadGLTF(root: any, gltf: any, loaderOptions: any): any;
declare const GLTFHelper_d_exportGLTFPack: typeof exportGLTFPack;
declare const GLTFHelper_d_load: typeof load;
declare const GLTFHelper_d_loadGLTF: typeof loadGLTF;
declare namespace GLTFHelper_d {
export { GLTFHelper_d_exportGLTFPack as exportGLTFPack, GLTFHelper_d_load as load, GLTFHelper_d_loadGLTF as loadGLTF };
}
declare class GLTFManager {
constructor(regl: any, options: any);
regl: any;
resourceMap: {};
options: any;
getGLTF(url: any): any;
loginGLTF(url: any, requestor: any): void;
logoutGLTF(url: any): void;
isSimpleModel(url: any): any;
addSimpleModel(id: any, gltfData: any): void;
removeSimpleModel(id: any): void;
_exportGLTFResource(gltf: any, url: any, useUniqueREGLBuffer?: boolean): {
bbox: BoundingBox;
gltfPack: GLTFPack;
resources: any[];
json: any;
refCount: any;
};
fetchGLTF(url: any): any;
_loadGLTFModel(url: any): any;
}
declare function getPrimitive(mode: any): string;
declare function getMaterialType(type: any): any;
declare function getArrayType(array: any): "uint8" | "float" | "uint16" | "int8" | "int16";
declare function getMaterialFormat(format: any): any;
declare function getTextureMagFilter(filter: any): any;
declare function getTextureMinFilter(filter: any): any;
declare function getTextureWrap(wrap: any): any;
declare function getUniqueREGLBuffer(regl: any, data: any, options: any): any;
declare function getUniqueTexture(regl: any, texConfig: any): any;
declare const REGLHelper_d_getArrayType: typeof getArrayType;
declare const REGLHelper_d_getMaterialFormat: typeof getMaterialFormat;
declare const REGLHelper_d_getMaterialType: typeof getMaterialType;
declare const REGLHelper_d_getPrimitive: typeof getPrimitive;
declare const REGLHelper_d_getTextureMagFilter: typeof getTextureMagFilter;
declare const REGLHelper_d_getTextureMinFilter: typeof getTextureMinFilter;
declare const REGLHelper_d_getTextureWrap: typeof getTextureWrap;
declare const REGLHelper_d_getUniqueREGLBuffer: typeof getUniqueREGLBuffer;
declare const REGLHelper_d_getUniqueTexture: typeof getUniqueTexture;
declare namespace REGLHelper_d {
export { REGLHelper_d_getArrayType as getArrayType, REGLHelper_d_getMaterialFormat as getMaterialFormat, REGLHelper_d_getMaterialType as getMaterialType, REGLHelper_d_getPrimitive as getPrimitive, REGLHelper_d_getTextureMagFilter as getTextureMagFilter, REGLHelper_d_getTextureMinFilter as getTextureMinFilter, REGLHelper_d_getTextureWrap as getTextureWrap, REGLHelper_d_getUniqueREGLBuffer as getUniqueREGLBuffer, REGLHelper_d_getUniqueTexture as getUniqueTexture };
}
/**
* {
* envTexture,
* envCubeSize,
* irradianceCubeSize,
* sampleSize,
* roughnessLevels,
* prefilterCubeSize,
* dfgSize
* }
* @param regl - regl
* @param config - config
*/
declare function createIBLMaps(regl: any, config?: {}): {
envMap: any;
isHDR: boolean;
prefilterMap: any;
};
declare function createIBLMapsAsync(regl: any, config?: {}): Promise;
declare function generateDFGLUT(device: any, size: any, sampleSize: any, roughnessLevels: any): any;
declare function supportFloat16(regl: any): any;
declare const PBRHelper_createIBLMaps: typeof createIBLMaps;
declare const PBRHelper_createIBLMapsAsync: typeof createIBLMapsAsync;
declare const PBRHelper_generateDFGLUT: typeof generateDFGLUT;
declare const PBRHelper_supportFloat16: typeof supportFloat16;
declare namespace PBRHelper {
export { PBRHelper_createIBLMaps as createIBLMaps, PBRHelper_createIBLMapsAsync as createIBLMapsAsync, PBRHelper_generateDFGLUT as generateDFGLUT, PBRHelper_supportFloat16 as supportFloat16 };
}
declare const StandardSpecularGlossinessMaterial_base: {
new (...args: any[]): {
appendDefines(defines: ShaderDefines, geometry: Geometry): ShaderDefines;
};
} & typeof StandardMaterial;
declare class StandardSpecularGlossinessMaterial extends StandardSpecularGlossinessMaterial_base {
}
//# sourceMappingURL=StandardSpecularGlossinessMaterial.d.ts.map
declare class StandardShader extends MeshShader {
constructor(config?: {});
getGeometryDefines(geometry: any): {
HAS_TANGENT: number;
HAS_NORMAL: number;
HAS_COLOR: number;
HAS_COLOR0: number;
COLOR0_SIZE: any;
};
}
//# sourceMappingURL=StandardShader.d.ts.map
declare class StandardDepthShader extends MeshShader {
constructor(config?: {});
}
//# sourceMappingURL=StandardDepthShader.d.ts.map
declare function loginIBLResOnCanvas(canvas: any, regl: any, map: any): {
dfgLUT: any;
iblTexes: any;
};
declare function getIBLResOnCanvas(canvas: any): {
dfgLUT: any;
iblTexes: any;
};
declare function logoutIBLResOnCanvas(canvas: any, map: any): void;
declare function getPBRUniforms(map: any, iblTexes: any, dfgLUT: any, ssr: any, jitter: any): any;
declare function createIBLTextures(regl: any, map: any): {
prefilterMap: any;
envMap: any;
sh: any;
};
declare function disposeIBLTextures(iblTexes: any): void;
declare function isSupported(regl: any): any;
declare const PBRUtils_createIBLTextures: typeof createIBLTextures;
declare const PBRUtils_disposeIBLTextures: typeof disposeIBLTextures;
declare const PBRUtils_getIBLResOnCanvas: typeof getIBLResOnCanvas;
declare const PBRUtils_getPBRUniforms: typeof getPBRUniforms;
declare const PBRUtils_isSupported: typeof isSupported;
declare const PBRUtils_loginIBLResOnCanvas: typeof loginIBLResOnCanvas;
declare const PBRUtils_logoutIBLResOnCanvas: typeof logoutIBLResOnCanvas;
declare namespace PBRUtils {
export { PBRUtils_createIBLTextures as createIBLTextures, PBRUtils_disposeIBLTextures as disposeIBLTextures, PBRUtils_getIBLResOnCanvas as getIBLResOnCanvas, PBRUtils_getPBRUniforms as getPBRUniforms, PBRUtils_isSupported as isSupported, PBRUtils_loginIBLResOnCanvas as loginIBLResOnCanvas, PBRUtils_logoutIBLResOnCanvas as logoutIBLResOnCanvas };
}
declare class BoxShadowBlurShader extends QuadShader {
constructor({ blurOffset }: {
blurOffset: any;
});
_blurOffset: any;
getMeshCommand(regl: any, mesh: any): any;
}
//# sourceMappingURL=BoxShadowBlurShader.d.ts.map
declare class ShadowMapShader extends MeshShader {
constructor(defines: any);
filter(mesh: any): any;
}
//# sourceMappingURL=ShadowMapShader.d.ts.map
declare class ShadowPass {
constructor(renderer: any, { width, height, blurOffset, defines }: {
width: any;
height: any;
blurOffset: any;
defines: any;
});
renderer: any;
width: any;
height: any;
blurOffset: any;
render(scene: any, { cameraProjViewMatrix, lightDir, farPlane, cameraLookAt }: {
cameraProjViewMatrix: any;
lightDir: any;
farPlane: any;
cameraLookAt: any;
}): {
lightProjViewMatrix: any;
shadowMap: any;
depthFBO: any;
blurFBO: any;
};
resize(width: any, height: any): this;
_renderShadow(scene: any, cameraProjViewMatrix: any, lightDir: any, farPlane: any, cameraLookAt: any): any;
boxBlurShader: BoxShadowBlurShader;
_init(defines: any): void;
depthTex: any;
shadowMapShader: ShadowMapShader;
depthFBO: any;
blurTex: any;
blurFBO: any;
dispose(): void;
}
//# sourceMappingURL=ShadowPass.d.ts.map
declare class ShadowDisplayShader extends MeshShader {
constructor(defines: any);
getMeshCommand(regl: any, mesh: any): any;
}
//# sourceMappingURL=ShadowDisplayShader.d.ts.map
declare class FBORayPicking {
constructor(renderer: any, { name, vert, wgslVert, uniforms, defines, extraCommandProps, enableStencil }: {
name: any;
vert: any;
wgslVert: any;
uniforms: any;
defines: any;
extraCommandProps: any;
enableStencil: any;
}, fbo: any, map: any);
_renderer: any;
_fbo: any;
_map: any;
_name: any;
_vert: any;
_wgslVert: any;
_uniforms: any;
_defines: any;
_extraCommandProps: any;
_currentMeshes: any[];
_init(): void;
_shader0: MeshShader;
_shader2: MeshShader;
_shader1: MeshShader;
_depthShader: MeshShader;
_scene: Scene;
_scene1: Scene;
filter(): boolean;
/**
* Render meshes to fbo for further picking
* @param {Mesh[]} meshes - meshes to render
* @param {Object} uniforms - uniform values
* @param {Boolean} once - if it's an one time rendering which can gain some performance improvement
*/
render(meshes: Mesh[], uniforms: any, once?: boolean): this;
_currentShader: any;
pickAll(x: any, y: any, tolerance: any, uniforms: any, options: any): {
meshId: number;
pickingId: any;
point: number[];
coordinate: any[];
}[];
pick(x: any, y: any, tolerance: any, uniforms: any, options?: {}): {
meshId: number;
pickingId: any;
point: number[];
coordinate: any[];
} | {
pickingId: any;
meshId: any;
point: any;
coordinate?: undefined;
};
_pick(x: any, y: any, tolerance: any, uniforms: any, options?: {}): {
pickingId: any;
meshId: any;
point: any;
meshIds?: undefined;
pickingIds?: undefined;
coords?: undefined;
points?: undefined;
width?: undefined;
height?: undefined;
} | {
meshIds: number[];
pickingIds: any[];
coords: any[][];
points: number[][];
width: number;
height: number;
pickingId?: undefined;
meshId?: undefined;
point?: undefined;
};
_convertPickPoint(point: any): any[];
clear(): this;
getMeshAt(idx: any): any;
getRenderedMeshes(): any[];
dispose(): void;
_getWorldPos(x: any, y: any, depth: any, viewMatrix: any, projMatrix: any): number[];
_getPickingId(x: any, y: any, width: any, height: any, pixels: any, meshes: any, uniforms: any): any[];
_pickDepth(x: any, y: any, width: any, height: any, pixels: any, meshes: any, uniforms: any): number[];
_packData(data: any, shader: any): {
meshId: number;
pickingId: number;
};
_clearFbo(framebuffer: any): void;
_getShader(meshes: any, once: any): MeshShader;
_getFBO1(): any;
_fbo1: any;
_debugFBO(fbo: any): void;
_getParams(px: any, py: any, tolerance: any, fbo: any): {
px: any;
py: any;
width: number;
height: number;
};
getPickingVert(): any;
getPickingWGSLVert(): any;
getUniformDeclares(): any;
}
declare const KEY_DISPOSED = "__reshader_disposed";
declare const WEBGL_EXTENSIONS: string[];
declare const WEBGL_OPTIONAL_EXTENSIONS: string[];
declare const ERROR_NOT_IMPLEMENTED = "not implemented";
declare const Constants_d_ERROR_NOT_IMPLEMENTED: typeof ERROR_NOT_IMPLEMENTED;
declare const Constants_d_KEY_DISPOSED: typeof KEY_DISPOSED;
declare const Constants_d_WEBGL_EXTENSIONS: typeof WEBGL_EXTENSIONS;
declare const Constants_d_WEBGL_OPTIONAL_EXTENSIONS: typeof WEBGL_OPTIONAL_EXTENSIONS;
declare namespace Constants_d {
export { Constants_d_ERROR_NOT_IMPLEMENTED as ERROR_NOT_IMPLEMENTED, Constants_d_KEY_DISPOSED as KEY_DISPOSED, Constants_d_WEBGL_EXTENSIONS as WEBGL_EXTENSIONS, Constants_d_WEBGL_OPTIONAL_EXTENSIONS as WEBGL_OPTIONAL_EXTENSIONS };
}
declare class KHRTechniquesWebglManager {
constructor(regl: any, extraCommandProps: any, resLoader: any);
_regl: any;
_khrShaders: {};
_commandProps: any;
_resLoader: any;
getExcludeFilter(): (mesh: any) => boolean;
/**
* 遍历Shader
*
* */
forEachShader(cb: any): void;
createMesh(primitive: any, gltf: any, excludeElementsInVAO: any, useWebGL2: any): {
geometry: Geometry;
material: Material;
};
_createGeometry(gltfMesh: any, attributeSemantics: any, excludeElementsInVAO: any, shaderHash: any): Geometry;
_getTexture(texInfo: any): Texture2D;
_createTechniqueShader(hash: any, extension: any, techIndex: any, extraCommandProps: any, useWebGL2: any): {
shader: MeshShader;
filter: (mesh: any) => boolean;
uniformSemantics: {};
attributeSemantics: {};
};
dispose(): void;
}
/*!
* codes from GEngine
* https://github.com/GEngine-js/GEngine/blob/e9c0e2c4a28cc6b9fec133c75958b80115e53a63/src/shader/WGSLParseDefines.ts
* ISC License
*/
declare function WGSLParseDefines(shader: string, meshDefines: ShaderDefines): string;
declare function getDefineConditionValue(define: any, defines: any, usedDefines: any): any;
declare const WGSLParseDefines_d_WGSLParseDefines: typeof WGSLParseDefines;
declare const WGSLParseDefines_d_getDefineConditionValue: typeof getDefineConditionValue;
declare namespace WGSLParseDefines_d {
export { WGSLParseDefines_d_WGSLParseDefines as WGSLParseDefines, WGSLParseDefines_d_getDefineConditionValue as getDefineConditionValue };
}
declare const HDR: {
parseHDR: typeof parseRGBE;
};
declare const pbr: {
PBRHelper: typeof PBRHelper;
StandardMaterial: typeof StandardMaterial;
StandardSpecularGlossinessMaterial: typeof StandardSpecularGlossinessMaterial;
StandardShader: typeof StandardShader;
StandardDepthShader: typeof StandardDepthShader;
PBRUtils: typeof PBRUtils;
};
declare const earcut: any;
//# sourceMappingURL=index.d.ts.map
type index_d_AbstractTexture = AbstractTexture;
declare const index_d_AbstractTexture: typeof AbstractTexture;
type index_d_BloomPass = BloomPass;
declare const index_d_BloomPass: typeof BloomPass;
type index_d_BoundingBox = BoundingBox;
declare const index_d_BoundingBox: typeof BoundingBox;
type index_d_BoxBlurShader = BoxBlurShader;
declare const index_d_BoxBlurShader: typeof BoxBlurShader;
type index_d_CopyShader = CopyShader;
declare const index_d_CopyShader: typeof CopyShader;
type index_d_EdgeGeometry = EdgeGeometry;
declare const index_d_EdgeGeometry: typeof EdgeGeometry;
type index_d_EdgeShader = EdgeShader;
declare const index_d_EdgeShader: typeof EdgeShader;
type index_d_ExtentPass = ExtentPass;
declare const index_d_ExtentPass: typeof ExtentPass;
type index_d_FBORayPicking = FBORayPicking;
declare const index_d_FBORayPicking: typeof FBORayPicking;
type index_d_FogPass = FogPass;
declare const index_d_FogPass: typeof FogPass;
type index_d_FogShader = FogShader;
declare const index_d_FogShader: typeof FogShader;
type index_d_FxaaShader = FxaaShader;
declare const index_d_FxaaShader: typeof FxaaShader;
type index_d_GLTFManager = GLTFManager;
declare const index_d_GLTFManager: typeof GLTFManager;
type index_d_Geometry = Geometry;
declare const index_d_Geometry: typeof Geometry;
type index_d_GraphicsDevice = GraphicsDevice;
declare const index_d_GraphicsDevice: typeof GraphicsDevice;
type index_d_GraphicsFramebuffer = GraphicsFramebuffer;
declare const index_d_GraphicsFramebuffer: typeof GraphicsFramebuffer;
type index_d_GraphicsTexture = GraphicsTexture;
declare const index_d_GraphicsTexture: typeof GraphicsTexture;
declare const index_d_HDR: typeof HDR;
type index_d_HeatmapDisplayShader = HeatmapDisplayShader;
declare const index_d_HeatmapDisplayShader: typeof HeatmapDisplayShader;
type index_d_HeatmapShader = HeatmapShader;
declare const index_d_HeatmapShader: typeof HeatmapShader;
type index_d_ImageShader = ImageShader;
declare const index_d_ImageShader: typeof ImageShader;
type index_d_InstancedMesh = InstancedMesh;
declare const index_d_InstancedMesh: typeof InstancedMesh;
type index_d_Jitter = Jitter;
declare const index_d_Jitter: typeof Jitter;
type index_d_KHRTechniquesWebglManager = KHRTechniquesWebglManager;
declare const index_d_KHRTechniquesWebglManager: typeof KHRTechniquesWebglManager;
type index_d_Material = Material;
declare const index_d_Material: typeof Material;
type index_d_MeshShader = MeshShader;
declare const index_d_MeshShader: typeof MeshShader;
type index_d_PhongMaterial = PhongMaterial;
declare const index_d_PhongMaterial: typeof PhongMaterial;
type index_d_PhongShader = PhongShader;
declare const index_d_PhongShader: typeof PhongShader;
type index_d_PhongSpecularGlossinessMaterial = PhongSpecularGlossinessMaterial;
declare const index_d_PhongSpecularGlossinessMaterial: typeof PhongSpecularGlossinessMaterial;
type index_d_Plane = Plane;
declare const index_d_Plane: typeof Plane;
type index_d_PointLineShader = PointLineShader;
declare const index_d_PointLineShader: typeof PointLineShader;
type index_d_PostProcessShader = PostProcessShader;
declare const index_d_PostProcessShader: typeof PostProcessShader;
type index_d_QuadShader = QuadShader;
declare const index_d_QuadShader: typeof QuadShader;
type index_d_Renderer = Renderer;
declare const index_d_Renderer: typeof Renderer;
type index_d_ResourceLoader = ResourceLoader;
declare const index_d_ResourceLoader: typeof ResourceLoader;
type index_d_ScanEffectPass = ScanEffectPass;
declare const index_d_ScanEffectPass: typeof ScanEffectPass;
type index_d_Scene = Scene;
declare const index_d_Scene: typeof Scene;
type index_d_ShadowDisplayShader = ShadowDisplayShader;
declare const index_d_ShadowDisplayShader: typeof ShadowDisplayShader;
type index_d_ShadowMapShader = ShadowMapShader;
declare const index_d_ShadowMapShader: typeof ShadowMapShader;
type index_d_ShadowPass = ShadowPass;
declare const index_d_ShadowPass: typeof ShadowPass;
type index_d_SkyboxShader = SkyboxShader;
declare const index_d_SkyboxShader: typeof SkyboxShader;
type index_d_SsrPass = SsrPass;
declare const index_d_SsrPass: typeof SsrPass;
type index_d_StandardLiteMaterial = StandardLiteMaterial;
declare const index_d_StandardLiteMaterial: typeof StandardLiteMaterial;
type index_d_StandardLiteShader = StandardLiteShader;
declare const index_d_StandardLiteShader: typeof StandardLiteShader;
type index_d_Texture2D = Texture2D;
declare const index_d_Texture2D: typeof Texture2D;
type index_d_WaterShader = WaterShader;
declare const index_d_WaterShader: typeof WaterShader;
type index_d_WireFrameMaterial = WireFrameMaterial;
declare const index_d_WireFrameMaterial: typeof WireFrameMaterial;
type index_d_WireframeShader = WireframeShader;
declare const index_d_WireframeShader: typeof WireframeShader;
declare const index_d_earcut: typeof earcut;
declare const index_d_glMatrix: typeof glMatrix;
declare const index_d_mat2: typeof mat2;
declare const index_d_mat2d: typeof mat2d;
declare const index_d_mat3: typeof mat3;
declare const index_d_mat4: typeof mat4;
declare const index_d_pbr: typeof pbr;
declare const index_d_quat: typeof quat;
declare const index_d_quat2: typeof quat2;
declare const index_d_vec2: typeof vec2;
declare const index_d_vec3: typeof vec3;
declare const index_d_vec4: typeof vec4;
declare namespace index_d {
export { index_d_AbstractTexture as AbstractTexture, index_d_BloomPass as BloomPass, index_d_BoundingBox as BoundingBox, index_d_BoxBlurShader as BoxBlurShader, Constants_d as Constants, index_d_CopyShader as CopyShader, index_d_EdgeGeometry as EdgeGeometry, index_d_EdgeShader as EdgeShader, index_d_ExtentPass as ExtentPass, index_d_FBORayPicking as FBORayPicking, index_d_FogPass as FogPass, index_d_FogShader as FogShader, index_d_FxaaShader as FxaaShader, GLTFHelper_d as GLTFHelper, index_d_GLTFManager as GLTFManager, index_d_Geometry as Geometry, index_d_GraphicsDevice as GraphicsDevice, index_d_GraphicsFramebuffer as GraphicsFramebuffer, index_d_GraphicsTexture as GraphicsTexture, index_d_HDR as HDR, index_d_HeatmapDisplayShader as HeatmapDisplayShader, index_d_HeatmapShader as HeatmapShader, index_d_ImageShader as ImageShader, index_d_InstancedMesh as InstancedMesh, index_d_Jitter as Jitter, index_d_KHRTechniquesWebglManager as KHRTechniquesWebglManager, index_d_Material as Material, Mesh$1 as Mesh, index_d_MeshShader as MeshShader, index_d_PhongMaterial as PhongMaterial, index_d_PhongShader as PhongShader, index_d_PhongSpecularGlossinessMaterial as PhongSpecularGlossinessMaterial, index_d_Plane as Plane, index_d_PointLineShader as PointLineShader, index_d_PostProcessShader as PostProcessShader, index_d_QuadShader as QuadShader, REGLHelper_d as REGLHelper, RainRipplePass as RainRipplesPass, index_d_Renderer as Renderer, index_d_ResourceLoader as ResourceLoader, index_d_ScanEffectPass as ScanEffectPass, EffectShader as ScanEffectShader, index_d_Scene as Scene, GPUShader as Shader, _default$2 as ShaderLib, index_d_ShadowDisplayShader as ShadowDisplayShader, index_d_ShadowMapShader as ShadowMapShader, index_d_ShadowPass as ShadowPass, index_d_SkyboxShader as SkyboxShader, index_d_SsrPass as SsrPass, index_d_StandardLiteMaterial as StandardLiteMaterial, index_d_StandardLiteShader as StandardLiteShader, index_d_Texture2D as Texture2D, Util_d as Util, WGSLParseDefines_d as WGSLParseDefines, index_d_WaterShader as WaterShader, WebGLConstants_d as WebGLConstants, _default$1 as WgslShaderLib, index_d_WireFrameMaterial as WireFrameMaterial, index_d_WireframeShader as WireframeShader, index_d_earcut as earcut, index_d_glMatrix as glMatrix, index_d_mat2 as mat2, index_d_mat2d as mat2d, index_d_mat3 as mat3, index_d_mat4 as mat4, index_d_pbr as pbr, index_d_quat as quat, index_d_quat2 as quat2, index_d_vec2 as vec2, index_d_vec3 as vec3, index_d_vec4 as vec4 };
}
declare class Mask extends Polygon {
getMode(): any;
remove(): this;
getMesh(regl: any, ratio: any, minHeight: any): any;
_mesh: any;
setCoordinates(coordinates: any): this;
_createGeometry(regl: any): Geometry | {
geometry: Geometry;
copyGeometry: Geometry;
};
_createPOSITION(data: any, hasHeight: any): {
positions: number[];
uvs: number[];
triangles: any;
};
_createTexcoords(vertices: any, dimension: any): number[];
_createBilinearPOSITON(data: any): {
positions: number[];
uvs: number[];
triangles: number[];
};
_positions: any[];
clearMesh(): void;
maskGeoJSON: any;
_getMaskMode(): any;
_getMaskColor(): any;
_altitudeToPoint(altitude?: number): number;
_setLocalTransform(mesh: any): void;
_dispose(): void;
containsPoint(coordinate: any): boolean;
_contains(coordinates: any, coordinate: any): boolean;
_calArea(coordinates: any): number;
}
declare class GroupGLLayer extends maptalks.Layer {
/**
* Reproduce a GroupGLLayer from layer's profile JSON.
* @param {Object} layerJSON - layer's profile JSON
* @return {GroupGLLayer}
* @static
* @private
* @function
*/
static fromJSON(layerJSON: object): GroupGLLayer;
options: GroupGLLayerOptions;
layers: maptalks.Layer[];
/**
* @param id - layer's id
* @param layers - layers to add
* @param [options=null] - construct options
*/
constructor(id: string, layers: maptalks.Layer[], options: GroupGLLayerOptions);
sortLayersByZIndex(): void;
setSceneConfig(sceneConfig: GroupGLLayerSceneConfig): this;
getSceneConfig(): GroupGLLayerSceneConfig;
getGroundConfig(): SceneGround;
getWeatherConfig(): SceneWeather;
getScanEffectConfig(): ScanEffect;
/**
* Add a new Layer.
* @param layer - new layer
* @param index - index to insert
* @returns {GroupGLLayer} this
*/
addLayer(layer: maptalks.Layer, index?: number): this;
removeLayer(layer: maptalks.Layer): this;
clearLayers(): this;
getPolygonOffsetCount(): number;
/**
* Get children TileLayer
* @returns {TileLayer[]}
*/
getLayers(): maptalks.Layer[];
/**
* 导出GroupGLLayer的序列化JSON对象，可以用于反序列化为一个GroupGLLayer对象。
* @english
* Export the GroupGLLayer's profile json.
* Layer's profile is a snapshot of the layer in JSON format.
* It can be used to reproduce the instance by [fromJSON]{@link Layer#fromJSON} method
* @return layer's profile JSON
*/
toJSON(): LayerJSONType;
onLoadEnd(): void;
_onChildLayerZIndexChanged(): void;
onRemove(): void;
getChildLayer(id: string): maptalks.Layer | null;
getLayer(id: string): maptalks.Layer | null;
addAnalysis(analysis: Analysis): void;
removeAnalysis(analysis: Analysis): void;
clearAnalysis(): void;
/**
* 查询给定坐标上的数据要素
*
* @english
* Identify the geometries on the given coordinate
* @param coordinate - coordinate to identify
* @param options - options
* @return
*/
identify(coordinate: maptalks.Coordinate, options: object): any[];
/**
* 查询给定容器坐标（containerPoint）上的数据要素
* @english
* Identify the data at the given point
* @param point - container point to identify
* @param options - the identify options
**/
identifyAtPoint(point: maptalks.Point, options?: any): any[];
getTerrain(): TerrainOptions | undefined | null;
setTerrain(info: TerrainOptions | null): this;
removeTerrain(): this;
updateTerrainMaterial(mat: object): void;
queryTerrain(coord: maptalks.Coordinate, out: QueryHitResult): QueryHitResult;
queryTerrainAtPoint(containerPoint: maptalks.Point): any;
query3DTilesAtPoint(containerPoint: maptalks.Point): maptalks.Coordinate;
_queryRayCast(containerPoint: maptalks.Point, meshes: any[]): any;
queryTerrainByProjCoord(projCoord: maptalks.Coordinate, out: QueryHitResult): QueryHitResult;
getTerrainLayer(): TerrainLayer | undefined;
fire(...args: any[]): void;
}
type TerrainOptions = {
type: 'mapbox' | 'tianditu' | 'cesium' | 'cesium-ion';
urlTemplate: string;
spatialReference?: string;
shader?: 'lit' | 'default';
subdomains?: string[];
tileSystem?: number[];
tileSize?: number;
zoomOffset?: number;
requireSkuToken?: boolean;
depthMask?: boolean;
depthFunc?: ComparisonOperatorType;
blendSrc?: BlendingFunction;
blendDst?: BlendingFunction;
material?: object;
masks?: Mask[];
};
type QueryHitResult = [number | null, 0 | 1];
type GroupGLLayerOptions = {
renderer?: 'gl';
antialias?: true;
extensions?: string[];
single?: boolean;
onlyWebGL1?: boolean;
optionalExtensions?: string[];
forceRenderOnZooming?: true;
forceRenderOnMoving?: true;
forceRenderOnRotating?: true;
viewMoveThreshold?: number;
geometryEvents?: boolean;
multiSamples?: number;
forceRedrawPerFrame?: boolean;
sceneConfig?: GroupGLLayerSceneConfig;
terrain?: TerrainOptions;
};
declare enum SkyboxMode {
AMBIENT = 0,
REALISTIC = 1
}
type SceneEnvironment = {
enable: boolean;
mode?: SkyboxMode;
level?: 0 | 1 | 2 | 3;
brightness?: number;
};
type SceneGround = {
enable?: boolean;
renderPlugin: {
type: 'lit' | 'fill';
};
symbol: {
ssr?: true;
material?: any;
polygonFill?: number[];
polygonOpacity?: number;
};
};
type SceneWeather = {
enable?: boolean;
fog?: {
enable?: boolean;
start?: number;
end?: number;
color?: number[];
};
rain?: {
enable?: boolean;
density?: number;
windDirectionX?: number;
windDirectionY?: number;
rainTexture: string;
};
snow?: {
enable?: boolean;
};
};
type ScanEffectItem = {
center: maptalks.Coordinate;
radius: number;
speed: number;
color: number[];
};
type ScanEffect = {
enable?: boolean;
effects: ScanEffectItem[];
};
type SceneShadow = {
enable?: boolean;
type?: 'esm';
quality?: 'low' | 'medium' | 'high';
opacity?: number;
color?: number[];
blurOffset?: number;
};
type ScenePostProcess = {
enable?: boolean;
antialias?: {
enable?: boolean;
};
ssr?: {
enable?: boolean;
};
sharpen?: {
enable?: boolean;
factor?: number;
};
bloom?: {
enable?: boolean;
factor?: number;
threshold?: number;
radius?: number;
};
outline: {
enable?: boolean;
highlightFactor?: number;
outlineFactor?: number;
outlineWidth?: number;
outlineColor?: number[];
};
scanEffect?: ScanEffect;
};
type GroupGLLayerSceneConfig = {
environment?: SceneEnvironment;
shadow?: SceneShadow;
ground?: SceneGround;
weather?: SceneWeather;
postProcess?: ScenePostProcess;
};
declare class GroundPainter {
renderer: Renderer;
static getGroundTransform(out: any, map: any): any;
constructor(regl: any, layer: any);
needToRedraw(): any;
getMap(): any;
getSymbol(): any;
isEnable(): any;
paint(context: any): boolean;
_isInSSRPhase(context: any): boolean;
update(): void;
setToRedraw(): void;
dispose(): void;
_getShader(): any;
_getUniformValues(context: any): any;
_getCommonUniforms(context: any): any;
_setIncludeUniformValues(uniforms: any, context: any): void;
_disposeIblTextures(): void;
_init(): void;
_getExtraCommandProps(): {
viewport: {
x: number;
y: number;
width: () => any;
height: () => any;
};
cull: {
enable: boolean;
};
depth: {
enable: boolean;
mask: () => any;
range: () => any;
func: string;
};
blend: {
enable: boolean;
func: {
src: string;
dst: string;
};
equation: string;
};
polygonOffset: {
enable: boolean;
offset: {
factor: (context: any, props: any) => any;
units: (context: any, props: any) => any;
};
};
};
_hasIBL(): boolean;
_createGround(): void;
_transformGround(): void;
_getGroundDefines(context: any): any;
_updateMaterial(): void;
_onMaterialComplete(): void;
_createPatternTexture(image: any): any;
_parseColor(c: any): any;
_getUVOffsetAnim(): any;
getRenderMeshes(): Mesh$1[];
}
//# sourceMappingURL=GroundPainter.d.ts.map
declare const canvasCompatible: (Base: T) => {
new (...args: any[]): {
[x: string]: any;
createContext(): void;
};
} & T;
//# sourceMappingURL=CanvasCompatible.d.ts.map
declare class MapGLRenderer extends renderer.MapAbstractRenderer {
clearLayerCanvasContext(layer: any): void;
gl: any;
regl: REGL.Regl;
reglGL: any;
device: REGL.Regl;
_initGL(): void;
getContextInstance(): any;
}
declare class MapGPURenderer extends MapGLRenderer {
device: any;
drawLayers(layers: Layer[], framestamp: number): boolean;
createContext(): Promise;
isWebGL(): boolean;
isWebGPU(): boolean;
}
declare function clearShowOnly(mesh: any): void;
declare function showOnly(regl: any, mesh: any, items: any, timestamp: any, feaIdIndiceMap: any): void;
declare function clearHighlight(mesh: any): void;
declare function highlightMesh(regl: any, mesh: any, highlighted: any, timestamp: any, feaIdIndiceMap: any): void;
declare function deleteHighlightBloomMesh(mesh: any): void;
declare const highlight_d_clearHighlight: typeof clearHighlight;
declare const highlight_d_clearShowOnly: typeof clearShowOnly;
declare const highlight_d_deleteHighlightBloomMesh: typeof deleteHighlightBloomMesh;
declare const highlight_d_highlightMesh: typeof highlightMesh;
declare const highlight_d_showOnly: typeof showOnly;
declare namespace highlight_d {
export { highlight_d_clearHighlight as clearHighlight, highlight_d_clearShowOnly as clearShowOnly, highlight_d_deleteHighlightBloomMesh as deleteHighlightBloomMesh, highlight_d_highlightMesh as highlightMesh, highlight_d_showOnly as showOnly };
}
declare function fillIncludes(defines: any, uniformDeclares: any, context: any): void;
declare function setIncludeUniformValues(uniforms: any, context: any): void;
declare const context_d_fillIncludes: typeof fillIncludes;
declare const context_d_setIncludeUniformValues: typeof setIncludeUniformValues;
declare namespace context_d {
export { context_d_fillIncludes as fillIncludes, context_d_setIncludeUniformValues as setIncludeUniformValues };
}
declare class HeatmapProcess {
constructor(regl: any, sceneConfig: any, layer: any, colorStops: any, stencil: any, polygonOffset: any);
renderer: Renderer;
sceneConfig: any;
_layer: any;
_colorStops: any;
_stencil: any;
_polygonOffset: any;
_outputSize: any[];
render(scene: any, uniforms: any, fbo: any): number;
dispose(): void;
_createColorRamp(): void;
_rampCanvas: HTMLCanvasElement;
_rampCtx: CanvasRenderingContext2D;
_colorRampTex: any;
_check(): void;
_init(): void;
_createGround(): void;
_ground: Mesh$1;
_groundScene: Scene;
_transformGround(): void;
_createHeatmapTex(): void;
_heatmapFBO: any;
_createShader(): void;
_heatmapShader: HeatmapShader;
_displayShader: HeatmapDisplayShader;
}
declare function export_default(Base: T): {
new (...args: any[]): {
_maskProjViewMatrix: mat4;
_maskExtentInWorld: [number, number, number, number];
removeMask(masks: undefined | null | any): any;
setMask(masks: any): any;
onAdd(): void;
getMasks(): any;
onGeometryEvent(param: any): void;
identifyMask(point: any, options: any): any[];
remove(): void;
updateMask(extent: any): {
projViewMatrix: mat4;
extentInWorld: [number, number, number, number];
};
getProjViewMatrixInOrtho(extent: any): {
mapExtent: any;
projViewMatrix: mat4;
};
updateMaskExtent(): void;
getMaskExtent(): {
extent: Extent;
ratio: number;
minHeight: any;
};
};
} & T;
declare function _default(Base: any): {
new (): {
[x: string]: any;
setMask(extent: any, projViewMatrix: any, ratio: any, minHeight: any): void;
viewport: {
x: number;
y: number;
width: () => any;
height: () => any;
};
_extentPass: ExtentPass;
needToRedraw(): boolean;
getMaskUniforms(): any;
getMaskDefines(): {};
_maskDefines: {};
updateMaskDefines(mesh: any): void;
_clearMask(): void;
_deleteMaskUniforms(): void;
};
[x: string]: any;
};
declare class ClipMask extends Mask {
constructor(coordinates: any, options: any);
_createMesh(regl: any): Mesh$1;
_updateUniforms(mesh: any, ratio: any, minHeight: any): void;
setHeightRange(heightRange: any): void;
getHeightRange(): any;
_getHeightRange(): number[];
_setDefines(mesh: any): void;
}
declare class ClipInsideMask extends ClipMask {
_mode: string;
}
declare class ClipOutsideMask extends ClipMask {
_mode: string;
}
declare class FlatMask extends Mask {
constructor(coordinates: any, options: any);
setFlatheight(flatHeight: any): void;
_createMesh(regl: any): Mesh$1;
_updateUniforms(mesh: any): void;
_setDefines(mesh: any): void;
_getHeightRange(): any[];
}
declare class FlatInsideMask$1 extends FlatMask {
_mode: string;
}
declare class FlatInsideMask extends FlatMask {
_mode: string;
}
declare class ColorMask extends Mask {
constructor(coordinates: any, options: any);
_mode: string;
setHeightRange(heightRange: any): void;
_createMesh(regl: any): Mesh$1;
_updateUniforms(mesh: any, ratio: any, minHeight: any): void;
_setDefines(mesh: any): void;
_getHeightRange(): number[];
}
declare class VideoMask extends Mask {
constructor(coordinates: any, options: any);
_mode: string;
play(): void;
pause(): void;
setAudio(audio: any): void;
setUrl(url: any): void;
getState(): string;
_createMesh(regl: any): Mesh$1;
_copyMesh: Mesh$1;
_updateUniforms(mesh: any): void;
_setDefines(mesh: any): void;
_createVideoTexture(regl: any): any;
_createVideo(): void;
_videoState: string;
_video: HTMLElement;
_update(): void;
_needUpdate(): boolean;
}
declare class ImageMask extends Mask {
/**
* @param {Object} options.url image resource url
*/
constructor(coordinates: any, options: any);
_mode: string;
setUrl(url: any): void;
_createMesh(regl: any): Mesh$1;
_copyMesh: Mesh$1;
_updateUniforms(mesh: any): void;
_setDefines(mesh: any): void;
_createTexture(imageTexture: any): void;
getBBox(): [vec3, vec3];
}
declare class ElevateMask extends FlatMask {
_mode: string;
setElevation(elevation: any): void;
}
declare class BoxClipMask extends ClipMask {
_position: any;
setPosition(position: any): void;
getPosition(): any;
setWidth(width: any): void;
setLength(length: any): void;
setHeight(height: any): void;
setRotation(rotation: any): void;
_updateCoordinates(): void;
_generateCoordinates(map: any, center: any, length: any, width: any, height: any, rotation: any): {
coordinates: any[][];
heightRange: any[];
};
_rotatePoint(points: any, center: any, rotation: any): any;
}
declare class BoxInsideClipper extends BoxClipMask {
_mode: string;
}
declare class BoxOutsideClipper extends BoxClipMask {
_mode: string;
}
declare class RayCaster {
constructor(from: any, to: any, isLngLat?: boolean);
_from: any;
_to: any;
_isLngLat: boolean;
setFromPoint(from: any): void;
setToPoint(to: any): void;
test(meshes: any, map: any, options?: {}): {
mesh: any;
coordinates: {
coordinate: any;
indices: any[];
normal: vec3;
}[];
}[];
_testMesh(mesh: any, ray: any, map: any, positions: any, altitudes: any, indices: any, dim: any, matrix: any, count: any): {
coordinate: any;
indices: any[];
normal: vec3;
}[];
_toWorldPosition(out: any, map: any, pos: any, altitude: any, matrix: any): any;
_testIntersection(out: any, triangle: any, ray: any): any;
_checkBBox(bbox: any, ray: any): any;
}
declare class Measure3DTool extends maptalks.DrawTool {
constructor(options: any);
_drawCoordinates: any[];
addTo(map: any): this;
_map: any;
_addHelperLayer(): void;
_afterEnable(): void;
_afterDisable(): void;
_getPickedCoordinate(e: any): any;
_msOnDrawStart(e: any): void;
_first: boolean;
_msOnDrawVertex(e: any): void;
_msOnMouseMove(e: any): void;
_msOnDrawEnd(e: any): void;
_drawEnd(): void;
_helperGeometry: any;
_label: any;
remove(): void;
clear(): void;
}
declare class Distance3DTool extends Measure3DTool {
_helperLayer: maptalks.DrawToolLayer;
_markerLayer: maptalks.DrawToolLayer;
_drawVertexMarker(): void;
_drawLabel(): void;
_getUnitContent(length: any): string;
_measure: any;
_units: string;
_addHelperGeometry(coordinate: any): void;
getMeasureResult(): any;
}
declare class Area3DTool extends Measure3DTool {
_helperLayer: maptalks.DrawToolLayer;
_markerLayer: maptalks.DrawToolLayer;
_drawVertexMarker(): void;
_getPolygonCoordinates(coordinates: any): any;
_drawLabel(): void;
_getUnitContent(area: any): string;
_measure: any;
_units: string;
_addHelperGeometry(coordinate: any): void;
_polygon: maptalks.Polygon;
getMeasureResult(): number;
}
declare class Height3DTool extends Measure3DTool {
_helperLayer: maptalks.DrawToolLayer;
_markerLayer: maptalks.DrawToolLayer;
_drawVertexMarker(): void;
_drawLabel(coordinates: any, distances: any): void;
_getUnitContent(length: any): string;
_measure: any;
_units: string;
_addHelperGeometry(coordinate: any): void;
getMeasureResult(): any;
}
declare function getWGSLSource(name: any): any;
declare function registerWGSLSource(name: any, source: any): any;
export { Area3DTool, BoxInsideClipper as BoxInsideClipMask, BoxOutsideClipper as BoxOutsideClipMask, canvasCompatible as CanvasCompatible, ClipInsideMask, ClipOutsideMask, ColorMask, context_d as ContextUtil, Distance3DTool, ElevateMask, FlatInsideMask$1 as FlatInsideMask, FlatInsideMask as FlatOutsideMask, GroundPainter, GroupGLLayer, HeatmapProcess, Height3DTool, highlight_d as HighlightUtil, ImageMask, MapGLRenderer, MapGPURenderer, export_default as MaskLayerMixin, _default as MaskRendererMixin, Measure3DTool, RayCaster, VideoMask, getWGSLSource, registerWGSLSource, index_d as reshader };