mirror of
https://gitee.com/dgflash/oops-framework.git
synced 2026-05-11 19:21:18 +08:00
391 lines
9.7 KiB
TypeScript
391 lines
9.7 KiB
TypeScript
|
||
import { Mat4, Vec3 } from "cc";
|
||
import { MathUtil } from "./MathUtil";
|
||
|
||
export class Vec3Util {
|
||
/**
|
||
* X轴
|
||
*/
|
||
public static get x(): Readonly<Vec3> {
|
||
return new Vec3(1, 0, 0);
|
||
}
|
||
|
||
/**
|
||
* Y轴
|
||
*/
|
||
public static get y(): Readonly<Vec3> {
|
||
return new Vec3(0, 1, 0);
|
||
}
|
||
|
||
/**
|
||
* Z轴
|
||
*/
|
||
public static get z(): Readonly<Vec3> {
|
||
return new Vec3(0, 0, 1);
|
||
}
|
||
|
||
/**
|
||
* 左向量
|
||
*/
|
||
public static get left(): Readonly<Vec3> {
|
||
return new Vec3(-1, 0, 0);
|
||
}
|
||
|
||
/**
|
||
* 右向量
|
||
*/
|
||
public static get right(): Readonly<Vec3> {
|
||
return new Vec3(1, 0, 0);
|
||
}
|
||
|
||
/**
|
||
* 上向量
|
||
*/
|
||
public static get up(): Readonly<Vec3> {
|
||
return new Vec3(0, 1, 0);
|
||
}
|
||
|
||
/**
|
||
* 下向量
|
||
*/
|
||
public static get down(): Readonly<Vec3> {
|
||
return new Vec3(0, -1, 0);
|
||
}
|
||
|
||
/**
|
||
* 前向量
|
||
*/
|
||
public static get forward(): Readonly<Vec3> {
|
||
return new Vec3(0, 0, 1);
|
||
}
|
||
|
||
/**
|
||
* 后向量
|
||
*/
|
||
public static get back(): Readonly<Vec3> {
|
||
return new Vec3(0, 0, -1);
|
||
}
|
||
|
||
/**
|
||
* 1向量
|
||
*/
|
||
public static get one(): Readonly<Vec3> {
|
||
return new Vec3(1, 1, 1);
|
||
}
|
||
|
||
/**
|
||
* 0向量
|
||
*/
|
||
public static get zero(): Readonly<Vec3> {
|
||
return new Vec3(0, 0, 0);
|
||
}
|
||
|
||
/**
|
||
* 随时间变化进度值
|
||
* @param start 起始位置
|
||
* @param end 结束位置
|
||
* @param t [0，1]
|
||
* @returns
|
||
*/
|
||
public static progress(start: Vec3, end: Vec3, t: number): Vec3 {
|
||
var current = new Vec3();
|
||
current.x = MathUtil.progress(start.x, end.x, t);
|
||
current.y = MathUtil.progress(start.y, end.y, t);
|
||
current.z = MathUtil.progress(start.z, end.z, t);
|
||
return current;
|
||
}
|
||
|
||
/**
|
||
* 获得两个三维向量的和
|
||
* @param pos1
|
||
* @param pos2
|
||
*/
|
||
public static add(pos1: Vec3, pos2: Vec3): Vec3 {
|
||
var outPos: Vec3 = new Vec3();
|
||
Vec3.add(outPos, pos1, pos2);
|
||
return outPos;
|
||
}
|
||
|
||
/**
|
||
* 获得两个三维向量的差
|
||
* @param pos1
|
||
* @param pos2
|
||
*/
|
||
public static sub(pos1: Vec3, pos2: Vec3): Vec3 {
|
||
var outPos: Vec3 = new Vec3();
|
||
Vec3.subtract(outPos, pos1, pos2);
|
||
return outPos;
|
||
}
|
||
|
||
/**
|
||
* 三维向量乘以常量
|
||
* @param pos1 b
|
||
* @param pos2
|
||
*/
|
||
public static mul(pos: Vec3, scalar: number): Vec3 {
|
||
var outPos: Vec3 = new Vec3();
|
||
Vec3.multiplyScalar(outPos, pos, scalar);
|
||
return outPos;
|
||
}
|
||
|
||
/**
|
||
* 三维向量除常量
|
||
* @param pos1 b
|
||
* @param pos2
|
||
*/
|
||
public static div(pos: Vec3, scalar: number): Vec3 {
|
||
var outPos: Vec3 = new Vec3();
|
||
|
||
outPos.x = pos.x / scalar;
|
||
outPos.y = pos.y / scalar;
|
||
outPos.z = pos.z / scalar;
|
||
|
||
return outPos;
|
||
}
|
||
|
||
/**
|
||
* 判断两个三维向量的值是否相等
|
||
* @param pos1
|
||
* @param pos2
|
||
*/
|
||
public static equals(pos1: Vec3, pos2: Vec3): boolean {
|
||
if (pos1.x == pos2.x && pos1.y == pos2.y && pos1.z == pos2.z) {
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 三维向量的模
|
||
*/
|
||
public static magnitude(pos: Vec3): number {
|
||
return pos.length();
|
||
}
|
||
|
||
/**
|
||
* 三维向量归一化
|
||
*/
|
||
public static normalize(pos: Vec3): Vec3 {
|
||
var outPos: Vec3 = new Vec3(pos.x, pos.y, pos.z);
|
||
return outPos.normalize();
|
||
}
|
||
|
||
/**
|
||
* 获得位置pos1，到位置 pos2 的方向
|
||
*/
|
||
public static direction(pos1: Vec3, pos2: Vec3): Vec3 {
|
||
var outPos: Vec3 = new Vec3();
|
||
Vec3.subtract(outPos, pos2, pos1)
|
||
return outPos.normalize();
|
||
}
|
||
|
||
/**
|
||
* 获得两点间的距离
|
||
* @param pos1
|
||
* @param pos2
|
||
*/
|
||
public static distance(pos1: Vec3, pos2: Vec3): number {
|
||
return Vec3.distance(pos1, pos2);
|
||
}
|
||
|
||
/**
|
||
* 插值运算
|
||
* @param posStart
|
||
* @param posEnd
|
||
* @param t
|
||
*/
|
||
public static lerp(posStart: Vec3, posEnd: Vec3, t: number): Vec3 {
|
||
return this.bezierOne(t, posStart, posEnd);
|
||
}
|
||
|
||
/**
|
||
* 球面插值
|
||
* @param from
|
||
* @param to
|
||
* @param t
|
||
* @returns
|
||
*/
|
||
public static slerp(from: Vec3, to: Vec3, t: number): Vec3 {
|
||
if (t <= 0) {
|
||
return from;
|
||
}
|
||
else if (t >= 1) {
|
||
return to;
|
||
}
|
||
|
||
var dir: Vec3 = this.rotateTo(from, to, (Vec3.angle(from, to) / Math.PI * 180) * t);
|
||
var lenght: number = to.length() * t + from.length() * (1 - t);
|
||
|
||
return (dir.normalize()).multiplyScalar(lenght);
|
||
}
|
||
|
||
public static rotateTo(from: Vec3, to: Vec3, angle: number): Vec3 {
|
||
//如果两个方向角度为0，则返回目标
|
||
if (Vec3.angle(from, to) == 0) {
|
||
return to;
|
||
}
|
||
|
||
var axis: Vec3 = new Vec3() // 获得旋转轴
|
||
Vec3.cross(axis, from, to);
|
||
axis.normalize();
|
||
|
||
var radian: number = angle * Math.PI / 180; // 获得弧度
|
||
var rotateMatrix: Mat4 = new Mat4();
|
||
rotateMatrix.rotate(radian, axis);
|
||
|
||
return new Vec3(
|
||
from.x * rotateMatrix.m00 + from.y * rotateMatrix.m04 + from.z * rotateMatrix.m08,
|
||
from.x * rotateMatrix.m01 + from.y * rotateMatrix.m05 + from.z * rotateMatrix.m09,
|
||
from.x * rotateMatrix.m02 + from.y * rotateMatrix.m06 + from.z * rotateMatrix.m10
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 一次贝塞尔即为线性插值函数
|
||
* @param t
|
||
* @param posStart
|
||
* @param posEnd
|
||
* @returns
|
||
*/
|
||
public static bezierOne(t: number, posStart: Vec3, posEnd: Vec3): Vec3 {
|
||
if (t > 1) {
|
||
t = 1;
|
||
}
|
||
else if (t < 0) {
|
||
t = 0
|
||
}
|
||
|
||
var pStart: Vec3 = posStart.clone();
|
||
var pEnd: Vec3 = posEnd.clone();
|
||
|
||
return pStart.multiplyScalar(1 - t).add(pEnd.multiplyScalar(t));
|
||
}
|
||
|
||
/**
|
||
* 二次贝塞尔曲线
|
||
* @param t
|
||
* @param posStart
|
||
* @param posCon
|
||
* @param posEnd
|
||
* @returns
|
||
*/
|
||
public static bezierTwo(t: number, posStart: Vec3, posCon: Vec3, posEnd: Vec3): Vec3 {
|
||
if (t > 1) {
|
||
t = 1;
|
||
}
|
||
else if (t < 0) {
|
||
t = 0
|
||
}
|
||
|
||
var n = (1 - t);
|
||
var tt = t * t;
|
||
|
||
var pStart: Vec3 = posStart.clone();
|
||
var pos = posStart.clone();
|
||
|
||
var pCon: Vec3 = posCon.clone();
|
||
var pEnd: Vec3 = posEnd.clone();
|
||
|
||
pos.add(pStart.multiplyScalar(n * n));
|
||
pos.add(pCon.multiplyScalar(2 * n * t));
|
||
pos.add(pEnd.multiplyScalar(tt));
|
||
|
||
return pos;
|
||
}
|
||
|
||
/**
|
||
* 三次贝塞尔
|
||
* @param t
|
||
* @param posStart
|
||
* @param posCon1
|
||
* @param posCon2
|
||
* @param posEnd
|
||
* @returns
|
||
*/
|
||
public static bezierThree(t: number, posStart: Vec3, posCon1: Vec3, posCon2: Vec3, posEnd: Vec3): Vec3 {
|
||
if (t > 1) {
|
||
t = 1;
|
||
}
|
||
else if (t < 0) {
|
||
t = 0
|
||
}
|
||
|
||
var n = (1 - t);
|
||
var nn = n * n;
|
||
var nnn = nn * n;
|
||
var tt = t * t;
|
||
var ttt = tt * t;
|
||
|
||
var pStart: Vec3 = posStart.clone();
|
||
var pos = posStart.clone();
|
||
|
||
var pCon1: Vec3 = posCon1.clone();
|
||
var pCon2: Vec3 = posCon2.clone();
|
||
var pEnd: Vec3 = posEnd.clone();
|
||
|
||
pos.add(pStart.multiplyScalar(nnn));
|
||
pos.add(pCon1.multiplyScalar(3 * nn * t));
|
||
pos.add(pCon2.multiplyScalar(3 * n * tt));
|
||
pos.add(pEnd.multiplyScalar(ttt));
|
||
|
||
return pos;
|
||
}
|
||
|
||
/**
|
||
* 点乘
|
||
* @param dir1
|
||
* @param dir2
|
||
*/
|
||
public static dot(dir1: Vec3, dir2: Vec3): number {
|
||
var tempDir1: Vec3 = dir1;
|
||
var tempDir2: Vec3 = dir2;
|
||
|
||
return tempDir1.x * tempDir2.x + tempDir1.y * tempDir2.y + tempDir1.z * tempDir2.z;
|
||
}
|
||
|
||
/**
|
||
* 叉乘
|
||
* @param dir1
|
||
* @param dir2
|
||
*/
|
||
public static cross(dir1: Vec3, dir2: Vec3): Vec3 {
|
||
var i: Vec3 = new Vec3(1, 0, 0);
|
||
var j: Vec3 = new Vec3(0, 1, 0);
|
||
var k: Vec3 = new Vec3(0, 0, 1);
|
||
|
||
var tempDir1: Vec3 = new Vec3(dir1.x, dir1.y, dir1.z);
|
||
var tempDir2: Vec3 = new Vec3(dir2.x, dir2.y, dir2.z);
|
||
|
||
var iv: Vec3 = i.multiplyScalar(tempDir1.y * tempDir2.z - tempDir2.y * tempDir1.z);
|
||
var jv: Vec3 = j.multiplyScalar(tempDir2.x * tempDir1.z - tempDir1.x * tempDir2.z);
|
||
var kv: Vec3 = k.multiplyScalar(tempDir1.x * tempDir2.y - tempDir2.x * tempDir1.y);
|
||
|
||
return iv.add(jv).add(kv);
|
||
}
|
||
|
||
/**
|
||
* 获得两个方向向量的角度
|
||
* @param dir1
|
||
* @param dir2
|
||
*/
|
||
public static angle(dir1: Vec3, dir2: Vec3): number {
|
||
var dotValue = this.dot(dir1.clone().normalize(), dir2.clone().normalize());
|
||
return Math.acos(dotValue) / Math.PI * 180 * Math.sign(dotValue);
|
||
}
|
||
|
||
/**
|
||
* 获得方向a到方向b的角度（带有方向的角度）
|
||
* @param a
|
||
* @param b
|
||
*/
|
||
public static dirAngle(a: Vec3, b: Vec3): number {
|
||
var c: Vec3 = Vec3Util.cross(a, b);
|
||
var angle: number = Vec3Util.angle(a, b);
|
||
// a 到 b 的夹角
|
||
var sign = Math.sign(Vec3Util.dot(c.normalize(), Vec3Util.cross(b.normalize(), a.normalize())));
|
||
|
||
return angle * sign;
|
||
}
|
||
}
|