@baidumap/mapv-three 1.0.0

package/dist/types/threemap/engine/rendering/Label.d.ts

@@ -0,0 +1,161 @@
+/**
+ * 全局标签类，可通过此类的API添加和移除标签 <br/>
+ * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.label`访问
+ *
+ * @category Internal
+ * @example
+* ```javascript
+* // 添加一个简单的文本标签
+* engine.rendering.label.add({
+*     position: [116.404, 39.915, 0],
+*     text: '北京市',
+*     textSize: 14,
+*     textFillStyle: '#ffffff',
+* });
+*
+* // 添加一个图标标签
+* engine.rendering.label.add({
+*     position: [116.404, 39.915, 0],
+*     mapSrc: 'marker.png',
+*     width: 32,
+*     height: 32,
+* });
+*
+* // 添加一个图文组合标签
+* engine.rendering.label.add({
+*     position: [116.404, 39.915, 0],
+*     text: '北京市',
+*     mapSrc: 'marker.png',
+*     width: 32,
+*     height: 32,
+*     collision: true, // 支持碰撞检测
+*     textAnchor: 'left',  // 图标在文字左边
+* });
+* ```
+*/
+export class RenderingLabel {
+    constructor(rendering: any);
+    /** @private */
+    private _blocks;
+    /** @private */
+    private _collisionLabels;
+    _timers: {};
+    /** @private */
+    private _enabled;
+    /**
+     * @private
+     */
+    private _spriteTexture;
+    _rendering: any;
+    set enabled(enabled: boolean);
+    get enabled(): boolean;
+    set spriteTexture(spriteTexture: any);
+    init(): void;
+    initCollisionLabel(): void;
+    _iconDataSource: DataSource | undefined;
+    _icon: any;
+    _iconUvDataSource: DataSource | undefined;
+    _iconUv: any;
+    _iconFlatUvDataSource: DataSource | undefined;
+    _iconFlatUv: any;
+    _textFlatDataSource: DataSource | undefined;
+    _textFlat: any;
+    _textFixedDataSource: DataSource | undefined;
+    _textFixed: any;
+    _iconTextDataSource: DataSource | undefined;
+    _iconText: any;
+    _iconTextUvDataSource: DataSource | undefined;
+    _iconTextUv: any;
+    initLabel(): void;
+    _labelIconDataSource: DataSource | undefined;
+    _labelIcon: any;
+    _labelIconFlatDataSource: DataSource | undefined;
+    _labelIconFlat: any;
+    _labelTextFlatDataSource: DataSource | undefined;
+    _labelTextFlat: any;
+    _labelTextFixedDataSource: DataSource | undefined;
+    _labelTextFixed: any;
+    _labelIconTextDataSource: DataSource | undefined;
+    _labelIconText: any;
+    processLabel(label: any): any;
+    /**
+     * @internal
+     * 根据label数据项，选择已经创建或者创建新的label组件
+     * @param {Object} label
+     * @returns {Symbol}
+     */
+    _getCollisionLabel(label: Object): Symbol;
+    addCollisionLabel(label: any): any;
+    addNormalLabel(label: any): any;
+    /**
+     * 添加单个标签
+     * @param {Object} label 标签配置
+     * @param {Array<number>} label.position 标签位置 [经度, 纬度, 高度]
+     * @param {string} [label.text] 标签文本
+     * @param {string} [label.mapSrc] 图标URL
+     * @param {number} [label.width] 图标宽度(像素)
+     * @param {number} [label.height] 图标高度(像素)
+     * @param {number} [label.textSize=16] 文字大小(像素)
+     * @param {string} [label.textFillStyle='#ffffff'] 文字颜色
+     * @param {string} [label.textStrokeStyle='#000000'] 文字描边颜色
+     * @param {number} [label.textStrokeWidth=0] 文字描边宽度
+     * @param {string} [label.textAnchor='center'] 文字锚点位置
+     * @param {boolean} [label.collision=false] 是否启用碰撞检测
+     * @param {boolean} [label.flat=false] 是否贴地
+     * @returns {DataItem} 返回添加的标签项
+     *
+     * @example
+     * ```javascript
+     * const label = engine.rendering.label.add({
+     *     position: [116.404, 39.915, 0],
+     *     text: '北京市',
+     *     textSize: 16,
+     *     textFillStyle: '#ffffff',
+     *     textStrokeStyle: '#000000',
+     *     textStrokeWidth: 2,
+     *     textAnchor: 'bottom',
+     *     collision: true,
+     *     flat: false
+     * });
+     * ```
+    */
+    addLabel(label: {
+        position: Array<number>;
+        text?: string | undefined;
+        mapSrc?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        textSize?: number | undefined;
+        textFillStyle?: string | undefined;
+        textStrokeStyle?: string | undefined;
+        textStrokeWidth?: number | undefined;
+        textAnchor?: string | undefined;
+        collision?: boolean | undefined;
+        flat?: boolean | undefined;
+    }): DataItem;
+    addLabels(labels: any, id: any): void;
+    _createLabelTask(labels: any): () => Promise<any>;
+    computeBoundingBox(label: any): any;
+    _checkRemoveCollisionLabel(collisionLabel: any, label: any): void;
+    removeCollisionLabel(label: any): void;
+    removeNormalLabel(label: any): void;
+    /**
+     * 移除单个标签
+     * @param {DataItem} label 要移除的标签项
+     * @example
+     * ```javascript
+     * const label = engine.rendering.label.add({
+     *     position: [116.404, 39.915, 0],
+     *     text: '北京市'
+     * });
+     *
+     * // 稍后移除该标签
+     * engine.rendering.label.removeLabel(label);
+     * ```
+    */
+    removeLabel(label: DataItem): void;
+    removeLabels(labels: any, id: any): void;
+    dispose(): void;
+}
+import { DataSource } from '../../dataSource/DataSource';
+import { DataItem } from '../../dataSource/DataItem';

package/dist/types/threemap/engine/rendering/Main.d.ts

@@ -0,0 +1,37 @@
+export class RenderingMain {
+    constructor(rendering: any);
+    /** @private */
+    private _rendering;
+    /** @private */
+    private _useMrt;
+    /** @private */
+    private _mainMrt;
+    /** @private */
+    private _renderPass;
+    /** @private */
+    private _needsPrepare;
+    /** @private */
+    private _antialias;
+    /** @private */
+    private _msaaSamples;
+    set useMrt(value: boolean);
+    get useMrt(): boolean;
+    _init(): void;
+    _tDepth: any;
+    _tDiffuse: any;
+    _tEmissive: any;
+    _tNormal: any;
+    _tSpecular: any;
+    render(): void;
+    cleanup: () => void;
+    dispose(): void;
+    getTextures(): any[];
+    setSize(width: any, height: any): void;
+    get tDiffuse(): any;
+    get tNormal(): any;
+    get tDepth(): any;
+    get tSpecular(): any;
+    get tEmissive(): any;
+    set antialias(value: boolean);
+    get antialias(): boolean;
+}

package/dist/types/threemap/engine/rendering/MainNew.d.ts

@@ -0,0 +1,47 @@
+export class RenderingMainNew {
+    constructor(rendering: any, options: any);
+    /** @private */
+    private _rendering;
+    /** @private
+     * @type {RenderingRequirements}
+    */
+    private _requirements;
+    /** @private */
+    private _useMRT;
+    /** @private
+     * 初始状态为null
+    */
+    private _lastUseMRT;
+    /** @private */
+    private _sceneRendering;
+    /** @private
+     * @type {Features}
+     */
+    private _features;
+    /** @private
+     * @type {Postprocessings}
+     */
+    private _postprocessings;
+    /** @private
+     */
+    private _opaquePostprocessings;
+    _sharedFullScreenRenderTargets: SharedFullScreenRenderTargets;
+    beginFrame(): void;
+    render(): void;
+    endFrame(): void;
+    setSize(width: any, height: any): void;
+    get sceneRendering(): any;
+    set useFastEmissiveMethod(value: any);
+    get useFastEmissiveMethod(): any;
+    get antialias(): boolean;
+    get rendering(): any;
+    get requirements(): RenderingRequirements;
+    get features(): Features;
+    get postprocessings(): Postprocessings;
+    get opaquePostprocessings(): OpaquePostprocessings;
+}
+import { SharedFullScreenRenderTargets } from './SharedFullScreenRenderTargets';
+import { RenderingRequirements } from './RenderingRequirements';
+import { Features } from './features/Features';
+import { Postprocessings } from './postprocessing/Postprocessings';
+import { OpaquePostprocessings } from './postprocessing/OpaquePostprocessings';

package/dist/types/threemap/engine/rendering/MicroTaskScheduler.d.ts

@@ -0,0 +1,48 @@
+export class RenderingMicroTaskScheduler {
+    constructor(rendering: any);
+    /**
+     * 保存最近几帧的时间，用于计算平均帧时间
+     * @type {number[]}
+     * @private
+     */
+    private _frameDurationList;
+    /**
+     * 最大任务数量，
+     * 超过这个数量的任务将直接执行
+     */
+    _maxTaskCount: number;
+    /**
+     * 存储任务队列
+     * @type {Array<{task: Function, priority: number}>}
+     */
+    _taskQueue: Array<{
+        task: Function;
+        priority: number;
+    }>;
+    _rendering: any;
+    beginFrame(): void;
+    _frameStartTime: number | undefined;
+    _lastFrameStartTime: number | undefined;
+    endFrame(): void;
+    /**
+     * 添加一个微任务
+     * @param {Function} task - 返回 Promise 的任务函数
+     * @param {number} priority - 任务优先级（默认为 0，值越大优先级越高）
+     */
+    addTask(taskFunc: any, priority?: number): MicroTask;
+    set maxTaskCount(value: number);
+    get maxTaskCount(): number;
+    get taskCount(): number;
+}
+declare class MicroTask {
+    constructor(task: any, priority?: number);
+    taskFunc: any;
+    priority: number;
+    _isCancelled: boolean;
+    _isStart: boolean;
+    execute(): void;
+    cancel(): void;
+    isCancelled(): boolean;
+    isStart(): boolean;
+}
+export {};

package/dist/types/threemap/engine/rendering/Picking.d.ts

@@ -0,0 +1,140 @@
+/**
+ * 场景拾取，用于拾取场景中的物体和坐标<br/>
+ * 需要了解有三种坐标系背景：
+ * - 1. pixel 屏幕像素坐标，左上角为原点，x轴向右，y轴向下，单位为像素
+ * - 2. ndc 归一化设备坐标系，以中心为原点，x轴向右，y轴向上，xy范围[-1, 1]
+ * - 3. readPixel 左下角为原点，x轴向右，y轴向上，单位为像素，调用 depthPicking.pickDepth 时注意转换成该坐标系
+ *
+ * @category Internal
+ */
+export class Picking {
+    static PICK_INTERSECTION_TYPE_ALL: number;
+    static PICK_INTERSECTION_TYPE_VISIBLE: number;
+    static PICK_INTERSECTION_TYPE_EVENT: number;
+    constructor(rendering: any);
+    /** @private */
+    private _useDepthPicking;
+    /** @private */
+    private _positionCache;
+    /** @private */
+    private _seaLevelPositionCache;
+    /** @private */
+    private _intersectionCache;
+    _rendering: any;
+    init(): void;
+    dispose(): void;
+    beginFrame(): void;
+    endFrame(): void;
+    onResolutionChange(): void;
+    /**
+     * 获取世界坐标，优先获取场景物体的世界坐标，若未找到则获取地图上的海平面交点
+     * @param {*} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns 返回对应的世界坐标
+     */
+    pickWorldPosition(pixel: any): Promise<Vector3>;
+    /**
+     * 从归一化设备坐标(NDC)中选取世界坐标
+     * @param {Vector2} ndc 归一化设备坐标(NDC)
+     * @returns 返回对应的世界坐标
+     */
+    pickWorldPositionFromNdc(ndc: Vector2): Promise<Vector3>;
+    /**
+     * 拾取场景物体像素点的世界坐标，每帧缓存，同屏幕位置只计算一次
+     * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns {Vector3} 拾取坐标
+     */
+    pickSceneWorldPosition(pixel: Vector2): Vector3;
+    /**
+     * 从归一化设备坐标(NDC)中选取世界坐标
+     * @param {Vector2} ndc 归一化设备坐标(NDC)
+     * @returns 返回对应的世界坐标
+     */
+    pickSceneWorldPositionFromNdc(ndc: Vector2): Promise<Vector3>;
+    /**
+     * @internal
+     * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns 返回世界坐标位置，若未找到则返回null
+     */
+    _pickSceneWorldPosition(pixel: Vector2): Promise<any>;
+    /**
+     * @internal
+     * 从depthTexture获取地图上的交点
+     * @private
+     * @param {*} pixel 屏幕像素坐标，左上角为原点，向右向上为正方向
+     * @returns 交点坐标
+     */
+    private _pickSceneWorldPositionFromDepth;
+    /**
+     * @internal
+     * 获取像素坐标对应的地图上的相交物体数组，每帧缓存，同屏幕位置只计算一次
+     * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns {Array} 交点数组
+     */
+    pickIntersections(pixel: Vector2): any[];
+    /**
+     * @internal
+     * 获取可见物体的交点
+     * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns {Array} 交点数组
+     */
+    pickIntersectionsOfVisibleObjects(pixel: Vector2): any[];
+    /**
+     * @internal
+     * 获取与事件相关的物体的交点
+     * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns {Array} 交点数组
+     */
+    pickIntersectionsOfEventObjects(pixel: Vector2, eventNames?: string[]): any[];
+    /**
+     * @internal
+     * 拾取物体
+     * @param {*} pixel
+     */
+    _pickIntersectionByRayRasting(type: any, pixel: any, eventNames?: string[]): Promise<any>;
+    /**
+     * 拾取地形交点
+     * @param {Ray} ray 射线
+     * @returns {Vector3} 交点坐标
+     */
+    pickTerrainWorldPosition(ray: Ray): Vector3;
+    /**
+     * @internal
+     * @param {Ray} ray 射线
+     * @param {Function} callback 回调函数
+     * @returns {Array} 交点数组
+     */
+    _pickIntersectionsWithCheckCallback(ray: Ray, callback: Function): any[];
+    pickSeaLevelWorldPositionFromNdc(ndc: any): Vector3;
+    /**
+     * 拾取海平面交点
+     * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
+     * @returns {Vector3} 交点坐标
+     */
+    pickSeaLevelWorldPosition(pixel: Vector2): Vector3;
+    /**
+     * 将像素坐标转换为NDC坐标，以中心为原点，向右向上为正方向，范围[-1, 1]
+     * @private
+     * @param {Vector2} pixel 屏幕像素坐标
+     * @returns NDC坐标
+     */
+    private pixelToNdc;
+    /**
+     * 转换NDC坐标为屏幕像素坐标，以左上角为原点，向右向下为正方向
+     * @private
+     * @param {Vector2} ndc NDC坐标
+     * @returns 屏幕像素坐标
+     */
+    private ndcToPixel;
+    /**
+     * @param {boolean} value 是否使用深度拾取
+     */
+    set useDepthPicking(value: boolean);
+    /**
+     * 获取是否使用深度拾取
+     * 使用深度图拾取世界坐标，性能表现受GPU、屏幕分辨率影响。
+     * 小分辨率，大场景的情况下性能表现较好。
+     * 注意该api是同步的，主线程发起请求后会等GPU处理完返回通信后才响应，所以性能差的时候会导致IO阻塞。
+     * @returns {boolean} 是否使用深度拾取
+     */
+    get useDepthPicking(): boolean;
+}

package/dist/types/threemap/engine/rendering/RenderState.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 渲染状态管理类，用于管理渲染状态<br/>
+ * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.renderState`访问<br/>
+ * 该类会管理渲染状态，包括渲染时间、渲染帧数、渲染视图变化等。其状态由引擎内部自动管理，开发者可在回调中获取相关状态<br/>
+ *
+ * @category Internal
+ * @example
+ * ```javascript
+ * engine.addBeforeRenderListener((engine, renderState) => {
+ *     console.log(renderState.deltaTime);
+ *     console.log(renderState.frameCount);
+ *     console.log(renderState.viewChanged);
+ *     console.log(renderState.viewMatrixWorld);
+ *     console.log(renderState.projectionMatrix);
+ *     console.log(renderState.cameraMatrix);
+ *     console.log(renderState.cameraMatrixInverse);
+ * });
+ * ```
+ */
+export class RenderState {
+    constructor(rendering: any);
+    /** @private */
+    private _stage;
+    /** @private */
+    private _time;
+    /** @private */
+    private _startTime;
+    /** @private */
+    private _elapsedTime;
+    /** @private */
+    private _viewChanged;
+    /** @private */
+    private _viewMatrixWorld;
+    /** @private */
+    private _viewMatrixWorldInverse;
+    /** @private */
+    private _projectionMatrix;
+    /** @private */
+    private _cameraMatrix;
+    /** @private */
+    private _cameraMatrixInverse;
+    /** @private */
+    private _cameraOffsetX;
+    /** @private */
+    private _cameraOffsetY;
+    /** @private */
+    private _cameraOffset;
+    /** @private */
+    private _frameCount;
+    /** @private */
+    private _viewStableFrameCount;
+    /** @private */
+    private _isRendererRecreated;
+    /** @private */
+    private _cameraLocation;
+    _rendering: any;
+    beginFrame(rendering: any, time: any): void;
+    _deltaTime: number | undefined;
+    _deltaSeconds: number | undefined;
+    endFrame(): void;
+    updateCameraOffsetState(camera: any, offsetX: any, offsetY: any, offsetZ: any): void;
+    getDepthByDistance(distance: any): number;
+    /**
+     * 获取当前渲染时间
+     * @returns {number} 当前渲染时间
+     */
+    get time(): number;
+    /**
+     * 获取当前渲染视图是否发生变化
+     * @returns {boolean} 当前渲染视图是否发生变化
+     */
+    get viewChanged(): boolean;
+    /**
+     * 获取当前渲染视图矩阵
+     * @returns {Matrix4} 当前渲染视图矩阵
+     */
+    get viewMatrixWorld(): Matrix4;
+    /**
+     * 获取当前渲染视图矩阵的逆矩阵
+     * @returns {Matrix4} 当前渲染视图矩阵的逆矩阵
+     */
+    get viewMatrixWorldInverse(): Matrix4;
+    /**
+     * 获取当前渲染投影矩阵
+     * @returns {Matrix4} 当前渲染投影矩阵
+     */
+    get projectionMatrix(): Matrix4;
+    /**
+     * 获取当前渲染相机矩阵
+     * @returns {Matrix4} 当前渲染相机矩阵
+     */
+    get cameraMatrix(): Matrix4;
+    /**
+     * 获取当前渲染相机矩阵的逆矩阵
+     * @returns {Matrix4} 当前渲染相机矩阵的逆矩阵
+     */
+    get cameraMatrixInverse(): Matrix4;
+    /**
+     * 获取当前渲染相机偏移量X
+     * @returns {number} 当前渲染相机偏移量X
+     */
+    get cameraOffsetX(): number;
+    /**
+     * 获取当前渲染相机偏移量Y
+     * @returns {number} 当前渲染相机偏移量Y
+     */
+    get cameraOffsetY(): number;
+    /**
+     * 获取当前渲染时间差
+     * @returns {number} 当前渲染时间差
+     */
+    get deltaTime(): number;
+    /**
+     * 获取从渲染开始到当前的渲染时间
+     * @returns {number} 从渲染开始到当前的渲染时间
+     */
+    get elapsedTime(): number;
+    /**
+     * 获取当前渲染时间差，单位秒
+     * @returns {number} 当前渲染时间差，单位秒
+     */
+    get deltaSeconds(): number;
+    /**
+     * 获取当前渲染帧数
+     * @returns {number} 当前渲染帧数
+     */
+    get frameCount(): number;
+    /**
+     * 获取当前渲染视图稳定帧数
+     * @returns {number} 当前渲染视图稳定帧数
+     */
+    get viewStableFrameCount(): number;
+    /**
+     * 获取当前渲染相机偏移量
+     * @returns {Vector3} 当前渲染相机偏移量
+     */
+    get cameraOffset(): Vector3;
+    /**
+     * 获取当前渲染是否重新创建渲染器
+     * @returns {boolean} 当前渲染是否重新创建渲染器
+     */
+    get isRendererRecreated(): boolean;
+    set stage(value: null);
+    get stage(): null;
+}

package/dist/types/threemap/engine/rendering/RenderingRequirements.d.ts

@@ -0,0 +1,33 @@
+export class RenderingRequirements {
+    constructor(rendering: any);
+    needsEmissiveTexture: boolean;
+    needsNormalTexture: boolean;
+    needsNormalTextureWhenMRT: boolean;
+    needsDepthTexture: boolean;
+    needsMetallicRoughTexture: boolean;
+    enableStencilBuffer: boolean;
+    enableRenderingJitter: boolean;
+    needsFloatRenderTarget: boolean;
+    _lastNeedsFloatRenderTarget: null;
+    /** @private */
+    private _lastTextureRequirementsKey;
+    /** @private */
+    private _currentTextureRequirementsKey;
+    featuresShaderKey: string;
+    _rendering: any;
+    _renderingMain: any;
+    /**
+     * 重置状态
+     * 重新计算需求
+     */
+    beginFrame(): void;
+    _updateRequirements(): void;
+    _resetTextureRequirements(): void;
+    _updateTextureRequirementsKey(): number;
+    isTextureRequirementsChanged(): boolean;
+    isRenderTargetTypeChanged(): boolean;
+    getRenderTargetType(): any;
+    endFrame(): void;
+    get currentTextureRequirementsKey(): number;
+    get currentShaderKey(): string;
+}

package/dist/types/threemap/engine/rendering/Shadow.d.ts

@@ -0,0 +1,19 @@
+export class RenderingShadow {
+    static DEFAULT: number;
+    static CSM: number;
+    constructor(rendering: any);
+    /** @private */
+    private _rendering;
+    /**
+     * @type {number}
+     * 适用于简单投影模型，平行光只用一个shadowMap
+     * 平行光投影的基准高度，越接近此值，阴影越清晰，阴影范围越小
+     */
+    _baseHeight: number;
+    /** @private */
+    private _mode;
+    set enabled(enabled: any);
+    get enabled(): any;
+    set baseHeight(height: number);
+    get baseHeight(): number;
+}

package/dist/types/threemap/engine/rendering/SharedFullScreenRenderTargets.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 集中管理的全屏渲染目标，用作后处理或全屏绘图使用，没有深度和模板
+ * 主要用于后处理的中间渲染目标
+ * 例如FXAA, SSAO等
+ * 使用是get,使用完立即release，以使得buffer尽可能复用
+ * 不包含主渲染流程中的buffer
+ */
+export class SharedFullScreenRenderTargets {
+    constructor(rendering: any);
+    /** @private
+     * @type {RenderTarget}
+     */
+    private _renderTargets;
+    /** @private
+     * 锁
+    */
+    private _locks;
+    /** @private */
+    private _maxRenderTargets;
+    _rendering: any;
+    beginFrame(): void;
+    _disposeRenderTargets(): void;
+    _resetLocks(): void;
+    getAvailableRenderTarget(): RenderTarget;
+    releaseRenderTarget(renderTarget: any): void;
+    releaseRenderTargetByIndex(index: any): void;
+    lockRenderTarget(renderTarget: any): void;
+    setSize(width: any, height: any): void;
+    endFrame(): void;
+}