CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

完善shapeCollision 支持多边形

Browse Source
This commit is contained in:
YHH
2020-06-16 00:04:28 +08:00
parent 5186bc0187
commit dba43b9773
22 changed files with 872 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/src/ECS/Component.ts
View File

@@ -29,7 +29,9 @@ abstract class Component {
return this;
}
public abstract initialize();
public initialize(){
}
public onAddedToEntity(){

33
source/src/ECS/Components/Physics/Colliders/Collider.ts
View File

@@ -3,7 +3,10 @@ abstract class Collider extends Component{
public physicsLayer = 1 << 0;
public isTrigger: boolean;
public registeredPhysicsBounds: Rectangle;
public shouldColliderScaleAndRotationWithTransform = true;
public collidesWithLayers = Physics.allLayers;
public _localOffsetLength: number;
protected _isParentEntityAddedToScene;
protected _isPositionDirty = true;
protected _isRotationDirty = true;
@@ -32,6 +35,7 @@ abstract class Collider extends Component{
if (this._localOffset != offset){
this.unregisterColliderWithPhysicsSystem();
this._localOffset = offset;
this._localOffsetLength = this._localOffset.length();
this._isPositionDirty = true;
this.registerColliderWithPhysicsSystem();
}
@@ -51,6 +55,33 @@ abstract class Collider extends Component{
this._isColliderRegisterd = false;
}
public initialize() {
public overlaps(other: Collider){
return this.shape.overlaps(other.shape);
}
public onEntityTransformChanged(comp: ComponentTransform){
switch (comp){
case ComponentTransform.position:
this._isPositionDirty = true;
break;
case ComponentTransform.scale:
this._isPositionDirty = true;
break;
case ComponentTransform.rotation:
this._isRotationDirty = true;
break;
}
if (this._isColliderRegisterd)
Physics.updateCollider(this);
}
public onEnabled(){
this.registerColliderWithPhysicsSystem();
this._isPositionDirty = this._isRotationDirty = true;
}
public onDisabled(){
this.unregisterColliderWithPhysicsSystem();
}
}

4
source/src/ECS/Components/Physics/ITriggerListener.ts Normal file
View File

@@ -0,0 +1,4 @@
interface ITriggerListener {
onTriggerEnter(other: Collider, local: Collider);
onTriggerExit(other: Collider, local: Collider);
}

4
source/src/ECS/Entity.ts
View File

@@ -212,6 +212,10 @@ class Entity {
return this.components.getComponent(type, false) as T;
}
public getComponents<T extends Component>(type): T[]{
return this.components.getComponents<T>(type);
}
public removeComponentForType<T extends Component>(type){
let comp = this.getComponent<T>(type);
if (comp){

17
source/src/ECS/Utils/ComponentList.ts
View File

@@ -120,6 +120,23 @@ class ComponentList {
return null;
}
public getComponents<T extends Component>(type): T[]{
let components = [];
for (let i = 0; i < this._components.length; i ++){
let component = this._components[i];
if (component instanceof type)
components.push(components);
}
for (let i = 0; i < this._componentsToAdd.length; i ++){
let component = this._componentsToAdd[i];
if (component instanceof type)
components.push(components);
}
return components;
}
public update(){
this.updateLists();
for (let i = 0; i < this._components.length; i ++){

9
source/src/Math/MathHelper.ts
View File

@@ -1,4 +1,8 @@
class MathHelper {
public static readonly Epsilon: number = 0.00001;
public static readonly Rad2Deg = 57.29578;
public static readonly Deg2Rad = 0.0174532924;
/**
* 将弧度转换成角度。
* @param radians 用弧度表示的角
@@ -48,4 +52,9 @@ class MathHelper {
public static maxOf(a: number, b: number, c: number, d: number){
return Math.max(a, Math.max(b, Math.max(c, d)));
}
public static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number){
let radians = MathHelper.toRadians(angleInDegrees);
return new Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
}
}

28
source/src/Math/Vector2.ts
View File

@@ -3,6 +3,26 @@ class Vector2 {
public x: number = 0;
public y: number = 0;
private static readonly unitYVector = new Vector2(0, 1);
private static readonly unitXVector = new Vector2(1, 0);
private static readonly unitVector2 = new Vector2(1, 1);
private static readonly zeroVector2 = new Vector2(0, 0);
public static get zero(){
return Vector2.zeroVector2;
}
public static get one(){
return Vector2.unitVector2;
}
public static get unitX(){
return Vector2.unitXVector;
}
public static get unitY(){
return Vector2.unitYVector;
}
/**
* 从两个值构造一个带有X和Y的二维向量。
* @param x 二维空间中的x坐标
@@ -90,4 +110,12 @@ class Vector2 {
let v1 = value1.x - value2.x, v2 = value1.y - value2.y;
return Math.sqrt((v1 * v1) + (v2 * v2));
}
public static negate(value: Vector2){
let result: Vector2 = new Vector2();
result.x = -value.x;
result.y = -value.y;
return result;
}
}

21
source/src/Physics/ColliderTriggerHelper.ts Normal file
View File

@@ -0,0 +1,21 @@
class ColliderTriggerHelper {
private _entity: Entity;
public update(){
let colliders = this._entity.getComponents<Collider>(Collider);
for (let i = 0; i < colliders.length; i ++){
let collider = colliders[i];
let neighbors = Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
for (let i = 0; i < neighbors.length; i ++){
let neighbor = neighbors[i];
if (!collider.isTrigger && !neighbor.isTrigger)
continue;
if (collider.overlaps(neighbor)){
}
}
}
}
}

45
source/src/Physics/Shapes/Circle.ts
View File

@@ -3,26 +3,26 @@ class Circle extends Shape {
public radius: number;
private _originalRadius: number;
constructor(radius: number){
constructor(radius: number) {
super();
this.radius = radius;
this._originalRadius = radius;
}
public pointCollidesWithShape(point: Vector2): CollisionResult {
return ShapeCollisions.pointToCicle(point, this);
return ShapeCollisions.pointToCircle(point, this);
}
public collidesWithShape(other: Shape): CollisionResult{
if (other instanceof Box && (other as Box).isUnrotated){
return ShapeCollisions.circleToRect(this, other as Box);
public collidesWithShape(other: Shape): CollisionResult {
if (other instanceof Box && (other as Box).isUnrotated) {
return ShapeCollisions.circleToBox(this, other);
}
if (other instanceof Circle){
// TODO CIRCLETOCIRCLE
if (other instanceof Circle) {
return ShapeCollisions.circleToCircle(this, other);
}
if (other instanceof Polygon){
if (other instanceof Polygon) {
return ShapeCollisions.circleToPolygon(this, other);
}
@@ -31,5 +31,34 @@ class Circle extends Shape {
public recalculateBounds(collider: Collider) {
this.center = collider.localOffset;
if (collider.shouldColliderScaleAndRotationWithTransform) {
let scale = collider.entity.transform.scale;
let hasUnitScale = scale.x == 1 && scale.y == 1;
let maxScale = Math.max(scale.x, scale.y);
this.radius = this._originalRadius * maxScale;
if (collider.entity.transform.rotation != 0) {
let offsetAngle = Math.atan2(collider.localOffset.y, collider.localOffset.x) * MathHelper.Rad2Deg;
let offsetLength = hasUnitScale ? collider._localOffsetLength : (Vector2.multiply(collider.localOffset, collider.entity.transform.scale)).length();
this.center = MathHelper.pointOnCirlce(Vector2.zero, offsetLength, collider.entity.transform.rotationDegrees + offsetAngle);
}
}
this.position = Vector2.add(collider.entity.transform.position, this.center);
this.bounds = new Rectangle(this.position.x - this.radius, this.position.y - this.radius, this.radius * 2, this.radius * 2);
}
public overlaps(other: Shape){
if (other instanceof Box && (other as Box).isUnrotated)
return Collisions.isRectToCircle(other.bounds, this.position, this.radius);
if (other instanceof Circle)
return Collisions.isCircleToCircle(this.position, this.radius, other.position, (other as Circle).radius);
if (other instanceof Polygon)
return ShapeCollisions.circleToPolygon(this, other);
throw new Error(`overlaps of circle to ${other} are not supported`);
}
}

5
source/src/Physics/Shapes/CollisionResult.ts
View File

@@ -2,4 +2,9 @@ class CollisionResult {
public minimumTranslationVector: Vector2;
public normal: Vector2;
public point: Vector2;
public invertResult(){
this.minimumTranslationVector = Vector2.negate(this.minimumTranslationVector);
this.normal = Vector2.negate(this.normal);
}
}

18
source/src/Physics/Shapes/Polygon.ts
View File

@@ -56,6 +56,24 @@ class Polygon extends Shape {
this._areEdgeNormalsDirty = true;
}
public overlaps(other: Shape){
let result: CollisionResult;
if (other instanceof Polygon)
return ShapeCollisions.polygonToPolygon(this, other);
if (other instanceof Circle){
result = ShapeCollisions.circleToPolygon(other, this);
if (result){
result.invertResult();
return true;
}
return false;
}
throw new Error(`overlaps of Pologon to ${other} are not supported`);
}
public static findPolygonCenter(points: Vector2[]) {
let x = 0, y = 0;

1
source/src/Physics/Shapes/Shape.ts
View File

@@ -5,4 +5,5 @@ abstract class Shape {
public abstract recalculateBounds(collider: Collider);
public abstract pointCollidesWithShape(point: Vector2): CollisionResult;
public abstract overlaps(other: Shape);
}

150
source/src/Physics/Shapes/ShapeCollisions/ShapeCollisions.ts
View File

@@ -1,5 +1,5 @@
class ShapeCollisions {
public static polygonToPolygon(first: Polygon, second: Polygon){
public static polygonToPolygon(first: Polygon, second: Polygon) {
let result = new CollisionResult();
let isIntersecting = true;
@@ -9,9 +9,9 @@ class ShapeCollisions {
let translationAxis = new Vector2();
let polygonOffset = Vector2.subtract(first.position, second.position);
let axis: Vector2;
for (let edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex ++){
if (edgeIndex < firstEdges.length){
for (let edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
if (edgeIndex < firstEdges.length) {
axis = firstEdges[edgeIndex];
} else {
axis = secondEdges[edgeIndex - firstEdges.length];
@@ -22,72 +22,130 @@ class ShapeCollisions {
let maxA = 0;
let maxB = 0;
let intervalDist = 0;
this.getInterval(axis, first, minA, maxA);
this.getInterval(axis, second, minB, maxB);
let ta = this.getInterval(axis, first, minA, maxA);
minA = ta.min;
minB = ta.max;
let tb = this.getInterval(axis, second, minB, maxB);
minB = tb.min;
maxB = tb.max;
let relativeIntervalOffset = Vector2.dot(polygonOffset, axis);
minA += relativeIntervalOffset;
maxA += relativeIntervalOffset;
intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
if (intervalDist > 0)
isIntersecting = false;
if (!isIntersecting)
return null;
intervalDist = Math.abs(intervalDist);
if (intervalDist < minIntervalDistance) {
minIntervalDistance = intervalDist;
translationAxis = axis;
if (Vector2.dot(translationAxis, polygonOffset) < 0)
translationAxis = new Vector2(-translationAxis);
}
}
result.normal = translationAxis;
result.minimumTranslationVector = Vector2.multiply(new Vector2(-translationAxis), new Vector2(minIntervalDistance));
return result;
}
public static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number){
public static intervalDistance(minA: number, maxA: number, minB: number, maxB) {
if (minA < minB)
return minB - maxA;
return minA - minB;
}
public static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number) {
let dot = Vector2.dot(polygon.points[0], axis);
min = max = dot;
for (let i = 1; i < polygon.points.length; i++){
for (let i = 1; i < polygon.points.length; i++) {
dot = Vector2.dot(polygon.points[i], axis);
if (dot < min){
if (dot < min) {
min = dot;
}else if(dot > max){
} else if (dot > max) {
max = dot;
}
}
return { min: min, max: max };
}
public static circleToPolygon(circle: Circle, polygon: Polygon){
public static circleToPolygon(circle: Circle, polygon: Polygon) {
let result = new CollisionResult();
let poly2Circle = Vector2.subtract(circle.position, polygon.position);
let gpp = Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
let closestPoint = gpp.closestPoint;
let closestPoint: Vector2 = gpp.closestPoint;
let distanceSquared: number = gpp.distanceSquared;
result.normal = gpp.edgeNormal;
let circleCenterInsidePoly = polygon.containsPoint(circle.position);
if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
return result;
return null;
let mtv: Vector2;
if (circleCenterInsidePoly){
mtv = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared) - circle.radius, Math.sqrt(distanceSquared) - circle.radius));
}else{
if (distanceSquared == 0){
mtv = Vector2.multiply(result.normal, new Vector2(circle.radius, circle.radius));
}else{
if (circleCenterInsidePoly) {
mtv = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared) - circle.radius));
} else {
if (distanceSquared == 0) {
mtv = Vector2.multiply(result.normal, new Vector2(circle.radius));
} else {
let distance = Math.sqrt(distanceSquared);
// mtv = Vector2.multiply( -Vector2.subtract(poly2Circle, closestPoint), new Vector2((circle.radius - distanceSquared) / distance))
mtv = Vector2.multiply(new Vector2(-Vector2.subtract(poly2Circle, closestPoint)), new Vector2((circle.radius - distanceSquared) / distance));
}
}
}
public static circleToRect(circle: Circle, box: Box): CollisionResult{
let result = new CollisionResult();
let closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
if (box.containsPoint(circle.position)){
result.point = closestPointOnBounds;
let safePlace = Vector2.add(closestPointOnBounds, Vector2.subtract(result.normal, new Vector2(circle.radius, circle.radius)));
}
result.minimumTranslationVector = mtv;
result.point = Vector2.add(closestPoint, polygon.position);
return result;
}
public static pointToCicle(point: Vector2, circle: Circle){
public static circleToBox(circle: Circle, box: Box): CollisionResult {
let result = new CollisionResult();
let closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
if (box.containsPoint(circle.position)) {
result.point = closestPointOnBounds;
let safePlace = Vector2.add(closestPointOnBounds, Vector2.subtract(result.normal, new Vector2(circle.radius)));
result.minimumTranslationVector = Vector2.subtract(circle.position, safePlace);
return result;
}
let sqrDistance = Vector2.distanceSquared(closestPointOnBounds, circle.position);
if (sqrDistance == 0) {
result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(circle.radius));
} else if (sqrDistance <= circle.radius * circle.radius) {
result.normal = Vector2.subtract(circle.position, closestPointOnBounds);
let depth = result.normal.length() - circle.radius;
result.normal = Vector2Ext.normalize(result.normal);
result.minimumTranslationVector = Vector2.multiply(new Vector2(depth), result.normal);
return result;
}
return null;
}
public static pointToCircle(point: Vector2, circle: Circle) {
let result = new CollisionResult();
let distanceSquared = Vector2.distanceSquared(point, circle.position);
let sumOfRadii = 1 + circle.radius;
let collided = distanceSquared < sumOfRadii * sumOfRadii;
if (collided){
if (collided) {
result.normal = Vector2.normalize(Vector2.subtract(point, circle.position));
let depth = sumOfRadii - Math.sqrt(distanceSquared);
result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth, -depth), result.normal);
@@ -96,10 +154,10 @@ class ShapeCollisions {
return result;
}
return result;
return null;
}
public static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2){
public static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2) {
let v = Vector2.subtract(lineB, lineA);
let w = Vector2.subtract(closestTo, lineA);
let t = Vector2.dot(w, v) / Vector2.dot(v, v);
@@ -108,10 +166,10 @@ class ShapeCollisions {
return Vector2.add(lineA, Vector2.multiply(v, new Vector2(t, t)));
}
public static pointToPoly(point: Vector2, poly: Polygon){
public static pointToPoly(point: Vector2, poly: Polygon) {
let result = new CollisionResult();
if (poly.containsPoint(point)){
if (poly.containsPoint(point)) {
let distanceSquared: number;
let gpp = Polygon.getClosestPointOnPolygonToPoint(poly.points, Vector2.subtract(point, poly.position));
let closestPoint = gpp.closestPoint;
@@ -124,6 +182,24 @@ class ShapeCollisions {
return result;
}
return result;
return null;
}
public static circleToCircle(first: Circle, second: Circle){
let result = new CollisionResult();
let distanceSquared = Vector2.distanceSquared(first.position, second.position);
let sumOfRadii = first.radius + second.radius;
let collided = distanceSquared < sumOfRadii * sumOfRadii;
if (collided){
result.normal = Vector2.normalize(Vector2.subtract(first.position, second.position));
let depth = sumOfRadii - Math.sqrt(distanceSquared);
result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth), result.normal);
result.point = Vector2.add(second.position, Vector2.multiply(result.normal, new Vector2(second.radius)));
return result;
}
return null;
}
}

16
source/src/Utils/Vector2Ext.ts
View File

@@ -26,4 +26,20 @@ class Vector2Ext {
public static perpendicular(first: Vector2, second: Vector2){
return new Vector2(-1 * (second.y - first.y), second.x - first.x);
}
/**
* Vector2的临时解决方案
* 标准化把向量弄乱了
* @param vec
*/
public static normalize(vec: Vector2){
let magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
if (magnitude > MathHelper.Epsilon){
vec = Vector2.divide(vec, new Vector2(magnitude));
} else {
vec.x = vec.y = 0;
}
return vec;
}
}