diff --git a/cocos/core/geom-utils/capsule.ts b/cocos/core/geom-utils/capsule.ts new file mode 100644 index 0000000000..1749ac7d66 --- /dev/null +++ b/cocos/core/geom-utils/capsule.ts @@ -0,0 +1,94 @@ +import { Vec3, Quat, Mat4, absMaxComponent } from "../math"; +import enums from "./enums"; +import { IVec3Like, IQuatLike } from "../math/type-define"; + +/** + * @zh + * 基础几何,胶囊体 + */ +export class capsule { + + protected _type: number; + + /** + * @zh + * 胶囊体球部半径 + */ + radius: number; + + /** + * @zh + * 胶囊体中心点和球部圆心的距离 + */ + halfHeight: number; + + /** + * @zh + * 胶囊体的朝向,映射关系 [0,1,2] => [x,y,z] + */ + axis: number; + + readonly center: Vec3; + readonly rotation: Quat; + + /** cache, local center of ellipse */ + readonly ellipseCenter0: Vec3; + readonly ellipseCenter1: Vec3; + + constructor (radius: number = 0.5, halfHeight: number = 0.5, axis = 1) { + this._type = enums.SHAPE_CAPSULE; + this.radius = radius; + this.halfHeight = halfHeight; + this.axis = axis; + + this.center = new Vec3(); + this.rotation = new Quat(); + + this.ellipseCenter0 = new Vec3(0, halfHeight, 0); + this.ellipseCenter1 = new Vec3(0, -halfHeight, 0); + this.updateCache(); + } + + transform (m: Mat4, pos: IVec3Like, rot: IQuatLike, scale: IVec3Like, out: capsule) { + const ws = scale; + const s = absMaxComponent(ws as Vec3); + out.radius = this.radius * Math.abs(s); + + const halfTotalWorldHeight = (this.halfHeight + this.radius) * Math.abs(ws.y); + let halfWorldHeight = halfTotalWorldHeight - out.radius; + if (halfWorldHeight < 0) halfWorldHeight = 0; + out.halfHeight = halfWorldHeight; + + Vec3.transformMat4(out.center, this.center, m); + Quat.multiply(out.rotation, this.rotation, rot); + out.updateCache(); + } + + updateCache () { + this.updateLocalCenter(); + Vec3.transformQuat(this.ellipseCenter0, this.ellipseCenter0, this.rotation); + Vec3.transformQuat(this.ellipseCenter1, this.ellipseCenter1, this.rotation); + this.ellipseCenter0.add(this.center); + this.ellipseCenter1.add(this.center); + } + + updateLocalCenter () { + const halfHeight = this.halfHeight; + const axis = this.axis; + switch (axis) { + case 0: + this.ellipseCenter0.set(halfHeight, 0, 0); + this.ellipseCenter1.set(-halfHeight, 0, 0); + break; + case 1: + this.ellipseCenter0.set(0, halfHeight, 0); + this.ellipseCenter1.set(0, -halfHeight, 0); + break; + case 2: + this.ellipseCenter0.set(0, 0, halfHeight); + this.ellipseCenter1.set(0, 0, -halfHeight); + break; + } + } + +} \ No newline at end of file diff --git a/cocos/core/geom-utils/distance.ts b/cocos/core/geom-utils/distance.ts index 1f41fee16e..0eff219cfd 100644 --- a/cocos/core/geom-utils/distance.ts +++ b/cocos/core/geom-utils/distance.ts @@ -117,3 +117,29 @@ export function pt_point_obb (out: Vec3, point: Vec3, obb_: obb): Vec3 { } return out; } + +export function pt_point_line (out: Vec3, point: Vec3, start: Vec3, end: Vec3) { + Vec3.subtract(X, start, end); + const dir = X; + const dirSquaredLength = Vec3.lengthSqr(dir); + + if (dirSquaredLength == 0) { + // The point is at the segment start. + Vec3.copy(out, start); + } else { + // Calculate the projection of the point onto the line extending through the segment. + Vec3.subtract(X, point, start); + const t = Vec3.dot(X, dir) / dirSquaredLength; + + if (t < 0) { + // The point projects beyond the segment start. + Vec3.copy(out, start); + } else if (t > 1) { + // The point projects beyond the segment end. + Vec3.copy(out, end); + } else { + // The point projects between the start and end of the segment. + Vec3.scaleAndAdd(out, start, dir, t); + } + } +} \ No newline at end of file diff --git a/cocos/core/geom-utils/enums.ts b/cocos/core/geom-utils/enums.ts index 9af97fb244..8d03fc9398 100644 --- a/cocos/core/geom-utils/enums.ts +++ b/cocos/core/geom-utils/enums.ts @@ -16,4 +16,5 @@ export default { SHAPE_TRIANGLE: (1 << 6), SHAPE_FRUSTUM: (1 << 7), SHAPE_FRUSTUM_ACCURATE: (1 << 8), + SHAPE_CAPSULE: (1 << 9), }; diff --git a/cocos/core/geom-utils/index.ts b/cocos/core/geom-utils/index.ts index 85ede55866..70e2d38d3e 100644 --- a/cocos/core/geom-utils/index.ts +++ b/cocos/core/geom-utils/index.ts @@ -13,6 +13,7 @@ export { default as triangle } from './triangle'; export { default as sphere } from './sphere'; export { default as aabb } from './aabb'; export { default as obb } from './obb'; +export { capsule } from './capsule'; export { frustum } from './frustum'; export { Keyframe, AnimationCurve } from './curve'; diff --git a/cocos/core/geom-utils/intersect.ts b/cocos/core/geom-utils/intersect.ts index f16965fbaa..bba216818c 100644 --- a/cocos/core/geom-utils/intersect.ts +++ b/cocos/core/geom-utils/intersect.ts @@ -3,7 +3,7 @@ * @category geometry */ -import { Mat3, Vec3 } from '../math'; +import { Mat3, Vec3, EPSILON, Vec2 } from '../math'; import aabb from './aabb'; import * as distance from './distance'; import enums from './enums'; @@ -14,6 +14,7 @@ import plane from './plane'; import ray from './ray'; import sphere from './sphere'; import triangle from './triangle'; +import { capsule } from './capsule'; // tslint:disable:only-arrow-functions // tslint:disable:one-variable-per-declaration @@ -212,6 +213,84 @@ const ray_obb = (function () { }; })(); +const ray_capsule = (function () { + const v3_0 = new Vec3(); + const v3_1 = new Vec3(); + const v3_2 = new Vec3(); + const v3_3 = new Vec3(); + const v3_4 = new Vec3(); + const v3_5 = new Vec3(); + const v3_6 = new Vec3(); + const sphere_0 = new sphere(); + return function (ray: ray, capsule: capsule) { + const radiusSqr = capsule.radius * capsule.radius; + var vRayNorm = Vec3.normalize(v3_0, ray.d); + var A = capsule.ellipseCenter0; + var B = capsule.ellipseCenter1; + var BA = Vec3.subtract(v3_1, B, A); + if (BA.equals(Vec3.ZERO)) { + sphere_0.radius = capsule.radius; + sphere_0.center.set(capsule.ellipseCenter0); + return intersect.ray_sphere(ray, sphere_0); + } + + var O = ray.o; + var OA = Vec3.subtract(v3_2, O, A); + var VxBA = Vec3.cross(v3_3, vRayNorm, BA); + var a = VxBA.lengthSqr(); + if (a == 0) { + sphere_0.radius = capsule.radius; + var BO = Vec3.subtract(v3_4, B, O); + if (OA.lengthSqr() < BO.lengthSqr()) { + sphere_0.center.set(capsule.ellipseCenter0); + } else { + sphere_0.center.set(capsule.ellipseCenter1); + } + return intersect.ray_sphere(ray, sphere_0); + } + + var OAxBA = Vec3.cross(v3_4, OA, BA); + var ab2 = BA.lengthSqr(); + var b = 2 * Vec3.dot(VxBA, OAxBA); + var c = OAxBA.lengthSqr() - (radiusSqr * ab2); + var d = b * b - 4 * a * c; + + if (d < 0) return 0; + + var t = (-b - Math.sqrt(d)) / (2 * a); + if (t < 0) { + sphere_0.radius = capsule.radius; + var BO = Vec3.subtract(v3_5, B, O); + if (OA.lengthSqr() < BO.lengthSqr()) { + sphere_0.center.set(capsule.ellipseCenter0); + } else { + sphere_0.center.set(capsule.ellipseCenter1); + } + return intersect.ray_sphere(ray, sphere_0); + } else { + //Limit intersection between the bounds of the cylinder's end caps. + var iPos = Vec3.scaleAndAdd(v3_5, ray.o, vRayNorm, t); + var iPosLen = Vec3.subtract(v3_6, iPos, A); + var tLimit = Vec3.dot(iPosLen, BA) / ab2; + + if (tLimit >= 0 && tLimit <= 1) { + return t; + } else if (tLimit < 0) { + sphere_0.radius = capsule.radius; + sphere_0.center.set(capsule.ellipseCenter0); + return intersect.ray_sphere(ray, sphere_0); + } else if (tLimit > 1) { + sphere_0.radius = capsule.radius; + sphere_0.center.set(capsule.ellipseCenter1); + return intersect.ray_sphere(ray, sphere_0); + } else { + return 0; + } + } + + } +})(); + /** * line-plane intersect
* 线段与平面的相交性检测。 @@ -741,6 +820,68 @@ const obb_obb = (function () { }; })(); + +// https://github.com/diku-dk/bvh-tvcg18/blob/1fd3348c17bc8cf3da0b4ae60fdb8f2aa90a6ff0/FOUNDATION/GEOMETRY/GEOMETRY/include/overlap/geometry_overlap_obb_capsule.h +/** + * 方向包围盒和胶囊体的重叠检测 + * @param obb 方向包围盒 + * @param capsule 胶囊体 + */ +const obb_capsule = (function () { + const sphere_0 = new sphere(); + const v3_0 = new Vec3(); + const v3_1 = new Vec3(); + const v3_2 = new Vec3(); + const v3_verts8 = new Array(8); + for (let i = 0; i < 8; i++) { v3_verts8[i] = new Vec3(); } + const v3_axis7 = new Array(7); + for (let i = 0; i < 7; i++) { v3_axis7[i] = new Vec3(); } + return function (obb: obb, capsule: capsule) { + const h = Vec3.squaredDistance(capsule.ellipseCenter0, capsule.ellipseCenter1); + if (h == 0) { + sphere_0.radius = capsule.radius; + sphere_0.center.set(capsule.ellipseCenter0); + return intersect.sphere_obb(sphere_0, obb); + } else { + v3_0.x = obb.orientation.m00; + v3_0.y = obb.orientation.m01; + v3_0.z = obb.orientation.m02; + v3_1.x = obb.orientation.m03; + v3_1.y = obb.orientation.m04; + v3_1.z = obb.orientation.m05; + v3_2.x = obb.orientation.m06; + v3_2.y = obb.orientation.m07; + v3_2.z = obb.orientation.m08; + getOBBVertices(obb.center, obb.halfExtents, v3_0, v3_1, v3_2, v3_verts8); + + const axes = v3_axis7; + const a0 = Vec3.copy(axes[0], v3_0); + const a1 = Vec3.copy(axes[1], v3_1); + const a2 = Vec3.copy(axes[2], v3_2); + const B = Vec3.subtract(axes[3], capsule.ellipseCenter0, capsule.ellipseCenter1); + Vec3.cross(axes[4], a0, B); + Vec3.cross(axes[5], a1, B); + Vec3.cross(axes[6], a2, B); + for (let i = 0; i < 7; ++i) { + const a = getInterval(v3_verts8, axes[i]); + const d0 = Vec3.dot(axes[i], capsule.ellipseCenter0); + const d1 = Vec3.dot(axes[i], capsule.ellipseCenter1); + const d0_min = d0 - capsule.radius; + const d0_max = d0 + capsule.radius; + const d1_min = d1 - capsule.radius; + const d1_max = d1 + capsule.radius; + const d_max = Math.max(d0_min, d1_min, d0_max, d1_max); + const d_min = Math.min(d0_min, d1_min, d0_max, d1_max); + + if (d_min > a[1] || a[0] > d_max) { + return 0; // Seperating axis found + } + } + return 1; + } + } +})(); + /** * sphere-plane intersect, not necessarily faster than obb-plane
* due to the length calculation of the plane normal to factor out
@@ -849,12 +990,123 @@ const sphere_obb = (function () { }; })(); +const sphere_capsule = (function () { + const v3_0 = new Vec3(); + const v3_1 = new Vec3(); + return function (sphere: sphere, capsule: capsule) { + const r = sphere.radius + capsule.radius; + const squaredR = r * r; + const h = Vec3.squaredDistance(capsule.ellipseCenter0, capsule.ellipseCenter1); + if (h == 0) { + return Vec3.squaredDistance(sphere.center, capsule.center) < squaredR; + } else { + Vec3.subtract(v3_0, sphere.center, capsule.ellipseCenter0); + Vec3.subtract(v3_1, capsule.ellipseCenter1, capsule.ellipseCenter0); + const t = Vec3.dot(v3_0, v3_1) / h; + if (t < 0) { + return Vec3.squaredDistance(sphere.center, capsule.ellipseCenter0) < squaredR; + } else if (t > 1) { + return Vec3.squaredDistance(sphere.center, capsule.ellipseCenter1) < squaredR; + } else { + Vec3.scaleAndAdd(v3_0, capsule.ellipseCenter0, v3_1, t); + return Vec3.squaredDistance(sphere.center, v3_0) < squaredR; + } + } + } +})(); + +// http://www.geomalgorithms.com/a07-_distance.html +const capsule_capsule = (function () { + const v3_0 = new Vec3(); + const v3_1 = new Vec3(); + const v3_2 = new Vec3(); + const v3_3 = new Vec3(); + const v3_4 = new Vec3(); + const v3_5 = new Vec3(); + return function capsule_capsule (capsuleA: capsule, capsuleB: capsule) { + let u = Vec3.subtract(v3_0, capsuleA.ellipseCenter1, capsuleA.ellipseCenter0); + let v = Vec3.subtract(v3_1, capsuleB.ellipseCenter1, capsuleB.ellipseCenter0); + let w = Vec3.subtract(v3_2, capsuleA.ellipseCenter0, capsuleB.ellipseCenter0); + let a = Vec3.dot(u, u); // always >= 0 + let b = Vec3.dot(u, v); + let c = Vec3.dot(v, v); // always >= 0 + let d = Vec3.dot(u, w); + let e = Vec3.dot(v, w); + let D = a * c - b * b; // always >= 0 + let sc: number; + let sN: number; + let sD = D; // sc = sN / sD, default sD = D >= 0 + let tc: number; + let tN: number; + let tD = D; // tc = tN / tD, default tD = D >= 0 + + // compute the line parameters of the two closest points + if (D < EPSILON) { // the lines are almost parallel + sN = 0.0; // force using point P0 on segment S1 + sD = 1.0; // to prevent possible division by 0.0 later + tN = e; + tD = c; + } + else { // get the closest points on the infinite lines + sN = (b * e - c * d); + tN = (a * e - b * d); + if (sN < 0.0) { // sc < 0 => the s=0 edge is visible + sN = 0.0; + tN = e; + tD = c; + } + else if (sN > sD) { // sc > 1 => the s=1 edge is visible + sN = sD; + tN = e + b; + tD = c; + } + } + + if (tN < 0.0) { // tc < 0 => the t=0 edge is visible + tN = 0.0; + // recompute sc for this edge + if (-d < 0.0) + sN = 0.0; + else if (-d > a) + sN = sD; + else { + sN = -d; + sD = a; + } + } + else if (tN > tD) { // tc > 1 => the t=1 edge is visible + tN = tD; + // recompute sc for this edge + if ((-d + b) < 0.0) + sN = 0; + else if ((-d + b) > a) + sN = sD; + else { + sN = (-d + b); + sD = a; + } + } + // finally do the division to get sc and tc + sc = (Math.abs(sN) < EPSILON ? 0.0 : sN / sD); + tc = (Math.abs(tN) < EPSILON ? 0.0 : tN / tD); + + // get the difference of the two closest points + var dP = v3_3; + dP.set(w); + dP.add(Vec3.multiplyScalar(v3_4, u, sc)); + dP.subtract(Vec3.multiplyScalar(v3_5, v, tc)); + const radius = capsuleA.radius + capsuleB.radius; + return dP.lengthSqr() < radius * radius; + } +})(); + const intersect = { ray_sphere, ray_aabb, ray_obb, ray_plane, ray_triangle, + ray_capsule, line_sphere, line_aabb, @@ -868,6 +1120,7 @@ const intersect = { sphere_plane, sphere_frustum, sphere_frustum_accurate, + sphere_capsule, aabb_aabb, aabb_obb, @@ -880,6 +1133,9 @@ const intersect = { obb_frustum, obb_frustum_accurate, obb_point, + obb_capsule, + + capsule_capsule, /** * @zh @@ -901,6 +1157,7 @@ intersect[enums.SHAPE_RAY | enums.SHAPE_AABB] = ray_aabb; intersect[enums.SHAPE_RAY | enums.SHAPE_OBB] = ray_obb; intersect[enums.SHAPE_RAY | enums.SHAPE_PLANE] = ray_plane; intersect[enums.SHAPE_RAY | enums.SHAPE_TRIANGLE] = ray_triangle; +intersect[enums.SHAPE_RAY | enums.SHAPE_CAPSULE] = ray_capsule; intersect[enums.SHAPE_LINE | enums.SHAPE_SPHERE] = line_sphere; intersect[enums.SHAPE_LINE | enums.SHAPE_AABB] = line_aabb; @@ -914,6 +1171,7 @@ intersect[enums.SHAPE_SPHERE | enums.SHAPE_OBB] = sphere_obb; intersect[enums.SHAPE_SPHERE | enums.SHAPE_PLANE] = sphere_plane; intersect[enums.SHAPE_SPHERE | enums.SHAPE_FRUSTUM] = sphere_frustum; intersect[enums.SHAPE_SPHERE | enums.SHAPE_FRUSTUM_ACCURATE] = sphere_frustum_accurate; +intersect[enums.SHAPE_SPHERE | enums.SHAPE_CAPSULE] = sphere_capsule; intersect[enums.SHAPE_AABB] = aabb_aabb; intersect[enums.SHAPE_AABB | enums.SHAPE_OBB] = aabb_obb; @@ -925,5 +1183,8 @@ intersect[enums.SHAPE_OBB] = obb_obb; intersect[enums.SHAPE_OBB | enums.SHAPE_PLANE] = obb_plane; intersect[enums.SHAPE_OBB | enums.SHAPE_FRUSTUM] = obb_frustum; intersect[enums.SHAPE_OBB | enums.SHAPE_FRUSTUM_ACCURATE] = obb_frustum_accurate; +intersect[enums.SHAPE_OBB | enums.SHAPE_CAPSULE] = obb_capsule; + +intersect[enums.SHAPE_CAPSULE] = capsule_capsule; export default intersect; diff --git a/cocos/core/math/utils.ts b/cocos/core/math/utils.ts index 54a18a273b..a9cfdde6a6 100644 --- a/cocos/core/math/utils.ts +++ b/cocos/core/math/utils.ts @@ -1,3 +1,5 @@ +import { IVec3Like } from "./type-define"; + /** * @category core/math */ @@ -203,3 +205,24 @@ export function pingPong (t: number, length: number) { export function inverseLerp (from: number, to: number, value: number) { return (value - from) / (to - from); } + +/** + * @zh 对所有分量的绝对值进行比较大小,返回绝对值最大的分量。 + * @param v 类 Vec3 结构 + * @returns 绝对值最大的分量 + */ +export function absMaxComponent (v: IVec3Like) { + if (Math.abs(v.x) > Math.abs(v.y)) { + if (Math.abs(v.x) > Math.abs(v.z)) { + return v.x; + } else { + return v.z; + } + } else { + if (Math.abs(v.y) > Math.abs(v.z)) { + return v.y; + } else { + return v.z; + } + } +} \ No newline at end of file diff --git a/cocos/physics/cocos/instantiate.ts b/cocos/physics/cocos/instantiate.ts index 9df6f6cbde..95ad80f5e1 100644 --- a/cocos/physics/cocos/instantiate.ts +++ b/cocos/physics/cocos/instantiate.ts @@ -6,6 +6,7 @@ import { instantiate } from '../framework/Physics-selector'; import { BuiltInWorld } from './builtin-world'; import { BuiltinBoxShape } from './shapes/builtin-box-shape'; import { BuiltinSphereShape } from './shapes/builtin-sphere-shape'; +import { BuiltinCapsuleShape } from './shapes/builtin-capsule-shape'; if (CC_PHYSICS_BUILTIN) { instantiate( @@ -13,5 +14,6 @@ if (CC_PHYSICS_BUILTIN) { BuiltinSphereShape, null, BuiltInWorld, + BuiltinCapsuleShape ); } diff --git a/cocos/physics/cocos/shapes/builtin-capsule-shape.ts b/cocos/physics/cocos/shapes/builtin-capsule-shape.ts new file mode 100644 index 0000000000..23d6a02881 --- /dev/null +++ b/cocos/physics/cocos/shapes/builtin-capsule-shape.ts @@ -0,0 +1,79 @@ + +import { BuiltinShape } from './builtin-shape'; +import { ICapsuleShape } from '../../spec/i-physics-shape'; +import { ECapsuleDirection, CapsuleColliderComponent } from '../../framework/components/collider/capsule-collider-component'; +import { capsule } from '../../../core/geom-utils'; + +export class BuiltinCapsuleShape extends BuiltinShape implements ICapsuleShape { + + get localCapsule () { + return this._localShape as capsule; + } + + get worldCapsule () { + return this._worldShape as capsule; + } + + get capsuleCollider () { + return this.collider as CapsuleColliderComponent; + } + + constructor (radius: number, height: number, direction = ECapsuleDirection.Y_AXIS) { + super(); + const halfHeight = (height - radius * 2) / 2; + const h = halfHeight < 0 ? 0 : halfHeight; + this._localShape = new capsule(radius, h, direction); + this._worldShape = new capsule(radius, h, direction); + } + + set radius (v: number) { + this.localCapsule.radius = v; + + const halfTotalHeight = this.capsuleCollider.height / 2; + let halfHeight = halfTotalHeight - v; + if (halfHeight < 0) halfHeight = 0; + this.localCapsule.halfHeight = halfHeight; + this.localCapsule.updateCache(); + + this.transform( + this._sharedBody.node.worldMatrix, + this._sharedBody.node.worldPosition, + this._sharedBody.node.worldRotation, + this._sharedBody.node.worldScale + ); + } + + set height (v: number) { + const hf = v / 2 - this.capsuleCollider.radius; + this.localCapsule.halfHeight = hf; + this.localCapsule.updateCache(); + + this.transform( + this._sharedBody.node.worldMatrix, + this._sharedBody.node.worldPosition, + this._sharedBody.node.worldRotation, + this._sharedBody.node.worldScale + ); + } + + set direction (v: ECapsuleDirection) { + this.localCapsule.axis = v; + this.localCapsule.updateCache(); + + this.worldCapsule.axis = v; + this.worldCapsule.updateCache(); + + this.transform( + this._sharedBody.node.worldMatrix, + this._sharedBody.node.worldPosition, + this._sharedBody.node.worldRotation, + this._sharedBody.node.worldScale + ); + } + + onLoad () { + super.onLoad(); + this.radius = this.capsuleCollider.radius; + this.direction = this.capsuleCollider.direction; + } +} \ No newline at end of file diff --git a/cocos/physics/framework/Physics-selector.ts b/cocos/physics/framework/Physics-selector.ts index e6612e2762..fe3fbe6c6d 100644 --- a/cocos/physics/framework/Physics-selector.ts +++ b/cocos/physics/framework/Physics-selector.ts @@ -12,6 +12,7 @@ import { CannonSphereShape } from '../cannon/shapes/cannon-sphere-shape'; import { BuiltInWorld } from '../cocos/builtin-world'; import { BuiltinBoxShape } from '../cocos/shapes/builtin-box-shape'; import { BuiltinSphereShape } from '../cocos/shapes/builtin-sphere-shape'; +import { BuiltinCapsuleShape } from '../cocos/shapes/builtin-capsule-shape'; // Ammo import { AmmoRigidBody } from '../ammo/ammo-rigid-body'; @@ -23,14 +24,20 @@ export let BoxShape: typeof CannonBoxShape | typeof BuiltinBoxShape | typeof Amm export let SphereShape: typeof CannonSphereShape | typeof BuiltinSphereShape | typeof AmmoSphereShape; export let RigidBody: typeof CannonRigidBody | null | typeof AmmoRigidBody; export let PhysicsWorld: typeof CannonWorld | typeof BuiltInWorld | typeof AmmoWorld; +export let CapsuleShape: typeof BuiltinCapsuleShape; export function instantiate ( boxShape: typeof BoxShape, sphereShape: typeof SphereShape, body: typeof RigidBody, - world: typeof PhysicsWorld) { + world: typeof PhysicsWorld, + capsuleShape?: typeof CapsuleShape +) { BoxShape = boxShape; SphereShape = sphereShape; RigidBody = body; PhysicsWorld = world; + if (capsuleShape) { + CapsuleShape = capsuleShape; + } } diff --git a/cocos/physics/framework/components/collider/capsule-collider-component.ts b/cocos/physics/framework/components/collider/capsule-collider-component.ts new file mode 100644 index 0000000000..b56588a022 --- /dev/null +++ b/cocos/physics/framework/components/collider/capsule-collider-component.ts @@ -0,0 +1,117 @@ +/** + * @category physics + */ + +import { + ccclass, + executeInEditMode, + executionOrder, + menu, + property, +} from '../../../../core/data/class-decorator'; +import { createCapsuleShape } from '../../instance'; +import { ColliderComponent } from './collider-component'; +import { ICapsuleShape } from '../../../spec/i-physics-shape'; +import { Enum } from '../../../../core'; + +export enum ECapsuleDirection { + X_AXIS, + Y_AXIS, + Z_AXIS, +} +Enum(ECapsuleDirection); + +/** + * @zh + * 胶囊体碰撞器 + */ +@ccclass('cc.CapsuleColliderComponent') +@executionOrder(98) +@menu('Components/CapsuleCollider') +@executeInEditMode +export class CapsuleColliderComponent extends ColliderComponent { + /// PUBLIC PROPERTY GETTER\SETTER /// + + /** + * @en + * Get or set the radius of the sphere on the capsule body, in local space. + * @zh + * 获取或设置胶囊体上的球半径。 + */ + @property({ tooltip: '胶囊体上的球的半径' }) + public get radius () { + return this._radius; + } + + public set radius (value) { + if (value < 0) value = 0; + + this._radius = value; + + /** Recalculated height */ + const doubleR = this._radius * 2 + if (this._height < doubleR) { + this._height = doubleR; + // if (!CC_EDITOR) { + // this.capsuleShape.height = this._height; + // } + } + + if (!CC_EDITOR) { + this.capsuleShape.radius = this._radius; + } + } + + /** + * @en + * Get or set the capsule body is at the corresponding axial height, in local space. + * @zh + * 胶囊体在相应轴向的高度,最小值为两倍的 radius。 + */ + @property({ tooltip: '胶囊体在相应轴向的高度' }) + public get height () { + return this._height; + } + + public set height (value) { + if (value < this._radius * 2) { + value = this._radius * 2 + } + + this._height = value; + if (!CC_EDITOR) { + this.capsuleShape.height = this._height; + } + } + + @property({ type: ECapsuleDirection }) + public get direction () { + return this._direction; + } + + public set direction (value: ECapsuleDirection) { + this._direction = value; + } + + public get capsuleShape (): ICapsuleShape { + return this._shape as ICapsuleShape; + } + + /// PRIVATE PROPERTY /// + + @property + private _radius = 0.5; + + @property + private _height = 2; + + @property + private _direction = ECapsuleDirection.Y_AXIS; + + constructor () { + super(); + if (!CC_EDITOR) { + this._shape = createCapsuleShape(); + } + } +} diff --git a/cocos/physics/framework/index.ts b/cocos/physics/framework/index.ts index 90638bd1e6..3636f79f75 100644 --- a/cocos/physics/framework/index.ts +++ b/cocos/physics/framework/index.ts @@ -8,6 +8,7 @@ import { PhysicsRayResult } from './physics-ray-result'; import { BoxColliderComponent } from './components/collider/box-collider-component'; import { ColliderComponent } from './components/collider/collider-component'; import { SphereColliderComponent } from './components/collider/sphere-collider-component'; +import { CapsuleColliderComponent } from './components/collider/capsule-collider-component'; import { RigidBodyComponent } from './components/rigid-body-component'; import { ConstantForce } from './components/constant-force'; @@ -18,16 +19,21 @@ export { ColliderComponent, BoxColliderComponent, SphereColliderComponent, + CapsuleColliderComponent, + RigidBodyComponent, PhysicMaterial, }; cc.PhysicsSystem = PhysicsSystem; + cc.ColliderComponent = ColliderComponent; cc.BoxColliderComponent = BoxColliderComponent; cc.SphereColliderComponent = SphereColliderComponent; + cc.RigidBodyComponent = RigidBodyComponent; + cc.PhysicMaterial = PhysicMaterial; cc.PhysicsRayResult = PhysicsRayResult; cc.ConstantForce = ConstantForce; diff --git a/cocos/physics/framework/instance.ts b/cocos/physics/framework/instance.ts index 892ed7000b..778baeee2b 100644 --- a/cocos/physics/framework/instance.ts +++ b/cocos/physics/framework/instance.ts @@ -3,10 +3,11 @@ */ import { Vec3 } from '../../core/math'; -import { BoxShape, PhysicsWorld, RigidBody, SphereShape } from './Physics-selector'; +import { BoxShape, PhysicsWorld, RigidBody, SphereShape, CapsuleShape } from './Physics-selector'; import { IRigidBody } from '../spec/i-rigid-body'; -import { IBoxShape, ISphereShape } from '../spec/i-physics-shape'; +import { IBoxShape, ISphereShape, ICapsuleShape } from '../spec/i-physics-shape'; import { IPhysicsWorld } from '../spec/i-physics-world'; +import { warn } from '../../core'; export function createPhysicsWorld (): IPhysicsWorld { return new PhysicsWorld() as IPhysicsWorld; @@ -23,3 +24,23 @@ export function createBoxShape (size: Vec3): IBoxShape { export function createSphereShape (radius: number): ISphereShape { return new SphereShape(radius) as ISphereShape; } + +export function createCapsuleShape (radius = 0.5, height = 2, dir = 1): ICapsuleShape { + if (CC_PHYSICS_BUILTIN) { + return new CapsuleShape(radius, height, dir) as ICapsuleShape; + } else { + warn('[v1.0.3][Physics]: Currently only builtin support capsule collider'); + /** apater */ + return { + radius: radius, height: height, direction: dir, + material: null, + isTrigger: false, + center: new Vec3(), + __preload: () => { }, + onLoad: () => { }, + onEnable: () => { }, + onDisable: () => { }, + onDestroy: () => { } + } as any + } +} diff --git a/cocos/physics/framework/util.ts b/cocos/physics/framework/util.ts index 909c8d22a1..77f811f04b 100644 --- a/cocos/physics/framework/util.ts +++ b/cocos/physics/framework/util.ts @@ -6,11 +6,11 @@ import { Vec3 } from '../../core/math'; import { IVec3Like, IQuatLike } from '../../core/math/type-define'; export function stringfyVec3 (value: IVec3Like): string { - return `(x: ${value.x}, y: ${value.y}, z: ${value.z})`; + return `(x: ${value.x}, y: ${value.y}, z: ${value.z})`; } export function stringfyQuat (value: IQuatLike): string { - return `(x: ${value.x}, y: ${value.y}, z: ${value.z}, w: ${value.w})`; + return `(x: ${value.x}, y: ${value.y}, z: ${value.z}, w: ${value.w})`; } interface IWrapped { @@ -28,3 +28,4 @@ export function getWrap (object: any) { export function maxComponent (v: Vec3) { return Math.max(v.x, Math.max(v.y, v.z)); } + diff --git a/cocos/physics/spec/i-physics-shape.ts b/cocos/physics/spec/i-physics-shape.ts index 09d1867846..0c50ad4989 100644 --- a/cocos/physics/spec/i-physics-shape.ts +++ b/cocos/physics/spec/i-physics-shape.ts @@ -19,3 +19,8 @@ export interface ISphereShape extends IBaseShape { radius: number; } +export interface ICapsuleShape extends IBaseShape { + radius: number; + height: number; + direction: number; +} \ No newline at end of file