restructure physics (#3985)

This commit is contained in:
Leslie Leigh
2019-03-08 11:30:14 +08:00
committed by Weiliang Wang
parent 504990d19f
commit b7869b595d
16 changed files with 1030 additions and 671 deletions
-10
View File
@@ -1,7 +1,6 @@
// @ts-check
import CANNON from 'cannon';
import { Asset } from '../../../assets/asset';
import { ccclass, property } from '../../../core/data/class-decorator';
@@ -13,8 +12,6 @@ export class PhysicsMaterial extends Asset {
@property
public _restitution = -1;
private _cannonMaterial: CANNON.Material;
/**
* Friction for this material.
* If non-negative, it will be used instead of the friction given by ContactMaterials.
@@ -26,7 +23,6 @@ export class PhysicsMaterial extends Asset {
set friction (value) {
this._friction = value;
this._cannonMaterial.friction = value;
}
/**
@@ -40,16 +36,10 @@ export class PhysicsMaterial extends Asset {
set restitution (value) {
this._restitution = value;
this._cannonMaterial.restitution = value;
}
constructor () {
super();
this._cannonMaterial = new CANNON.Material('');
}
public _getImpl () {
return this._cannonMaterial;
}
}
cc.PhysicsMaterial = PhysicsMaterial;
@@ -7,9 +7,13 @@ import {
} from '../../../core/data/class-decorator';
import Vec3 from '../../../core/value-types/vec3';
import { vec3 } from '../../../core/vmath';
import { BoxShapeBase, ShapeBase, SphereShapeBase } from '../../physics/api';
import { createBoxShape, createSphereShape } from '../../physics/instance';
import { PhysicsBasedComponent } from './detail/physics-based-component';
export class ColliderComponentBase extends PhysicsBasedComponent {
protected _shapeBase: ShapeBase | null = null;
/**
* The center of the collider, in local space.
*/
@@ -20,9 +24,7 @@ export class ColliderComponentBase extends PhysicsBasedComponent {
set center (value: Vec3) {
vec3.copy(this._center, value);
if (this.sharedBody) {
this.sharedBody.updateCollidier(this);
}
this._shapeBase!.setCenter(this._center);
}
@property
@@ -38,16 +40,16 @@ export class ColliderComponentBase extends PhysicsBasedComponent {
}
public onEnable () {
this.sharedBody!.addCollider(this);
this.sharedBody!.body.addShape(this._shapeBase!);
}
public onDisable () {
this.sharedBody!.removeCollider(this);
this.sharedBody!.body.removeShape(this._shapeBase!);
}
public destroy () {
if (this.sharedBody) {
this.sharedBody.removeCollider(this);
this.sharedBody.body.removeShape(this._shapeBase!);
}
super.destroy();
}
@@ -61,8 +63,12 @@ export class BoxColliderComponent extends ColliderComponentBase {
@property
private _size: Vec3 = new Vec3(0, 0, 0);
private _shape: BoxShapeBase;
constructor () {
super();
this._shape = createBoxShape(this._size);
this._shapeBase = this._shape;
}
public onLoad () {
@@ -81,8 +87,9 @@ export class BoxColliderComponent extends ColliderComponentBase {
set size (value) {
vec3.copy(this._size, value);
this._shape.setSize(this._size);
if (this.sharedBody) {
this.sharedBody.updateCollidier(this);
this.sharedBody.body.commitShapeUpdates();
}
}
}
@@ -95,8 +102,12 @@ export class SphereColliderComponent extends ColliderComponentBase {
@property
private _radius: number = 0;
private _shape: SphereShapeBase;
constructor () {
super();
this._shape = createSphereShape(this._radius);
this._shapeBase = this._shape;
}
public onLoad () {
@@ -114,8 +125,9 @@ export class SphereColliderComponent extends ColliderComponentBase {
set radius (value) {
this._radius = value;
this._shape.setRadius(value);
if (this.sharedBody) {
this.sharedBody.updateCollidier(this);
this.sharedBody.body.commitShapeUpdates();
}
}
}
-149
View File
@@ -1,149 +0,0 @@
import CANNON from 'cannon';
import { Vec3 } from '../../../core/value-types';
import { PhysicsBody } from './body';
import { getWrap, setWrap, toCannonVec3 } from './util';
/**
* Constraint options.
*/
export interface IConstraintOptions {
/**
* Set to true if you want the bodies to collide when they are connected.
* @default true
*/
collideConnected?: boolean;
/**
* @default true
*/
wakeUpBodies?: boolean;
}
/**
* Base class for Constraint classes.
*/
export class Constraint {
protected _cannonConstraint: CANNON.Constraint;
/**
* @param first The first body.
* @param second The second body.
* @param options Options.
*/
protected constructor (cannonConstraint: CANNON.Constraint) {
this._cannonConstraint = cannonConstraint;
setWrap<Constraint>(this._cannonConstraint, this);
}
get first () {
return getWrap<PhysicsBody>(this._cannonConstraint.bodyA);
}
get second () {
return getWrap<PhysicsBody>(this._cannonConstraint.bodyB);
}
public enable () {
this._cannonConstraint.enable();
}
public disable () {
this._cannonConstraint.disable();
}
public update () {
this._cannonConstraint.update();
}
public _getImpl () {
return this._cannonConstraint;
}
}
/**
* DistanceConstraint options.
*/
export interface IDistanceConstraintOptions {
/**
* The maximum force that should be applied to constrain the bodies.
*/
maxForce?: number;
}
/**
* Constrains two bodies to be at a constant distance from each others center of mass.
*/
export class DistanceConstraint extends Constraint {
/**
* @param first The first body.
* @param second The second body.
* @param distance The distance to keep. If undefined, it will be set to the current distance between bodyA and bodyB.
* @param options Options.
*/
constructor (first: PhysicsBody, second: PhysicsBody, distance?: number, options?: IDistanceConstraintOptions) {
super(new CANNON.DistanceConstraint(
first._getCannonBody(),
second._getCannonBody(),
distance!,
options === undefined ? undefined : options.maxForce));
}
}
/**
* PointToPointConstraint options.
*/
export interface IPointToPointConstraintOptions {
/**
* The maximum force that should be applied to constrain the bodies.
*/
maxForce?: number;
}
/**
* Connects two bodies at given offset points.
*/
export class PointToPointConstraint extends Constraint {
/**
* @param first The first body.
* @param firstPivot The point relative to the center of mass of the first body which the first body is constrained to.
* @param second The second body.
* @param secondPivot The point relative to the center of mass of the second body which the second body is constrained to.
* @param options Options.
*/
constructor (first: PhysicsBody, firstPivot: Vec3, second: PhysicsBody, secondPivot: Vec3, options?: IPointToPointConstraintOptions) {
super(new CANNON.PointToPointConstraint(
first._getCannonBody(),
toCannonVec3(firstPivot),
second._getCannonBody(),
toCannonVec3(secondPivot),
options === undefined ? undefined : options.maxForce));
}
}
/**
* LockConstraint options.
*/
export interface ILockConstraintOptions {
/**
* The maximum force that should be applied to constrain the bodies.
*/
maxForce?: number;
}
/**
* The Lock constraint will remove all degrees of freedom between the bodies.
*/
export class LockConstraint extends Constraint {
/**
* @param first The first body.
* @param second The second body.
* @param options Options.
*/
constructor (first: PhysicsBody, second: PhysicsBody, options?: ILockConstraintOptions) {
super(new CANNON.LockConstraint(
first._getCannonBody(),
second._getCannonBody(),
options));
}
}
@@ -1,90 +0,0 @@
import CANNON from 'cannon';
import { PhysicsMaterial } from '../../assets/physics/material';
export class ContactMaterial {
private _cannonContactMaterial: CANNON.ContactMaterial;
constructor (lhs: PhysicsMaterial, rhs: PhysicsMaterial) {
const opts: CANNON.IContactMaterialOptions = {
friction: 0.3,
restitution: 0.3,
contactEquationStiffness: 1e7,
contactEquationRelaxation: 3,
frictionEquationStiffness: 1e7,
frictionEquationRelaxation: 3,
};
this._cannonContactMaterial = new CANNON.ContactMaterial(lhs._getImpl(), rhs._getImpl(), opts);
}
/**
* Friction coefficient. Default value 0.3.
*/
get friction () {
return this._cannonContactMaterial.friction;
}
set friction (value) {
this._cannonContactMaterial.friction = value;
}
/**
* Restitution coefficient. Default value 0.3.
*/
get restitution () {
return this._cannonContactMaterial.restitution;
}
set restitution (value) {
this._cannonContactMaterial.restitution = value;
}
/**
* Stiffness of the produced contact equations. Default value 1e7.
*/
get contactEquationStiffness () {
return this._cannonContactMaterial.contactEquationStiffness;
}
set contactEquationStiffness (value) {
this._cannonContactMaterial.contactEquationStiffness = value;
}
/**
* Relaxation time of the produced contact equations. Default value 0.3.
*/
get contactEquationRelaxation () {
return this._cannonContactMaterial.contactEquationRelaxation;
}
set contactEquationRelaxation (value) {
this._cannonContactMaterial.contactEquationRelaxation = value;
}
/**
* Stiffness of the produced friction equations. Default value 1e7.
*/
get frictionEquationStiffness () {
return this._cannonContactMaterial.frictionEquationStiffness;
}
set frictionEquationStiffness (value) {
this._cannonContactMaterial.frictionEquationStiffness = value;
}
/**
* Relaxation time of the produced friction equations. Default value 3.
*/
get frictionEquationRelaxation () {
return this._cannonContactMaterial.frictionEquationRelaxation;
}
set frictionEquationRelaxation (value) {
this._cannonContactMaterial.frictionEquationRelaxation = value;
}
public _getImpl () {
return this._cannonContactMaterial;
}
}
cc.ContactMaterial = ContactMaterial;
@@ -1,13 +1,10 @@
import CANNON from 'cannon';
import { Component } from '../../../../components/component';
import { ccclass } from '../../../../core/data/class-decorator';
import { Quat, Vec3 } from '../../../../core/value-types';
import { quat, vec3 } from '../../../../core/vmath';
import { Node } from '../../../../scene-graph/node';
import { BoxColliderComponent, ColliderComponentBase, SphereColliderComponent } from '../collider-component';
import { DefaultPhysicsMaterial } from '../default-material';
import { getWrap, setWrap } from '../util';
import { PhysicsWorld } from '../world';
import { AfterStepCallback, BeforeStepCallback, ICollisionCallback, ICollisionEvent, PhysicsWorldBase, RigidBodyBase } from '../../../physics/api';
import { createRigidBody } from '../../../physics/instance';
export class PhysicsBasedComponent extends Component {
@@ -26,11 +23,6 @@ export class PhysicsBasedComponent extends Component {
public onLoad () {
this._refSharedBody();
this._sharedBody!.syncPhysWithScene();
}
public start () {
this._sharedBody!.syncPhysWithScene();
}
public destroy () {
@@ -42,7 +34,7 @@ export class PhysicsBasedComponent extends Component {
public syncPhysWithScene () {
if (this.sharedBody) {
this.sharedBody.syncPhysWithScene();
this.sharedBody.syncPhysWithScene(this.node);
}
}
@@ -66,79 +58,42 @@ export class PhysicsBasedComponent extends Component {
}
}
export enum TransformSource {
Scene,
Phycis,
}
type Collider = ColliderComponentBase;
function isBoxCollider (collider: Collider): collider is BoxColliderComponent {
return 'size' in collider;
}
function isSphereCollider (collider: Collider): collider is SphereColliderComponent {
return 'radius' in collider;
}
class SharedRigidBody {
private _body: CANNON.Body;
private _onCollidedListener: (event: CANNON.ICollisionEvent) => any;
private _cancelGravityListener: (event: CANNON.IEvent) => any;
private _onWorldBeforeStepListener: (event: CANNON.IEvent) => any;
private _onWorldPostStepListener: (event: CANNON.IEvent) => any;
private _body: RigidBodyBase;
private _refCount = 0;
private _actived = false;
private _world: PhysicsWorld;
private _world: PhysicsWorldBase;
private _node: Node;
private _transformSource: TransformSource = TransformSource.Scene;
private _colliders: Map<Collider, number> = new Map();
private _worldScale: Vec3 = new Vec3(1, 1, 1);
private _useGravity = true;
private _beforeStepCallback: BeforeStepCallback;
constructor (node: Node, world: PhysicsWorld) {
this._body = new CANNON.Body({
material: DefaultPhysicsMaterial._getImpl(),
});
private _afterStepCallback: AfterStepCallback;
private _onCollidedCallback: ICollisionCallback;
private _transformInitialized: boolean = false;
constructor (node: Node, world: PhysicsWorldBase) {
this._body = createRigidBody();
this._node = node;
setWrap<Node>(this._body, this._node);
this._world = world;
this._onCollidedListener = this._onCollided.bind(this);
this._onWorldBeforeStepListener = this._onWorldBeforeStep.bind(this);
this._onWorldPostStepListener = this._onWorldPostStep.bind(this);
this._cancelGravityListener = (event) => {
if (!this._useGravity && this._body) {
const gravity = this._body.world.gravity;
vec3.scaleAndAdd(this._body.force, this._body.force, gravity, this._body.mass * -1);
}
};
this._body.setUserData(this._node);
this._beforeStepCallback = this._beforeStep.bind(this);
this._afterStepCallback = this._afterStep.bind(this);
this._onCollidedCallback = this._onCollided.bind(this);
this._body.addCollisionCallback(this._onCollidedCallback);
}
public get body () {
return this._body;
}
public get transformSource () {
return this._transformSource;
}
public set transformSource (value) {
this._transformSource = value;
}
public ref () {
if (!this._refCount) {
this._activeBody();
@@ -161,66 +116,18 @@ class SharedRigidBody {
this._deactiveBody();
}
public addCollider (collider: Collider) {
let shape: CANNON.Shape | undefined;
if (isBoxCollider(collider)) {
shape = new CANNON.Box(new CANNON.Vec3());
} else if (isSphereCollider(collider)) {
shape = new CANNON.Sphere(0);
}
if (!shape) {
return;
}
setWrap(shape, collider);
const ishape = this.body.shapes.length;
this.body.addShape(shape);
this._colliders.set(collider, ishape);
this.updateCollidier(collider);
}
public syncPhysWithScene (node: Node) {
const p = node.getWorldPosition();
const r = node.getWorldRotation();
console.log(`Set ${node.name} pos to ${p.x}, ${p.y}, ${p.z}, rot to ${r.x}, ${r.y}, ${r.z}, ${r.w}`);
public updateCollidier (collider: Collider) {
const ishape = this._colliders.get(collider);
if (ishape === undefined) {
return;
}
if (isBoxCollider(collider)) {
const shape = this.body.shapes[ishape] as CANNON.Box;
vec3.scale(shape.halfExtents, collider.size, 0.5);
vec3.multiply(shape.halfExtents, shape.halfExtents, this._worldScale);
shape.updateConvexPolyhedronRepresentation();
shape.updateBoundingSphereRadius();
} else if (isSphereCollider(collider)) {
const shape = this.body.shapes[ishape] as CANNON.Sphere;
shape.radius = collider.radius * maxComponent(this._worldScale);
shape.updateBoundingSphereRadius();
}
const center = this.body.shapeOffsets[ishape];
vec3.multiply(center, center, this._worldScale);
this.body.updateBoundingRadius();
}
public removeCollider (collider: Collider) {
const ishape = this._colliders.get(collider);
if (ishape === undefined) {
return;
}
this._colliders.delete(collider);
this._removeShape(ishape);
}
public syncPhysWithScene () {
vec3.copy(this._body.position, this._node.getWorldPosition());
quat.copy(this._body.quaternion, this._node.getWorldRotation());
this.body.setPosition(p);
this.body.setRotation(r);
// Because we sync the scale, we should update shape parameters.
this._node.getWorldScale(this._worldScale);
this._colliders.forEach((shape, collider) => {
this.updateCollidier(collider);
});
}
public setUseGravity (value: boolean) {
this._useGravity = value;
node.getWorldScale(this._worldScale);
this.body.scaleAllShapes(this._worldScale);
this.body.commitShapeUpdates();
}
/**
@@ -231,10 +138,12 @@ class SharedRigidBody {
return;
}
const p = this._body.position;
const p = new Vec3();
this.body.getPosition(p);
this._node.setWorldPosition(p.x, p.y, p.z);
if (!this._body.fixedRotation) {
const q = this._body.quaternion;
if (!this._body.getFreezeRotation()) {
const q = new Quat();
this.body.getRotation(q);
this._node.setWorldRotation(q.x, q.y, q.z, q.w);
}
}
@@ -244,11 +153,9 @@ class SharedRigidBody {
return;
}
this._actived = true;
this._world.addBody(this._body);
this._body.addEventListener('collide', this._onCollidedListener);
this._body.world.addEventListener('beforeStep', this._onWorldBeforeStepListener);
this._body.world.addEventListener('postStep', this._onWorldPostStepListener);
this._body.world.addEventListener('beforeStep', this._cancelGravityListener);
this._body.setWorld(this._world);
this._world.addBeforeStep(this._beforeStepCallback);
this._world.addAfterStep(this._afterStepCallback);
}
private _deactiveBody () {
@@ -256,48 +163,31 @@ class SharedRigidBody {
return;
}
this._actived = false;
this._body.removeEventListener('collide', this._onCollidedListener);
this._body.world.removeEventListener('postStep', this._onWorldPostStepListener);
this._body.world.removeEventListener('beforeStep', this._onWorldBeforeStepListener);
this._body.world.removeEventListener('beforeStep', this._cancelGravityListener);
this._world.removeBody(this._body);
this._world.removeAfterStep(this._afterStepCallback);
this._world.removeBeforeStep(this._beforeStepCallback);
this._body.setWorld(null);
}
private _onCollided (event: CANNON.ICollisionEvent) {
private _onCollided (event: ICollisionEvent) {
if (!this._node) {
return;
}
this._node.emit('collided', {
source: getWrap<Node>(event.body),
target: getWrap<Node>((event as any).target),
source: event.source.getUserData() as Node,
target: event.target.getUserData() as Node,
});
}
private _onWorldBeforeStep (event: CANNON.IEvent) {
// if (this._transformSource === TransformSource.Scene) {
// this.syncPhysWithScene();
// }
}
private _onWorldPostStep (event: CANNON.IEvent) {
if (this._transformSource === TransformSource.Phycis) {
this._syncSceneWithPhys();
private _beforeStep () {
if (!this._transformInitialized) {
this._transformInitialized = true;
this.syncPhysWithScene(this._node);
}
}
private _removeShape (iShape: number) {
const body = this._body;
const shape = body.shapes[iShape];
body.shapes.splice(iShape, 1);
body.shapeOffsets.splice(iShape, 1);
body.shapeOrientations.splice(iShape, 1);
body.updateMassProperties();
body.updateBoundingRadius();
body.aabbNeedsUpdate = true;
(shape as any).body = null;
private _afterStep () {
if (this.body.shouldRender()) {
this._syncSceneWithPhys();
}
}
}
function maxComponent (v: Vec3) {
return Math.max(v.x, Math.max(v.y, v.z));
}
-2
View File
@@ -1,3 +1 @@
export { ContactMaterial } from './contact-material';
export * from './physics-system';
export * from './world';
+4 -3
View File
@@ -1,10 +1,11 @@
import { PhysicsWorld } from './world';
import { PhysicsWorldBase } from '../../physics/api';
import { createPhysicsWorld } from '../../physics/instance';
export class PhysicsSystem {
private _world: PhysicsWorld;
private _world: PhysicsWorldBase;
constructor () {
this._world = new PhysicsWorld();
this._world = createPhysicsWorld();
}
public update (deltaTime: number) {
@@ -1,5 +1,4 @@
import CANNON from 'cannon';
import {
ccclass,
executeInEditMode,
@@ -11,8 +10,7 @@ import { Quat, Vec3 } from '../../../core/value-types';
import { vec3 } from '../../../core/vmath';
import { PhysicsMaterial } from '../../assets/physics/material';
import { DefaultPhysicsMaterial as DefaultPhysicsMaterial } from './default-material';
import { PhysicsBasedComponent, TransformSource } from './detail/physics-based-component';
import { toCannonVec3 } from './util';
import { PhysicsBasedComponent } from './detail/physics-based-component';
const NonRigidBodyProperties = {
mass: 0,
@@ -65,15 +63,15 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
this.angularDamping = this._angularDamping;
this.material = this._material;
this.useGravity = this._useGravity;
if (this.sharedBody) {
this.sharedBody.body.wakeUp();
}
// if (this.sharedBody) {
// this.sharedBody.body.wakeUp();
// }
}
public onDisable () {
if (this.sharedBody) {
this.sharedBody.body.sleep();
}
// if (this.sharedBody) {
// this.sharedBody.body.sleep();
// }
}
@property({
@@ -85,9 +83,9 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set material (value) {
this._material = value;
if (this._body) {
this._body.material = (this._material || DefaultPhysicsMaterial)._getImpl();
}
// if (this._body) {
// this._body.material = (this._material || DefaultPhysicsMaterial)._getImpl();
// }
}
@property
@@ -98,12 +96,7 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set mass (value) {
this._mass = value;
if (this._body) {
this._body.mass = value;
this._body.updateMassProperties();
if (this._body.type !== CANNON.Body.KINEMATIC) {
this._resetBodyTypeAccordingMess();
this._onBodyTypeUpdated();
}
this._body.setMass(value);
}
}
@@ -115,12 +108,7 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set isKinematic (value) {
this._isKinematic = value;
if (this._body) {
if (value) {
this._body.type = CANNON.Body.KINEMATIC;
} else {
this._resetBodyTypeAccordingMess();
}
this._onBodyTypeUpdated();
this._body.setIsKinematic(value);
}
}
@@ -131,8 +119,8 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set useGravity (value) {
this._useGravity = value;
if (this.sharedBody) {
this.sharedBody.setUseGravity(value);
if (this._body) {
this._body.setUseGravity(value);
}
}
@@ -144,7 +132,7 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set linearDamping (value) {
this._linearDamping = value;
if (this._body) {
this._body.linearDamping = value;
this._body.setLinearDamping(value);
}
}
@@ -156,7 +144,7 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set angularDamping (value) {
this._angularDamping = value;
if (this._body) {
this._body.angularDamping = value;
this._body.setAngularDamping(value);
}
}
@@ -167,8 +155,7 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set fixedRotation (value) {
this._fixedRotation = value;
if (this._body) {
this._body.fixedRotation = value;
this._body.updateMassProperties();
this._body.setFreezeRotation(!value);
}
}
@@ -179,13 +166,13 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set isTrigger (value) {
this._triggered = value;
if (this._body) {
this._body.collisionResponse = value;
this._body.setIsTrigger(value);
}
}
get velocity () {
if (this._body) {
vec3.copy(this._velocity, this._body!.velocity);
vec3.copy(this._velocity, this._body!.getVelocity());
}
return this._velocity;
}
@@ -193,64 +180,19 @@ export class RigidBodyComponent extends PhysicsBasedComponent {
set velocity (value: Vec3) {
vec3.copy(this._velocity, value);
if (this._body) {
vec3.copy(this._body.velocity, this._velocity);
this._body.setVelocity(this._velocity);
}
}
public applyForce (force: Vec3, position?: Vec3) {
if (!position) {
position = new Vec3();
vec3.copy(position, this._body!.position);
}
this._body!.applyForce(toCannonVec3(force), toCannonVec3(position));
this._body!.applyForce(force, position);
}
public applyImpulse (impulse: Vec3) {
this._body!.applyImpulse(toCannonVec3(impulse), toCannonVec3(new Vec3()));
this._body!.applyImpulse(impulse);
}
/**
* Set the collision filter of this body, remember that they are tested bitwise.
* @param {number} group The group which this body will be put into.
* @param {number} mask The groups which this body can collide with.
*/
public setCollisionFilter (group: number, mask: number) {
if (this._body) {
this._body.collisionFilterGroup = group;
this._body.collisionFilterMask = mask;
}
}
// /**
// * Is this body currently in contact with the specified body?
// * @param {CannonBody} body The body to test against.
// */
// public isInContactWith (body: PhysicsBody) {
// if (!this._cannonBody.world) {
// return false;
// }
// return this._cannonBody.world.collisionMatrix.get(
// this._cannonBody.id, body._cannonBody.id) > 0;
// }
private _resetBodyTypeAccordingMess () {
if (this._body) {
if (this.mass <= 0) {
this._body.type = CANNON.Body.STATIC;
} else {
this._body.type = CANNON.Body.DYNAMIC;
}
}
}
private _onBodyTypeUpdated () {
if (this.sharedBody) {
if (this.sharedBody.body.type === CANNON.Body.STATIC) {
this.sharedBody.transformSource = TransformSource.Scene;
} else {
this.sharedBody.transformSource = TransformSource.Phycis;
}
}
this._body!.setCollisionFilter(group, mask);
}
}
-33
View File
@@ -1,33 +0,0 @@
import CANNON from 'cannon';
import { Vec3 } from '../../../core/value-types';
export interface IWrappedCANNON<T> {
__cc_wrapper__: T;
}
export function setWrap<Wrapper> (cannonObject: any, wrapper: Wrapper) {
(cannonObject as unknown as IWrappedCANNON<Wrapper>).__cc_wrapper__ = wrapper;
}
export function getWrap<Wrapper> (cannonObject: any) {
return (cannonObject as unknown as IWrappedCANNON<Wrapper>).__cc_wrapper__;
}
export function toCannonVec3 (value: Vec3) {
return new CANNON.Vec3(value.x, value.y, value.z);
}
export function toCannonOptions<T> (options: any, optionsRename?: { [x: string]: string; }) {
const result = {};
for (const key of Object.keys(options)) {
let destKey = key;
if (optionsRename) {
const rename = optionsRename[key];
if (rename) {
destKey = rename;
}
}
result[destKey] = options[key];
}
return result as T;
}
-133
View File
@@ -1,133 +0,0 @@
import CANNON from 'cannon';
import { Component } from '../../../components/component';
import { Vec3 } from '../../../core/value-types';
import { Node } from '../../../scene-graph/node';
import { PhysicsMaterial } from '../../assets/physics/material';
import { Constraint } from './constraints';
import { ContactMaterial } from './contact-material';
import { DefaultPhysicsMaterial } from './default-material';
import { getWrap, setWrap, toCannonOptions } from './util';
export interface IRaycastOptions {
collisionFilterMask?: number;
collisionFilterGroup?: number;
queryTriggerInteraction?: boolean;
}
export class RaycastResult {
public _cannonResult: CANNON.RaycastResult = new CANNON.RaycastResult();
get hit () {
return this._cannonResult.hasHit;
}
get hitPoint () {
return this._cannonResult.hitPointWorld;
}
get distance () {
return this._cannonResult.distance;
}
get shape () {
return getWrap<Component>(this._cannonResult.shape);
}
get body () {
return getWrap<Node>(this._cannonResult.body);
}
}
cc.RaycastResult = RaycastResult;
export class PhysicsWorld {
private _cannonWorld: CANNON.World;
private _defaultContactMaterial: ContactMaterial;
private _beforeStepEvent: CANNON.IEvent = {
type: 'beforeStep',
};
constructor () {
this._defaultContactMaterial = new ContactMaterial(DefaultPhysicsMaterial, DefaultPhysicsMaterial);
this._defaultContactMaterial.friction = 0.06;
this._defaultContactMaterial.restitution = 0;
this._cannonWorld = new CANNON.World();
setWrap<PhysicsWorld>(this._cannonWorld, this);
this._cannonWorld.gravity.set(0, -9.81, 0);
this._cannonWorld.broadphase = new CANNON.NaiveBroadphase();
this._cannonWorld.defaultMaterial = DefaultPhysicsMaterial._getImpl();
this._cannonWorld.defaultContactMaterial = this._defaultContactMaterial._getImpl();
}
get defaultContactMaterial () {
return this._defaultContactMaterial;
}
public addBody (body: CANNON.Body) {
this._cannonWorld.addBody(body);
}
public removeBody (body: CANNON.Body) {
this._cannonWorld.remove(body);
}
public step (deltaTime: number) {
this._cannonWorld.dispatchEvent(this._beforeStepEvent);
this._cannonWorld.step(deltaTime);
}
/**
* Ray cast, and return information of the closest hit.
* @return True if any body was hit.
*/
public raycastClosest (from: Vec3, to: Vec3, options: IRaycastOptions, result: RaycastResult): boolean {
const hit = (this._cannonWorld as any).raycastClosest(from, to, toCannonRaycastOptions(options), result._cannonResult);
return hit;
}
/**
* Ray cast, and stop at the first result. Note that the order is random - but the method is fast.
* @return True if any body was hit.
*/
public raycastAny (from: Vec3, to: Vec3, options: IRaycastOptions, result: RaycastResult): boolean {
const hit = (this._cannonWorld as any).raycastAny(from, to, toCannonRaycastOptions(options), result._cannonResult);
return hit;
}
/**
* Ray cast against all bodies. The provided callback will be executed for each hit with a RaycastResult as single argument.
* @return True if any body was hit.
*/
public raycastAll (from: Vec3, to: Vec3, options: IRaycastOptions, callback: (result: RaycastResult) => void): boolean {
return (this._cannonWorld as any).raycastAll(from, to, toCannonRaycastOptions(options), (cannonResult: CANNON.RaycastResult) => {
const result = new RaycastResult();
result._cannonResult = cannonResult;
callback(result);
});
}
public addContactMaterial (contactMaterial: ContactMaterial) {
this._cannonWorld.addContactMaterial(contactMaterial._getImpl());
}
public addConstraint (constraint: Constraint) {
this._cannonWorld.addConstraint(constraint._getImpl());
}
public removeConstraint (constraint: Constraint) {
this._cannonWorld.removeConstraint(constraint._getImpl());
}
}
interface ICANNONRaycastOptions {
collisionFilterMask?: number;
collisionFilterGroup?: number;
checkCollisionResponse?: boolean;
skipBackfaces?: boolean;
}
function toCannonRaycastOptions (options: IRaycastOptions): ICANNONRaycastOptions {
return toCannonOptions(options, {
queryTriggerInteraction: 'checkCollisionResponse',
});
}
+2 -1
View File
@@ -27,10 +27,11 @@ export * from './assets';
export * from './builtin';
export * from './framework';
export * from './memop';
import * as geometry from './geom-utils';
import * as utils from './misc/utils';
import * as primitives from './primitive';
import * as geometry from './geom-utils';
import './ui';
export { createRaycastResult } from './physics/instance';
export {
utils,
+240
View File
@@ -0,0 +1,240 @@
import { Vec3, Quat } from '../../core/value-types';
import { Node } from '../../scene-graph';
export interface IRaycastOptions {
collisionFilterMask?: number;
collisionFilterGroup?: number;
queryTriggerInteraction?: boolean;
}
export interface ICollisionEvent {
source: RigidBodyBase;
target: RigidBodyBase;
}
export type ICollisionCallback = (event: ICollisionEvent) => void;
export type BeforeStepCallback = () => void;
export type AfterStepCallback = () => void;
export class PhysicsWorldBase {
constructor ();
step (deltaTime: number): void;
addBeforeStep (cb: BeforeStepCallback): void;
removeBeforeStep (cb: BeforeStepCallback): void;
addAfterStep (cb: AfterStepCallback): void;
removeAfterStep (cb: AfterStepCallback): void;
/**
* Ray cast, and return information of the closest hit.
* @return True if any body was hit.
*/
raycastClosest (from: Vec3, to: Vec3, options: IRaycastOptions, result: RaycastResultBase): boolean;
/**
* Ray cast, and stop at the first result. Note that the order is random - but the method is fast.
* @return True if any body was hit.
*/
raycastAny (from: Vec3, to: Vec3, options: IRaycastOptions, result: RaycastResultBase): boolean;
/**
* Ray cast against all bodies. The provided callback will be executed for each hit with a RaycastResult as single argument.
* @return True if any body was hit.
*/
raycastAll (from: Vec3, to: Vec3, options: IRaycastOptions, callback: (result: RaycastResultBase) => void): boolean;
}
export class RigidBodyBase {
constructor ();
addShape (shape: ShapeBase): void;
removeShape (shape: ShapeBase): void;
getMass (): number;
setMass (value: number): void;
applyForce (force: Vec3, position?: Vec3): void;
applyImpulse (impulse: Vec3): void;
getIsKinematic (): boolean;
setIsKinematic (value: boolean): void;
getLinearDamping (): number;
setLinearDamping (value: number): void;
getAngularDamping (): number;
setAngularDamping (value: number): void;
getUseGravity (): boolean;
setUseGravity (value: boolean): void;
getIsTrigger (): boolean;
setIsTrigger (value: boolean): void;
getVelocity (): Vec3;
setVelocity (value: Vec3): void;
getFreezeRotation (): boolean;
setFreezeRotation (value: boolean): void;
/**
* Set the collision filter of this body, remember that they are tested bitwise.
* @param group The group which this body will be put into.
* @param mask The groups which this body can collide with.
*/
setCollisionFilter (group: number, mask: number): void;
setWorld (world: PhysicsWorldBase | null): void;
commitShapeUpdates (): void;
shouldRender (): boolean;
getPosition (out: Vec3): void;
setPosition (value: Vec3): void;
getRotation (out: Quat): void;
setRotation (out: Quat): void;
scaleAllShapes (scale: Vec3): void;
addCollisionCallback (callback: ICollisionCallback): void;
removeCollisionCllback (callback: ICollisionCallback): void;
getUserData (): any;
setUserData(data: any): void;
}
export class ShapeBase {
setCenter (center: Vec3): void;
setScale (scale: Vec3): void;
setRotation (rotation: Quat): void;
}
export class SphereShapeBase extends ShapeBase {
constructor (radius: number);
setRadius (radius: number): void;
}
export class BoxShapeBase extends ShapeBase {
constructor (size: Vec3);
setSize (size: Vec3): void;
}
/**
* Base class for Constraint classes.
*/
export class ConstraintBase {
first: RigidBodyBase;
second: RigidBodyBase;
enable (): void;
disable (): void;
update (): void;
}
/**
* DistanceConstraint options.
*/
export interface IDistanceConstraintOptions {
/**
* The maximum force that should be applied to constrain the bodies.
*/
maxForce?: number;
}
/**
* Constrains two bodies to be at a constant distance from each others center of mass.
*/
export class DistanceConstraintBase extends ConstraintBase {
/**
* @param first The first body.
* @param second The second body.
* @param distance The distance to keep. If undefined, it will be set to the current distance between bodyA and bodyB.
* @param options Options.
*/
constructor (first: RigidBodyBase, second: RigidBodyBase, distance?: number, options?: IDistanceConstraintOptions);
}
/**
* PointToPointConstraint options.
*/
export interface IPointToPointConstraintOptions {
/**
* The maximum force that should be applied to constrain the bodies.
*/
maxForce?: number;
}
/**
* Connects two bodies at given offset points.
*/
export class PointToPointConstraintBase extends ConstraintBase {
/**
* @param first The first body.
* @param firstPivot The point relative to the center of mass of the first body which the first body is constrained to.
* @param second The second body.
* @param secondPivot The point relative to the center of mass of the second body which the second body is constrained to.
* @param options Options.
*/
constructor (first: RigidBodyBase, firstPivot: Vec3, second: RigidBodyBase, secondPivot: Vec3, options?: IPointToPointConstraintOptions);
}
/**
* LockConstraint options.
*/
export interface ILockConstraintOptions {
/**
* The maximum force that should be applied to constrain the bodies.
*/
maxForce?: number;
}
/**
* The Lock constraint will remove all degrees of freedom between the bodies.
*/
export class LockConstraintBase extends ConstraintBase {
/**
* @param first The first body.
* @param second The second body.
* @param options Options.
*/
constructor (first: RigidBodyBase, second: RigidBodyBase, options?: ILockConstraintOptions);
}
export class RaycastResultBase {
readonly hit: boolean;
readonly hitPoint: Vec3;
readonly distance: number;
readonly shape: ShapeBase;
readonly body: RigidBodyBase;
}
export enum TransformSource {
Scene,
Phycis,
}
+657
View File
@@ -0,0 +1,657 @@
import CANNON from 'cannon';
import { Quat, Vec3 } from '../../core/value-types';
import { quat, vec3 } from '../../core/vmath';
import { AfterStepCallback, BeforeStepCallback,
BoxShapeBase,
ConstraintBase, DistanceConstraintBase,
ICollisionCallback, ICollisionEvent,
IDistanceConstraintOptions, ILockConstraintOptions,
IPointToPointConstraintOptions,
IRaycastOptions,
LockConstraintBase, PhysicsWorldBase, PointToPointConstraintBase,
RaycastResultBase, RigidBodyBase, ShapeBase, SphereShapeBase } from './api';
const defaultCannonMaterial = new CANNON.Material('');
const defaultCannonContactMaterial = new CANNON.ContactMaterial(
defaultCannonMaterial, defaultCannonMaterial, {
friction: 0.06,
restitution: 0,
});
export class CannonWorld implements PhysicsWorldBase {
private _cannonWorld: CANNON.World;
private _beforeStepEvent: CANNON.IEvent = {
type: 'beforeStep',
};
private _customBeforeStepListener: BeforeStepCallback[] = [];
private _customAfterStepListener: AfterStepCallback[] = [];
constructor () {
this._cannonWorld = new CANNON.World();
setWrap<PhysicsWorldBase>(this._cannonWorld, this);
this._cannonWorld.gravity.set(0, -9.81, 0);
this._cannonWorld.broadphase = new CANNON.NaiveBroadphase();
this._cannonWorld.defaultMaterial = defaultCannonMaterial;
this._cannonWorld.defaultContactMaterial = defaultCannonContactMaterial;
}
get impl () {
return this._cannonWorld;
}
// get defaultContactMaterial () {
// return this._defaultContactMaterial;
// }
public step (deltaTime: number) {
this._customBeforeStepListener.forEach((fx) => fx());
this._cannonWorld.dispatchEvent(this._beforeStepEvent);
this._cannonWorld.step(deltaTime);
this._customAfterStepListener.forEach((fx) => fx());
}
public addBeforeStep (cb: BeforeStepCallback) {
this._customBeforeStepListener.push(cb);
}
public removeBeforeStep (cb: BeforeStepCallback) {
const i = this._customBeforeStepListener.indexOf(cb);
if (i < 0) {
return;
}
this._customBeforeStepListener.splice(i, 1);
}
public addAfterStep (cb: AfterStepCallback) {
this._customAfterStepListener.push(cb);
}
public removeAfterStep (cb: AfterStepCallback) {
const i = this._customAfterStepListener.indexOf(cb);
if (i < 0) {
return;
}
this._customAfterStepListener.splice(i, 1);
}
public raycastClosest (from: Vec3, to: Vec3, options: IRaycastOptions, result_: RaycastResultBase): boolean {
const result = result_ as unknown as CannonRaycastResult;
const hit = (this._cannonWorld as any).raycastClosest(from, to, toCannonRaycastOptions(options), result._cannonResult);
return hit;
}
public raycastAny (from: Vec3, to: Vec3, options: IRaycastOptions, result_: RaycastResultBase): boolean {
const result = result_ as unknown as CannonRaycastResult;
const hit = (this._cannonWorld as any).raycastAny(from, to, toCannonRaycastOptions(options), result._cannonResult);
return hit;
}
public raycastAll (from: Vec3, to: Vec3, options: IRaycastOptions, callback: (result: RaycastResultBase) => void): boolean {
return (this._cannonWorld as any).raycastAll(from, to, toCannonRaycastOptions(options), (cannonResult: CANNON.RaycastResult) => {
const result = new CannonRaycastResult();
result._cannonResult = cannonResult;
callback(result);
});
}
// public addContactMaterial (contactMaterial: ContactMaterial) {
// this._cannonWorld.addContactMaterial(contactMaterial._getImpl());
// }
public addConstraint (constraint: CannonConstraint) {
this._cannonWorld.addConstraint(constraint.impl);
}
public removeConstraint (constraint: CannonConstraint) {
this._cannonWorld.removeConstraint(constraint.impl);
}
}
enum TransformSource {
Scene,
Phycis,
}
export class CannonRigidBody implements RigidBodyBase {
get impl (): CANNON.Body {
return this._cannonBody;
}
private _cannonBody: CANNON.Body;
private _velocityResult: Vec3 = new Vec3();
private _useGravity = true;
private _cannonMaterial: CANNON.Material;
private _onCollidedListener: (event: CANNON.ICollisionEvent) => any;
private _cancelGravityListener: (event: CANNON.IEvent) => any;
private _onWorldBeforeStepListener: (event: CANNON.IEvent) => any;
private _onWorldPostStepListener: (event: CANNON.IEvent) => any;
private _collisionCallbacks: ICollisionCallback[] = [];
private _shapes: CannonShape[] = [];
private _transformSource: TransformSource = TransformSource.Scene;
private _userData: any;
constructor () {
this._cannonMaterial = defaultCannonMaterial;
this._cannonBody = new CANNON.Body({
material: this._cannonMaterial,
});
setWrap<RigidBodyBase>(this._cannonBody, this);
this._onCollidedListener = this._onCollided.bind(this);
this._onWorldBeforeStepListener = this._onWorldBeforeStep.bind(this);
this._onWorldPostStepListener = this._onWorldPostStep.bind(this);
this._cancelGravityListener = (event) => {
if (!this._useGravity) {
const gravity = this._cannonBody.world.gravity;
vec3.scaleAndAdd(this._cannonBody.force, this._cannonBody.force, gravity, this._cannonBody.mass * -1);
}
};
}
public addShape (shape: CannonShape) {
const index = this._shapes.length;
this._shapes.push(shape);
this._cannonBody.addShape(shape.impl);
shape._setBody(this._cannonBody, index);
}
public removeShape (shape: CannonShape) {
const i = this._shapes.indexOf(shape);
if (i < 0) {
return;
}
this._removeShape(i);
for (let j = i + 1; j < this._shapes.length; ++j) {
const s = this._shapes[j];
s._setIndex(j - 1);
}
this._shapes.splice(i, 1);
}
public commitShapeUpdates () {
this._cannonBody.updateBoundingRadius();
}
public getMass () {
return this._cannonBody.mass;
}
public setMass (value: number) {
this._cannonBody.mass = value;
this._cannonBody.updateMassProperties();
if (this._cannonBody.type !== CANNON.Body.KINEMATIC) {
this._resetBodyTypeAccordingMess();
this._onBodyTypeUpdated();
}
}
public getIsKinematic () {
return this._cannonBody.type === CANNON.Body.KINEMATIC;
}
public setIsKinematic (value: boolean) {
if (value) {
this._cannonBody.type = CANNON.Body.KINEMATIC;
} else {
this._resetBodyTypeAccordingMess();
}
this._onBodyTypeUpdated();
}
public getLinearDamping () {
return this._cannonBody.linearDamping;
}
public setLinearDamping (value: number) {
this._cannonBody.linearDamping = value;
}
public getAngularDamping () {
return this._cannonBody.angularDamping;
}
public setAngularDamping (value: number) {
this._cannonBody.angularDamping = value;
}
public getUseGravity (): boolean {
return this._useGravity;
}
public setUseGravity (value: boolean) {
this._useGravity = value;
}
public getIsTrigger (): boolean {
return this._cannonBody.collisionResponse;
}
public setIsTrigger (value: boolean): void {
this._cannonBody.collisionResponse = value;
}
public getVelocity (): Vec3 {
vec3.copy(this._velocityResult, this._cannonBody.velocity);
return this._velocityResult;
}
public setVelocity (value: Vec3): void {
vec3.copy(this._cannonBody.velocity, value);
}
public getFreezeRotation (): boolean {
return this._cannonBody.fixedRotation;
}
public setFreezeRotation (value: boolean) {
this._cannonBody.fixedRotation = value;
this._cannonBody.updateMassProperties();
}
public applyForce (force: Vec3, position?: Vec3) {
if (!position) {
position = new Vec3();
vec3.copy(position, this._cannonBody.position);
}
this._cannonBody.applyForce(toCannonVec3(force), toCannonVec3(position));
}
public applyImpulse (impulse: Vec3) {
this._cannonBody.applyImpulse(toCannonVec3(impulse), toCannonVec3(new Vec3()));
}
public setCollisionFilter (group: number, mask: number) {
this._cannonBody.collisionFilterGroup = group;
this._cannonBody.collisionFilterMask = mask;
}
// /**
// * Is this body currently in contact with the specified body?
// * @param {CannonBody} body The body to test against.
// */
// public isInContactWith (body: PhysicsBody) {
// if (!this._cannonBody.world) {
// return false;
// }
// return this._cannonBody.world.collisionMatrix.get(
// this._cannonBody.id, body._cannonBody.id) > 0;
// }
public setWorld (world_: PhysicsWorldBase | null) {
const world = world_ as unknown as (CannonWorld | null);
if (world) {
world.impl.addBody(this._cannonBody);
this._cannonBody.addEventListener('collide', this._onCollidedListener);
this._cannonBody.world.addEventListener('beforeStep', this._onWorldBeforeStepListener);
this._cannonBody.world.addEventListener('postStep', this._onWorldPostStepListener);
this._cannonBody.world.addEventListener('beforeStep', this._cancelGravityListener);
} else {
this._cannonBody.world.removeEventListener('beforeStep', this._cancelGravityListener);
this._cannonBody.world.removeEventListener('postStep', this._onWorldPostStepListener);
this._cannonBody.world.removeEventListener('beforeStep', this._onWorldBeforeStepListener);
this._cannonBody.removeEventListener('collide', this._onCollidedListener);
this._cannonBody.world.remove(this._cannonBody);
}
}
public shouldRender (): boolean {
return this._transformSource === TransformSource.Phycis;
}
public getPosition (out: Vec3) {
vec3.copy(out, this._cannonBody.position);
}
public setPosition (value: Vec3) {
vec3.copy(this._cannonBody.position, value);
}
public getRotation (out: Quat) {
quat.copy(out, this._cannonBody.quaternion);
}
public setRotation (value: Quat) {
quat.copy(this._cannonBody.quaternion, value);
}
public scaleAllShapes (scale: Vec3) {
for (const shape of this._shapes) {
shape.setScale(scale);
}
}
public addCollisionCallback (callback: ICollisionCallback): void {
this._collisionCallbacks.push(callback);
}
public removeCollisionCllback (callback: ICollisionCallback): void {
const i = this._collisionCallbacks.indexOf(callback);
if (i >= 0) {
this._collisionCallbacks.splice(i, 1);
}
}
public getUserData (): any {
return this._userData;
}
public setUserData (data: any): void {
this._userData = data;
}
private _resetBodyTypeAccordingMess () {
if (this._cannonBody.mass <= 0) {
this._cannonBody.type = CANNON.Body.STATIC;
} else {
this._cannonBody.type = CANNON.Body.DYNAMIC;
}
}
private _onBodyTypeUpdated () {
if (this._cannonBody) {
if (this._cannonBody.type === CANNON.Body.STATIC) {
this._transformSource = TransformSource.Scene;
} else {
this._transformSource = TransformSource.Phycis;
}
}
}
private _onCollided (event: CANNON.ICollisionEvent) {
const evt: ICollisionEvent = {
source: getWrap<RigidBodyBase>(event.body),
target: getWrap<RigidBodyBase>((event as any).target),
};
for (const callback of this._collisionCallbacks) {
callback(evt);
}
}
private _onWorldBeforeStep (event: CANNON.IEvent) {
}
private _onWorldPostStep (event: CANNON.IEvent) {
}
private _removeShape (iShape: number) {
const body = this._cannonBody;
const shape = body.shapes[iShape];
body.shapes.splice(iShape, 1);
body.shapeOffsets.splice(iShape, 1);
body.shapeOrientations.splice(iShape, 1);
body.updateMassProperties();
body.updateBoundingRadius();
body.aabbNeedsUpdate = true;
(shape as any).body = null;
}
}
export class CannonShape implements ShapeBase {
public get impl () {
return this._cannonShape!;
}
protected _scale: Vec3 = new Vec3(1, 1, 1);
protected _cannonShape: CANNON.Shape | null = null;
private _index: number = -1;
private _body: CANNON.Body | null = null;
private _center: Vec3 = new Vec3(0, 0, 0);
public constructor () {
}
public _setIndex (index: number) {
this._index = index;
this._recalcCenter();
}
public _setBody (body: CANNON.Body, index: number) {
this._body = body;
this._setIndex(index);
}
public setCenter (center: Vec3): void {
vec3.copy(this._center, center);
this._recalcCenter();
}
public setScale (scale: Vec3): void {
vec3.copy(this._scale, scale);
this._recalcCenter();
}
public setRotation (rotation: Quat): void {
}
private _recalcCenter () {
if (!this._body) {
return;
}
const shapeOffset = this._body.shapeOffsets[this._index];
vec3.copy(shapeOffset, this._center);
vec3.multiply(shapeOffset, shapeOffset, this._scale);
}
}
export class CannonSphereShape extends CannonShape implements SphereShapeBase {
private _cannonSphere: CANNON.Sphere;
private _radius: number = 0;
constructor (radius: number) {
super();
this._radius = radius;
this._cannonSphere = new CANNON.Sphere(this._radius);
setWrap<ShapeBase>(this._cannonSphere, this);
this._cannonShape = this._cannonSphere;
}
public setScale (scale: Vec3): void {
super.setScale(scale);
this._recalcRadius();
}
public setRadius (radius: number) {
this._radius = radius;
this._recalcRadius();
}
private _recalcRadius () {
this._cannonSphere.radius = this._radius * maxComponent(this._scale);
this._cannonSphere.updateBoundingSphereRadius();
}
}
export class CannonBoxShape extends CannonShape implements BoxShapeBase {
private _cannonBox: CANNON.Box;
private _halfExtent: CANNON.Vec3 = new CANNON.Vec3();
constructor (size: Vec3) {
super();
vec3.scale(this._halfExtent, size, 0.5);
this._cannonBox = new CANNON.Box(this._halfExtent);
setWrap<ShapeBase>(this._cannonBox, this);
this._cannonShape = this._cannonBox;
}
public setScale (scale: Vec3): void {
super.setScale(scale);
this._recalcExtents();
}
public setSize (size: Vec3) {
vec3.scale(this._halfExtent, size, 0.5);
this._recalcExtents();
}
private _recalcExtents () {
vec3.multiply(this._cannonBox.halfExtents, this._halfExtent, this._scale);
this._cannonBox.updateConvexPolyhedronRepresentation();
this._cannonBox.updateBoundingSphereRadius();
}
}
/**
* Constraint options.
*/
export interface IConstraintOptions {
/**
* Set to true if you want the bodies to collide when they are connected.
* @default true
*/
collideConnected?: boolean;
/**
* @default true
*/
wakeUpBodies?: boolean;
}
export class CannonConstraint implements ConstraintBase {
protected _cannonConstraint: CANNON.Constraint;
/**
* @param first The first body.
* @param second The second body.
* @param options Options.
*/
protected constructor (cannonConstraint: CANNON.Constraint) {
this._cannonConstraint = cannonConstraint;
setWrap<CannonConstraint>(this._cannonConstraint, this);
}
get first () {
return getWrap<CannonRigidBody>(this._cannonConstraint.bodyA);
}
get second () {
return getWrap<CannonRigidBody>(this._cannonConstraint.bodyB);
}
public enable () {
this._cannonConstraint.enable();
}
public disable () {
this._cannonConstraint.disable();
}
public update () {
this._cannonConstraint.update();
}
public get impl () {
return this._cannonConstraint;
}
}
export class CannonDistanceConstraint extends CannonConstraint implements DistanceConstraintBase {
constructor (first: CannonRigidBody, second: CannonRigidBody, distance?: number, options?: IDistanceConstraintOptions) {
super(new CANNON.DistanceConstraint(
first.impl,
second.impl,
distance!,
options === undefined ? undefined : options.maxForce));
}
}
export class CannonPointToPointConstraint extends CannonConstraint implements PointToPointConstraintBase {
constructor (first: CannonRigidBody, firstPivot: Vec3, second: CannonRigidBody, secondPivot: Vec3, options?: IPointToPointConstraintOptions) {
super(new CANNON.PointToPointConstraint(
first.impl,
toCannonVec3(firstPivot),
second.impl,
toCannonVec3(secondPivot),
options === undefined ? undefined : options.maxForce));
}
}
export class CannonLockConstraint extends CannonConstraint implements LockConstraintBase {
constructor (first: CannonRigidBody, second: CannonRigidBody, options?: ILockConstraintOptions) {
super(new CANNON.LockConstraint(
first.impl,
second.impl,
options));
}
}
export class CannonRaycastResult implements RaycastResultBase {
public _cannonResult: CANNON.RaycastResult = new CANNON.RaycastResult();
public _hitPoint: Vec3 = new Vec3();
get hit () {
return this._cannonResult.hasHit;
}
get hitPoint () {
vec3.copy(this._hitPoint, this._cannonResult.hitPointWorld);
return this._hitPoint;
}
get distance () {
return this._cannonResult.distance;
}
get shape () {
return getWrap<ShapeBase>(this._cannonResult.shape);
}
get body () {
return getWrap<RigidBodyBase>(this._cannonResult.body);
}
}
interface ICANNONRaycastOptions {
collisionFilterMask?: number;
collisionFilterGroup?: number;
checkCollisionResponse?: boolean;
skipBackfaces?: boolean;
}
function toCannonRaycastOptions (options: IRaycastOptions): ICANNONRaycastOptions {
return toCannonOptions(options, {
queryTriggerInteraction: 'checkCollisionResponse',
});
}
interface IWrappedCANNON<T> {
__cc_wrapper__: T;
}
function setWrap<Wrapper> (cannonObject: any, wrapper: Wrapper) {
(cannonObject as unknown as IWrappedCANNON<Wrapper>).__cc_wrapper__ = wrapper;
}
function getWrap<Wrapper> (cannonObject: any) {
return (cannonObject as unknown as IWrappedCANNON<Wrapper>).__cc_wrapper__;
}
function toCannonVec3 (value: Vec3) {
return new CANNON.Vec3(value.x, value.y, value.z);
}
function toCannonOptions<T> (options: any, optionsRename?: { [x: string]: string; }) {
const result = {};
for (const key of Object.keys(options)) {
let destKey = key;
if (optionsRename) {
const rename = optionsRename[key];
if (rename) {
destKey = rename;
}
}
result[destKey] = options[key];
}
return result as T;
}
function maxComponent (v: Vec3) {
return Math.max(v.x, Math.max(v.y, v.z));
}
+8
View File
@@ -0,0 +1,8 @@
export {
CannonBoxShape as BoxShape,
CannonRaycastResult as RaycastResult,
CannonRigidBody as RigidBody,
CannonSphereShape as SphereShape,
CannonWorld as PhysicsWorld,
} from './cannon-impl';
+25
View File
@@ -0,0 +1,25 @@
import { Vec3 } from '../../core/value-types';
import { BoxShapeBase, PhysicsWorldBase, RaycastResultBase, RigidBodyBase } from './api';
import { BoxShape, PhysicsWorld, RaycastResult, RigidBody, SphereShape } from './impl-selector';
export function createPhysicsWorld (): PhysicsWorldBase {
return new PhysicsWorld();
}
export function createRigidBody (): RigidBodyBase {
return new RigidBody();
}
export function createBoxShape (size: Vec3): BoxShapeBase {
return new BoxShape(size);
}
export function createSphereShape (radius: number): SphereShape {
return new SphereShape(radius);
}
export function createRaycastResult (): RaycastResultBase {
return new RaycastResult();
}
cc.createRaycastResult = createRaycastResult;
+1 -1
View File
@@ -23,11 +23,11 @@
THE SOFTWARE.
****************************************************************************/
import { Vec3 } from 'cannon';
import CCClass from '../data/class';
import { mat4 } from '../vmath';
import Quat from './quat';
import { ValueType } from './value-type';
import Vec3 from './vec3';
/**
* !#en Representation of 4*4 matrix.