bpmatrixjs 0.0.1

package/lib/Geometry/Rect.d.ts

@@ -0,0 +1,32 @@
+interface RectGeometryData {
+    geometry: Float32Array;
+    uv: Float32Array;
+    width: number;
+    height: number;
+    radius: number;
+}
+/**
+ * 数值钳制
+ * @param value 当前值
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 钳制结果
+ */
+/**
+ * 生成矩形几何
+ * 以(0, 0)为中心
+ * 圆角半径会自动限制到半宽半高的较小值
+ * @param width 宽度
+ * @param height 高度
+ * @param radius 圆角半径
+ * @returns 几何数据
+ */
+declare const CreateRectGeometry: (width: number, height: number, radius?: number) => RectGeometryData;
+/**
+ * 矩形几何工具
+ */
+declare const Rect: {
+    CreateGeometry: (width: number, height: number, radius?: number) => RectGeometryData;
+};
+export { CreateRectGeometry, Rect };
+export type { RectGeometryData };

package/lib/Geometry/Rect.js

@@ -0,0 +1,134 @@
+import { Clamp } from "../Utils/index.js";
+/**
+ * 生成矩形边界点
+ * @param halfWidth 半宽
+ * @param halfHeight 半高
+ * @param radius 圆角半径
+ * @returns 边界点列表
+ */
+const CreatePerimeterPoints = (halfWidth, halfHeight, radius) => {
+    if (halfWidth === 0 || halfHeight === 0) {
+        return [];
+    }
+    if (radius === 0) {
+        return [
+            [halfWidth, halfHeight],
+            [halfWidth, -halfHeight],
+            [-halfWidth, -halfHeight],
+            [-halfWidth, halfHeight],
+        ];
+    }
+    const segments = GetCornerSegments(radius);
+    const points = [];
+    PushArc(points, halfWidth - radius, halfHeight - radius, radius, Math.PI * 0.5, 0, segments, true);
+    PushArc(points, halfWidth - radius, -halfHeight + radius, radius, 0, -Math.PI * 0.5, segments, false);
+    PushArc(points, -halfWidth + radius, -halfHeight + radius, radius, -Math.PI * 0.5, -Math.PI, segments, false);
+    PushArc(points, -halfWidth + radius, halfHeight - radius, radius, Math.PI, Math.PI * 0.5, segments, false);
+    return points;
+};
+/**
+ * 添加圆角圆弧点
+ * @param points 点数组
+ * @param centerX 圆心X
+ * @param centerY 圆心Y
+ * @param radius 圆角半径
+ * @param startAngle 起始弧度
+ * @param endAngle 结束弧度
+ * @param segments 分段数
+ * @param includeStart 是否包含起始点
+ * @returns 无返回值
+ */
+const PushArc = (points, centerX, centerY, radius, startAngle, endAngle, segments, includeStart) => {
+    const startIndex = includeStart ? 0 : 1;
+    for (let index = startIndex; index <= segments; index += 1) {
+        const t = index / segments;
+        const angle = startAngle + (endAngle - startAngle) * t;
+        const x = centerX + Math.cos(angle) * radius;
+        const y = centerY + Math.sin(angle) * radius;
+        points.push([x, y]);
+    }
+};
+/**
+ * 生成位置缓冲
+ * @param points 边界点列表
+ * @returns 位置缓冲
+ */
+const CreateGeometryBuffer = (points) => {
+    if (points.length < 3) {
+        return new Float32Array(0);
+    }
+    const geometry = [];
+    for (let index = 0; index < points.length; index += 1) {
+        const current = points[index];
+        const next = points[(index + 1) % points.length];
+        geometry.push(0, 0, current[0], current[1], next[0], next[1]);
+    }
+    return new Float32Array(geometry);
+};
+/**
+ * 生成UV缓冲
+ * @param points 边界点列表
+ * @param width 宽度
+ * @param height 高度
+ * @returns UV缓冲
+ */
+const CreateUvBuffer = (points, width, height) => {
+    if (points.length < 3 || width === 0 || height === 0) {
+        return new Float32Array(0);
+    }
+    const uv = [];
+    const halfWidth = width * 0.5;
+    const halfHeight = height * 0.5;
+    for (let index = 0; index < points.length; index += 1) {
+        const current = points[index];
+        const next = points[(index + 1) % points.length];
+        uv.push(0.5, 0.5, (current[0] + halfWidth) / width, (current[1] + halfHeight) / height, (next[0] + halfWidth) / width, (next[1] + halfHeight) / height);
+    }
+    return new Float32Array(uv);
+};
+/**
+ * 计算圆角分段数
+ * @param radius 圆角半径
+ * @returns 分段数
+ */
+const GetCornerSegments = (radius) => {
+    return Math.max(2, Math.ceil(radius / 8));
+};
+/**
+ * 数值钳制
+ * @param value 当前值
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 钳制结果
+ */
+/**
+ * 生成矩形几何
+ * 以(0, 0)为中心
+ * 圆角半径会自动限制到半宽半高的较小值
+ * @param width 宽度
+ * @param height 高度
+ * @param radius 圆角半径
+ * @returns 几何数据
+ */
+const CreateRectGeometry = (width, height, radius = 0) => {
+    const safeWidth = Math.max(0, width);
+    const safeHeight = Math.max(0, height);
+    const halfWidth = safeWidth * 0.5;
+    const halfHeight = safeHeight * 0.5;
+    const safeRadius = Clamp(radius, 0, Math.min(halfWidth, halfHeight));
+    const points = CreatePerimeterPoints(halfWidth, halfHeight, safeRadius);
+    return {
+        geometry: CreateGeometryBuffer(points),
+        uv: CreateUvBuffer(points, safeWidth, safeHeight),
+        width: safeWidth,
+        height: safeHeight,
+        radius: safeRadius,
+    };
+};
+/**
+ * 矩形几何工具
+ */
+const Rect = {
+    CreateGeometry: CreateRectGeometry,
+};
+export { CreateRectGeometry, Rect };

package/lib/Geometry/index.d.ts

@@ -0,0 +1 @@
+export { CreateRectGeometry, Rect, type RectGeometryData } from "./Rect.js";

package/lib/Geometry/index.js

@@ -0,0 +1 @@
+export { CreateRectGeometry, Rect } from "./Rect.js";

package/lib/Math/Mat3.d.ts

@@ -0,0 +1,130 @@
+import { type Vec2Like } from "./Vec2.js";
+type Mat3Data = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+interface Mat3Like {
+    data: Mat3Data;
+}
+/**
+ * 3x3矩阵
+ * @class
+ * @implements Mat3Like
+ * @example
+ * ```ts
+ * const mat3 = new Mat3([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+ * ```
+ */
+declare class Matrix3 implements Mat3Like {
+    /**
+     * 矩阵数组
+     * 采用列主序:
+     * [m00, m10, m20, m01, m11, m21, m02, m12, m22]
+     */
+    data: Mat3Data;
+    /**
+     * 创建3x3矩阵
+     * @param data 矩阵数组
+     */
+    constructor(data?: Readonly<Mat3Data>);
+    /**
+     * 设置为单位矩阵
+     * @returns 当前矩阵
+     */
+    identity(): this;
+    /**
+     * 设置矩阵数组
+     * @param data 矩阵数组
+     * @returns 当前矩阵
+     */
+    set(data: Readonly<Mat3Data>): this;
+    /**
+     * 设置平移分量
+     * @param vec2 平移向量
+     * @returns 当前矩阵
+     */
+    setTranslate(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 设置缩放分量
+     * @param vec2 缩放向量
+     * @returns 当前矩阵
+     */
+    setScale(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 设置旋转分量
+     * @param angle 弧度
+     * @returns 当前矩阵
+     */
+    setRotation(angle: number): this;
+    /**
+     * 获取平移分量
+     * @param vec2 输出向量
+     * @returns 输出向量
+     */
+    getTranslate(vec2?: Vec2Like): Vec2Like;
+    /**
+     * 获取缩放分量
+     * @param vec2 输出向量
+     * @returns 输出向量
+     */
+    getScale(vec2?: Vec2Like): Vec2Like;
+    /**
+     * 获取旋转弧度
+     * @returns 旋转弧度
+     */
+    getRotation(): number;
+    /**
+     * 矩阵乘法
+     * 传入标量时执行标量乘法
+     * 传入一个矩阵时执行当前矩阵右乘目标矩阵
+     * 传入两个矩阵时执行 a * b 并写回当前矩阵
+     * @param value 标量或矩阵a
+     * @param mat3 矩阵b
+     * @returns 当前矩阵
+     */
+    mul(value: number | Readonly<Mat3Like>, mat3?: Readonly<Mat3Like>): this;
+    /**
+     * 转置矩阵
+     * @returns 当前矩阵
+     */
+    transpose(): this;
+    /**
+     * 求矩阵行列式
+     * @returns 行列式
+     */
+    det(): number;
+    /**
+     * 求逆矩阵
+     * 不可逆时保持原矩阵不变
+     * @returns 当前矩阵
+     */
+    invert(): this;
+    /**
+     * 复制目标矩阵
+     * @param mat3 目标矩阵
+     * @returns 当前矩阵
+     */
+    copy(mat3: Readonly<Mat3Like>): this;
+    /**
+     * 克隆矩阵
+     * @returns 新的矩阵实例
+     */
+    clone(): Matrix3;
+    /**
+     * 判断矩阵是否完全相等
+     * @param mat3 目标矩阵
+     * @returns 是否相等
+     */
+    equals(mat3: Readonly<Mat3Like>): boolean;
+    private multiplyData;
+}
+declare const Mat3: typeof Matrix3;
+export { Mat3, Matrix3 };
+export type { Mat3Data, Mat3Like };

package/lib/Math/Mat3.js

@@ -0,0 +1,294 @@
+import { Vec2 } from "./Vec2.js";
+/**
+ * 3x3矩阵
+ * @class
+ * @implements Mat3Like
+ * @example
+ * ```ts
+ * const mat3 = new Mat3([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+ * ```
+ */
+class Matrix3 {
+    /**
+     * 矩阵数组
+     * 采用列主序:
+     * [m00, m10, m20, m01, m11, m21, m02, m12, m22]
+     */
+    data;
+    /**
+     * 创建3x3矩阵
+     * @param data 矩阵数组
+     */
+    constructor(data) {
+        this.data = CreateIdentityData();
+        if (data !== undefined) {
+            this.set(data);
+        }
+    }
+    /**
+     * 设置为单位矩阵
+     * @returns 当前矩阵
+     */
+    identity() {
+        this.data[0] = 1;
+        this.data[1] = 0;
+        this.data[2] = 0;
+        this.data[3] = 0;
+        this.data[4] = 1;
+        this.data[5] = 0;
+        this.data[6] = 0;
+        this.data[7] = 0;
+        this.data[8] = 1;
+        return this;
+    }
+    /**
+     * 设置矩阵数组
+     * @param data 矩阵数组
+     * @returns 当前矩阵
+     */
+    set(data) {
+        this.data[0] = data[0];
+        this.data[1] = data[1];
+        this.data[2] = data[2];
+        this.data[3] = data[3];
+        this.data[4] = data[4];
+        this.data[5] = data[5];
+        this.data[6] = data[6];
+        this.data[7] = data[7];
+        this.data[8] = data[8];
+        return this;
+    }
+    /**
+     * 设置平移分量
+     * @param vec2 平移向量
+     * @returns 当前矩阵
+     */
+    setTranslate(vec2) {
+        this.data[6] = vec2.x;
+        this.data[7] = vec2.y;
+        return this;
+    }
+    /**
+     * 设置缩放分量
+     * @param vec2 缩放向量
+     * @returns 当前矩阵
+     */
+    setScale(vec2) {
+        const rotation = this.getRotation();
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        this.data[0] = cos * vec2.x;
+        this.data[1] = sin * vec2.x;
+        this.data[3] = -sin * vec2.y;
+        this.data[4] = cos * vec2.y;
+        return this;
+    }
+    /**
+     * 设置旋转分量
+     * @param angle 弧度
+     * @returns 当前矩阵
+     */
+    setRotation(angle) {
+        const scale = this.getScale();
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        this.data[0] = cos * scale.x;
+        this.data[1] = sin * scale.x;
+        this.data[3] = -sin * scale.y;
+        this.data[4] = cos * scale.y;
+        return this;
+    }
+    /**
+     * 获取平移分量
+     * @param vec2 输出向量
+     * @returns 输出向量
+     */
+    getTranslate(vec2 = new Vec2()) {
+        vec2.x = this.data[6];
+        vec2.y = this.data[7];
+        return vec2;
+    }
+    /**
+     * 获取缩放分量
+     * @param vec2 输出向量
+     * @returns 输出向量
+     */
+    getScale(vec2 = new Vec2()) {
+        vec2.x = Math.hypot(this.data[0], this.data[1]);
+        vec2.y = Math.hypot(this.data[3], this.data[4]);
+        return vec2;
+    }
+    /**
+     * 获取旋转弧度
+     * @returns 旋转弧度
+     */
+    getRotation() {
+        return Math.atan2(this.data[1], this.data[0]);
+    }
+    /**
+     * 矩阵乘法
+     * 传入标量时执行标量乘法
+     * 传入一个矩阵时执行当前矩阵右乘目标矩阵
+     * 传入两个矩阵时执行 a * b 并写回当前矩阵
+     * @param value 标量或矩阵a
+     * @param mat3 矩阵b
+     * @returns 当前矩阵
+     */
+    mul(value, mat3) {
+        if (typeof value === "number") {
+            this.data[0] *= value;
+            this.data[1] *= value;
+            this.data[2] *= value;
+            this.data[3] *= value;
+            this.data[4] *= value;
+            this.data[5] *= value;
+            this.data[6] *= value;
+            this.data[7] *= value;
+            this.data[8] *= value;
+            return this;
+        }
+        const left = mat3 === undefined ? this.data : value.data;
+        const right = mat3 === undefined ? value.data : mat3.data;
+        return this.multiplyData(left, right);
+    }
+    /**
+     * 转置矩阵
+     * @returns 当前矩阵
+     */
+    transpose() {
+        const m01 = this.data[3];
+        const m02 = this.data[6];
+        const m12 = this.data[7];
+        this.data[3] = this.data[1];
+        this.data[6] = this.data[2];
+        this.data[7] = this.data[5];
+        this.data[1] = m01;
+        this.data[2] = m02;
+        this.data[5] = m12;
+        return this;
+    }
+    /**
+     * 求矩阵行列式
+     * @returns 行列式
+     */
+    det() {
+        const a00 = this.data[0];
+        const a10 = this.data[1];
+        const a20 = this.data[2];
+        const a01 = this.data[3];
+        const a11 = this.data[4];
+        const a21 = this.data[5];
+        const a02 = this.data[6];
+        const a12 = this.data[7];
+        const a22 = this.data[8];
+        return a00 * (a11 * a22 - a21 * a12)
+            - a01 * (a10 * a22 - a20 * a12)
+            + a02 * (a10 * a21 - a20 * a11);
+    }
+    /**
+     * 求逆矩阵
+     * 不可逆时保持原矩阵不变
+     * @returns 当前矩阵
+     */
+    invert() {
+        const a00 = this.data[0];
+        const a10 = this.data[1];
+        const a20 = this.data[2];
+        const a01 = this.data[3];
+        const a11 = this.data[4];
+        const a21 = this.data[5];
+        const a02 = this.data[6];
+        const a12 = this.data[7];
+        const a22 = this.data[8];
+        const b00 = a11 * a22 - a21 * a12;
+        const b01 = -(a10 * a22 - a20 * a12);
+        const b02 = a10 * a21 - a20 * a11;
+        const b10 = -(a01 * a22 - a21 * a02);
+        const b11 = a00 * a22 - a20 * a02;
+        const b12 = -(a00 * a21 - a20 * a01);
+        const b20 = a01 * a12 - a11 * a02;
+        const b21 = -(a00 * a12 - a10 * a02);
+        const b22 = a00 * a11 - a10 * a01;
+        const determinant = a00 * b00 + a01 * b01 + a02 * b02;
+        if (determinant === 0) {
+            return this;
+        }
+        const inverseDeterminant = 1 / determinant;
+        this.data[0] = b00 * inverseDeterminant;
+        this.data[1] = b01 * inverseDeterminant;
+        this.data[2] = b02 * inverseDeterminant;
+        this.data[3] = b10 * inverseDeterminant;
+        this.data[4] = b11 * inverseDeterminant;
+        this.data[5] = b12 * inverseDeterminant;
+        this.data[6] = b20 * inverseDeterminant;
+        this.data[7] = b21 * inverseDeterminant;
+        this.data[8] = b22 * inverseDeterminant;
+        return this;
+    }
+    /**
+     * 复制目标矩阵
+     * @param mat3 目标矩阵
+     * @returns 当前矩阵
+     */
+    copy(mat3) {
+        return this.set(mat3.data);
+    }
+    /**
+     * 克隆矩阵
+     * @returns 新的矩阵实例
+     */
+    clone() {
+        return new Matrix3(this.data);
+    }
+    /**
+     * 判断矩阵是否完全相等
+     * @param mat3 目标矩阵
+     * @returns 是否相等
+     */
+    equals(mat3) {
+        return this.data[0] === mat3.data[0]
+            && this.data[1] === mat3.data[1]
+            && this.data[2] === mat3.data[2]
+            && this.data[3] === mat3.data[3]
+            && this.data[4] === mat3.data[4]
+            && this.data[5] === mat3.data[5]
+            && this.data[6] === mat3.data[6]
+            && this.data[7] === mat3.data[7]
+            && this.data[8] === mat3.data[8];
+    }
+    multiplyData(left, right) {
+        const a00 = left[0];
+        const a10 = left[1];
+        const a20 = left[2];
+        const a01 = left[3];
+        const a11 = left[4];
+        const a21 = left[5];
+        const a02 = left[6];
+        const a12 = left[7];
+        const a22 = left[8];
+        const b00 = right[0];
+        const b10 = right[1];
+        const b20 = right[2];
+        const b01 = right[3];
+        const b11 = right[4];
+        const b21 = right[5];
+        const b02 = right[6];
+        const b12 = right[7];
+        const b22 = right[8];
+        this.data[0] = a00 * b00 + a01 * b10 + a02 * b20;
+        this.data[1] = a10 * b00 + a11 * b10 + a12 * b20;
+        this.data[2] = a20 * b00 + a21 * b10 + a22 * b20;
+        this.data[3] = a00 * b01 + a01 * b11 + a02 * b21;
+        this.data[4] = a10 * b01 + a11 * b11 + a12 * b21;
+        this.data[5] = a20 * b01 + a21 * b11 + a22 * b21;
+        this.data[6] = a00 * b02 + a01 * b12 + a02 * b22;
+        this.data[7] = a10 * b02 + a11 * b12 + a12 * b22;
+        this.data[8] = a20 * b02 + a21 * b12 + a22 * b22;
+        return this;
+    }
+}
+const CreateIdentityData = () => {
+    return [1, 0, 0, 0, 1, 0, 0, 0, 1];
+};
+const Mat3 = Matrix3;
+export { Mat3, Matrix3 };

package/lib/Math/Vec2.d.ts

@@ -0,0 +1,171 @@
+import type { Mat3Like } from "./Mat3.js";
+interface Vec2Like {
+    x: number;
+    y: number;
+}
+/**
+ * 2D向量
+ * @class
+ * @implements Vec2Like
+ * @description 2D向量类
+ * @example
+ * ```ts
+ * const vec2 = new Vec2(x, y);
+ * ```
+ */
+declare class Vector2 implements Vec2Like {
+    /**
+     * X分量
+     */
+    x: number;
+    /**
+     * Y分量
+     */
+    y: number;
+    /**
+     * 创建2D向量
+     * @param x X分量
+     * @param y Y分量
+     */
+    constructor(x?: number, y?: number);
+    /**
+     * 当前向量加上目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    add(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 当前向量减去目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    sub(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 当前向量按分量乘以目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    mul(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 当前向量按分量除以目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    div(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 计算与目标向量的点乘
+     * @param vec2 目标向量
+     * @returns 点乘结果
+     */
+    dot(vec2: Readonly<Vec2Like>): number;
+    /**
+     * 计算与目标向量的叉乘
+     * @param vec2 目标向量
+     * @returns 叉乘结果
+     */
+    crs(vec2: Readonly<Vec2Like>): number;
+    /**
+     * 计算与目标向量的距离
+     * @param vec2 目标向量
+     * @returns 距离
+     */
+    dist(vec2: Readonly<Vec2Like>): number;
+    /**
+     * 计算与目标向量的距离平方
+     * @param vec2 目标向量
+     * @returns 距离平方
+     */
+    distSq(vec2: Readonly<Vec2Like>): number;
+    /**
+     * 获取向量长度
+     * @returns 向量长度
+     */
+    len(): number;
+    /**
+     * 获取向量长度平方
+     * @returns 向量长度平方
+     */
+    lenSq(): number;
+    /**
+     * 将当前向量归一化
+     * @returns 当前向量
+     */
+    normal(): this;
+    /**
+     * 复制目标向量的分量到当前向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    copy(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 克隆当前向量
+     * @returns 新的向量实例
+     */
+    clone(): Vector2;
+    /**
+     * 设置向量分量
+     * @param x X分量
+     * @param y Y分量
+     * @returns 当前向量
+     */
+    set(x: number, y: number): this;
+    /**
+     * 设置X分量
+     * @param x X分量
+     * @returns 当前向量
+     */
+    setX(x: number): this;
+    /**
+     * 设置Y分量
+     * @param y Y分量
+     * @returns 当前向量
+     */
+    setY(y: number): this;
+    /**
+     * 应用矩阵变换
+     * @param mat3 目标矩阵
+     * @returns 当前向量
+     */
+    apply(mat3: Readonly<Mat3Like>): this;
+    /**
+     * 按分量取较大值
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    max(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 按分量取较小值
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    min(vec2: Readonly<Vec2Like>): this;
+    /**
+     * 将当前向量限制在最小值和最大值之间
+     * @param min 最小向量
+     * @param max 最大向量
+     * @returns 当前向量
+     */
+    clamp(min: Readonly<Vec2Like>, max: Readonly<Vec2Like>): this;
+    /**
+     * 乘以标量
+     * @param value 标量
+     * @returns 当前向量
+     */
+    scl(value: number): this;
+    /**
+     * 获取向量弧度
+     * 传入目标向量时，返回与目标向量的夹角弧度
+     * @param vec2 目标向量
+     * @returns 弧度值
+     */
+    angle(vec2?: Readonly<Vec2Like>): number;
+    /**
+     * 判断是否与目标向量完全相等
+     * @param vec2 目标向量
+     * @returns 是否相等
+     */
+    equals(vec2: Readonly<Vec2Like>): boolean;
+}
+declare const Vec2: typeof Vector2;
+export { Vec2, Vector2 };
+export type { Vec2Like };

package/lib/Math/Vec2.js

@@ -0,0 +1,251 @@
+/**
+ * 2D向量
+ * @class
+ * @implements Vec2Like
+ * @description 2D向量类
+ * @example
+ * ```ts
+ * const vec2 = new Vec2(x, y);
+ * ```
+ */
+class Vector2 {
+    /**
+     * X分量
+     */
+    x;
+    /**
+     * Y分量
+     */
+    y;
+    /**
+     * 创建2D向量
+     * @param x X分量
+     * @param y Y分量
+     */
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    /**
+     * 当前向量加上目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    add(vec2) {
+        this.x += vec2.x;
+        this.y += vec2.y;
+        return this;
+    }
+    /**
+     * 当前向量减去目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    sub(vec2) {
+        this.x -= vec2.x;
+        this.y -= vec2.y;
+        return this;
+    }
+    /**
+     * 当前向量按分量乘以目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    mul(vec2) {
+        this.x *= vec2.x;
+        this.y *= vec2.y;
+        return this;
+    }
+    /**
+     * 当前向量按分量除以目标向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    div(vec2) {
+        this.x /= vec2.x;
+        this.y /= vec2.y;
+        return this;
+    }
+    /**
+     * 计算与目标向量的点乘
+     * @param vec2 目标向量
+     * @returns 点乘结果
+     */
+    dot(vec2) {
+        return this.x * vec2.x + this.y * vec2.y;
+    }
+    /**
+     * 计算与目标向量的叉乘
+     * @param vec2 目标向量
+     * @returns 叉乘结果
+     */
+    crs(vec2) {
+        return this.x * vec2.y - this.y * vec2.x;
+    }
+    /**
+     * 计算与目标向量的距离
+     * @param vec2 目标向量
+     * @returns 距离
+     */
+    dist(vec2) {
+        return Math.sqrt(this.distSq(vec2));
+    }
+    /**
+     * 计算与目标向量的距离平方
+     * @param vec2 目标向量
+     * @returns 距离平方
+     */
+    distSq(vec2) {
+        const dx = this.x - vec2.x;
+        const dy = this.y - vec2.y;
+        return dx * dx + dy * dy;
+    }
+    /**
+     * 获取向量长度
+     * @returns 向量长度
+     */
+    len() {
+        return Math.sqrt(this.lenSq());
+    }
+    /**
+     * 获取向量长度平方
+     * @returns 向量长度平方
+     */
+    lenSq() {
+        return this.x * this.x + this.y * this.y;
+    }
+    /**
+     * 将当前向量归一化
+     * @returns 当前向量
+     */
+    normal() {
+        const length = this.len();
+        if (length === 0) {
+            return this;
+        }
+        this.x /= length;
+        this.y /= length;
+        return this;
+    }
+    /**
+     * 复制目标向量的分量到当前向量
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    copy(vec2) {
+        this.x = vec2.x;
+        this.y = vec2.y;
+        return this;
+    }
+    /**
+     * 克隆当前向量
+     * @returns 新的向量实例
+     */
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+    /**
+     * 设置向量分量
+     * @param x X分量
+     * @param y Y分量
+     * @returns 当前向量
+     */
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    /**
+     * 设置X分量
+     * @param x X分量
+     * @returns 当前向量
+     */
+    setX(x) {
+        this.x = x;
+        return this;
+    }
+    /**
+     * 设置Y分量
+     * @param y Y分量
+     * @returns 当前向量
+     */
+    setY(y) {
+        this.y = y;
+        return this;
+    }
+    /**
+     * 应用矩阵变换
+     * @param mat3 目标矩阵
+     * @returns 当前向量
+     */
+    apply(mat3) {
+        const x = this.x;
+        const y = this.y;
+        this.x = mat3.data[0] * x + mat3.data[3] * y + mat3.data[6];
+        this.y = mat3.data[1] * x + mat3.data[4] * y + mat3.data[7];
+        return this;
+    }
+    /**
+     * 按分量取较大值
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    max(vec2) {
+        this.x = Math.max(this.x, vec2.x);
+        this.y = Math.max(this.y, vec2.y);
+        return this;
+    }
+    /**
+     * 按分量取较小值
+     * @param vec2 目标向量
+     * @returns 当前向量
+     */
+    min(vec2) {
+        this.x = Math.min(this.x, vec2.x);
+        this.y = Math.min(this.y, vec2.y);
+        return this;
+    }
+    /**
+     * 将当前向量限制在最小值和最大值之间
+     * @param min 最小向量
+     * @param max 最大向量
+     * @returns 当前向量
+     */
+    clamp(min, max) {
+        this.x = Math.min(Math.max(this.x, min.x), max.x);
+        this.y = Math.min(Math.max(this.y, min.y), max.y);
+        return this;
+    }
+    /**
+     * 乘以标量
+     * @param value 标量
+     * @returns 当前向量
+     */
+    scl(value) {
+        this.x *= value;
+        this.y *= value;
+        return this;
+    }
+    /**
+     * 获取向量弧度
+     * 传入目标向量时，返回与目标向量的夹角弧度
+     * @param vec2 目标向量
+     * @returns 弧度值
+     */
+    angle(vec2) {
+        if (vec2 === undefined) {
+            return Math.atan2(this.y, this.x);
+        }
+        return Math.atan2(this.crs(vec2), this.dot(vec2));
+    }
+    /**
+     * 判断是否与目标向量完全相等
+     * @param vec2 目标向量
+     * @returns 是否相等
+     */
+    equals(vec2) {
+        return this.x === vec2.x && this.y === vec2.y;
+    }
+}
+const Vec2 = Vector2;
+export { Vec2, Vector2 };

package/lib/Math/index.d.ts

@@ -0,0 +1,2 @@
+export { Mat3, Matrix3, type Mat3Data, type Mat3Like } from "./Mat3.js";
+export { Vec2, Vector2, type Vec2Like } from "./Vec2.js";

package/lib/Math/index.js

@@ -0,0 +1,2 @@
+export { Mat3, Matrix3 } from "./Mat3.js";
+export { Vec2, Vector2 } from "./Vec2.js";

package/lib/Utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 数值钳制
+ * @param value 当前值
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 钳制结果
+ */
+declare const Clamp: (value: number, min: number, max: number) => number;
+export { Clamp };

package/lib/Utils/index.js

@@ -0,0 +1,11 @@
+/**
+ * 数值钳制
+ * @param value 当前值
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 钳制结果
+ */
+const Clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+export { Clamp };

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import * as Geometry from "./Geometry/index.js";
+import * as Math from "./Math/index.js";
+import * as Utils from "./Utils/index.js";
+declare const BPMatrixJS: {
+    Geometry: typeof Geometry;
+    Math: typeof Math;
+    Utils: typeof Utils;
+};
+export default BPMatrixJS;
+export { BPMatrixJS, Geometry, Math, Utils };

package/lib/index.js

@@ -0,0 +1,10 @@
+import * as Geometry from "./Geometry/index.js";
+import * as Math from "./Math/index.js";
+import * as Utils from "./Utils/index.js";
+const BPMatrixJS = {
+    Geometry,
+    Math,
+    Utils,
+};
+export default BPMatrixJS;
+export { BPMatrixJS, Geometry, Math, Utils };

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "bpmatrixjs",
+    "version": "0.0.1",
+    "type": "module",
+    "main": "./lib/index.js",
+    "module": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "files": [
+        "lib"
+    ],
+    "exports": {
+        ".": {
+            "types": "./lib/index.d.ts",
+            "import": "./lib/index.js"
+        },
+        "./Math": {
+            "types": "./lib/Math/index.d.ts",
+            "import": "./lib/Math/index.js"
+        },
+        "./Math/*": {
+            "types": "./lib/Math/*.d.ts",
+            "import": "./lib/Math/*.js"
+        },
+        "./Geometry": {
+            "types": "./lib/Geometry/index.d.ts",
+            "import": "./lib/Geometry/index.js"
+        },
+        "./Geometry/*": {
+            "types": "./lib/Geometry/*.d.ts",
+            "import": "./lib/Geometry/*.js"
+        },
+        "./Utils": {
+            "types": "./lib/Utils/index.d.ts",
+            "import": "./lib/Utils/index.js"
+        }
+    },
+    "scripts": {
+        "dev": "vite --host",
+        "build": "npm run build:lib && npm run build:app",
+        "build:app": "tsc && vite build",
+        "build:lib": "tsc -p tsconfig.lib.json",
+        "preview": "vite preview",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "pack:check": "npm pack --dry-run"
+    },
+    "devDependencies": {
+        "@types/node": "^24.0.13",
+        "@eslint/js": "^9.32.0",
+        "@stylistic/eslint-plugin": "^5.2.3",
+        "eslint": "^9.32.0",
+        "globals": "^16.3.0",
+        "typescript": "~6.0.2",
+        "typescript-eslint": "^8.38.0",
+        "vite": "^8.1.1"
+    }
+}