three-base 2.0.169 → 2.0.175

package/PipeMesh/PathPointList.ts

@@ -1,227 +0,0 @@
-import { Vector3 } from 'three/src/math/Vector3.js';
-import { PathPoint } from './PathPoint.js';
-import { Matrix4 } from 'three/src/math/Matrix4.js';
-import { QuadraticBezierCurve3 } from 'three/src/extras/curves/QuadraticBezierCurve3.js';
-
-const helpVec3_1: Vector3 = new Vector3();
-const helpVec3_2: Vector3 = new Vector3();
-const helpVec3_3: Vector3 = new Vector3();
-const helpMat4: Matrix4 = new Matrix4();
-const helpCurve: QuadraticBezierCurve3 = new QuadraticBezierCurve3(new Vector3(), new Vector3(), new Vector3());
-
-interface CornerBezierCurve {
-    v0: Vector3;
-    v1: Vector3;
-    v2: Vector3;
-}
-
-function _getCornerBezierCurve(last: Vector3, current: Vector3, next: Vector3, cornerRadius: number, firstCorner: boolean, out: QuadraticBezierCurve3): QuadraticBezierCurve3 {
-    const lastDir = helpVec3_1.subVectors(current, last);
-    const nextDir = helpVec3_2.subVectors(next, current);
-    const lastDirLength = lastDir.length();
-    const nextDirLength = nextDir.length();
-    lastDir.normalize();
-    nextDir.normalize();
-    // cornerRadius can not bigger then lineDistance / 2, auto fix this
-    const v0Dist = Math.min((firstCorner ? lastDirLength / 2 : lastDirLength) * 0.999999, cornerRadius);
-    out.v0.copy(current).sub(lastDir.multiplyScalar(v0Dist));
-    out.v1.copy(current);
-    const v2Dist = Math.min((nextDirLength / 2) * 0.999999, cornerRadius);
-    out.v2.copy(current).add(nextDir.multiplyScalar(v2Dist));
-    return out;
-}
-
-/**
- * PathPointList
- * input points to generate a PathPoint list
- */
-class PathPointList {
-    array: Array<PathPoint> = []; // path point array
-    count: number = 0;
-
-    constructor() { }
-
-    /**
-     * Set points
-     * @param {Vector3[]} points key points array
-     * @param {number} cornerRadius? the corner radius. set 0 to disable round corner. default is 0.1
-     * @param {number} cornerSplit? the corner split. default is 10.
-     * @param {number} up? force up. default is auto up (calculate by tangent).
-     * @param {boolean} close? close path. default is false.
-     */
-    set(points: Array<Vector3>, cornerRadius: number = 0.1, cornerSplit: number = 10, up?: Vector3, close: boolean = false): void {
-        points = points.slice(0);
-        if (points.length < 2) {
-            console.warn('PathPointList: points length less than 2.');
-            this.count = 0;
-            return;
-        }
-        // Auto close
-        if (close && !points[0].equals(points[points.length - 1])) {
-            points.push(new Vector3().copy(points[0]));
-        }
-        // Generate path point list
-        for (let i = 0, l = points.length; i < l; i++) {
-            if (i === 0) {
-                this._start(points[i], points[i + 1], up);
-            }
-            else if (i === l - 1) {
-                if (close) {
-                    // Connect end point and start point
-                    this._corner(points[i], points[1], cornerRadius, cornerSplit, up);
-                    // Fix start point
-                    const dist = this.array[0].dist; // should not copy dist
-                    this.array[0].copy(this.array[this.count - 1]);
-                    this.array[0].dist = dist;
-                }
-                else {
-                    this._end(points[i]);
-                }
-            }
-            else {
-                this._corner(points[i], points[i + 1], cornerRadius, cornerSplit, up);
-            }
-        }
-    }
-
-    /**
-     * Get distance of this path
-     * @return {number}
-     */
-    distance(): number {
-        if (this.count > 0) {
-            return this.array[this.count - 1].dist;
-        }
-        return 0;
-    }
-
-    _getByIndex(index: number): PathPoint {
-        if (!this.array[index]) {
-            this.array[index] = new PathPoint();
-        }
-        return this.array[index];
-    }
-
-    _start(current: Vector3, next: Vector3, up?: Vector3): void {
-        this.count = 0;
-        const point = this._getByIndex(this.count);
-        point.pos.copy(current);
-        point.dir.subVectors(next, current);
-        // init start up dir
-        if (up) {
-            point.up.copy(up);
-        }
-        else {
-            // select an initial normal vector perpendicular to the first tangent vector
-            let min = Number.MAX_VALUE;
-            const tx = Math.abs(point.dir.x);
-            const ty = Math.abs(point.dir.y);
-            const tz = Math.abs(point.dir.z);
-            if (tx < min) {
-                min = tx;
-                point.up.set(1, 0, 0);
-            }
-            if (ty < min) {
-                min = ty;
-                point.up.set(0, 1, 0);
-            }
-            if (tz < min) {
-                min = tz;
-                point.up.set(0, 0, 1);
-            }
-        }
-        point.right.crossVectors(point.dir, point.up).normalize();
-        point.up.crossVectors(point.right, point.dir).normalize();
-        point.dist = 0;
-        point.widthScale = 1;
-        point.sharp = false;
-        point.dir.normalize();
-        this.count++;
-    }
-
-    _end(current: Vector3): void {
-        const lastPoint = this.array[this.count - 1];
-        const point = this._getByIndex(this.count);
-        point.pos.copy(current);
-        point.dir.subVectors(current, lastPoint.pos);
-        const dist = point.dir.length();
-        point.dir.normalize();
-        point.up.copy(lastPoint.up); // copy last up
-        const vec = helpVec3_1.crossVectors(lastPoint.dir, point.dir);
-        if (vec.length() > Number.EPSILON) {
-            vec.normalize();
-            const theta = Math.acos(Math.min(Math.max(lastPoint.dir.dot(point.dir), -1), 1)); // clamp for floating pt errors
-            point.up.applyMatrix4(helpMat4.makeRotationAxis(vec, theta));
-        }
-        point.right.crossVectors(point.dir, point.up).normalize();
-        point.dist = lastPoint.dist + dist;
-        point.widthScale = 1;
-        point.sharp = false;
-        this.count++;
-    }
-
-    _corner(current: Vector3, next: Vector3, cornerRadius: number, cornerSplit: number, up?: Vector3): void {
-        if (cornerRadius > 0 && cornerSplit > 0) {
-            const lastPoint = this.array[this.count - 1];
-            const curve = _getCornerBezierCurve(lastPoint.pos, current, next, cornerRadius, this.count - 1 === 0, helpCurve);
-            const samplerPoints = curve.getPoints(cornerSplit);
-            for (let f = 0; f < cornerSplit; f++) {
-                this._sharpCorner(samplerPoints[f], samplerPoints[f + 1], up, f === 0 ? 1 : 0);
-            }
-            if (!samplerPoints[cornerSplit].equals(next)) {
-                this._sharpCorner(samplerPoints[cornerSplit], next, up, 2);
-            }
-        }
-        else {
-            this._sharpCorner(current, next, up, 0, true);
-        }
-    }
-
-    // dirType: 0 - use middle dir / 1 - use last dir / 2- use next dir
-    _sharpCorner(current: Vector3, next: Vector3, up?: Vector3, dirType: 0 | 1 | 2 = 0, sharp: boolean = false): void {
-        const lastPoint = this.array[this.count - 1];
-        const point = this._getByIndex(this.count);
-        const lastDir = helpVec3_1.subVectors(current, lastPoint.pos);
-        const nextDir = helpVec3_2.subVectors(next, current);
-        const lastDirLength = lastDir.length();
-        lastDir.normalize();
-        nextDir.normalize();
-        point.pos.copy(current);
-        if (dirType === 1) {
-            point.dir.copy(lastDir);
-        }
-        else if (dirType === 2) {
-            point.dir.copy(nextDir);
-        }
-        else {
-            point.dir.addVectors(lastDir, nextDir);
-            point.dir.normalize();
-        }
-        if (up) {
-            if (point.dir.dot(up) === 1) {
-                point.right.crossVectors(nextDir, up).normalize();
-            }
-            else {
-                point.right.crossVectors(point.dir, up).normalize();
-            }
-            point.up.crossVectors(point.right, point.dir).normalize();
-        }
-        else {
-            point.up.copy(lastPoint.up);
-            const vec = helpVec3_3.crossVectors(lastPoint.dir, point.dir);
-            if (vec.length() > Number.EPSILON) {
-                vec.normalize();
-                const theta = Math.acos(Math.min(Math.max(lastPoint.dir.dot(point.dir), -1), 1)); // clamp for floating pt errors
-                point.up.applyMatrix4(helpMat4.makeRotationAxis(vec, theta));
-            }
-            point.right.crossVectors(point.dir, point.up).normalize();
-        }
-        point.dist = lastPoint.dist + lastDirLength;
-        const _cos = lastDir.dot(nextDir);
-        point.widthScale = Math.min(1 / Math.sqrt((1 + _cos) / 2), 1.415) || 1;
-        point.sharp = Math.abs(_cos - 1) > 0.05 && sharp;
-        this.count++;
-    }
-}
-
-export { PathPointList };

package/PipeMesh/PathTubeGeometry.d.ts

@@ -1,25 +0,0 @@
-import { Usage } from 'three/src/constants.js';
-import { PathGeometry, type Options, type PathGeometryParam } from './PathGeometry.js';
-import type { PathPointList } from './PathPointList.js';
-/**
- * PathTubeGeometry
- */
-declare class PathTubeGeometry extends PathGeometry {
-    /**
-     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
-     * @param {Boolean} [generateUv2=false]
-     */
-    constructor(initData: PathGeometryParam, generateUv2?: boolean);
-    _initByData(pathPointList: PathPointList, options: Options, usage: Usage, generateUv2: boolean): void;
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.radius=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.radialSegments=8]
-     * @param {String} [options.startRad=0]
-     */
-    update(pathPointList: PathPointList, options: Options): void;
-}
-export { PathTubeGeometry };

package/PipeMesh/PathTubeGeometry.js

@@ -1,130 +0,0 @@
-import { StaticDrawUsage } from 'three/src/constants.js';
-import { PathGeometry } from './PathGeometry.js';
-import { PathPoint } from './PathPoint.js';
-import { BufferAttribute } from 'three/src/core/BufferAttribute.js';
-import { Vector3 } from 'three/src/math/Vector3.js';
-/**
- * PathTubeGeometry
- */
-class PathTubeGeometry extends PathGeometry {
-    /**
-     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
-     * @param {Boolean} [generateUv2=false]
-     */
-    constructor(initData, generateUv2 = false) {
-        super(initData, generateUv2);
-    }
-    _initByData(pathPointList, options = {}, usage, generateUv2) {
-        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
-        if (vertexData && vertexData.count !== 0) {
-            this.setAttribute('position', new BufferAttribute(new Float32Array(vertexData.position), 3).setUsage(usage || StaticDrawUsage));
-            this.setAttribute('normal', new BufferAttribute(new Float32Array(vertexData.normal), 3).setUsage(usage || StaticDrawUsage));
-            this.setAttribute('uv', new BufferAttribute(new Float32Array(vertexData.uv), 2).setUsage(usage || StaticDrawUsage));
-            if (generateUv2) {
-                this.setAttribute('uv2', new BufferAttribute(new Float32Array(vertexData.uv2), 2).setUsage(usage || StaticDrawUsage));
-            }
-            this.setIndex(vertexData.indices);
-        }
-        else {
-            this._initByMaxVertex(2, generateUv2);
-        }
-    }
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.radius=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.radialSegments=8]
-     * @param {String} [options.startRad=0]
-     */
-    update(pathPointList, options) {
-        const generateUv2 = !!this.getAttribute('uv2');
-        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
-        if (vertexData) {
-            this._updateAttributes(vertexData.position, vertexData.normal, vertexData.uv, generateUv2 ? vertexData.uv2 : null, vertexData.indices);
-            this.drawRange.count = vertexData.count;
-        }
-        else {
-            this.drawRange.count = 0;
-        }
-    }
-}
-export { PathTubeGeometry };
-// Vertex Data Generate Functions
-function generateTubeVertexData(pathPointList, options, generateUv2 = false) {
-    const radius = options.radius || 0.1;
-    const progress = options.progress !== undefined ? options.progress : 1;
-    const radialSegments = Math.max(2, options.radialSegments || 8);
-    const startRad = options.startRad || 0;
-    const circum = radius * 2 * Math.PI;
-    const totalDistance = pathPointList.distance();
-    const progressDistance = progress * totalDistance;
-    if (progressDistance == 0) {
-        return null;
-    }
-    let count = 0;
-    // modify data
-    const position = [];
-    const normal = [];
-    const uv = [];
-    const uv2 = [];
-    const indices = [];
-    let verticesCount = 0;
-    const normalDir = new Vector3();
-    function addVertices(pathPoint, radius, radialSegments) {
-        const first = position.length === 0;
-        const uvDist = pathPoint.dist / circum;
-        const uvDist2 = pathPoint.dist / totalDistance;
-        for (let r = 0; r <= radialSegments; r++) {
-            let _r = r;
-            if (_r == radialSegments) {
-                _r = 0;
-            }
-            normalDir
-                .copy(pathPoint.up)
-                .applyAxisAngle(pathPoint.dir, startRad + (Math.PI * 2 * _r) / radialSegments)
-                .normalize();
-            position.push(pathPoint.pos.x + normalDir.x * radius * pathPoint.widthScale, pathPoint.pos.y + normalDir.y * radius * pathPoint.widthScale, pathPoint.pos.z + normalDir.z * radius * pathPoint.widthScale);
-            normal.push(normalDir.x, normalDir.y, normalDir.z);
-            uv.push(uvDist, r / radialSegments);
-            if (generateUv2) {
-                uv2.push(uvDist2, r / radialSegments);
-            }
-            verticesCount++;
-        }
-        if (!first) {
-            const begin1 = verticesCount - (radialSegments + 1) * 2;
-            const begin2 = verticesCount - (radialSegments + 1);
-            for (let i = 0; i < radialSegments; i++) {
-                indices.push(begin2 + i, begin1 + i, begin1 + i + 1, begin2 + i, begin1 + i + 1, begin2 + i + 1);
-                count += 6;
-            }
-        }
-    }
-    if (progressDistance > 0) {
-        for (let i = 0; i < pathPointList.count; i++) {
-            const pathPoint = pathPointList.array[i];
-            if (pathPoint.dist > progressDistance) {
-                const prevPoint = pathPointList.array[i - 1];
-                const lastPoint = new PathPoint();
-                // linear lerp for progress
-                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
-                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
-                addVertices(lastPoint, radius, radialSegments);
-                break;
-            }
-            else {
-                addVertices(pathPoint, radius, radialSegments);
-            }
-        }
-    }
-    return {
-        position,
-        normal,
-        uv,
-        uv2,
-        indices,
-        count,
-    };
-}

package/PipeMesh/PathTubeGeometry.ts

@@ -1,146 +0,0 @@
-import { StaticDrawUsage, Usage } from 'three/src/constants.js';
-import { PathGeometry, type Options, type PathGeometryParam } from './PathGeometry.js';
-import { PathPoint } from './PathPoint.js';
-import type { PathPointList } from './PathPointList.js';
-import { BufferAttribute } from 'three/src/core/BufferAttribute.js';
-import { Vector3 } from 'three/src/math/Vector3.js';
-
-interface TubeVertexData {
-    position: Array<number>;
-    normal: Array<number>;
-    uv: Array<number>;
-    uv2: Array<number>;
-    indices: Array<number>;
-    count: number;
-}
-
-/**
- * PathTubeGeometry
- */
-class PathTubeGeometry extends PathGeometry {
-    /**
-     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
-     * @param {Boolean} [generateUv2=false]
-     */
-    constructor(initData: PathGeometryParam, generateUv2: boolean = false) {
-        super(initData, generateUv2);
-    }
-
-    _initByData(pathPointList: PathPointList, options: Options = {}, usage: Usage, generateUv2: boolean): void {
-        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
-        if (vertexData && vertexData.count !== 0) {
-            this.setAttribute('position', new BufferAttribute(new Float32Array(vertexData.position), 3).setUsage(usage || StaticDrawUsage));
-            this.setAttribute('normal', new BufferAttribute(new Float32Array(vertexData.normal), 3).setUsage(usage || StaticDrawUsage));
-            this.setAttribute('uv', new BufferAttribute(new Float32Array(vertexData.uv), 2).setUsage(usage || StaticDrawUsage));
-            if (generateUv2) {
-                this.setAttribute('uv2', new BufferAttribute(new Float32Array(vertexData.uv2), 2).setUsage(usage || StaticDrawUsage));
-            }
-            this.setIndex(vertexData.indices);
-        }
-        else {
-            this._initByMaxVertex(2, generateUv2);
-        }
-    }
-
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.radius=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.radialSegments=8]
-     * @param {String} [options.startRad=0]
-     */
-    update(pathPointList: PathPointList, options: Options): void {
-        const generateUv2 = !!this.getAttribute('uv2');
-        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
-        if (vertexData) {
-            this._updateAttributes(vertexData.position, vertexData.normal, vertexData.uv, generateUv2 ? vertexData.uv2 : null, vertexData.indices);
-            this.drawRange.count = vertexData.count;
-        }
-        else {
-            this.drawRange.count = 0;
-        }
-    }
-}
-
-export { PathTubeGeometry };
-
-// Vertex Data Generate Functions
-function generateTubeVertexData(pathPointList: PathPointList, options: Options, generateUv2: boolean = false): TubeVertexData | null {
-    const radius = options.radius || 0.1;
-    const progress = options.progress !== undefined ? options.progress : 1;
-    const radialSegments = Math.max(2, options.radialSegments || 8);
-    const startRad = options.startRad || 0;
-    const circum = radius * 2 * Math.PI;
-    const totalDistance = pathPointList.distance();
-    const progressDistance = progress * totalDistance;
-    if (progressDistance == 0) {
-        return null;
-    }
-    let count = 0;
-    // modify data
-    const position: Array<number> = [];
-    const normal: Array<number> = [];
-    const uv: Array<number> = [];
-    const uv2: Array<number> = [];
-    const indices: Array<number> = [];
-    let verticesCount = 0;
-    const normalDir = new Vector3();
-
-    function addVertices(pathPoint: PathPoint, radius: number, radialSegments: number): void {
-        const first = position.length === 0;
-        const uvDist = pathPoint.dist / circum;
-        const uvDist2 = pathPoint.dist / totalDistance;
-        for (let r = 0; r <= radialSegments; r++) {
-            let _r = r;
-            if (_r == radialSegments) {
-                _r = 0;
-            }
-            normalDir
-                .copy(pathPoint.up)
-                .applyAxisAngle(pathPoint.dir, startRad + (Math.PI * 2 * _r) / radialSegments)
-                .normalize();
-            position.push(pathPoint.pos.x + normalDir.x * radius * pathPoint.widthScale, pathPoint.pos.y + normalDir.y * radius * pathPoint.widthScale, pathPoint.pos.z + normalDir.z * radius * pathPoint.widthScale);
-            normal.push(normalDir.x, normalDir.y, normalDir.z);
-            uv.push(uvDist, r / radialSegments);
-            if (generateUv2) {
-                uv2.push(uvDist2, r / radialSegments);
-            }
-            verticesCount++;
-        }
-        if (!first) {
-            const begin1 = verticesCount - (radialSegments + 1) * 2;
-            const begin2 = verticesCount - (radialSegments + 1);
-            for (let i = 0; i < radialSegments; i++) {
-                indices.push(begin2 + i, begin1 + i, begin1 + i + 1, begin2 + i, begin1 + i + 1, begin2 + i + 1);
-                count += 6;
-            }
-        }
-    }
-    if (progressDistance > 0) {
-        for (let i = 0; i < pathPointList.count; i++) {
-            const pathPoint = pathPointList.array[i];
-            if (pathPoint.dist > progressDistance) {
-                const prevPoint = pathPointList.array[i - 1];
-                const lastPoint = new PathPoint();
-                // linear lerp for progress
-                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
-                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
-                addVertices(lastPoint, radius, radialSegments);
-                break;
-            }
-            else {
-                addVertices(pathPoint, radius, radialSegments);
-            }
-        }
-    }
-    return {
-        position,
-        normal,
-        uv,
-        uv2,
-        indices,
-        count,
-    };
-}

package/WaterFlow/FloatingDuck.d.ts

@@ -1,88 +0,0 @@
-/** 水面采样结果（由 ShallowWaterSurface.sampleSurface 回填，供浮力/倾斜计算读高度与坡度）。 */
-interface DuckSurfaceSample {
-    height?: number;
-    velocityY?: number;
-    slopeX?: number;
-    slopeZ?: number;
-    flowX?: number;
-    flowZ?: number;
-    impact?: number;
-}
-/** 构造选项。 */
-export interface FloatingDuckOptions {
-    basinMinX: number;
-    basinMaxX: number;
-    basinHalfZ: number;
-    waterY: number;
-    startX?: number;
-    startZ?: number;
-}
-/** setEnvironment / clampToBounds 用的环境口径。 */
-export interface DuckEnvironment {
-    minX: number;
-    maxX: number;
-    halfZ: number;
-    centerZ?: number;
-    waterY: number;
-}
-/** update 的可调项。 */
-export interface DuckUpdateOptions {
-    surface?: DuckSurfaceSampler | null;
-    impactX?: number;
-    impactZ?: number;
-    impactEnergy?: number;
-    emitting?: boolean;
-}
-/** 只取 update 真正用到的水面能力（避免与 ShallowWaterSurface 形成类型环）。 */
-interface DuckSurfaceSampler {
-    sampleSurface(worldX: number, worldZ: number, target?: DuckSurfaceSample): DuckSurfaceSample;
-}
-/** 漂浮的橡皮鸭：跟随水面高度/坡度做浮沉与倾斜，可被鼠标拖拽。 */
-export declare class FloatingDuck {
-    private readonly bounds;
-    /** 静水面高度；setEnvironment 会随容器变化更新（故非 readonly）。 */
-    private waterY;
-    private readonly start;
-    private readonly velocity;
-    private readonly surfaceSample;
-    private yaw;
-    private yawVelocity;
-    private pitch;
-    private roll;
-    private readonly radiusX;
-    private readonly radiusZ;
-    private active;
-    private dragging;
-    private readonly dragOffset;
-    private readonly dragVelocity;
-    private readonly lastDragPosition;
-    private readonly group;
-    private readonly model;
-    private readonly pickGeometry;
-    private readonly pickMaterial;
-    private readonly pickMesh;
-    private readonly yellowMaterial;
-    private readonly wingMaterial;
-    private readonly beakMaterial;
-    private readonly eyeMaterial;
-    private readonly highlightMaterial;
-    private readonly sphereGeometry;
-    private readonly body;
-    private readonly head;
-    private readonly beak;
-    private readonly tailGeometry;
-    private readonly tail;
-    constructor({ basinMinX, basinMaxX, basinHalfZ, waterY, startX, startZ, }: FloatingDuckOptions);
-    setActive(active: boolean): void;
-    setEnvironment({ minX, maxX, halfZ, centerZ, waterY }: DuckEnvironment, reposition?: boolean): void;
-    place(x: number, z: number): void;
-    translateContainer(deltaX: number, deltaZ: number): void;
-    beginDrag(worldX: number, worldZ: number): void;
-    dragTo(worldX: number, worldZ: number, deltaSeconds: number): void;
-    endDrag(): void;
-    clampToBounds(): void;
-    reset(): void;
-    update(delta: number, elapsed: number, { surface, impactX, impactZ, impactEnergy, emitting, }?: DuckUpdateOptions): void;
-    dispose(): void;
-}
-export {};