@realsee/dnalogel 2.1.0-alpha.13 → 2.1.0-alpha.15

package/libs/src/shared-utils/math/planimetry.js

@@ -0,0 +1,288 @@
+/**
+ * 平面几何相关数学函数
+ */
+/**
+ * 检查两个点是否位置相同
+ * @param point1
+ * @param point2
+ * @return
+ */
+export function samePointAt(point1, point2) {
+    return point1.x === point2.x && point1.y === point2.y;
+}
+/**
+ * 计算两个点之间的位置
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export function distance(point1, point2) {
+    return Math.sqrt(Math.pow(point2.x - point1.x, 2) + Math.pow(point2.y - point1.y, 2));
+}
+/**
+ * 两个计算的斜率是否相同
+ * @param  {number} k1
+ * @param  {number} k2
+ * @return
+ */
+export function sameK(k1, k2) {
+    if (Math.abs(k1) === Infinity && Math.abs(k2) === Infinity)
+        return true;
+    return Math.abs(k1 - k2) < 0.001;
+}
+/**
+ * 获取两点之间的斜率
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export function getK(point1, point2) {
+    return (point2.y - point1.y) / (point2.x - point1.x);
+}
+/**
+ * 获取一点对于线段上最近的一点，
+ * 如果可以是过直线垂线的垂足，不行的话取线段的两端
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {point}
+ */
+export function closestPointOnLine(point, linePoints) {
+    const tA = point.x - linePoints[0].x;
+    const tB = point.y - linePoints[0].y;
+    const tC = linePoints[1].x - linePoints[0].x;
+    const tD = linePoints[1].y - linePoints[0].y;
+    const tDot = tA * tC + tB * tD;
+    const tLenSq = tC * tC + tD * tD;
+    const tParam = tDot / tLenSq;
+    let tXx, tYy;
+    if (tParam < 0 || samePointAt(linePoints[0], linePoints[1])) {
+        tXx = linePoints[0].x;
+        tYy = linePoints[0].y;
+    }
+    else if (tParam > 1) {
+        tXx = linePoints[1].x;
+        tYy = linePoints[1].y;
+    }
+    else {
+        tXx = linePoints[0].x + tParam * tC;
+        tYy = linePoints[0].y + tParam * tD;
+    }
+    return { x: tXx, y: tYy };
+}
+/**
+ * 点到线段的距离，
+ * 如果可以是过直线垂线的垂足的距离，不行的话取线段的两端的距离
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {number}
+ */
+export function pointDistanceFromLine(point, linePoints) {
+    const closestPoint = closestPointOnLine(point, linePoints);
+    return distance(point, closestPoint);
+}
+/**
+ * 做线段的距离一定值的平行线段
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @return {[linePoints, linePoints]}
+ */
+export function linesWithDistanceOfLine(distanceOfLine, linePoints) {
+    const k = getK(linePoints[1], linePoints[0]);
+    let dx, dy;
+    if (Math.abs(k) === Infinity) {
+        dy = 0;
+        dx = distanceOfLine;
+    }
+    else {
+        dy = Math.sqrt((distanceOfLine * distanceOfLine) / (k * k + 1));
+        dx = dy / -(1 / k);
+    }
+    const result = [
+        [
+            { x: linePoints[0].x - dx, y: linePoints[0].y - dy },
+            { x: linePoints[1].x - dx, y: linePoints[1].y - dy },
+        ],
+        [
+            { x: linePoints[0].x + dx, y: linePoints[0].y + dy },
+            { x: linePoints[1].x + dx, y: linePoints[1].y + dy },
+        ],
+    ];
+    if (linePoints[1].x - linePoints[0].x < 0) {
+        return result;
+    }
+    else if (linePoints[1].x - linePoints[0].x > 0) {
+        return result.reverse();
+    }
+    else {
+        if (linePoints[1].y - linePoints[0].y < 0) {
+            return result.reverse();
+        }
+        else {
+            return result;
+        }
+    }
+}
+/**
+ * 做线段的距离一定值的平行线段 (如果线段是弧形的)
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @param  {number} 弧形定点到线段的距离
+ * @return {[linePoints, linePoints]}
+ */
+export function linesWithDistanceOfLineWithCurve(distanceOfLine, linePoints, curve) {
+    const centerPoint = getCenterPointOfPoints(linePoints);
+    const pHelfDistance = distance(linePoints[0], centerPoint);
+    const cDistance = Math.sqrt(curve * curve - pHelfDistance * pHelfDistance);
+    const cpoint = isNaN(cDistance)
+        ? centerPoint
+        : linesWithDistanceOfLine(cDistance, [centerPoint, linePoints[0]])[curve > 0 ? 0 : 1][0];
+    const dx1 = ((linePoints[0].x - cpoint.x) / curve) * distanceOfLine;
+    const dy1 = ((linePoints[0].y - cpoint.y) / curve) * distanceOfLine;
+    const dx2 = ((linePoints[1].x - cpoint.x) / curve) * distanceOfLine;
+    const dy2 = ((linePoints[1].y - cpoint.y) / curve) * distanceOfLine;
+    return [
+        [
+            { x: linePoints[0].x - dx1, y: linePoints[0].y - dy1 },
+            { x: linePoints[1].x - dx2, y: linePoints[1].y - dy2 },
+        ],
+        [
+            { x: linePoints[0].x + dx1, y: linePoints[0].y + dy1 },
+            { x: linePoints[1].x + dx2, y: linePoints[1].y + dy2 },
+        ],
+    ];
+}
+/**
+ * 两条线段(包括延长线)的交点点
+ * @param  {linePoints} linePoints1
+ * @param  {linePoints} linePoints2
+ * @param   needIntersectionInLine 是否是延长线的相交
+ * @return {point || false}
+ */
+export function intersectionOfLine(linePoints1, linePoints2, needIntersectionInLine) {
+    const k1 = getK(linePoints1[1], linePoints1[0]);
+    const k2 = getK(linePoints2[1], linePoints2[0]);
+    if (isNaN(k1) || isNaN(k2))
+        return false;
+    if (sameK(k1, k2))
+        return false;
+    if (pointOnLine(linePoints1[0], linePoints2))
+        return linePoints1[0];
+    if (pointOnLine(linePoints1[1], linePoints2))
+        return linePoints1[1];
+    if (pointOnLine(linePoints2[0], linePoints1))
+        return linePoints2[0];
+    if (pointOnLine(linePoints2[1], linePoints1))
+        return linePoints2[1];
+    //needIntersectionInLine 是否焦点在线段内
+    if (needIntersectionInLine && !isIntersect(linePoints1, linePoints2))
+        return false;
+    const p1 = linePoints1[0];
+    const p2 = linePoints2[0];
+    if (Math.abs(k1) === Infinity) {
+        return { x: p1.x, y: linePoints2[1].y - (linePoints2[1].x - p1.x) * k2 };
+    }
+    if (Math.abs(k2) === Infinity) {
+        return { x: p2.x, y: linePoints1[1].y - (linePoints1[1].x - p2.x) * k1 };
+    }
+    const x = (p2.y - p1.y + k1 * p1.x - k2 * p2.x) / (k1 - k2);
+    const y = k1 * x - k1 * p1.x + p1.y;
+    return { x, y };
+}
+/**
+ * 是否点在线段上
+ * @param  {point} point
+ * @param  {linePoints} linePoints
+ * @return
+ */
+export function pointOnLine(point, linePoints) {
+    if (samePointAt(point, linePoints[0]))
+        return true;
+    if (samePointAt(point, linePoints[1]))
+        return true;
+    return (true &&
+        (linePoints[0].x - point.x) * (point.x - linePoints[1].x) >= 0 &&
+        (linePoints[0].y - point.y) * (point.y - linePoints[1].y) >= 0 &&
+        sameK(getK(linePoints[0], point), getK(point, linePoints[1])));
+}
+/**
+ * 让点按照另一个点为圆心，一定弧度的情况下转动得到下一个点
+ * @param  {point} point
+ * @param  {point} centerPoint
+ * @param  {number} rad
+ * @return {point}
+ */
+export function pointRotateByCenterPoint(point, centerPoint, rad) {
+    const r = distance(point, centerPoint);
+    let nextRad = Math.atan2(point.y - centerPoint.y, point.x - centerPoint.x);
+    nextRad -= rad;
+    return {
+        x: centerPoint.x + Math.cos(nextRad) * r,
+        y: centerPoint.y + Math.sin(nextRad) * r,
+    };
+}
+/**
+ * 获取一些点的中心点
+ * @param  {points} point
+ * @return {point}
+ */
+export function getCenterPointOfPoints(points) {
+    let minX = Infinity, maxX = 0, minY = Infinity, maxY = 0;
+    points.forEach((point) => {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    });
+    return { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+}
+/**
+ *  判断两条线段是否相交
+ */
+function multi(p1, p2, p0) {
+    return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
+}
+export function isIntersect(linePoints1, linePoints2) {
+    if (Math.max(linePoints1[0].x, linePoints1[1].x) >= Math.min(linePoints2[0].x, linePoints2[1].x) &&
+        Math.max(linePoints2[0].x, linePoints2[1].x) >= Math.min(linePoints1[0].x, linePoints1[1].x) &&
+        Math.max(linePoints1[0].y, linePoints1[1].y) >= Math.min(linePoints2[0].y, linePoints2[1].y) &&
+        multi(linePoints2[0], linePoints1[1], linePoints1[0]) * multi(linePoints1[1], linePoints2[1], linePoints1[0]) > 0 &&
+        multi(linePoints1[0], linePoints2[1], linePoints2[0]) * multi(linePoints2[1], linePoints1[1], linePoints2[0]) > 0)
+        return 1;
+    return 0;
+}
+/**
+ * 计算点按序围成区域的面就
+ * @param  {[point]} points
+ * @return {number}
+ */
+function cross(p1, p2) {
+    // 向量叉积
+    return p1.x * p2.y - p1.y * p2.x;
+}
+export function getAreaSize(points) {
+    let ret = 0;
+    return ((cross(points.reduce((pf, pn) => {
+        ret += cross(pf, pn);
+        return pn;
+    }), points[0]) +
+        ret) /
+        2);
+}
+export function getAreaSizeWithoutLine(points) {
+    let ret = 0;
+    const r = (cross(points.reduce((pf, pn) => {
+        ret += cross(pf, pn);
+        return pn;
+    }), points[0]) +
+        ret) /
+        2;
+    let wall = 0;
+    const wr = (distance(points.reduce((pf, pn) => {
+        wall += distance(pf, pn) * 250;
+        return pn;
+    }), points[0]) *
+        250 +
+        wall) /
+        2;
+    return r - (wr - 250 * 1000) * (r > 0 ? 1 : -1);
+}

package/libs/src/shared-utils/math/rad2Deg.d.ts

@@ -0,0 +1 @@
+export default function rad2Deg(rad: number): number;

package/libs/src/shared-utils/math/rad2Deg.js

@@ -0,0 +1,3 @@
+export default function rad2Deg(rad) {
+    return (rad * 180) / Math.PI;
+}

package/libs/src/shared-utils/nearlyEqual.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 比较两个数字近似相等
+ * @param num1 数字1
+ * @param num2 数字2
+ * @param accuracy 精度：精确到小数点后几位，默认精确到 小数点后四位
+ */
+export default function nearlyEqual(num1: number, num2: number, accuracy?: number): boolean;

package/libs/src/shared-utils/nearlyEqual.js

@@ -0,0 +1,9 @@
+/**
+ * 比较两个数字近似相等
+ * @param num1 数字1
+ * @param num2 数字2
+ * @param accuracy 精度：精确到小数点后几位，默认精确到 小数点后四位
+ */
+export default function nearlyEqual(num1, num2, accuracy = 4) {
+    return Math.floor(num1 * Math.pow(10, accuracy)) === Math.floor(num2 * Math.pow(10, accuracy));
+}

package/libs/src/shared-utils/nextFrame.d.ts

@@ -0,0 +1 @@
+export declare function nextFrame(fn: () => void, delay?: number): void;

package/libs/src/shared-utils/nextFrame.js

@@ -0,0 +1,6 @@
+export function nextFrame(fn, delay = 0) {
+    if (delay <= 0)
+        requestAnimationFrame(fn);
+    else
+        requestAnimationFrame(() => nextFrame(fn, delay - 1));
+}

package/libs/src/shared-utils/noop.d.ts

@@ -0,0 +1,5 @@
+declare function noop(): void;
+/**
+ * 空函数
+ */
+export default noop;

package/libs/src/shared-utils/noop.js

@@ -0,0 +1,7 @@
+function noop() {
+    return void 0;
+}
+/**
+ * 空函数
+ */
+export default noop;

package/libs/src/shared-utils/object3d2LocalMatrix.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+export declare const genRotationMatrix: (x: number, y: number, z: number) => THREE.Matrix4;
+declare const bject3d2LocalMatrix: (mesh: THREE.Object3D, { scale, rotation, position, }: {
+    scale: number;
+    rotation: number[];
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}) => THREE.Object3D;
+export default bject3d2LocalMatrix;

package/libs/src/shared-utils/object3d2LocalMatrix.js

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+export const genRotationMatrix = (x, y, z) => {
+    const matrix = new THREE.Matrix4();
+    const euler = new THREE.Euler(x, y, z, 'YXZ');
+    matrix.makeRotationFromEuler(euler);
+    return matrix;
+};
+const bject3d2LocalMatrix = (mesh, { scale, rotation, position, }) => {
+    if (scale) {
+        mesh.scale.set(scale, scale, scale);
+    }
+    if (rotation) {
+        const [x, y, z] = rotation;
+        if (x) {
+            mesh.applyMatrix4(genRotationMatrix(x, 0, 0));
+        }
+        if (y) {
+            mesh.applyMatrix4(genRotationMatrix(0, y, 0));
+        }
+        if (z) {
+            mesh.applyMatrix4(genRotationMatrix(0, 0, z));
+        }
+    }
+    if (position) {
+        mesh.position.set(position.x, position.y, position.z);
+    }
+    return mesh;
+};
+export default bject3d2LocalMatrix;

package/libs/src/shared-utils/px2rem.d.ts

@@ -0,0 +1 @@
+export default function px2rem(_px: number | string, precision?: number): string;

package/libs/src/shared-utils/px2rem.js

@@ -0,0 +1,4 @@
+export default function px2rem(_px, precision = 16) {
+    const px = Number(typeof _px === 'string' ? _px.replace(/px/g, '') : _px);
+    return (px / precision).toFixed(5) + 'rem';
+}

package/libs/src/shared-utils/removeArrayItem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 从数组中删除
+ * @param   item
+ * @param   array
+ * @return  如果删除返回 item
+ */
+export default function removeArrayItem<T>(item: T, array: T[]): T;

package/libs/src/shared-utils/removeArrayItem.js

@@ -0,0 +1,12 @@
+/**
+ * 从数组中删除
+ * @param   item
+ * @param   array
+ * @return  如果删除返回 item
+ */
+export default function removeArrayItem(item, array) {
+    for (let index = 0, len = array.length; index < len; index++) {
+        if (item === array[index])
+            return array.splice(index, 1)[0];
+    }
+}

package/libs/src/shared-utils/tap.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 把第一个参数传入第二个参数（函数）中并执行
+ * 一般用于执行函数后返回变量。
+ * @param {any} something
+ * @param {function} callback
+ * @return {any}
+ */
+export default function tap<T>(something: T, callback: (p: T) => any): T;

package/libs/src/shared-utils/tap.js

@@ -0,0 +1,12 @@
+/**
+ * 把第一个参数传入第二个参数（函数）中并执行
+ * 一般用于执行函数后返回变量。
+ * @param {any} something
+ * @param {function} callback
+ * @return {any}
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function tap(something, callback) {
+    callback(something);
+    return something;
+}

package/libs/src/shared-utils/three/centerPoint.d.ts

@@ -0,0 +1,2 @@
+import { Vector3 } from 'three';
+export default function centerPoint(point1: Vector3, point2: Vector3): Vector3;

package/libs/src/shared-utils/three/centerPoint.js

@@ -0,0 +1,4 @@
+import { Vector3 } from 'three';
+export default function centerPoint(point1, point2) {
+    return new Vector3((point1.x + point2.x) / 2, (point1.y + point2.y) / 2, (point1.z + point2.z) / 2);
+}

package/libs/src/shared-utils/three/getExtraModelLoader.d.ts

@@ -0,0 +1,6 @@
+import type * as THREE from 'three';
+/** 模型资源加载器，用于满足资源共用 */
+export declare function getExtraModelLoader(): {
+    load: (url: string, type?: string) => Promise<THREE.Group>;
+    dispose: () => void;
+};

package/libs/src/shared-utils/three/getExtraModelLoader.js

@@ -0,0 +1,18 @@
+import { loadFbxObj } from './loadFbxObj';
+/** 模型资源加载器，用于满足资源共用 */
+export function getExtraModelLoader() {
+    const cache = new Map();
+    const load = function (url, type = 'FBX') {
+        if (type !== 'FBX')
+            return Promise.reject(new Error('不支持的类型'));
+        if (cache.has(url))
+            return cache.get(url);
+        const groupPromise = loadFbxObj(url);
+        cache.set(url, groupPromise);
+        return groupPromise;
+    };
+    const dispose = function () {
+        cache.clear();
+    };
+    return { load, dispose };
+}

package/libs/src/shared-utils/three/getNormal.d.ts

@@ -0,0 +1,2 @@
+import type { Vector3 } from 'three';
+export default function getNormal(a: Vector3, b: Vector3, c: Vector3): Vector3;

package/libs/src/shared-utils/three/getNormal.js

@@ -0,0 +1,6 @@
+export default function getNormal(a, b, c) {
+    const ab = b.clone().sub(a);
+    const ac = c.clone().sub(a);
+    const normal = ab.clone().cross(ac);
+    return normal;
+}

package/libs/src/shared-utils/three/getTextureLoader.d.ts

@@ -0,0 +1,6 @@
+import type * as THREE from 'three';
+/** 贴图加载器，用于满足资源共用 */
+export declare function getTextureLoader(): {
+    load: (url: string) => Promise<THREE.Texture>;
+    dispose: () => void;
+};

package/libs/src/shared-utils/three/getTextureLoader.js

@@ -0,0 +1,17 @@
+import { loadTexture } from './loadTexture';
+/** 贴图加载器，用于满足资源共用 */
+export function getTextureLoader() {
+    const cache = new Map();
+    const load = function (url) {
+        if (cache.has(url))
+            return cache.get(url);
+        const texturePromise = loadTexture(url);
+        cache.set(url, texturePromise);
+        return texturePromise;
+    };
+    const dispose = function () {
+        cache.forEach((texturePromise) => texturePromise.then((texture) => texture.dispose()));
+        cache.clear();
+    };
+    return { load, dispose };
+}

package/libs/src/shared-utils/three/loadFbxObj.d.ts

@@ -0,0 +1,2 @@
+import type { Group } from 'three';
+export declare function loadFbxObj(url: string): Promise<Group>;

package/libs/src/shared-utils/three/loadFbxObj.js

@@ -0,0 +1,13 @@
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader';
+const loader = new FBXLoader();
+export async function loadFbxObj(url) {
+    return new Promise((resolve, reject) => {
+        function onLoad(object) {
+            resolve(object);
+        }
+        function onError(error) {
+            reject(error);
+        }
+        loader.load(url, onLoad, undefined, onError);
+    });
+}

package/libs/src/shared-utils/three/loadTexture.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export declare function loadTexture(url: string): Promise<THREE.Texture>;

package/libs/src/shared-utils/three/loadTexture.js

@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+const textureLoader = new THREE.TextureLoader();
+export async function loadTexture(url) {
+    return new Promise((resolve, reject) => {
+        textureLoader.load(url, resolve, undefined, reject);
+    }).then((texture) => {
+        texture.encoding = THREE.sRGBEncoding;
+        return texture;
+    });
+}

package/libs/src/shared-utils/three/transformPositionToVector3.d.ts

@@ -0,0 +1,7 @@
+import { Vector3 } from 'three';
+declare const transformPositionToVector3: ({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}) => Vector3;
+export default transformPositionToVector3;

package/libs/src/shared-utils/three/transformPositionToVector3.js

@@ -0,0 +1,3 @@
+import { Vector3 } from 'three';
+const transformPositionToVector3 = ({ x, y, z }) => new Vector3(x, y, z);
+export default transformPositionToVector3;

package/libs/src/shared-utils/three/transfromToMeshBasicMaterial.d.ts

@@ -0,0 +1,2 @@
+import { MeshBasicMaterialParameters, Object3D } from 'three';
+export default function transfromToMeshBasicMaterial(object: Object3D, options?: MeshBasicMaterialParameters): void;

package/libs/src/shared-utils/three/transfromToMeshBasicMaterial.js

@@ -0,0 +1,15 @@
+import { MeshBasicMaterial } from 'three';
+export default function transfromToMeshBasicMaterial(object, options) {
+    object.traverse((ele) => {
+        var _a;
+        if (ele.type === 'Mesh') {
+            const mesh = ele;
+            const materialConf = Object.assign({ map: mesh.material.map || {} }, options);
+            mesh.material = new MeshBasicMaterial(materialConf);
+            mesh.renderOrder = 1;
+            if (((_a = ele.parent) === null || _a === void 0 ? void 0 : _a.type) === 'Mesh') {
+                ele.renderOrder = ele.parent.renderOrder + 1;
+            }
+        }
+    });
+}

package/libs/src/shared-utils/throttle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 创建一个防抖动函数，该函数在高频调用时会每隔 wait 毫秒后调用 func 方法
+ * `throttle` 会在第一次调用时立刻调用一次
+ * @param func - 要防抖动的函数
+ * @param wait - 需要延迟的毫秒数
+ */
+export default function throttle<T extends (...args: any[]) => any>(func: T, wait?: number): (...args: Parameters<T>) => void;

package/libs/src/shared-utils/throttle.js

@@ -0,0 +1,18 @@
+/**
+ * 创建一个防抖动函数，该函数在高频调用时会每隔 wait 毫秒后调用 func 方法
+ * `throttle` 会在第一次调用时立刻调用一次
+ * @param func - 要防抖动的函数
+ * @param wait - 需要延迟的毫秒数
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function throttle(func, wait = 200) {
+    let last;
+    return function (...args) {
+        if (last)
+            return;
+        func(...args);
+        last = setTimeout(function () {
+            last = null;
+        }, wait);
+    };
+}

package/libs/src/shared-utils/tinyEJSrender.d.ts

@@ -0,0 +1,5 @@
+interface RenderData {
+    [key: string]: string;
+}
+export default function render(template: string, data: RenderData): string;
+export {};