@vvfx/sdk 0.2.8 → 0.2.9

package/dist/layer-order.js

@@ -0,0 +1,8 @@
+export function orderSDKCanvasLayers({ container, playerContainer, htmlOverlayLayer, gestureCanvas, }) {
+    ;
+    [playerContainer, htmlOverlayLayer, gestureCanvas].forEach(layer => {
+        if (layer?.parentElement === container) {
+            container.appendChild(layer);
+        }
+    });
+}

package/dist/math/box2.js

@@ -0,0 +1,396 @@
+import { Line2 } from './line2';
+import { Vector2 } from './vector2';
+/**
+ * @class 二维包围盒
+ */
+export class Box2 {
+    /**
+     * @member {Vector2[]} corners 二维包围盒角点
+     */
+    corners = [];
+    min = new Vector2(Infinity, Infinity);
+    max = new Vector2(-Infinity, -Infinity);
+    /**
+     * 构造函数，传入值为空时表示空包围盒
+     * @param {Vector2} [min=new Vector2(Infinity, Infinity)] 最小点
+     * @param {Vector2} [max=new Vector2(-Infinity, -Infinity)] 最大点
+     */
+    constructor(min = new Vector2(Infinity, Infinity), max = new Vector2(-Infinity, -Infinity)) {
+        this.min = min.clone();
+        this.max = max.clone();
+        if (!this.isEmpty()) {
+            this.corners = [
+                new Vector2(max.x, min.y),
+                max.clone(),
+                new Vector2(min.x, max.y),
+                min.clone(),
+            ];
+        }
+        else {
+            this.corners = [];
+        }
+    }
+    /**
+     * 通过最大最小点设置二维包围盒
+     * @param {Vector2} min 最小点
+     * @param {Vector2} max 最大点
+     * @returns {Box2} 二维包围盒
+     */
+    set(min, max) {
+        this.min.copyFrom(min);
+        this.max.copyFrom(max);
+        this.corners = [
+            new Vector2(max.x, min.y),
+            max.clone(),
+            new Vector2(min.x, max.y),
+            min.clone(),
+        ];
+        return this;
+    }
+    /**
+     * 通过角点设置二维包围盒
+     * @param {Vector2[]} vecArray 二维空间点数组
+     * @returns {Box2} 二维包围盒
+     */
+    setFromVec2Array(vecArray) {
+        this.min = new Vector2().copyFrom(vecArray[0]);
+        this.max = new Vector2().copyFrom(vecArray[0]);
+        vecArray.forEach(v => {
+            this.min.min(v);
+            this.max.max(v);
+        });
+        this.corners = [
+            new Vector2(this.max.x, this.min.y),
+            this.max.clone(),
+            new Vector2(this.min.x, this.max.y),
+            this.min.clone(),
+        ];
+        return this;
+    }
+    setFromCorners(corners) {
+        if (corners.length !== 4) {
+            throw new Error('corners length should be 4');
+        }
+        this.corners = [];
+        corners.forEach(corner => {
+            this.corners.push(corner.clone());
+            this.min.min(corner);
+            this.max.max(corner);
+        });
+        return this;
+    }
+    /**
+     * 通过屏幕坐标点设置二维包围盒 - 点为屏幕坐标点，x正方向为右，y正方向为向上
+     * @param vecArray 屏幕坐标点
+     */
+    setFromVec2ArrayWithOutCorners(vecArray) {
+        this.min = new Vector2().copyFrom(vecArray[0]);
+        this.max = new Vector2().copyFrom(vecArray[0]);
+        vecArray.forEach(v => {
+            this.min = this.min.min(v);
+            this.max = this.max.max(v);
+        });
+        this.corners.push(new Vector2(this.max.x, this.min.y));
+        this.corners.push(new Vector2(this.max.x, this.max.y));
+        this.corners.push(new Vector2(this.min.x, this.max.y));
+        this.corners.push(new Vector2(this.min.x, this.min.y));
+        return this;
+    }
+    /**
+     * 通过中心与大小设置二维包围盒
+     * @param {Vector2} center 二维中心点
+     * @param {Vector2} size 二维大小
+     * @returns {Box2} 二维包围盒
+     */
+    setFromCenterAndSize(center, size) {
+        const halfSize = new Vector2().copyFrom(size).multiply(0.5);
+        this.min.copyFrom(center).subtract(halfSize);
+        this.max.copyFrom(center).add(halfSize);
+        this.corners = [
+            new Vector2(this.max.x, this.min.y),
+            this.max.clone(),
+            new Vector2(this.min.x, this.max.y),
+            this.min.clone(),
+        ];
+        return this;
+    }
+    /**
+     * 克隆二维包围盒
+     * @returns {Box2} 克隆结果
+     */
+    clone() {
+        return new Box2().copyFrom(this);
+    }
+    /**
+     * 复制二维包围盒
+     * @param {Box2} box 二维包围盒
+     * @returns {Box2} 复制结果
+     */
+    copyFrom(box) {
+        this.corners = [];
+        this.min.copyFrom(box.min);
+        this.max.copyFrom(box.max);
+        box.corners.forEach(corner => {
+            this.corners.push(corner.clone());
+        });
+        return this;
+    }
+    /**
+     * 二维包围盒置空
+     * @returns {Box2} 置空结果
+     */
+    makeEmpty() {
+        this.min.x = this.min.y = Infinity;
+        this.max.x = this.max.y = -Infinity;
+        this.corners = [];
+        return this;
+    }
+    /**
+     * 二维包围盒判空
+     * @returns {boolean} 判空结果
+     */
+    isEmpty() {
+        // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
+        return (this.max.x < this.min.x) || (this.max.y < this.min.y);
+    }
+    /**
+     * 获取二维包围盒角点
+     * @returns {Vector2[]} 二维包围盒角点
+     */
+    getCorners() {
+        const res = [];
+        this.corners.forEach(corner => {
+            res.push(corner.clone());
+        });
+        return res;
+    }
+    /**
+     * 获取二维包围盒中心点
+     * @param {Vector2} [target=new Vector2()] 目标点(用以存放二维包围盒中心点)
+     * @returns {Vector2} 二维包围盒中心点
+     */
+    getCenter(target = new Vector2()) {
+        return this.isEmpty() ? target.set(0, 0) : target.addVectors(this.min, this.max).multiply(0.5);
+    }
+    /**
+     * 获取二维包围盒大小
+     * @param {Vector2} [target=new Vector2()] 目标向量(用以存放二维包围盒大小)
+     * @returns {Vector2} 二维包围盒大小
+     */
+    getSize(target = new Vector2()) {
+        return this.isEmpty() ? target.set(0, 0) : target.subtractVectors(this.max, this.min);
+    }
+    /**
+     * 通过二维空间点扩展二维包围盒
+     * @param {Vector2} point 二维空间点
+     * @returns {Box2} 扩展包围盒
+     */
+    expandByPoint(point) {
+        this.min.min(point);
+        this.max.max(point);
+        return this;
+    }
+    /**
+     * 通过向量扩展二维包围盒
+     * @param {Vector2} vector 二维向量
+     * @returns {Box2} 扩展结果
+     */
+    expandByVector(vector) {
+        this.min.subtract(vector);
+        this.max.add(vector);
+        return this;
+    }
+    /**
+     * 通过大小扩展二维包围盒
+     * @param {number} scalar 扩展大小
+     * @returns {Box2} 扩展结果
+     */
+    expandByScalar(scalar) {
+        this.min.add(-scalar);
+        this.max.add(scalar);
+        return this;
+    }
+    /**
+     * 判断二维包围盒是否包含二维空间点
+     * @param {Vector2} point 二维空间点
+     * @param {boolean} [isOrthogonal=true] 包围盒正交判断(默认为true)
+     * @returns {boolean} 点包含判断结果
+     */
+    containsPoint(point, isOrthogonal = true) {
+        if (isOrthogonal) {
+            return point.x < this.min.x || point.x > this.max.x ||
+                point.y < this.min.y || point.y > this.max.y ? false : true;
+        }
+        else {
+            if (this.isEmpty()) {
+                return false;
+            }
+            for (let i = 0; i < this.corners.length; i++) {
+                const corner = this.corners[i];
+                const next = this.corners[(i + 1) % 4];
+                const edge = new Vector2(next.x - corner.x, next.y - corner.y);
+                const vec = new Vector2(point.x - corner.x, point.y - corner.y);
+                if (edge.cross(vec) < 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    /**
+     * 判断二维包围盒包含关系(if this contains other)
+     * @param {Box2} box 其它包围盒
+     * @returns {boolean} 二维包围盒包含判断结果
+     */
+    containsBox(box) {
+        return this.min.x <= box.min.x
+            && box.max.x <= this.max.x
+            && this.min.y <= box.min.y
+            && box.max.y <= this.max.y;
+    }
+    /**
+     * 获取点以包围盒左上角顶点为原点的相对位置
+     * @param {Vector2} point 指定二维空间点
+     * @param {Vector2} [target=new Vector2()] 目标空间点
+     * @returns {Vector2} 计算结果空间点
+     */
+    getParameter(point, target = new Vector2()) {
+        // This can potentially have a divide by zero if the box
+        // has a size dimension of 0.
+        return target.set((point.x - this.min.x) / (this.max.x - this.min.x), (point.y - this.min.y) / (this.max.y - this.min.y));
+    }
+    /**
+     * 求点与二维包围盒的最近点
+     * @param {Vector2} point 二维空间点
+     * @param {Vector2} [target=new Vector2()] 结果点
+     * @returns {Vector2} 二维空间点
+     */
+    clampPoint(point, target = new Vector2()) {
+        return target.copyFrom(point).clamp(this.min, this.max);
+    }
+    /**
+     * 求点到二维包围盒的距离
+     * @param {Vector2} point 二维空间点
+     * @returns {number} 距离
+     */
+    distanceToPoint(point) {
+        const clampedPoint = new Vector2().copyFrom(point).clamp(this.min, this.max);
+        return clampedPoint.subtract(point).length();
+    }
+    /**
+     * 二维包围盒求交集
+     * @param {Box2} box 二维包围盒
+     * @returns {Box2} 求交结果
+     */
+    intersect(box) {
+        this.min.max(box.min);
+        this.max.min(box.max);
+        if (this.min.x > this.max.x || this.min.y > this.max.y) {
+            return this.makeEmpty();
+        }
+        return this;
+    }
+    /**
+     * 二维包围盒求并集
+     * @param {Box2} box 二维包围盒
+     * @returns {Box2} 求并结果
+     */
+    union(target) {
+        if (target instanceof Box2) {
+            this.min.min(target.min);
+            this.max.max(target.max);
+        }
+        else {
+            this.min.min(target);
+            this.max.max(target);
+        }
+        this.corners = [
+            new Vector2(this.max.x, this.min.y),
+            this.max.clone(),
+            new Vector2(this.min.x, this.max.y),
+            this.min.clone(),
+        ];
+        return this;
+    }
+    /**
+     * 二维包围盒位移
+     * @param {Vector2} offset 位移向量
+     * @returns {Box2} 位移结果
+     */
+    translate(offset) {
+        this.min.add(offset);
+        this.max.add(offset);
+        this.corners.forEach(corner => {
+            corner.add(offset);
+        });
+        return this;
+    }
+    scale(scalar, anchor) {
+        anchor ??= this.getCenter();
+        const resultScalar = typeof scalar === 'number' ? new Vector2(scalar, scalar) : new Vector2(scalar.x, scalar.y);
+        this.min.scaleByCenter(resultScalar, anchor);
+        this.max.scaleByCenter(resultScalar, anchor);
+        this.corners.forEach(corner => {
+            corner.scaleByCenter(resultScalar, anchor);
+        });
+        return this;
+    }
+    /**
+     * 二维包围盒判等
+     * @param {Box2} box 二维包围盒
+     * @returns {boolean} 判等结果
+     */
+    equals(box) {
+        return box.min.equals(this.min) && box.max.equals(this.max);
+    }
+    /**
+     * 判断二维包围盒相交关系(if this intersect other)
+     * @param {Box2} box 二维包围盒
+     * @param {boolean} [isOrthogonal=true] 正交判断(当前包围盒)
+     * @returns {boolean} 相交判断结果
+     */
+    intersectsBox(box, isOrthogonal = true) {
+        // using 4 splitting planes to rule out intersections
+        // 基于点判断
+        if (isOrthogonal) {
+            return !(box.max.x < this.min.x
+                || box.min.x > this.max.x
+                || box.max.y < this.min.y
+                || box.min.y > this.max.y);
+        }
+        else {
+            if (!this.isEmpty()) {
+                for (let i = 0; i < this.corners.length; i++) {
+                    const line = new Line2(this.corners[i], this.corners[(i + 1) % 4]);
+                    if (box.containsPoint(this.corners[i], false)) {
+                        return true;
+                    }
+                    for (let j = 0; j < box.corners.length; j++) {
+                        const boxLine = new Line2(box.corners[j], box.corners[(j + 1) % 4]);
+                        if (this.containsPoint(box.corners[j], false)) {
+                            return true;
+                        }
+                        if (line.crossWithLine(boxLine)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < box.corners.length; i++) {
+                const state = this.containsPoint(box.corners[i], false);
+                const stateOther = box.containsPoint(this.corners[i], false);
+                if (state || stateOther) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    rotate(angle, center) {
+        center ??= this.getCenter();
+        const corners = this.corners.map(corner => corner.rotateAround(center, angle));
+        this.makeEmpty();
+        this.setFromVec2Array(corners);
+        return this;
+    }
+}

package/dist/math/circle.js

@@ -0,0 +1,131 @@
+import { Vector2 } from './vector2';
+export class Circle {
+    center;
+    radius;
+    constructor(center = new Vector2(), radius = 0) {
+        this.center = center.clone();
+        this.radius = radius;
+    }
+    /**
+     * 通过中心点与大小设置圆
+     * @param {Vector2} center 圆心
+     * @param {number} radius 半径
+     * @returns {Circle}
+     */
+    set(center, radius) {
+        this.center = new Vector2().copyFrom(center);
+        this.radius = radius;
+        return this;
+    }
+    /**
+     * 克隆圆
+     * @returns {Circle} 克隆结果
+     */
+    clone() {
+        return new Circle().copy(this);
+    }
+    /**
+     * 复制圆
+     * @param {Circle} circle 复制对象
+     * @returns {Circle} 复制结果
+     */
+    copy(circle) {
+        this.center.copyFrom(circle.center);
+        this.radius = circle.radius;
+        return this;
+    }
+    /**
+     * 圆置空
+     * @returns {Circle} 置空结果
+     */
+    makeEmpty() {
+        this.center = new Vector2();
+        this.radius = 0;
+        return this;
+    }
+    /**
+     * 圆判空
+     * @returns {boolean} 判空结果
+     */
+    isEmpty() {
+        // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
+        return this.radius <= 0;
+    }
+    /**
+     * 获取圆心
+     * @param {Vector2} [target=new Vector2()] 目标结果对象
+     * @returns {Vector2} 圆心
+     */
+    getCenter(target = new Vector2()) {
+        target.copyFrom(this.center);
+        return target;
+    }
+    /**
+     * 获取半径
+     * @returns {number} 半径
+     */
+    getRadius() {
+        return this.radius;
+    }
+    /**
+     * 通过二维空间点扩展圆
+     * @param {Vector2} point 二维空间点
+     * @returns {Circle} 扩展结果
+     */
+    expandByPoint(point) {
+        this.radius = this.center.distanceTo(point);
+        return this;
+    }
+    /**
+     * 通过大小扩展圆
+     * @param {number} scalar 扩展大小
+     * @returns {Circle} 扩展结果
+     */
+    expandByScalar(scalar) {
+        this.radius += scalar;
+        return this;
+    }
+    /**
+     * 判断圆是否包含二维空间点
+     * @param {Vector2} point 二维空间点
+     * @returns {boolean}  包含判断结果
+     */
+    containsPoint(point) {
+        return this.center.distanceTo(point) < this.radius;
+    }
+    /**
+     * 判断圆是否包含二维包围盒
+     * @param {Box2} box 二维包围盒
+     * @returns {boolean} 包含判断结果
+     */
+    containsBox(box) {
+        for (let i = 0; i < 4; i++) {
+            if (!this.containsPoint(box.corners[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 判断圆与二维包围盒的相交关系
+     * @param {Box2} box 二维包围盒
+     * @returns {boolean} 相交判断结果
+     */
+    intersectsBox(box) {
+        // using 4 splitting planes to rule out intersections
+        for (let i = 0; i < 4; i++) {
+            if (this.containsPoint(box.corners[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 求点与圆的最短距离
+     * @param {Vector2} point 二维空间点
+     * @returns {number} 距离
+     */
+    distanceToPoint(point) {
+        return this.center.distanceTo(point) - this.radius;
+    }
+}

package/dist/math/euler.js

@@ -0,0 +1,35 @@
+import { math } from '../shared';
+import { Matrix4 } from './matrix4';
+import { DEG2RAD, RAD2DEG } from './utils';
+import { Vector3 } from './vector3';
+export class Euler extends math.Euler {
+    constructor(x = 0, y = 0, z = 0, order = math.EulerOrder.XYZ) {
+        super(x, y, z, order);
+    }
+    getInvertMatrixByEuler() {
+        const matrix = new Matrix4().makeRotationFromEuler(this).invert();
+        return matrix;
+    }
+    /**
+     * 欧拉角保存于三维向量(应用于计算)
+     * @param {Vector3} [optionalResult] 目标保存对象
+     * @returns {Vector3} 保存结果
+     */
+    toDegreeVector3(optionalResult) {
+        if (optionalResult) {
+            return optionalResult.set(this.x * RAD2DEG, this.y * RAD2DEG, this.z * RAD2DEG);
+        }
+        else {
+            return new Vector3(this.x * RAD2DEG, this.y * RAD2DEG, this.z * RAD2DEG);
+        }
+    }
+    /**
+     * 由角度三维向量构建欧拉角
+     * @param {Vector3} v 角度三维向量
+     * @param {EulerOrder} [order] 欧拉角顺序，默认为ZYX
+     * @returns {Euler} 欧拉角
+     */
+    setFromDegreeVector3(degree, order) {
+        return this.set(degree.x * DEG2RAD, degree.y * DEG2RAD, degree.z * DEG2RAD, order ?? this.order);
+    }
+}

package/dist/math/index.js

@@ -0,0 +1,13 @@
+export * from './box2';
+export * from './circle';
+export * from './euler';
+export * from './line2';
+export * from './line3';
+export * from './matrix4';
+export * from './plane';
+export * from './quaternion';
+export * from './ray-caster';
+export * from './ray';
+export * from './utils';
+export * from './vector2';
+export * from './vector3';