@vvfx/sdk 0.2.8 → 0.2.10

package/dist/math/line2.js

@@ -0,0 +1,153 @@
+import { clamp } from './utils';
+import { Vector2 } from './vector2';
+/**
+ * @class 二维线段
+ */
+export class Line2 {
+    start = new Vector2();
+    end = new Vector2();
+    constructor(start = new Vector2(), end = new Vector2()) {
+        this.start.copyFrom(start);
+        this.end.copyFrom(end);
+    }
+    /**
+     * 设置二维线段
+     * @param {Vector2} start 线段起点
+     * @param {Vector2} end 线段终点
+     * @returns {Line2} 二维线段
+     */
+    set(start, end) {
+        this.start.copyFrom(start);
+        this.end.copyFrom(end);
+        return this;
+    }
+    /**
+     * 复制二维线段
+     * @param {Line2} line 复制对象
+     * @returns {Line2} 复制结果
+     */
+    copyFrom(line) {
+        this.start.copyFrom(line.start);
+        this.end.copyFrom(line.end);
+        return this;
+    }
+    /**
+     * 二维线段求方向
+     * @returns {Vector2} 二维线段方向
+     */
+    direction() {
+        return new Vector2().subtractVectors(this.end, this.start).normalize();
+    }
+    /**
+     * 二维线段求中点
+     * @param {Vector2} [target=new Vector2()] 目标保存对象
+     * @returns {Vector2} 二维线段中点
+     */
+    getCenter(target = new Vector2()) {
+        return target.addVectors(this.start, this.end).multiply(0.5);
+    }
+    /**
+     * 二维线段向量值
+     * @param {Vector2} [target=new Vector2()] 目标保存对象
+     * @returns {Vector2} 二维线段向量值
+     */
+    delta(target = new Vector2()) {
+        return target.subtractVectors(this.end, this.start);
+    }
+    /**
+     * 二维线段欧式距离平方(应用于计算)
+     * @returns {number} 计算结果
+     */
+    distanceSq() {
+        return this.start.distanceSquared(this.end);
+    }
+    /**
+     * 二维线段欧式距离
+     * @returns {number} 计算结果
+     */
+    distance() {
+        return this.start.distance(this.end);
+    }
+    /**
+     * 求二维线段比例点
+     * @param {number} t 比例值
+     * @param {Vector2} target 目标保存对象
+     * @returns {Vector2} 比例点结果
+     */
+    at(t, target = new Vector2()) {
+        return this.delta(target).multiply(t).add(this.start);
+    }
+    /**
+     * 求点与线段的最短距离
+     * @param {Vector2} point 二维空间点
+     * @param {boolean} clampToLine 是否限制于线段内
+     * @returns {number} 距离结果
+     */
+    closestPointToPointParameter(point, clampToLine) {
+        const startP = new Vector2();
+        const startEnd = new Vector2();
+        startP.subtractVectors(point, this.start);
+        startEnd.subtractVectors(this.end, this.start);
+        const se2se = startEnd.dot(startEnd);
+        const se2sp = startEnd.dot(startP);
+        let t = se2sp / se2se;
+        if (clampToLine) {
+            t = clamp(t, 0, 1);
+        }
+        return t;
+    }
+    /**
+     * 求点与线段的最近交点
+     * @param {Vector2} point 二维空间点
+     * @param {boolean} clampToLine 是否限制于线段内
+     * @param {Vector2} target 目标保存对象
+     * @returns {Vector2} 最近交点
+     */
+    closestPointToPoint(point, clampToLine, target = new Vector2()) {
+        const t = this.closestPointToPointParameter(point, clampToLine);
+        return this.delta(target).multiply(t).add(this.start);
+    }
+    /**
+     * 二维线段判等
+     * @param {Line2} line 二维线段
+     * @returns {boolean} 判等结果
+     */
+    equals(line) {
+        return line.start.equals(this.start) && line.end.equals(this.end);
+    }
+    /**
+     * 克隆二维线段
+     * @returns {Line2} 克隆结果
+     */
+    clone() {
+        return new Line2().copyFrom(this);
+    }
+    /**
+     * 二维线段求长度
+     * @returns {number} 长度
+     */
+    length() {
+        return new Vector2().subtractVectors(this.end, this.start).length();
+    }
+    /**
+     * 二维线段判断相交
+     * @param {Line2} other 二维线段
+     * @returns {boolean} 相交判断结果
+     */
+    crossWithLine(other) {
+        const vecA = this.delta();
+        const vecB = other.delta();
+        const vecAStart = new Vector2().subtractVectors(other.start, this.start);
+        const vecAEnd = new Vector2().subtractVectors(other.end, this.start);
+        const vecBStart = new Vector2().subtractVectors(this.start, other.start);
+        const vecBEnd = new Vector2().subtractVectors(this.end, other.start);
+        const crossA2BStart = vecAStart.cross(vecA);
+        const crossA2BEnd = vecAEnd.cross(vecA);
+        const crossB2AStart = vecBStart.cross(vecB);
+        const crossB2AEnd = vecBEnd.cross(vecB);
+        if (crossA2BStart * crossA2BEnd < 0 && crossB2AStart * crossB2AEnd < 0) {
+            return true;
+        }
+        return false;
+    }
+}

package/dist/math/line3.js

@@ -0,0 +1,36 @@
+import { clamp } from './utils';
+import { Vector3 } from './vector3';
+/**
+ * @class 三维线段
+ */
+export class Line3 {
+    start;
+    end;
+    /**
+     * 构造函数
+     * @param {Vector3} [start=new Vector3()] 线段起点，默认值为(0, 0, 0)
+     * @param {Vector3} [end=new Vector3()] 线段终点，默认值为(0, 0, 0)
+     */
+    constructor(start = new Vector3(), end = new Vector3()) {
+        this.start = start.clone();
+        this.end = end.clone();
+    }
+    closestPointToPointParameter(point, clampToLine = false) {
+        const startP = new Vector3().subtractVectors(point, this.start);
+        const startEnd = new Vector3().subtractVectors(this.end, this.start);
+        const startEnd2 = startEnd.dot(startEnd);
+        const startEnd_startP = startEnd.dot(startP);
+        let t = startEnd_startP / startEnd2;
+        if (clampToLine) {
+            t = clamp(t, 0, 1);
+        }
+        return t;
+    }
+    closestPointToPoint(point, clampToLine = false) {
+        const t = this.closestPointToPointParameter(point, clampToLine);
+        return this.delta().multiply(t).add(this.start);
+    }
+    delta() {
+        return new Vector3().subtractVectors(this.end, this.start);
+    }
+}

package/dist/math/matrix4.js

@@ -0,0 +1,207 @@
+import { math } from '../shared';
+import { Vector3 } from './vector3';
+export class Matrix4 extends math.Matrix4 {
+    /**
+     * 通过数组创建矩阵
+     * @param array - 数组
+     * @param [offset=0] - 起始偏移值
+     * @returns 矩阵
+     */
+    static fromArray(array, offset = 0) {
+        return new Matrix4().setFromArray(array, offset);
+    }
+    clone() {
+        const e = this.elements;
+        return new Matrix4(e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15]);
+    }
+    compose(translation, rotation, scale, anchor = Vector3.ZERO) {
+        const te = this.elements;
+        const { x, y, z, w } = rotation;
+        const l = -anchor.x;
+        const m = -anchor.y;
+        const n = -anchor.z;
+        const x2 = x + x;
+        const y2 = y + y;
+        const z2 = z + z;
+        const xx = x * x2;
+        const xy = x * y2;
+        const xz = x * z2;
+        const yy = y * y2;
+        const yz = y * z2;
+        const zz = z * z2;
+        const wx = w * x2;
+        const wy = w * y2;
+        const wz = w * z2;
+        const { x: sx, y: sy, z: sz } = scale;
+        te[0] = (1 - (yy + zz)) * sx;
+        te[1] = (xy + wz) * sx;
+        te[2] = (xz - wy) * sx;
+        te[3] = 0;
+        te[4] = (xy - wz) * sy;
+        te[5] = (1 - (xx + zz)) * sy;
+        te[6] = (yz + wx) * sy;
+        te[7] = 0;
+        te[8] = (xz + wy) * sz;
+        te[9] = (yz - wx) * sz;
+        te[10] = (1 - (xx + yy)) * sz;
+        te[11] = 0;
+        te[12] = l * te[0] + m * te[4] + n * te[8] - l + translation.x;
+        te[13] = l * te[1] + m * te[5] + n * te[9] - m + translation.y;
+        te[14] = l * te[2] + m * te[6] + n * te[10] - n + translation.z;
+        return this;
+    }
+    /**
+     * 导出四维矩阵[三维空间变换矩阵]旋转部分
+     * @param {Matrix4} m 四维矩阵
+     * @returns {Matrix4} 导出结果
+     */
+    extractRotation(m) {
+        // this method does not support reflection matrices
+        const _v = new Vector3();
+        const me = m.elements;
+        const te = this.elements;
+        const scaleX = 1 / _v.setFromMatrixColumn(m, 0).length();
+        const scaleY = 1 / _v.setFromMatrixColumn(m, 1).length();
+        const scaleZ = 1 / _v.setFromMatrixColumn(m, 2).length();
+        te[0] = me[0] * scaleX;
+        te[1] = me[1] * scaleX;
+        te[2] = me[2] * scaleX;
+        te[3] = 0;
+        te[4] = me[4] * scaleY;
+        te[5] = me[5] * scaleY;
+        te[6] = me[6] * scaleY;
+        te[7] = 0;
+        te[8] = me[8] * scaleZ;
+        te[9] = me[9] * scaleZ;
+        te[10] = me[10] * scaleZ;
+        te[11] = 0;
+        te[12] = 0;
+        te[13] = 0;
+        te[14] = 0;
+        te[15] = 1;
+        return this;
+    }
+    /**
+     * 由欧拉角设置四维矩阵
+     * @param {Euler} euler 欧拉角
+     * @returns {Matrix4} 四维矩阵
+     */
+    makeRotationFromEuler(euler) {
+        const te = this.elements;
+        const x = euler.x;
+        const y = euler.y;
+        const z = euler.z;
+        const a = Math.cos(x);
+        const b = Math.sin(x);
+        const c = Math.cos(y);
+        const d = Math.sin(y);
+        const e = Math.cos(z);
+        const f = Math.sin(z);
+        if (euler.order === math.EulerOrder.XYZ) {
+            const ae = a * e;
+            const af = a * f;
+            const be = b * e;
+            const bf = b * f;
+            te[0] = c * e;
+            te[4] = -c * f;
+            te[8] = d;
+            te[1] = af + be * d;
+            te[5] = ae - bf * d;
+            te[9] = -b * c;
+            te[2] = bf - ae * d;
+            te[6] = be + af * d;
+            te[10] = a * c;
+        }
+        else if (euler.order === math.EulerOrder.YXZ) {
+            const ce = c * e;
+            const cf = c * f;
+            const de = d * e;
+            const df = d * f;
+            te[0] = ce + df * b;
+            te[4] = de * b - cf;
+            te[8] = a * d;
+            te[1] = a * f;
+            te[5] = a * e;
+            te[9] = -b;
+            te[2] = cf * b - de;
+            te[6] = df + ce * b;
+            te[10] = a * c;
+        }
+        else if (euler.order === math.EulerOrder.ZXY) {
+            const ce = c * e;
+            const cf = c * f;
+            const de = d * e;
+            const df = d * f;
+            te[0] = ce - df * b;
+            te[4] = -a * f;
+            te[8] = de + cf * b;
+            te[1] = cf + de * b;
+            te[5] = a * e;
+            te[9] = df - ce * b;
+            te[2] = -a * d;
+            te[6] = b;
+            te[10] = a * c;
+        }
+        else if (euler.order === math.EulerOrder.ZYX) {
+            const ae = a * e;
+            const af = a * f;
+            const be = b * e;
+            const bf = b * f;
+            te[0] = c * e;
+            te[4] = be * d - af;
+            te[8] = ae * d + bf;
+            te[1] = c * f;
+            te[5] = bf * d + ae;
+            te[9] = af * d - be;
+            te[2] = -d;
+            te[6] = b * c;
+            te[10] = a * c;
+        }
+        else if (euler.order === math.EulerOrder.YZX) {
+            const ac = a * c;
+            const ad = a * d;
+            const bc = b * c;
+            const bd = b * d;
+            te[0] = c * e;
+            te[4] = bd - ac * f;
+            te[8] = bc * f + ad;
+            te[1] = f;
+            te[5] = a * e;
+            te[9] = -b * e;
+            te[2] = -d * e;
+            te[6] = ad * f + bc;
+            te[10] = ac - bd * f;
+        }
+        else if (euler.order === math.EulerOrder.XZY) {
+            const ac = a * c;
+            const ad = a * d;
+            const bc = b * c;
+            const bd = b * d;
+            te[0] = c * e;
+            te[4] = -f;
+            te[8] = d * e;
+            te[1] = ac * f + bd;
+            te[5] = a * e;
+            te[9] = ad * f - bc;
+            te[2] = bc * f - ad;
+            te[6] = b * e;
+            te[10] = bd * f + ac;
+        }
+        // bottom row
+        te[3] = 0;
+        te[7] = 0;
+        te[11] = 0;
+        // last column
+        te[12] = 0;
+        te[13] = 0;
+        te[14] = 0;
+        te[15] = 1;
+        return this;
+    }
+    setPosition(position) {
+        this.elements[12] = position.x;
+        this.elements[13] = position.y;
+        this.elements[14] = position.z;
+        return this;
+    }
+}

package/dist/math/plane.js

@@ -0,0 +1,52 @@
+import { Vector3 } from './vector3';
+export class Plane {
+    distance;
+    normal;
+    constructor(distance = 0, normal = new Vector3(0, 0, 1)) {
+        const length = normal.length();
+        if (length === 0) {
+            this.normal = new Vector3(0, 0, 1);
+        }
+        this.distance = distance / (length ?? 1);
+        this.normal = normal.normalize();
+    }
+    static set(distance, normal) {
+        const plane = new Plane(distance, normal);
+        return plane;
+    }
+    set(distance, normal) {
+        const length = normal.length();
+        if (length === 0) {
+            this.normal = new Vector3(0, 0, 1);
+        }
+        this.distance = distance / length;
+        this.normal = normal.normalize();
+        return this;
+    }
+    static copy(target) {
+        const plane = new Plane(target.distance, target.normal.clone());
+        return plane;
+    }
+    copy(target) {
+        this.distance = target.distance;
+        this.normal.copyFrom(target.normal);
+        return this;
+    }
+    static setFromNormalAndCoplanarPoint(point, normal) {
+        const distance = -point.dot(normal);
+        const plane = new Plane(distance, normal);
+        return plane;
+    }
+    setFromNormalAndCoplanarPoint(point, normal) {
+        this.normal.copyFrom(normal);
+        this.distance = -point.dot(this.normal);
+        return this;
+    }
+    clone() {
+        const plane = new Plane(this.distance, this.normal.clone());
+        return plane;
+    }
+    distanceToPoint(point) {
+        return this.normal.dot(point) + this.distance;
+    }
+}

package/dist/math/quaternion.js

@@ -0,0 +1,3 @@
+import { math } from '../shared';
+export class Quaternion extends math.Quaternion {
+}

package/dist/math/ray-caster.js

@@ -0,0 +1,25 @@
+import { Ray } from './ray';
+import { Vector3 } from './vector3';
+export class RayCaster {
+    ray;
+    constructor(ray = new Ray()) {
+        this.ray = ray.clone();
+    }
+    setFromCamera(coords, camera) {
+        const origin = camera.position;
+        const direction = new Vector3(coords.x, coords.y, 0.5).applyMatrix(camera.inverseViewProjectMatrix).subtract(origin).normalize();
+        this.ray.set(origin, direction);
+        return this;
+    }
+    rayCastPlane(plane) {
+        const point = new Vector3();
+        const distance = this.ray.rayCastPlane(plane, point);
+        if (isNaN(distance)) {
+            return undefined;
+        }
+        return {
+            distance,
+            point: this.ray.at(distance),
+        };
+    }
+}

package/dist/math/ray.js

@@ -0,0 +1,47 @@
+import { math } from '../shared';
+import { isZero } from './utils';
+import { Vector3 } from './vector3';
+export class Ray extends math.Ray {
+    origin;
+    direction;
+    constructor(origin = new Vector3(), direction = new Vector3(1, 0, 0)) {
+        super(origin, direction);
+        this.origin = origin.clone();
+        this.direction = direction.clone();
+    }
+    clone() {
+        return new Ray(this.origin, this.direction);
+    }
+    rayCastPlane(plane, _target) {
+        const t = this.distanceToPlane(plane);
+        if (isNaN(t)) {
+            return t;
+        }
+        // TODO:: @赤芍 无意义
+        _target = this.at(t);
+        return t;
+    }
+    at(t) {
+        return this.direction.clone().normalize().multiply(t).add(this.origin);
+    }
+    /**
+     * 射线到平面的距离
+     * 当两个向量都是单位向量的时候，从a投影到b的距离等于从b投影到a的距离
+     * @param plane 平面
+     * @returns 射线到平面的距离
+     */
+    distanceToPlane(plane) {
+        /**
+         * 单位向量的投影距离
+         */
+        const dotProduct = plane.normal.dot(this.direction);
+        if (isZero(dotProduct)) {
+            if (isZero(plane.distanceToPoint(this.origin))) {
+                return 0;
+            }
+            return NaN;
+        }
+        const t = (-this.origin.dot(plane.normal) - plane.distance) / dotProduct;
+        return t > 0 ? t : NaN;
+    }
+}

package/dist/math/type.js

@@ -0,0 +1 @@
+export {};

package/dist/math/utils.js

@@ -0,0 +1,77 @@
+import { Box2 } from './box2';
+import { Vector2 } from './vector2';
+const Number_Tolerance = 0.000001;
+export function clamp(value, min, max) {
+    const fixedMin = isNaN(min) ? -Infinity : min;
+    const fixedMax = isNaN(max) ? Infinity : max;
+    const lower = Math.min(fixedMin, fixedMax);
+    const upper = Math.max(fixedMin, fixedMax);
+    return Math.min(Math.max(value, lower), upper);
+}
+/**
+ * @description 角度转弧度系数
+ */
+export const DEG2RAD = Math.PI / 180;
+/**
+ * @description 弧度转角度系数
+ */
+export const RAD2DEG = 180 / Math.PI;
+export function getVector2Angle(vector) {
+    const angle = Math.atan2(-vector.y, -vector.x) + Math.PI;
+    return angle;
+}
+export function getAngleByVectors(vector1, vector2) {
+    const cosValue = Math.min(Math.max(vector1.dot(vector2) / vector1.length() / vector2.length(), -1), 1);
+    let angle = Math.acos(cosValue);
+    angle = vector1.x * vector2.y - vector1.y * vector2.x > 0 ? angle : -angle;
+    return angle;
+}
+export function roundNumber(number, precision, method = Math.round) {
+    // 已经是整数，则无需处理
+    if (Number.isInteger(number)) {
+        return number;
+    }
+    const decimal = Math.pow(10, precision);
+    return method(number * decimal) / decimal;
+}
+export function getAbsMaxIndex(numbers) {
+    let resultIndex = 0;
+    let max;
+    numbers.forEach((number, index) => {
+        if (index === 0) {
+            max = Math.abs(number);
+        }
+        else {
+            const absNumber = Math.abs(number);
+            if (max < absNumber) {
+                max = absNumber;
+                resultIndex = index;
+            }
+        }
+    });
+    return resultIndex;
+}
+export function isEqual(a, b) {
+    return Math.abs(a - b) < Number_Tolerance || (a === Infinity && b === Infinity) || (a === -Infinity && b === -Infinity);
+}
+export function isZero(v) {
+    return isNaN(v) || Math.abs(v) < Number_Tolerance;
+}
+export function getBoxByNormalizeBox(origin, normalize) {
+    const result = new Box2();
+    const { min: originMin, max: originMax } = origin;
+    const { min: normalizeMin, max: normalizeMax } = normalize;
+    const min = originMin.clone().add(new Vector2().subtractVectors(originMax, originMin).multiply(normalizeMin));
+    const max = originMin.clone().add(new Vector2().subtractVectors(originMax, originMin).multiply(normalizeMax));
+    result.setFromVec2ArrayWithOutCorners([min, max]);
+    return result;
+}
+export function getNormalizeBoxByBoxes(origin, current) {
+    const result = new Box2();
+    const { min: originMin, max: originMax } = origin;
+    const { min: currentMin, max: currentMax } = current;
+    const min = new Vector2().subtractVectors(currentMin, originMin).divide(new Vector2().subtractVectors(originMax, originMin));
+    const max = new Vector2().subtractVectors(currentMax, originMin).divide(new Vector2().subtractVectors(originMax, originMin));
+    result.setFromVec2ArrayWithOutCorners([min, max]);
+    return result;
+}

package/dist/math/vector2.js

@@ -0,0 +1,70 @@
+import { math } from '../shared';
+import { clamp } from './utils';
+export class Vector2 extends math.Vector2 {
+    subtract(other) {
+        this.x -= other.x;
+        this.y -= other.y;
+        return this;
+    }
+    toViewCoordinate(width, height) {
+        this.x = ((this.x + 1) / 2) * width;
+        this.y = (1 - (this.y + 1) / 2) * height;
+        return this;
+    }
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+    distanceTo(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    scaleByCenter(scalar, anchor = new Vector2()) {
+        const delta = new Vector2().subtractVectors(anchor, this).multiply(scalar);
+        return this.subtractVectors(anchor, delta);
+    }
+    round(precision = 0) {
+        // 已经是整数，则无需处理
+        const decimal = Math.pow(10, precision);
+        this.x = Math.round((this.x * decimal)) / decimal;
+        this.y = Math.round((this.y * decimal)) / decimal;
+        return this;
+    }
+    /**
+     * 点到直线的最短距离
+     * @returns {{d: number, t: number}} d表示距离，t表示最近点在直线的比例
+     */
+    distanceToLine(line) {
+        const l2 = Math.pow(line.length(), 2);
+        const { start, end } = line;
+        if (l2 === 0) {
+            return { d: new Vector2().subtractVectors(this, start).length(), t: 0 };
+        }
+        const t = ((this.x - start.x) * (end.x - start.x) + (this.y - start.y) * (end.y - start.y)) / l2;
+        const clampedT = clamp(t, 0, 1);
+        return { d: new Vector2().subtractVectors(this, line.at(clampedT)).length(), t: clampedT };
+    }
+    /**
+     * 二维向量与x轴夹角
+     * @returns {number} 弧度值
+     */
+    angle() {
+        // computes the angle in radians with respect to the positive x-axis
+        const angle = Math.atan2(-this.y, -this.x) + Math.PI;
+        return angle;
+    }
+    /**
+     * 二维点绕点旋转
+     * @param {Vec2} center 旋转中心
+     * @param {number} angle 旋转角度
+     * @returns {Vec2} 旋转结果
+     */
+    rotateAround(center, angle) {
+        const c = Math.cos(angle), s = Math.sin(angle);
+        const x = this.x - center.x;
+        const y = this.y - center.y;
+        this.x = x * c - y * s + center.x;
+        this.y = x * s + y * c + center.y;
+        return this;
+    }
+}