9886 lines
452 KiB
JavaScript
9886 lines
452 KiB
JavaScript
|
(function() {
|
||
|
|
function r(e, n, t) {
|
||
|
|
function o(i, f) {
|
||
|
|
if (!n[i]) {
|
||
|
|
if (!e[i]) {
|
||
|
|
var c = "function" == typeof require && require;
|
||
|
|
if (!f && c) return c(i, !0);
|
||
|
|
if (u) return u(i, !0);
|
||
|
|
var a = new Error("Cannot find module '" + i + "'");
|
||
|
|
throw a.code = "MODULE_NOT_FOUND", a;
|
||
|
|
}
|
||
|
|
var p = n[i] = {
|
||
|
|
exports: {}
|
||
|
|
};
|
||
|
|
e[i][0].call(p.exports, function(r) {
|
||
|
|
var n = e[i][1][r];
|
||
|
|
return o(n || r);
|
||
|
|
}, p, p.exports, r, e, n, t);
|
||
|
|
}
|
||
|
|
return n[i].exports;
|
||
|
|
}
|
||
|
|
for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
|
||
|
|
return o;
|
||
|
|
}
|
||
|
|
return r;
|
||
|
|
})()({
|
||
|
|
1: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.CannonRigidBody = void 0;
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../external/cannon/cannon"));
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
var v3_cannon0 = new _cannon["default"].Vec3();
|
||
|
|
var v3_cannon1 = new _cannon["default"].Vec3();
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var CannonRigidBody = function() {
|
||
|
|
function CannonRigidBody() {
|
||
|
|
this._rigidBody = void 0;
|
||
|
|
this._sharedBody = void 0;
|
||
|
|
this._isEnabled = false;
|
||
|
|
}
|
||
|
|
var _proto = CannonRigidBody.prototype;
|
||
|
|
_proto.__preload = function __preload(com) {
|
||
|
|
this._rigidBody = com;
|
||
|
|
this._sharedBody = cc.director.getPhysics3DManager().physicsWorld.getSharedBody(this._rigidBody.node);
|
||
|
|
this._sharedBody.reference = true;
|
||
|
|
this._sharedBody.wrappedBody = this;
|
||
|
|
};
|
||
|
|
_proto.onLoad = function onLoad() {};
|
||
|
|
_proto.onEnable = function onEnable() {
|
||
|
|
this._isEnabled = true;
|
||
|
|
this.mass = this._rigidBody.mass;
|
||
|
|
this.allowSleep = this._rigidBody.allowSleep;
|
||
|
|
this.linearDamping = this._rigidBody.linearDamping;
|
||
|
|
this.angularDamping = this._rigidBody.angularDamping;
|
||
|
|
this.useGravity = this._rigidBody.useGravity;
|
||
|
|
this.isKinematic = this._rigidBody.isKinematic;
|
||
|
|
this.fixedRotation = this._rigidBody.fixedRotation;
|
||
|
|
this.linearFactor = this._rigidBody.linearFactor;
|
||
|
|
this.angularFactor = this._rigidBody.angularFactor;
|
||
|
|
this._sharedBody.enabled = true;
|
||
|
|
};
|
||
|
|
_proto.onDisable = function onDisable() {
|
||
|
|
this._isEnabled = false;
|
||
|
|
this._sharedBody.enabled = false;
|
||
|
|
};
|
||
|
|
_proto.onDestroy = function onDestroy() {
|
||
|
|
this._sharedBody.reference = false;
|
||
|
|
this._rigidBody = null;
|
||
|
|
this._sharedBody = null;
|
||
|
|
};
|
||
|
|
_proto.wakeUp = function wakeUp() {
|
||
|
|
return this._sharedBody.body.wakeUp();
|
||
|
|
};
|
||
|
|
_proto.sleep = function sleep() {
|
||
|
|
return this._sharedBody.body.sleep();
|
||
|
|
};
|
||
|
|
_proto.getLinearVelocity = function getLinearVelocity(out) {
|
||
|
|
Vec3.copy(out, this._sharedBody.body.velocity);
|
||
|
|
return out;
|
||
|
|
};
|
||
|
|
_proto.setLinearVelocity = function setLinearVelocity(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
Vec3.copy(body.velocity, value);
|
||
|
|
};
|
||
|
|
_proto.getAngularVelocity = function getAngularVelocity(out) {
|
||
|
|
Vec3.copy(out, this._sharedBody.body.angularVelocity);
|
||
|
|
return out;
|
||
|
|
};
|
||
|
|
_proto.setAngularVelocity = function setAngularVelocity(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
Vec3.copy(body.angularVelocity, value);
|
||
|
|
};
|
||
|
|
_proto.applyForce = function applyForce(force, worldPoint) {
|
||
|
|
null == worldPoint && (worldPoint = Vec3.ZERO);
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.applyForce(Vec3.copy(v3_cannon0, force), Vec3.copy(v3_cannon1, worldPoint));
|
||
|
|
};
|
||
|
|
_proto.applyImpulse = function applyImpulse(impulse, worldPoint) {
|
||
|
|
null == worldPoint && (worldPoint = Vec3.ZERO);
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.applyImpulse(Vec3.copy(v3_cannon0, impulse), Vec3.copy(v3_cannon1, worldPoint));
|
||
|
|
};
|
||
|
|
_proto.applyLocalForce = function applyLocalForce(force, localPoint) {
|
||
|
|
null == localPoint && (localPoint = Vec3.ZERO);
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.applyLocalForce(Vec3.copy(v3_cannon0, force), Vec3.copy(v3_cannon1, localPoint));
|
||
|
|
};
|
||
|
|
_proto.applyLocalImpulse = function applyLocalImpulse(impulse, localPoint) {
|
||
|
|
null == localPoint && (localPoint = Vec3.ZERO);
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.applyLocalImpulse(Vec3.copy(v3_cannon0, impulse), Vec3.copy(v3_cannon1, localPoint));
|
||
|
|
};
|
||
|
|
_proto.applyTorque = function applyTorque(torque) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.torque.x += torque.x;
|
||
|
|
body.torque.y += torque.y;
|
||
|
|
body.torque.z += torque.z;
|
||
|
|
};
|
||
|
|
_proto.applyLocalTorque = function applyLocalTorque(torque) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
Vec3.copy(v3_cannon0, torque);
|
||
|
|
body.vectorToWorldFrame(v3_cannon0, v3_cannon0);
|
||
|
|
body.torque.x += v3_cannon0.x;
|
||
|
|
body.torque.y += v3_cannon0.y;
|
||
|
|
body.torque.z += v3_cannon0.z;
|
||
|
|
};
|
||
|
|
_createClass(CannonRigidBody, [ {
|
||
|
|
key: "isAwake",
|
||
|
|
get: function get() {
|
||
|
|
return this._sharedBody.body.isAwake();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isSleepy",
|
||
|
|
get: function get() {
|
||
|
|
return this._sharedBody.body.isSleepy();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isSleeping",
|
||
|
|
get: function get() {
|
||
|
|
return this._sharedBody.body.isSleeping();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "allowSleep",
|
||
|
|
set: function set(v) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.allowSleep = v;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "mass",
|
||
|
|
set: function set(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.mass = value;
|
||
|
|
0 == body.mass ? body.type = _cannon["default"].Body.STATIC : body.type = this._rigidBody.isKinematic ? _cannon["default"].Body.KINEMATIC : _cannon["default"].Body.DYNAMIC;
|
||
|
|
body.updateMassProperties();
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isKinematic",
|
||
|
|
set: function set(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
0 == body.mass ? body.type = _cannon["default"].Body.STATIC : body.type = value ? _cannon["default"].Body.KINEMATIC : _cannon["default"].Body.DYNAMIC;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "fixedRotation",
|
||
|
|
set: function set(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.fixedRotation = value;
|
||
|
|
body.updateMassProperties();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "linearDamping",
|
||
|
|
set: function set(value) {
|
||
|
|
this._sharedBody.body.linearDamping = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "angularDamping",
|
||
|
|
set: function set(value) {
|
||
|
|
this._sharedBody.body.angularDamping = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "useGravity",
|
||
|
|
set: function set(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
body.useGravity = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "linearFactor",
|
||
|
|
set: function set(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
Vec3.copy(body.linearFactor, value);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "angularFactor",
|
||
|
|
set: function set(value) {
|
||
|
|
var body = this._sharedBody.body;
|
||
|
|
body.isSleeping() && body.wakeUp();
|
||
|
|
Vec3.copy(body.angularFactor, value);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "rigidBody",
|
||
|
|
get: function get() {
|
||
|
|
return this._rigidBody;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "sharedBody",
|
||
|
|
get: function get() {
|
||
|
|
return this._sharedBody;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isEnabled",
|
||
|
|
get: function get() {
|
||
|
|
return this._isEnabled;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
return CannonRigidBody;
|
||
|
|
}();
|
||
|
|
exports.CannonRigidBody = CannonRigidBody;
|
||
|
|
}, {
|
||
|
|
"../../../../../external/cannon/cannon": 24
|
||
|
|
} ],
|
||
|
|
2: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.CannonSharedBody = void 0;
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../external/cannon/cannon"));
|
||
|
|
var _physicsEnum = require("../framework/physics-enum");
|
||
|
|
var _util = require("../framework/util");
|
||
|
|
var _cannonUtil = require("./cannon-util");
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
var LocalDirtyFlag = cc.Node._LocalDirtyFlag;
|
||
|
|
var PHYSICS_SCALE = LocalDirtyFlag.PHYSICS_SCALE;
|
||
|
|
var Quat = cc.Quat;
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var fastRemoveAt = cc.js.array.fastRemoveAt;
|
||
|
|
var v3_0 = new Vec3();
|
||
|
|
var quat_0 = new Quat();
|
||
|
|
var contactsPool = [];
|
||
|
|
var CollisionEventObject = {
|
||
|
|
type: "collision-enter",
|
||
|
|
selfCollider: null,
|
||
|
|
otherCollider: null,
|
||
|
|
contacts: []
|
||
|
|
};
|
||
|
|
var CannonSharedBody = function() {
|
||
|
|
CannonSharedBody.getSharedBody = function getSharedBody(node, wrappedWorld) {
|
||
|
|
var key = node._id;
|
||
|
|
if (CannonSharedBody.sharedBodiesMap.has(key)) return CannonSharedBody.sharedBodiesMap.get(key);
|
||
|
|
var newSB = new CannonSharedBody(node, wrappedWorld);
|
||
|
|
CannonSharedBody.sharedBodiesMap.set(node._id, newSB);
|
||
|
|
return newSB;
|
||
|
|
};
|
||
|
|
_createClass(CannonSharedBody, [ {
|
||
|
|
key: "enabled",
|
||
|
|
set: function set(v) {
|
||
|
|
if (v) {
|
||
|
|
if (this.index < 0) {
|
||
|
|
this.index = this.wrappedWorld.bodies.length;
|
||
|
|
this.wrappedWorld.addSharedBody(this);
|
||
|
|
var node = this.node;
|
||
|
|
this.body.aabbNeedsUpdate = true;
|
||
|
|
node.getWorldPosition(v3_0);
|
||
|
|
node.getWorldRotation(quat_0);
|
||
|
|
var pos = this.body.position;
|
||
|
|
pos.x = parseFloat(v3_0.x.toFixed(3));
|
||
|
|
pos.y = parseFloat(v3_0.y.toFixed(3));
|
||
|
|
pos.z = parseFloat(v3_0.z.toFixed(3));
|
||
|
|
var rot = this.body.quaternion;
|
||
|
|
rot.x = parseFloat(quat_0.x.toFixed(12));
|
||
|
|
rot.y = parseFloat(quat_0.y.toFixed(12));
|
||
|
|
rot.z = parseFloat(quat_0.z.toFixed(12));
|
||
|
|
rot.w = parseFloat(quat_0.w.toFixed(12));
|
||
|
|
if (node._localMatDirty & PHYSICS_SCALE) {
|
||
|
|
var wscale = node.__wscale;
|
||
|
|
for (var i = 0; i < this.shapes.length; i++) this.shapes[i].setScale(wscale);
|
||
|
|
(0, _cannonUtil.commitShapeUpdates)(this.body);
|
||
|
|
}
|
||
|
|
this.body.isSleeping() && this.body.wakeUp();
|
||
|
|
}
|
||
|
|
} else if (this.index >= 0) {
|
||
|
|
var isRemove = 0 == this.shapes.length && null == this.wrappedBody || 0 == this.shapes.length && null != this.wrappedBody && !this.wrappedBody.rigidBody.enabledInHierarchy || 0 == this.shapes.length && null != this.wrappedBody && !this.wrappedBody.isEnabled;
|
||
|
|
if (isRemove) {
|
||
|
|
this.body.sleep();
|
||
|
|
this.index = -1;
|
||
|
|
this.wrappedWorld.removeSharedBody(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "reference",
|
||
|
|
set: function set(v) {
|
||
|
|
v ? this.ref++ : this.ref--;
|
||
|
|
0 == this.ref && this.destroy();
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function CannonSharedBody(node, wrappedWorld) {
|
||
|
|
this.node = void 0;
|
||
|
|
this.wrappedWorld = void 0;
|
||
|
|
this.body = new _cannon["default"].Body();
|
||
|
|
this.shapes = [];
|
||
|
|
this.wrappedBody = null;
|
||
|
|
this.index = -1;
|
||
|
|
this.ref = 0;
|
||
|
|
this.onCollidedListener = this.onCollided.bind(this);
|
||
|
|
this.wrappedWorld = wrappedWorld;
|
||
|
|
this.node = node;
|
||
|
|
this.body.material = this.wrappedWorld.world.defaultMaterial;
|
||
|
|
this.body.addEventListener("cc-collide", this.onCollidedListener);
|
||
|
|
this._updateGroup();
|
||
|
|
this.node.on(cc.Node.EventType.GROUP_CHANGED, this._updateGroup, this);
|
||
|
|
}
|
||
|
|
var _proto = CannonSharedBody.prototype;
|
||
|
|
_proto._updateGroup = function _updateGroup() {
|
||
|
|
(0, _cannonUtil.groupIndexToBitMask)(this.node.groupIndex, this.body);
|
||
|
|
};
|
||
|
|
_proto.addShape = function addShape(v) {
|
||
|
|
var index = this.shapes.indexOf(v);
|
||
|
|
if (index < 0) {
|
||
|
|
var _index = this.body.shapes.length;
|
||
|
|
this.body.addShape(v.shape);
|
||
|
|
this.shapes.push(v);
|
||
|
|
v.setIndex(_index);
|
||
|
|
var offset = this.body.shapeOffsets[_index];
|
||
|
|
var orient = this.body.shapeOrientations[_index];
|
||
|
|
v.setOffsetAndOrient(offset, orient);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_proto.removeShape = function removeShape(v) {
|
||
|
|
var index = this.shapes.indexOf(v);
|
||
|
|
if (index >= 0) {
|
||
|
|
fastRemoveAt(this.shapes, index);
|
||
|
|
this.body.removeShape(v.shape);
|
||
|
|
v.setIndex(-1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_proto.syncSceneToPhysics = function syncSceneToPhysics(force) {
|
||
|
|
void 0 === force && (force = false);
|
||
|
|
var node = this.node;
|
||
|
|
var needUpdateTransform = (0, _util.worldDirty)(node);
|
||
|
|
if (!force && !needUpdateTransform) return;
|
||
|
|
this.body.aabbNeedsUpdate = true;
|
||
|
|
node.getWorldPosition(v3_0);
|
||
|
|
node.getWorldRotation(quat_0);
|
||
|
|
Vec3.copy(this.body.position, v3_0);
|
||
|
|
Quat.copy(this.body.quaternion, quat_0);
|
||
|
|
if (node._localMatDirty & PHYSICS_SCALE) {
|
||
|
|
var wscale = node.__wscale;
|
||
|
|
for (var i = 0; i < this.shapes.length; i++) this.shapes[i].setScale(wscale);
|
||
|
|
(0, _cannonUtil.commitShapeUpdates)(this.body);
|
||
|
|
}
|
||
|
|
this.body.isSleeping() && this.body.wakeUp();
|
||
|
|
};
|
||
|
|
_proto.syncPhysicsToScene = function syncPhysicsToScene() {
|
||
|
|
if (this.body.type != _physicsEnum.ERigidBodyType.STATIC && !this.body.isSleeping()) {
|
||
|
|
Vec3.copy(v3_0, this.body.position);
|
||
|
|
Quat.copy(quat_0, this.body.quaternion);
|
||
|
|
this.node.setWorldPosition(v3_0);
|
||
|
|
this.node.setWorldRotation(quat_0);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_proto.destroy = function destroy() {
|
||
|
|
this.body.removeEventListener("cc-collide", this.onCollidedListener);
|
||
|
|
this.node.off(cc.Node.EventType.GROUP_CHANGED, this._updateGroup, this);
|
||
|
|
CannonSharedBody.sharedBodiesMap["delete"](this.node._id);
|
||
|
|
delete _cannon["default"].World["idToBodyMap"][this.body.id];
|
||
|
|
this.node = null;
|
||
|
|
this.wrappedWorld = null;
|
||
|
|
this.body = null;
|
||
|
|
this.shapes = null;
|
||
|
|
this.onCollidedListener = null;
|
||
|
|
};
|
||
|
|
_proto.onCollided = function onCollided(event) {
|
||
|
|
CollisionEventObject.type = event.event;
|
||
|
|
var self = (0, _util.getWrap)(event.selfShape);
|
||
|
|
var other = (0, _util.getWrap)(event.otherShape);
|
||
|
|
if (self) {
|
||
|
|
CollisionEventObject.selfCollider = self.collider;
|
||
|
|
CollisionEventObject.otherCollider = other ? other.collider : null;
|
||
|
|
var i = 0;
|
||
|
|
for (i = CollisionEventObject.contacts.length; i--; ) contactsPool.push(CollisionEventObject.contacts.pop());
|
||
|
|
for (i = 0; i < event.contacts.length; i++) {
|
||
|
|
var cq = event.contacts[i];
|
||
|
|
if (contactsPool.length > 0) {
|
||
|
|
var c = contactsPool.pop();
|
||
|
|
Vec3.copy(c.contactA, cq.ri);
|
||
|
|
Vec3.copy(c.contactB, cq.rj);
|
||
|
|
Vec3.copy(c.normal, cq.ni);
|
||
|
|
CollisionEventObject.contacts.push(c);
|
||
|
|
} else {
|
||
|
|
var _c = {
|
||
|
|
contactA: Vec3.copy(new Vec3(), cq.ri),
|
||
|
|
contactB: Vec3.copy(new Vec3(), cq.rj),
|
||
|
|
normal: Vec3.copy(new Vec3(), cq.ni)
|
||
|
|
};
|
||
|
|
CollisionEventObject.contacts.push(_c);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.shapes.length; i++) {
|
||
|
|
var shape = this.shapes[i];
|
||
|
|
CollisionEventObject.type = _cannonUtil.deprecatedEventMap[CollisionEventObject.type];
|
||
|
|
shape.collider.emit(CollisionEventObject.type, CollisionEventObject);
|
||
|
|
CollisionEventObject.type = event.event;
|
||
|
|
shape.collider.emit(CollisionEventObject.type, CollisionEventObject);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return CannonSharedBody;
|
||
|
|
}();
|
||
|
|
exports.CannonSharedBody = CannonSharedBody;
|
||
|
|
CannonSharedBody.sharedBodiesMap = new Map();
|
||
|
|
}, {
|
||
|
|
"../../../../../external/cannon/cannon": 24,
|
||
|
|
"../framework/physics-enum": 19,
|
||
|
|
"../framework/util": 23,
|
||
|
|
"./cannon-util": 3
|
||
|
|
} ],
|
||
|
|
3: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.groupIndexToBitMask = groupIndexToBitMask;
|
||
|
|
exports.toCannonRaycastOptions = toCannonRaycastOptions;
|
||
|
|
exports.fillRaycastResult = fillRaycastResult;
|
||
|
|
exports.commitShapeUpdates = commitShapeUpdates;
|
||
|
|
exports.deprecatedEventMap = void 0;
|
||
|
|
var _util = require("../framework/util");
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
function groupIndexToBitMask(groupIndex, out) {
|
||
|
|
var categoryBits = 1 << groupIndex;
|
||
|
|
var maskBits = 0;
|
||
|
|
var bits = cc.game.collisionMatrix[groupIndex];
|
||
|
|
if (!bits) {
|
||
|
|
cc.error("cannon-utils: group is not exist", groupIndex);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (var i = 0; i < bits.length; i++) {
|
||
|
|
if (!bits[i]) continue;
|
||
|
|
maskBits |= 1 << i;
|
||
|
|
}
|
||
|
|
out.collisionFilterGroup = categoryBits;
|
||
|
|
out.collisionFilterMask = maskBits;
|
||
|
|
}
|
||
|
|
function toCannonRaycastOptions(out, options) {
|
||
|
|
out.checkCollisionResponse = !options.queryTrigger;
|
||
|
|
groupIndexToBitMask(options.groupIndex, out);
|
||
|
|
out.skipBackFaces = false;
|
||
|
|
}
|
||
|
|
function fillRaycastResult(result, cannonResult) {
|
||
|
|
result._assign(Vec3.copy(new Vec3(), cannonResult.hitPointWorld), cannonResult.distance, (0,
|
||
|
|
_util.getWrap)(cannonResult.shape).collider);
|
||
|
|
}
|
||
|
|
function commitShapeUpdates(body) {
|
||
|
|
body.aabbNeedsUpdate = true;
|
||
|
|
body.updateMassProperties();
|
||
|
|
body.updateBoundingRadius();
|
||
|
|
}
|
||
|
|
var deprecatedEventMap = {
|
||
|
|
onCollisionEnter: "collision-enter",
|
||
|
|
onCollisionStay: "collision-stay",
|
||
|
|
onCollisionExit: "collision-exit",
|
||
|
|
onTriggerEnter: "trigger-enter",
|
||
|
|
onTriggerStay: "trigger-stay",
|
||
|
|
onTriggerExit: "trigger-exit"
|
||
|
|
};
|
||
|
|
exports.deprecatedEventMap = deprecatedEventMap;
|
||
|
|
}, {
|
||
|
|
"../framework/util": 23
|
||
|
|
} ],
|
||
|
|
4: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.CannonWorld = void 0;
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../external/cannon/cannon"));
|
||
|
|
var _cannonUtil = require("./cannon-util");
|
||
|
|
var _cannonShape = require("./shapes/cannon-shape");
|
||
|
|
var _cannonSharedBody = require("./cannon-shared-body");
|
||
|
|
var _util = require("../framework/util");
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var fastRemoveAt = cc.js.array.fastRemoveAt;
|
||
|
|
var CannonWorld = function() {
|
||
|
|
_createClass(CannonWorld, [ {
|
||
|
|
key: "world",
|
||
|
|
get: function get() {
|
||
|
|
return this._world;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "defaultMaterial",
|
||
|
|
set: function set(mat) {
|
||
|
|
this._world.defaultMaterial.friction = mat.friction;
|
||
|
|
this._world.defaultMaterial.restitution = mat.restitution;
|
||
|
|
null != _cannonShape.CannonShape.idToMaterial[mat._uuid] && (_cannonShape.CannonShape.idToMaterial[mat._uuid] = this._world.defaultMaterial);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "allowSleep",
|
||
|
|
set: function set(v) {
|
||
|
|
this._world.allowSleep = v;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "gravity",
|
||
|
|
set: function set(gravity) {
|
||
|
|
Vec3.copy(this._world.gravity, gravity);
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function CannonWorld() {
|
||
|
|
this.bodies = [];
|
||
|
|
this._world = void 0;
|
||
|
|
this._raycastResult = new _cannon["default"].RaycastResult();
|
||
|
|
this._world = new _cannon["default"].World();
|
||
|
|
this._world.broadphase = new _cannon["default"].NaiveBroadphase();
|
||
|
|
this._world.addEventListener("postStep", this.onPostStep.bind(this));
|
||
|
|
}
|
||
|
|
var _proto = CannonWorld.prototype;
|
||
|
|
_proto.onPostStep = function onPostStep() {
|
||
|
|
var p3dm = cc.director.getPhysics3DManager();
|
||
|
|
if (p3dm.useFixedDigit) {
|
||
|
|
var pd = p3dm.fixDigits.position;
|
||
|
|
var rd = p3dm.fixDigits.rotation;
|
||
|
|
var bodies = this._world.bodies;
|
||
|
|
for (var i = 0; i < bodies.length; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
if (bi.type != _cannon["default"].Body.STATIC && !bi.isSleeping()) {
|
||
|
|
var pos = bi.position;
|
||
|
|
pos.x = parseFloat(pos.x.toFixed(pd));
|
||
|
|
pos.y = parseFloat(pos.y.toFixed(pd));
|
||
|
|
pos.z = parseFloat(pos.z.toFixed(pd));
|
||
|
|
var rot = bi.quaternion;
|
||
|
|
rot.x = parseFloat(rot.x.toFixed(rd));
|
||
|
|
rot.y = parseFloat(rot.y.toFixed(rd));
|
||
|
|
rot.z = parseFloat(rot.z.toFixed(rd));
|
||
|
|
rot.w = parseFloat(rot.w.toFixed(rd));
|
||
|
|
var vel = bi.velocity;
|
||
|
|
vel.x = parseFloat(vel.x.toFixed(pd));
|
||
|
|
vel.y = parseFloat(vel.y.toFixed(pd));
|
||
|
|
vel.z = parseFloat(vel.z.toFixed(pd));
|
||
|
|
var avel = bi.angularVelocity;
|
||
|
|
avel.x = parseFloat(avel.x.toFixed(pd));
|
||
|
|
avel.y = parseFloat(avel.y.toFixed(pd));
|
||
|
|
avel.z = parseFloat(avel.z.toFixed(pd));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_proto.step = function step(deltaTime, timeSinceLastCalled, maxSubStep) {
|
||
|
|
this.syncSceneToPhysics();
|
||
|
|
this._world.step(deltaTime, timeSinceLastCalled, maxSubStep);
|
||
|
|
this.syncPhysicsToScene();
|
||
|
|
this.emitEvents();
|
||
|
|
};
|
||
|
|
_proto.syncSceneToPhysics = function syncSceneToPhysics() {
|
||
|
|
(0, _util.clearNodeTransformRecord)();
|
||
|
|
for (var i = 0; i < this.bodies.length; i++) this.bodies[i].syncSceneToPhysics();
|
||
|
|
(0, _util.clearNodeTransformDirtyFlag)();
|
||
|
|
};
|
||
|
|
_proto.syncPhysicsToScene = function syncPhysicsToScene() {
|
||
|
|
for (var i = 0; i < this.bodies.length; i++) this.bodies[i].syncPhysicsToScene();
|
||
|
|
};
|
||
|
|
_proto.emitEvents = function emitEvents() {
|
||
|
|
this._world.emitTriggeredEvents();
|
||
|
|
this._world.emitCollisionEvents();
|
||
|
|
};
|
||
|
|
_proto.raycastClosest = function raycastClosest(worldRay, options, result) {
|
||
|
|
setupFromAndTo(worldRay, options.maxDistance);
|
||
|
|
(0, _cannonUtil.toCannonRaycastOptions)(raycastOpt, options);
|
||
|
|
var hit = this._world.raycastClosest(from, to, raycastOpt, this._raycastResult);
|
||
|
|
hit && (0, _cannonUtil.fillRaycastResult)(result, this._raycastResult);
|
||
|
|
return hit;
|
||
|
|
};
|
||
|
|
_proto.raycast = function raycast(worldRay, options, pool, results) {
|
||
|
|
setupFromAndTo(worldRay, options.maxDistance);
|
||
|
|
(0, _cannonUtil.toCannonRaycastOptions)(raycastOpt, options);
|
||
|
|
var hit = this._world.raycastAll(from, to, raycastOpt, function(result) {
|
||
|
|
var r = pool.add();
|
||
|
|
(0, _cannonUtil.fillRaycastResult)(r, result);
|
||
|
|
results.push(r);
|
||
|
|
});
|
||
|
|
return hit;
|
||
|
|
};
|
||
|
|
_proto.getSharedBody = function getSharedBody(node) {
|
||
|
|
return _cannonSharedBody.CannonSharedBody.getSharedBody(node, this);
|
||
|
|
};
|
||
|
|
_proto.addSharedBody = function addSharedBody(sharedBody) {
|
||
|
|
var i = this.bodies.indexOf(sharedBody);
|
||
|
|
if (i < 0) {
|
||
|
|
this.bodies.push(sharedBody);
|
||
|
|
this._world.addBody(sharedBody.body);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_proto.removeSharedBody = function removeSharedBody(sharedBody) {
|
||
|
|
var i = this.bodies.indexOf(sharedBody);
|
||
|
|
if (i >= 0) {
|
||
|
|
fastRemoveAt(this.bodies, i);
|
||
|
|
this._world.remove(sharedBody.body);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return CannonWorld;
|
||
|
|
}();
|
||
|
|
exports.CannonWorld = CannonWorld;
|
||
|
|
var from = new _cannon["default"].Vec3();
|
||
|
|
var to = new _cannon["default"].Vec3();
|
||
|
|
function setupFromAndTo(worldRay, distance) {
|
||
|
|
Vec3.copy(from, worldRay.o);
|
||
|
|
worldRay.computeHit(to, distance);
|
||
|
|
}
|
||
|
|
var raycastOpt = {
|
||
|
|
checkCollisionResponse: false,
|
||
|
|
collisionFilterGroup: -1,
|
||
|
|
collisionFilterMask: -1,
|
||
|
|
skipBackFaces: false
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../../../../../external/cannon/cannon": 24,
|
||
|
|
"../framework/util": 23,
|
||
|
|
"./cannon-shared-body": 2,
|
||
|
|
"./cannon-util": 3,
|
||
|
|
"./shapes/cannon-shape": 7
|
||
|
|
} ],
|
||
|
|
5: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
var _physicsSelector = require("../framework/physics-selector");
|
||
|
|
var _cannonRigidBody = require("./cannon-rigid-body");
|
||
|
|
var _cannonWorld = require("./cannon-world");
|
||
|
|
var _cannonBoxShape = require("./shapes/cannon-box-shape");
|
||
|
|
var _cannonSphereShape = require("./shapes/cannon-sphere-shape");
|
||
|
|
true;
|
||
|
|
(0, _physicsSelector.instantiate)(_cannonBoxShape.CannonBoxShape, _cannonSphereShape.CannonSphereShape, _cannonRigidBody.CannonRigidBody, _cannonWorld.CannonWorld);
|
||
|
|
}, {
|
||
|
|
"../framework/physics-selector": 22,
|
||
|
|
"./cannon-rigid-body": 1,
|
||
|
|
"./cannon-world": 4,
|
||
|
|
"./shapes/cannon-box-shape": 6,
|
||
|
|
"./shapes/cannon-sphere-shape": 8
|
||
|
|
} ],
|
||
|
|
6: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.CannonBoxShape = void 0;
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../../external/cannon/cannon"));
|
||
|
|
var _cannonUtil = require("../cannon-util");
|
||
|
|
var _cannonShape = require("./cannon-shape");
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var v3_0 = new Vec3();
|
||
|
|
var CannonBoxShape = function(_CannonShape) {
|
||
|
|
_inheritsLoose(CannonBoxShape, _CannonShape);
|
||
|
|
_createClass(CannonBoxShape, [ {
|
||
|
|
key: "boxCollider",
|
||
|
|
get: function get() {
|
||
|
|
return this.collider;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "box",
|
||
|
|
get: function get() {
|
||
|
|
return this._shape;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function CannonBoxShape(size) {
|
||
|
|
var _this;
|
||
|
|
_this = _CannonShape.call(this) || this;
|
||
|
|
_this.halfExtent = new _cannon["default"].Vec3();
|
||
|
|
Vec3.multiplyScalar(_this.halfExtent, size, .5);
|
||
|
|
_this._shape = new _cannon["default"].Box(_this.halfExtent.clone());
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
var _proto = CannonBoxShape.prototype;
|
||
|
|
_proto.onLoad = function onLoad() {
|
||
|
|
_CannonShape.prototype.onLoad.call(this);
|
||
|
|
this.size = this.boxCollider.size;
|
||
|
|
};
|
||
|
|
_proto.setScale = function setScale(scale) {
|
||
|
|
_CannonShape.prototype.setScale.call(this, scale);
|
||
|
|
this.size = this.boxCollider.size;
|
||
|
|
};
|
||
|
|
_createClass(CannonBoxShape, [ {
|
||
|
|
key: "size",
|
||
|
|
set: function set(v) {
|
||
|
|
this.collider.node.getWorldScale(v3_0);
|
||
|
|
v3_0.x = Math.abs(v3_0.x);
|
||
|
|
v3_0.y = Math.abs(v3_0.y);
|
||
|
|
v3_0.z = Math.abs(v3_0.z);
|
||
|
|
Vec3.multiplyScalar(this.halfExtent, v, .5);
|
||
|
|
Vec3.multiply(this.box.halfExtents, this.halfExtent, v3_0);
|
||
|
|
this.box.updateConvexPolyhedronRepresentation();
|
||
|
|
-1 != this._index && (0, _cannonUtil.commitShapeUpdates)(this._body);
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
return CannonBoxShape;
|
||
|
|
}(_cannonShape.CannonShape);
|
||
|
|
exports.CannonBoxShape = CannonBoxShape;
|
||
|
|
}, {
|
||
|
|
"../../../../../../external/cannon/cannon": 24,
|
||
|
|
"../cannon-util": 3,
|
||
|
|
"./cannon-shape": 7
|
||
|
|
} ],
|
||
|
|
7: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.CannonShape = void 0;
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../../external/cannon/cannon"));
|
||
|
|
var _util = require("../../framework/util");
|
||
|
|
var _cannonUtil = require("../cannon-util");
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
var TriggerEventObject = {
|
||
|
|
type: "trigger-enter",
|
||
|
|
selfCollider: null,
|
||
|
|
otherCollider: null
|
||
|
|
};
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var v3_0 = new Vec3();
|
||
|
|
var CannonShape = function() {
|
||
|
|
function CannonShape() {
|
||
|
|
this._collider = void 0;
|
||
|
|
this._shape = void 0;
|
||
|
|
this._offset = new _cannon["default"].Vec3();
|
||
|
|
this._orient = new _cannon["default"].Quaternion();
|
||
|
|
this._index = -1;
|
||
|
|
this._sharedBody = void 0;
|
||
|
|
this.onTriggerListener = this.onTrigger.bind(this);
|
||
|
|
}
|
||
|
|
var _proto = CannonShape.prototype;
|
||
|
|
_proto.__preload = function __preload(comp) {
|
||
|
|
this._collider = comp;
|
||
|
|
(0, _util.setWrap)(this._shape, this);
|
||
|
|
this._shape.addEventListener("cc-trigger", this.onTriggerListener);
|
||
|
|
this._sharedBody = cc.director.getPhysics3DManager().physicsWorld.getSharedBody(this._collider.node);
|
||
|
|
this._sharedBody.reference = true;
|
||
|
|
};
|
||
|
|
_proto.onLoad = function onLoad() {
|
||
|
|
this.center = this._collider.center;
|
||
|
|
this.isTrigger = this._collider.isTrigger;
|
||
|
|
};
|
||
|
|
_proto.onEnable = function onEnable() {
|
||
|
|
this._sharedBody.addShape(this);
|
||
|
|
this._sharedBody.enabled = true;
|
||
|
|
};
|
||
|
|
_proto.onDisable = function onDisable() {
|
||
|
|
this._sharedBody.removeShape(this);
|
||
|
|
this._sharedBody.enabled = false;
|
||
|
|
};
|
||
|
|
_proto.onDestroy = function onDestroy() {
|
||
|
|
this._sharedBody.reference = false;
|
||
|
|
this._shape.removeEventListener("cc-trigger", this.onTriggerListener);
|
||
|
|
delete _cannon["default"].World["idToShapeMap"][this._shape.id];
|
||
|
|
this._sharedBody = null;
|
||
|
|
(0, _util.setWrap)(this._shape, null);
|
||
|
|
this._offset = null;
|
||
|
|
this._orient = null;
|
||
|
|
this._shape = null;
|
||
|
|
this._collider = null;
|
||
|
|
this.onTriggerListener = null;
|
||
|
|
};
|
||
|
|
_proto.setScale = function setScale(scale) {
|
||
|
|
this._setCenter(this._collider.center);
|
||
|
|
};
|
||
|
|
_proto.setIndex = function setIndex(index) {
|
||
|
|
this._index = index;
|
||
|
|
};
|
||
|
|
_proto.setOffsetAndOrient = function setOffsetAndOrient(offset, orient) {
|
||
|
|
cc.Vec3.copy(offset, this._offset);
|
||
|
|
cc.Vec3.copy(orient, this._orient);
|
||
|
|
this._offset = offset;
|
||
|
|
this._orient = orient;
|
||
|
|
};
|
||
|
|
_proto._setCenter = function _setCenter(v) {
|
||
|
|
var lpos = this._offset;
|
||
|
|
Vec3.copy(lpos, v);
|
||
|
|
this._collider.node.getWorldScale(v3_0);
|
||
|
|
Vec3.multiply(lpos, lpos, v3_0);
|
||
|
|
};
|
||
|
|
_proto.onTrigger = function onTrigger(event) {
|
||
|
|
TriggerEventObject.type = event.event;
|
||
|
|
var self = (0, _util.getWrap)(event.selfShape);
|
||
|
|
var other = (0, _util.getWrap)(event.otherShape);
|
||
|
|
if (self) {
|
||
|
|
TriggerEventObject.selfCollider = self.collider;
|
||
|
|
TriggerEventObject.otherCollider = other ? other.collider : null;
|
||
|
|
TriggerEventObject.type = _cannonUtil.deprecatedEventMap[TriggerEventObject.type];
|
||
|
|
this._collider.emit(TriggerEventObject.type, TriggerEventObject);
|
||
|
|
TriggerEventObject.type = event.event;
|
||
|
|
this._collider.emit(TriggerEventObject.type, TriggerEventObject);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_createClass(CannonShape, [ {
|
||
|
|
key: "shape",
|
||
|
|
get: function get() {
|
||
|
|
return this._shape;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "collider",
|
||
|
|
get: function get() {
|
||
|
|
return this._collider;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "attachedRigidBody",
|
||
|
|
get: function get() {
|
||
|
|
if (this._sharedBody.wrappedBody) return this._sharedBody.wrappedBody.rigidBody;
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "sharedBody",
|
||
|
|
get: function get() {
|
||
|
|
return this._sharedBody;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "material",
|
||
|
|
set: function set(mat) {
|
||
|
|
if (null == mat) this._shape.material = null; else {
|
||
|
|
null == CannonShape.idToMaterial[mat._uuid] && (CannonShape.idToMaterial[mat._uuid] = new _cannon["default"].Material(mat._uuid));
|
||
|
|
this._shape.material = CannonShape.idToMaterial[mat._uuid];
|
||
|
|
this._shape.material.friction = mat.friction;
|
||
|
|
this._shape.material.restitution = mat.restitution;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isTrigger",
|
||
|
|
set: function set(v) {
|
||
|
|
this._shape.collisionResponse = !v;
|
||
|
|
this._index >= 0 && this._body.updateHasTrigger();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "center",
|
||
|
|
set: function set(v) {
|
||
|
|
this._setCenter(v);
|
||
|
|
this._index >= 0 && (0, _cannonUtil.commitShapeUpdates)(this._body);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "_body",
|
||
|
|
get: function get() {
|
||
|
|
return this._sharedBody.body;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
return CannonShape;
|
||
|
|
}();
|
||
|
|
exports.CannonShape = CannonShape;
|
||
|
|
CannonShape.idToMaterial = {};
|
||
|
|
}, {
|
||
|
|
"../../../../../../external/cannon/cannon": 24,
|
||
|
|
"../../framework/util": 23,
|
||
|
|
"../cannon-util": 3
|
||
|
|
} ],
|
||
|
|
8: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.CannonSphereShape = void 0;
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../../external/cannon/cannon"));
|
||
|
|
var _cannonUtil = require("../cannon-util");
|
||
|
|
var _cannonShape = require("./cannon-shape");
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
var v3_0 = new cc.Vec3();
|
||
|
|
var CannonSphereShape = function(_CannonShape) {
|
||
|
|
_inheritsLoose(CannonSphereShape, _CannonShape);
|
||
|
|
_createClass(CannonSphereShape, [ {
|
||
|
|
key: "sphereCollider",
|
||
|
|
get: function get() {
|
||
|
|
return this.collider;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "sphere",
|
||
|
|
get: function get() {
|
||
|
|
return this._shape;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "radius",
|
||
|
|
get: function get() {
|
||
|
|
return this._radius;
|
||
|
|
},
|
||
|
|
set: function set(v) {
|
||
|
|
this.collider.node.getWorldScale(v3_0);
|
||
|
|
var max = v3_0.maxAxis();
|
||
|
|
this.sphere.radius = v * Math.abs(max);
|
||
|
|
this.sphere.updateBoundingSphereRadius();
|
||
|
|
-1 != this._index && (0, _cannonUtil.commitShapeUpdates)(this._body);
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function CannonSphereShape(radius) {
|
||
|
|
var _this;
|
||
|
|
_this = _CannonShape.call(this) || this;
|
||
|
|
_this._radius = void 0;
|
||
|
|
_this._radius = radius;
|
||
|
|
_this._shape = new _cannon["default"].Sphere(_this._radius);
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
var _proto = CannonSphereShape.prototype;
|
||
|
|
_proto.onLoad = function onLoad() {
|
||
|
|
_CannonShape.prototype.onLoad.call(this);
|
||
|
|
this.radius = this.sphereCollider.radius;
|
||
|
|
};
|
||
|
|
_proto.setScale = function setScale(scale) {
|
||
|
|
_CannonShape.prototype.setScale.call(this, scale);
|
||
|
|
this.radius = this.sphereCollider.radius;
|
||
|
|
};
|
||
|
|
return CannonSphereShape;
|
||
|
|
}(_cannonShape.CannonShape);
|
||
|
|
exports.CannonSphereShape = CannonSphereShape;
|
||
|
|
}, {
|
||
|
|
"../../../../../../external/cannon/cannon": 24,
|
||
|
|
"../cannon-util": 3,
|
||
|
|
"./cannon-shape": 7
|
||
|
|
} ],
|
||
|
|
9: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
require("../cannon/instantiate");
|
||
|
|
var _cannon = _interopRequireDefault(require("../../../../../external/cannon/cannon"));
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {
|
||
|
|
default: obj
|
||
|
|
};
|
||
|
|
}
|
||
|
|
window && (window.CANNON = _cannon["default"]);
|
||
|
|
}, {
|
||
|
|
"../../../../../external/cannon/cannon": 24,
|
||
|
|
"../cannon/instantiate": 5
|
||
|
|
} ],
|
||
|
|
10: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
var _framework = require("../framework");
|
||
|
|
Object.keys(_framework).forEach(function(key) {
|
||
|
|
if ("default" === key || "__esModule" === key) return;
|
||
|
|
if (key in exports && exports[key] === _framework[key]) return;
|
||
|
|
exports[key] = _framework[key];
|
||
|
|
});
|
||
|
|
}, {
|
||
|
|
"../framework": 17
|
||
|
|
} ],
|
||
|
|
11: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.PhysicsMaterial = void 0;
|
||
|
|
var _dec, _class, _class2, _descriptor, _descriptor2, _class3, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _assertThisInitialized(self) {
|
||
|
|
if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, ccclass = _cc$_decorator.ccclass, property = _cc$_decorator.property;
|
||
|
|
var fastRemove = cc.js.array.fastRemove;
|
||
|
|
var equals = cc.math.equals;
|
||
|
|
var PhysicsMaterial = (_dec = ccclass("cc.PhysicsMaterial"), _dec(_class = (_class2 = (_temp = _class3 = function(_cc$Asset) {
|
||
|
|
_inheritsLoose(PhysicsMaterial, _cc$Asset);
|
||
|
|
_createClass(PhysicsMaterial, [ {
|
||
|
|
key: "friction",
|
||
|
|
get: function get() {
|
||
|
|
return this._friction;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
if (!equals(this._friction, value)) {
|
||
|
|
this._friction = value;
|
||
|
|
this.emit("physics_material_update");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "restitution",
|
||
|
|
get: function get() {
|
||
|
|
return this._restitution;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
if (!equals(this._restitution, value)) {
|
||
|
|
this._restitution = value;
|
||
|
|
this.emit("physics_material_update");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function PhysicsMaterial() {
|
||
|
|
var _this;
|
||
|
|
_this = _cc$Asset.call(this) || this;
|
||
|
|
_initializerDefineProperty(_this, "_friction", _descriptor, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_restitution", _descriptor2, _assertThisInitialized(_this));
|
||
|
|
cc.EventTarget.call(_assertThisInitialized(_this));
|
||
|
|
PhysicsMaterial.allMaterials.push(_assertThisInitialized(_this));
|
||
|
|
"" == _this._uuid && (_this._uuid = "pm_" + PhysicsMaterial._idCounter++);
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
var _proto = PhysicsMaterial.prototype;
|
||
|
|
_proto.clone = function clone() {
|
||
|
|
var c = new PhysicsMaterial();
|
||
|
|
c._friction = this._friction;
|
||
|
|
c._restitution = this._restitution;
|
||
|
|
return c;
|
||
|
|
};
|
||
|
|
_proto.destroy = function destroy() {
|
||
|
|
if (_cc$Asset.prototype.destroy.call(this)) {
|
||
|
|
fastRemove(PhysicsMaterial.allMaterials, this);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
return PhysicsMaterial;
|
||
|
|
}(cc.Asset), _class3.allMaterials = [], _class3._idCounter = 0, _temp), _descriptor = _applyDecoratedDescriptor(_class2.prototype, "_friction", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return .1;
|
||
|
|
}
|
||
|
|
}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_restitution", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return .1;
|
||
|
|
}
|
||
|
|
}), _applyDecoratedDescriptor(_class2.prototype, "friction", [ property ], Object.getOwnPropertyDescriptor(_class2.prototype, "friction"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "restitution", [ property ], Object.getOwnPropertyDescriptor(_class2.prototype, "restitution"), _class2.prototype),
|
||
|
|
_class2)) || _class);
|
||
|
|
exports.PhysicsMaterial = PhysicsMaterial;
|
||
|
|
cc.js.mixin(PhysicsMaterial.prototype, cc.EventTarget.prototype);
|
||
|
|
cc.PhysicsMaterial = PhysicsMaterial;
|
||
|
|
}, {} ],
|
||
|
|
12: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.BoxCollider3D = void 0;
|
||
|
|
var _instance = require("../../instance");
|
||
|
|
var _colliderComponent = require("./collider-component");
|
||
|
|
var _dec, _dec2, _dec3, _dec4, _class, _class2, _descriptor, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _assertThisInitialized(self) {
|
||
|
|
if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, ccclass = _cc$_decorator.ccclass, executeInEditMode = _cc$_decorator.executeInEditMode, executionOrder = _cc$_decorator.executionOrder, menu = _cc$_decorator.menu, property = _cc$_decorator.property;
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var BoxCollider3D = (_dec = ccclass("cc.BoxCollider3D"), _dec2 = executionOrder(98),
|
||
|
|
_dec3 = menu("i18n:MAIN_MENU.component.physics/Collider/Box 3D"), _dec4 = property({
|
||
|
|
type: cc.Vec3
|
||
|
|
}), _dec(_class = _dec2(_class = _dec3(_class = executeInEditMode(_class = (_class2 = (_temp = function(_Collider3D) {
|
||
|
|
_inheritsLoose(BoxCollider3D, _Collider3D);
|
||
|
|
_createClass(BoxCollider3D, [ {
|
||
|
|
key: "size",
|
||
|
|
get: function get() {
|
||
|
|
return this._size;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._size, value);
|
||
|
|
true;
|
||
|
|
this.boxShape.size = this._size;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "boxShape",
|
||
|
|
get: function get() {
|
||
|
|
return this._shape;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function BoxCollider3D() {
|
||
|
|
var _this;
|
||
|
|
_this = _Collider3D.call(this) || this;
|
||
|
|
_initializerDefineProperty(_this, "_size", _descriptor, _assertThisInitialized(_this));
|
||
|
|
true;
|
||
|
|
_this._shape = (0, _instance.createBoxShape)(_this._size);
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
return BoxCollider3D;
|
||
|
|
}(_colliderComponent.Collider3D), _temp), _applyDecoratedDescriptor(_class2.prototype, "size", [ _dec4 ], Object.getOwnPropertyDescriptor(_class2.prototype, "size"), _class2.prototype),
|
||
|
|
_descriptor = _applyDecoratedDescriptor(_class2.prototype, "_size", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3(1, 1, 1);
|
||
|
|
}
|
||
|
|
}), _class2)) || _class) || _class) || _class) || _class);
|
||
|
|
exports.BoxCollider3D = BoxCollider3D;
|
||
|
|
}, {
|
||
|
|
"../../instance": 18,
|
||
|
|
"./collider-component": 13
|
||
|
|
} ],
|
||
|
|
13: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.Collider3D = void 0;
|
||
|
|
var _physicsMaterial = require("../../assets/physics-material");
|
||
|
|
var _dec, _dec2, _dec3, _dec4, _dec5, _class, _class2, _descriptor, _descriptor2, _descriptor3, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _assertThisInitialized(self) {
|
||
|
|
if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, ccclass = _cc$_decorator.ccclass, property = _cc$_decorator.property;
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var Collider3D = (_dec = ccclass("cc.Collider3D"), _dec2 = property({
|
||
|
|
type: _physicsMaterial.PhysicsMaterial,
|
||
|
|
displayName: "Material",
|
||
|
|
displayOrder: -1
|
||
|
|
}), _dec3 = property({
|
||
|
|
displayOrder: 0
|
||
|
|
}), _dec4 = property({
|
||
|
|
type: cc.Vec3,
|
||
|
|
displayOrder: 1
|
||
|
|
}), _dec5 = property({
|
||
|
|
type: _physicsMaterial.PhysicsMaterial
|
||
|
|
}), _dec(_class = (_class2 = (_temp = function(_cc$Component) {
|
||
|
|
_inheritsLoose(Collider3D, _cc$Component);
|
||
|
|
_createClass(Collider3D, [ {
|
||
|
|
key: "sharedMaterial",
|
||
|
|
get: function get() {
|
||
|
|
return this._material;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this.material = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "material",
|
||
|
|
get: function get() {
|
||
|
|
true;
|
||
|
|
if (this._isSharedMaterial && null != this._material) {
|
||
|
|
this._material.off("physics_material_update", this._updateMaterial, this);
|
||
|
|
this._material = this._material.clone();
|
||
|
|
this._material.on("physics_material_update", this._updateMaterial, this);
|
||
|
|
this._isSharedMaterial = false;
|
||
|
|
}
|
||
|
|
return this._material;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
false, false;
|
||
|
|
if (null != value && null != this._material) {
|
||
|
|
if (this._material._uuid != value._uuid) {
|
||
|
|
this._material.off("physics_material_update", this._updateMaterial, this);
|
||
|
|
value.on("physics_material_update", this._updateMaterial, this);
|
||
|
|
this._isSharedMaterial = false;
|
||
|
|
this._material = value;
|
||
|
|
}
|
||
|
|
} else if (null != value && null == this._material) {
|
||
|
|
value.on("physics_material_update", this._updateMaterial, this);
|
||
|
|
this._material = value;
|
||
|
|
} else if (null == value && null != this._material) {
|
||
|
|
this._material.off("physics_material_update", this._updateMaterial, this);
|
||
|
|
this._material = value;
|
||
|
|
}
|
||
|
|
this._updateMaterial();
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isTrigger",
|
||
|
|
get: function get() {
|
||
|
|
return this._isTrigger;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._isTrigger = value;
|
||
|
|
true;
|
||
|
|
this._shape.isTrigger = this._isTrigger;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "center",
|
||
|
|
get: function get() {
|
||
|
|
return this._center;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._center, value);
|
||
|
|
true;
|
||
|
|
this._shape.center = this._center;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "attachedRigidbody",
|
||
|
|
get: function get() {
|
||
|
|
return this.shape.attachedRigidBody;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "shape",
|
||
|
|
get: function get() {
|
||
|
|
return this._shape;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "_assertOnload",
|
||
|
|
get: function get() {
|
||
|
|
var r = 0 == this._isOnLoadCalled;
|
||
|
|
r && cc.error("Physics Error: Please make sure that the node has been added to the scene");
|
||
|
|
return !r;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function Collider3D() {
|
||
|
|
var _this;
|
||
|
|
_this = _cc$Component.call(this) || this;
|
||
|
|
_this._shape = void 0;
|
||
|
|
_this._isSharedMaterial = true;
|
||
|
|
_initializerDefineProperty(_this, "_material", _descriptor, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_isTrigger", _descriptor2, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_center", _descriptor3, _assertThisInitialized(_this));
|
||
|
|
cc.EventTarget.call(_assertThisInitialized(_this));
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
var _proto = Collider3D.prototype;
|
||
|
|
_proto.on = function on(type, callback, target, useCapture) {};
|
||
|
|
_proto.off = function off(type, callback, target) {};
|
||
|
|
_proto.once = function once(type, callback, target) {};
|
||
|
|
_proto.emit = function emit(key) {};
|
||
|
|
_proto.__preload = function __preload() {
|
||
|
|
true;
|
||
|
|
this._shape.__preload(this);
|
||
|
|
};
|
||
|
|
_proto.onLoad = function onLoad() {
|
||
|
|
true;
|
||
|
|
true;
|
||
|
|
this.sharedMaterial = null == this._material ? cc.director.getPhysics3DManager().defaultMaterial : this._material;
|
||
|
|
this._shape.onLoad();
|
||
|
|
};
|
||
|
|
_proto.onEnable = function onEnable() {
|
||
|
|
true;
|
||
|
|
this._shape.onEnable();
|
||
|
|
};
|
||
|
|
_proto.onDisable = function onDisable() {
|
||
|
|
true;
|
||
|
|
this._shape.onDisable();
|
||
|
|
};
|
||
|
|
_proto.onDestroy = function onDestroy() {
|
||
|
|
true;
|
||
|
|
this._material && this._material.off("physics_material_update", this._updateMaterial, this);
|
||
|
|
this._shape.onDestroy();
|
||
|
|
};
|
||
|
|
_proto._updateMaterial = function _updateMaterial() {
|
||
|
|
true;
|
||
|
|
this._shape.material = this._material;
|
||
|
|
};
|
||
|
|
return Collider3D;
|
||
|
|
}(cc.Component), _temp), _applyDecoratedDescriptor(_class2.prototype, "sharedMaterial", [ _dec2 ], Object.getOwnPropertyDescriptor(_class2.prototype, "sharedMaterial"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "isTrigger", [ _dec3 ], Object.getOwnPropertyDescriptor(_class2.prototype, "isTrigger"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "center", [ _dec4 ], Object.getOwnPropertyDescriptor(_class2.prototype, "center"), _class2.prototype),
|
||
|
|
_descriptor = _applyDecoratedDescriptor(_class2.prototype, "_material", [ _dec5 ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_isTrigger", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "_center", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3();
|
||
|
|
}
|
||
|
|
}), _class2)) || _class);
|
||
|
|
exports.Collider3D = Collider3D;
|
||
|
|
cc.js.mixin(Collider3D.prototype, cc.EventTarget.prototype);
|
||
|
|
}, {
|
||
|
|
"../../assets/physics-material": 11
|
||
|
|
} ],
|
||
|
|
14: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.SphereCollider3D = void 0;
|
||
|
|
var _instance = require("../../instance");
|
||
|
|
var _colliderComponent = require("./collider-component");
|
||
|
|
var _dec, _dec2, _dec3, _class, _class2, _descriptor, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _assertThisInitialized(self) {
|
||
|
|
if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, ccclass = _cc$_decorator.ccclass, executeInEditMode = _cc$_decorator.executeInEditMode, executionOrder = _cc$_decorator.executionOrder, menu = _cc$_decorator.menu, property = _cc$_decorator.property;
|
||
|
|
var SphereCollider3D = (_dec = ccclass("cc.SphereCollider3D"), _dec2 = executionOrder(98),
|
||
|
|
_dec3 = menu("i18n:MAIN_MENU.component.physics/Collider/Sphere 3D"), _dec(_class = _dec2(_class = _dec3(_class = executeInEditMode(_class = (_class2 = (_temp = function(_Collider3D) {
|
||
|
|
_inheritsLoose(SphereCollider3D, _Collider3D);
|
||
|
|
_createClass(SphereCollider3D, [ {
|
||
|
|
key: "radius",
|
||
|
|
get: function get() {
|
||
|
|
return this._radius;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._radius = value;
|
||
|
|
true;
|
||
|
|
this.sphereShape.radius = this._radius;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "sphereShape",
|
||
|
|
get: function get() {
|
||
|
|
return this._shape;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function SphereCollider3D() {
|
||
|
|
var _this;
|
||
|
|
_this = _Collider3D.call(this) || this;
|
||
|
|
_initializerDefineProperty(_this, "_radius", _descriptor, _assertThisInitialized(_this));
|
||
|
|
true;
|
||
|
|
_this._shape = (0, _instance.createSphereShape)(_this._radius);
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
return SphereCollider3D;
|
||
|
|
}(_colliderComponent.Collider3D), _temp), _applyDecoratedDescriptor(_class2.prototype, "radius", [ property ], Object.getOwnPropertyDescriptor(_class2.prototype, "radius"), _class2.prototype),
|
||
|
|
_descriptor = _applyDecoratedDescriptor(_class2.prototype, "_radius", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return .5;
|
||
|
|
}
|
||
|
|
}), _class2)) || _class) || _class) || _class) || _class);
|
||
|
|
exports.SphereCollider3D = SphereCollider3D;
|
||
|
|
}, {
|
||
|
|
"../../instance": 18,
|
||
|
|
"./collider-component": 13
|
||
|
|
} ],
|
||
|
|
15: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.ConstantForce = void 0;
|
||
|
|
var _rigidBodyComponent = require("./rigid-body-component");
|
||
|
|
var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _assertThisInitialized(self) {
|
||
|
|
if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, ccclass = _cc$_decorator.ccclass, executeInEditMode = _cc$_decorator.executeInEditMode, executionOrder = _cc$_decorator.executionOrder, menu = _cc$_decorator.menu, property = _cc$_decorator.property, requireComponent = _cc$_decorator.requireComponent, disallowMultiple = _cc$_decorator.disallowMultiple;
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var ConstantForce = (_dec = ccclass("cc.ConstantForce"), _dec2 = executionOrder(98),
|
||
|
|
_dec3 = requireComponent(_rigidBodyComponent.RigidBody3D), _dec4 = menu("i18n:MAIN_MENU.component.physics/Constant Force 3D"),
|
||
|
|
_dec5 = property({
|
||
|
|
displayOrder: 0
|
||
|
|
}), _dec6 = property({
|
||
|
|
displayOrder: 1
|
||
|
|
}), _dec7 = property({
|
||
|
|
displayOrder: 2
|
||
|
|
}), _dec8 = property({
|
||
|
|
displayOrder: 3
|
||
|
|
}), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = disallowMultiple(_class = executeInEditMode(_class = (_class2 = (_temp = function(_cc$Component) {
|
||
|
|
_inheritsLoose(ConstantForce, _cc$Component);
|
||
|
|
function ConstantForce() {
|
||
|
|
var _this;
|
||
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
|
||
|
|
_this = _cc$Component.call.apply(_cc$Component, [ this ].concat(args)) || this;
|
||
|
|
_this._rigidbody = null;
|
||
|
|
_initializerDefineProperty(_this, "_force", _descriptor, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_localForce", _descriptor2, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_torque", _descriptor3, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_localTorque", _descriptor4, _assertThisInitialized(_this));
|
||
|
|
_this._mask = 0;
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
var _proto = ConstantForce.prototype;
|
||
|
|
_proto.onLoad = function onLoad() {
|
||
|
|
true;
|
||
|
|
this._rigidbody = this.node.getComponent(_rigidBodyComponent.RigidBody3D);
|
||
|
|
this._maskUpdate(this._force, 1);
|
||
|
|
this._maskUpdate(this._localForce, 2);
|
||
|
|
this._maskUpdate(this._torque, 4);
|
||
|
|
this._maskUpdate(this._localTorque, 8);
|
||
|
|
};
|
||
|
|
_proto.lateUpdate = function lateUpdate(dt) {
|
||
|
|
true;
|
||
|
|
if (null != this._rigidbody && 0 != this._mask) {
|
||
|
|
1 & this._mask && this._rigidbody.applyForce(this._force);
|
||
|
|
2 & this._mask && this._rigidbody.applyLocalForce(this.localForce);
|
||
|
|
4 & this._mask && this._rigidbody.applyTorque(this._torque);
|
||
|
|
8 & this._mask && this._rigidbody.applyLocalTorque(this._localTorque);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
_proto._maskUpdate = function _maskUpdate(t, m) {
|
||
|
|
Vec3.strictEquals(t, Vec3.ZERO) ? this._mask &= ~m : this._mask |= m;
|
||
|
|
};
|
||
|
|
_createClass(ConstantForce, [ {
|
||
|
|
key: "force",
|
||
|
|
get: function get() {
|
||
|
|
return this._force;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._force, value);
|
||
|
|
this._maskUpdate(this._force, 1);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "localForce",
|
||
|
|
get: function get() {
|
||
|
|
return this._localForce;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._localForce, value);
|
||
|
|
this._maskUpdate(this.localForce, 2);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "torque",
|
||
|
|
get: function get() {
|
||
|
|
return this._torque;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._torque, value);
|
||
|
|
this._maskUpdate(this._torque, 4);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "localTorque",
|
||
|
|
get: function get() {
|
||
|
|
return this._localTorque;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._localTorque, value);
|
||
|
|
this._maskUpdate(this._localTorque, 8);
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
return ConstantForce;
|
||
|
|
}(cc.Component), _temp), _descriptor = _applyDecoratedDescriptor(_class2.prototype, "_force", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3();
|
||
|
|
}
|
||
|
|
}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_localForce", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3();
|
||
|
|
}
|
||
|
|
}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "_torque", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3();
|
||
|
|
}
|
||
|
|
}), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "_localTorque", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3();
|
||
|
|
}
|
||
|
|
}), _applyDecoratedDescriptor(_class2.prototype, "force", [ _dec5 ], Object.getOwnPropertyDescriptor(_class2.prototype, "force"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "localForce", [ _dec6 ], Object.getOwnPropertyDescriptor(_class2.prototype, "localForce"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "torque", [ _dec7 ], Object.getOwnPropertyDescriptor(_class2.prototype, "torque"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "localTorque", [ _dec8 ], Object.getOwnPropertyDescriptor(_class2.prototype, "localTorque"), _class2.prototype),
|
||
|
|
_class2)) || _class) || _class) || _class) || _class) || _class) || _class);
|
||
|
|
exports.ConstantForce = ConstantForce;
|
||
|
|
}, {
|
||
|
|
"./rigid-body-component": 16
|
||
|
|
} ],
|
||
|
|
16: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.RigidBody3D = void 0;
|
||
|
|
var _instance = require("../instance");
|
||
|
|
var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _descriptor7, _descriptor8, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _assertThisInitialized(self) {
|
||
|
|
if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _inheritsLoose(subClass, superClass) {
|
||
|
|
subClass.prototype = Object.create(superClass.prototype);
|
||
|
|
subClass.prototype.constructor = subClass;
|
||
|
|
subClass.__proto__ = superClass;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, ccclass = _cc$_decorator.ccclass, disallowMultiple = _cc$_decorator.disallowMultiple, executeInEditMode = _cc$_decorator.executeInEditMode, executionOrder = _cc$_decorator.executionOrder, menu = _cc$_decorator.menu, property = _cc$_decorator.property;
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var RigidBody3D = (_dec = ccclass("cc.RigidBody3D"), _dec2 = executionOrder(99),
|
||
|
|
_dec3 = menu("i18n:MAIN_MENU.component.physics/Rigid Body 3D"), _dec4 = property({
|
||
|
|
displayOrder: 0
|
||
|
|
}), _dec5 = property({
|
||
|
|
displayOrder: 1
|
||
|
|
}), _dec6 = property({
|
||
|
|
displayOrder: 2
|
||
|
|
}), _dec7 = property({
|
||
|
|
displayOrder: 3
|
||
|
|
}), _dec8 = property({
|
||
|
|
displayOrder: 4
|
||
|
|
}), _dec9 = property({
|
||
|
|
displayOrder: 5
|
||
|
|
}), _dec10 = property({
|
||
|
|
displayOrder: 6
|
||
|
|
}), _dec11 = property({
|
||
|
|
displayOrder: 7
|
||
|
|
}), _dec(_class = _dec2(_class = _dec3(_class = executeInEditMode(_class = disallowMultiple(_class = (_class2 = (_temp = function(_cc$Component) {
|
||
|
|
_inheritsLoose(RigidBody3D, _cc$Component);
|
||
|
|
_createClass(RigidBody3D, [ {
|
||
|
|
key: "allowSleep",
|
||
|
|
get: function get() {
|
||
|
|
return this._allowSleep;
|
||
|
|
},
|
||
|
|
set: function set(v) {
|
||
|
|
this._allowSleep = v;
|
||
|
|
true, true;
|
||
|
|
this._body.allowSleep = v;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "mass",
|
||
|
|
get: function get() {
|
||
|
|
return this._mass;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._mass = value;
|
||
|
|
true, true;
|
||
|
|
this._body.mass = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "linearDamping",
|
||
|
|
get: function get() {
|
||
|
|
return this._linearDamping;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._linearDamping = value;
|
||
|
|
true, true;
|
||
|
|
this._body.linearDamping = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "angularDamping",
|
||
|
|
get: function get() {
|
||
|
|
return this._angularDamping;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._angularDamping = value;
|
||
|
|
true, true;
|
||
|
|
this._body.angularDamping = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isKinematic",
|
||
|
|
get: function get() {
|
||
|
|
return this._isKinematic;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._isKinematic = value;
|
||
|
|
true, true;
|
||
|
|
this._body.isKinematic = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "useGravity",
|
||
|
|
get: function get() {
|
||
|
|
return this._useGravity;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._useGravity = value;
|
||
|
|
true, true;
|
||
|
|
this._body.useGravity = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "fixedRotation",
|
||
|
|
get: function get() {
|
||
|
|
return this._fixedRotation;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._fixedRotation = value;
|
||
|
|
true, true;
|
||
|
|
this._body.fixedRotation = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "linearFactor",
|
||
|
|
get: function get() {
|
||
|
|
return this._linearFactor;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._linearFactor, value);
|
||
|
|
true, true;
|
||
|
|
this._body.linearFactor = this._linearFactor;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "angularFactor",
|
||
|
|
get: function get() {
|
||
|
|
return this._angularFactor;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
Vec3.copy(this._angularFactor, value);
|
||
|
|
true, true;
|
||
|
|
this._body.angularFactor = this._angularFactor;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isAwake",
|
||
|
|
get: function get() {
|
||
|
|
if (this._assertOnload && true) return this._body.isAwake;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isSleepy",
|
||
|
|
get: function get() {
|
||
|
|
if (this._assertOnload && true) return this._body.isSleepy;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isSleeping",
|
||
|
|
get: function get() {
|
||
|
|
if (this._assertOnload && true) return this._body.isSleeping;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "rigidBody",
|
||
|
|
get: function get() {
|
||
|
|
return this._body;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "_assertOnload",
|
||
|
|
get: function get() {
|
||
|
|
var r = 0 == this._isOnLoadCalled;
|
||
|
|
r && cc.error("Physics Error: Please make sure that the node has been added to the scene");
|
||
|
|
return !r;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function RigidBody3D() {
|
||
|
|
var _this;
|
||
|
|
_this = _cc$Component.call(this) || this;
|
||
|
|
_this._body = void 0;
|
||
|
|
_this._allowSleep = true;
|
||
|
|
_initializerDefineProperty(_this, "_mass", _descriptor, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_linearDamping", _descriptor2, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_angularDamping", _descriptor3, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_fixedRotation", _descriptor4, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_isKinematic", _descriptor5, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_useGravity", _descriptor6, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_linearFactor", _descriptor7, _assertThisInitialized(_this));
|
||
|
|
_initializerDefineProperty(_this, "_angularFactor", _descriptor8, _assertThisInitialized(_this));
|
||
|
|
true, true;
|
||
|
|
_this._body = (0, _instance.createRigidBody)();
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
var _proto = RigidBody3D.prototype;
|
||
|
|
_proto.__preload = function __preload() {
|
||
|
|
true, true;
|
||
|
|
this._body.__preload(this);
|
||
|
|
};
|
||
|
|
_proto.onEnable = function onEnable() {
|
||
|
|
true, true;
|
||
|
|
this._body.onEnable();
|
||
|
|
};
|
||
|
|
_proto.onDisable = function onDisable() {
|
||
|
|
true, true;
|
||
|
|
this._body.onDisable();
|
||
|
|
};
|
||
|
|
_proto.onDestroy = function onDestroy() {
|
||
|
|
true, true;
|
||
|
|
this._body.onDestroy();
|
||
|
|
};
|
||
|
|
_proto.applyForce = function applyForce(force, relativePoint) {
|
||
|
|
this._assertOnload && true && this._body.applyForce(force, relativePoint);
|
||
|
|
};
|
||
|
|
_proto.applyLocalForce = function applyLocalForce(force, localPoint) {
|
||
|
|
this._assertOnload && true && this._body.applyLocalForce(force, localPoint);
|
||
|
|
};
|
||
|
|
_proto.applyImpulse = function applyImpulse(impulse, relativePoint) {
|
||
|
|
this._assertOnload && true && this._body.applyImpulse(impulse, relativePoint);
|
||
|
|
};
|
||
|
|
_proto.applyLocalImpulse = function applyLocalImpulse(impulse, localPoint) {
|
||
|
|
this._assertOnload && true && this._body.applyLocalImpulse(impulse, localPoint);
|
||
|
|
};
|
||
|
|
_proto.applyTorque = function applyTorque(torque) {
|
||
|
|
this._assertOnload && true && this._body.applyTorque(torque);
|
||
|
|
};
|
||
|
|
_proto.applyLocalTorque = function applyLocalTorque(torque) {
|
||
|
|
this._assertOnload && true && this._body.applyLocalTorque(torque);
|
||
|
|
};
|
||
|
|
_proto.wakeUp = function wakeUp() {
|
||
|
|
this._assertOnload && true && this._body.wakeUp();
|
||
|
|
};
|
||
|
|
_proto.sleep = function sleep() {
|
||
|
|
this._assertOnload && true && this._body.sleep();
|
||
|
|
};
|
||
|
|
_proto.getLinearVelocity = function getLinearVelocity(out) {
|
||
|
|
this._assertOnload && true && this._body.getLinearVelocity(out);
|
||
|
|
};
|
||
|
|
_proto.setLinearVelocity = function setLinearVelocity(value) {
|
||
|
|
this._assertOnload && true && this._body.setLinearVelocity(value);
|
||
|
|
};
|
||
|
|
_proto.getAngularVelocity = function getAngularVelocity(out) {
|
||
|
|
this._assertOnload && true && this._body.getAngularVelocity(out);
|
||
|
|
};
|
||
|
|
_proto.setAngularVelocity = function setAngularVelocity(value) {
|
||
|
|
this._assertOnload && true && this._body.setAngularVelocity(value);
|
||
|
|
};
|
||
|
|
return RigidBody3D;
|
||
|
|
}(cc.Component), _temp), _applyDecoratedDescriptor(_class2.prototype, "mass", [ _dec4 ], Object.getOwnPropertyDescriptor(_class2.prototype, "mass"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "linearDamping", [ _dec5 ], Object.getOwnPropertyDescriptor(_class2.prototype, "linearDamping"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "angularDamping", [ _dec6 ], Object.getOwnPropertyDescriptor(_class2.prototype, "angularDamping"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "isKinematic", [ _dec7 ], Object.getOwnPropertyDescriptor(_class2.prototype, "isKinematic"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "useGravity", [ _dec8 ], Object.getOwnPropertyDescriptor(_class2.prototype, "useGravity"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "fixedRotation", [ _dec9 ], Object.getOwnPropertyDescriptor(_class2.prototype, "fixedRotation"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "linearFactor", [ _dec10 ], Object.getOwnPropertyDescriptor(_class2.prototype, "linearFactor"), _class2.prototype),
|
||
|
|
_applyDecoratedDescriptor(_class2.prototype, "angularFactor", [ _dec11 ], Object.getOwnPropertyDescriptor(_class2.prototype, "angularFactor"), _class2.prototype),
|
||
|
|
_descriptor = _applyDecoratedDescriptor(_class2.prototype, "_mass", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return 10;
|
||
|
|
}
|
||
|
|
}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_linearDamping", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return .1;
|
||
|
|
}
|
||
|
|
}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "_angularDamping", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return .1;
|
||
|
|
}
|
||
|
|
}), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "_fixedRotation", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}), _descriptor5 = _applyDecoratedDescriptor(_class2.prototype, "_isKinematic", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}), _descriptor6 = _applyDecoratedDescriptor(_class2.prototype, "_useGravity", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}), _descriptor7 = _applyDecoratedDescriptor(_class2.prototype, "_linearFactor", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3(1, 1, 1);
|
||
|
|
}
|
||
|
|
}), _descriptor8 = _applyDecoratedDescriptor(_class2.prototype, "_angularFactor", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new Vec3(1, 1, 1);
|
||
|
|
}
|
||
|
|
}), _class2)) || _class) || _class) || _class) || _class) || _class);
|
||
|
|
exports.RigidBody3D = RigidBody3D;
|
||
|
|
}, {
|
||
|
|
"../instance": 18
|
||
|
|
} ],
|
||
|
|
17: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
var _physicsManager = require("./physics-manager");
|
||
|
|
exports.Physics3DManager = _physicsManager.Physics3DManager;
|
||
|
|
var _physicsRayResult = require("./physics-ray-result");
|
||
|
|
exports.PhysicsRayResult = _physicsRayResult.PhysicsRayResult;
|
||
|
|
var _boxColliderComponent = require("./components/collider/box-collider-component");
|
||
|
|
exports.BoxCollider3D = _boxColliderComponent.BoxCollider3D;
|
||
|
|
var _colliderComponent = require("./components/collider/collider-component");
|
||
|
|
exports.Collider3D = _colliderComponent.Collider3D;
|
||
|
|
var _sphereColliderComponent = require("./components/collider/sphere-collider-component");
|
||
|
|
exports.SphereCollider3D = _sphereColliderComponent.SphereCollider3D;
|
||
|
|
var _rigidBodyComponent = require("./components/rigid-body-component");
|
||
|
|
exports.RigidBody3D = _rigidBodyComponent.RigidBody3D;
|
||
|
|
var _constantForce = require("./components/constant-force");
|
||
|
|
var _physicsMaterial = require("./assets/physics-material");
|
||
|
|
exports.PhysicsMaterial = _physicsMaterial.PhysicsMaterial;
|
||
|
|
cc.Physics3DManager = _physicsManager.Physics3DManager;
|
||
|
|
cc.Collider3D = _colliderComponent.Collider3D;
|
||
|
|
cc.BoxCollider3D = _boxColliderComponent.BoxCollider3D;
|
||
|
|
cc.SphereCollider3D = _sphereColliderComponent.SphereCollider3D;
|
||
|
|
cc.RigidBody3D = _rigidBodyComponent.RigidBody3D;
|
||
|
|
cc.PhysicsRayResult = _physicsRayResult.PhysicsRayResult;
|
||
|
|
cc.ConstantForce = _constantForce.ConstantForce;
|
||
|
|
}, {
|
||
|
|
"./assets/physics-material": 11,
|
||
|
|
"./components/collider/box-collider-component": 12,
|
||
|
|
"./components/collider/collider-component": 13,
|
||
|
|
"./components/collider/sphere-collider-component": 14,
|
||
|
|
"./components/constant-force": 15,
|
||
|
|
"./components/rigid-body-component": 16,
|
||
|
|
"./physics-manager": 20,
|
||
|
|
"./physics-ray-result": 21
|
||
|
|
} ],
|
||
|
|
18: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.createPhysicsWorld = createPhysicsWorld;
|
||
|
|
exports.createRigidBody = createRigidBody;
|
||
|
|
exports.createBoxShape = createBoxShape;
|
||
|
|
exports.createSphereShape = createSphereShape;
|
||
|
|
var _physicsSelector = require("./physics-selector");
|
||
|
|
function createPhysicsWorld() {
|
||
|
|
return new _physicsSelector.PhysicsWorld();
|
||
|
|
}
|
||
|
|
function createRigidBody() {
|
||
|
|
return new _physicsSelector.RigidBody();
|
||
|
|
}
|
||
|
|
function createBoxShape(size) {
|
||
|
|
return new _physicsSelector.BoxShape(size);
|
||
|
|
}
|
||
|
|
function createSphereShape(radius) {
|
||
|
|
return new _physicsSelector.SphereShape(radius);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
"./physics-selector": 22
|
||
|
|
} ],
|
||
|
|
19: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.ERigidBodyType = void 0;
|
||
|
|
var ERigidBodyType;
|
||
|
|
exports.ERigidBodyType = ERigidBodyType;
|
||
|
|
(function(ERigidBodyType) {
|
||
|
|
ERigidBodyType[ERigidBodyType["DYNAMIC"] = 1] = "DYNAMIC";
|
||
|
|
ERigidBodyType[ERigidBodyType["STATIC"] = 2] = "STATIC";
|
||
|
|
ERigidBodyType[ERigidBodyType["KINEMATIC"] = 4] = "KINEMATIC";
|
||
|
|
})(ERigidBodyType || (exports.ERigidBodyType = ERigidBodyType = {}));
|
||
|
|
}, {} ],
|
||
|
|
20: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.Physics3DManager = void 0;
|
||
|
|
var _instance = require("./instance");
|
||
|
|
var _physicsMaterial = require("./assets/physics-material");
|
||
|
|
var _physicsRayResult = require("./physics-ray-result");
|
||
|
|
var _dec, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _temp;
|
||
|
|
function _initializerDefineProperty(target, property, descriptor, context) {
|
||
|
|
if (!descriptor) return;
|
||
|
|
Object.defineProperty(target, property, {
|
||
|
|
enumerable: descriptor.enumerable,
|
||
|
|
configurable: descriptor.configurable,
|
||
|
|
writable: descriptor.writable,
|
||
|
|
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
|
||
|
|
var desc = {};
|
||
|
|
Object.keys(descriptor).forEach(function(key) {
|
||
|
|
desc[key] = descriptor[key];
|
||
|
|
});
|
||
|
|
desc.enumerable = !!desc.enumerable;
|
||
|
|
desc.configurable = !!desc.configurable;
|
||
|
|
("value" in desc || desc.initializer) && (desc.writable = true);
|
||
|
|
desc = decorators.slice().reverse().reduce(function(desc, decorator) {
|
||
|
|
return decorator(target, property, desc) || desc;
|
||
|
|
}, desc);
|
||
|
|
if (context && void 0 !== desc.initializer) {
|
||
|
|
desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
|
||
|
|
desc.initializer = void 0;
|
||
|
|
}
|
||
|
|
if (void 0 === desc.initializer) {
|
||
|
|
Object.defineProperty(target, property, desc);
|
||
|
|
desc = null;
|
||
|
|
}
|
||
|
|
return desc;
|
||
|
|
}
|
||
|
|
function _initializerWarningHelper(descriptor, context) {
|
||
|
|
throw new Error("Decorating class property failed. Please ensure that proposal-class-properties is enabled and runs after the decorators transform.");
|
||
|
|
}
|
||
|
|
var _cc$_decorator = cc._decorator, property = _cc$_decorator.property, ccclass = _cc$_decorator.ccclass;
|
||
|
|
var Physics3DManager = (_dec = ccclass("cc.Physics3DManager"), _dec(_class = (_class2 = (_temp = function() {
|
||
|
|
_createClass(Physics3DManager, [ {
|
||
|
|
key: "enabled",
|
||
|
|
get: function get() {
|
||
|
|
return this._enabled;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._enabled = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "allowSleep",
|
||
|
|
get: function get() {
|
||
|
|
return this._allowSleep;
|
||
|
|
},
|
||
|
|
set: function set(v) {
|
||
|
|
this._allowSleep = v;
|
||
|
|
true, true;
|
||
|
|
this.physicsWorld.allowSleep = this._allowSleep;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "maxSubStep",
|
||
|
|
get: function get() {
|
||
|
|
return this._maxSubStep;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._maxSubStep = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "deltaTime",
|
||
|
|
get: function get() {
|
||
|
|
return this._fixedTime;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._fixedTime = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "useFixedTime",
|
||
|
|
get: function get() {
|
||
|
|
return this._useFixedTime;
|
||
|
|
},
|
||
|
|
set: function set(value) {
|
||
|
|
this._useFixedTime = value;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "gravity",
|
||
|
|
get: function get() {
|
||
|
|
return this._gravity;
|
||
|
|
},
|
||
|
|
set: function set(gravity) {
|
||
|
|
this._gravity.set(gravity);
|
||
|
|
true, true;
|
||
|
|
this.physicsWorld.gravity = gravity;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "defaultMaterial",
|
||
|
|
get: function get() {
|
||
|
|
return this._material;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
function Physics3DManager() {
|
||
|
|
this.physicsWorld = void 0;
|
||
|
|
this.raycastClosestResult = new _physicsRayResult.PhysicsRayResult();
|
||
|
|
this.raycastResults = [];
|
||
|
|
_initializerDefineProperty(this, "_enabled", _descriptor, this);
|
||
|
|
_initializerDefineProperty(this, "_allowSleep", _descriptor2, this);
|
||
|
|
_initializerDefineProperty(this, "_gravity", _descriptor3, this);
|
||
|
|
_initializerDefineProperty(this, "_maxSubStep", _descriptor4, this);
|
||
|
|
_initializerDefineProperty(this, "_fixedTime", _descriptor5, this);
|
||
|
|
_initializerDefineProperty(this, "_useFixedTime", _descriptor6, this);
|
||
|
|
this.useAccumulator = false;
|
||
|
|
this._accumulator = 0;
|
||
|
|
this.useFixedDigit = false;
|
||
|
|
this.useInternalTime = false;
|
||
|
|
this.fixDigits = {
|
||
|
|
position: 5,
|
||
|
|
rotation: 12,
|
||
|
|
timeNow: 3
|
||
|
|
};
|
||
|
|
this._deltaTime = 0;
|
||
|
|
this._lastTime = 0;
|
||
|
|
this._material = null;
|
||
|
|
this.raycastOptions = {
|
||
|
|
groupIndex: -1,
|
||
|
|
queryTrigger: true,
|
||
|
|
maxDistance: Infinity
|
||
|
|
};
|
||
|
|
this.raycastResultPool = new cc.RecyclePool(function() {
|
||
|
|
return new _physicsRayResult.PhysicsRayResult();
|
||
|
|
}, 1);
|
||
|
|
cc.director._scheduler && cc.director._scheduler.enableForTarget(this);
|
||
|
|
this.physicsWorld = (0, _instance.createPhysicsWorld)();
|
||
|
|
this._lastTime = performance.now();
|
||
|
|
true;
|
||
|
|
this.gravity = this._gravity;
|
||
|
|
this.allowSleep = this._allowSleep;
|
||
|
|
this._material = new _physicsMaterial.PhysicsMaterial();
|
||
|
|
this._material.friction = .1;
|
||
|
|
this._material.restitution = .1;
|
||
|
|
this._material.on("physics_material_update", this._updateMaterial, this);
|
||
|
|
this.physicsWorld.defaultMaterial = this._material;
|
||
|
|
}
|
||
|
|
var _proto = Physics3DManager.prototype;
|
||
|
|
_proto.update = function update(deltaTime) {
|
||
|
|
false;
|
||
|
|
if (!this._enabled) return;
|
||
|
|
if (this.useInternalTime) {
|
||
|
|
var now = parseFloat(performance.now().toFixed(this.fixDigits.timeNow));
|
||
|
|
this._deltaTime = now > this._lastTime ? (now - this._lastTime) / 1e3 : 0;
|
||
|
|
this._lastTime = now;
|
||
|
|
} else this._deltaTime = deltaTime;
|
||
|
|
cc.director.emit(cc.Director.EVENT_BEFORE_PHYSICS);
|
||
|
|
false;
|
||
|
|
if (this._useFixedTime) this.physicsWorld.step(this._fixedTime); else if (this.useAccumulator) {
|
||
|
|
var i = 0;
|
||
|
|
this._accumulator += this._deltaTime;
|
||
|
|
while (i < this._maxSubStep && this._accumulator > this._fixedTime) {
|
||
|
|
this.physicsWorld.step(this._fixedTime);
|
||
|
|
this._accumulator -= this._fixedTime;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
} else this.physicsWorld.step(this._fixedTime, this._deltaTime, this._maxSubStep);
|
||
|
|
cc.director.emit(cc.Director.EVENT_AFTER_PHYSICS);
|
||
|
|
};
|
||
|
|
_proto.raycast = function raycast(worldRay, groupIndexOrName, maxDistance, queryTrigger) {
|
||
|
|
void 0 === groupIndexOrName && (groupIndexOrName = 0);
|
||
|
|
void 0 === maxDistance && (maxDistance = Infinity);
|
||
|
|
void 0 === queryTrigger && (queryTrigger = true);
|
||
|
|
this.raycastResultPool.reset();
|
||
|
|
this.raycastResults.length = 0;
|
||
|
|
if ("string" == typeof groupIndexOrName) {
|
||
|
|
var groupIndex = cc.game.groupList.indexOf(groupIndexOrName);
|
||
|
|
-1 == groupIndex && (groupIndex = 0);
|
||
|
|
this.raycastOptions.groupIndex = groupIndex;
|
||
|
|
} else this.raycastOptions.groupIndex = groupIndexOrName;
|
||
|
|
this.raycastOptions.maxDistance = maxDistance;
|
||
|
|
this.raycastOptions.queryTrigger = queryTrigger;
|
||
|
|
var result = this.physicsWorld.raycast(worldRay, this.raycastOptions, this.raycastResultPool, this.raycastResults);
|
||
|
|
if (result) return this.raycastResults;
|
||
|
|
return null;
|
||
|
|
};
|
||
|
|
_proto.raycastClosest = function raycastClosest(worldRay, groupIndexOrName, maxDistance, queryTrigger) {
|
||
|
|
void 0 === groupIndexOrName && (groupIndexOrName = 0);
|
||
|
|
void 0 === maxDistance && (maxDistance = Infinity);
|
||
|
|
void 0 === queryTrigger && (queryTrigger = true);
|
||
|
|
if ("string" == typeof groupIndexOrName) {
|
||
|
|
var groupIndex = cc.game.groupList.indexOf(groupIndexOrName);
|
||
|
|
-1 == groupIndex && (groupIndex = 0);
|
||
|
|
this.raycastOptions.groupIndex = groupIndex;
|
||
|
|
} else this.raycastOptions.groupIndex = groupIndexOrName;
|
||
|
|
this.raycastOptions.maxDistance = maxDistance;
|
||
|
|
this.raycastOptions.queryTrigger = queryTrigger;
|
||
|
|
var result = this.physicsWorld.raycastClosest(worldRay, this.raycastOptions, this.raycastClosestResult);
|
||
|
|
if (result) return this.raycastClosestResult;
|
||
|
|
return null;
|
||
|
|
};
|
||
|
|
_proto._updateMaterial = function _updateMaterial() {
|
||
|
|
true;
|
||
|
|
this.physicsWorld.defaultMaterial = this._material;
|
||
|
|
};
|
||
|
|
return Physics3DManager;
|
||
|
|
}(), _temp), _descriptor = _applyDecoratedDescriptor(_class2.prototype, "_enabled", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_allowSleep", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "_gravity", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return new cc.Vec3(0, -10, 0);
|
||
|
|
}
|
||
|
|
}), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "_maxSubStep", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}), _descriptor5 = _applyDecoratedDescriptor(_class2.prototype, "_fixedTime", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return 1 / 60;
|
||
|
|
}
|
||
|
|
}), _descriptor6 = _applyDecoratedDescriptor(_class2.prototype, "_useFixedTime", [ property ], {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
initializer: function initializer() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}), _class2)) || _class);
|
||
|
|
exports.Physics3DManager = Physics3DManager;
|
||
|
|
}, {
|
||
|
|
"./assets/physics-material": 11,
|
||
|
|
"./instance": 18,
|
||
|
|
"./physics-ray-result": 21
|
||
|
|
} ],
|
||
|
|
21: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.PhysicsRayResult = void 0;
|
||
|
|
function _defineProperties(target, props) {
|
||
|
|
for (var i = 0; i < props.length; i++) {
|
||
|
|
var descriptor = props[i];
|
||
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
||
|
|
descriptor.configurable = true;
|
||
|
|
"value" in descriptor && (descriptor.writable = true);
|
||
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
protoProps && _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
staticProps && _defineProperties(Constructor, staticProps);
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var PhysicsRayResult = function() {
|
||
|
|
function PhysicsRayResult() {
|
||
|
|
this._hitPoint = new Vec3();
|
||
|
|
this._distance = 0;
|
||
|
|
this._collidier = null;
|
||
|
|
}
|
||
|
|
var _proto = PhysicsRayResult.prototype;
|
||
|
|
_proto._assign = function _assign(hitPoint, distance, collider) {
|
||
|
|
Vec3.copy(this._hitPoint, hitPoint);
|
||
|
|
this._distance = distance;
|
||
|
|
this._collidier = collider;
|
||
|
|
};
|
||
|
|
_proto.clone = function clone() {
|
||
|
|
var c = new PhysicsRayResult();
|
||
|
|
Vec3.copy(c._hitPoint, this._hitPoint);
|
||
|
|
c._distance = this._distance;
|
||
|
|
c._collidier = this._collidier;
|
||
|
|
return c;
|
||
|
|
};
|
||
|
|
_createClass(PhysicsRayResult, [ {
|
||
|
|
key: "hitPoint",
|
||
|
|
get: function get() {
|
||
|
|
return this._hitPoint;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "distance",
|
||
|
|
get: function get() {
|
||
|
|
return this._distance;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "collider",
|
||
|
|
get: function get() {
|
||
|
|
return this._collidier;
|
||
|
|
}
|
||
|
|
} ]);
|
||
|
|
return PhysicsRayResult;
|
||
|
|
}();
|
||
|
|
exports.PhysicsRayResult = PhysicsRayResult;
|
||
|
|
}, {} ],
|
||
|
|
22: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.instantiate = instantiate;
|
||
|
|
exports.PhysicsWorld = exports.RigidBody = exports.SphereShape = exports.BoxShape = void 0;
|
||
|
|
var BoxShape;
|
||
|
|
exports.BoxShape = BoxShape;
|
||
|
|
var SphereShape;
|
||
|
|
exports.SphereShape = SphereShape;
|
||
|
|
var RigidBody;
|
||
|
|
exports.RigidBody = RigidBody;
|
||
|
|
var PhysicsWorld;
|
||
|
|
exports.PhysicsWorld = PhysicsWorld;
|
||
|
|
function instantiate(boxShape, sphereShape, body, world) {
|
||
|
|
exports.BoxShape = BoxShape = boxShape;
|
||
|
|
exports.SphereShape = SphereShape = sphereShape;
|
||
|
|
exports.RigidBody = RigidBody = body;
|
||
|
|
exports.PhysicsWorld = PhysicsWorld = world;
|
||
|
|
}
|
||
|
|
}, {} ],
|
||
|
|
23: [ function(require, module, exports) {
|
||
|
|
"use strict";
|
||
|
|
exports.__esModule = true;
|
||
|
|
exports.stringfyVec3 = stringfyVec3;
|
||
|
|
exports.stringfyQuat = stringfyQuat;
|
||
|
|
exports.setWrap = setWrap;
|
||
|
|
exports.getWrap = getWrap;
|
||
|
|
exports.clearNodeTransformDirtyFlag = clearNodeTransformDirtyFlag;
|
||
|
|
exports.clearNodeTransformRecord = clearNodeTransformRecord;
|
||
|
|
exports.updateWorldTransform = updateWorldTransform;
|
||
|
|
exports.updateWorldRT = updateWorldRT;
|
||
|
|
exports.worldDirty = worldDirty;
|
||
|
|
function stringfyVec3(value) {
|
||
|
|
return "(x: " + value.x + ", y: " + value.y + ", z: " + value.z + ")";
|
||
|
|
}
|
||
|
|
function stringfyQuat(value) {
|
||
|
|
return "(x: " + value.x + ", y: " + value.y + ", z: " + value.z + ", w: " + value.w + ")";
|
||
|
|
}
|
||
|
|
function setWrap(object, wrapper) {
|
||
|
|
object.__cc_wrapper__ = wrapper;
|
||
|
|
}
|
||
|
|
function getWrap(object) {
|
||
|
|
return object.__cc_wrapper__;
|
||
|
|
}
|
||
|
|
var LocalDirtyFlag = cc.Node._LocalDirtyFlag;
|
||
|
|
var PHYSICS_TRS = LocalDirtyFlag.PHYSICS_TRS;
|
||
|
|
var ALL_TRS = LocalDirtyFlag.ALL_TRS;
|
||
|
|
var SKEW = LocalDirtyFlag.SKEW;
|
||
|
|
var FLAG_TRANSFORM = cc.RenderFlow.FLAG_TRANSFORM;
|
||
|
|
var Mat3 = cc.Mat3;
|
||
|
|
var Mat4 = cc.Mat4;
|
||
|
|
var Vec3 = cc.Vec3;
|
||
|
|
var Quat = cc.Quat;
|
||
|
|
var Trs = cc.Trs;
|
||
|
|
var _nodeArray = [];
|
||
|
|
var _lpos = cc.v3();
|
||
|
|
var _lrot = cc.quat();
|
||
|
|
var _mat3 = new Mat3();
|
||
|
|
var _mat3m = _mat3.m;
|
||
|
|
var _quat = cc.quat();
|
||
|
|
var _mat4 = cc.mat4();
|
||
|
|
var _nodeTransformRecord = {};
|
||
|
|
function clearNodeTransformDirtyFlag() {
|
||
|
|
for (var key in _nodeTransformRecord) {
|
||
|
|
var physicsNode = _nodeTransformRecord[key];
|
||
|
|
physicsNode._localMatDirty &= ~ALL_TRS;
|
||
|
|
if (!(physicsNode._localMatDirty & SKEW)) {
|
||
|
|
physicsNode._worldMatDirty = false;
|
||
|
|
true, physicsNode._renderFlag &= ~FLAG_TRANSFORM;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_nodeTransformRecord = {};
|
||
|
|
_nodeArray.length = 0;
|
||
|
|
}
|
||
|
|
function clearNodeTransformRecord() {
|
||
|
|
_nodeTransformRecord = {};
|
||
|
|
_nodeArray.length = 0;
|
||
|
|
}
|
||
|
|
function updateWorldTransform(node, traverseAllNode) {
|
||
|
|
void 0 === traverseAllNode && (traverseAllNode = false);
|
||
|
|
var cur = node;
|
||
|
|
var i = 0;
|
||
|
|
var needUpdateTransform = false;
|
||
|
|
var physicsDirtyFlag = 0;
|
||
|
|
while (cur) {
|
||
|
|
if (!traverseAllNode && _nodeTransformRecord[cur._id]) {
|
||
|
|
physicsDirtyFlag |= cur._localMatDirty & PHYSICS_TRS;
|
||
|
|
needUpdateTransform = needUpdateTransform || !!physicsDirtyFlag;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
_nodeArray[i++] = cur;
|
||
|
|
cur._localMatDirty & PHYSICS_TRS && (needUpdateTransform = true);
|
||
|
|
cur = cur._parent;
|
||
|
|
}
|
||
|
|
if (!needUpdateTransform) return false;
|
||
|
|
var child;
|
||
|
|
var childWorldMat, curWorldMat, childTrs, childLocalMat;
|
||
|
|
var wpos, wrot, wscale;
|
||
|
|
_nodeArray.length = i;
|
||
|
|
while (i) {
|
||
|
|
child = _nodeArray[--i];
|
||
|
|
!traverseAllNode && (_nodeTransformRecord[child._id] = child);
|
||
|
|
childWorldMat = child._worldMatrix;
|
||
|
|
childLocalMat = child._matrix;
|
||
|
|
childTrs = child._trs;
|
||
|
|
wpos = child.__wpos = child.__wpos || cc.v3();
|
||
|
|
wrot = child.__wrot = child.__wrot || cc.quat();
|
||
|
|
wscale = child.__wscale = child.__wscale || cc.v3();
|
||
|
|
child._localMatDirty & PHYSICS_TRS && Trs.toMat4(childLocalMat, childTrs);
|
||
|
|
child._localMatDirty |= physicsDirtyFlag;
|
||
|
|
physicsDirtyFlag |= child._localMatDirty & PHYSICS_TRS;
|
||
|
|
if (!(physicsDirtyFlag & PHYSICS_TRS)) {
|
||
|
|
cur = child;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (cur) {
|
||
|
|
curWorldMat = cur._worldMatrix;
|
||
|
|
Trs.toPosition(_lpos, childTrs);
|
||
|
|
Vec3.transformMat4(wpos, _lpos, curWorldMat);
|
||
|
|
Mat4.multiply(childWorldMat, curWorldMat, childLocalMat);
|
||
|
|
Trs.toRotation(_lrot, childTrs);
|
||
|
|
Quat.multiply(wrot, cur.__wrot, _lrot);
|
||
|
|
Mat3.fromQuat(_mat3, Quat.conjugate(_quat, wrot));
|
||
|
|
Mat3.multiplyMat4(_mat3, _mat3, childWorldMat);
|
||
|
|
wscale.x = _mat3m[0];
|
||
|
|
wscale.y = _mat3m[4];
|
||
|
|
wscale.z = _mat3m[8];
|
||
|
|
} else {
|
||
|
|
Trs.toPosition(wpos, childTrs);
|
||
|
|
Trs.toRotation(wrot, childTrs);
|
||
|
|
Trs.toScale(wscale, childTrs);
|
||
|
|
Mat4.copy(childWorldMat, childLocalMat);
|
||
|
|
}
|
||
|
|
cur = child;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
function updateWorldRT(node, position, rotation) {
|
||
|
|
var parent = node.parent;
|
||
|
|
if (parent) {
|
||
|
|
updateWorldTransform(parent, true);
|
||
|
|
Vec3.transformMat4(_lpos, position, Mat4.invert(_mat4, parent._worldMatrix));
|
||
|
|
Quat.multiply(_quat, Quat.conjugate(_quat, parent.__wrot), rotation);
|
||
|
|
node.setPosition(_lpos);
|
||
|
|
node.setRotation(_quat);
|
||
|
|
} else {
|
||
|
|
node.setPosition(position);
|
||
|
|
node.setRotation(rotation);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function worldDirty(node) {
|
||
|
|
var cur = node;
|
||
|
|
while (cur) {
|
||
|
|
if (cur._worldMatDirty) return true;
|
||
|
|
cur = cur._parent;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}, {} ],
|
||
|
|
24: [ function(require, module, exports) {
|
||
|
|
(function(global) {
|
||
|
|
"use strict";
|
||
|
|
!function(e) {
|
||
|
|
if ("object" == typeof exports && "undefined" != typeof module) module.exports = e(); else if ("function" == typeof define && define.amd) define([], e); else {
|
||
|
|
var f;
|
||
|
|
"undefined" != typeof window ? f = window : "undefined" != typeof global ? f = global : "undefined" != typeof self && (f = self),
|
||
|
|
f.CANNON = e();
|
||
|
|
}
|
||
|
|
}(function() {
|
||
|
|
var define, module, exports;
|
||
|
|
return function e(t, n, r) {
|
||
|
|
function s(o, u) {
|
||
|
|
if (!n[o]) {
|
||
|
|
if (!t[o]) {
|
||
|
|
var a = "function" == typeof require && require;
|
||
|
|
if (!u && a) return a(o, !0);
|
||
|
|
if (i) return i(o, !0);
|
||
|
|
throw new Error("Cannot find module '" + o + "'");
|
||
|
|
}
|
||
|
|
var f = n[o] = {
|
||
|
|
exports: {}
|
||
|
|
};
|
||
|
|
t[o][0].call(f.exports, function(e) {
|
||
|
|
var n = t[o][1][e];
|
||
|
|
return s(n || e);
|
||
|
|
}, f, f.exports, e, t, n, r);
|
||
|
|
}
|
||
|
|
return n[o].exports;
|
||
|
|
}
|
||
|
|
var i = "function" == typeof require && require;
|
||
|
|
for (var o = 0; o < r.length; o++) s(r[o]);
|
||
|
|
return s;
|
||
|
|
}({
|
||
|
|
1: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = {
|
||
|
|
name: "@cocos/cannon",
|
||
|
|
version: "1.1.1-exp.3",
|
||
|
|
description: "A lightweight 3D physics engine written in JavaScript.",
|
||
|
|
homepage: "https://github.com/cocos-creator/cannon.js",
|
||
|
|
author: "Stefan Hedman <schteppe@gmail.com> (http://steffe.se), JayceLai",
|
||
|
|
keywords: [ "cannon.js", "cocos", "creator", "physics", "engine", "3d" ],
|
||
|
|
scripts: {
|
||
|
|
build: "grunt && npm run preprocess && grunt addLicense && grunt addDate",
|
||
|
|
preprocess: "node node_modules/uglify-js/bin/uglifyjs build/cannon.js -o build/cannon.min.js -c -m"
|
||
|
|
},
|
||
|
|
main: "./build/cannon.min.js",
|
||
|
|
engines: {
|
||
|
|
node: "*"
|
||
|
|
},
|
||
|
|
repository: {
|
||
|
|
type: "git",
|
||
|
|
url: "https://github.com/cocos-creator/cannon.js.git"
|
||
|
|
},
|
||
|
|
bugs: {
|
||
|
|
url: "https://github.com/cocos-creator/cannon.js/issues"
|
||
|
|
},
|
||
|
|
licenses: [ {
|
||
|
|
type: "MIT"
|
||
|
|
} ],
|
||
|
|
devDependencies: {
|
||
|
|
jshint: "latest",
|
||
|
|
"uglify-js": "latest",
|
||
|
|
nodeunit: "^0.9.0",
|
||
|
|
grunt: "~0.4.0",
|
||
|
|
"grunt-contrib-jshint": "~0.1.1",
|
||
|
|
"grunt-contrib-nodeunit": "^0.4.1",
|
||
|
|
"grunt-contrib-concat": "~0.1.3",
|
||
|
|
"grunt-contrib-uglify": "^0.5.1",
|
||
|
|
"grunt-browserify": "^2.1.4",
|
||
|
|
"grunt-contrib-yuidoc": "^0.5.2",
|
||
|
|
browserify: "*"
|
||
|
|
},
|
||
|
|
dependencies: {}
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
2: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = {
|
||
|
|
version: _dereq_("../package.json").version,
|
||
|
|
AABB: _dereq_("./collision/AABB"),
|
||
|
|
ArrayCollisionMatrix: _dereq_("./collision/ArrayCollisionMatrix"),
|
||
|
|
Body: _dereq_("./objects/Body"),
|
||
|
|
Box: _dereq_("./shapes/Box"),
|
||
|
|
Broadphase: _dereq_("./collision/Broadphase"),
|
||
|
|
Constraint: _dereq_("./constraints/Constraint"),
|
||
|
|
ContactEquation: _dereq_("./equations/ContactEquation"),
|
||
|
|
Narrowphase: _dereq_("./world/Narrowphase"),
|
||
|
|
ConeTwistConstraint: _dereq_("./constraints/ConeTwistConstraint"),
|
||
|
|
ContactMaterial: _dereq_("./material/ContactMaterial"),
|
||
|
|
ConvexPolyhedron: _dereq_("./shapes/ConvexPolyhedron"),
|
||
|
|
Cylinder: _dereq_("./shapes/Cylinder"),
|
||
|
|
DistanceConstraint: _dereq_("./constraints/DistanceConstraint"),
|
||
|
|
Equation: _dereq_("./equations/Equation"),
|
||
|
|
EventTarget: _dereq_("./utils/EventTarget"),
|
||
|
|
FrictionEquation: _dereq_("./equations/FrictionEquation"),
|
||
|
|
GSSolver: _dereq_("./solver/GSSolver"),
|
||
|
|
GridBroadphase: _dereq_("./collision/GridBroadphase"),
|
||
|
|
Heightfield: _dereq_("./shapes/Heightfield"),
|
||
|
|
HingeConstraint: _dereq_("./constraints/HingeConstraint"),
|
||
|
|
LockConstraint: _dereq_("./constraints/LockConstraint"),
|
||
|
|
Mat3: _dereq_("./math/Mat3"),
|
||
|
|
Material: _dereq_("./material/Material"),
|
||
|
|
NaiveBroadphase: _dereq_("./collision/NaiveBroadphase"),
|
||
|
|
ObjectCollisionMatrix: _dereq_("./collision/ObjectCollisionMatrix"),
|
||
|
|
Pool: _dereq_("./utils/Pool"),
|
||
|
|
Particle: _dereq_("./shapes/Particle"),
|
||
|
|
Plane: _dereq_("./shapes/Plane"),
|
||
|
|
PointToPointConstraint: _dereq_("./constraints/PointToPointConstraint"),
|
||
|
|
Quaternion: _dereq_("./math/Quaternion"),
|
||
|
|
Ray: _dereq_("./collision/Ray"),
|
||
|
|
RaycastVehicle: _dereq_("./objects/RaycastVehicle"),
|
||
|
|
RaycastResult: _dereq_("./collision/RaycastResult"),
|
||
|
|
RigidVehicle: _dereq_("./objects/RigidVehicle"),
|
||
|
|
RotationalEquation: _dereq_("./equations/RotationalEquation"),
|
||
|
|
RotationalMotorEquation: _dereq_("./equations/RotationalMotorEquation"),
|
||
|
|
SAPBroadphase: _dereq_("./collision/SAPBroadphase"),
|
||
|
|
SPHSystem: _dereq_("./objects/SPHSystem"),
|
||
|
|
Shape: _dereq_("./shapes/Shape"),
|
||
|
|
Solver: _dereq_("./solver/Solver"),
|
||
|
|
Sphere: _dereq_("./shapes/Sphere"),
|
||
|
|
SplitSolver: _dereq_("./solver/SplitSolver"),
|
||
|
|
Spring: _dereq_("./objects/Spring"),
|
||
|
|
Transform: _dereq_("./math/Transform"),
|
||
|
|
Trimesh: _dereq_("./shapes/Trimesh"),
|
||
|
|
Vec3: _dereq_("./math/Vec3"),
|
||
|
|
Vec3Pool: _dereq_("./utils/Vec3Pool"),
|
||
|
|
World: _dereq_("./world/World"),
|
||
|
|
Octree: _dereq_("./utils/Octree"),
|
||
|
|
CMath: _dereq_("./math/CMath")
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../package.json": 1,
|
||
|
|
"./collision/AABB": 3,
|
||
|
|
"./collision/ArrayCollisionMatrix": 4,
|
||
|
|
"./collision/Broadphase": 5,
|
||
|
|
"./collision/GridBroadphase": 6,
|
||
|
|
"./collision/NaiveBroadphase": 7,
|
||
|
|
"./collision/ObjectCollisionMatrix": 8,
|
||
|
|
"./collision/Ray": 10,
|
||
|
|
"./collision/RaycastResult": 11,
|
||
|
|
"./collision/SAPBroadphase": 12,
|
||
|
|
"./constraints/ConeTwistConstraint": 13,
|
||
|
|
"./constraints/Constraint": 14,
|
||
|
|
"./constraints/DistanceConstraint": 15,
|
||
|
|
"./constraints/HingeConstraint": 16,
|
||
|
|
"./constraints/LockConstraint": 17,
|
||
|
|
"./constraints/PointToPointConstraint": 18,
|
||
|
|
"./equations/ContactEquation": 20,
|
||
|
|
"./equations/Equation": 21,
|
||
|
|
"./equations/FrictionEquation": 22,
|
||
|
|
"./equations/RotationalEquation": 23,
|
||
|
|
"./equations/RotationalMotorEquation": 24,
|
||
|
|
"./material/ContactMaterial": 25,
|
||
|
|
"./material/Material": 26,
|
||
|
|
"./math/CMath": 27,
|
||
|
|
"./math/Mat3": 29,
|
||
|
|
"./math/Quaternion": 30,
|
||
|
|
"./math/Transform": 31,
|
||
|
|
"./math/Vec3": 32,
|
||
|
|
"./objects/Body": 33,
|
||
|
|
"./objects/RaycastVehicle": 34,
|
||
|
|
"./objects/RigidVehicle": 35,
|
||
|
|
"./objects/SPHSystem": 36,
|
||
|
|
"./objects/Spring": 37,
|
||
|
|
"./shapes/Box": 39,
|
||
|
|
"./shapes/ConvexPolyhedron": 40,
|
||
|
|
"./shapes/Cylinder": 41,
|
||
|
|
"./shapes/Heightfield": 42,
|
||
|
|
"./shapes/Particle": 43,
|
||
|
|
"./shapes/Plane": 44,
|
||
|
|
"./shapes/Shape": 45,
|
||
|
|
"./shapes/Sphere": 46,
|
||
|
|
"./shapes/Trimesh": 47,
|
||
|
|
"./solver/GSSolver": 48,
|
||
|
|
"./solver/Solver": 49,
|
||
|
|
"./solver/SplitSolver": 50,
|
||
|
|
"./utils/EventTarget": 51,
|
||
|
|
"./utils/Octree": 52,
|
||
|
|
"./utils/Pool": 53,
|
||
|
|
"./utils/Vec3Pool": 56,
|
||
|
|
"./world/Narrowphase": 57,
|
||
|
|
"./world/World": 58
|
||
|
|
} ],
|
||
|
|
3: [ function(_dereq_, module, exports) {
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Utils = _dereq_("../utils/Utils");
|
||
|
|
module.exports = AABB;
|
||
|
|
function AABB(options) {
|
||
|
|
options = options || {};
|
||
|
|
this.lowerBound = new Vec3();
|
||
|
|
options.lowerBound && this.lowerBound.copy(options.lowerBound);
|
||
|
|
this.upperBound = new Vec3();
|
||
|
|
options.upperBound && this.upperBound.copy(options.upperBound);
|
||
|
|
}
|
||
|
|
var tmp = new Vec3();
|
||
|
|
AABB.prototype.setFromPoints = function(points, position, quaternion, skinSize) {
|
||
|
|
var l = this.lowerBound, u = this.upperBound, q = quaternion;
|
||
|
|
l.copy(points[0]);
|
||
|
|
q && q.vmult(l, l);
|
||
|
|
u.copy(l);
|
||
|
|
for (var i = 1; i < points.length; i++) {
|
||
|
|
var p = points[i];
|
||
|
|
if (q) {
|
||
|
|
q.vmult(p, tmp);
|
||
|
|
p = tmp;
|
||
|
|
}
|
||
|
|
p.x > u.x && (u.x = p.x);
|
||
|
|
p.x < l.x && (l.x = p.x);
|
||
|
|
p.y > u.y && (u.y = p.y);
|
||
|
|
p.y < l.y && (l.y = p.y);
|
||
|
|
p.z > u.z && (u.z = p.z);
|
||
|
|
p.z < l.z && (l.z = p.z);
|
||
|
|
}
|
||
|
|
if (position) {
|
||
|
|
position.vadd(l, l);
|
||
|
|
position.vadd(u, u);
|
||
|
|
}
|
||
|
|
if (skinSize) {
|
||
|
|
l.x -= skinSize;
|
||
|
|
l.y -= skinSize;
|
||
|
|
l.z -= skinSize;
|
||
|
|
u.x += skinSize;
|
||
|
|
u.y += skinSize;
|
||
|
|
u.z += skinSize;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
AABB.prototype.copy = function(aabb) {
|
||
|
|
this.lowerBound.copy(aabb.lowerBound);
|
||
|
|
this.upperBound.copy(aabb.upperBound);
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
AABB.prototype.clone = function() {
|
||
|
|
return new AABB().copy(this);
|
||
|
|
};
|
||
|
|
AABB.prototype.extend = function(aabb) {
|
||
|
|
this.lowerBound.x = Math.min(this.lowerBound.x, aabb.lowerBound.x);
|
||
|
|
this.upperBound.x = Math.max(this.upperBound.x, aabb.upperBound.x);
|
||
|
|
this.lowerBound.y = Math.min(this.lowerBound.y, aabb.lowerBound.y);
|
||
|
|
this.upperBound.y = Math.max(this.upperBound.y, aabb.upperBound.y);
|
||
|
|
this.lowerBound.z = Math.min(this.lowerBound.z, aabb.lowerBound.z);
|
||
|
|
this.upperBound.z = Math.max(this.upperBound.z, aabb.upperBound.z);
|
||
|
|
};
|
||
|
|
AABB.prototype.overlaps = function(aabb) {
|
||
|
|
var l1 = this.lowerBound, u1 = this.upperBound, l2 = aabb.lowerBound, u2 = aabb.upperBound;
|
||
|
|
var overlapsX = l2.x <= u1.x && u1.x <= u2.x || l1.x <= u2.x && u2.x <= u1.x;
|
||
|
|
var overlapsY = l2.y <= u1.y && u1.y <= u2.y || l1.y <= u2.y && u2.y <= u1.y;
|
||
|
|
var overlapsZ = l2.z <= u1.z && u1.z <= u2.z || l1.z <= u2.z && u2.z <= u1.z;
|
||
|
|
return overlapsX && overlapsY && overlapsZ;
|
||
|
|
};
|
||
|
|
AABB.prototype.volume = function() {
|
||
|
|
var l = this.lowerBound, u = this.upperBound;
|
||
|
|
return (u.x - l.x) * (u.y - l.y) * (u.z - l.z);
|
||
|
|
};
|
||
|
|
AABB.prototype.contains = function(aabb) {
|
||
|
|
var l1 = this.lowerBound, u1 = this.upperBound, l2 = aabb.lowerBound, u2 = aabb.upperBound;
|
||
|
|
return l1.x <= l2.x && u1.x >= u2.x && l1.y <= l2.y && u1.y >= u2.y && l1.z <= l2.z && u1.z >= u2.z;
|
||
|
|
};
|
||
|
|
AABB.prototype.getCorners = function(a, b, c, d, e, f, g, h) {
|
||
|
|
var l = this.lowerBound, u = this.upperBound;
|
||
|
|
a.copy(l);
|
||
|
|
b.set(u.x, l.y, l.z);
|
||
|
|
c.set(u.x, u.y, l.z);
|
||
|
|
d.set(l.x, u.y, u.z);
|
||
|
|
e.set(u.x, l.y, u.z);
|
||
|
|
f.set(l.x, u.y, l.z);
|
||
|
|
g.set(l.x, l.y, u.z);
|
||
|
|
h.copy(u);
|
||
|
|
};
|
||
|
|
var transformIntoFrame_corners = [ new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3() ];
|
||
|
|
AABB.prototype.toLocalFrame = function(frame, target) {
|
||
|
|
var corners = transformIntoFrame_corners;
|
||
|
|
var a = corners[0];
|
||
|
|
var b = corners[1];
|
||
|
|
var c = corners[2];
|
||
|
|
var d = corners[3];
|
||
|
|
var e = corners[4];
|
||
|
|
var f = corners[5];
|
||
|
|
var g = corners[6];
|
||
|
|
var h = corners[7];
|
||
|
|
this.getCorners(a, b, c, d, e, f, g, h);
|
||
|
|
for (var i = 0; 8 !== i; i++) {
|
||
|
|
var corner = corners[i];
|
||
|
|
frame.pointToLocal(corner, corner);
|
||
|
|
}
|
||
|
|
return target.setFromPoints(corners);
|
||
|
|
};
|
||
|
|
AABB.prototype.toWorldFrame = function(frame, target) {
|
||
|
|
var corners = transformIntoFrame_corners;
|
||
|
|
var a = corners[0];
|
||
|
|
var b = corners[1];
|
||
|
|
var c = corners[2];
|
||
|
|
var d = corners[3];
|
||
|
|
var e = corners[4];
|
||
|
|
var f = corners[5];
|
||
|
|
var g = corners[6];
|
||
|
|
var h = corners[7];
|
||
|
|
this.getCorners(a, b, c, d, e, f, g, h);
|
||
|
|
for (var i = 0; 8 !== i; i++) {
|
||
|
|
var corner = corners[i];
|
||
|
|
frame.pointToWorld(corner, corner);
|
||
|
|
}
|
||
|
|
return target.setFromPoints(corners);
|
||
|
|
};
|
||
|
|
AABB.prototype.overlapsRay = function(ray) {
|
||
|
|
var t = 0;
|
||
|
|
var dirFracX = 1 / ray._direction.x;
|
||
|
|
var dirFracY = 1 / ray._direction.y;
|
||
|
|
var dirFracZ = 1 / ray._direction.z;
|
||
|
|
var t1 = (this.lowerBound.x - ray.from.x) * dirFracX;
|
||
|
|
var t2 = (this.upperBound.x - ray.from.x) * dirFracX;
|
||
|
|
var t3 = (this.lowerBound.y - ray.from.y) * dirFracY;
|
||
|
|
var t4 = (this.upperBound.y - ray.from.y) * dirFracY;
|
||
|
|
var t5 = (this.lowerBound.z - ray.from.z) * dirFracZ;
|
||
|
|
var t6 = (this.upperBound.z - ray.from.z) * dirFracZ;
|
||
|
|
var tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6));
|
||
|
|
var tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6));
|
||
|
|
if (tmax < 0) return false;
|
||
|
|
if (tmin > tmax) return false;
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../utils/Utils": 55
|
||
|
|
} ],
|
||
|
|
4: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = ArrayCollisionMatrix;
|
||
|
|
function ArrayCollisionMatrix() {
|
||
|
|
this.matrix = [];
|
||
|
|
}
|
||
|
|
ArrayCollisionMatrix.prototype.get = function(i, j) {
|
||
|
|
i = i.index;
|
||
|
|
j = j.index;
|
||
|
|
if (j > i) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
return this.matrix[(i * (i + 1) >> 1) + j - 1];
|
||
|
|
};
|
||
|
|
ArrayCollisionMatrix.prototype.set = function(i, j, value) {
|
||
|
|
i = i.index;
|
||
|
|
j = j.index;
|
||
|
|
if (j > i) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
this.matrix[(i * (i + 1) >> 1) + j - 1] = value ? 1 : 0;
|
||
|
|
};
|
||
|
|
ArrayCollisionMatrix.prototype.reset = function() {
|
||
|
|
for (var i = 0, l = this.matrix.length; i !== l; i++) this.matrix[i] = 0;
|
||
|
|
};
|
||
|
|
ArrayCollisionMatrix.prototype.setNumObjects = function(n) {
|
||
|
|
this.matrix.length = n * (n - 1) >> 1;
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
5: [ function(_dereq_, module, exports) {
|
||
|
|
var Body = _dereq_("../objects/Body");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var Plane = _dereq_("../shapes/Plane");
|
||
|
|
module.exports = Broadphase;
|
||
|
|
function Broadphase() {
|
||
|
|
this.world = null;
|
||
|
|
this.useBoundingBoxes = false;
|
||
|
|
this.dirty = true;
|
||
|
|
}
|
||
|
|
Broadphase.prototype.collisionPairs = function(world, p1, p2) {
|
||
|
|
throw new Error("collisionPairs not implemented for this BroadPhase class!");
|
||
|
|
};
|
||
|
|
Broadphase.prototype.needBroadphaseCollision = function(bodyA, bodyB) {
|
||
|
|
if (0 === (bodyA.collisionFilterGroup & bodyB.collisionFilterMask) || 0 === (bodyB.collisionFilterGroup & bodyA.collisionFilterMask)) return false;
|
||
|
|
if (bodyA.hasTrigger || bodyB.hasTrigger) return true;
|
||
|
|
if ((0 !== (bodyA.type & Body.STATIC) || bodyA.sleepState === Body.SLEEPING) && (0 !== (bodyB.type & Body.STATIC) || bodyB.sleepState === Body.SLEEPING)) return false;
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
Broadphase.prototype.intersectionTest = function(bodyA, bodyB, pairs1, pairs2) {
|
||
|
|
this.useBoundingBoxes ? this.doBoundingBoxBroadphase(bodyA, bodyB, pairs1, pairs2) : this.doBoundingSphereBroadphase(bodyA, bodyB, pairs1, pairs2);
|
||
|
|
};
|
||
|
|
var Broadphase_collisionPairs_r = new Vec3(), Broadphase_collisionPairs_normal = new Vec3(), Broadphase_collisionPairs_quat = new Quaternion(), Broadphase_collisionPairs_relpos = new Vec3();
|
||
|
|
Broadphase.prototype.doBoundingSphereBroadphase = function(bodyA, bodyB, pairs1, pairs2) {
|
||
|
|
var r = Broadphase_collisionPairs_r;
|
||
|
|
bodyB.position.vsub(bodyA.position, r);
|
||
|
|
var boundingRadiusSum2 = Math.pow(bodyA.boundingRadius + bodyB.boundingRadius, 2);
|
||
|
|
var norm2 = r.norm2();
|
||
|
|
if (norm2 < boundingRadiusSum2) {
|
||
|
|
pairs1.push(bodyA);
|
||
|
|
pairs2.push(bodyB);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Broadphase.prototype.doBoundingBoxBroadphase = function(bodyA, bodyB, pairs1, pairs2) {
|
||
|
|
bodyA.aabbNeedsUpdate && bodyA.computeAABB();
|
||
|
|
bodyB.aabbNeedsUpdate && bodyB.computeAABB();
|
||
|
|
if (bodyA.aabb.overlaps(bodyB.aabb)) {
|
||
|
|
pairs1.push(bodyA);
|
||
|
|
pairs2.push(bodyB);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var Broadphase_makePairsUnique_temp = {
|
||
|
|
keys: []
|
||
|
|
}, Broadphase_makePairsUnique_p1 = [], Broadphase_makePairsUnique_p2 = [];
|
||
|
|
Broadphase.prototype.makePairsUnique = function(pairs1, pairs2) {
|
||
|
|
var t = Broadphase_makePairsUnique_temp, p1 = Broadphase_makePairsUnique_p1, p2 = Broadphase_makePairsUnique_p2, N = pairs1.length;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
p1[i] = pairs1[i];
|
||
|
|
p2[i] = pairs2[i];
|
||
|
|
}
|
||
|
|
pairs1.length = 0;
|
||
|
|
pairs2.length = 0;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var id1 = p1[i].id, id2 = p2[i].id;
|
||
|
|
var key = id1 < id2 ? id1 + "," + id2 : id2 + "," + id1;
|
||
|
|
t[key] = i;
|
||
|
|
t.keys.push(key);
|
||
|
|
}
|
||
|
|
for (var i = 0; i !== t.keys.length; i++) {
|
||
|
|
var key = t.keys.pop(), pairIndex = t[key];
|
||
|
|
pairs1.push(p1[pairIndex]);
|
||
|
|
pairs2.push(p2[pairIndex]);
|
||
|
|
delete t[key];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Broadphase.prototype.setWorld = function(world) {};
|
||
|
|
var bsc_dist = new Vec3();
|
||
|
|
Broadphase.boundingSphereCheck = function(bodyA, bodyB) {
|
||
|
|
var dist = bsc_dist;
|
||
|
|
bodyA.position.vsub(bodyB.position, dist);
|
||
|
|
return Math.pow(bodyA.shape.boundingSphereRadius + bodyB.shape.boundingSphereRadius, 2) > dist.norm2();
|
||
|
|
};
|
||
|
|
Broadphase.prototype.aabbQuery = function(world, aabb, result) {
|
||
|
|
console.warn(".aabbQuery is not implemented in this Broadphase subclass.");
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../objects/Body": 33,
|
||
|
|
"../shapes/Plane": 44,
|
||
|
|
"../shapes/Shape": 45
|
||
|
|
} ],
|
||
|
|
6: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = GridBroadphase;
|
||
|
|
var Broadphase = _dereq_("./Broadphase");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
function GridBroadphase(aabbMin, aabbMax, nx, ny, nz) {
|
||
|
|
Broadphase.apply(this);
|
||
|
|
this.nx = nx || 10;
|
||
|
|
this.ny = ny || 10;
|
||
|
|
this.nz = nz || 10;
|
||
|
|
this.aabbMin = aabbMin || new Vec3(100, 100, 100);
|
||
|
|
this.aabbMax = aabbMax || new Vec3(-100, -100, -100);
|
||
|
|
var nbins = this.nx * this.ny * this.nz;
|
||
|
|
if (nbins <= 0) throw "GridBroadphase: Each dimension's n must be >0";
|
||
|
|
this.bins = [];
|
||
|
|
this.binLengths = [];
|
||
|
|
this.bins.length = nbins;
|
||
|
|
this.binLengths.length = nbins;
|
||
|
|
for (var i = 0; i < nbins; i++) {
|
||
|
|
this.bins[i] = [];
|
||
|
|
this.binLengths[i] = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
GridBroadphase.prototype = new Broadphase();
|
||
|
|
GridBroadphase.prototype.constructor = GridBroadphase;
|
||
|
|
var GridBroadphase_collisionPairs_d = new Vec3();
|
||
|
|
var GridBroadphase_collisionPairs_binPos = new Vec3();
|
||
|
|
GridBroadphase.prototype.collisionPairs = function(world, pairs1, pairs2) {
|
||
|
|
var N = world.numObjects(), bodies = world.bodies;
|
||
|
|
var max = this.aabbMax, min = this.aabbMin, nx = this.nx, ny = this.ny, nz = this.nz;
|
||
|
|
var xstep = ny * nz;
|
||
|
|
var ystep = nz;
|
||
|
|
var zstep = 1;
|
||
|
|
var xmax = max.x, ymax = max.y, zmax = max.z, xmin = min.x, ymin = min.y, zmin = min.z;
|
||
|
|
var xmult = nx / (xmax - xmin), ymult = ny / (ymax - ymin), zmult = nz / (zmax - zmin);
|
||
|
|
var binsizeX = (xmax - xmin) / nx, binsizeY = (ymax - ymin) / ny, binsizeZ = (zmax - zmin) / nz;
|
||
|
|
var binRadius = .5 * Math.sqrt(binsizeX * binsizeX + binsizeY * binsizeY + binsizeZ * binsizeZ);
|
||
|
|
var types = Shape.types;
|
||
|
|
var SPHERE = types.SPHERE, PLANE = types.PLANE, BOX = types.BOX, COMPOUND = types.COMPOUND, CONVEXPOLYHEDRON = types.CONVEXPOLYHEDRON;
|
||
|
|
var bins = this.bins, binLengths = this.binLengths, Nbins = this.bins.length;
|
||
|
|
for (var i = 0; i !== Nbins; i++) binLengths[i] = 0;
|
||
|
|
var ceil = Math.ceil;
|
||
|
|
var min = Math.min;
|
||
|
|
var max = Math.max;
|
||
|
|
function addBoxToBins(x0, y0, z0, x1, y1, z1, bi) {
|
||
|
|
var xoff0 = (x0 - xmin) * xmult | 0, yoff0 = (y0 - ymin) * ymult | 0, zoff0 = (z0 - zmin) * zmult | 0, xoff1 = ceil((x1 - xmin) * xmult), yoff1 = ceil((y1 - ymin) * ymult), zoff1 = ceil((z1 - zmin) * zmult);
|
||
|
|
xoff0 < 0 ? xoff0 = 0 : xoff0 >= nx && (xoff0 = nx - 1);
|
||
|
|
yoff0 < 0 ? yoff0 = 0 : yoff0 >= ny && (yoff0 = ny - 1);
|
||
|
|
zoff0 < 0 ? zoff0 = 0 : zoff0 >= nz && (zoff0 = nz - 1);
|
||
|
|
xoff1 < 0 ? xoff1 = 0 : xoff1 >= nx && (xoff1 = nx - 1);
|
||
|
|
yoff1 < 0 ? yoff1 = 0 : yoff1 >= ny && (yoff1 = ny - 1);
|
||
|
|
zoff1 < 0 ? zoff1 = 0 : zoff1 >= nz && (zoff1 = nz - 1);
|
||
|
|
xoff0 *= xstep;
|
||
|
|
yoff0 *= ystep;
|
||
|
|
zoff0 *= zstep;
|
||
|
|
xoff1 *= xstep;
|
||
|
|
yoff1 *= ystep;
|
||
|
|
zoff1 *= zstep;
|
||
|
|
for (var xoff = xoff0; xoff <= xoff1; xoff += xstep) for (var yoff = yoff0; yoff <= yoff1; yoff += ystep) for (var zoff = zoff0; zoff <= zoff1; zoff += zstep) {
|
||
|
|
var idx = xoff + yoff + zoff;
|
||
|
|
bins[idx][binLengths[idx]++] = bi;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
var si = bi.shape;
|
||
|
|
switch (si.type) {
|
||
|
|
case SPHERE:
|
||
|
|
var x = bi.position.x, y = bi.position.y, z = bi.position.z;
|
||
|
|
var r = si.radius;
|
||
|
|
addBoxToBins(x - r, y - r, z - r, x + r, y + r, z + r, bi);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case PLANE:
|
||
|
|
si.worldNormalNeedsUpdate && si.computeWorldNormal(bi.quaternion);
|
||
|
|
var planeNormal = si.worldNormal;
|
||
|
|
var xreset = xmin + .5 * binsizeX - bi.position.x, yreset = ymin + .5 * binsizeY - bi.position.y, zreset = zmin + .5 * binsizeZ - bi.position.z;
|
||
|
|
var d = GridBroadphase_collisionPairs_d;
|
||
|
|
d.set(xreset, yreset, zreset);
|
||
|
|
for (var xi = 0, xoff = 0; xi !== nx; xi++, xoff += xstep, d.y = yreset, d.x += binsizeX) for (var yi = 0, yoff = 0; yi !== ny; yi++,
|
||
|
|
yoff += ystep, d.z = zreset, d.y += binsizeY) for (var zi = 0, zoff = 0; zi !== nz; zi++,
|
||
|
|
zoff += zstep, d.z += binsizeZ) if (d.dot(planeNormal) < binRadius) {
|
||
|
|
var idx = xoff + yoff + zoff;
|
||
|
|
bins[idx][binLengths[idx]++] = bi;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
bi.aabbNeedsUpdate && bi.computeAABB();
|
||
|
|
addBoxToBins(bi.aabb.lowerBound.x, bi.aabb.lowerBound.y, bi.aabb.lowerBound.z, bi.aabb.upperBound.x, bi.aabb.upperBound.y, bi.aabb.upperBound.z, bi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var i = 0; i !== Nbins; i++) {
|
||
|
|
var binLength = binLengths[i];
|
||
|
|
if (binLength > 1) {
|
||
|
|
var bin = bins[i];
|
||
|
|
for (var xi = 0; xi !== binLength; xi++) {
|
||
|
|
var bi = bin[xi];
|
||
|
|
for (var yi = 0; yi !== xi; yi++) {
|
||
|
|
var bj = bin[yi];
|
||
|
|
this.needBroadphaseCollision(bi, bj) && this.intersectionTest(bi, bj, pairs1, pairs2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.makePairsUnique(pairs1, pairs2);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../shapes/Shape": 45,
|
||
|
|
"./Broadphase": 5
|
||
|
|
} ],
|
||
|
|
7: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = NaiveBroadphase;
|
||
|
|
var Broadphase = _dereq_("./Broadphase");
|
||
|
|
var AABB = _dereq_("./AABB");
|
||
|
|
function NaiveBroadphase() {
|
||
|
|
Broadphase.apply(this);
|
||
|
|
}
|
||
|
|
NaiveBroadphase.prototype = new Broadphase();
|
||
|
|
NaiveBroadphase.prototype.constructor = NaiveBroadphase;
|
||
|
|
NaiveBroadphase.prototype.collisionPairs = function(world, pairs1, pairs2) {
|
||
|
|
var bodies = world.bodies, n = bodies.length, i, j, bi, bj;
|
||
|
|
for (i = 0; i !== n; i++) for (j = 0; j !== i; j++) {
|
||
|
|
bi = bodies[i];
|
||
|
|
bj = bodies[j];
|
||
|
|
if (!this.needBroadphaseCollision(bi, bj)) continue;
|
||
|
|
this.intersectionTest(bi, bj, pairs1, pairs2);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var tmpAABB = new AABB();
|
||
|
|
NaiveBroadphase.prototype.aabbQuery = function(world, aabb, result) {
|
||
|
|
result = result || [];
|
||
|
|
for (var i = 0; i < world.bodies.length; i++) {
|
||
|
|
var b = world.bodies[i];
|
||
|
|
b.aabbNeedsUpdate && b.computeAABB();
|
||
|
|
b.aabb.overlaps(aabb) && result.push(b);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"./AABB": 3,
|
||
|
|
"./Broadphase": 5
|
||
|
|
} ],
|
||
|
|
8: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = ObjectCollisionMatrix;
|
||
|
|
function ObjectCollisionMatrix() {
|
||
|
|
this.matrix = {};
|
||
|
|
}
|
||
|
|
ObjectCollisionMatrix.prototype.get = function(i, j) {
|
||
|
|
i = i.id;
|
||
|
|
j = j.id;
|
||
|
|
if (j > i) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
return i + "-" + j in this.matrix;
|
||
|
|
};
|
||
|
|
ObjectCollisionMatrix.prototype.set = function(i, j, value) {
|
||
|
|
i = i.id;
|
||
|
|
j = j.id;
|
||
|
|
if (j > i) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
value ? this.matrix[i + "-" + j] = true : delete this.matrix[i + "-" + j];
|
||
|
|
};
|
||
|
|
ObjectCollisionMatrix.prototype.reset = function() {
|
||
|
|
this.matrix = {};
|
||
|
|
};
|
||
|
|
ObjectCollisionMatrix.prototype.setNumObjects = function(n) {};
|
||
|
|
}, {} ],
|
||
|
|
9: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = OverlapKeeper;
|
||
|
|
function OverlapKeeper() {
|
||
|
|
this.current = [];
|
||
|
|
this.previous = [];
|
||
|
|
}
|
||
|
|
OverlapKeeper.prototype.getKey = function(i, j) {
|
||
|
|
if (j < i) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
return i << 16 | j;
|
||
|
|
};
|
||
|
|
OverlapKeeper.prototype.set = function(i, j) {
|
||
|
|
var key = this.getKey(i, j);
|
||
|
|
var current = this.current;
|
||
|
|
var index = 0;
|
||
|
|
while (key > current[index]) index++;
|
||
|
|
if (key === current[index]) return;
|
||
|
|
for (var j = current.length - 1; j >= index; j--) current[j + 1] = current[j];
|
||
|
|
current[index] = key;
|
||
|
|
};
|
||
|
|
OverlapKeeper.prototype.tick = function() {
|
||
|
|
var tmp = this.current;
|
||
|
|
this.current = this.previous;
|
||
|
|
this.previous = tmp;
|
||
|
|
this.current.length = 0;
|
||
|
|
};
|
||
|
|
function unpackAndPush(array, key) {
|
||
|
|
array.push((4294901760 & key) >> 16, 65535 & key);
|
||
|
|
}
|
||
|
|
OverlapKeeper.prototype.getDiff = function(additions, removals) {
|
||
|
|
var a = this.current;
|
||
|
|
var b = this.previous;
|
||
|
|
var al = a.length;
|
||
|
|
var bl = b.length;
|
||
|
|
var j = 0;
|
||
|
|
for (var i = 0; i < al; i++) {
|
||
|
|
var found = false;
|
||
|
|
var keyA = a[i];
|
||
|
|
while (keyA > b[j]) j++;
|
||
|
|
found = keyA === b[j];
|
||
|
|
found || unpackAndPush(additions, keyA);
|
||
|
|
}
|
||
|
|
j = 0;
|
||
|
|
for (var i = 0; i < bl; i++) {
|
||
|
|
var found = false;
|
||
|
|
var keyB = b[i];
|
||
|
|
while (keyB > a[j]) j++;
|
||
|
|
found = a[j] === keyB;
|
||
|
|
found || unpackAndPush(removals, keyB);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
10: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Ray;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Transform = _dereq_("../math/Transform");
|
||
|
|
var ConvexPolyhedron = _dereq_("../shapes/ConvexPolyhedron");
|
||
|
|
var Box = _dereq_("../shapes/Box");
|
||
|
|
var RaycastResult = _dereq_("../collision/RaycastResult");
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var AABB = _dereq_("../collision/AABB");
|
||
|
|
function Ray(from, to) {
|
||
|
|
this.from = from ? from.clone() : new Vec3();
|
||
|
|
this.to = to ? to.clone() : new Vec3();
|
||
|
|
this._direction = new Vec3();
|
||
|
|
this.precision = 1e-4;
|
||
|
|
this.checkCollisionResponse = true;
|
||
|
|
this.skipBackfaces = false;
|
||
|
|
this.collisionFilterMask = -1;
|
||
|
|
this.collisionFilterGroup = -1;
|
||
|
|
this.mode = Ray.ANY;
|
||
|
|
this.result = new RaycastResult();
|
||
|
|
this.hasHit = false;
|
||
|
|
this.callback = function(result) {};
|
||
|
|
}
|
||
|
|
Ray.prototype.constructor = Ray;
|
||
|
|
Ray.CLOSEST = 1;
|
||
|
|
Ray.ANY = 2;
|
||
|
|
Ray.ALL = 4;
|
||
|
|
var tmpAABB = new AABB();
|
||
|
|
var tmpArray = [];
|
||
|
|
Ray.prototype.intersectWorld = function(world, options) {
|
||
|
|
this.mode = options.mode || Ray.ANY;
|
||
|
|
this.result = options.result || new RaycastResult();
|
||
|
|
this.skipBackfaces = !!options.skipBackfaces;
|
||
|
|
this.checkCollisionResponse = !!options.checkCollisionResponse;
|
||
|
|
this.collisionFilterMask = "undefined" !== typeof options.collisionFilterMask ? options.collisionFilterMask : -1;
|
||
|
|
this.collisionFilterGroup = "undefined" !== typeof options.collisionFilterGroup ? options.collisionFilterGroup : -1;
|
||
|
|
options.from && this.from.copy(options.from);
|
||
|
|
options.to && this.to.copy(options.to);
|
||
|
|
this.callback = options.callback || function() {};
|
||
|
|
this.hasHit = false;
|
||
|
|
this.result.reset();
|
||
|
|
this._updateDirection();
|
||
|
|
this.getAABB(tmpAABB);
|
||
|
|
tmpArray.length = 0;
|
||
|
|
world.broadphase.aabbQuery(world, tmpAABB, tmpArray);
|
||
|
|
this.intersectBodies(tmpArray);
|
||
|
|
return this.hasHit;
|
||
|
|
};
|
||
|
|
var v1 = new Vec3(), v2 = new Vec3();
|
||
|
|
Ray.pointInTriangle = pointInTriangle;
|
||
|
|
function pointInTriangle(p, a, b, c) {
|
||
|
|
c.vsub(a, v0);
|
||
|
|
b.vsub(a, v1);
|
||
|
|
p.vsub(a, v2);
|
||
|
|
var dot00 = v0.dot(v0);
|
||
|
|
var dot01 = v0.dot(v1);
|
||
|
|
var dot02 = v0.dot(v2);
|
||
|
|
var dot11 = v1.dot(v1);
|
||
|
|
var dot12 = v1.dot(v2);
|
||
|
|
var u, v;
|
||
|
|
return (u = dot11 * dot02 - dot01 * dot12) >= 0 && (v = dot00 * dot12 - dot01 * dot02) >= 0 && u + v < dot00 * dot11 - dot01 * dot01;
|
||
|
|
}
|
||
|
|
var intersectBody_xi = new Vec3();
|
||
|
|
var intersectBody_qi = new Quaternion();
|
||
|
|
Ray.prototype.intersectBody = function(body, result) {
|
||
|
|
if (result) {
|
||
|
|
this.result = result;
|
||
|
|
this._updateDirection();
|
||
|
|
}
|
||
|
|
var checkCollisionResponse = this.checkCollisionResponse;
|
||
|
|
if (checkCollisionResponse && !body.collisionResponse) return;
|
||
|
|
if (0 === (this.collisionFilterGroup & body.collisionFilterMask) || 0 === (body.collisionFilterGroup & this.collisionFilterMask)) return;
|
||
|
|
var xi = intersectBody_xi;
|
||
|
|
var qi = intersectBody_qi;
|
||
|
|
for (var i = 0, N = body.shapes.length; i < N; i++) {
|
||
|
|
var shape = body.shapes[i];
|
||
|
|
if (checkCollisionResponse && !shape.collisionResponse) continue;
|
||
|
|
body.quaternion.mult(body.shapeOrientations[i], qi);
|
||
|
|
body.quaternion.vmult(body.shapeOffsets[i], xi);
|
||
|
|
xi.vadd(body.position, xi);
|
||
|
|
this.intersectShape(shape, qi, xi, body);
|
||
|
|
if (this.result._shouldStop) break;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Ray.prototype.intersectBodies = function(bodies, result) {
|
||
|
|
if (result) {
|
||
|
|
this.result = result;
|
||
|
|
this._updateDirection();
|
||
|
|
}
|
||
|
|
for (var i = 0, l = bodies.length; !this.result._shouldStop && i < l; i++) this.intersectBody(bodies[i]);
|
||
|
|
};
|
||
|
|
Ray.prototype._updateDirection = function() {
|
||
|
|
this.to.vsub(this.from, this._direction);
|
||
|
|
this._direction.normalize();
|
||
|
|
};
|
||
|
|
Ray.prototype.intersectShape = function(shape, quat, position, body) {
|
||
|
|
var from = this.from;
|
||
|
|
var distance = distanceFromIntersection(from, this._direction, position);
|
||
|
|
if (distance > shape.boundingSphereRadius) return;
|
||
|
|
var intersectMethod = this[shape.type];
|
||
|
|
intersectMethod && intersectMethod.call(this, shape, quat, position, body, shape);
|
||
|
|
};
|
||
|
|
var vector = new Vec3();
|
||
|
|
var normal = new Vec3();
|
||
|
|
var intersectPoint = new Vec3();
|
||
|
|
var a = new Vec3();
|
||
|
|
var b = new Vec3();
|
||
|
|
var c = new Vec3();
|
||
|
|
var d = new Vec3();
|
||
|
|
var tmpRaycastResult = new RaycastResult();
|
||
|
|
Ray.prototype.intersectBox = function(shape, quat, position, body, reportedShape) {
|
||
|
|
return this.intersectConvex(shape.convexPolyhedronRepresentation, quat, position, body, reportedShape);
|
||
|
|
};
|
||
|
|
Ray.prototype[Shape.types.BOX] = Ray.prototype.intersectBox;
|
||
|
|
Ray.prototype.intersectPlane = function(shape, quat, position, body, reportedShape) {
|
||
|
|
var from = this.from;
|
||
|
|
var to = this.to;
|
||
|
|
var direction = this._direction;
|
||
|
|
var worldNormal = new Vec3(0, 0, 1);
|
||
|
|
quat.vmult(worldNormal, worldNormal);
|
||
|
|
var len = new Vec3();
|
||
|
|
from.vsub(position, len);
|
||
|
|
var planeToFrom = len.dot(worldNormal);
|
||
|
|
to.vsub(position, len);
|
||
|
|
var planeToTo = len.dot(worldNormal);
|
||
|
|
if (planeToFrom * planeToTo > 0) return;
|
||
|
|
if (from.distanceTo(to) < planeToFrom) return;
|
||
|
|
var n_dot_dir = worldNormal.dot(direction);
|
||
|
|
if (Math.abs(n_dot_dir) < this.precision) return;
|
||
|
|
var planePointToFrom = new Vec3();
|
||
|
|
var dir_scaled_with_t = new Vec3();
|
||
|
|
var hitPointWorld = new Vec3();
|
||
|
|
from.vsub(position, planePointToFrom);
|
||
|
|
var t = -worldNormal.dot(planePointToFrom) / n_dot_dir;
|
||
|
|
direction.scale(t, dir_scaled_with_t);
|
||
|
|
from.vadd(dir_scaled_with_t, hitPointWorld);
|
||
|
|
this.reportIntersection(worldNormal, hitPointWorld, reportedShape, body, -1);
|
||
|
|
};
|
||
|
|
Ray.prototype[Shape.types.PLANE] = Ray.prototype.intersectPlane;
|
||
|
|
Ray.prototype.getAABB = function(result) {
|
||
|
|
var to = this.to;
|
||
|
|
var from = this.from;
|
||
|
|
result.lowerBound.x = Math.min(to.x, from.x);
|
||
|
|
result.lowerBound.y = Math.min(to.y, from.y);
|
||
|
|
result.lowerBound.z = Math.min(to.z, from.z);
|
||
|
|
result.upperBound.x = Math.max(to.x, from.x);
|
||
|
|
result.upperBound.y = Math.max(to.y, from.y);
|
||
|
|
result.upperBound.z = Math.max(to.z, from.z);
|
||
|
|
};
|
||
|
|
var intersectConvexOptions = {
|
||
|
|
faceList: [ 0 ]
|
||
|
|
};
|
||
|
|
var worldPillarOffset = new Vec3();
|
||
|
|
var intersectHeightfield_localRay = new Ray();
|
||
|
|
var intersectHeightfield_index = [];
|
||
|
|
var intersectHeightfield_minMax = [];
|
||
|
|
Ray.prototype.intersectHeightfield = function(shape, quat, position, body, reportedShape) {
|
||
|
|
var data = shape.data, w = shape.elementSize;
|
||
|
|
var localRay = intersectHeightfield_localRay;
|
||
|
|
localRay.from.copy(this.from);
|
||
|
|
localRay.to.copy(this.to);
|
||
|
|
Transform.pointToLocalFrame(position, quat, localRay.from, localRay.from);
|
||
|
|
Transform.pointToLocalFrame(position, quat, localRay.to, localRay.to);
|
||
|
|
localRay._updateDirection();
|
||
|
|
var index = intersectHeightfield_index;
|
||
|
|
var iMinX, iMinY, iMaxX, iMaxY;
|
||
|
|
iMinX = iMinY = 0;
|
||
|
|
iMaxX = iMaxY = shape.data.length - 1;
|
||
|
|
var aabb = new AABB();
|
||
|
|
localRay.getAABB(aabb);
|
||
|
|
shape.getIndexOfPosition(aabb.lowerBound.x, aabb.lowerBound.y, index, true);
|
||
|
|
iMinX = Math.max(iMinX, index[0]);
|
||
|
|
iMinY = Math.max(iMinY, index[1]);
|
||
|
|
shape.getIndexOfPosition(aabb.upperBound.x, aabb.upperBound.y, index, true);
|
||
|
|
iMaxX = Math.min(iMaxX, index[0] + 1);
|
||
|
|
iMaxY = Math.min(iMaxY, index[1] + 1);
|
||
|
|
for (var i = iMinX; i < iMaxX; i++) for (var j = iMinY; j < iMaxY; j++) {
|
||
|
|
if (this.result._shouldStop) return;
|
||
|
|
shape.getAabbAtIndex(i, j, aabb);
|
||
|
|
if (!aabb.overlapsRay(localRay)) continue;
|
||
|
|
shape.getConvexTrianglePillar(i, j, false);
|
||
|
|
Transform.pointToWorldFrame(position, quat, shape.pillarOffset, worldPillarOffset);
|
||
|
|
this.intersectConvex(shape.pillarConvex, quat, worldPillarOffset, body, reportedShape, intersectConvexOptions);
|
||
|
|
if (this.result._shouldStop) return;
|
||
|
|
shape.getConvexTrianglePillar(i, j, true);
|
||
|
|
Transform.pointToWorldFrame(position, quat, shape.pillarOffset, worldPillarOffset);
|
||
|
|
this.intersectConvex(shape.pillarConvex, quat, worldPillarOffset, body, reportedShape, intersectConvexOptions);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Ray.prototype[Shape.types.HEIGHTFIELD] = Ray.prototype.intersectHeightfield;
|
||
|
|
var Ray_intersectSphere_intersectionPoint = new Vec3();
|
||
|
|
var Ray_intersectSphere_normal = new Vec3();
|
||
|
|
Ray.prototype.intersectSphere = function(shape, quat, position, body, reportedShape) {
|
||
|
|
var from = this.from, to = this.to, r = shape.radius;
|
||
|
|
var a = Math.pow(to.x - from.x, 2) + Math.pow(to.y - from.y, 2) + Math.pow(to.z - from.z, 2);
|
||
|
|
var b = 2 * ((to.x - from.x) * (from.x - position.x) + (to.y - from.y) * (from.y - position.y) + (to.z - from.z) * (from.z - position.z));
|
||
|
|
var c = Math.pow(from.x - position.x, 2) + Math.pow(from.y - position.y, 2) + Math.pow(from.z - position.z, 2) - Math.pow(r, 2);
|
||
|
|
var delta = Math.pow(b, 2) - 4 * a * c;
|
||
|
|
var intersectionPoint = Ray_intersectSphere_intersectionPoint;
|
||
|
|
var normal = Ray_intersectSphere_normal;
|
||
|
|
if (delta < 0) return;
|
||
|
|
if (0 === delta) {
|
||
|
|
from.lerp(to, delta, intersectionPoint);
|
||
|
|
intersectionPoint.vsub(position, normal);
|
||
|
|
normal.normalize();
|
||
|
|
this.reportIntersection(normal, intersectionPoint, reportedShape, body, -1);
|
||
|
|
} else {
|
||
|
|
var d1 = (-b - Math.sqrt(delta)) / (2 * a);
|
||
|
|
var d2 = (-b + Math.sqrt(delta)) / (2 * a);
|
||
|
|
if (d1 >= 0 && d1 <= 1) {
|
||
|
|
from.lerp(to, d1, intersectionPoint);
|
||
|
|
intersectionPoint.vsub(position, normal);
|
||
|
|
normal.normalize();
|
||
|
|
this.reportIntersection(normal, intersectionPoint, reportedShape, body, -1);
|
||
|
|
}
|
||
|
|
if (this.result._shouldStop) return;
|
||
|
|
if (d2 >= 0 && d2 <= 1) {
|
||
|
|
from.lerp(to, d2, intersectionPoint);
|
||
|
|
intersectionPoint.vsub(position, normal);
|
||
|
|
normal.normalize();
|
||
|
|
this.reportIntersection(normal, intersectionPoint, reportedShape, body, -1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Ray.prototype[Shape.types.SPHERE] = Ray.prototype.intersectSphere;
|
||
|
|
var intersectConvex_normal = new Vec3();
|
||
|
|
var intersectConvex_minDistNormal = new Vec3();
|
||
|
|
var intersectConvex_minDistIntersect = new Vec3();
|
||
|
|
var intersectConvex_vector = new Vec3();
|
||
|
|
Ray.prototype.intersectConvex = function intersectConvex(shape, quat, position, body, reportedShape, options) {
|
||
|
|
var minDistNormal = intersectConvex_minDistNormal;
|
||
|
|
var normal = intersectConvex_normal;
|
||
|
|
var vector = intersectConvex_vector;
|
||
|
|
var minDistIntersect = intersectConvex_minDistIntersect;
|
||
|
|
var faceList = options && options.faceList || null;
|
||
|
|
var faces = shape.faces, vertices = shape.vertices, normals = shape.faceNormals;
|
||
|
|
var direction = this._direction;
|
||
|
|
var from = this.from;
|
||
|
|
var to = this.to;
|
||
|
|
var fromToDistance = from.distanceTo(to);
|
||
|
|
var minDist = -1;
|
||
|
|
var Nfaces = faceList ? faceList.length : faces.length;
|
||
|
|
var result = this.result;
|
||
|
|
for (var j = 0; !result._shouldStop && j < Nfaces; j++) {
|
||
|
|
var fi = faceList ? faceList[j] : j;
|
||
|
|
var face = faces[fi];
|
||
|
|
var faceNormal = normals[fi];
|
||
|
|
var q = quat;
|
||
|
|
var x = position;
|
||
|
|
vector.copy(vertices[face[0]]);
|
||
|
|
q.vmult(vector, vector);
|
||
|
|
vector.vadd(x, vector);
|
||
|
|
vector.vsub(from, vector);
|
||
|
|
q.vmult(faceNormal, normal);
|
||
|
|
var dot = direction.dot(normal);
|
||
|
|
if (Math.abs(dot) < this.precision) continue;
|
||
|
|
var scalar = normal.dot(vector) / dot;
|
||
|
|
if (scalar < 0) continue;
|
||
|
|
direction.mult(scalar, intersectPoint);
|
||
|
|
intersectPoint.vadd(from, intersectPoint);
|
||
|
|
a.copy(vertices[face[0]]);
|
||
|
|
q.vmult(a, a);
|
||
|
|
x.vadd(a, a);
|
||
|
|
for (var i = 1; !result._shouldStop && i < face.length - 1; i++) {
|
||
|
|
b.copy(vertices[face[i]]);
|
||
|
|
c.copy(vertices[face[i + 1]]);
|
||
|
|
q.vmult(b, b);
|
||
|
|
q.vmult(c, c);
|
||
|
|
x.vadd(b, b);
|
||
|
|
x.vadd(c, c);
|
||
|
|
var distance = intersectPoint.distanceTo(from);
|
||
|
|
if (!(pointInTriangle(intersectPoint, a, b, c) || pointInTriangle(intersectPoint, b, a, c)) || distance > fromToDistance) continue;
|
||
|
|
this.reportIntersection(normal, intersectPoint, reportedShape, body, fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Ray.prototype[Shape.types.CONVEXPOLYHEDRON] = Ray.prototype.intersectConvex;
|
||
|
|
var intersectTrimesh_normal = new Vec3();
|
||
|
|
var intersectTrimesh_localDirection = new Vec3();
|
||
|
|
var intersectTrimesh_localFrom = new Vec3();
|
||
|
|
var intersectTrimesh_localTo = new Vec3();
|
||
|
|
var intersectTrimesh_worldNormal = new Vec3();
|
||
|
|
var intersectTrimesh_worldIntersectPoint = new Vec3();
|
||
|
|
var intersectTrimesh_localAABB = new AABB();
|
||
|
|
var intersectTrimesh_triangles = [];
|
||
|
|
var intersectTrimesh_treeTransform = new Transform();
|
||
|
|
Ray.prototype.intersectTrimesh = function intersectTrimesh(mesh, quat, position, body, reportedShape, options) {
|
||
|
|
var normal = intersectTrimesh_normal;
|
||
|
|
var triangles = intersectTrimesh_triangles;
|
||
|
|
var treeTransform = intersectTrimesh_treeTransform;
|
||
|
|
var minDistNormal = intersectConvex_minDistNormal;
|
||
|
|
var vector = intersectConvex_vector;
|
||
|
|
var minDistIntersect = intersectConvex_minDistIntersect;
|
||
|
|
var localAABB = intersectTrimesh_localAABB;
|
||
|
|
var localDirection = intersectTrimesh_localDirection;
|
||
|
|
var localFrom = intersectTrimesh_localFrom;
|
||
|
|
var localTo = intersectTrimesh_localTo;
|
||
|
|
var worldIntersectPoint = intersectTrimesh_worldIntersectPoint;
|
||
|
|
var worldNormal = intersectTrimesh_worldNormal;
|
||
|
|
var faceList = options && options.faceList || null;
|
||
|
|
var indices = mesh.indices, vertices = mesh.vertices, normals = mesh.faceNormals;
|
||
|
|
var from = this.from;
|
||
|
|
var to = this.to;
|
||
|
|
var direction = this._direction;
|
||
|
|
var minDist = -1;
|
||
|
|
treeTransform.position.copy(position);
|
||
|
|
treeTransform.quaternion.copy(quat);
|
||
|
|
Transform.vectorToLocalFrame(position, quat, direction, localDirection);
|
||
|
|
Transform.pointToLocalFrame(position, quat, from, localFrom);
|
||
|
|
Transform.pointToLocalFrame(position, quat, to, localTo);
|
||
|
|
localTo.x *= mesh.scale.x;
|
||
|
|
localTo.y *= mesh.scale.y;
|
||
|
|
localTo.z *= mesh.scale.z;
|
||
|
|
localFrom.x *= mesh.scale.x;
|
||
|
|
localFrom.y *= mesh.scale.y;
|
||
|
|
localFrom.z *= mesh.scale.z;
|
||
|
|
localTo.vsub(localFrom, localDirection);
|
||
|
|
localDirection.normalize();
|
||
|
|
var fromToDistanceSquared = localFrom.distanceSquared(localTo);
|
||
|
|
mesh.tree.rayQuery(this, treeTransform, triangles);
|
||
|
|
for (var i = 0, N = triangles.length; !this.result._shouldStop && i !== N; i++) {
|
||
|
|
var trianglesIndex = triangles[i];
|
||
|
|
mesh.getNormal(trianglesIndex, normal);
|
||
|
|
mesh.getVertex(indices[3 * trianglesIndex], a);
|
||
|
|
a.vsub(localFrom, vector);
|
||
|
|
var dot = localDirection.dot(normal);
|
||
|
|
var scalar = normal.dot(vector) / dot;
|
||
|
|
if (scalar < 0) continue;
|
||
|
|
localDirection.scale(scalar, intersectPoint);
|
||
|
|
intersectPoint.vadd(localFrom, intersectPoint);
|
||
|
|
mesh.getVertex(indices[3 * trianglesIndex + 1], b);
|
||
|
|
mesh.getVertex(indices[3 * trianglesIndex + 2], c);
|
||
|
|
var squaredDistance = intersectPoint.distanceSquared(localFrom);
|
||
|
|
if (!(pointInTriangle(intersectPoint, b, a, c) || pointInTriangle(intersectPoint, a, b, c)) || squaredDistance > fromToDistanceSquared) continue;
|
||
|
|
Transform.vectorToWorldFrame(quat, normal, worldNormal);
|
||
|
|
Transform.pointToWorldFrame(position, quat, intersectPoint, worldIntersectPoint);
|
||
|
|
this.reportIntersection(worldNormal, worldIntersectPoint, reportedShape, body, trianglesIndex);
|
||
|
|
}
|
||
|
|
triangles.length = 0;
|
||
|
|
};
|
||
|
|
Ray.prototype[Shape.types.TRIMESH] = Ray.prototype.intersectTrimesh;
|
||
|
|
Ray.prototype.reportIntersection = function(normal, hitPointWorld, shape, body, hitFaceIndex) {
|
||
|
|
var from = this.from;
|
||
|
|
var to = this.to;
|
||
|
|
var distance = from.distanceTo(hitPointWorld);
|
||
|
|
var result = this.result;
|
||
|
|
if (this.skipBackfaces && normal.dot(this._direction) > 0) return;
|
||
|
|
result.hitFaceIndex = "undefined" !== typeof hitFaceIndex ? hitFaceIndex : -1;
|
||
|
|
switch (this.mode) {
|
||
|
|
case Ray.ALL:
|
||
|
|
this.hasHit = true;
|
||
|
|
result.set(from, to, normal, hitPointWorld, shape, body, distance);
|
||
|
|
result.hasHit = true;
|
||
|
|
this.callback(result);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case Ray.CLOSEST:
|
||
|
|
if (distance < result.distance || !result.hasHit) {
|
||
|
|
this.hasHit = true;
|
||
|
|
result.hasHit = true;
|
||
|
|
result.set(from, to, normal, hitPointWorld, shape, body, distance);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case Ray.ANY:
|
||
|
|
this.hasHit = true;
|
||
|
|
result.hasHit = true;
|
||
|
|
result.set(from, to, normal, hitPointWorld, shape, body, distance);
|
||
|
|
result._shouldStop = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var v0 = new Vec3(), intersect = new Vec3();
|
||
|
|
function distanceFromIntersection(from, direction, position) {
|
||
|
|
position.vsub(from, v0);
|
||
|
|
var dot = v0.dot(direction);
|
||
|
|
direction.mult(dot, intersect);
|
||
|
|
intersect.vadd(from, intersect);
|
||
|
|
var distance = position.distanceTo(intersect);
|
||
|
|
return distance;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
"../collision/AABB": 3,
|
||
|
|
"../collision/RaycastResult": 11,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Transform": 31,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../shapes/Box": 39,
|
||
|
|
"../shapes/ConvexPolyhedron": 40,
|
||
|
|
"../shapes/Shape": 45
|
||
|
|
} ],
|
||
|
|
11: [ function(_dereq_, module, exports) {
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
module.exports = RaycastResult;
|
||
|
|
function RaycastResult() {
|
||
|
|
this.rayFromWorld = new Vec3();
|
||
|
|
this.rayToWorld = new Vec3();
|
||
|
|
this.hitNormalWorld = new Vec3();
|
||
|
|
this.hitPointWorld = new Vec3();
|
||
|
|
this.hasHit = false;
|
||
|
|
this.shape = null;
|
||
|
|
this.body = null;
|
||
|
|
this.hitFaceIndex = -1;
|
||
|
|
this.distance = -1;
|
||
|
|
this._shouldStop = false;
|
||
|
|
}
|
||
|
|
RaycastResult.prototype.reset = function() {
|
||
|
|
this.rayFromWorld.setZero();
|
||
|
|
this.rayToWorld.setZero();
|
||
|
|
this.hitNormalWorld.setZero();
|
||
|
|
this.hitPointWorld.setZero();
|
||
|
|
this.hasHit = false;
|
||
|
|
this.shape = null;
|
||
|
|
this.body = null;
|
||
|
|
this.hitFaceIndex = -1;
|
||
|
|
this.distance = -1;
|
||
|
|
this._shouldStop = false;
|
||
|
|
};
|
||
|
|
RaycastResult.prototype.abort = function() {
|
||
|
|
this._shouldStop = true;
|
||
|
|
};
|
||
|
|
RaycastResult.prototype.set = function(rayFromWorld, rayToWorld, hitNormalWorld, hitPointWorld, shape, body, distance) {
|
||
|
|
this.rayFromWorld.copy(rayFromWorld);
|
||
|
|
this.rayToWorld.copy(rayToWorld);
|
||
|
|
this.hitNormalWorld.copy(hitNormalWorld);
|
||
|
|
this.hitPointWorld.copy(hitPointWorld);
|
||
|
|
this.shape = shape;
|
||
|
|
this.body = body;
|
||
|
|
this.distance = distance;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32
|
||
|
|
} ],
|
||
|
|
12: [ function(_dereq_, module, exports) {
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var Broadphase = _dereq_("../collision/Broadphase");
|
||
|
|
module.exports = SAPBroadphase;
|
||
|
|
function SAPBroadphase(world) {
|
||
|
|
Broadphase.apply(this);
|
||
|
|
this.axisList = [];
|
||
|
|
this.world = null;
|
||
|
|
this.axisIndex = 0;
|
||
|
|
var axisList = this.axisList;
|
||
|
|
this._addBodyHandler = function(e) {
|
||
|
|
axisList.push(e.body);
|
||
|
|
};
|
||
|
|
this._removeBodyHandler = function(e) {
|
||
|
|
var idx = axisList.indexOf(e.body);
|
||
|
|
-1 !== idx && axisList.splice(idx, 1);
|
||
|
|
};
|
||
|
|
world && this.setWorld(world);
|
||
|
|
}
|
||
|
|
SAPBroadphase.prototype = new Broadphase();
|
||
|
|
SAPBroadphase.prototype.setWorld = function(world) {
|
||
|
|
this.axisList.length = 0;
|
||
|
|
for (var i = 0; i < world.bodies.length; i++) this.axisList.push(world.bodies[i]);
|
||
|
|
world.removeEventListener("addBody", this._addBodyHandler);
|
||
|
|
world.removeEventListener("removeBody", this._removeBodyHandler);
|
||
|
|
world.addEventListener("addBody", this._addBodyHandler);
|
||
|
|
world.addEventListener("removeBody", this._removeBodyHandler);
|
||
|
|
this.world = world;
|
||
|
|
this.dirty = true;
|
||
|
|
};
|
||
|
|
SAPBroadphase.insertionSortX = function(a) {
|
||
|
|
for (var i = 1, l = a.length; i < l; i++) {
|
||
|
|
var v = a[i];
|
||
|
|
for (var j = i - 1; j >= 0; j--) {
|
||
|
|
if (a[j].aabb.lowerBound.x <= v.aabb.lowerBound.x) break;
|
||
|
|
a[j + 1] = a[j];
|
||
|
|
}
|
||
|
|
a[j + 1] = v;
|
||
|
|
}
|
||
|
|
return a;
|
||
|
|
};
|
||
|
|
SAPBroadphase.insertionSortY = function(a) {
|
||
|
|
for (var i = 1, l = a.length; i < l; i++) {
|
||
|
|
var v = a[i];
|
||
|
|
for (var j = i - 1; j >= 0; j--) {
|
||
|
|
if (a[j].aabb.lowerBound.y <= v.aabb.lowerBound.y) break;
|
||
|
|
a[j + 1] = a[j];
|
||
|
|
}
|
||
|
|
a[j + 1] = v;
|
||
|
|
}
|
||
|
|
return a;
|
||
|
|
};
|
||
|
|
SAPBroadphase.insertionSortZ = function(a) {
|
||
|
|
for (var i = 1, l = a.length; i < l; i++) {
|
||
|
|
var v = a[i];
|
||
|
|
for (var j = i - 1; j >= 0; j--) {
|
||
|
|
if (a[j].aabb.lowerBound.z <= v.aabb.lowerBound.z) break;
|
||
|
|
a[j + 1] = a[j];
|
||
|
|
}
|
||
|
|
a[j + 1] = v;
|
||
|
|
}
|
||
|
|
return a;
|
||
|
|
};
|
||
|
|
SAPBroadphase.prototype.collisionPairs = function(world, p1, p2) {
|
||
|
|
var bodies = this.axisList, N = bodies.length, axisIndex = this.axisIndex, i, j;
|
||
|
|
if (this.dirty) {
|
||
|
|
this.sortList();
|
||
|
|
this.dirty = false;
|
||
|
|
}
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
for (j = i + 1; j < N; j++) {
|
||
|
|
var bj = bodies[j];
|
||
|
|
if (!this.needBroadphaseCollision(bi, bj)) continue;
|
||
|
|
if (!SAPBroadphase.checkBounds(bi, bj, axisIndex)) break;
|
||
|
|
this.intersectionTest(bi, bj, p1, p2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
SAPBroadphase.prototype.sortList = function() {
|
||
|
|
var axisList = this.axisList;
|
||
|
|
var axisIndex = this.axisIndex;
|
||
|
|
var N = axisList.length;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var bi = axisList[i];
|
||
|
|
bi.aabbNeedsUpdate && bi.computeAABB();
|
||
|
|
}
|
||
|
|
0 === axisIndex ? SAPBroadphase.insertionSortX(axisList) : 1 === axisIndex ? SAPBroadphase.insertionSortY(axisList) : 2 === axisIndex && SAPBroadphase.insertionSortZ(axisList);
|
||
|
|
};
|
||
|
|
SAPBroadphase.checkBounds = function(bi, bj, axisIndex) {
|
||
|
|
var biPos;
|
||
|
|
var bjPos;
|
||
|
|
if (0 === axisIndex) {
|
||
|
|
biPos = bi.position.x;
|
||
|
|
bjPos = bj.position.x;
|
||
|
|
} else if (1 === axisIndex) {
|
||
|
|
biPos = bi.position.y;
|
||
|
|
bjPos = bj.position.y;
|
||
|
|
} else if (2 === axisIndex) {
|
||
|
|
biPos = bi.position.z;
|
||
|
|
bjPos = bj.position.z;
|
||
|
|
}
|
||
|
|
var ri = bi.boundingRadius, rj = bj.boundingRadius, boundA1 = biPos - ri, boundA2 = biPos + ri, boundB1 = bjPos - rj, boundB2 = bjPos + rj;
|
||
|
|
return boundB1 < boundA2;
|
||
|
|
};
|
||
|
|
SAPBroadphase.prototype.autoDetectAxis = function() {
|
||
|
|
var sumX = 0, sumX2 = 0, sumY = 0, sumY2 = 0, sumZ = 0, sumZ2 = 0, bodies = this.axisList, N = bodies.length, invN = 1 / N;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var b = bodies[i];
|
||
|
|
var centerX = b.position.x;
|
||
|
|
sumX += centerX;
|
||
|
|
sumX2 += centerX * centerX;
|
||
|
|
var centerY = b.position.y;
|
||
|
|
sumY += centerY;
|
||
|
|
sumY2 += centerY * centerY;
|
||
|
|
var centerZ = b.position.z;
|
||
|
|
sumZ += centerZ;
|
||
|
|
sumZ2 += centerZ * centerZ;
|
||
|
|
}
|
||
|
|
var varianceX = sumX2 - sumX * sumX * invN, varianceY = sumY2 - sumY * sumY * invN, varianceZ = sumZ2 - sumZ * sumZ * invN;
|
||
|
|
this.axisIndex = varianceX > varianceY ? varianceX > varianceZ ? 0 : 2 : varianceY > varianceZ ? 1 : 2;
|
||
|
|
};
|
||
|
|
SAPBroadphase.prototype.aabbQuery = function(world, aabb, result) {
|
||
|
|
result = result || [];
|
||
|
|
if (this.dirty) {
|
||
|
|
this.sortList();
|
||
|
|
this.dirty = false;
|
||
|
|
}
|
||
|
|
var axisIndex = this.axisIndex, axis = "x";
|
||
|
|
1 === axisIndex && (axis = "y");
|
||
|
|
2 === axisIndex && (axis = "z");
|
||
|
|
var axisList = this.axisList;
|
||
|
|
var lower = aabb.lowerBound[axis];
|
||
|
|
var upper = aabb.upperBound[axis];
|
||
|
|
for (var i = 0; i < axisList.length; i++) {
|
||
|
|
var b = axisList[i];
|
||
|
|
b.aabbNeedsUpdate && b.computeAABB();
|
||
|
|
b.aabb.overlaps(aabb) && result.push(b);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/Broadphase": 5,
|
||
|
|
"../shapes/Shape": 45
|
||
|
|
} ],
|
||
|
|
13: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = ConeTwistConstraint;
|
||
|
|
var Constraint = _dereq_("./Constraint");
|
||
|
|
var PointToPointConstraint = _dereq_("./PointToPointConstraint");
|
||
|
|
var ConeEquation = _dereq_("../equations/ConeEquation");
|
||
|
|
var RotationalEquation = _dereq_("../equations/RotationalEquation");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function ConeTwistConstraint(bodyA, bodyB, options) {
|
||
|
|
options = options || {};
|
||
|
|
var maxForce = "undefined" !== typeof options.maxForce ? options.maxForce : 1e6;
|
||
|
|
var pivotA = options.pivotA ? options.pivotA.clone() : new Vec3();
|
||
|
|
var pivotB = options.pivotB ? options.pivotB.clone() : new Vec3();
|
||
|
|
this.axisA = options.axisA ? options.axisA.clone() : new Vec3();
|
||
|
|
this.axisB = options.axisB ? options.axisB.clone() : new Vec3();
|
||
|
|
PointToPointConstraint.call(this, bodyA, pivotA, bodyB, pivotB, maxForce);
|
||
|
|
this.collideConnected = !!options.collideConnected;
|
||
|
|
this.angle = "undefined" !== typeof options.angle ? options.angle : 0;
|
||
|
|
var c = this.coneEquation = new ConeEquation(bodyA, bodyB, options);
|
||
|
|
var t = this.twistEquation = new RotationalEquation(bodyA, bodyB, options);
|
||
|
|
this.twistAngle = "undefined" !== typeof options.twistAngle ? options.twistAngle : 0;
|
||
|
|
c.maxForce = 0;
|
||
|
|
c.minForce = -maxForce;
|
||
|
|
t.maxForce = 0;
|
||
|
|
t.minForce = -maxForce;
|
||
|
|
this.equations.push(c, t);
|
||
|
|
}
|
||
|
|
ConeTwistConstraint.prototype = new PointToPointConstraint();
|
||
|
|
ConeTwistConstraint.constructor = ConeTwistConstraint;
|
||
|
|
var ConeTwistConstraint_update_tmpVec1 = new Vec3();
|
||
|
|
var ConeTwistConstraint_update_tmpVec2 = new Vec3();
|
||
|
|
ConeTwistConstraint.prototype.update = function() {
|
||
|
|
var bodyA = this.bodyA, bodyB = this.bodyB, cone = this.coneEquation, twist = this.twistEquation;
|
||
|
|
PointToPointConstraint.prototype.update.call(this);
|
||
|
|
bodyA.vectorToWorldFrame(this.axisA, cone.axisA);
|
||
|
|
bodyB.vectorToWorldFrame(this.axisB, cone.axisB);
|
||
|
|
this.axisA.tangents(twist.axisA, twist.axisA);
|
||
|
|
bodyA.vectorToWorldFrame(twist.axisA, twist.axisA);
|
||
|
|
this.axisB.tangents(twist.axisB, twist.axisB);
|
||
|
|
bodyB.vectorToWorldFrame(twist.axisB, twist.axisB);
|
||
|
|
cone.angle = this.angle;
|
||
|
|
twist.maxAngle = this.twistAngle;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../equations/ConeEquation": 19,
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"../equations/RotationalEquation": 23,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Constraint": 14,
|
||
|
|
"./PointToPointConstraint": 18
|
||
|
|
} ],
|
||
|
|
14: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Constraint;
|
||
|
|
var Utils = _dereq_("../utils/Utils");
|
||
|
|
function Constraint(bodyA, bodyB, options) {
|
||
|
|
options = Utils.defaults(options, {
|
||
|
|
collideConnected: true,
|
||
|
|
wakeUpBodies: true
|
||
|
|
});
|
||
|
|
this.equations = [];
|
||
|
|
this.bodyA = bodyA;
|
||
|
|
this.bodyB = bodyB;
|
||
|
|
this.id = Constraint.idCounter++;
|
||
|
|
this.collideConnected = options.collideConnected;
|
||
|
|
if (options.wakeUpBodies) {
|
||
|
|
bodyA && bodyA.wakeUp();
|
||
|
|
bodyB && bodyB.wakeUp();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Constraint.prototype.update = function() {
|
||
|
|
throw new Error("method update() not implmemented in this Constraint subclass!");
|
||
|
|
};
|
||
|
|
Constraint.prototype.enable = function() {
|
||
|
|
var eqs = this.equations;
|
||
|
|
for (var i = 0; i < eqs.length; i++) eqs[i].enabled = true;
|
||
|
|
};
|
||
|
|
Constraint.prototype.disable = function() {
|
||
|
|
var eqs = this.equations;
|
||
|
|
for (var i = 0; i < eqs.length; i++) eqs[i].enabled = false;
|
||
|
|
};
|
||
|
|
Constraint.idCounter = 0;
|
||
|
|
}, {
|
||
|
|
"../utils/Utils": 55
|
||
|
|
} ],
|
||
|
|
15: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = DistanceConstraint;
|
||
|
|
var Constraint = _dereq_("./Constraint");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
function DistanceConstraint(bodyA, bodyB, distance, maxForce) {
|
||
|
|
Constraint.call(this, bodyA, bodyB);
|
||
|
|
"undefined" === typeof distance && (distance = bodyA.position.distanceTo(bodyB.position));
|
||
|
|
"undefined" === typeof maxForce && (maxForce = 1e6);
|
||
|
|
this.distance = distance;
|
||
|
|
var eq = this.distanceEquation = new ContactEquation(bodyA, bodyB);
|
||
|
|
this.equations.push(eq);
|
||
|
|
eq.minForce = -maxForce;
|
||
|
|
eq.maxForce = maxForce;
|
||
|
|
}
|
||
|
|
DistanceConstraint.prototype = new Constraint();
|
||
|
|
DistanceConstraint.prototype.update = function() {
|
||
|
|
var bodyA = this.bodyA;
|
||
|
|
var bodyB = this.bodyB;
|
||
|
|
var eq = this.distanceEquation;
|
||
|
|
var halfDist = .5 * this.distance;
|
||
|
|
var normal = eq.ni;
|
||
|
|
bodyB.position.vsub(bodyA.position, normal);
|
||
|
|
normal.normalize();
|
||
|
|
normal.mult(halfDist, eq.ri);
|
||
|
|
normal.mult(-halfDist, eq.rj);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"./Constraint": 14
|
||
|
|
} ],
|
||
|
|
16: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = HingeConstraint;
|
||
|
|
var Constraint = _dereq_("./Constraint");
|
||
|
|
var PointToPointConstraint = _dereq_("./PointToPointConstraint");
|
||
|
|
var RotationalEquation = _dereq_("../equations/RotationalEquation");
|
||
|
|
var RotationalMotorEquation = _dereq_("../equations/RotationalMotorEquation");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function HingeConstraint(bodyA, bodyB, options) {
|
||
|
|
options = options || {};
|
||
|
|
var maxForce = "undefined" !== typeof options.maxForce ? options.maxForce : 1e6;
|
||
|
|
var pivotA = options.pivotA ? options.pivotA.clone() : new Vec3();
|
||
|
|
var pivotB = options.pivotB ? options.pivotB.clone() : new Vec3();
|
||
|
|
PointToPointConstraint.call(this, bodyA, pivotA, bodyB, pivotB, maxForce);
|
||
|
|
var axisA = this.axisA = options.axisA ? options.axisA.clone() : new Vec3(1, 0, 0);
|
||
|
|
axisA.normalize();
|
||
|
|
var axisB = this.axisB = options.axisB ? options.axisB.clone() : new Vec3(1, 0, 0);
|
||
|
|
axisB.normalize();
|
||
|
|
var r1 = this.rotationalEquation1 = new RotationalEquation(bodyA, bodyB, options);
|
||
|
|
var r2 = this.rotationalEquation2 = new RotationalEquation(bodyA, bodyB, options);
|
||
|
|
var motor = this.motorEquation = new RotationalMotorEquation(bodyA, bodyB, maxForce);
|
||
|
|
motor.enabled = false;
|
||
|
|
this.equations.push(r1, r2, motor);
|
||
|
|
}
|
||
|
|
HingeConstraint.prototype = new PointToPointConstraint();
|
||
|
|
HingeConstraint.constructor = HingeConstraint;
|
||
|
|
HingeConstraint.prototype.enableMotor = function() {
|
||
|
|
this.motorEquation.enabled = true;
|
||
|
|
};
|
||
|
|
HingeConstraint.prototype.disableMotor = function() {
|
||
|
|
this.motorEquation.enabled = false;
|
||
|
|
};
|
||
|
|
HingeConstraint.prototype.setMotorSpeed = function(speed) {
|
||
|
|
this.motorEquation.targetVelocity = speed;
|
||
|
|
};
|
||
|
|
HingeConstraint.prototype.setMotorMaxForce = function(maxForce) {
|
||
|
|
this.motorEquation.maxForce = maxForce;
|
||
|
|
this.motorEquation.minForce = -maxForce;
|
||
|
|
};
|
||
|
|
var HingeConstraint_update_tmpVec1 = new Vec3();
|
||
|
|
var HingeConstraint_update_tmpVec2 = new Vec3();
|
||
|
|
HingeConstraint.prototype.update = function() {
|
||
|
|
var bodyA = this.bodyA, bodyB = this.bodyB, motor = this.motorEquation, r1 = this.rotationalEquation1, r2 = this.rotationalEquation2, worldAxisA = HingeConstraint_update_tmpVec1, worldAxisB = HingeConstraint_update_tmpVec2;
|
||
|
|
var axisA = this.axisA;
|
||
|
|
var axisB = this.axisB;
|
||
|
|
PointToPointConstraint.prototype.update.call(this);
|
||
|
|
bodyA.quaternion.vmult(axisA, worldAxisA);
|
||
|
|
bodyB.quaternion.vmult(axisB, worldAxisB);
|
||
|
|
worldAxisA.tangents(r1.axisA, r2.axisA);
|
||
|
|
r1.axisB.copy(worldAxisB);
|
||
|
|
r2.axisB.copy(worldAxisB);
|
||
|
|
if (this.motorEquation.enabled) {
|
||
|
|
bodyA.quaternion.vmult(this.axisA, motor.axisA);
|
||
|
|
bodyB.quaternion.vmult(this.axisB, motor.axisB);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"../equations/RotationalEquation": 23,
|
||
|
|
"../equations/RotationalMotorEquation": 24,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Constraint": 14,
|
||
|
|
"./PointToPointConstraint": 18
|
||
|
|
} ],
|
||
|
|
17: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = LockConstraint;
|
||
|
|
var Constraint = _dereq_("./Constraint");
|
||
|
|
var PointToPointConstraint = _dereq_("./PointToPointConstraint");
|
||
|
|
var RotationalEquation = _dereq_("../equations/RotationalEquation");
|
||
|
|
var RotationalMotorEquation = _dereq_("../equations/RotationalMotorEquation");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function LockConstraint(bodyA, bodyB, options) {
|
||
|
|
options = options || {};
|
||
|
|
var maxForce = "undefined" !== typeof options.maxForce ? options.maxForce : 1e6;
|
||
|
|
var pivotA = new Vec3();
|
||
|
|
var pivotB = new Vec3();
|
||
|
|
var halfWay = new Vec3();
|
||
|
|
bodyA.position.vadd(bodyB.position, halfWay);
|
||
|
|
halfWay.scale(.5, halfWay);
|
||
|
|
bodyB.pointToLocalFrame(halfWay, pivotB);
|
||
|
|
bodyA.pointToLocalFrame(halfWay, pivotA);
|
||
|
|
PointToPointConstraint.call(this, bodyA, pivotA, bodyB, pivotB, maxForce);
|
||
|
|
this.xA = bodyA.vectorToLocalFrame(Vec3.UNIT_X);
|
||
|
|
this.xB = bodyB.vectorToLocalFrame(Vec3.UNIT_X);
|
||
|
|
this.yA = bodyA.vectorToLocalFrame(Vec3.UNIT_Y);
|
||
|
|
this.yB = bodyB.vectorToLocalFrame(Vec3.UNIT_Y);
|
||
|
|
this.zA = bodyA.vectorToLocalFrame(Vec3.UNIT_Z);
|
||
|
|
this.zB = bodyB.vectorToLocalFrame(Vec3.UNIT_Z);
|
||
|
|
var r1 = this.rotationalEquation1 = new RotationalEquation(bodyA, bodyB, options);
|
||
|
|
var r2 = this.rotationalEquation2 = new RotationalEquation(bodyA, bodyB, options);
|
||
|
|
var r3 = this.rotationalEquation3 = new RotationalEquation(bodyA, bodyB, options);
|
||
|
|
this.equations.push(r1, r2, r3);
|
||
|
|
}
|
||
|
|
LockConstraint.prototype = new PointToPointConstraint();
|
||
|
|
LockConstraint.constructor = LockConstraint;
|
||
|
|
var LockConstraint_update_tmpVec1 = new Vec3();
|
||
|
|
var LockConstraint_update_tmpVec2 = new Vec3();
|
||
|
|
LockConstraint.prototype.update = function() {
|
||
|
|
var bodyA = this.bodyA, bodyB = this.bodyB, motor = this.motorEquation, r1 = this.rotationalEquation1, r2 = this.rotationalEquation2, r3 = this.rotationalEquation3, worldAxisA = LockConstraint_update_tmpVec1, worldAxisB = LockConstraint_update_tmpVec2;
|
||
|
|
PointToPointConstraint.prototype.update.call(this);
|
||
|
|
bodyA.vectorToWorldFrame(this.xA, r1.axisA);
|
||
|
|
bodyB.vectorToWorldFrame(this.yB, r1.axisB);
|
||
|
|
bodyA.vectorToWorldFrame(this.yA, r2.axisA);
|
||
|
|
bodyB.vectorToWorldFrame(this.zB, r2.axisB);
|
||
|
|
bodyA.vectorToWorldFrame(this.zA, r3.axisA);
|
||
|
|
bodyB.vectorToWorldFrame(this.xB, r3.axisB);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"../equations/RotationalEquation": 23,
|
||
|
|
"../equations/RotationalMotorEquation": 24,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Constraint": 14,
|
||
|
|
"./PointToPointConstraint": 18
|
||
|
|
} ],
|
||
|
|
18: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = PointToPointConstraint;
|
||
|
|
var Constraint = _dereq_("./Constraint");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function PointToPointConstraint(bodyA, pivotA, bodyB, pivotB, maxForce) {
|
||
|
|
Constraint.call(this, bodyA, bodyB);
|
||
|
|
maxForce = "undefined" !== typeof maxForce ? maxForce : 1e6;
|
||
|
|
this.pivotA = pivotA ? pivotA.clone() : new Vec3();
|
||
|
|
this.pivotB = pivotB ? pivotB.clone() : new Vec3();
|
||
|
|
var x = this.equationX = new ContactEquation(bodyA, bodyB);
|
||
|
|
var y = this.equationY = new ContactEquation(bodyA, bodyB);
|
||
|
|
var z = this.equationZ = new ContactEquation(bodyA, bodyB);
|
||
|
|
this.equations.push(x, y, z);
|
||
|
|
x.minForce = y.minForce = z.minForce = -maxForce;
|
||
|
|
x.maxForce = y.maxForce = z.maxForce = maxForce;
|
||
|
|
x.ni.set(1, 0, 0);
|
||
|
|
y.ni.set(0, 1, 0);
|
||
|
|
z.ni.set(0, 0, 1);
|
||
|
|
}
|
||
|
|
PointToPointConstraint.prototype = new Constraint();
|
||
|
|
PointToPointConstraint.prototype.update = function() {
|
||
|
|
var bodyA = this.bodyA;
|
||
|
|
var bodyB = this.bodyB;
|
||
|
|
var x = this.equationX;
|
||
|
|
var y = this.equationY;
|
||
|
|
var z = this.equationZ;
|
||
|
|
bodyA.quaternion.vmult(this.pivotA, x.ri);
|
||
|
|
bodyB.quaternion.vmult(this.pivotB, x.rj);
|
||
|
|
y.ri.copy(x.ri);
|
||
|
|
y.rj.copy(x.rj);
|
||
|
|
z.ri.copy(x.ri);
|
||
|
|
z.rj.copy(x.rj);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Constraint": 14
|
||
|
|
} ],
|
||
|
|
19: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = ConeEquation;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Mat3 = _dereq_("../math/Mat3");
|
||
|
|
var Equation = _dereq_("./Equation");
|
||
|
|
var CMath = _dereq_("../math/CMath");
|
||
|
|
function ConeEquation(bodyA, bodyB, options) {
|
||
|
|
options = options || {};
|
||
|
|
var maxForce = "undefined" !== typeof options.maxForce ? options.maxForce : 1e6;
|
||
|
|
Equation.call(this, bodyA, bodyB, -maxForce, maxForce);
|
||
|
|
this.axisA = options.axisA ? options.axisA.clone() : new Vec3(1, 0, 0);
|
||
|
|
this.axisB = options.axisB ? options.axisB.clone() : new Vec3(0, 1, 0);
|
||
|
|
this.angle = "undefined" !== typeof options.angle ? options.angle : 0;
|
||
|
|
}
|
||
|
|
ConeEquation.prototype = new Equation();
|
||
|
|
ConeEquation.prototype.constructor = ConeEquation;
|
||
|
|
var tmpVec1 = new Vec3();
|
||
|
|
var tmpVec2 = new Vec3();
|
||
|
|
ConeEquation.prototype.computeB = function(h) {
|
||
|
|
var a = this.a, b = this.b, ni = this.axisA, nj = this.axisB, nixnj = tmpVec1, njxni = tmpVec2, GA = this.jacobianElementA, GB = this.jacobianElementB;
|
||
|
|
ni.cross(nj, nixnj);
|
||
|
|
nj.cross(ni, njxni);
|
||
|
|
GA.rotational.copy(njxni);
|
||
|
|
GB.rotational.copy(nixnj);
|
||
|
|
var g = CMath.cos(this.angle) - ni.dot(nj), GW = this.computeGW(), GiMf = this.computeGiMf();
|
||
|
|
var B = -g * a - GW * b - h * GiMf;
|
||
|
|
return B;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/CMath": 27,
|
||
|
|
"../math/Mat3": 29,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Equation": 21
|
||
|
|
} ],
|
||
|
|
20: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = ContactEquation;
|
||
|
|
var Equation = _dereq_("./Equation");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Mat3 = _dereq_("../math/Mat3");
|
||
|
|
function ContactEquation(bodyA, bodyB, maxForce) {
|
||
|
|
maxForce = "undefined" !== typeof maxForce ? maxForce : 1e6;
|
||
|
|
Equation.call(this, bodyA, bodyB, 0, maxForce);
|
||
|
|
this.si = null;
|
||
|
|
this.sj = null;
|
||
|
|
this.restitution = 0;
|
||
|
|
this.ri = new Vec3();
|
||
|
|
this.rj = new Vec3();
|
||
|
|
this.ni = new Vec3();
|
||
|
|
}
|
||
|
|
ContactEquation.prototype = new Equation();
|
||
|
|
ContactEquation.prototype.constructor = ContactEquation;
|
||
|
|
var ContactEquation_computeB_temp1 = new Vec3();
|
||
|
|
var ContactEquation_computeB_temp2 = new Vec3();
|
||
|
|
var ContactEquation_computeB_temp3 = new Vec3();
|
||
|
|
ContactEquation.prototype.computeB = function(h) {
|
||
|
|
var a = this.a, b = this.b, bi = this.bi, bj = this.bj, ri = this.ri, rj = this.rj, rixn = ContactEquation_computeB_temp1, rjxn = ContactEquation_computeB_temp2, vi = bi.velocity, wi = bi.angularVelocity, fi = bi.force, taui = bi.torque, vj = bj.velocity, wj = bj.angularVelocity, fj = bj.force, tauj = bj.torque, penetrationVec = ContactEquation_computeB_temp3, GA = this.jacobianElementA, GB = this.jacobianElementB, n = this.ni;
|
||
|
|
ri.cross(n, rixn);
|
||
|
|
rj.cross(n, rjxn);
|
||
|
|
n.negate(GA.spatial);
|
||
|
|
rixn.negate(GA.rotational);
|
||
|
|
GB.spatial.copy(n);
|
||
|
|
GB.rotational.copy(rjxn);
|
||
|
|
penetrationVec.copy(bj.position);
|
||
|
|
penetrationVec.vadd(rj, penetrationVec);
|
||
|
|
penetrationVec.vsub(bi.position, penetrationVec);
|
||
|
|
penetrationVec.vsub(ri, penetrationVec);
|
||
|
|
var g = n.dot(penetrationVec);
|
||
|
|
var ePlusOne = this.restitution + 1;
|
||
|
|
var GW = ePlusOne * vj.dot(n) - ePlusOne * vi.dot(n) + wj.dot(rjxn) - wi.dot(rixn);
|
||
|
|
var GiMf = this.computeGiMf();
|
||
|
|
var B = -g * a - GW * b - h * GiMf;
|
||
|
|
return B;
|
||
|
|
};
|
||
|
|
var ContactEquation_getImpactVelocityAlongNormal_vi = new Vec3();
|
||
|
|
var ContactEquation_getImpactVelocityAlongNormal_vj = new Vec3();
|
||
|
|
var ContactEquation_getImpactVelocityAlongNormal_xi = new Vec3();
|
||
|
|
var ContactEquation_getImpactVelocityAlongNormal_xj = new Vec3();
|
||
|
|
var ContactEquation_getImpactVelocityAlongNormal_relVel = new Vec3();
|
||
|
|
ContactEquation.prototype.getImpactVelocityAlongNormal = function() {
|
||
|
|
var vi = ContactEquation_getImpactVelocityAlongNormal_vi;
|
||
|
|
var vj = ContactEquation_getImpactVelocityAlongNormal_vj;
|
||
|
|
var xi = ContactEquation_getImpactVelocityAlongNormal_xi;
|
||
|
|
var xj = ContactEquation_getImpactVelocityAlongNormal_xj;
|
||
|
|
var relVel = ContactEquation_getImpactVelocityAlongNormal_relVel;
|
||
|
|
this.bi.position.vadd(this.ri, xi);
|
||
|
|
this.bj.position.vadd(this.rj, xj);
|
||
|
|
this.bi.getVelocityAtWorldPoint(xi, vi);
|
||
|
|
this.bj.getVelocityAtWorldPoint(xj, vj);
|
||
|
|
vi.vsub(vj, relVel);
|
||
|
|
return this.ni.dot(relVel);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Mat3": 29,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Equation": 21
|
||
|
|
} ],
|
||
|
|
21: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Equation;
|
||
|
|
var JacobianElement = _dereq_("../math/JacobianElement"), Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function Equation(bi, bj, minForce, maxForce) {
|
||
|
|
this.id = Equation.id++;
|
||
|
|
this.minForce = "undefined" === typeof minForce ? -1e6 : minForce;
|
||
|
|
this.maxForce = "undefined" === typeof maxForce ? 1e6 : maxForce;
|
||
|
|
this.bi = bi;
|
||
|
|
this.bj = bj;
|
||
|
|
this.a = 0;
|
||
|
|
this.b = 0;
|
||
|
|
this.eps = 0;
|
||
|
|
this.jacobianElementA = new JacobianElement();
|
||
|
|
this.jacobianElementB = new JacobianElement();
|
||
|
|
this.enabled = true;
|
||
|
|
this.multiplier = 0;
|
||
|
|
this.setSpookParams(1e7, 4, 1 / 60);
|
||
|
|
}
|
||
|
|
Equation.prototype.constructor = Equation;
|
||
|
|
Equation.id = 0;
|
||
|
|
Equation.prototype.setSpookParams = function(stiffness, relaxation, timeStep) {
|
||
|
|
var d = relaxation, k = stiffness, h = timeStep;
|
||
|
|
this.a = 4 / (h * (1 + 4 * d));
|
||
|
|
this.b = 4 * d / (1 + 4 * d);
|
||
|
|
this.eps = 4 / (h * h * k * (1 + 4 * d));
|
||
|
|
};
|
||
|
|
Equation.prototype.computeB = function(a, b, h) {
|
||
|
|
var GW = this.computeGW(), Gq = this.computeGq(), GiMf = this.computeGiMf();
|
||
|
|
return -Gq * a - GW * b - GiMf * h;
|
||
|
|
};
|
||
|
|
Equation.prototype.computeGq = function() {
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB, bi = this.bi, bj = this.bj, xi = bi.position, xj = bj.position;
|
||
|
|
return GA.spatial.dot(xi) + GB.spatial.dot(xj);
|
||
|
|
};
|
||
|
|
var zero = new Vec3();
|
||
|
|
Equation.prototype.computeGW = function() {
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB, bi = this.bi, bj = this.bj, vi = bi.velocity, vj = bj.velocity, wi = bi.angularVelocity, wj = bj.angularVelocity;
|
||
|
|
return GA.multiplyVectors(vi, wi) + GB.multiplyVectors(vj, wj);
|
||
|
|
};
|
||
|
|
Equation.prototype.computeGWlambda = function() {
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB, bi = this.bi, bj = this.bj, vi = bi.vlambda, vj = bj.vlambda, wi = bi.wlambda, wj = bj.wlambda;
|
||
|
|
return GA.multiplyVectors(vi, wi) + GB.multiplyVectors(vj, wj);
|
||
|
|
};
|
||
|
|
var iMfi = new Vec3(), iMfj = new Vec3(), invIi_vmult_taui = new Vec3(), invIj_vmult_tauj = new Vec3();
|
||
|
|
Equation.prototype.computeGiMf = function() {
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB, bi = this.bi, bj = this.bj, fi = bi.force, ti = bi.torque, fj = bj.force, tj = bj.torque, invMassi = bi.invMassSolve, invMassj = bj.invMassSolve;
|
||
|
|
fi.scale(invMassi, iMfi);
|
||
|
|
fj.scale(invMassj, iMfj);
|
||
|
|
bi.invInertiaWorldSolve.vmult(ti, invIi_vmult_taui);
|
||
|
|
bj.invInertiaWorldSolve.vmult(tj, invIj_vmult_tauj);
|
||
|
|
return GA.multiplyVectors(iMfi, invIi_vmult_taui) + GB.multiplyVectors(iMfj, invIj_vmult_tauj);
|
||
|
|
};
|
||
|
|
var tmp = new Vec3();
|
||
|
|
Equation.prototype.computeGiMGt = function() {
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB, bi = this.bi, bj = this.bj, invMassi = bi.invMassSolve, invMassj = bj.invMassSolve, invIi = bi.invInertiaWorldSolve, invIj = bj.invInertiaWorldSolve, result = invMassi + invMassj;
|
||
|
|
invIi.vmult(GA.rotational, tmp);
|
||
|
|
result += tmp.dot(GA.rotational);
|
||
|
|
invIj.vmult(GB.rotational, tmp);
|
||
|
|
result += tmp.dot(GB.rotational);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var addToWlambda_temp = new Vec3(), addToWlambda_Gi = new Vec3(), addToWlambda_Gj = new Vec3(), addToWlambda_ri = new Vec3(), addToWlambda_rj = new Vec3(), addToWlambda_Mdiag = new Vec3();
|
||
|
|
Equation.prototype.addToWlambda = function(deltalambda) {
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB, bi = this.bi, bj = this.bj, temp = addToWlambda_temp;
|
||
|
|
bi.vlambda.addScaledVector(bi.invMassSolve * deltalambda, GA.spatial, bi.vlambda);
|
||
|
|
bj.vlambda.addScaledVector(bj.invMassSolve * deltalambda, GB.spatial, bj.vlambda);
|
||
|
|
bi.invInertiaWorldSolve.vmult(GA.rotational, temp);
|
||
|
|
bi.wlambda.addScaledVector(deltalambda, temp, bi.wlambda);
|
||
|
|
bj.invInertiaWorldSolve.vmult(GB.rotational, temp);
|
||
|
|
bj.wlambda.addScaledVector(deltalambda, temp, bj.wlambda);
|
||
|
|
};
|
||
|
|
Equation.prototype.computeC = function() {
|
||
|
|
return this.computeGiMGt() + this.eps;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/JacobianElement": 28,
|
||
|
|
"../math/Vec3": 32
|
||
|
|
} ],
|
||
|
|
22: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = FrictionEquation;
|
||
|
|
var Equation = _dereq_("./Equation");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Mat3 = _dereq_("../math/Mat3");
|
||
|
|
function FrictionEquation(bodyA, bodyB, slipForce) {
|
||
|
|
Equation.call(this, bodyA, bodyB, -slipForce, slipForce);
|
||
|
|
this.ri = new Vec3();
|
||
|
|
this.rj = new Vec3();
|
||
|
|
this.t = new Vec3();
|
||
|
|
}
|
||
|
|
FrictionEquation.prototype = new Equation();
|
||
|
|
FrictionEquation.prototype.constructor = FrictionEquation;
|
||
|
|
var FrictionEquation_computeB_temp1 = new Vec3();
|
||
|
|
var FrictionEquation_computeB_temp2 = new Vec3();
|
||
|
|
FrictionEquation.prototype.computeB = function(h) {
|
||
|
|
var a = this.a, b = this.b, bi = this.bi, bj = this.bj, ri = this.ri, rj = this.rj, rixt = FrictionEquation_computeB_temp1, rjxt = FrictionEquation_computeB_temp2, t = this.t;
|
||
|
|
ri.cross(t, rixt);
|
||
|
|
rj.cross(t, rjxt);
|
||
|
|
var GA = this.jacobianElementA, GB = this.jacobianElementB;
|
||
|
|
t.negate(GA.spatial);
|
||
|
|
rixt.negate(GA.rotational);
|
||
|
|
GB.spatial.copy(t);
|
||
|
|
GB.rotational.copy(rjxt);
|
||
|
|
var GW = this.computeGW();
|
||
|
|
var GiMf = this.computeGiMf();
|
||
|
|
var B = -GW * b - h * GiMf;
|
||
|
|
return B;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Mat3": 29,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Equation": 21
|
||
|
|
} ],
|
||
|
|
23: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = RotationalEquation;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Mat3 = _dereq_("../math/Mat3");
|
||
|
|
var Equation = _dereq_("./Equation");
|
||
|
|
var CMath = _dereq_("../math/CMath");
|
||
|
|
function RotationalEquation(bodyA, bodyB, options) {
|
||
|
|
options = options || {};
|
||
|
|
var maxForce = "undefined" !== typeof options.maxForce ? options.maxForce : 1e6;
|
||
|
|
Equation.call(this, bodyA, bodyB, -maxForce, maxForce);
|
||
|
|
this.axisA = options.axisA ? options.axisA.clone() : new Vec3(1, 0, 0);
|
||
|
|
this.axisB = options.axisB ? options.axisB.clone() : new Vec3(0, 1, 0);
|
||
|
|
this.maxAngle = Math.PI / 2;
|
||
|
|
}
|
||
|
|
RotationalEquation.prototype = new Equation();
|
||
|
|
RotationalEquation.prototype.constructor = RotationalEquation;
|
||
|
|
var tmpVec1 = new Vec3();
|
||
|
|
var tmpVec2 = new Vec3();
|
||
|
|
RotationalEquation.prototype.computeB = function(h) {
|
||
|
|
var a = this.a, b = this.b, ni = this.axisA, nj = this.axisB, nixnj = tmpVec1, njxni = tmpVec2, GA = this.jacobianElementA, GB = this.jacobianElementB;
|
||
|
|
ni.cross(nj, nixnj);
|
||
|
|
nj.cross(ni, njxni);
|
||
|
|
GA.rotational.copy(njxni);
|
||
|
|
GB.rotational.copy(nixnj);
|
||
|
|
var g = CMath.cos(this.maxAngle) - ni.dot(nj), GW = this.computeGW(), GiMf = this.computeGiMf();
|
||
|
|
var B = -g * a - GW * b - h * GiMf;
|
||
|
|
return B;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/CMath": 27,
|
||
|
|
"../math/Mat3": 29,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Equation": 21
|
||
|
|
} ],
|
||
|
|
24: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = RotationalMotorEquation;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Mat3 = _dereq_("../math/Mat3");
|
||
|
|
var Equation = _dereq_("./Equation");
|
||
|
|
function RotationalMotorEquation(bodyA, bodyB, maxForce) {
|
||
|
|
maxForce = "undefined" !== typeof maxForce ? maxForce : 1e6;
|
||
|
|
Equation.call(this, bodyA, bodyB, -maxForce, maxForce);
|
||
|
|
this.axisA = new Vec3();
|
||
|
|
this.axisB = new Vec3();
|
||
|
|
this.targetVelocity = 0;
|
||
|
|
}
|
||
|
|
RotationalMotorEquation.prototype = new Equation();
|
||
|
|
RotationalMotorEquation.prototype.constructor = RotationalMotorEquation;
|
||
|
|
RotationalMotorEquation.prototype.computeB = function(h) {
|
||
|
|
var a = this.a, b = this.b, bi = this.bi, bj = this.bj, axisA = this.axisA, axisB = this.axisB, GA = this.jacobianElementA, GB = this.jacobianElementB;
|
||
|
|
GA.rotational.copy(axisA);
|
||
|
|
axisB.negate(GB.rotational);
|
||
|
|
var GW = this.computeGW() - this.targetVelocity, GiMf = this.computeGiMf();
|
||
|
|
var B = -GW * b - h * GiMf;
|
||
|
|
return B;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Mat3": 29,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Equation": 21
|
||
|
|
} ],
|
||
|
|
25: [ function(_dereq_, module, exports) {
|
||
|
|
var Utils = _dereq_("../utils/Utils");
|
||
|
|
module.exports = ContactMaterial;
|
||
|
|
function ContactMaterial(m1, m2, options) {
|
||
|
|
options = Utils.defaults(options, {
|
||
|
|
friction: .3,
|
||
|
|
restitution: .3,
|
||
|
|
contactEquationStiffness: 1e7,
|
||
|
|
contactEquationRelaxation: 3,
|
||
|
|
frictionEquationStiffness: 1e7,
|
||
|
|
frictionEquationRelaxation: 3
|
||
|
|
});
|
||
|
|
this.id = ContactMaterial.idCounter++;
|
||
|
|
this.materials = [ m1, m2 ];
|
||
|
|
this.friction = options.friction;
|
||
|
|
this.restitution = options.restitution;
|
||
|
|
this.contactEquationStiffness = options.contactEquationStiffness;
|
||
|
|
this.contactEquationRelaxation = options.contactEquationRelaxation;
|
||
|
|
this.frictionEquationStiffness = options.frictionEquationStiffness;
|
||
|
|
this.frictionEquationRelaxation = options.frictionEquationRelaxation;
|
||
|
|
}
|
||
|
|
ContactMaterial.idCounter = 0;
|
||
|
|
}, {
|
||
|
|
"../utils/Utils": 55
|
||
|
|
} ],
|
||
|
|
26: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Material;
|
||
|
|
function Material(options) {
|
||
|
|
var name = "";
|
||
|
|
options = options || {};
|
||
|
|
if ("string" === typeof options) {
|
||
|
|
name = options;
|
||
|
|
options = {};
|
||
|
|
} else "object" === typeof options && (name = "");
|
||
|
|
this.name = name;
|
||
|
|
this.id = Material.idCounter++;
|
||
|
|
this.friction = "undefined" !== typeof options.friction ? options.friction : -1;
|
||
|
|
this.restitution = "undefined" !== typeof options.restitution ? options.restitution : -1;
|
||
|
|
}
|
||
|
|
Material.idCounter = 0;
|
||
|
|
}, {} ],
|
||
|
|
27: [ function(_dereq_, module, exports) {
|
||
|
|
var rad2ang = 180 / Math.PI;
|
||
|
|
function radian2angle(rad) {
|
||
|
|
return rad * rad2ang;
|
||
|
|
}
|
||
|
|
var sinArr = {};
|
||
|
|
function calculateSinByDigit(digit) {
|
||
|
|
if (sinArr.digit == digit) return;
|
||
|
|
var step = 1 / Math.pow(10, digit);
|
||
|
|
for (var i = 0; i <= 90; i += step) sinArr[i.toFixed(digit)] = Math.sin(i / rad2ang);
|
||
|
|
sinArr.digit = digit;
|
||
|
|
}
|
||
|
|
function sin360(angle, digit) {
|
||
|
|
if (angle <= 90) return sinArr[angle.toFixed(digit)];
|
||
|
|
if (angle <= 180) {
|
||
|
|
angle = 180 - angle;
|
||
|
|
return sinArr[angle.toFixed(digit)];
|
||
|
|
}
|
||
|
|
if (angle <= 270) {
|
||
|
|
angle -= 180;
|
||
|
|
return -sinArr[angle.toFixed(digit)];
|
||
|
|
}
|
||
|
|
angle = 360 - angle;
|
||
|
|
return -sinArr[angle.toFixed(digit)];
|
||
|
|
}
|
||
|
|
function sin(rad) {
|
||
|
|
var angle = radian2angle(rad) % 360;
|
||
|
|
angle < 0 && (angle += 360);
|
||
|
|
return sin360(angle, CMath._digit);
|
||
|
|
}
|
||
|
|
function cos(rad) {
|
||
|
|
var angle = (radian2angle(rad) + 90) % 360;
|
||
|
|
angle < 0 && (angle += 360);
|
||
|
|
return sin360(angle, CMath._digit);
|
||
|
|
}
|
||
|
|
function sinNative(rad) {
|
||
|
|
return Math.sin(rad).toFixed(CMath.digit);
|
||
|
|
}
|
||
|
|
function cosNative(rad) {
|
||
|
|
return Math.cos(rad).toFixed(CMath.digit);
|
||
|
|
}
|
||
|
|
var CMath = {
|
||
|
|
sin: Math.sin,
|
||
|
|
cos: Math.cos,
|
||
|
|
atan2: Math.atan2
|
||
|
|
};
|
||
|
|
CMath._sin = sin;
|
||
|
|
CMath._cos = cos;
|
||
|
|
CMath._sinArr = sinArr;
|
||
|
|
CMath._sin360 = sin360;
|
||
|
|
CMath._sinNative = sinNative;
|
||
|
|
CMath._cosNative = cosNative;
|
||
|
|
CMath._radian2angle = radian2angle;
|
||
|
|
CMath._calculateSinByDigit = calculateSinByDigit;
|
||
|
|
CMath._digit = 1;
|
||
|
|
Object.defineProperty(CMath, "digit", {
|
||
|
|
get: function get() {
|
||
|
|
return this._digit;
|
||
|
|
},
|
||
|
|
set: function set(v) {
|
||
|
|
this._digit = v;
|
||
|
|
1 == this._mode && calculateSinByDigit(v);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
CMath._mode = 0;
|
||
|
|
Object.defineProperty(CMath, "mode", {
|
||
|
|
get: function get() {
|
||
|
|
return this._mode;
|
||
|
|
},
|
||
|
|
set: function set(v) {
|
||
|
|
if (this._mode != v) {
|
||
|
|
this._mode = v;
|
||
|
|
if (0 == v) {
|
||
|
|
CMath.sin = Math.sin;
|
||
|
|
CMath.cos = Math.cos;
|
||
|
|
} else if (1 == v) {
|
||
|
|
CMath.digit = CMath._digit;
|
||
|
|
CMath.sin = sin;
|
||
|
|
CMath.cos = cos;
|
||
|
|
} else if (2 == v) {
|
||
|
|
CMath.sin = sinNative;
|
||
|
|
CMath.cos = cosNative;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
module.exports = CMath;
|
||
|
|
}, {} ],
|
||
|
|
28: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = JacobianElement;
|
||
|
|
var Vec3 = _dereq_("./Vec3");
|
||
|
|
function JacobianElement() {
|
||
|
|
this.spatial = new Vec3();
|
||
|
|
this.rotational = new Vec3();
|
||
|
|
}
|
||
|
|
JacobianElement.prototype.multiplyElement = function(element) {
|
||
|
|
return element.spatial.dot(this.spatial) + element.rotational.dot(this.rotational);
|
||
|
|
};
|
||
|
|
JacobianElement.prototype.multiplyVectors = function(spatial, rotational) {
|
||
|
|
return spatial.dot(this.spatial) + rotational.dot(this.rotational);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"./Vec3": 32
|
||
|
|
} ],
|
||
|
|
29: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Mat3;
|
||
|
|
var Vec3 = _dereq_("./Vec3");
|
||
|
|
function Mat3(elements) {
|
||
|
|
this.elements = elements || [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
|
||
|
|
}
|
||
|
|
Mat3.prototype.identity = function() {
|
||
|
|
var e = this.elements;
|
||
|
|
e[0] = 1;
|
||
|
|
e[1] = 0;
|
||
|
|
e[2] = 0;
|
||
|
|
e[3] = 0;
|
||
|
|
e[4] = 1;
|
||
|
|
e[5] = 0;
|
||
|
|
e[6] = 0;
|
||
|
|
e[7] = 0;
|
||
|
|
e[8] = 1;
|
||
|
|
};
|
||
|
|
Mat3.prototype.setZero = function() {
|
||
|
|
var e = this.elements;
|
||
|
|
e[0] = 0;
|
||
|
|
e[1] = 0;
|
||
|
|
e[2] = 0;
|
||
|
|
e[3] = 0;
|
||
|
|
e[4] = 0;
|
||
|
|
e[5] = 0;
|
||
|
|
e[6] = 0;
|
||
|
|
e[7] = 0;
|
||
|
|
e[8] = 0;
|
||
|
|
};
|
||
|
|
Mat3.prototype.setTrace = function(vec3) {
|
||
|
|
var e = this.elements;
|
||
|
|
e[0] = vec3.x;
|
||
|
|
e[4] = vec3.y;
|
||
|
|
e[8] = vec3.z;
|
||
|
|
};
|
||
|
|
Mat3.prototype.getTrace = function(target) {
|
||
|
|
var target = target || new Vec3();
|
||
|
|
var e = this.elements;
|
||
|
|
target.x = e[0];
|
||
|
|
target.y = e[4];
|
||
|
|
target.z = e[8];
|
||
|
|
};
|
||
|
|
Mat3.prototype.vmult = function(v, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var e = this.elements, x = v.x, y = v.y, z = v.z;
|
||
|
|
target.x = e[0] * x + e[1] * y + e[2] * z;
|
||
|
|
target.y = e[3] * x + e[4] * y + e[5] * z;
|
||
|
|
target.z = e[6] * x + e[7] * y + e[8] * z;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Mat3.prototype.smult = function(s) {
|
||
|
|
for (var i = 0; i < this.elements.length; i++) this.elements[i] *= s;
|
||
|
|
};
|
||
|
|
Mat3.prototype.mmult = function(m, target) {
|
||
|
|
var r = target || new Mat3();
|
||
|
|
for (var i = 0; i < 3; i++) for (var j = 0; j < 3; j++) {
|
||
|
|
var sum = 0;
|
||
|
|
for (var k = 0; k < 3; k++) sum += m.elements[i + 3 * k] * this.elements[k + 3 * j];
|
||
|
|
r.elements[i + 3 * j] = sum;
|
||
|
|
}
|
||
|
|
return r;
|
||
|
|
};
|
||
|
|
Mat3.prototype.scale = function(v, target) {
|
||
|
|
target = target || new Mat3();
|
||
|
|
var e = this.elements, t = target.elements;
|
||
|
|
for (var i = 0; 3 !== i; i++) {
|
||
|
|
t[3 * i + 0] = v.x * e[3 * i + 0];
|
||
|
|
t[3 * i + 1] = v.y * e[3 * i + 1];
|
||
|
|
t[3 * i + 2] = v.z * e[3 * i + 2];
|
||
|
|
}
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Mat3.prototype.solve = function(b, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var nr = 3;
|
||
|
|
var nc = 4;
|
||
|
|
var eqns = [];
|
||
|
|
for (var i = 0; i < nr * nc; i++) eqns.push(0);
|
||
|
|
var i, j;
|
||
|
|
for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) eqns[i + nc * j] = this.elements[i + 3 * j];
|
||
|
|
eqns[3] = b.x;
|
||
|
|
eqns[7] = b.y;
|
||
|
|
eqns[11] = b.z;
|
||
|
|
var n = 3, k = n, np;
|
||
|
|
var kp = 4;
|
||
|
|
var p, els;
|
||
|
|
do {
|
||
|
|
i = k - n;
|
||
|
|
if (0 === eqns[i + nc * i]) for (j = i + 1; j < k; j++) if (0 !== eqns[i + nc * j]) {
|
||
|
|
np = kp;
|
||
|
|
do {
|
||
|
|
p = kp - np;
|
||
|
|
eqns[p + nc * i] += eqns[p + nc * j];
|
||
|
|
} while (--np);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (0 !== eqns[i + nc * i]) for (j = i + 1; j < k; j++) {
|
||
|
|
var multiplier = eqns[i + nc * j] / eqns[i + nc * i];
|
||
|
|
np = kp;
|
||
|
|
do {
|
||
|
|
p = kp - np;
|
||
|
|
eqns[p + nc * j] = p <= i ? 0 : eqns[p + nc * j] - eqns[p + nc * i] * multiplier;
|
||
|
|
} while (--np);
|
||
|
|
}
|
||
|
|
} while (--n);
|
||
|
|
target.z = eqns[2 * nc + 3] / eqns[2 * nc + 2];
|
||
|
|
target.y = (eqns[1 * nc + 3] - eqns[1 * nc + 2] * target.z) / eqns[1 * nc + 1];
|
||
|
|
target.x = (eqns[0 * nc + 3] - eqns[0 * nc + 2] * target.z - eqns[0 * nc + 1] * target.y) / eqns[0 * nc + 0];
|
||
|
|
if (isNaN(target.x) || isNaN(target.y) || isNaN(target.z) || Infinity === target.x || Infinity === target.y || Infinity === target.z) throw "Could not solve equation! Got x=[" + target.toString() + "], b=[" + b.toString() + "], A=[" + this.toString() + "]";
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Mat3.prototype.e = function(row, column, value) {
|
||
|
|
if (void 0 === value) return this.elements[column + 3 * row];
|
||
|
|
this.elements[column + 3 * row] = value;
|
||
|
|
};
|
||
|
|
Mat3.prototype.copy = function(source) {
|
||
|
|
for (var i = 0; i < source.elements.length; i++) this.elements[i] = source.elements[i];
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Mat3.prototype.toString = function() {
|
||
|
|
var r = "";
|
||
|
|
var sep = ",";
|
||
|
|
for (var i = 0; i < 9; i++) r += this.elements[i] + sep;
|
||
|
|
return r;
|
||
|
|
};
|
||
|
|
Mat3.prototype.reverse = function(target) {
|
||
|
|
target = target || new Mat3();
|
||
|
|
var nr = 3;
|
||
|
|
var nc = 6;
|
||
|
|
var eqns = [];
|
||
|
|
for (var i = 0; i < nr * nc; i++) eqns.push(0);
|
||
|
|
var i, j;
|
||
|
|
for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) eqns[i + nc * j] = this.elements[i + 3 * j];
|
||
|
|
eqns[3] = 1;
|
||
|
|
eqns[9] = 0;
|
||
|
|
eqns[15] = 0;
|
||
|
|
eqns[4] = 0;
|
||
|
|
eqns[10] = 1;
|
||
|
|
eqns[16] = 0;
|
||
|
|
eqns[5] = 0;
|
||
|
|
eqns[11] = 0;
|
||
|
|
eqns[17] = 1;
|
||
|
|
var n = 3, k = n, np;
|
||
|
|
var kp = nc;
|
||
|
|
var p;
|
||
|
|
do {
|
||
|
|
i = k - n;
|
||
|
|
if (0 === eqns[i + nc * i]) for (j = i + 1; j < k; j++) if (0 !== eqns[i + nc * j]) {
|
||
|
|
np = kp;
|
||
|
|
do {
|
||
|
|
p = kp - np;
|
||
|
|
eqns[p + nc * i] += eqns[p + nc * j];
|
||
|
|
} while (--np);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (0 !== eqns[i + nc * i]) for (j = i + 1; j < k; j++) {
|
||
|
|
var multiplier = eqns[i + nc * j] / eqns[i + nc * i];
|
||
|
|
np = kp;
|
||
|
|
do {
|
||
|
|
p = kp - np;
|
||
|
|
eqns[p + nc * j] = p <= i ? 0 : eqns[p + nc * j] - eqns[p + nc * i] * multiplier;
|
||
|
|
} while (--np);
|
||
|
|
}
|
||
|
|
} while (--n);
|
||
|
|
i = 2;
|
||
|
|
do {
|
||
|
|
j = i - 1;
|
||
|
|
do {
|
||
|
|
var multiplier = eqns[i + nc * j] / eqns[i + nc * i];
|
||
|
|
np = nc;
|
||
|
|
do {
|
||
|
|
p = nc - np;
|
||
|
|
eqns[p + nc * j] = eqns[p + nc * j] - eqns[p + nc * i] * multiplier;
|
||
|
|
} while (--np);
|
||
|
|
} while (j--);
|
||
|
|
} while (--i);
|
||
|
|
i = 2;
|
||
|
|
do {
|
||
|
|
var multiplier = 1 / eqns[i + nc * i];
|
||
|
|
np = nc;
|
||
|
|
do {
|
||
|
|
p = nc - np;
|
||
|
|
eqns[p + nc * i] = eqns[p + nc * i] * multiplier;
|
||
|
|
} while (--np);
|
||
|
|
} while (i--);
|
||
|
|
i = 2;
|
||
|
|
do {
|
||
|
|
j = 2;
|
||
|
|
do {
|
||
|
|
p = eqns[nr + j + nc * i];
|
||
|
|
if (isNaN(p) || Infinity === p) throw "Could not reverse! A=[" + this.toString() + "]";
|
||
|
|
target.e(i, j, p);
|
||
|
|
} while (j--);
|
||
|
|
} while (i--);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Mat3.prototype.setRotationFromQuaternion = function(q) {
|
||
|
|
var x = q.x, y = q.y, z = q.z, w = q.w, x2 = x + x, y2 = y + y, z2 = z + z, xx = x * x2, xy = x * y2, xz = x * z2, yy = y * y2, yz = y * z2, zz = z * z2, wx = w * x2, wy = w * y2, wz = w * z2, e = this.elements;
|
||
|
|
e[0] = 1 - (yy + zz);
|
||
|
|
e[1] = xy - wz;
|
||
|
|
e[2] = xz + wy;
|
||
|
|
e[3] = xy + wz;
|
||
|
|
e[4] = 1 - (xx + zz);
|
||
|
|
e[5] = yz - wx;
|
||
|
|
e[6] = xz - wy;
|
||
|
|
e[7] = yz + wx;
|
||
|
|
e[8] = 1 - (xx + yy);
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Mat3.prototype.transpose = function(target) {
|
||
|
|
target = target || new Mat3();
|
||
|
|
var Mt = target.elements, M = this.elements;
|
||
|
|
for (var i = 0; 3 !== i; i++) for (var j = 0; 3 !== j; j++) Mt[3 * i + j] = M[3 * j + i];
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"./Vec3": 32
|
||
|
|
} ],
|
||
|
|
30: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Quaternion;
|
||
|
|
var Vec3 = _dereq_("./Vec3");
|
||
|
|
var CMath = _dereq_("./CMath");
|
||
|
|
function Quaternion(x, y, z, w) {
|
||
|
|
this.x = void 0 !== x ? x : 0;
|
||
|
|
this.y = void 0 !== y ? y : 0;
|
||
|
|
this.z = void 0 !== z ? z : 0;
|
||
|
|
this.w = void 0 !== w ? w : 1;
|
||
|
|
}
|
||
|
|
Quaternion.prototype.set = function(x, y, z, w) {
|
||
|
|
this.x = x;
|
||
|
|
this.y = y;
|
||
|
|
this.z = z;
|
||
|
|
this.w = w;
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.toString = function() {
|
||
|
|
return this.x + "," + this.y + "," + this.z + "," + this.w;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.toArray = function() {
|
||
|
|
return [ this.x, this.y, this.z, this.w ];
|
||
|
|
};
|
||
|
|
Quaternion.prototype.setFromAxisAngle = function(axis, angle) {
|
||
|
|
var s = CMath.sin(.5 * angle);
|
||
|
|
this.x = axis.x * s;
|
||
|
|
this.y = axis.y * s;
|
||
|
|
this.z = axis.z * s;
|
||
|
|
this.w = CMath.cos(.5 * angle);
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.toAxisAngle = function(targetAxis) {
|
||
|
|
targetAxis = targetAxis || new Vec3();
|
||
|
|
this.normalize();
|
||
|
|
var angle = 2 * Math.acos(this.w);
|
||
|
|
var s = Math.sqrt(1 - this.w * this.w);
|
||
|
|
if (s < .001) {
|
||
|
|
targetAxis.x = this.x;
|
||
|
|
targetAxis.y = this.y;
|
||
|
|
targetAxis.z = this.z;
|
||
|
|
} else {
|
||
|
|
targetAxis.x = this.x / s;
|
||
|
|
targetAxis.y = this.y / s;
|
||
|
|
targetAxis.z = this.z / s;
|
||
|
|
}
|
||
|
|
return [ targetAxis, angle ];
|
||
|
|
};
|
||
|
|
var sfv_t1 = new Vec3(), sfv_t2 = new Vec3();
|
||
|
|
Quaternion.prototype.setFromVectors = function(u, v) {
|
||
|
|
if (u.isAntiparallelTo(v)) {
|
||
|
|
var t1 = sfv_t1;
|
||
|
|
var t2 = sfv_t2;
|
||
|
|
u.tangents(t1, t2);
|
||
|
|
this.setFromAxisAngle(t1, Math.PI);
|
||
|
|
} else {
|
||
|
|
var a = u.cross(v);
|
||
|
|
this.x = a.x;
|
||
|
|
this.y = a.y;
|
||
|
|
this.z = a.z;
|
||
|
|
this.w = Math.sqrt(Math.pow(u.norm(), 2) * Math.pow(v.norm(), 2)) + u.dot(v);
|
||
|
|
this.normalize();
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
var Quaternion_mult_va = new Vec3();
|
||
|
|
var Quaternion_mult_vb = new Vec3();
|
||
|
|
var Quaternion_mult_vaxvb = new Vec3();
|
||
|
|
Quaternion.prototype.mult = function(q, target) {
|
||
|
|
target = target || new Quaternion();
|
||
|
|
var ax = this.x, ay = this.y, az = this.z, aw = this.w, bx = q.x, by = q.y, bz = q.z, bw = q.w;
|
||
|
|
target.x = ax * bw + aw * bx + ay * bz - az * by;
|
||
|
|
target.y = ay * bw + aw * by + az * bx - ax * bz;
|
||
|
|
target.z = az * bw + aw * bz + ax * by - ay * bx;
|
||
|
|
target.w = aw * bw - ax * bx - ay * by - az * bz;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.inverse = function(target) {
|
||
|
|
var x = this.x, y = this.y, z = this.z, w = this.w;
|
||
|
|
target = target || new Quaternion();
|
||
|
|
this.conjugate(target);
|
||
|
|
var inorm2 = 1 / (x * x + y * y + z * z + w * w);
|
||
|
|
target.x *= inorm2;
|
||
|
|
target.y *= inorm2;
|
||
|
|
target.z *= inorm2;
|
||
|
|
target.w *= inorm2;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.conjugate = function(target) {
|
||
|
|
target = target || new Quaternion();
|
||
|
|
target.x = -this.x;
|
||
|
|
target.y = -this.y;
|
||
|
|
target.z = -this.z;
|
||
|
|
target.w = this.w;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.normalize = function() {
|
||
|
|
var l = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
|
||
|
|
if (0 === l) {
|
||
|
|
this.x = 0;
|
||
|
|
this.y = 0;
|
||
|
|
this.z = 0;
|
||
|
|
this.w = 0;
|
||
|
|
} else {
|
||
|
|
l = 1 / l;
|
||
|
|
this.x *= l;
|
||
|
|
this.y *= l;
|
||
|
|
this.z *= l;
|
||
|
|
this.w *= l;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.normalizeFast = function() {
|
||
|
|
var f = (3 - (this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w)) / 2;
|
||
|
|
if (0 === f) {
|
||
|
|
this.x = 0;
|
||
|
|
this.y = 0;
|
||
|
|
this.z = 0;
|
||
|
|
this.w = 0;
|
||
|
|
} else {
|
||
|
|
this.x *= f;
|
||
|
|
this.y *= f;
|
||
|
|
this.z *= f;
|
||
|
|
this.w *= f;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.vmult = function(v, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var x = v.x, y = v.y, z = v.z;
|
||
|
|
var qx = this.x, qy = this.y, qz = this.z, qw = this.w;
|
||
|
|
var ix = qw * x + qy * z - qz * y, iy = qw * y + qz * x - qx * z, iz = qw * z + qx * y - qy * x, iw = -qx * x - qy * y - qz * z;
|
||
|
|
target.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
|
||
|
|
target.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
|
||
|
|
target.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.copy = function(source) {
|
||
|
|
this.x = source.x;
|
||
|
|
this.y = source.y;
|
||
|
|
this.z = source.z;
|
||
|
|
this.w = source.w;
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.toEuler = function(target, order) {
|
||
|
|
order = order || "YZX";
|
||
|
|
var heading, attitude, bank;
|
||
|
|
var x = this.x, y = this.y, z = this.z, w = this.w;
|
||
|
|
switch (order) {
|
||
|
|
case "YZX":
|
||
|
|
var test = x * y + z * w;
|
||
|
|
if (test > .499) {
|
||
|
|
heading = 2 * CMath.atan2(x, w);
|
||
|
|
attitude = Math.PI / 2;
|
||
|
|
bank = 0;
|
||
|
|
}
|
||
|
|
if (test < -.499) {
|
||
|
|
heading = -2 * CMath.atan2(x, w);
|
||
|
|
attitude = -Math.PI / 2;
|
||
|
|
bank = 0;
|
||
|
|
}
|
||
|
|
if (isNaN(heading)) {
|
||
|
|
var sqx = x * x;
|
||
|
|
var sqy = y * y;
|
||
|
|
var sqz = z * z;
|
||
|
|
heading = CMath.atan2(2 * y * w - 2 * x * z, 1 - 2 * sqy - 2 * sqz);
|
||
|
|
attitude = Math.asin(2 * test);
|
||
|
|
bank = CMath.atan2(2 * x * w - 2 * y * z, 1 - 2 * sqx - 2 * sqz);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
throw new Error("Euler order " + order + " not supported yet.");
|
||
|
|
}
|
||
|
|
target.y = heading;
|
||
|
|
target.z = attitude;
|
||
|
|
target.x = bank;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.setFromEuler = function(x, y, z, order) {
|
||
|
|
order = order || "XYZ";
|
||
|
|
var c1 = CMath.cos(x / 2);
|
||
|
|
var c2 = CMath.cos(y / 2);
|
||
|
|
var c3 = CMath.cos(z / 2);
|
||
|
|
var s1 = CMath.sin(x / 2);
|
||
|
|
var s2 = CMath.sin(y / 2);
|
||
|
|
var s3 = CMath.sin(z / 2);
|
||
|
|
if ("XYZ" === order) {
|
||
|
|
this.x = s1 * c2 * c3 + c1 * s2 * s3;
|
||
|
|
this.y = c1 * s2 * c3 - s1 * c2 * s3;
|
||
|
|
this.z = c1 * c2 * s3 + s1 * s2 * c3;
|
||
|
|
this.w = c1 * c2 * c3 - s1 * s2 * s3;
|
||
|
|
} else if ("YXZ" === order) {
|
||
|
|
this.x = s1 * c2 * c3 + c1 * s2 * s3;
|
||
|
|
this.y = c1 * s2 * c3 - s1 * c2 * s3;
|
||
|
|
this.z = c1 * c2 * s3 - s1 * s2 * c3;
|
||
|
|
this.w = c1 * c2 * c3 + s1 * s2 * s3;
|
||
|
|
} else if ("ZXY" === order) {
|
||
|
|
this.x = s1 * c2 * c3 - c1 * s2 * s3;
|
||
|
|
this.y = c1 * s2 * c3 + s1 * c2 * s3;
|
||
|
|
this.z = c1 * c2 * s3 + s1 * s2 * c3;
|
||
|
|
this.w = c1 * c2 * c3 - s1 * s2 * s3;
|
||
|
|
} else if ("ZYX" === order) {
|
||
|
|
this.x = s1 * c2 * c3 - c1 * s2 * s3;
|
||
|
|
this.y = c1 * s2 * c3 + s1 * c2 * s3;
|
||
|
|
this.z = c1 * c2 * s3 - s1 * s2 * c3;
|
||
|
|
this.w = c1 * c2 * c3 + s1 * s2 * s3;
|
||
|
|
} else if ("YZX" === order) {
|
||
|
|
this.x = s1 * c2 * c3 + c1 * s2 * s3;
|
||
|
|
this.y = c1 * s2 * c3 + s1 * c2 * s3;
|
||
|
|
this.z = c1 * c2 * s3 - s1 * s2 * c3;
|
||
|
|
this.w = c1 * c2 * c3 - s1 * s2 * s3;
|
||
|
|
} else if ("XZY" === order) {
|
||
|
|
this.x = s1 * c2 * c3 - c1 * s2 * s3;
|
||
|
|
this.y = c1 * s2 * c3 - s1 * c2 * s3;
|
||
|
|
this.z = c1 * c2 * s3 + s1 * s2 * c3;
|
||
|
|
this.w = c1 * c2 * c3 + s1 * s2 * s3;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.clone = function() {
|
||
|
|
return new Quaternion(this.x, this.y, this.z, this.w);
|
||
|
|
};
|
||
|
|
Quaternion.prototype.slerp = function(toQuat, t, target) {
|
||
|
|
target = target || new Quaternion();
|
||
|
|
var ax = this.x, ay = this.y, az = this.z, aw = this.w, bx = toQuat.x, by = toQuat.y, bz = toQuat.z, bw = toQuat.w;
|
||
|
|
var omega, cosom, sinom, scale0, scale1;
|
||
|
|
cosom = ax * bx + ay * by + az * bz + aw * bw;
|
||
|
|
if (cosom < 0) {
|
||
|
|
cosom = -cosom;
|
||
|
|
bx = -bx;
|
||
|
|
by = -by;
|
||
|
|
bz = -bz;
|
||
|
|
bw = -bw;
|
||
|
|
}
|
||
|
|
if (1 - cosom > 1e-6) {
|
||
|
|
omega = Math.acos(cosom);
|
||
|
|
sinom = CMath.sin(omega);
|
||
|
|
scale0 = CMath.sin((1 - t) * omega) / sinom;
|
||
|
|
scale1 = CMath.sin(t * omega) / sinom;
|
||
|
|
} else {
|
||
|
|
scale0 = 1 - t;
|
||
|
|
scale1 = t;
|
||
|
|
}
|
||
|
|
target.x = scale0 * ax + scale1 * bx;
|
||
|
|
target.y = scale0 * ay + scale1 * by;
|
||
|
|
target.z = scale0 * az + scale1 * bz;
|
||
|
|
target.w = scale0 * aw + scale1 * bw;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Quaternion.prototype.integrate = function(angularVelocity, dt, angularFactor, target) {
|
||
|
|
target = target || new Quaternion();
|
||
|
|
var ax = angularVelocity.x * angularFactor.x, ay = angularVelocity.y * angularFactor.y, az = angularVelocity.z * angularFactor.z, bx = this.x, by = this.y, bz = this.z, bw = this.w;
|
||
|
|
var half_dt = .5 * dt;
|
||
|
|
target.x += half_dt * (ax * bw + ay * bz - az * by);
|
||
|
|
target.y += half_dt * (ay * bw + az * bx - ax * bz);
|
||
|
|
target.z += half_dt * (az * bw + ax * by - ay * bx);
|
||
|
|
target.w += half_dt * (-ax * bx - ay * by - az * bz);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"./CMath": 27,
|
||
|
|
"./Vec3": 32
|
||
|
|
} ],
|
||
|
|
31: [ function(_dereq_, module, exports) {
|
||
|
|
var Vec3 = _dereq_("./Vec3");
|
||
|
|
var Quaternion = _dereq_("./Quaternion");
|
||
|
|
module.exports = Transform;
|
||
|
|
function Transform(options) {
|
||
|
|
options = options || {};
|
||
|
|
this.position = new Vec3();
|
||
|
|
options.position && this.position.copy(options.position);
|
||
|
|
this.quaternion = new Quaternion();
|
||
|
|
options.quaternion && this.quaternion.copy(options.quaternion);
|
||
|
|
}
|
||
|
|
var tmpQuat = new Quaternion();
|
||
|
|
Transform.pointToLocalFrame = function(position, quaternion, worldPoint, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
worldPoint.vsub(position, result);
|
||
|
|
quaternion.conjugate(tmpQuat);
|
||
|
|
tmpQuat.vmult(result, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Transform.prototype.pointToLocal = function(worldPoint, result) {
|
||
|
|
return Transform.pointToLocalFrame(this.position, this.quaternion, worldPoint, result);
|
||
|
|
};
|
||
|
|
Transform.pointToWorldFrame = function(position, quaternion, localPoint, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
quaternion.vmult(localPoint, result);
|
||
|
|
result.vadd(position, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Transform.prototype.pointToWorld = function(localPoint, result) {
|
||
|
|
return Transform.pointToWorldFrame(this.position, this.quaternion, localPoint, result);
|
||
|
|
};
|
||
|
|
Transform.prototype.vectorToWorldFrame = function(localVector, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
this.quaternion.vmult(localVector, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Transform.vectorToWorldFrame = function(quaternion, localVector, result) {
|
||
|
|
quaternion.vmult(localVector, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Transform.vectorToLocalFrame = function(position, quaternion, worldVector, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
quaternion.w *= -1;
|
||
|
|
quaternion.vmult(worldVector, result);
|
||
|
|
quaternion.w *= -1;
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"./Quaternion": 30,
|
||
|
|
"./Vec3": 32
|
||
|
|
} ],
|
||
|
|
32: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Vec3;
|
||
|
|
var Mat3 = _dereq_("./Mat3");
|
||
|
|
function Vec3(x, y, z) {
|
||
|
|
this.x = x || 0;
|
||
|
|
this.y = y || 0;
|
||
|
|
this.z = z || 0;
|
||
|
|
}
|
||
|
|
Vec3.ZERO = new Vec3(0, 0, 0);
|
||
|
|
Vec3.UNIT_X = new Vec3(1, 0, 0);
|
||
|
|
Vec3.UNIT_Y = new Vec3(0, 1, 0);
|
||
|
|
Vec3.UNIT_Z = new Vec3(0, 0, 1);
|
||
|
|
Vec3.prototype.cross = function(v, target) {
|
||
|
|
var vx = v.x, vy = v.y, vz = v.z, x = this.x, y = this.y, z = this.z;
|
||
|
|
target = target || new Vec3();
|
||
|
|
target.x = y * vz - z * vy;
|
||
|
|
target.y = z * vx - x * vz;
|
||
|
|
target.z = x * vy - y * vx;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Vec3.prototype.set = function(x, y, z) {
|
||
|
|
this.x = x;
|
||
|
|
this.y = y;
|
||
|
|
this.z = z;
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Vec3.prototype.setZero = function() {
|
||
|
|
this.x = this.y = this.z = 0;
|
||
|
|
};
|
||
|
|
Vec3.prototype.vadd = function(v, target) {
|
||
|
|
if (!target) return new Vec3(this.x + v.x, this.y + v.y, this.z + v.z);
|
||
|
|
target.x = v.x + this.x;
|
||
|
|
target.y = v.y + this.y;
|
||
|
|
target.z = v.z + this.z;
|
||
|
|
};
|
||
|
|
Vec3.prototype.vsub = function(v, target) {
|
||
|
|
if (!target) return new Vec3(this.x - v.x, this.y - v.y, this.z - v.z);
|
||
|
|
target.x = this.x - v.x;
|
||
|
|
target.y = this.y - v.y;
|
||
|
|
target.z = this.z - v.z;
|
||
|
|
};
|
||
|
|
Vec3.prototype.crossmat = function() {
|
||
|
|
return new Mat3([ 0, -this.z, this.y, this.z, 0, -this.x, -this.y, this.x, 0 ]);
|
||
|
|
};
|
||
|
|
Vec3.prototype.normalize = function() {
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
var n = Math.sqrt(x * x + y * y + z * z);
|
||
|
|
if (n > 0) {
|
||
|
|
var invN = 1 / n;
|
||
|
|
this.x *= invN;
|
||
|
|
this.y *= invN;
|
||
|
|
this.z *= invN;
|
||
|
|
} else {
|
||
|
|
this.x = 0;
|
||
|
|
this.y = 0;
|
||
|
|
this.z = 0;
|
||
|
|
}
|
||
|
|
return n;
|
||
|
|
};
|
||
|
|
Vec3.prototype.unit = function(target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
var ninv = Math.sqrt(x * x + y * y + z * z);
|
||
|
|
if (ninv > 0) {
|
||
|
|
ninv = 1 / ninv;
|
||
|
|
target.x = x * ninv;
|
||
|
|
target.y = y * ninv;
|
||
|
|
target.z = z * ninv;
|
||
|
|
} else {
|
||
|
|
target.x = 1;
|
||
|
|
target.y = 0;
|
||
|
|
target.z = 0;
|
||
|
|
}
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Vec3.prototype.norm = function() {
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
return Math.sqrt(x * x + y * y + z * z);
|
||
|
|
};
|
||
|
|
Vec3.prototype.length = Vec3.prototype.norm;
|
||
|
|
Vec3.prototype.norm2 = function() {
|
||
|
|
return this.dot(this);
|
||
|
|
};
|
||
|
|
Vec3.prototype.lengthSquared = Vec3.prototype.norm2;
|
||
|
|
Vec3.prototype.distanceTo = function(p) {
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
var px = p.x, py = p.y, pz = p.z;
|
||
|
|
return Math.sqrt((px - x) * (px - x) + (py - y) * (py - y) + (pz - z) * (pz - z));
|
||
|
|
};
|
||
|
|
Vec3.prototype.distanceSquared = function(p) {
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
var px = p.x, py = p.y, pz = p.z;
|
||
|
|
return (px - x) * (px - x) + (py - y) * (py - y) + (pz - z) * (pz - z);
|
||
|
|
};
|
||
|
|
Vec3.prototype.mult = function(scalar, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
target.x = scalar * x;
|
||
|
|
target.y = scalar * y;
|
||
|
|
target.z = scalar * z;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Vec3.prototype.vmul = function(vector, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
target.x = vector.x * this.x;
|
||
|
|
target.y = vector.y * this.y;
|
||
|
|
target.z = vector.z * this.z;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Vec3.prototype.scale = Vec3.prototype.mult;
|
||
|
|
Vec3.prototype.addScaledVector = function(scalar, vector, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
target.x = this.x + scalar * vector.x;
|
||
|
|
target.y = this.y + scalar * vector.y;
|
||
|
|
target.z = this.z + scalar * vector.z;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Vec3.prototype.dot = function(v) {
|
||
|
|
return this.x * v.x + this.y * v.y + this.z * v.z;
|
||
|
|
};
|
||
|
|
Vec3.prototype.isZero = function() {
|
||
|
|
return 0 === this.x && 0 === this.y && 0 === this.z;
|
||
|
|
};
|
||
|
|
Vec3.prototype.negate = function(target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
target.x = -this.x;
|
||
|
|
target.y = -this.y;
|
||
|
|
target.z = -this.z;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
var Vec3_tangents_n = new Vec3();
|
||
|
|
var Vec3_tangents_randVec = new Vec3();
|
||
|
|
Vec3.prototype.tangents = function(t1, t2) {
|
||
|
|
var norm = this.norm();
|
||
|
|
if (norm > 0) {
|
||
|
|
var n = Vec3_tangents_n;
|
||
|
|
var inorm = 1 / norm;
|
||
|
|
n.set(this.x * inorm, this.y * inorm, this.z * inorm);
|
||
|
|
var randVec = Vec3_tangents_randVec;
|
||
|
|
if (Math.abs(n.x) < .9) {
|
||
|
|
randVec.set(1, 0, 0);
|
||
|
|
n.cross(randVec, t1);
|
||
|
|
} else {
|
||
|
|
randVec.set(0, 1, 0);
|
||
|
|
n.cross(randVec, t1);
|
||
|
|
}
|
||
|
|
n.cross(t1, t2);
|
||
|
|
} else {
|
||
|
|
t1.set(1, 0, 0);
|
||
|
|
t2.set(0, 1, 0);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Vec3.prototype.toString = function() {
|
||
|
|
return this.x + "," + this.y + "," + this.z;
|
||
|
|
};
|
||
|
|
Vec3.prototype.toArray = function() {
|
||
|
|
return [ this.x, this.y, this.z ];
|
||
|
|
};
|
||
|
|
Vec3.prototype.copy = function(source) {
|
||
|
|
this.x = source.x;
|
||
|
|
this.y = source.y;
|
||
|
|
this.z = source.z;
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Vec3.prototype.lerp = function(v, t, target) {
|
||
|
|
var x = this.x, y = this.y, z = this.z;
|
||
|
|
target.x = x + (v.x - x) * t;
|
||
|
|
target.y = y + (v.y - y) * t;
|
||
|
|
target.z = z + (v.z - z) * t;
|
||
|
|
};
|
||
|
|
Vec3.prototype.almostEquals = function(v, precision) {
|
||
|
|
void 0 === precision && (precision = 1e-6);
|
||
|
|
if (Math.abs(this.x - v.x) > precision || Math.abs(this.y - v.y) > precision || Math.abs(this.z - v.z) > precision) return false;
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
Vec3.prototype.almostZero = function(precision) {
|
||
|
|
void 0 === precision && (precision = 1e-6);
|
||
|
|
if (Math.abs(this.x) > precision || Math.abs(this.y) > precision || Math.abs(this.z) > precision) return false;
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
var antip_neg = new Vec3();
|
||
|
|
Vec3.prototype.isAntiparallelTo = function(v, precision) {
|
||
|
|
this.negate(antip_neg);
|
||
|
|
return antip_neg.almostEquals(v, precision);
|
||
|
|
};
|
||
|
|
Vec3.prototype.clone = function() {
|
||
|
|
return new Vec3(this.x, this.y, this.z);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"./Mat3": 29
|
||
|
|
} ],
|
||
|
|
33: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Body;
|
||
|
|
var EventTarget = _dereq_("../utils/EventTarget");
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Mat3 = _dereq_("../math/Mat3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Material = _dereq_("../material/Material");
|
||
|
|
var AABB = _dereq_("../collision/AABB");
|
||
|
|
var Box = _dereq_("../shapes/Box");
|
||
|
|
var World = _dereq_("../world/World");
|
||
|
|
function Body(options) {
|
||
|
|
options = options || {};
|
||
|
|
EventTarget.apply(this);
|
||
|
|
this.id = Body.idCounter++;
|
||
|
|
this.world = null;
|
||
|
|
this.preStep = null;
|
||
|
|
this.postStep = null;
|
||
|
|
this.vlambda = new Vec3();
|
||
|
|
this.collisionFilterGroup = "number" === typeof options.collisionFilterGroup ? options.collisionFilterGroup : 1;
|
||
|
|
this.collisionFilterMask = "number" === typeof options.collisionFilterMask ? options.collisionFilterMask : -1;
|
||
|
|
this.collisionResponse = true;
|
||
|
|
this.position = new Vec3();
|
||
|
|
this.previousPosition = new Vec3();
|
||
|
|
this.interpolatedPosition = new Vec3();
|
||
|
|
this.initPosition = new Vec3();
|
||
|
|
if (options.position) {
|
||
|
|
this.position.copy(options.position);
|
||
|
|
this.previousPosition.copy(options.position);
|
||
|
|
this.interpolatedPosition.copy(options.position);
|
||
|
|
this.initPosition.copy(options.position);
|
||
|
|
}
|
||
|
|
this.velocity = new Vec3();
|
||
|
|
options.velocity && this.velocity.copy(options.velocity);
|
||
|
|
this.initVelocity = new Vec3();
|
||
|
|
this.force = new Vec3();
|
||
|
|
var mass = "number" === typeof options.mass ? options.mass : 0;
|
||
|
|
this.mass = mass;
|
||
|
|
this.invMass = mass > 0 ? 1 / mass : 0;
|
||
|
|
this.material = options.material || null;
|
||
|
|
this.linearDamping = "number" === typeof options.linearDamping ? options.linearDamping : .01;
|
||
|
|
this.type = mass <= 0 ? Body.STATIC : Body.DYNAMIC;
|
||
|
|
typeof options.type === typeof Body.STATIC && (this.type = options.type);
|
||
|
|
this.allowSleep = "undefined" === typeof options.allowSleep || options.allowSleep;
|
||
|
|
this.sleepState = 0;
|
||
|
|
this.sleepSpeedLimit = "undefined" !== typeof options.sleepSpeedLimit ? options.sleepSpeedLimit : .1;
|
||
|
|
this.sleepTimeLimit = "undefined" !== typeof options.sleepTimeLimit ? options.sleepTimeLimit : 1;
|
||
|
|
this.timeLastSleepy = 0;
|
||
|
|
this._wakeUpAfterNarrowphase = false;
|
||
|
|
this.torque = new Vec3();
|
||
|
|
this.quaternion = new Quaternion();
|
||
|
|
this.initQuaternion = new Quaternion();
|
||
|
|
this.previousQuaternion = new Quaternion();
|
||
|
|
this.interpolatedQuaternion = new Quaternion();
|
||
|
|
if (options.quaternion) {
|
||
|
|
this.quaternion.copy(options.quaternion);
|
||
|
|
this.initQuaternion.copy(options.quaternion);
|
||
|
|
this.previousQuaternion.copy(options.quaternion);
|
||
|
|
this.interpolatedQuaternion.copy(options.quaternion);
|
||
|
|
}
|
||
|
|
this.angularVelocity = new Vec3();
|
||
|
|
options.angularVelocity && this.angularVelocity.copy(options.angularVelocity);
|
||
|
|
this.initAngularVelocity = new Vec3();
|
||
|
|
this.shapes = [];
|
||
|
|
this.shapeOffsets = [];
|
||
|
|
this.shapeOrientations = [];
|
||
|
|
this.inertia = new Vec3();
|
||
|
|
this.invInertia = new Vec3();
|
||
|
|
this.invInertiaWorld = new Mat3();
|
||
|
|
this.invMassSolve = 0;
|
||
|
|
this.invInertiaSolve = new Vec3();
|
||
|
|
this.invInertiaWorldSolve = new Mat3();
|
||
|
|
this.fixedRotation = "undefined" !== typeof options.fixedRotation && options.fixedRotation;
|
||
|
|
this.useGravity = true;
|
||
|
|
this.angularDamping = "undefined" !== typeof options.angularDamping ? options.angularDamping : .01;
|
||
|
|
this.linearFactor = new Vec3(1, 1, 1);
|
||
|
|
options.linearFactor && this.linearFactor.copy(options.linearFactor);
|
||
|
|
this.angularFactor = new Vec3(1, 1, 1);
|
||
|
|
options.angularFactor && this.angularFactor.copy(options.angularFactor);
|
||
|
|
this.aabb = new AABB();
|
||
|
|
this.aabbNeedsUpdate = true;
|
||
|
|
this.boundingRadius = 0;
|
||
|
|
this.wlambda = new Vec3();
|
||
|
|
options.shape && this.addShape(options.shape);
|
||
|
|
this.hasTrigger = true;
|
||
|
|
this.updateMassProperties();
|
||
|
|
}
|
||
|
|
Body.prototype = new EventTarget();
|
||
|
|
Body.prototype.constructor = Body;
|
||
|
|
Body.COLLIDE_EVENT_NAME = "collide";
|
||
|
|
Body.DYNAMIC = 1;
|
||
|
|
Body.STATIC = 2;
|
||
|
|
Body.KINEMATIC = 4;
|
||
|
|
Body.AWAKE = 0;
|
||
|
|
Body.SLEEPY = 1;
|
||
|
|
Body.SLEEPING = 2;
|
||
|
|
Body.idCounter = 0;
|
||
|
|
Body.wakeupEvent = {
|
||
|
|
type: "wakeup"
|
||
|
|
};
|
||
|
|
Body.prototype.wakeUp = function() {
|
||
|
|
World.SLEEPING = false;
|
||
|
|
var s = this.sleepState;
|
||
|
|
this.sleepState = 0;
|
||
|
|
this._wakeUpAfterNarrowphase = false;
|
||
|
|
s === Body.SLEEPING && this.dispatchEvent(Body.wakeupEvent);
|
||
|
|
};
|
||
|
|
Body.prototype.sleep = function() {
|
||
|
|
this.sleepState = Body.SLEEPING;
|
||
|
|
this.velocity.set(0, 0, 0);
|
||
|
|
this.angularVelocity.set(0, 0, 0);
|
||
|
|
this._wakeUpAfterNarrowphase = false;
|
||
|
|
};
|
||
|
|
Body.sleepyEvent = {
|
||
|
|
type: "sleepy"
|
||
|
|
};
|
||
|
|
Body.sleepEvent = {
|
||
|
|
type: "sleep"
|
||
|
|
};
|
||
|
|
Body.prototype.sleepTick = function(time) {
|
||
|
|
if (this.allowSleep) {
|
||
|
|
var sleepState = this.sleepState;
|
||
|
|
var speedSquared = this.velocity.norm2() + this.angularVelocity.norm2();
|
||
|
|
var speedLimitSquared = Math.pow(this.sleepSpeedLimit, 2);
|
||
|
|
if (sleepState === Body.AWAKE && speedSquared < speedLimitSquared) {
|
||
|
|
this.sleepState = Body.SLEEPY;
|
||
|
|
this.timeLastSleepy = time;
|
||
|
|
this.dispatchEvent(Body.sleepyEvent);
|
||
|
|
} else if (sleepState === Body.SLEEPY && speedSquared > speedLimitSquared) this.wakeUp(); else if (sleepState === Body.SLEEPY && time - this.timeLastSleepy > this.sleepTimeLimit) {
|
||
|
|
this.sleep();
|
||
|
|
this.dispatchEvent(Body.sleepEvent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Body.prototype.updateSolveMassProperties = function() {
|
||
|
|
if (this.sleepState === Body.SLEEPING || this.type === Body.KINEMATIC) {
|
||
|
|
this.invMassSolve = 0;
|
||
|
|
this.invInertiaSolve.setZero();
|
||
|
|
this.invInertiaWorldSolve.setZero();
|
||
|
|
} else {
|
||
|
|
this.invMassSolve = this.invMass;
|
||
|
|
this.invInertiaSolve.copy(this.invInertia);
|
||
|
|
this.invInertiaWorldSolve.copy(this.invInertiaWorld);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Body.prototype.pointToLocalFrame = function(worldPoint, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
worldPoint.vsub(this.position, result);
|
||
|
|
this.quaternion.conjugate().vmult(result, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Body.prototype.vectorToLocalFrame = function(worldVector, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
this.quaternion.conjugate().vmult(worldVector, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Body.prototype.pointToWorldFrame = function(localPoint, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
this.quaternion.vmult(localPoint, result);
|
||
|
|
result.vadd(this.position, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
Body.prototype.vectorToWorldFrame = function(localVector, result) {
|
||
|
|
var result = result || new Vec3();
|
||
|
|
this.quaternion.vmult(localVector, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var tmpVec = new Vec3();
|
||
|
|
var tmpQuat = new Quaternion();
|
||
|
|
Body.prototype.addShape = function(shape, _offset, _orientation) {
|
||
|
|
var offset = new Vec3();
|
||
|
|
var orientation = new Quaternion();
|
||
|
|
_offset && offset.copy(_offset);
|
||
|
|
_orientation && orientation.copy(_orientation);
|
||
|
|
this.shapes.push(shape);
|
||
|
|
this.shapeOffsets.push(offset);
|
||
|
|
this.shapeOrientations.push(orientation);
|
||
|
|
this.aabbNeedsUpdate = true;
|
||
|
|
this.updateMassProperties();
|
||
|
|
this.updateBoundingRadius();
|
||
|
|
this.updateHasTrigger();
|
||
|
|
World.idToShapeMap[shape.id] = shape;
|
||
|
|
shape.body = this;
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Body.prototype.removeShape = function(shape) {
|
||
|
|
var idx = this.shapes.indexOf(shape);
|
||
|
|
if (-1 === idx) return;
|
||
|
|
this.shapes.splice(idx, 1);
|
||
|
|
this.shapeOffsets.splice(idx, 1);
|
||
|
|
this.shapeOrientations.splice(idx, 1);
|
||
|
|
this.aabbNeedsUpdate = true;
|
||
|
|
this.updateMassProperties();
|
||
|
|
this.updateBoundingRadius();
|
||
|
|
this.updateHasTrigger();
|
||
|
|
};
|
||
|
|
Body.prototype.updateBoundingRadius = function() {
|
||
|
|
var shapes = this.shapes, shapeOffsets = this.shapeOffsets, N = shapes.length, radius = 0;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var shape = shapes[i];
|
||
|
|
shape.updateBoundingSphereRadius();
|
||
|
|
var offset = shapeOffsets[i].norm(), r = shape.boundingSphereRadius;
|
||
|
|
offset + r > radius && (radius = offset + r);
|
||
|
|
}
|
||
|
|
this.boundingRadius = radius;
|
||
|
|
};
|
||
|
|
var computeAABB_shapeAABB = new AABB();
|
||
|
|
Body.prototype.computeAABB = function() {
|
||
|
|
var shapes = this.shapes, shapeOffsets = this.shapeOffsets, shapeOrientations = this.shapeOrientations, N = shapes.length, offset = tmpVec, orientation = tmpQuat, bodyQuat = this.quaternion, aabb = this.aabb, shapeAABB = computeAABB_shapeAABB;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var shape = shapes[i];
|
||
|
|
bodyQuat.vmult(shapeOffsets[i], offset);
|
||
|
|
offset.vadd(this.position, offset);
|
||
|
|
shapeOrientations[i].mult(bodyQuat, orientation);
|
||
|
|
shape.calculateWorldAABB(offset, orientation, shapeAABB.lowerBound, shapeAABB.upperBound);
|
||
|
|
0 === i ? aabb.copy(shapeAABB) : aabb.extend(shapeAABB);
|
||
|
|
}
|
||
|
|
this.aabbNeedsUpdate = false;
|
||
|
|
};
|
||
|
|
var uiw_m1 = new Mat3(), uiw_m2 = new Mat3(), uiw_m3 = new Mat3();
|
||
|
|
Body.prototype.updateInertiaWorld = function(force) {
|
||
|
|
var I = this.invInertia;
|
||
|
|
if (I.x !== I.y || I.y !== I.z || force) {
|
||
|
|
var m1 = uiw_m1, m2 = uiw_m2, m3 = uiw_m3;
|
||
|
|
m1.setRotationFromQuaternion(this.quaternion);
|
||
|
|
m1.transpose(m2);
|
||
|
|
m1.scale(I, m1);
|
||
|
|
m1.mmult(m2, this.invInertiaWorld);
|
||
|
|
} else ;
|
||
|
|
};
|
||
|
|
var Body_applyForce_r = new Vec3();
|
||
|
|
var Body_applyForce_rotForce = new Vec3();
|
||
|
|
Body.prototype.applyForce = function(force, relativePoint) {
|
||
|
|
if (this.type !== Body.DYNAMIC) return;
|
||
|
|
var rotForce = Body_applyForce_rotForce;
|
||
|
|
relativePoint.cross(force, rotForce);
|
||
|
|
this.force.vadd(force, this.force);
|
||
|
|
this.torque.vadd(rotForce, this.torque);
|
||
|
|
};
|
||
|
|
var Body_applyLocalForce_worldForce = new Vec3();
|
||
|
|
var Body_applyLocalForce_relativePointWorld = new Vec3();
|
||
|
|
Body.prototype.applyLocalForce = function(localForce, localPoint) {
|
||
|
|
if (this.type !== Body.DYNAMIC) return;
|
||
|
|
var worldForce = Body_applyLocalForce_worldForce;
|
||
|
|
var relativePointWorld = Body_applyLocalForce_relativePointWorld;
|
||
|
|
this.vectorToWorldFrame(localForce, worldForce);
|
||
|
|
this.vectorToWorldFrame(localPoint, relativePointWorld);
|
||
|
|
this.applyForce(worldForce, relativePointWorld);
|
||
|
|
};
|
||
|
|
var Body_applyImpulse_r = new Vec3();
|
||
|
|
var Body_applyImpulse_velo = new Vec3();
|
||
|
|
var Body_applyImpulse_rotVelo = new Vec3();
|
||
|
|
Body.prototype.applyImpulse = function(impulse, relativePoint) {
|
||
|
|
if (this.type !== Body.DYNAMIC) return;
|
||
|
|
var r = relativePoint;
|
||
|
|
var velo = Body_applyImpulse_velo;
|
||
|
|
velo.copy(impulse);
|
||
|
|
velo.mult(this.invMass, velo);
|
||
|
|
this.velocity.vadd(velo, this.velocity);
|
||
|
|
var rotVelo = Body_applyImpulse_rotVelo;
|
||
|
|
r.cross(impulse, rotVelo);
|
||
|
|
this.invInertiaWorld.vmult(rotVelo, rotVelo);
|
||
|
|
this.angularVelocity.vadd(rotVelo, this.angularVelocity);
|
||
|
|
};
|
||
|
|
var Body_applyLocalImpulse_worldImpulse = new Vec3();
|
||
|
|
var Body_applyLocalImpulse_relativePoint = new Vec3();
|
||
|
|
Body.prototype.applyLocalImpulse = function(localImpulse, localPoint) {
|
||
|
|
if (this.type !== Body.DYNAMIC) return;
|
||
|
|
var worldImpulse = Body_applyLocalImpulse_worldImpulse;
|
||
|
|
var relativePointWorld = Body_applyLocalImpulse_relativePoint;
|
||
|
|
this.vectorToWorldFrame(localImpulse, worldImpulse);
|
||
|
|
this.vectorToWorldFrame(localPoint, relativePointWorld);
|
||
|
|
this.applyImpulse(worldImpulse, relativePointWorld);
|
||
|
|
};
|
||
|
|
var Body_updateMassProperties_halfExtents = new Vec3();
|
||
|
|
Body.prototype.updateMassProperties = function() {
|
||
|
|
var halfExtents = Body_updateMassProperties_halfExtents;
|
||
|
|
this.invMass = this.mass > 0 ? 1 / this.mass : 0;
|
||
|
|
var I = this.inertia;
|
||
|
|
var fixed = this.fixedRotation;
|
||
|
|
this.computeAABB();
|
||
|
|
halfExtents.set((this.aabb.upperBound.x - this.aabb.lowerBound.x) / 2, (this.aabb.upperBound.y - this.aabb.lowerBound.y) / 2, (this.aabb.upperBound.z - this.aabb.lowerBound.z) / 2);
|
||
|
|
Box.calculateInertia(halfExtents, this.mass, I);
|
||
|
|
this.invInertia.set(I.x > 0 && !fixed ? 1 / I.x : 0, I.y > 0 && !fixed ? 1 / I.y : 0, I.z > 0 && !fixed ? 1 / I.z : 0);
|
||
|
|
this.updateInertiaWorld(true);
|
||
|
|
};
|
||
|
|
Body.prototype.getVelocityAtWorldPoint = function(worldPoint, result) {
|
||
|
|
var r = new Vec3();
|
||
|
|
worldPoint.vsub(this.position, r);
|
||
|
|
this.angularVelocity.cross(r, result);
|
||
|
|
this.velocity.vadd(result, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var torque = new Vec3();
|
||
|
|
var invI_tau_dt = new Vec3();
|
||
|
|
var w = new Quaternion();
|
||
|
|
var wq = new Quaternion();
|
||
|
|
Body.prototype.integrate = function(dt, quatNormalize, quatNormalizeFast) {
|
||
|
|
this.previousPosition.copy(this.position);
|
||
|
|
this.previousQuaternion.copy(this.quaternion);
|
||
|
|
if (!(this.type === Body.DYNAMIC || this.type === Body.KINEMATIC) || this.sleepState === Body.SLEEPING) return;
|
||
|
|
var velo = this.velocity, angularVelo = this.angularVelocity, pos = this.position, force = this.force, torque = this.torque, quat = this.quaternion, invMass = this.invMass, invInertia = this.invInertiaWorld, linearFactor = this.linearFactor;
|
||
|
|
var iMdt = invMass * dt;
|
||
|
|
velo.x += force.x * iMdt * linearFactor.x;
|
||
|
|
velo.y += force.y * iMdt * linearFactor.y;
|
||
|
|
velo.z += force.z * iMdt * linearFactor.z;
|
||
|
|
var e = invInertia.elements;
|
||
|
|
var angularFactor = this.angularFactor;
|
||
|
|
var tx = torque.x * angularFactor.x;
|
||
|
|
var ty = torque.y * angularFactor.y;
|
||
|
|
var tz = torque.z * angularFactor.z;
|
||
|
|
angularVelo.x += dt * (e[0] * tx + e[1] * ty + e[2] * tz);
|
||
|
|
angularVelo.y += dt * (e[3] * tx + e[4] * ty + e[5] * tz);
|
||
|
|
angularVelo.z += dt * (e[6] * tx + e[7] * ty + e[8] * tz);
|
||
|
|
pos.x += velo.x * dt;
|
||
|
|
pos.y += velo.y * dt;
|
||
|
|
pos.z += velo.z * dt;
|
||
|
|
quat.integrate(this.angularVelocity, dt, this.angularFactor, quat);
|
||
|
|
quatNormalize && (quatNormalizeFast ? quat.normalizeFast() : quat.normalize());
|
||
|
|
this.aabbNeedsUpdate = true;
|
||
|
|
this.updateInertiaWorld();
|
||
|
|
};
|
||
|
|
Body.prototype.isSleeping = function() {
|
||
|
|
return this.sleepState === Body.SLEEPING;
|
||
|
|
};
|
||
|
|
Body.prototype.isSleepy = function() {
|
||
|
|
return this.sleepState === Body.SLEEPY;
|
||
|
|
};
|
||
|
|
Body.prototype.isAwake = function() {
|
||
|
|
return this.sleepState === Body.AWAKE;
|
||
|
|
};
|
||
|
|
Body.prototype.updateHasTrigger = function() {
|
||
|
|
for (var i = this.shapes.length; i--; ) {
|
||
|
|
this.hasTrigger = !this.shapes[i].collisionResponse;
|
||
|
|
if (this.hasTrigger) break;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/AABB": 3,
|
||
|
|
"../material/Material": 26,
|
||
|
|
"../math/Mat3": 29,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../shapes/Box": 39,
|
||
|
|
"../shapes/Shape": 45,
|
||
|
|
"../utils/EventTarget": 51,
|
||
|
|
"../world/World": 58
|
||
|
|
} ],
|
||
|
|
34: [ function(_dereq_, module, exports) {
|
||
|
|
var Body = _dereq_("./Body");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var RaycastResult = _dereq_("../collision/RaycastResult");
|
||
|
|
var Ray = _dereq_("../collision/Ray");
|
||
|
|
var WheelInfo = _dereq_("../objects/WheelInfo");
|
||
|
|
module.exports = RaycastVehicle;
|
||
|
|
function RaycastVehicle(options) {
|
||
|
|
this.chassisBody = options.chassisBody;
|
||
|
|
this.wheelInfos = [];
|
||
|
|
this.sliding = false;
|
||
|
|
this.world = null;
|
||
|
|
this.indexRightAxis = "undefined" !== typeof options.indexRightAxis ? options.indexRightAxis : 1;
|
||
|
|
this.indexForwardAxis = "undefined" !== typeof options.indexForwardAxis ? options.indexForwardAxis : 0;
|
||
|
|
this.indexUpAxis = "undefined" !== typeof options.indexUpAxis ? options.indexUpAxis : 2;
|
||
|
|
}
|
||
|
|
var tmpVec1 = new Vec3();
|
||
|
|
var tmpVec2 = new Vec3();
|
||
|
|
var tmpVec3 = new Vec3();
|
||
|
|
var tmpVec4 = new Vec3();
|
||
|
|
var tmpVec5 = new Vec3();
|
||
|
|
var tmpVec6 = new Vec3();
|
||
|
|
var tmpRay = new Ray();
|
||
|
|
RaycastVehicle.prototype.addWheel = function(options) {
|
||
|
|
options = options || {};
|
||
|
|
var info = new WheelInfo(options);
|
||
|
|
var index = this.wheelInfos.length;
|
||
|
|
this.wheelInfos.push(info);
|
||
|
|
return index;
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.setSteeringValue = function(value, wheelIndex) {
|
||
|
|
var wheel = this.wheelInfos[wheelIndex];
|
||
|
|
wheel.steering = value;
|
||
|
|
};
|
||
|
|
var torque = new Vec3();
|
||
|
|
RaycastVehicle.prototype.applyEngineForce = function(value, wheelIndex) {
|
||
|
|
this.wheelInfos[wheelIndex].engineForce = value;
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.setBrake = function(brake, wheelIndex) {
|
||
|
|
this.wheelInfos[wheelIndex].brake = brake;
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.addToWorld = function(world) {
|
||
|
|
var constraints = this.constraints;
|
||
|
|
world.addBody(this.chassisBody);
|
||
|
|
var that = this;
|
||
|
|
this.preStepCallback = function() {
|
||
|
|
that.updateVehicle(world.dt);
|
||
|
|
};
|
||
|
|
world.addEventListener("preStep", this.preStepCallback);
|
||
|
|
this.world = world;
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.getVehicleAxisWorld = function(axisIndex, result) {
|
||
|
|
result.set(0 === axisIndex ? 1 : 0, 1 === axisIndex ? 1 : 0, 2 === axisIndex ? 1 : 0);
|
||
|
|
this.chassisBody.vectorToWorldFrame(result, result);
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.updateVehicle = function(timeStep) {
|
||
|
|
var wheelInfos = this.wheelInfos;
|
||
|
|
var numWheels = wheelInfos.length;
|
||
|
|
var chassisBody = this.chassisBody;
|
||
|
|
for (var i = 0; i < numWheels; i++) this.updateWheelTransform(i);
|
||
|
|
this.currentVehicleSpeedKmHour = 3.6 * chassisBody.velocity.norm();
|
||
|
|
var forwardWorld = new Vec3();
|
||
|
|
this.getVehicleAxisWorld(this.indexForwardAxis, forwardWorld);
|
||
|
|
forwardWorld.dot(chassisBody.velocity) < 0 && (this.currentVehicleSpeedKmHour *= -1);
|
||
|
|
for (var i = 0; i < numWheels; i++) this.castRay(wheelInfos[i]);
|
||
|
|
this.updateSuspension(timeStep);
|
||
|
|
var impulse = new Vec3();
|
||
|
|
var relpos = new Vec3();
|
||
|
|
for (var i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
var suspensionForce = wheel.suspensionForce;
|
||
|
|
suspensionForce > wheel.maxSuspensionForce && (suspensionForce = wheel.maxSuspensionForce);
|
||
|
|
wheel.raycastResult.hitNormalWorld.scale(suspensionForce * timeStep, impulse);
|
||
|
|
wheel.raycastResult.hitPointWorld.vsub(chassisBody.position, relpos);
|
||
|
|
chassisBody.applyImpulse(impulse, relpos);
|
||
|
|
}
|
||
|
|
this.updateFriction(timeStep);
|
||
|
|
var hitNormalWorldScaledWithProj = new Vec3();
|
||
|
|
var fwd = new Vec3();
|
||
|
|
var vel = new Vec3();
|
||
|
|
for (i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
chassisBody.getVelocityAtWorldPoint(wheel.chassisConnectionPointWorld, vel);
|
||
|
|
var m = 1;
|
||
|
|
switch (this.indexUpAxis) {
|
||
|
|
case 1:
|
||
|
|
m = -1;
|
||
|
|
}
|
||
|
|
if (wheel.isInContact) {
|
||
|
|
this.getVehicleAxisWorld(this.indexForwardAxis, fwd);
|
||
|
|
var proj = fwd.dot(wheel.raycastResult.hitNormalWorld);
|
||
|
|
wheel.raycastResult.hitNormalWorld.scale(proj, hitNormalWorldScaledWithProj);
|
||
|
|
fwd.vsub(hitNormalWorldScaledWithProj, fwd);
|
||
|
|
var proj2 = fwd.dot(vel);
|
||
|
|
wheel.deltaRotation = m * proj2 * timeStep / wheel.radius;
|
||
|
|
}
|
||
|
|
!wheel.sliding && wheel.isInContact || 0 === wheel.engineForce || !wheel.useCustomSlidingRotationalSpeed || (wheel.deltaRotation = (wheel.engineForce > 0 ? 1 : -1) * wheel.customSlidingRotationalSpeed * timeStep);
|
||
|
|
Math.abs(wheel.brake) > Math.abs(wheel.engineForce) && (wheel.deltaRotation = 0);
|
||
|
|
wheel.rotation += wheel.deltaRotation;
|
||
|
|
wheel.deltaRotation *= .99;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.updateSuspension = function(deltaTime) {
|
||
|
|
var chassisBody = this.chassisBody;
|
||
|
|
var chassisMass = chassisBody.mass;
|
||
|
|
var wheelInfos = this.wheelInfos;
|
||
|
|
var numWheels = wheelInfos.length;
|
||
|
|
for (var w_it = 0; w_it < numWheels; w_it++) {
|
||
|
|
var wheel = wheelInfos[w_it];
|
||
|
|
if (wheel.isInContact) {
|
||
|
|
var force;
|
||
|
|
var susp_length = wheel.suspensionRestLength;
|
||
|
|
var current_length = wheel.suspensionLength;
|
||
|
|
var length_diff = susp_length - current_length;
|
||
|
|
force = wheel.suspensionStiffness * length_diff * wheel.clippedInvContactDotSuspension;
|
||
|
|
var projected_rel_vel = wheel.suspensionRelativeVelocity;
|
||
|
|
var susp_damping;
|
||
|
|
susp_damping = projected_rel_vel < 0 ? wheel.dampingCompression : wheel.dampingRelaxation;
|
||
|
|
force -= susp_damping * projected_rel_vel;
|
||
|
|
wheel.suspensionForce = force * chassisMass;
|
||
|
|
wheel.suspensionForce < 0 && (wheel.suspensionForce = 0);
|
||
|
|
} else wheel.suspensionForce = 0;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.removeFromWorld = function(world) {
|
||
|
|
var constraints = this.constraints;
|
||
|
|
world.remove(this.chassisBody);
|
||
|
|
world.removeEventListener("preStep", this.preStepCallback);
|
||
|
|
this.world = null;
|
||
|
|
};
|
||
|
|
var castRay_rayvector = new Vec3();
|
||
|
|
var castRay_target = new Vec3();
|
||
|
|
RaycastVehicle.prototype.castRay = function(wheel) {
|
||
|
|
var rayvector = castRay_rayvector;
|
||
|
|
var target = castRay_target;
|
||
|
|
this.updateWheelTransformWorld(wheel);
|
||
|
|
var chassisBody = this.chassisBody;
|
||
|
|
var depth = -1;
|
||
|
|
var raylen = wheel.suspensionRestLength + wheel.radius;
|
||
|
|
wheel.directionWorld.scale(raylen, rayvector);
|
||
|
|
var source = wheel.chassisConnectionPointWorld;
|
||
|
|
source.vadd(rayvector, target);
|
||
|
|
var raycastResult = wheel.raycastResult;
|
||
|
|
var param = 0;
|
||
|
|
raycastResult.reset();
|
||
|
|
var oldState = chassisBody.collisionResponse;
|
||
|
|
chassisBody.collisionResponse = false;
|
||
|
|
this.world.rayTest(source, target, raycastResult);
|
||
|
|
chassisBody.collisionResponse = oldState;
|
||
|
|
var object = raycastResult.body;
|
||
|
|
wheel.raycastResult.groundObject = 0;
|
||
|
|
if (object) {
|
||
|
|
depth = raycastResult.distance;
|
||
|
|
wheel.raycastResult.hitNormalWorld = raycastResult.hitNormalWorld;
|
||
|
|
wheel.isInContact = true;
|
||
|
|
var hitDistance = raycastResult.distance;
|
||
|
|
wheel.suspensionLength = hitDistance - wheel.radius;
|
||
|
|
var minSuspensionLength = wheel.suspensionRestLength - wheel.maxSuspensionTravel;
|
||
|
|
var maxSuspensionLength = wheel.suspensionRestLength + wheel.maxSuspensionTravel;
|
||
|
|
wheel.suspensionLength < minSuspensionLength && (wheel.suspensionLength = minSuspensionLength);
|
||
|
|
if (wheel.suspensionLength > maxSuspensionLength) {
|
||
|
|
wheel.suspensionLength = maxSuspensionLength;
|
||
|
|
wheel.raycastResult.reset();
|
||
|
|
}
|
||
|
|
var denominator = wheel.raycastResult.hitNormalWorld.dot(wheel.directionWorld);
|
||
|
|
var chassis_velocity_at_contactPoint = new Vec3();
|
||
|
|
chassisBody.getVelocityAtWorldPoint(wheel.raycastResult.hitPointWorld, chassis_velocity_at_contactPoint);
|
||
|
|
var projVel = wheel.raycastResult.hitNormalWorld.dot(chassis_velocity_at_contactPoint);
|
||
|
|
if (denominator >= -.1) {
|
||
|
|
wheel.suspensionRelativeVelocity = 0;
|
||
|
|
wheel.clippedInvContactDotSuspension = 10;
|
||
|
|
} else {
|
||
|
|
var inv = -1 / denominator;
|
||
|
|
wheel.suspensionRelativeVelocity = projVel * inv;
|
||
|
|
wheel.clippedInvContactDotSuspension = inv;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
wheel.suspensionLength = wheel.suspensionRestLength + 0 * wheel.maxSuspensionTravel;
|
||
|
|
wheel.suspensionRelativeVelocity = 0;
|
||
|
|
wheel.directionWorld.scale(-1, wheel.raycastResult.hitNormalWorld);
|
||
|
|
wheel.clippedInvContactDotSuspension = 1;
|
||
|
|
}
|
||
|
|
return depth;
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.updateWheelTransformWorld = function(wheel) {
|
||
|
|
wheel.isInContact = false;
|
||
|
|
var chassisBody = this.chassisBody;
|
||
|
|
chassisBody.pointToWorldFrame(wheel.chassisConnectionPointLocal, wheel.chassisConnectionPointWorld);
|
||
|
|
chassisBody.vectorToWorldFrame(wheel.directionLocal, wheel.directionWorld);
|
||
|
|
chassisBody.vectorToWorldFrame(wheel.axleLocal, wheel.axleWorld);
|
||
|
|
};
|
||
|
|
RaycastVehicle.prototype.updateWheelTransform = function(wheelIndex) {
|
||
|
|
var up = tmpVec4;
|
||
|
|
var right = tmpVec5;
|
||
|
|
var fwd = tmpVec6;
|
||
|
|
var wheel = this.wheelInfos[wheelIndex];
|
||
|
|
this.updateWheelTransformWorld(wheel);
|
||
|
|
wheel.directionLocal.scale(-1, up);
|
||
|
|
right.copy(wheel.axleLocal);
|
||
|
|
up.cross(right, fwd);
|
||
|
|
fwd.normalize();
|
||
|
|
right.normalize();
|
||
|
|
var steering = wheel.steering;
|
||
|
|
var steeringOrn = new Quaternion();
|
||
|
|
steeringOrn.setFromAxisAngle(up, steering);
|
||
|
|
var rotatingOrn = new Quaternion();
|
||
|
|
rotatingOrn.setFromAxisAngle(right, wheel.rotation);
|
||
|
|
var q = wheel.worldTransform.quaternion;
|
||
|
|
this.chassisBody.quaternion.mult(steeringOrn, q);
|
||
|
|
q.mult(rotatingOrn, q);
|
||
|
|
q.normalize();
|
||
|
|
var p = wheel.worldTransform.position;
|
||
|
|
p.copy(wheel.directionWorld);
|
||
|
|
p.scale(wheel.suspensionLength, p);
|
||
|
|
p.vadd(wheel.chassisConnectionPointWorld, p);
|
||
|
|
};
|
||
|
|
var directions = [ new Vec3(1, 0, 0), new Vec3(0, 1, 0), new Vec3(0, 0, 1) ];
|
||
|
|
RaycastVehicle.prototype.getWheelTransformWorld = function(wheelIndex) {
|
||
|
|
return this.wheelInfos[wheelIndex].worldTransform;
|
||
|
|
};
|
||
|
|
var updateFriction_surfNormalWS_scaled_proj = new Vec3();
|
||
|
|
var updateFriction_axle = [];
|
||
|
|
var updateFriction_forwardWS = [];
|
||
|
|
var sideFrictionStiffness2 = 1;
|
||
|
|
RaycastVehicle.prototype.updateFriction = function(timeStep) {
|
||
|
|
var surfNormalWS_scaled_proj = updateFriction_surfNormalWS_scaled_proj;
|
||
|
|
var wheelInfos = this.wheelInfos;
|
||
|
|
var numWheels = wheelInfos.length;
|
||
|
|
var chassisBody = this.chassisBody;
|
||
|
|
var forwardWS = updateFriction_forwardWS;
|
||
|
|
var axle = updateFriction_axle;
|
||
|
|
var numWheelsOnGround = 0;
|
||
|
|
for (var i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
var groundObject = wheel.raycastResult.body;
|
||
|
|
groundObject && numWheelsOnGround++;
|
||
|
|
wheel.sideImpulse = 0;
|
||
|
|
wheel.forwardImpulse = 0;
|
||
|
|
forwardWS[i] || (forwardWS[i] = new Vec3());
|
||
|
|
axle[i] || (axle[i] = new Vec3());
|
||
|
|
}
|
||
|
|
for (var i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
var groundObject = wheel.raycastResult.body;
|
||
|
|
if (groundObject) {
|
||
|
|
var axlei = axle[i];
|
||
|
|
var wheelTrans = this.getWheelTransformWorld(i);
|
||
|
|
wheelTrans.vectorToWorldFrame(directions[this.indexRightAxis], axlei);
|
||
|
|
var surfNormalWS = wheel.raycastResult.hitNormalWorld;
|
||
|
|
var proj = axlei.dot(surfNormalWS);
|
||
|
|
surfNormalWS.scale(proj, surfNormalWS_scaled_proj);
|
||
|
|
axlei.vsub(surfNormalWS_scaled_proj, axlei);
|
||
|
|
axlei.normalize();
|
||
|
|
surfNormalWS.cross(axlei, forwardWS[i]);
|
||
|
|
forwardWS[i].normalize();
|
||
|
|
wheel.sideImpulse = resolveSingleBilateral(chassisBody, wheel.raycastResult.hitPointWorld, groundObject, wheel.raycastResult.hitPointWorld, axlei);
|
||
|
|
wheel.sideImpulse *= sideFrictionStiffness2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var sideFactor = 1;
|
||
|
|
var fwdFactor = .5;
|
||
|
|
this.sliding = false;
|
||
|
|
for (var i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
var groundObject = wheel.raycastResult.body;
|
||
|
|
var rollingFriction = 0;
|
||
|
|
wheel.slipInfo = 1;
|
||
|
|
if (groundObject) {
|
||
|
|
var defaultRollingFrictionImpulse = 0;
|
||
|
|
var maxImpulse = wheel.brake ? wheel.brake : defaultRollingFrictionImpulse;
|
||
|
|
rollingFriction = calcRollingFriction(chassisBody, groundObject, wheel.raycastResult.hitPointWorld, forwardWS[i], maxImpulse);
|
||
|
|
rollingFriction += wheel.engineForce * timeStep;
|
||
|
|
var factor = maxImpulse / rollingFriction;
|
||
|
|
wheel.slipInfo *= factor;
|
||
|
|
}
|
||
|
|
wheel.forwardImpulse = 0;
|
||
|
|
wheel.skidInfo = 1;
|
||
|
|
if (groundObject) {
|
||
|
|
wheel.skidInfo = 1;
|
||
|
|
var maximp = wheel.suspensionForce * timeStep * wheel.frictionSlip;
|
||
|
|
var maximpSide = maximp;
|
||
|
|
var maximpSquared = maximp * maximpSide;
|
||
|
|
wheel.forwardImpulse = rollingFriction;
|
||
|
|
var x = wheel.forwardImpulse * fwdFactor;
|
||
|
|
var y = wheel.sideImpulse * sideFactor;
|
||
|
|
var impulseSquared = x * x + y * y;
|
||
|
|
wheel.sliding = false;
|
||
|
|
if (impulseSquared > maximpSquared) {
|
||
|
|
this.sliding = true;
|
||
|
|
wheel.sliding = true;
|
||
|
|
var factor = maximp / Math.sqrt(impulseSquared);
|
||
|
|
wheel.skidInfo *= factor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (this.sliding) for (var i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
if (0 !== wheel.sideImpulse && wheel.skidInfo < 1) {
|
||
|
|
wheel.forwardImpulse *= wheel.skidInfo;
|
||
|
|
wheel.sideImpulse *= wheel.skidInfo;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var i = 0; i < numWheels; i++) {
|
||
|
|
var wheel = wheelInfos[i];
|
||
|
|
var rel_pos = new Vec3();
|
||
|
|
wheel.raycastResult.hitPointWorld.vsub(chassisBody.position, rel_pos);
|
||
|
|
if (0 !== wheel.forwardImpulse) {
|
||
|
|
var impulse = new Vec3();
|
||
|
|
forwardWS[i].scale(wheel.forwardImpulse, impulse);
|
||
|
|
chassisBody.applyImpulse(impulse, rel_pos);
|
||
|
|
}
|
||
|
|
if (0 !== wheel.sideImpulse) {
|
||
|
|
var groundObject = wheel.raycastResult.body;
|
||
|
|
var rel_pos2 = new Vec3();
|
||
|
|
wheel.raycastResult.hitPointWorld.vsub(groundObject.position, rel_pos2);
|
||
|
|
var sideImp = new Vec3();
|
||
|
|
axle[i].scale(wheel.sideImpulse, sideImp);
|
||
|
|
chassisBody.vectorToLocalFrame(rel_pos, rel_pos);
|
||
|
|
rel_pos["xyz"[this.indexUpAxis]] *= wheel.rollInfluence;
|
||
|
|
chassisBody.vectorToWorldFrame(rel_pos, rel_pos);
|
||
|
|
chassisBody.applyImpulse(sideImp, rel_pos);
|
||
|
|
sideImp.scale(-1, sideImp);
|
||
|
|
groundObject.applyImpulse(sideImp, rel_pos2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var calcRollingFriction_vel1 = new Vec3();
|
||
|
|
var calcRollingFriction_vel2 = new Vec3();
|
||
|
|
var calcRollingFriction_vel = new Vec3();
|
||
|
|
function calcRollingFriction(body0, body1, frictionPosWorld, frictionDirectionWorld, maxImpulse) {
|
||
|
|
var j1 = 0;
|
||
|
|
var contactPosWorld = frictionPosWorld;
|
||
|
|
var vel1 = calcRollingFriction_vel1;
|
||
|
|
var vel2 = calcRollingFriction_vel2;
|
||
|
|
var vel = calcRollingFriction_vel;
|
||
|
|
body0.getVelocityAtWorldPoint(contactPosWorld, vel1);
|
||
|
|
body1.getVelocityAtWorldPoint(contactPosWorld, vel2);
|
||
|
|
vel1.vsub(vel2, vel);
|
||
|
|
var vrel = frictionDirectionWorld.dot(vel);
|
||
|
|
var denom0 = computeImpulseDenominator(body0, frictionPosWorld, frictionDirectionWorld);
|
||
|
|
var denom1 = computeImpulseDenominator(body1, frictionPosWorld, frictionDirectionWorld);
|
||
|
|
var relaxation = 1;
|
||
|
|
var jacDiagABInv = relaxation / (denom0 + denom1);
|
||
|
|
j1 = -vrel * jacDiagABInv;
|
||
|
|
maxImpulse < j1 && (j1 = maxImpulse);
|
||
|
|
j1 < -maxImpulse && (j1 = -maxImpulse);
|
||
|
|
return j1;
|
||
|
|
}
|
||
|
|
var computeImpulseDenominator_r0 = new Vec3();
|
||
|
|
var computeImpulseDenominator_c0 = new Vec3();
|
||
|
|
var computeImpulseDenominator_vec = new Vec3();
|
||
|
|
var computeImpulseDenominator_m = new Vec3();
|
||
|
|
function computeImpulseDenominator(body, pos, normal) {
|
||
|
|
var r0 = computeImpulseDenominator_r0;
|
||
|
|
var c0 = computeImpulseDenominator_c0;
|
||
|
|
var vec = computeImpulseDenominator_vec;
|
||
|
|
var m = computeImpulseDenominator_m;
|
||
|
|
pos.vsub(body.position, r0);
|
||
|
|
r0.cross(normal, c0);
|
||
|
|
body.invInertiaWorld.vmult(c0, m);
|
||
|
|
m.cross(r0, vec);
|
||
|
|
return body.invMass + normal.dot(vec);
|
||
|
|
}
|
||
|
|
var resolveSingleBilateral_vel1 = new Vec3();
|
||
|
|
var resolveSingleBilateral_vel2 = new Vec3();
|
||
|
|
var resolveSingleBilateral_vel = new Vec3();
|
||
|
|
function resolveSingleBilateral(body1, pos1, body2, pos2, normal, impulse) {
|
||
|
|
var normalLenSqr = normal.norm2();
|
||
|
|
if (normalLenSqr > 1.1) return 0;
|
||
|
|
var vel1 = resolveSingleBilateral_vel1;
|
||
|
|
var vel2 = resolveSingleBilateral_vel2;
|
||
|
|
var vel = resolveSingleBilateral_vel;
|
||
|
|
body1.getVelocityAtWorldPoint(pos1, vel1);
|
||
|
|
body2.getVelocityAtWorldPoint(pos2, vel2);
|
||
|
|
vel1.vsub(vel2, vel);
|
||
|
|
var rel_vel = normal.dot(vel);
|
||
|
|
var contactDamping = .2;
|
||
|
|
var massTerm = 1 / (body1.invMass + body2.invMass);
|
||
|
|
var impulse = -contactDamping * rel_vel * massTerm;
|
||
|
|
return impulse;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
"../collision/Ray": 10,
|
||
|
|
"../collision/RaycastResult": 11,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../objects/WheelInfo": 38,
|
||
|
|
"./Body": 33
|
||
|
|
} ],
|
||
|
|
35: [ function(_dereq_, module, exports) {
|
||
|
|
var Body = _dereq_("./Body");
|
||
|
|
var Sphere = _dereq_("../shapes/Sphere");
|
||
|
|
var Box = _dereq_("../shapes/Box");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var HingeConstraint = _dereq_("../constraints/HingeConstraint");
|
||
|
|
var CMath = _dereq_("../math/CMath");
|
||
|
|
module.exports = RigidVehicle;
|
||
|
|
function RigidVehicle(options) {
|
||
|
|
this.wheelBodies = [];
|
||
|
|
this.coordinateSystem = "undefined" === typeof options.coordinateSystem ? new Vec3(1, 2, 3) : options.coordinateSystem.clone();
|
||
|
|
this.chassisBody = options.chassisBody;
|
||
|
|
if (!this.chassisBody) {
|
||
|
|
var chassisShape = new Box(new Vec3(5, 2, .5));
|
||
|
|
this.chassisBody = new Body(1, chassisShape);
|
||
|
|
}
|
||
|
|
this.constraints = [];
|
||
|
|
this.wheelAxes = [];
|
||
|
|
this.wheelForces = [];
|
||
|
|
}
|
||
|
|
RigidVehicle.prototype.addWheel = function(options) {
|
||
|
|
options = options || {};
|
||
|
|
var wheelBody = options.body;
|
||
|
|
wheelBody || (wheelBody = new Body(1, new Sphere(1.2)));
|
||
|
|
this.wheelBodies.push(wheelBody);
|
||
|
|
this.wheelForces.push(0);
|
||
|
|
var zero = new Vec3();
|
||
|
|
var position = "undefined" !== typeof options.position ? options.position.clone() : new Vec3();
|
||
|
|
var worldPosition = new Vec3();
|
||
|
|
this.chassisBody.pointToWorldFrame(position, worldPosition);
|
||
|
|
wheelBody.position.set(worldPosition.x, worldPosition.y, worldPosition.z);
|
||
|
|
var axis = "undefined" !== typeof options.axis ? options.axis.clone() : new Vec3(0, 1, 0);
|
||
|
|
this.wheelAxes.push(axis);
|
||
|
|
var hingeConstraint = new HingeConstraint(this.chassisBody, wheelBody, {
|
||
|
|
pivotA: position,
|
||
|
|
axisA: axis,
|
||
|
|
pivotB: Vec3.ZERO,
|
||
|
|
axisB: axis,
|
||
|
|
collideConnected: false
|
||
|
|
});
|
||
|
|
this.constraints.push(hingeConstraint);
|
||
|
|
return this.wheelBodies.length - 1;
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype.setSteeringValue = function(value, wheelIndex) {
|
||
|
|
var axis = this.wheelAxes[wheelIndex];
|
||
|
|
var c = CMath.cos(value), s = CMath.sin(value), x = axis.x, y = axis.y;
|
||
|
|
this.constraints[wheelIndex].axisA.set(c * x - s * y, s * x + c * y, 0);
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype.setMotorSpeed = function(value, wheelIndex) {
|
||
|
|
var hingeConstraint = this.constraints[wheelIndex];
|
||
|
|
hingeConstraint.enableMotor();
|
||
|
|
hingeConstraint.motorTargetVelocity = value;
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype.disableMotor = function(wheelIndex) {
|
||
|
|
var hingeConstraint = this.constraints[wheelIndex];
|
||
|
|
hingeConstraint.disableMotor();
|
||
|
|
};
|
||
|
|
var torque = new Vec3();
|
||
|
|
RigidVehicle.prototype.setWheelForce = function(value, wheelIndex) {
|
||
|
|
this.wheelForces[wheelIndex] = value;
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype.applyWheelForce = function(value, wheelIndex) {
|
||
|
|
var axis = this.wheelAxes[wheelIndex];
|
||
|
|
var wheelBody = this.wheelBodies[wheelIndex];
|
||
|
|
var bodyTorque = wheelBody.torque;
|
||
|
|
axis.scale(value, torque);
|
||
|
|
wheelBody.vectorToWorldFrame(torque, torque);
|
||
|
|
bodyTorque.vadd(torque, bodyTorque);
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype.addToWorld = function(world) {
|
||
|
|
var constraints = this.constraints;
|
||
|
|
var bodies = this.wheelBodies.concat([ this.chassisBody ]);
|
||
|
|
for (var i = 0; i < bodies.length; i++) world.addBody(bodies[i]);
|
||
|
|
for (var i = 0; i < constraints.length; i++) world.addConstraint(constraints[i]);
|
||
|
|
world.addEventListener("preStep", this._update.bind(this));
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype._update = function() {
|
||
|
|
var wheelForces = this.wheelForces;
|
||
|
|
for (var i = 0; i < wheelForces.length; i++) this.applyWheelForce(wheelForces[i], i);
|
||
|
|
};
|
||
|
|
RigidVehicle.prototype.removeFromWorld = function(world) {
|
||
|
|
var constraints = this.constraints;
|
||
|
|
var bodies = this.wheelBodies.concat([ this.chassisBody ]);
|
||
|
|
for (var i = 0; i < bodies.length; i++) world.remove(bodies[i]);
|
||
|
|
for (var i = 0; i < constraints.length; i++) world.removeConstraint(constraints[i]);
|
||
|
|
};
|
||
|
|
var worldAxis = new Vec3();
|
||
|
|
RigidVehicle.prototype.getWheelSpeed = function(wheelIndex) {
|
||
|
|
var axis = this.wheelAxes[wheelIndex];
|
||
|
|
var wheelBody = this.wheelBodies[wheelIndex];
|
||
|
|
var w = wheelBody.angularVelocity;
|
||
|
|
this.chassisBody.vectorToWorldFrame(axis, worldAxis);
|
||
|
|
return w.dot(worldAxis);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../constraints/HingeConstraint": 16,
|
||
|
|
"../math/CMath": 27,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../shapes/Box": 39,
|
||
|
|
"../shapes/Sphere": 46,
|
||
|
|
"./Body": 33
|
||
|
|
} ],
|
||
|
|
36: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = SPHSystem;
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Particle = _dereq_("../shapes/Particle");
|
||
|
|
var Body = _dereq_("../objects/Body");
|
||
|
|
var Material = _dereq_("../material/Material");
|
||
|
|
function SPHSystem() {
|
||
|
|
this.particles = [];
|
||
|
|
this.density = 1;
|
||
|
|
this.smoothingRadius = 1;
|
||
|
|
this.speedOfSound = 1;
|
||
|
|
this.viscosity = .01;
|
||
|
|
this.eps = 1e-6;
|
||
|
|
this.pressures = [];
|
||
|
|
this.densities = [];
|
||
|
|
this.neighbors = [];
|
||
|
|
}
|
||
|
|
SPHSystem.prototype.add = function(particle) {
|
||
|
|
this.particles.push(particle);
|
||
|
|
this.neighbors.length < this.particles.length && this.neighbors.push([]);
|
||
|
|
};
|
||
|
|
SPHSystem.prototype.remove = function(particle) {
|
||
|
|
var idx = this.particles.indexOf(particle);
|
||
|
|
if (-1 !== idx) {
|
||
|
|
this.particles.splice(idx, 1);
|
||
|
|
this.neighbors.length > this.particles.length && this.neighbors.pop();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var SPHSystem_getNeighbors_dist = new Vec3();
|
||
|
|
SPHSystem.prototype.getNeighbors = function(particle, neighbors) {
|
||
|
|
var N = this.particles.length, id = particle.id, R2 = this.smoothingRadius * this.smoothingRadius, dist = SPHSystem_getNeighbors_dist;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var p = this.particles[i];
|
||
|
|
p.position.vsub(particle.position, dist);
|
||
|
|
id !== p.id && dist.norm2() < R2 && neighbors.push(p);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var SPHSystem_update_dist = new Vec3(), SPHSystem_update_a_pressure = new Vec3(), SPHSystem_update_a_visc = new Vec3(), SPHSystem_update_gradW = new Vec3(), SPHSystem_update_r_vec = new Vec3(), SPHSystem_update_u = new Vec3();
|
||
|
|
SPHSystem.prototype.update = function() {
|
||
|
|
var N = this.particles.length, dist = SPHSystem_update_dist, cs = this.speedOfSound, eps = this.eps;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var p = this.particles[i];
|
||
|
|
var neighbors = this.neighbors[i];
|
||
|
|
neighbors.length = 0;
|
||
|
|
this.getNeighbors(p, neighbors);
|
||
|
|
neighbors.push(this.particles[i]);
|
||
|
|
var numNeighbors = neighbors.length;
|
||
|
|
var sum = 0;
|
||
|
|
for (var j = 0; j !== numNeighbors; j++) {
|
||
|
|
p.position.vsub(neighbors[j].position, dist);
|
||
|
|
var len = dist.norm();
|
||
|
|
var weight = this.w(len);
|
||
|
|
sum += neighbors[j].mass * weight;
|
||
|
|
}
|
||
|
|
this.densities[i] = sum;
|
||
|
|
this.pressures[i] = cs * cs * (this.densities[i] - this.density);
|
||
|
|
}
|
||
|
|
var a_pressure = SPHSystem_update_a_pressure;
|
||
|
|
var a_visc = SPHSystem_update_a_visc;
|
||
|
|
var gradW = SPHSystem_update_gradW;
|
||
|
|
var r_vec = SPHSystem_update_r_vec;
|
||
|
|
var u = SPHSystem_update_u;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var particle = this.particles[i];
|
||
|
|
a_pressure.set(0, 0, 0);
|
||
|
|
a_visc.set(0, 0, 0);
|
||
|
|
var Pij;
|
||
|
|
var nabla;
|
||
|
|
var Vij;
|
||
|
|
var neighbors = this.neighbors[i];
|
||
|
|
var numNeighbors = neighbors.length;
|
||
|
|
for (var j = 0; j !== numNeighbors; j++) {
|
||
|
|
var neighbor = neighbors[j];
|
||
|
|
particle.position.vsub(neighbor.position, r_vec);
|
||
|
|
var r = r_vec.norm();
|
||
|
|
Pij = -neighbor.mass * (this.pressures[i] / (this.densities[i] * this.densities[i] + eps) + this.pressures[j] / (this.densities[j] * this.densities[j] + eps));
|
||
|
|
this.gradw(r_vec, gradW);
|
||
|
|
gradW.mult(Pij, gradW);
|
||
|
|
a_pressure.vadd(gradW, a_pressure);
|
||
|
|
neighbor.velocity.vsub(particle.velocity, u);
|
||
|
|
u.mult(1 / (1e-4 + this.densities[i] * this.densities[j]) * this.viscosity * neighbor.mass, u);
|
||
|
|
nabla = this.nablaw(r);
|
||
|
|
u.mult(nabla, u);
|
||
|
|
a_visc.vadd(u, a_visc);
|
||
|
|
}
|
||
|
|
a_visc.mult(particle.mass, a_visc);
|
||
|
|
a_pressure.mult(particle.mass, a_pressure);
|
||
|
|
particle.force.vadd(a_visc, particle.force);
|
||
|
|
particle.force.vadd(a_pressure, particle.force);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
SPHSystem.prototype.w = function(r) {
|
||
|
|
var h = this.smoothingRadius;
|
||
|
|
return 315 / (64 * Math.PI * Math.pow(h, 9)) * Math.pow(h * h - r * r, 3);
|
||
|
|
};
|
||
|
|
SPHSystem.prototype.gradw = function(rVec, resultVec) {
|
||
|
|
var r = rVec.norm(), h = this.smoothingRadius;
|
||
|
|
rVec.mult(945 / (32 * Math.PI * Math.pow(h, 9)) * Math.pow(h * h - r * r, 2), resultVec);
|
||
|
|
};
|
||
|
|
SPHSystem.prototype.nablaw = function(r) {
|
||
|
|
var h = this.smoothingRadius;
|
||
|
|
var nabla = 945 / (32 * Math.PI * Math.pow(h, 9)) * (h * h - r * r) * (7 * r * r - 3 * h * h);
|
||
|
|
return nabla;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../material/Material": 26,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../objects/Body": 33,
|
||
|
|
"../shapes/Particle": 43,
|
||
|
|
"../shapes/Shape": 45
|
||
|
|
} ],
|
||
|
|
37: [ function(_dereq_, module, exports) {
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
module.exports = Spring;
|
||
|
|
function Spring(bodyA, bodyB, options) {
|
||
|
|
options = options || {};
|
||
|
|
this.restLength = "number" === typeof options.restLength ? options.restLength : 1;
|
||
|
|
this.stiffness = options.stiffness || 100;
|
||
|
|
this.damping = options.damping || 1;
|
||
|
|
this.bodyA = bodyA;
|
||
|
|
this.bodyB = bodyB;
|
||
|
|
this.localAnchorA = new Vec3();
|
||
|
|
this.localAnchorB = new Vec3();
|
||
|
|
options.localAnchorA && this.localAnchorA.copy(options.localAnchorA);
|
||
|
|
options.localAnchorB && this.localAnchorB.copy(options.localAnchorB);
|
||
|
|
options.worldAnchorA && this.setWorldAnchorA(options.worldAnchorA);
|
||
|
|
options.worldAnchorB && this.setWorldAnchorB(options.worldAnchorB);
|
||
|
|
}
|
||
|
|
Spring.prototype.setWorldAnchorA = function(worldAnchorA) {
|
||
|
|
this.bodyA.pointToLocalFrame(worldAnchorA, this.localAnchorA);
|
||
|
|
};
|
||
|
|
Spring.prototype.setWorldAnchorB = function(worldAnchorB) {
|
||
|
|
this.bodyB.pointToLocalFrame(worldAnchorB, this.localAnchorB);
|
||
|
|
};
|
||
|
|
Spring.prototype.getWorldAnchorA = function(result) {
|
||
|
|
this.bodyA.pointToWorldFrame(this.localAnchorA, result);
|
||
|
|
};
|
||
|
|
Spring.prototype.getWorldAnchorB = function(result) {
|
||
|
|
this.bodyB.pointToWorldFrame(this.localAnchorB, result);
|
||
|
|
};
|
||
|
|
var applyForce_r = new Vec3(), applyForce_r_unit = new Vec3(), applyForce_u = new Vec3(), applyForce_f = new Vec3(), applyForce_worldAnchorA = new Vec3(), applyForce_worldAnchorB = new Vec3(), applyForce_ri = new Vec3(), applyForce_rj = new Vec3(), applyForce_ri_x_f = new Vec3(), applyForce_rj_x_f = new Vec3(), applyForce_tmp = new Vec3();
|
||
|
|
Spring.prototype.applyForce = function() {
|
||
|
|
var k = this.stiffness, d = this.damping, l = this.restLength, bodyA = this.bodyA, bodyB = this.bodyB, r = applyForce_r, r_unit = applyForce_r_unit, u = applyForce_u, f = applyForce_f, tmp = applyForce_tmp;
|
||
|
|
var worldAnchorA = applyForce_worldAnchorA, worldAnchorB = applyForce_worldAnchorB, ri = applyForce_ri, rj = applyForce_rj, ri_x_f = applyForce_ri_x_f, rj_x_f = applyForce_rj_x_f;
|
||
|
|
this.getWorldAnchorA(worldAnchorA);
|
||
|
|
this.getWorldAnchorB(worldAnchorB);
|
||
|
|
worldAnchorA.vsub(bodyA.position, ri);
|
||
|
|
worldAnchorB.vsub(bodyB.position, rj);
|
||
|
|
worldAnchorB.vsub(worldAnchorA, r);
|
||
|
|
var rlen = r.norm();
|
||
|
|
r_unit.copy(r);
|
||
|
|
r_unit.normalize();
|
||
|
|
bodyB.velocity.vsub(bodyA.velocity, u);
|
||
|
|
bodyB.angularVelocity.cross(rj, tmp);
|
||
|
|
u.vadd(tmp, u);
|
||
|
|
bodyA.angularVelocity.cross(ri, tmp);
|
||
|
|
u.vsub(tmp, u);
|
||
|
|
r_unit.mult(-k * (rlen - l) - d * u.dot(r_unit), f);
|
||
|
|
bodyA.force.vsub(f, bodyA.force);
|
||
|
|
bodyB.force.vadd(f, bodyB.force);
|
||
|
|
ri.cross(f, ri_x_f);
|
||
|
|
rj.cross(f, rj_x_f);
|
||
|
|
bodyA.torque.vsub(ri_x_f, bodyA.torque);
|
||
|
|
bodyB.torque.vadd(rj_x_f, bodyB.torque);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32
|
||
|
|
} ],
|
||
|
|
38: [ function(_dereq_, module, exports) {
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Transform = _dereq_("../math/Transform");
|
||
|
|
var RaycastResult = _dereq_("../collision/RaycastResult");
|
||
|
|
var Utils = _dereq_("../utils/Utils");
|
||
|
|
module.exports = WheelInfo;
|
||
|
|
function WheelInfo(options) {
|
||
|
|
options = Utils.defaults(options, {
|
||
|
|
chassisConnectionPointLocal: new Vec3(),
|
||
|
|
chassisConnectionPointWorld: new Vec3(),
|
||
|
|
directionLocal: new Vec3(),
|
||
|
|
directionWorld: new Vec3(),
|
||
|
|
axleLocal: new Vec3(),
|
||
|
|
axleWorld: new Vec3(),
|
||
|
|
suspensionRestLength: 1,
|
||
|
|
suspensionMaxLength: 2,
|
||
|
|
radius: 1,
|
||
|
|
suspensionStiffness: 100,
|
||
|
|
dampingCompression: 10,
|
||
|
|
dampingRelaxation: 10,
|
||
|
|
frictionSlip: 1e4,
|
||
|
|
steering: 0,
|
||
|
|
rotation: 0,
|
||
|
|
deltaRotation: 0,
|
||
|
|
rollInfluence: .01,
|
||
|
|
maxSuspensionForce: Number.MAX_VALUE,
|
||
|
|
isFrontWheel: true,
|
||
|
|
clippedInvContactDotSuspension: 1,
|
||
|
|
suspensionRelativeVelocity: 0,
|
||
|
|
suspensionForce: 0,
|
||
|
|
skidInfo: 0,
|
||
|
|
suspensionLength: 0,
|
||
|
|
maxSuspensionTravel: 1,
|
||
|
|
useCustomSlidingRotationalSpeed: false,
|
||
|
|
customSlidingRotationalSpeed: -.1
|
||
|
|
});
|
||
|
|
this.maxSuspensionTravel = options.maxSuspensionTravel;
|
||
|
|
this.customSlidingRotationalSpeed = options.customSlidingRotationalSpeed;
|
||
|
|
this.useCustomSlidingRotationalSpeed = options.useCustomSlidingRotationalSpeed;
|
||
|
|
this.sliding = false;
|
||
|
|
this.chassisConnectionPointLocal = options.chassisConnectionPointLocal.clone();
|
||
|
|
this.chassisConnectionPointWorld = options.chassisConnectionPointWorld.clone();
|
||
|
|
this.directionLocal = options.directionLocal.clone();
|
||
|
|
this.directionWorld = options.directionWorld.clone();
|
||
|
|
this.axleLocal = options.axleLocal.clone();
|
||
|
|
this.axleWorld = options.axleWorld.clone();
|
||
|
|
this.suspensionRestLength = options.suspensionRestLength;
|
||
|
|
this.suspensionMaxLength = options.suspensionMaxLength;
|
||
|
|
this.radius = options.radius;
|
||
|
|
this.suspensionStiffness = options.suspensionStiffness;
|
||
|
|
this.dampingCompression = options.dampingCompression;
|
||
|
|
this.dampingRelaxation = options.dampingRelaxation;
|
||
|
|
this.frictionSlip = options.frictionSlip;
|
||
|
|
this.steering = 0;
|
||
|
|
this.rotation = 0;
|
||
|
|
this.deltaRotation = 0;
|
||
|
|
this.rollInfluence = options.rollInfluence;
|
||
|
|
this.maxSuspensionForce = options.maxSuspensionForce;
|
||
|
|
this.engineForce = 0;
|
||
|
|
this.brake = 0;
|
||
|
|
this.isFrontWheel = options.isFrontWheel;
|
||
|
|
this.clippedInvContactDotSuspension = 1;
|
||
|
|
this.suspensionRelativeVelocity = 0;
|
||
|
|
this.suspensionForce = 0;
|
||
|
|
this.skidInfo = 0;
|
||
|
|
this.suspensionLength = 0;
|
||
|
|
this.sideImpulse = 0;
|
||
|
|
this.forwardImpulse = 0;
|
||
|
|
this.raycastResult = new RaycastResult();
|
||
|
|
this.worldTransform = new Transform();
|
||
|
|
this.isInContact = false;
|
||
|
|
}
|
||
|
|
var chassis_velocity_at_contactPoint = new Vec3();
|
||
|
|
var relpos = new Vec3();
|
||
|
|
var chassis_velocity_at_contactPoint = new Vec3();
|
||
|
|
WheelInfo.prototype.updateWheel = function(chassis) {
|
||
|
|
var raycastResult = this.raycastResult;
|
||
|
|
if (this.isInContact) {
|
||
|
|
var project = raycastResult.hitNormalWorld.dot(raycastResult.directionWorld);
|
||
|
|
raycastResult.hitPointWorld.vsub(chassis.position, relpos);
|
||
|
|
chassis.getVelocityAtWorldPoint(relpos, chassis_velocity_at_contactPoint);
|
||
|
|
var projVel = raycastResult.hitNormalWorld.dot(chassis_velocity_at_contactPoint);
|
||
|
|
if (project >= -.1) {
|
||
|
|
this.suspensionRelativeVelocity = 0;
|
||
|
|
this.clippedInvContactDotSuspension = 10;
|
||
|
|
} else {
|
||
|
|
var inv = -1 / project;
|
||
|
|
this.suspensionRelativeVelocity = projVel * inv;
|
||
|
|
this.clippedInvContactDotSuspension = inv;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
raycastResult.suspensionLength = this.suspensionRestLength;
|
||
|
|
this.suspensionRelativeVelocity = 0;
|
||
|
|
raycastResult.directionWorld.scale(-1, raycastResult.hitNormalWorld);
|
||
|
|
this.clippedInvContactDotSuspension = 1;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/RaycastResult": 11,
|
||
|
|
"../math/Transform": 31,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../utils/Utils": 55
|
||
|
|
} ],
|
||
|
|
39: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Box;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var ConvexPolyhedron = _dereq_("./ConvexPolyhedron");
|
||
|
|
function Box(halfExtents) {
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.BOX
|
||
|
|
});
|
||
|
|
this.halfExtents = halfExtents;
|
||
|
|
this.convexPolyhedronRepresentation = null;
|
||
|
|
this.updateConvexPolyhedronRepresentation();
|
||
|
|
this.updateBoundingSphereRadius();
|
||
|
|
}
|
||
|
|
Box.prototype = new Shape();
|
||
|
|
Box.prototype.constructor = Box;
|
||
|
|
Box.prototype.updateConvexPolyhedronRepresentation = function() {
|
||
|
|
var sx = this.halfExtents.x;
|
||
|
|
var sy = this.halfExtents.y;
|
||
|
|
var sz = this.halfExtents.z;
|
||
|
|
var V = Vec3;
|
||
|
|
var vertices = [ new V(-sx, -sy, -sz), new V(sx, -sy, -sz), new V(sx, sy, -sz), new V(-sx, sy, -sz), new V(-sx, -sy, sz), new V(sx, -sy, sz), new V(sx, sy, sz), new V(-sx, sy, sz) ];
|
||
|
|
var indices = [ [ 3, 2, 1, 0 ], [ 4, 5, 6, 7 ], [ 5, 4, 0, 1 ], [ 2, 3, 7, 6 ], [ 0, 4, 7, 3 ], [ 1, 2, 6, 5 ] ];
|
||
|
|
var axes = [ new V(0, 0, 1), new V(0, 1, 0), new V(1, 0, 0) ];
|
||
|
|
var h = new ConvexPolyhedron(vertices, indices);
|
||
|
|
this.convexPolyhedronRepresentation = h;
|
||
|
|
h.material = this.material;
|
||
|
|
};
|
||
|
|
Box.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
Box.calculateInertia(this.halfExtents, mass, target);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Box.calculateInertia = function(halfExtents, mass, target) {
|
||
|
|
var e = halfExtents;
|
||
|
|
if (e.isZero()) {
|
||
|
|
target.x = 2 / 12 * mass;
|
||
|
|
target.y = 2 / 12 * mass;
|
||
|
|
target.z = 2 / 12 * mass;
|
||
|
|
} else {
|
||
|
|
target.x = 1 / 12 * mass * (2 * e.y * 2 * e.y + 2 * e.z * 2 * e.z);
|
||
|
|
target.y = 1 / 12 * mass * (2 * e.x * 2 * e.x + 2 * e.z * 2 * e.z);
|
||
|
|
target.z = 1 / 12 * mass * (2 * e.y * 2 * e.y + 2 * e.x * 2 * e.x);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Box.prototype.getSideNormals = function(sixTargetVectors, quat) {
|
||
|
|
var sides = sixTargetVectors;
|
||
|
|
var ex = this.halfExtents;
|
||
|
|
sides[0].set(ex.x, 0, 0);
|
||
|
|
sides[1].set(0, ex.y, 0);
|
||
|
|
sides[2].set(0, 0, ex.z);
|
||
|
|
sides[3].set(-ex.x, 0, 0);
|
||
|
|
sides[4].set(0, -ex.y, 0);
|
||
|
|
sides[5].set(0, 0, -ex.z);
|
||
|
|
if (void 0 !== quat) for (var i = 0; i !== sides.length; i++) quat.vmult(sides[i], sides[i]);
|
||
|
|
return sides;
|
||
|
|
};
|
||
|
|
Box.prototype.volume = function() {
|
||
|
|
return 8 * this.halfExtents.x * this.halfExtents.y * this.halfExtents.z;
|
||
|
|
};
|
||
|
|
Box.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
this.boundingSphereRadius = this.halfExtents.norm();
|
||
|
|
};
|
||
|
|
var worldCornerTempPos = new Vec3();
|
||
|
|
var worldCornerTempNeg = new Vec3();
|
||
|
|
Box.prototype.forEachWorldCorner = function(pos, quat, callback) {
|
||
|
|
var e = this.halfExtents;
|
||
|
|
var corners = [ [ e.x, e.y, e.z ], [ -e.x, e.y, e.z ], [ -e.x, -e.y, e.z ], [ -e.x, -e.y, -e.z ], [ e.x, -e.y, -e.z ], [ e.x, e.y, -e.z ], [ -e.x, e.y, -e.z ], [ e.x, -e.y, e.z ] ];
|
||
|
|
for (var i = 0; i < corners.length; i++) {
|
||
|
|
worldCornerTempPos.set(corners[i][0], corners[i][1], corners[i][2]);
|
||
|
|
quat.vmult(worldCornerTempPos, worldCornerTempPos);
|
||
|
|
pos.vadd(worldCornerTempPos, worldCornerTempPos);
|
||
|
|
callback(worldCornerTempPos.x, worldCornerTempPos.y, worldCornerTempPos.z);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var worldCornersTemp = [ new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3() ];
|
||
|
|
Box.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
var e = this.halfExtents;
|
||
|
|
worldCornersTemp[0].set(e.x, e.y, e.z);
|
||
|
|
worldCornersTemp[1].set(-e.x, e.y, e.z);
|
||
|
|
worldCornersTemp[2].set(-e.x, -e.y, e.z);
|
||
|
|
worldCornersTemp[3].set(-e.x, -e.y, -e.z);
|
||
|
|
worldCornersTemp[4].set(e.x, -e.y, -e.z);
|
||
|
|
worldCornersTemp[5].set(e.x, e.y, -e.z);
|
||
|
|
worldCornersTemp[6].set(-e.x, e.y, -e.z);
|
||
|
|
worldCornersTemp[7].set(e.x, -e.y, e.z);
|
||
|
|
var wc = worldCornersTemp[0];
|
||
|
|
quat.vmult(wc, wc);
|
||
|
|
pos.vadd(wc, wc);
|
||
|
|
max.copy(wc);
|
||
|
|
min.copy(wc);
|
||
|
|
for (var i = 1; i < 8; i++) {
|
||
|
|
var wc = worldCornersTemp[i];
|
||
|
|
quat.vmult(wc, wc);
|
||
|
|
pos.vadd(wc, wc);
|
||
|
|
var x = wc.x;
|
||
|
|
var y = wc.y;
|
||
|
|
var z = wc.z;
|
||
|
|
x > max.x && (max.x = x);
|
||
|
|
y > max.y && (max.y = y);
|
||
|
|
z > max.z && (max.z = z);
|
||
|
|
x < min.x && (min.x = x);
|
||
|
|
y < min.y && (min.y = y);
|
||
|
|
z < min.z && (min.z = z);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./ConvexPolyhedron": 40,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
40: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = ConvexPolyhedron;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Transform = _dereq_("../math/Transform");
|
||
|
|
function ConvexPolyhedron(points, faces, uniqueAxes) {
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.CONVEXPOLYHEDRON
|
||
|
|
});
|
||
|
|
this.vertices = points || [];
|
||
|
|
this.worldVertices = [];
|
||
|
|
this.worldVerticesNeedsUpdate = true;
|
||
|
|
this.faces = faces || [];
|
||
|
|
this.faceNormals = [];
|
||
|
|
this.computeNormals();
|
||
|
|
this.worldFaceNormalsNeedsUpdate = true;
|
||
|
|
this.worldFaceNormals = [];
|
||
|
|
this.uniqueEdges = [];
|
||
|
|
this.uniqueAxes = uniqueAxes ? uniqueAxes.slice() : null;
|
||
|
|
this.computeEdges();
|
||
|
|
this.updateBoundingSphereRadius();
|
||
|
|
}
|
||
|
|
ConvexPolyhedron.prototype = new Shape();
|
||
|
|
ConvexPolyhedron.prototype.constructor = ConvexPolyhedron;
|
||
|
|
var computeEdges_tmpEdge = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.computeEdges = function() {
|
||
|
|
var faces = this.faces;
|
||
|
|
var vertices = this.vertices;
|
||
|
|
var nv = vertices.length;
|
||
|
|
var edges = this.uniqueEdges;
|
||
|
|
edges.length = 0;
|
||
|
|
var edge = computeEdges_tmpEdge;
|
||
|
|
for (var i = 0; i !== faces.length; i++) {
|
||
|
|
var face = faces[i];
|
||
|
|
var numVertices = face.length;
|
||
|
|
for (var j = 0; j !== numVertices; j++) {
|
||
|
|
var k = (j + 1) % numVertices;
|
||
|
|
vertices[face[j]].vsub(vertices[face[k]], edge);
|
||
|
|
edge.normalize();
|
||
|
|
var found = false;
|
||
|
|
for (var p = 0; p !== edges.length; p++) if (edges[p].almostEquals(edge) || edges[p].almostEquals(edge)) {
|
||
|
|
found = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
found || edges.push(edge.clone());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.computeNormals = function() {
|
||
|
|
this.faceNormals.length = this.faces.length;
|
||
|
|
for (var i = 0; i < this.faces.length; i++) {
|
||
|
|
for (var j = 0; j < this.faces[i].length; j++) if (!this.vertices[this.faces[i][j]]) throw new Error("Vertex " + this.faces[i][j] + " not found!");
|
||
|
|
var n = this.faceNormals[i] || new Vec3();
|
||
|
|
this.getFaceNormal(i, n);
|
||
|
|
n.negate(n);
|
||
|
|
this.faceNormals[i] = n;
|
||
|
|
var vertex = this.vertices[this.faces[i][0]];
|
||
|
|
if (n.dot(vertex) < 0) {
|
||
|
|
console.error(".faceNormals[" + i + "] = Vec3(" + n.toString() + ") looks like it points into the shape? The vertices follow. Make sure they are ordered CCW around the normal, using the right hand rule.");
|
||
|
|
for (var j = 0; j < this.faces[i].length; j++) console.warn(".vertices[" + this.faces[i][j] + "] = Vec3(" + this.vertices[this.faces[i][j]].toString() + ")");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var cb = new Vec3();
|
||
|
|
var ab = new Vec3();
|
||
|
|
ConvexPolyhedron.computeNormal = function(va, vb, vc, target) {
|
||
|
|
vb.vsub(va, ab);
|
||
|
|
vc.vsub(vb, cb);
|
||
|
|
cb.cross(ab, target);
|
||
|
|
target.isZero() || target.normalize();
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.getFaceNormal = function(i, target) {
|
||
|
|
var f = this.faces[i];
|
||
|
|
var va = this.vertices[f[0]];
|
||
|
|
var vb = this.vertices[f[1]];
|
||
|
|
var vc = this.vertices[f[2]];
|
||
|
|
return ConvexPolyhedron.computeNormal(va, vb, vc, target);
|
||
|
|
};
|
||
|
|
var cah_WorldNormal = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.clipAgainstHull = function(posA, quatA, hullB, posB, quatB, separatingNormal, minDist, maxDist, result) {
|
||
|
|
var WorldNormal = cah_WorldNormal;
|
||
|
|
var hullA = this;
|
||
|
|
var curMaxDist = maxDist;
|
||
|
|
var closestFaceB = -1;
|
||
|
|
var dmax = -Number.MAX_VALUE;
|
||
|
|
for (var face = 0; face < hullB.faces.length; face++) {
|
||
|
|
WorldNormal.copy(hullB.faceNormals[face]);
|
||
|
|
quatB.vmult(WorldNormal, WorldNormal);
|
||
|
|
var d = WorldNormal.dot(separatingNormal);
|
||
|
|
if (d > dmax) {
|
||
|
|
dmax = d;
|
||
|
|
closestFaceB = face;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var worldVertsB1 = [];
|
||
|
|
var polyB = hullB.faces[closestFaceB];
|
||
|
|
var numVertices = polyB.length;
|
||
|
|
for (var e0 = 0; e0 < numVertices; e0++) {
|
||
|
|
var b = hullB.vertices[polyB[e0]];
|
||
|
|
var worldb = new Vec3();
|
||
|
|
worldb.copy(b);
|
||
|
|
quatB.vmult(worldb, worldb);
|
||
|
|
posB.vadd(worldb, worldb);
|
||
|
|
worldVertsB1.push(worldb);
|
||
|
|
}
|
||
|
|
closestFaceB >= 0 && this.clipFaceAgainstHull(separatingNormal, posA, quatA, worldVertsB1, minDist, maxDist, result);
|
||
|
|
};
|
||
|
|
var fsa_faceANormalWS3 = new Vec3(), fsa_Worldnormal1 = new Vec3(), fsa_deltaC = new Vec3(), fsa_worldEdge0 = new Vec3(), fsa_worldEdge1 = new Vec3(), fsa_Cross = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.findSeparatingAxis = function(hullB, posA, quatA, posB, quatB, target, faceListA, faceListB) {
|
||
|
|
var faceANormalWS3 = fsa_faceANormalWS3, Worldnormal1 = fsa_Worldnormal1, deltaC = fsa_deltaC, worldEdge0 = fsa_worldEdge0, worldEdge1 = fsa_worldEdge1, Cross = fsa_Cross;
|
||
|
|
var dmin = Number.MAX_VALUE;
|
||
|
|
var hullA = this;
|
||
|
|
var curPlaneTests = 0;
|
||
|
|
if (hullA.uniqueAxes) for (var i = 0; i !== hullA.uniqueAxes.length; i++) {
|
||
|
|
quatA.vmult(hullA.uniqueAxes[i], faceANormalWS3);
|
||
|
|
var d = hullA.testSepAxis(faceANormalWS3, hullB, posA, quatA, posB, quatB);
|
||
|
|
if (false === d) return false;
|
||
|
|
if (d < dmin) {
|
||
|
|
dmin = d;
|
||
|
|
target.copy(faceANormalWS3);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var numFacesA = faceListA ? faceListA.length : hullA.faces.length;
|
||
|
|
for (var i = 0; i < numFacesA; i++) {
|
||
|
|
var fi = faceListA ? faceListA[i] : i;
|
||
|
|
faceANormalWS3.copy(hullA.faceNormals[fi]);
|
||
|
|
quatA.vmult(faceANormalWS3, faceANormalWS3);
|
||
|
|
var d = hullA.testSepAxis(faceANormalWS3, hullB, posA, quatA, posB, quatB);
|
||
|
|
if (false === d) return false;
|
||
|
|
if (d < dmin) {
|
||
|
|
dmin = d;
|
||
|
|
target.copy(faceANormalWS3);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (hullB.uniqueAxes) for (var i = 0; i !== hullB.uniqueAxes.length; i++) {
|
||
|
|
quatB.vmult(hullB.uniqueAxes[i], Worldnormal1);
|
||
|
|
curPlaneTests++;
|
||
|
|
var d = hullA.testSepAxis(Worldnormal1, hullB, posA, quatA, posB, quatB);
|
||
|
|
if (false === d) return false;
|
||
|
|
if (d < dmin) {
|
||
|
|
dmin = d;
|
||
|
|
target.copy(Worldnormal1);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var numFacesB = faceListB ? faceListB.length : hullB.faces.length;
|
||
|
|
for (var i = 0; i < numFacesB; i++) {
|
||
|
|
var fi = faceListB ? faceListB[i] : i;
|
||
|
|
Worldnormal1.copy(hullB.faceNormals[fi]);
|
||
|
|
quatB.vmult(Worldnormal1, Worldnormal1);
|
||
|
|
curPlaneTests++;
|
||
|
|
var d = hullA.testSepAxis(Worldnormal1, hullB, posA, quatA, posB, quatB);
|
||
|
|
if (false === d) return false;
|
||
|
|
if (d < dmin) {
|
||
|
|
dmin = d;
|
||
|
|
target.copy(Worldnormal1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var e0 = 0; e0 !== hullA.uniqueEdges.length; e0++) {
|
||
|
|
quatA.vmult(hullA.uniqueEdges[e0], worldEdge0);
|
||
|
|
for (var e1 = 0; e1 !== hullB.uniqueEdges.length; e1++) {
|
||
|
|
quatB.vmult(hullB.uniqueEdges[e1], worldEdge1);
|
||
|
|
worldEdge0.cross(worldEdge1, Cross);
|
||
|
|
if (!Cross.almostZero()) {
|
||
|
|
Cross.normalize();
|
||
|
|
var dist = hullA.testSepAxis(Cross, hullB, posA, quatA, posB, quatB);
|
||
|
|
if (false === dist) return false;
|
||
|
|
if (dist < dmin) {
|
||
|
|
dmin = dist;
|
||
|
|
target.copy(Cross);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
posB.vsub(posA, deltaC);
|
||
|
|
deltaC.dot(target) > 0 && target.negate(target);
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
var maxminA = [], maxminB = [];
|
||
|
|
ConvexPolyhedron.prototype.testSepAxis = function(axis, hullB, posA, quatA, posB, quatB) {
|
||
|
|
var hullA = this;
|
||
|
|
ConvexPolyhedron.project(hullA, axis, posA, quatA, maxminA);
|
||
|
|
ConvexPolyhedron.project(hullB, axis, posB, quatB, maxminB);
|
||
|
|
var maxA = maxminA[0];
|
||
|
|
var minA = maxminA[1];
|
||
|
|
var maxB = maxminB[0];
|
||
|
|
var minB = maxminB[1];
|
||
|
|
if (maxA < minB || maxB < minA) return false;
|
||
|
|
var d0 = maxA - minB;
|
||
|
|
var d1 = maxB - minA;
|
||
|
|
var depth = d0 < d1 ? d0 : d1;
|
||
|
|
return depth;
|
||
|
|
};
|
||
|
|
var cli_aabbmin = new Vec3(), cli_aabbmax = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
this.computeLocalAABB(cli_aabbmin, cli_aabbmax);
|
||
|
|
var x = cli_aabbmax.x - cli_aabbmin.x, y = cli_aabbmax.y - cli_aabbmin.y, z = cli_aabbmax.z - cli_aabbmin.z;
|
||
|
|
target.x = 1 / 12 * mass * (2 * y * 2 * y + 2 * z * 2 * z);
|
||
|
|
target.y = 1 / 12 * mass * (2 * x * 2 * x + 2 * z * 2 * z);
|
||
|
|
target.z = 1 / 12 * mass * (2 * y * 2 * y + 2 * x * 2 * x);
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.getPlaneConstantOfFace = function(face_i) {
|
||
|
|
var f = this.faces[face_i];
|
||
|
|
var n = this.faceNormals[face_i];
|
||
|
|
var v = this.vertices[f[0]];
|
||
|
|
var c = -n.dot(v);
|
||
|
|
return c;
|
||
|
|
};
|
||
|
|
var cfah_faceANormalWS = new Vec3(), cfah_edge0 = new Vec3(), cfah_WorldEdge0 = new Vec3(), cfah_worldPlaneAnormal1 = new Vec3(), cfah_planeNormalWS1 = new Vec3(), cfah_worldA1 = new Vec3(), cfah_localPlaneNormal = new Vec3(), cfah_planeNormalWS = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.clipFaceAgainstHull = function(separatingNormal, posA, quatA, worldVertsB1, minDist, maxDist, result) {
|
||
|
|
var faceANormalWS = cfah_faceANormalWS, edge0 = cfah_edge0, WorldEdge0 = cfah_WorldEdge0, worldPlaneAnormal1 = cfah_worldPlaneAnormal1, planeNormalWS1 = cfah_planeNormalWS1, worldA1 = cfah_worldA1, localPlaneNormal = cfah_localPlaneNormal, planeNormalWS = cfah_planeNormalWS;
|
||
|
|
var hullA = this;
|
||
|
|
var worldVertsB2 = [];
|
||
|
|
var pVtxIn = worldVertsB1;
|
||
|
|
var pVtxOut = worldVertsB2;
|
||
|
|
var closestFaceA = -1;
|
||
|
|
var dmin = Number.MAX_VALUE;
|
||
|
|
for (var face = 0; face < hullA.faces.length; face++) {
|
||
|
|
faceANormalWS.copy(hullA.faceNormals[face]);
|
||
|
|
quatA.vmult(faceANormalWS, faceANormalWS);
|
||
|
|
var d = faceANormalWS.dot(separatingNormal);
|
||
|
|
if (d < dmin) {
|
||
|
|
dmin = d;
|
||
|
|
closestFaceA = face;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (closestFaceA < 0) return;
|
||
|
|
var polyA = hullA.faces[closestFaceA];
|
||
|
|
polyA.connectedFaces = [];
|
||
|
|
for (var i = 0; i < hullA.faces.length; i++) for (var j = 0; j < hullA.faces[i].length; j++) -1 !== polyA.indexOf(hullA.faces[i][j]) && i !== closestFaceA && -1 === polyA.connectedFaces.indexOf(i) && polyA.connectedFaces.push(i);
|
||
|
|
var numContacts = pVtxIn.length;
|
||
|
|
var numVerticesA = polyA.length;
|
||
|
|
var res = [];
|
||
|
|
for (var e0 = 0; e0 < numVerticesA; e0++) {
|
||
|
|
var a = hullA.vertices[polyA[e0]];
|
||
|
|
var b = hullA.vertices[polyA[(e0 + 1) % numVerticesA]];
|
||
|
|
a.vsub(b, edge0);
|
||
|
|
WorldEdge0.copy(edge0);
|
||
|
|
quatA.vmult(WorldEdge0, WorldEdge0);
|
||
|
|
posA.vadd(WorldEdge0, WorldEdge0);
|
||
|
|
worldPlaneAnormal1.copy(this.faceNormals[closestFaceA]);
|
||
|
|
quatA.vmult(worldPlaneAnormal1, worldPlaneAnormal1);
|
||
|
|
posA.vadd(worldPlaneAnormal1, worldPlaneAnormal1);
|
||
|
|
WorldEdge0.cross(worldPlaneAnormal1, planeNormalWS1);
|
||
|
|
planeNormalWS1.negate(planeNormalWS1);
|
||
|
|
worldA1.copy(a);
|
||
|
|
quatA.vmult(worldA1, worldA1);
|
||
|
|
posA.vadd(worldA1, worldA1);
|
||
|
|
var planeEqWS1 = -worldA1.dot(planeNormalWS1);
|
||
|
|
var planeEqWS;
|
||
|
|
true;
|
||
|
|
var otherFace = polyA.connectedFaces[e0];
|
||
|
|
localPlaneNormal.copy(this.faceNormals[otherFace]);
|
||
|
|
var localPlaneEq = this.getPlaneConstantOfFace(otherFace);
|
||
|
|
planeNormalWS.copy(localPlaneNormal);
|
||
|
|
quatA.vmult(planeNormalWS, planeNormalWS);
|
||
|
|
var planeEqWS = localPlaneEq - planeNormalWS.dot(posA);
|
||
|
|
this.clipFaceAgainstPlane(pVtxIn, pVtxOut, planeNormalWS, planeEqWS);
|
||
|
|
while (pVtxIn.length) pVtxIn.shift();
|
||
|
|
while (pVtxOut.length) pVtxIn.push(pVtxOut.shift());
|
||
|
|
}
|
||
|
|
localPlaneNormal.copy(this.faceNormals[closestFaceA]);
|
||
|
|
var localPlaneEq = this.getPlaneConstantOfFace(closestFaceA);
|
||
|
|
planeNormalWS.copy(localPlaneNormal);
|
||
|
|
quatA.vmult(planeNormalWS, planeNormalWS);
|
||
|
|
var planeEqWS = localPlaneEq - planeNormalWS.dot(posA);
|
||
|
|
for (var i = 0; i < pVtxIn.length; i++) {
|
||
|
|
var depth = planeNormalWS.dot(pVtxIn[i]) + planeEqWS;
|
||
|
|
depth <= minDist && (depth = minDist);
|
||
|
|
if (depth <= maxDist) {
|
||
|
|
var point = pVtxIn[i];
|
||
|
|
if (depth <= 0) {
|
||
|
|
var p = {
|
||
|
|
point: point,
|
||
|
|
normal: planeNormalWS,
|
||
|
|
depth: depth
|
||
|
|
};
|
||
|
|
result.push(p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.clipFaceAgainstPlane = function(inVertices, outVertices, planeNormal, planeConstant) {
|
||
|
|
var n_dot_first, n_dot_last;
|
||
|
|
var numVerts = inVertices.length;
|
||
|
|
if (numVerts < 2) return outVertices;
|
||
|
|
var firstVertex = inVertices[inVertices.length - 1], lastVertex = inVertices[0];
|
||
|
|
n_dot_first = planeNormal.dot(firstVertex) + planeConstant;
|
||
|
|
for (var vi = 0; vi < numVerts; vi++) {
|
||
|
|
lastVertex = inVertices[vi];
|
||
|
|
n_dot_last = planeNormal.dot(lastVertex) + planeConstant;
|
||
|
|
if (n_dot_first < 0) if (n_dot_last < 0) {
|
||
|
|
var newv = new Vec3();
|
||
|
|
newv.copy(lastVertex);
|
||
|
|
outVertices.push(newv);
|
||
|
|
} else {
|
||
|
|
var newv = new Vec3();
|
||
|
|
firstVertex.lerp(lastVertex, n_dot_first / (n_dot_first - n_dot_last), newv);
|
||
|
|
outVertices.push(newv);
|
||
|
|
} else if (n_dot_last < 0) {
|
||
|
|
var newv = new Vec3();
|
||
|
|
firstVertex.lerp(lastVertex, n_dot_first / (n_dot_first - n_dot_last), newv);
|
||
|
|
outVertices.push(newv);
|
||
|
|
outVertices.push(lastVertex);
|
||
|
|
}
|
||
|
|
firstVertex = lastVertex;
|
||
|
|
n_dot_first = n_dot_last;
|
||
|
|
}
|
||
|
|
return outVertices;
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.computeWorldVertices = function(position, quat) {
|
||
|
|
var N = this.vertices.length;
|
||
|
|
while (this.worldVertices.length < N) this.worldVertices.push(new Vec3());
|
||
|
|
var verts = this.vertices, worldVerts = this.worldVertices;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
quat.vmult(verts[i], worldVerts[i]);
|
||
|
|
position.vadd(worldVerts[i], worldVerts[i]);
|
||
|
|
}
|
||
|
|
this.worldVerticesNeedsUpdate = false;
|
||
|
|
};
|
||
|
|
var computeLocalAABB_worldVert = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.computeLocalAABB = function(aabbmin, aabbmax) {
|
||
|
|
var n = this.vertices.length, vertices = this.vertices, worldVert = computeLocalAABB_worldVert;
|
||
|
|
aabbmin.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
|
||
|
|
aabbmax.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
|
||
|
|
for (var i = 0; i < n; i++) {
|
||
|
|
var v = vertices[i];
|
||
|
|
v.x < aabbmin.x ? aabbmin.x = v.x : v.x > aabbmax.x && (aabbmax.x = v.x);
|
||
|
|
v.y < aabbmin.y ? aabbmin.y = v.y : v.y > aabbmax.y && (aabbmax.y = v.y);
|
||
|
|
v.z < aabbmin.z ? aabbmin.z = v.z : v.z > aabbmax.z && (aabbmax.z = v.z);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.computeWorldFaceNormals = function(quat) {
|
||
|
|
var N = this.faceNormals.length;
|
||
|
|
while (this.worldFaceNormals.length < N) this.worldFaceNormals.push(new Vec3());
|
||
|
|
var normals = this.faceNormals, worldNormals = this.worldFaceNormals;
|
||
|
|
for (var i = 0; i !== N; i++) quat.vmult(normals[i], worldNormals[i]);
|
||
|
|
this.worldFaceNormalsNeedsUpdate = false;
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
var max2 = 0;
|
||
|
|
var verts = this.vertices;
|
||
|
|
for (var i = 0, N = verts.length; i !== N; i++) {
|
||
|
|
var norm2 = verts[i].norm2();
|
||
|
|
norm2 > max2 && (max2 = norm2);
|
||
|
|
}
|
||
|
|
this.boundingSphereRadius = Math.sqrt(max2);
|
||
|
|
};
|
||
|
|
var tempWorldVertex = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
var n = this.vertices.length, verts = this.vertices;
|
||
|
|
var minx, miny, minz, maxx, maxy, maxz;
|
||
|
|
for (var i = 0; i < n; i++) {
|
||
|
|
tempWorldVertex.copy(verts[i]);
|
||
|
|
quat.vmult(tempWorldVertex, tempWorldVertex);
|
||
|
|
pos.vadd(tempWorldVertex, tempWorldVertex);
|
||
|
|
var v = tempWorldVertex;
|
||
|
|
(v.x < minx || void 0 === minx) && (minx = v.x);
|
||
|
|
(v.x > maxx || void 0 === maxx) && (maxx = v.x);
|
||
|
|
(v.y < miny || void 0 === miny) && (miny = v.y);
|
||
|
|
(v.y > maxy || void 0 === maxy) && (maxy = v.y);
|
||
|
|
(v.z < minz || void 0 === minz) && (minz = v.z);
|
||
|
|
(v.z > maxz || void 0 === maxz) && (maxz = v.z);
|
||
|
|
}
|
||
|
|
min.set(minx, miny, minz);
|
||
|
|
max.set(maxx, maxy, maxz);
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.volume = function() {
|
||
|
|
return 4 * Math.PI * this.boundingSphereRadius / 3;
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.getAveragePointLocal = function(target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var n = this.vertices.length, verts = this.vertices;
|
||
|
|
for (var i = 0; i < n; i++) target.vadd(verts[i], target);
|
||
|
|
target.mult(1 / n, target);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
ConvexPolyhedron.prototype.transformAllPoints = function(offset, quat) {
|
||
|
|
var n = this.vertices.length, verts = this.vertices;
|
||
|
|
if (quat) {
|
||
|
|
for (var i = 0; i < n; i++) {
|
||
|
|
var v = verts[i];
|
||
|
|
quat.vmult(v, v);
|
||
|
|
}
|
||
|
|
for (var i = 0; i < this.faceNormals.length; i++) {
|
||
|
|
var v = this.faceNormals[i];
|
||
|
|
quat.vmult(v, v);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (offset) for (var i = 0; i < n; i++) {
|
||
|
|
var v = verts[i];
|
||
|
|
v.vadd(offset, v);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var ConvexPolyhedron_pointIsInside = new Vec3();
|
||
|
|
var ConvexPolyhedron_vToP = new Vec3();
|
||
|
|
var ConvexPolyhedron_vToPointInside = new Vec3();
|
||
|
|
ConvexPolyhedron.prototype.pointIsInside = function(p) {
|
||
|
|
var n = this.vertices.length, verts = this.vertices, faces = this.faces, normals = this.faceNormals;
|
||
|
|
var positiveResult = null;
|
||
|
|
var N = this.faces.length;
|
||
|
|
var pointInside = ConvexPolyhedron_pointIsInside;
|
||
|
|
this.getAveragePointLocal(pointInside);
|
||
|
|
for (var i = 0; i < N; i++) {
|
||
|
|
var numVertices = this.faces[i].length;
|
||
|
|
var n = normals[i];
|
||
|
|
var v = verts[faces[i][0]];
|
||
|
|
var vToP = ConvexPolyhedron_vToP;
|
||
|
|
p.vsub(v, vToP);
|
||
|
|
var r1 = n.dot(vToP);
|
||
|
|
var vToPointInside = ConvexPolyhedron_vToPointInside;
|
||
|
|
pointInside.vsub(v, vToPointInside);
|
||
|
|
var r2 = n.dot(vToPointInside);
|
||
|
|
if (r1 < 0 && r2 > 0 || r1 > 0 && r2 < 0) return false;
|
||
|
|
}
|
||
|
|
return positiveResult ? 1 : -1;
|
||
|
|
};
|
||
|
|
var project_worldVertex = new Vec3();
|
||
|
|
var project_localAxis = new Vec3();
|
||
|
|
var project_localOrigin = new Vec3();
|
||
|
|
ConvexPolyhedron.project = function(hull, axis, pos, quat, result) {
|
||
|
|
var n = hull.vertices.length, worldVertex = project_worldVertex, localAxis = project_localAxis, max = 0, min = 0, localOrigin = project_localOrigin, vs = hull.vertices;
|
||
|
|
localOrigin.setZero();
|
||
|
|
Transform.vectorToLocalFrame(pos, quat, axis, localAxis);
|
||
|
|
Transform.pointToLocalFrame(pos, quat, localOrigin, localOrigin);
|
||
|
|
var add = localOrigin.dot(localAxis);
|
||
|
|
min = max = vs[0].dot(localAxis);
|
||
|
|
for (var i = 1; i < n; i++) {
|
||
|
|
var val = vs[i].dot(localAxis);
|
||
|
|
val > max && (max = val);
|
||
|
|
val < min && (min = val);
|
||
|
|
}
|
||
|
|
min -= add;
|
||
|
|
max -= add;
|
||
|
|
if (min > max) {
|
||
|
|
var temp = min;
|
||
|
|
min = max;
|
||
|
|
max = temp;
|
||
|
|
}
|
||
|
|
result[0] = max;
|
||
|
|
result[1] = min;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Transform": 31,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
41: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Cylinder;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var ConvexPolyhedron = _dereq_("./ConvexPolyhedron");
|
||
|
|
var CMath = _dereq_("../math/CMath");
|
||
|
|
function Cylinder(radiusTop, radiusBottom, height, numSegments, isDirY) {
|
||
|
|
if (isDirY) {
|
||
|
|
var N = numSegments, cos = CMath.cos, sin = CMath.sin;
|
||
|
|
var halfH = height / 2;
|
||
|
|
var vertices = [];
|
||
|
|
var indices = [];
|
||
|
|
var tf = [ 0 ];
|
||
|
|
var bf = [ 1 ];
|
||
|
|
var axes = [];
|
||
|
|
var theta = 2 * Math.PI / N;
|
||
|
|
for (var i = 0; i < N; i++) {
|
||
|
|
vertices.push(new Vec3(radiusTop * cos(theta * i), halfH, radiusTop * sin(theta * i)));
|
||
|
|
vertices.push(new Vec3(radiusTop * cos(theta * i), -halfH, radiusTop * sin(theta * i)));
|
||
|
|
if (i < N - 1) {
|
||
|
|
indices.push([ 2 * i + 2, 2 * i + 3, 2 * i + 1, 2 * i ]);
|
||
|
|
tf.push(2 * i + 2);
|
||
|
|
bf.push(2 * i + 3);
|
||
|
|
} else indices.push([ 0, 1, 2 * i + 1, 2 * i ]);
|
||
|
|
(N % 2 === 1 || i < N / 2) && axes.push(new Vec3(cos(theta * (i + .5)), 0, sin(theta * (i + .5))));
|
||
|
|
}
|
||
|
|
indices.push(bf);
|
||
|
|
var temp = [];
|
||
|
|
for (var i = 0; i < tf.length; i++) temp.push(tf[tf.length - i - 1]);
|
||
|
|
indices.push(temp);
|
||
|
|
axes.push(new Vec3(0, 1, 0));
|
||
|
|
ConvexPolyhedron.call(this, vertices, indices, axes);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var N = numSegments, verts = [], axes = [], faces = [], bottomface = [], topface = [], cos = CMath.cos, sin = CMath.sin;
|
||
|
|
verts.push(new Vec3(radiusBottom * cos(0), radiusBottom * sin(0), .5 * -height));
|
||
|
|
bottomface.push(0);
|
||
|
|
verts.push(new Vec3(radiusTop * cos(0), radiusTop * sin(0), .5 * height));
|
||
|
|
topface.push(1);
|
||
|
|
for (var i = 0; i < N; i++) {
|
||
|
|
var theta = 2 * Math.PI / N * (i + 1);
|
||
|
|
var thetaN = 2 * Math.PI / N * (i + .5);
|
||
|
|
if (i < N - 1) {
|
||
|
|
verts.push(new Vec3(radiusBottom * cos(theta), radiusBottom * sin(theta), .5 * -height));
|
||
|
|
bottomface.push(2 * i + 2);
|
||
|
|
verts.push(new Vec3(radiusTop * cos(theta), radiusTop * sin(theta), .5 * height));
|
||
|
|
topface.push(2 * i + 3);
|
||
|
|
faces.push([ 2 * i + 2, 2 * i + 3, 2 * i + 1, 2 * i ]);
|
||
|
|
} else faces.push([ 0, 1, 2 * i + 1, 2 * i ]);
|
||
|
|
(N % 2 === 1 || i < N / 2) && axes.push(new Vec3(cos(thetaN), sin(thetaN), 0));
|
||
|
|
}
|
||
|
|
faces.push(topface);
|
||
|
|
axes.push(new Vec3(0, 0, 1));
|
||
|
|
var temp = [];
|
||
|
|
for (var i = 0; i < bottomface.length; i++) temp.push(bottomface[bottomface.length - i - 1]);
|
||
|
|
faces.push(temp);
|
||
|
|
ConvexPolyhedron.call(this, verts, faces, axes);
|
||
|
|
}
|
||
|
|
Cylinder.prototype = new ConvexPolyhedron();
|
||
|
|
}, {
|
||
|
|
"../math/CMath": 27,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./ConvexPolyhedron": 40,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
42: [ function(_dereq_, module, exports) {
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var ConvexPolyhedron = _dereq_("./ConvexPolyhedron");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Utils = _dereq_("../utils/Utils");
|
||
|
|
module.exports = Heightfield;
|
||
|
|
function Heightfield(data, options) {
|
||
|
|
options = Utils.defaults(options, {
|
||
|
|
maxValue: null,
|
||
|
|
minValue: null,
|
||
|
|
elementSize: 1
|
||
|
|
});
|
||
|
|
this.data = data;
|
||
|
|
this.maxValue = options.maxValue;
|
||
|
|
this.minValue = options.minValue;
|
||
|
|
this.elementSize = options.elementSize;
|
||
|
|
null === options.minValue && this.updateMinValue();
|
||
|
|
null === options.maxValue && this.updateMaxValue();
|
||
|
|
this.cacheEnabled = true;
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.HEIGHTFIELD
|
||
|
|
});
|
||
|
|
this.pillarConvex = new ConvexPolyhedron();
|
||
|
|
this.pillarOffset = new Vec3();
|
||
|
|
this.updateBoundingSphereRadius();
|
||
|
|
this._cachedPillars = {};
|
||
|
|
}
|
||
|
|
Heightfield.prototype = new Shape();
|
||
|
|
Heightfield.prototype.update = function() {
|
||
|
|
this._cachedPillars = {};
|
||
|
|
};
|
||
|
|
Heightfield.prototype.updateMinValue = function() {
|
||
|
|
var data = this.data;
|
||
|
|
var minValue = data[0][0];
|
||
|
|
for (var i = 0; i !== data.length; i++) for (var j = 0; j !== data[i].length; j++) {
|
||
|
|
var v = data[i][j];
|
||
|
|
v < minValue && (minValue = v);
|
||
|
|
}
|
||
|
|
this.minValue = minValue;
|
||
|
|
};
|
||
|
|
Heightfield.prototype.updateMaxValue = function() {
|
||
|
|
var data = this.data;
|
||
|
|
var maxValue = data[0][0];
|
||
|
|
for (var i = 0; i !== data.length; i++) for (var j = 0; j !== data[i].length; j++) {
|
||
|
|
var v = data[i][j];
|
||
|
|
v > maxValue && (maxValue = v);
|
||
|
|
}
|
||
|
|
this.maxValue = maxValue;
|
||
|
|
};
|
||
|
|
Heightfield.prototype.setHeightValueAtIndex = function(xi, yi, value) {
|
||
|
|
var data = this.data;
|
||
|
|
data[xi][yi] = value;
|
||
|
|
this.clearCachedConvexTrianglePillar(xi, yi, false);
|
||
|
|
if (xi > 0) {
|
||
|
|
this.clearCachedConvexTrianglePillar(xi - 1, yi, true);
|
||
|
|
this.clearCachedConvexTrianglePillar(xi - 1, yi, false);
|
||
|
|
}
|
||
|
|
if (yi > 0) {
|
||
|
|
this.clearCachedConvexTrianglePillar(xi, yi - 1, true);
|
||
|
|
this.clearCachedConvexTrianglePillar(xi, yi - 1, false);
|
||
|
|
}
|
||
|
|
yi > 0 && xi > 0 && this.clearCachedConvexTrianglePillar(xi - 1, yi - 1, true);
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getRectMinMax = function(iMinX, iMinY, iMaxX, iMaxY, result) {
|
||
|
|
result = result || [];
|
||
|
|
var data = this.data, max = this.minValue;
|
||
|
|
for (var i = iMinX; i <= iMaxX; i++) for (var j = iMinY; j <= iMaxY; j++) {
|
||
|
|
var height = data[i][j];
|
||
|
|
height > max && (max = height);
|
||
|
|
}
|
||
|
|
result[0] = this.minValue;
|
||
|
|
result[1] = max;
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getIndexOfPosition = function(x, y, result, clamp) {
|
||
|
|
var w = this.elementSize;
|
||
|
|
var data = this.data;
|
||
|
|
var xi = Math.floor(x / w);
|
||
|
|
var yi = Math.floor(y / w);
|
||
|
|
result[0] = xi;
|
||
|
|
result[1] = yi;
|
||
|
|
if (clamp) {
|
||
|
|
xi < 0 && (xi = 0);
|
||
|
|
yi < 0 && (yi = 0);
|
||
|
|
xi >= data.length - 1 && (xi = data.length - 1);
|
||
|
|
yi >= data[0].length - 1 && (yi = data[0].length - 1);
|
||
|
|
}
|
||
|
|
if (xi < 0 || yi < 0 || xi >= data.length - 1 || yi >= data[0].length - 1) return false;
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
var getHeightAt_idx = [];
|
||
|
|
var getHeightAt_weights = new Vec3();
|
||
|
|
var getHeightAt_a = new Vec3();
|
||
|
|
var getHeightAt_b = new Vec3();
|
||
|
|
var getHeightAt_c = new Vec3();
|
||
|
|
Heightfield.prototype.getTriangleAt = function(x, y, edgeClamp, a, b, c) {
|
||
|
|
var idx = getHeightAt_idx;
|
||
|
|
this.getIndexOfPosition(x, y, idx, edgeClamp);
|
||
|
|
var xi = idx[0];
|
||
|
|
var yi = idx[1];
|
||
|
|
var data = this.data;
|
||
|
|
if (edgeClamp) {
|
||
|
|
xi = Math.min(data.length - 2, Math.max(0, xi));
|
||
|
|
yi = Math.min(data[0].length - 2, Math.max(0, yi));
|
||
|
|
}
|
||
|
|
var elementSize = this.elementSize;
|
||
|
|
var lowerDist2 = Math.pow(x / elementSize - xi, 2) + Math.pow(y / elementSize - yi, 2);
|
||
|
|
var upperDist2 = Math.pow(x / elementSize - (xi + 1), 2) + Math.pow(y / elementSize - (yi + 1), 2);
|
||
|
|
var upper = lowerDist2 > upperDist2;
|
||
|
|
this.getTriangle(xi, yi, upper, a, b, c);
|
||
|
|
return upper;
|
||
|
|
};
|
||
|
|
var getNormalAt_a = new Vec3();
|
||
|
|
var getNormalAt_b = new Vec3();
|
||
|
|
var getNormalAt_c = new Vec3();
|
||
|
|
var getNormalAt_e0 = new Vec3();
|
||
|
|
var getNormalAt_e1 = new Vec3();
|
||
|
|
Heightfield.prototype.getNormalAt = function(x, y, edgeClamp, result) {
|
||
|
|
var a = getNormalAt_a;
|
||
|
|
var b = getNormalAt_b;
|
||
|
|
var c = getNormalAt_c;
|
||
|
|
var e0 = getNormalAt_e0;
|
||
|
|
var e1 = getNormalAt_e1;
|
||
|
|
this.getTriangleAt(x, y, edgeClamp, a, b, c);
|
||
|
|
b.vsub(a, e0);
|
||
|
|
c.vsub(a, e1);
|
||
|
|
e0.cross(e1, result);
|
||
|
|
result.normalize();
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getAabbAtIndex = function(xi, yi, result) {
|
||
|
|
var data = this.data;
|
||
|
|
var elementSize = this.elementSize;
|
||
|
|
result.lowerBound.set(xi * elementSize, yi * elementSize, data[xi][yi]);
|
||
|
|
result.upperBound.set((xi + 1) * elementSize, (yi + 1) * elementSize, data[xi + 1][yi + 1]);
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getHeightAt = function(x, y, edgeClamp) {
|
||
|
|
var data = this.data;
|
||
|
|
var a = getHeightAt_a;
|
||
|
|
var b = getHeightAt_b;
|
||
|
|
var c = getHeightAt_c;
|
||
|
|
var idx = getHeightAt_idx;
|
||
|
|
this.getIndexOfPosition(x, y, idx, edgeClamp);
|
||
|
|
var xi = idx[0];
|
||
|
|
var yi = idx[1];
|
||
|
|
if (edgeClamp) {
|
||
|
|
xi = Math.min(data.length - 2, Math.max(0, xi));
|
||
|
|
yi = Math.min(data[0].length - 2, Math.max(0, yi));
|
||
|
|
}
|
||
|
|
var upper = this.getTriangleAt(x, y, edgeClamp, a, b, c);
|
||
|
|
barycentricWeights(x, y, a.x, a.y, b.x, b.y, c.x, c.y, getHeightAt_weights);
|
||
|
|
var w = getHeightAt_weights;
|
||
|
|
return upper ? data[xi + 1][yi + 1] * w.x + data[xi][yi + 1] * w.y + data[xi + 1][yi] * w.z : data[xi][yi] * w.x + data[xi + 1][yi] * w.y + data[xi][yi + 1] * w.z;
|
||
|
|
};
|
||
|
|
function barycentricWeights(x, y, ax, ay, bx, by, cx, cy, result) {
|
||
|
|
result.x = ((by - cy) * (x - cx) + (cx - bx) * (y - cy)) / ((by - cy) * (ax - cx) + (cx - bx) * (ay - cy));
|
||
|
|
result.y = ((cy - ay) * (x - cx) + (ax - cx) * (y - cy)) / ((by - cy) * (ax - cx) + (cx - bx) * (ay - cy));
|
||
|
|
result.z = 1 - result.x - result.y;
|
||
|
|
}
|
||
|
|
Heightfield.prototype.getCacheConvexTrianglePillarKey = function(xi, yi, getUpperTriangle) {
|
||
|
|
return xi + "_" + yi + "_" + (getUpperTriangle ? 1 : 0);
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getCachedConvexTrianglePillar = function(xi, yi, getUpperTriangle) {
|
||
|
|
return this._cachedPillars[this.getCacheConvexTrianglePillarKey(xi, yi, getUpperTriangle)];
|
||
|
|
};
|
||
|
|
Heightfield.prototype.setCachedConvexTrianglePillar = function(xi, yi, getUpperTriangle, convex, offset) {
|
||
|
|
this._cachedPillars[this.getCacheConvexTrianglePillarKey(xi, yi, getUpperTriangle)] = {
|
||
|
|
convex: convex,
|
||
|
|
offset: offset
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Heightfield.prototype.clearCachedConvexTrianglePillar = function(xi, yi, getUpperTriangle) {
|
||
|
|
delete this._cachedPillars[this.getCacheConvexTrianglePillarKey(xi, yi, getUpperTriangle)];
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getTriangle = function(xi, yi, upper, a, b, c) {
|
||
|
|
var data = this.data;
|
||
|
|
var elementSize = this.elementSize;
|
||
|
|
if (upper) {
|
||
|
|
a.set((xi + 1) * elementSize, (yi + 1) * elementSize, data[xi + 1][yi + 1]);
|
||
|
|
b.set(xi * elementSize, (yi + 1) * elementSize, data[xi][yi + 1]);
|
||
|
|
c.set((xi + 1) * elementSize, yi * elementSize, data[xi + 1][yi]);
|
||
|
|
} else {
|
||
|
|
a.set(xi * elementSize, yi * elementSize, data[xi][yi]);
|
||
|
|
b.set((xi + 1) * elementSize, yi * elementSize, data[xi + 1][yi]);
|
||
|
|
c.set(xi * elementSize, (yi + 1) * elementSize, data[xi][yi + 1]);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Heightfield.prototype.getConvexTrianglePillar = function(xi, yi, getUpperTriangle) {
|
||
|
|
var result = this.pillarConvex;
|
||
|
|
var offsetResult = this.pillarOffset;
|
||
|
|
if (this.cacheEnabled) {
|
||
|
|
var data = this.getCachedConvexTrianglePillar(xi, yi, getUpperTriangle);
|
||
|
|
if (data) {
|
||
|
|
this.pillarConvex = data.convex;
|
||
|
|
this.pillarOffset = data.offset;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
result = new ConvexPolyhedron();
|
||
|
|
offsetResult = new Vec3();
|
||
|
|
this.pillarConvex = result;
|
||
|
|
this.pillarOffset = offsetResult;
|
||
|
|
}
|
||
|
|
var data = this.data;
|
||
|
|
var elementSize = this.elementSize;
|
||
|
|
var faces = result.faces;
|
||
|
|
result.vertices.length = 6;
|
||
|
|
for (var i = 0; i < 6; i++) result.vertices[i] || (result.vertices[i] = new Vec3());
|
||
|
|
faces.length = 5;
|
||
|
|
for (var i = 0; i < 5; i++) faces[i] || (faces[i] = []);
|
||
|
|
var verts = result.vertices;
|
||
|
|
var h = (Math.min(data[xi][yi], data[xi + 1][yi], data[xi][yi + 1], data[xi + 1][yi + 1]) - this.minValue) / 2 + this.minValue;
|
||
|
|
if (getUpperTriangle) {
|
||
|
|
offsetResult.set((xi + .75) * elementSize, (yi + .75) * elementSize, h);
|
||
|
|
verts[0].set(.25 * elementSize, .25 * elementSize, data[xi + 1][yi + 1] - h);
|
||
|
|
verts[1].set(-.75 * elementSize, .25 * elementSize, data[xi][yi + 1] - h);
|
||
|
|
verts[2].set(.25 * elementSize, -.75 * elementSize, data[xi + 1][yi] - h);
|
||
|
|
verts[3].set(.25 * elementSize, .25 * elementSize, -h - 1);
|
||
|
|
verts[4].set(-.75 * elementSize, .25 * elementSize, -h - 1);
|
||
|
|
verts[5].set(.25 * elementSize, -.75 * elementSize, -h - 1);
|
||
|
|
faces[0][0] = 0;
|
||
|
|
faces[0][1] = 1;
|
||
|
|
faces[0][2] = 2;
|
||
|
|
faces[1][0] = 5;
|
||
|
|
faces[1][1] = 4;
|
||
|
|
faces[1][2] = 3;
|
||
|
|
faces[2][0] = 2;
|
||
|
|
faces[2][1] = 5;
|
||
|
|
faces[2][2] = 3;
|
||
|
|
faces[2][3] = 0;
|
||
|
|
faces[3][0] = 3;
|
||
|
|
faces[3][1] = 4;
|
||
|
|
faces[3][2] = 1;
|
||
|
|
faces[3][3] = 0;
|
||
|
|
faces[4][0] = 1;
|
||
|
|
faces[4][1] = 4;
|
||
|
|
faces[4][2] = 5;
|
||
|
|
faces[4][3] = 2;
|
||
|
|
} else {
|
||
|
|
offsetResult.set((xi + .25) * elementSize, (yi + .25) * elementSize, h);
|
||
|
|
verts[0].set(-.25 * elementSize, -.25 * elementSize, data[xi][yi] - h);
|
||
|
|
verts[1].set(.75 * elementSize, -.25 * elementSize, data[xi + 1][yi] - h);
|
||
|
|
verts[2].set(-.25 * elementSize, .75 * elementSize, data[xi][yi + 1] - h);
|
||
|
|
verts[3].set(-.25 * elementSize, -.25 * elementSize, -h - 1);
|
||
|
|
verts[4].set(.75 * elementSize, -.25 * elementSize, -h - 1);
|
||
|
|
verts[5].set(-.25 * elementSize, .75 * elementSize, -h - 1);
|
||
|
|
faces[0][0] = 0;
|
||
|
|
faces[0][1] = 1;
|
||
|
|
faces[0][2] = 2;
|
||
|
|
faces[1][0] = 5;
|
||
|
|
faces[1][1] = 4;
|
||
|
|
faces[1][2] = 3;
|
||
|
|
faces[2][0] = 0;
|
||
|
|
faces[2][1] = 2;
|
||
|
|
faces[2][2] = 5;
|
||
|
|
faces[2][3] = 3;
|
||
|
|
faces[3][0] = 1;
|
||
|
|
faces[3][1] = 0;
|
||
|
|
faces[3][2] = 3;
|
||
|
|
faces[3][3] = 4;
|
||
|
|
faces[4][0] = 4;
|
||
|
|
faces[4][1] = 5;
|
||
|
|
faces[4][2] = 2;
|
||
|
|
faces[4][3] = 1;
|
||
|
|
}
|
||
|
|
result.computeNormals();
|
||
|
|
result.computeEdges();
|
||
|
|
result.updateBoundingSphereRadius();
|
||
|
|
this.setCachedConvexTrianglePillar(xi, yi, getUpperTriangle, result, offsetResult);
|
||
|
|
};
|
||
|
|
Heightfield.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
target.set(0, 0, 0);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Heightfield.prototype.volume = function() {
|
||
|
|
return Number.MAX_VALUE;
|
||
|
|
};
|
||
|
|
Heightfield.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
min.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
|
||
|
|
max.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
|
||
|
|
};
|
||
|
|
Heightfield.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
var data = this.data, s = this.elementSize;
|
||
|
|
this.boundingSphereRadius = new Vec3(data.length * s, data[0].length * s, Math.max(Math.abs(this.maxValue), Math.abs(this.minValue))).norm();
|
||
|
|
};
|
||
|
|
Heightfield.prototype.setHeightsFromImage = function(image, scale) {
|
||
|
|
var canvas = document.createElement("canvas");
|
||
|
|
canvas.width = image.width;
|
||
|
|
canvas.height = image.height;
|
||
|
|
var context = canvas.getContext("2d");
|
||
|
|
context.drawImage(image, 0, 0);
|
||
|
|
var imageData = context.getImageData(0, 0, image.width, image.height);
|
||
|
|
var matrix = this.data;
|
||
|
|
matrix.length = 0;
|
||
|
|
this.elementSize = Math.abs(scale.x) / imageData.width;
|
||
|
|
for (var i = 0; i < imageData.height; i++) {
|
||
|
|
var row = [];
|
||
|
|
for (var j = 0; j < imageData.width; j++) {
|
||
|
|
var a = imageData.data[4 * (i * imageData.height + j)];
|
||
|
|
var b = imageData.data[4 * (i * imageData.height + j) + 1];
|
||
|
|
var c = imageData.data[4 * (i * imageData.height + j) + 2];
|
||
|
|
var height = (a + b + c) / 4 / 255 * scale.z;
|
||
|
|
scale.x < 0 ? row.push(height) : row.unshift(height);
|
||
|
|
}
|
||
|
|
scale.y < 0 ? matrix.unshift(row) : matrix.push(row);
|
||
|
|
}
|
||
|
|
this.updateMaxValue();
|
||
|
|
this.updateMinValue();
|
||
|
|
this.update();
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../utils/Utils": 55,
|
||
|
|
"./ConvexPolyhedron": 40,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
43: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Particle;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function Particle() {
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.PARTICLE
|
||
|
|
});
|
||
|
|
}
|
||
|
|
Particle.prototype = new Shape();
|
||
|
|
Particle.prototype.constructor = Particle;
|
||
|
|
Particle.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
target.set(0, 0, 0);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Particle.prototype.volume = function() {
|
||
|
|
return 0;
|
||
|
|
};
|
||
|
|
Particle.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
this.boundingSphereRadius = 0;
|
||
|
|
};
|
||
|
|
Particle.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
min.copy(pos);
|
||
|
|
max.copy(pos);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
44: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Plane;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function Plane() {
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.PLANE
|
||
|
|
});
|
||
|
|
this.worldNormal = new Vec3();
|
||
|
|
this.worldNormalNeedsUpdate = true;
|
||
|
|
this.boundingSphereRadius = Number.MAX_VALUE;
|
||
|
|
}
|
||
|
|
Plane.prototype = new Shape();
|
||
|
|
Plane.prototype.constructor = Plane;
|
||
|
|
Plane.prototype.computeWorldNormal = function(quat) {
|
||
|
|
var n = this.worldNormal;
|
||
|
|
n.set(0, 0, 1);
|
||
|
|
quat.vmult(n, n);
|
||
|
|
this.worldNormalNeedsUpdate = false;
|
||
|
|
};
|
||
|
|
Plane.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Plane.prototype.volume = function() {
|
||
|
|
return Number.MAX_VALUE;
|
||
|
|
};
|
||
|
|
var tempNormal = new Vec3();
|
||
|
|
Plane.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
tempNormal.set(0, 0, 1);
|
||
|
|
quat.vmult(tempNormal, tempNormal);
|
||
|
|
var maxVal = Number.MAX_VALUE;
|
||
|
|
min.set(-maxVal, -maxVal, -maxVal);
|
||
|
|
max.set(maxVal, maxVal, maxVal);
|
||
|
|
1 === tempNormal.x && (max.x = pos.x);
|
||
|
|
1 === tempNormal.y && (max.y = pos.y);
|
||
|
|
1 === tempNormal.z && (max.z = pos.z);
|
||
|
|
-1 === tempNormal.x && (min.x = pos.x);
|
||
|
|
-1 === tempNormal.y && (min.y = pos.y);
|
||
|
|
-1 === tempNormal.z && (min.z = pos.z);
|
||
|
|
};
|
||
|
|
Plane.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
this.boundingSphereRadius = Number.MAX_VALUE;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
45: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Shape;
|
||
|
|
var EventTarget = _dereq_("../utils/EventTarget");
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Material = _dereq_("../material/Material");
|
||
|
|
function Shape(options) {
|
||
|
|
options = options || {};
|
||
|
|
EventTarget.apply(this);
|
||
|
|
this.id = Shape.idCounter++;
|
||
|
|
this.type = options.type || 0;
|
||
|
|
this.boundingSphereRadius = 0;
|
||
|
|
this.collisionResponse = !options.collisionResponse || options.collisionResponse;
|
||
|
|
this.collisionFilterGroup = void 0 !== options.collisionFilterGroup ? options.collisionFilterGroup : 1;
|
||
|
|
this.collisionFilterMask = void 0 !== options.collisionFilterMask ? options.collisionFilterMask : -1;
|
||
|
|
this.material = options.material ? options.material : null;
|
||
|
|
this.body = null;
|
||
|
|
}
|
||
|
|
Shape.prototype = new EventTarget();
|
||
|
|
Shape.prototype.constructor = Shape;
|
||
|
|
Shape.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
throw "computeBoundingSphereRadius() not implemented for shape type " + this.type;
|
||
|
|
};
|
||
|
|
Shape.prototype.volume = function() {
|
||
|
|
throw "volume() not implemented for shape type " + this.type;
|
||
|
|
};
|
||
|
|
Shape.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
throw "calculateLocalInertia() not implemented for shape type " + this.type;
|
||
|
|
};
|
||
|
|
Shape.idCounter = 0;
|
||
|
|
Shape.types = {
|
||
|
|
SPHERE: 1,
|
||
|
|
PLANE: 2,
|
||
|
|
BOX: 4,
|
||
|
|
COMPOUND: 8,
|
||
|
|
CONVEXPOLYHEDRON: 16,
|
||
|
|
HEIGHTFIELD: 32,
|
||
|
|
PARTICLE: 64,
|
||
|
|
CYLINDER: 128,
|
||
|
|
TRIMESH: 256
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../material/Material": 26,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../utils/EventTarget": 51,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
46: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Sphere;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
function Sphere(radius) {
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.SPHERE
|
||
|
|
});
|
||
|
|
this.radius = void 0 !== radius ? radius : 1;
|
||
|
|
if (this.radius < 0) throw new Error("The sphere radius cannot be negative.");
|
||
|
|
this.updateBoundingSphereRadius();
|
||
|
|
}
|
||
|
|
Sphere.prototype = new Shape();
|
||
|
|
Sphere.prototype.constructor = Sphere;
|
||
|
|
Sphere.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
target = target || new Vec3();
|
||
|
|
var I = 2 * mass * this.radius * this.radius / 5;
|
||
|
|
target.x = I;
|
||
|
|
target.y = I;
|
||
|
|
target.z = I;
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
Sphere.prototype.volume = function() {
|
||
|
|
return 4 * Math.PI * this.radius / 3;
|
||
|
|
};
|
||
|
|
Sphere.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
this.boundingSphereRadius = this.radius;
|
||
|
|
};
|
||
|
|
Sphere.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
var r = this.radius;
|
||
|
|
var axes = [ "x", "y", "z" ];
|
||
|
|
for (var i = 0; i < axes.length; i++) {
|
||
|
|
var ax = axes[i];
|
||
|
|
min[ax] = pos[ax] - r;
|
||
|
|
max[ax] = pos[ax] + r;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
47: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Trimesh;
|
||
|
|
var Shape = _dereq_("./Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Transform = _dereq_("../math/Transform");
|
||
|
|
var AABB = _dereq_("../collision/AABB");
|
||
|
|
var Octree = _dereq_("../utils/Octree");
|
||
|
|
var CMath = _dereq_("../math/CMath");
|
||
|
|
function Trimesh(vertices, indices) {
|
||
|
|
Shape.call(this, {
|
||
|
|
type: Shape.types.TRIMESH
|
||
|
|
});
|
||
|
|
this.vertices = new Float32Array(vertices);
|
||
|
|
this.indices = new Int16Array(indices);
|
||
|
|
this.normals = new Float32Array(indices.length);
|
||
|
|
this.aabb = new AABB();
|
||
|
|
this.edges = null;
|
||
|
|
this.scale = new Vec3(1, 1, 1);
|
||
|
|
this.tree = new Octree();
|
||
|
|
this.updateEdges();
|
||
|
|
this.updateNormals();
|
||
|
|
this.updateAABB();
|
||
|
|
this.updateBoundingSphereRadius();
|
||
|
|
this.updateTree();
|
||
|
|
}
|
||
|
|
Trimesh.prototype = new Shape();
|
||
|
|
Trimesh.prototype.constructor = Trimesh;
|
||
|
|
var computeNormals_n = new Vec3();
|
||
|
|
Trimesh.prototype.updateTree = function() {
|
||
|
|
var tree = this.tree;
|
||
|
|
tree.reset();
|
||
|
|
tree.aabb.copy(this.aabb);
|
||
|
|
var scale = this.scale;
|
||
|
|
tree.aabb.lowerBound.x *= 1 / scale.x;
|
||
|
|
tree.aabb.lowerBound.y *= 1 / scale.y;
|
||
|
|
tree.aabb.lowerBound.z *= 1 / scale.z;
|
||
|
|
tree.aabb.upperBound.x *= 1 / scale.x;
|
||
|
|
tree.aabb.upperBound.y *= 1 / scale.y;
|
||
|
|
tree.aabb.upperBound.z *= 1 / scale.z;
|
||
|
|
var triangleAABB = new AABB();
|
||
|
|
var a = new Vec3();
|
||
|
|
var b = new Vec3();
|
||
|
|
var c = new Vec3();
|
||
|
|
var points = [ a, b, c ];
|
||
|
|
for (var i = 0; i < this.indices.length / 3; i++) {
|
||
|
|
var i3 = 3 * i;
|
||
|
|
this._getUnscaledVertex(this.indices[i3], a);
|
||
|
|
this._getUnscaledVertex(this.indices[i3 + 1], b);
|
||
|
|
this._getUnscaledVertex(this.indices[i3 + 2], c);
|
||
|
|
triangleAABB.setFromPoints(points);
|
||
|
|
tree.insert(triangleAABB, i);
|
||
|
|
}
|
||
|
|
tree.removeEmptyNodes();
|
||
|
|
};
|
||
|
|
var unscaledAABB = new AABB();
|
||
|
|
Trimesh.prototype.getTrianglesInAABB = function(aabb, result) {
|
||
|
|
unscaledAABB.copy(aabb);
|
||
|
|
var scale = this.scale;
|
||
|
|
var isx = scale.x;
|
||
|
|
var isy = scale.y;
|
||
|
|
var isz = scale.z;
|
||
|
|
var l = unscaledAABB.lowerBound;
|
||
|
|
var u = unscaledAABB.upperBound;
|
||
|
|
l.x /= isx;
|
||
|
|
l.y /= isy;
|
||
|
|
l.z /= isz;
|
||
|
|
u.x /= isx;
|
||
|
|
u.y /= isy;
|
||
|
|
u.z /= isz;
|
||
|
|
return this.tree.aabbQuery(unscaledAABB, result);
|
||
|
|
};
|
||
|
|
Trimesh.prototype.setScale = function(scale) {
|
||
|
|
var wasUniform = this.scale.x === this.scale.y === this.scale.z;
|
||
|
|
var isUniform = scale.x === scale.y === scale.z;
|
||
|
|
wasUniform && isUniform || this.updateNormals();
|
||
|
|
this.scale.copy(scale);
|
||
|
|
this.updateAABB();
|
||
|
|
this.updateBoundingSphereRadius();
|
||
|
|
};
|
||
|
|
Trimesh.prototype.updateNormals = function() {
|
||
|
|
var n = computeNormals_n;
|
||
|
|
var normals = this.normals;
|
||
|
|
for (var i = 0; i < this.indices.length / 3; i++) {
|
||
|
|
var i3 = 3 * i;
|
||
|
|
var a = this.indices[i3], b = this.indices[i3 + 1], c = this.indices[i3 + 2];
|
||
|
|
this.getVertex(a, va);
|
||
|
|
this.getVertex(b, vb);
|
||
|
|
this.getVertex(c, vc);
|
||
|
|
Trimesh.computeNormal(vb, va, vc, n);
|
||
|
|
normals[i3] = n.x;
|
||
|
|
normals[i3 + 1] = n.y;
|
||
|
|
normals[i3 + 2] = n.z;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Trimesh.prototype.updateEdges = function() {
|
||
|
|
var edges = {};
|
||
|
|
var add = function add(indexA, indexB) {
|
||
|
|
var key = a < b ? a + "_" + b : b + "_" + a;
|
||
|
|
edges[key] = true;
|
||
|
|
};
|
||
|
|
for (var i = 0; i < this.indices.length / 3; i++) {
|
||
|
|
var i3 = 3 * i;
|
||
|
|
var a = this.indices[i3], b = this.indices[i3 + 1], c = this.indices[i3 + 2];
|
||
|
|
add(a, b);
|
||
|
|
add(b, c);
|
||
|
|
add(c, a);
|
||
|
|
}
|
||
|
|
var keys = Object.keys(edges);
|
||
|
|
this.edges = new Int16Array(2 * keys.length);
|
||
|
|
for (var i = 0; i < keys.length; i++) {
|
||
|
|
var indices = keys[i].split("_");
|
||
|
|
this.edges[2 * i] = parseInt(indices[0], 10);
|
||
|
|
this.edges[2 * i + 1] = parseInt(indices[1], 10);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Trimesh.prototype.getEdgeVertex = function(edgeIndex, firstOrSecond, vertexStore) {
|
||
|
|
var vertexIndex = this.edges[2 * edgeIndex + (firstOrSecond ? 1 : 0)];
|
||
|
|
this.getVertex(vertexIndex, vertexStore);
|
||
|
|
};
|
||
|
|
var getEdgeVector_va = new Vec3();
|
||
|
|
var getEdgeVector_vb = new Vec3();
|
||
|
|
Trimesh.prototype.getEdgeVector = function(edgeIndex, vectorStore) {
|
||
|
|
var va = getEdgeVector_va;
|
||
|
|
var vb = getEdgeVector_vb;
|
||
|
|
this.getEdgeVertex(edgeIndex, 0, va);
|
||
|
|
this.getEdgeVertex(edgeIndex, 1, vb);
|
||
|
|
vb.vsub(va, vectorStore);
|
||
|
|
};
|
||
|
|
var cb = new Vec3();
|
||
|
|
var ab = new Vec3();
|
||
|
|
Trimesh.computeNormal = function(va, vb, vc, target) {
|
||
|
|
vb.vsub(va, ab);
|
||
|
|
vc.vsub(vb, cb);
|
||
|
|
cb.cross(ab, target);
|
||
|
|
target.isZero() || target.normalize();
|
||
|
|
};
|
||
|
|
var va = new Vec3();
|
||
|
|
var vb = new Vec3();
|
||
|
|
var vc = new Vec3();
|
||
|
|
Trimesh.prototype.getVertex = function(i, out) {
|
||
|
|
var scale = this.scale;
|
||
|
|
this._getUnscaledVertex(i, out);
|
||
|
|
out.x *= scale.x;
|
||
|
|
out.y *= scale.y;
|
||
|
|
out.z *= scale.z;
|
||
|
|
return out;
|
||
|
|
};
|
||
|
|
Trimesh.prototype._getUnscaledVertex = function(i, out) {
|
||
|
|
var i3 = 3 * i;
|
||
|
|
var vertices = this.vertices;
|
||
|
|
return out.set(vertices[i3], vertices[i3 + 1], vertices[i3 + 2]);
|
||
|
|
};
|
||
|
|
Trimesh.prototype.getWorldVertex = function(i, pos, quat, out) {
|
||
|
|
this.getVertex(i, out);
|
||
|
|
Transform.pointToWorldFrame(pos, quat, out, out);
|
||
|
|
return out;
|
||
|
|
};
|
||
|
|
Trimesh.prototype.getTriangleVertices = function(i, a, b, c) {
|
||
|
|
var i3 = 3 * i;
|
||
|
|
this.getVertex(this.indices[i3], a);
|
||
|
|
this.getVertex(this.indices[i3 + 1], b);
|
||
|
|
this.getVertex(this.indices[i3 + 2], c);
|
||
|
|
};
|
||
|
|
Trimesh.prototype.getNormal = function(i, target) {
|
||
|
|
var i3 = 3 * i;
|
||
|
|
return target.set(this.normals[i3], this.normals[i3 + 1], this.normals[i3 + 2]);
|
||
|
|
};
|
||
|
|
var cli_aabb = new AABB();
|
||
|
|
Trimesh.prototype.calculateLocalInertia = function(mass, target) {
|
||
|
|
this.computeLocalAABB(cli_aabb);
|
||
|
|
var x = cli_aabb.upperBound.x - cli_aabb.lowerBound.x, y = cli_aabb.upperBound.y - cli_aabb.lowerBound.y, z = cli_aabb.upperBound.z - cli_aabb.lowerBound.z;
|
||
|
|
return target.set(1 / 12 * mass * (2 * y * 2 * y + 2 * z * 2 * z), 1 / 12 * mass * (2 * x * 2 * x + 2 * z * 2 * z), 1 / 12 * mass * (2 * y * 2 * y + 2 * x * 2 * x));
|
||
|
|
};
|
||
|
|
var computeLocalAABB_worldVert = new Vec3();
|
||
|
|
Trimesh.prototype.computeLocalAABB = function(aabb) {
|
||
|
|
var l = aabb.lowerBound, u = aabb.upperBound, n = this.vertices.length, vertices = this.vertices, v = computeLocalAABB_worldVert;
|
||
|
|
this.getVertex(0, v);
|
||
|
|
l.copy(v);
|
||
|
|
u.copy(v);
|
||
|
|
for (var i = 0; i !== n; i++) {
|
||
|
|
this.getVertex(i, v);
|
||
|
|
v.x < l.x ? l.x = v.x : v.x > u.x && (u.x = v.x);
|
||
|
|
v.y < l.y ? l.y = v.y : v.y > u.y && (u.y = v.y);
|
||
|
|
v.z < l.z ? l.z = v.z : v.z > u.z && (u.z = v.z);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Trimesh.prototype.updateAABB = function() {
|
||
|
|
this.computeLocalAABB(this.aabb);
|
||
|
|
};
|
||
|
|
Trimesh.prototype.updateBoundingSphereRadius = function() {
|
||
|
|
var max2 = 0;
|
||
|
|
var vertices = this.vertices;
|
||
|
|
var v = new Vec3();
|
||
|
|
for (var i = 0, N = vertices.length / 3; i !== N; i++) {
|
||
|
|
this.getVertex(i, v);
|
||
|
|
var norm2 = v.norm2();
|
||
|
|
norm2 > max2 && (max2 = norm2);
|
||
|
|
}
|
||
|
|
this.boundingSphereRadius = Math.sqrt(max2);
|
||
|
|
};
|
||
|
|
var tempWorldVertex = new Vec3();
|
||
|
|
var calculateWorldAABB_frame = new Transform();
|
||
|
|
var calculateWorldAABB_aabb = new AABB();
|
||
|
|
Trimesh.prototype.calculateWorldAABB = function(pos, quat, min, max) {
|
||
|
|
var frame = calculateWorldAABB_frame;
|
||
|
|
var result = calculateWorldAABB_aabb;
|
||
|
|
frame.position = pos;
|
||
|
|
frame.quaternion = quat;
|
||
|
|
this.aabb.toWorldFrame(frame, result);
|
||
|
|
min.copy(result.lowerBound);
|
||
|
|
max.copy(result.upperBound);
|
||
|
|
};
|
||
|
|
Trimesh.prototype.volume = function() {
|
||
|
|
return 4 * Math.PI * this.boundingSphereRadius / 3;
|
||
|
|
};
|
||
|
|
Trimesh.createTorus = function(radius, tube, radialSegments, tubularSegments, arc) {
|
||
|
|
radius = radius || 1;
|
||
|
|
tube = tube || .5;
|
||
|
|
radialSegments = radialSegments || 8;
|
||
|
|
tubularSegments = tubularSegments || 6;
|
||
|
|
arc = arc || 2 * Math.PI;
|
||
|
|
var vertices = [];
|
||
|
|
var indices = [];
|
||
|
|
for (var j = 0; j <= radialSegments; j++) for (var i = 0; i <= tubularSegments; i++) {
|
||
|
|
var u = i / tubularSegments * arc;
|
||
|
|
var v = j / radialSegments * Math.PI * 2;
|
||
|
|
var x = (radius + tube * CMath.cos(v)) * CMath.cos(u);
|
||
|
|
var y = (radius + tube * CMath.cos(v)) * CMath.sin(u);
|
||
|
|
var z = tube * CMath.sin(v);
|
||
|
|
vertices.push(x, y, z);
|
||
|
|
}
|
||
|
|
for (var j = 1; j <= radialSegments; j++) for (var i = 1; i <= tubularSegments; i++) {
|
||
|
|
var a = (tubularSegments + 1) * j + i - 1;
|
||
|
|
var b = (tubularSegments + 1) * (j - 1) + i - 1;
|
||
|
|
var c = (tubularSegments + 1) * (j - 1) + i;
|
||
|
|
var d = (tubularSegments + 1) * j + i;
|
||
|
|
indices.push(a, b, d);
|
||
|
|
indices.push(b, c, d);
|
||
|
|
}
|
||
|
|
return new Trimesh(vertices, indices);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/AABB": 3,
|
||
|
|
"../math/CMath": 27,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Transform": 31,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../utils/Octree": 52,
|
||
|
|
"./Shape": 45
|
||
|
|
} ],
|
||
|
|
48: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = GSSolver;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Solver = _dereq_("./Solver");
|
||
|
|
function GSSolver() {
|
||
|
|
Solver.call(this);
|
||
|
|
this.iterations = 10;
|
||
|
|
this.tolerance = 1e-7;
|
||
|
|
}
|
||
|
|
GSSolver.prototype = new Solver();
|
||
|
|
var GSSolver_solve_lambda = [];
|
||
|
|
var GSSolver_solve_invCs = [];
|
||
|
|
var GSSolver_solve_Bs = [];
|
||
|
|
GSSolver.prototype.solve = function(dt, world) {
|
||
|
|
var iter = 0, maxIter = this.iterations, tolSquared = this.tolerance * this.tolerance, equations = this.equations, Neq = equations.length, bodies = world.bodies, Nbodies = bodies.length, h = dt, q, B, invC, deltalambda, deltalambdaTot, GWlambda, lambdaj;
|
||
|
|
if (0 !== Neq) for (var i = 0; i !== Nbodies; i++) bodies[i].updateSolveMassProperties();
|
||
|
|
var invCs = GSSolver_solve_invCs, Bs = GSSolver_solve_Bs, lambda = GSSolver_solve_lambda;
|
||
|
|
invCs.length = Neq;
|
||
|
|
Bs.length = Neq;
|
||
|
|
lambda.length = Neq;
|
||
|
|
for (var i = 0; i !== Neq; i++) {
|
||
|
|
var c = equations[i];
|
||
|
|
lambda[i] = 0;
|
||
|
|
Bs[i] = c.computeB(h);
|
||
|
|
invCs[i] = 1 / c.computeC();
|
||
|
|
}
|
||
|
|
if (0 !== Neq) {
|
||
|
|
for (var i = 0; i !== Nbodies; i++) {
|
||
|
|
var b = bodies[i], vlambda = b.vlambda, wlambda = b.wlambda;
|
||
|
|
vlambda.set(0, 0, 0);
|
||
|
|
wlambda.set(0, 0, 0);
|
||
|
|
}
|
||
|
|
for (iter = 0; iter !== maxIter; iter++) {
|
||
|
|
deltalambdaTot = 0;
|
||
|
|
for (var j = 0; j !== Neq; j++) {
|
||
|
|
var c = equations[j];
|
||
|
|
B = Bs[j];
|
||
|
|
invC = invCs[j];
|
||
|
|
lambdaj = lambda[j];
|
||
|
|
GWlambda = c.computeGWlambda();
|
||
|
|
deltalambda = invC * (B - GWlambda - c.eps * lambdaj);
|
||
|
|
lambdaj + deltalambda < c.minForce ? deltalambda = c.minForce - lambdaj : lambdaj + deltalambda > c.maxForce && (deltalambda = c.maxForce - lambdaj);
|
||
|
|
lambda[j] += deltalambda;
|
||
|
|
deltalambdaTot += deltalambda > 0 ? deltalambda : -deltalambda;
|
||
|
|
c.addToWlambda(deltalambda);
|
||
|
|
}
|
||
|
|
if (deltalambdaTot * deltalambdaTot < tolSquared) break;
|
||
|
|
}
|
||
|
|
for (var i = 0; i !== Nbodies; i++) {
|
||
|
|
var b = bodies[i], v = b.velocity, w = b.angularVelocity;
|
||
|
|
b.vlambda.vmul(b.linearFactor, b.vlambda);
|
||
|
|
v.vadd(b.vlambda, v);
|
||
|
|
b.wlambda.vmul(b.angularFactor, b.wlambda);
|
||
|
|
w.vadd(b.wlambda, w);
|
||
|
|
}
|
||
|
|
var l = equations.length;
|
||
|
|
var invDt = 1 / h;
|
||
|
|
while (l--) equations[l].multiplier = lambda[l] * invDt;
|
||
|
|
}
|
||
|
|
return iter;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Solver": 49
|
||
|
|
} ],
|
||
|
|
49: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Solver;
|
||
|
|
function Solver() {
|
||
|
|
this.equations = [];
|
||
|
|
}
|
||
|
|
Solver.prototype.solve = function(dt, world) {
|
||
|
|
return 0;
|
||
|
|
};
|
||
|
|
Solver.prototype.addEquation = function(eq) {
|
||
|
|
eq.enabled && this.equations.push(eq);
|
||
|
|
};
|
||
|
|
Solver.prototype.removeEquation = function(eq) {
|
||
|
|
var eqs = this.equations;
|
||
|
|
var i = eqs.indexOf(eq);
|
||
|
|
-1 !== i && eqs.splice(i, 1);
|
||
|
|
};
|
||
|
|
Solver.prototype.removeAllEquations = function() {
|
||
|
|
this.equations.length = 0;
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
50: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = SplitSolver;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Solver = _dereq_("./Solver");
|
||
|
|
var Body = _dereq_("../objects/Body");
|
||
|
|
function SplitSolver(subsolver) {
|
||
|
|
Solver.call(this);
|
||
|
|
this.iterations = 10;
|
||
|
|
this.tolerance = 1e-7;
|
||
|
|
this.subsolver = subsolver;
|
||
|
|
this.nodes = [];
|
||
|
|
this.nodePool = [];
|
||
|
|
while (this.nodePool.length < 128) this.nodePool.push(this.createNode());
|
||
|
|
}
|
||
|
|
SplitSolver.prototype = new Solver();
|
||
|
|
var SplitSolver_solve_nodes = [];
|
||
|
|
var SplitSolver_solve_nodePool = [];
|
||
|
|
var SplitSolver_solve_eqs = [];
|
||
|
|
var SplitSolver_solve_bds = [];
|
||
|
|
var SplitSolver_solve_dummyWorld = {
|
||
|
|
bodies: []
|
||
|
|
};
|
||
|
|
var STATIC = Body.STATIC;
|
||
|
|
function getUnvisitedNode(nodes) {
|
||
|
|
var Nnodes = nodes.length;
|
||
|
|
for (var i = 0; i !== Nnodes; i++) {
|
||
|
|
var node = nodes[i];
|
||
|
|
if (!node.visited && !(node.body.type & STATIC)) return node;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var queue = [];
|
||
|
|
function bfs(root, visitFunc, bds, eqs) {
|
||
|
|
queue.push(root);
|
||
|
|
root.visited = true;
|
||
|
|
visitFunc(root, bds, eqs);
|
||
|
|
while (queue.length) {
|
||
|
|
var node = queue.pop();
|
||
|
|
var child;
|
||
|
|
while (child = getUnvisitedNode(node.children)) {
|
||
|
|
child.visited = true;
|
||
|
|
visitFunc(child, bds, eqs);
|
||
|
|
queue.push(child);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function visitFunc(node, bds, eqs) {
|
||
|
|
bds.push(node.body);
|
||
|
|
var Neqs = node.eqs.length;
|
||
|
|
for (var i = 0; i !== Neqs; i++) {
|
||
|
|
var eq = node.eqs[i];
|
||
|
|
-1 === eqs.indexOf(eq) && eqs.push(eq);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
SplitSolver.prototype.createNode = function() {
|
||
|
|
return {
|
||
|
|
body: null,
|
||
|
|
children: [],
|
||
|
|
eqs: [],
|
||
|
|
visited: false
|
||
|
|
};
|
||
|
|
};
|
||
|
|
SplitSolver.prototype.solve = function(dt, world) {
|
||
|
|
var nodes = SplitSolver_solve_nodes, nodePool = this.nodePool, bodies = world.bodies, equations = this.equations, Neq = equations.length, Nbodies = bodies.length, subsolver = this.subsolver;
|
||
|
|
while (nodePool.length < Nbodies) nodePool.push(this.createNode());
|
||
|
|
nodes.length = Nbodies;
|
||
|
|
for (var i = 0; i < Nbodies; i++) nodes[i] = nodePool[i];
|
||
|
|
for (var i = 0; i !== Nbodies; i++) {
|
||
|
|
var node = nodes[i];
|
||
|
|
node.body = bodies[i];
|
||
|
|
node.children.length = 0;
|
||
|
|
node.eqs.length = 0;
|
||
|
|
node.visited = false;
|
||
|
|
}
|
||
|
|
for (var k = 0; k !== Neq; k++) {
|
||
|
|
var eq = equations[k], i = bodies.indexOf(eq.bi), j = bodies.indexOf(eq.bj), ni = nodes[i], nj = nodes[j];
|
||
|
|
ni.children.push(nj);
|
||
|
|
ni.eqs.push(eq);
|
||
|
|
nj.children.push(ni);
|
||
|
|
nj.eqs.push(eq);
|
||
|
|
}
|
||
|
|
var child, n = 0, eqs = SplitSolver_solve_eqs;
|
||
|
|
subsolver.tolerance = this.tolerance;
|
||
|
|
subsolver.iterations = this.iterations;
|
||
|
|
var dummyWorld = SplitSolver_solve_dummyWorld;
|
||
|
|
while (child = getUnvisitedNode(nodes)) {
|
||
|
|
eqs.length = 0;
|
||
|
|
dummyWorld.bodies.length = 0;
|
||
|
|
bfs(child, visitFunc, dummyWorld.bodies, eqs);
|
||
|
|
var Neqs = eqs.length;
|
||
|
|
eqs = eqs.sort(sortById);
|
||
|
|
for (var i = 0; i !== Neqs; i++) subsolver.addEquation(eqs[i]);
|
||
|
|
var iter = subsolver.solve(dt, dummyWorld);
|
||
|
|
subsolver.removeAllEquations();
|
||
|
|
n++;
|
||
|
|
}
|
||
|
|
return n;
|
||
|
|
};
|
||
|
|
function sortById(a, b) {
|
||
|
|
return b.id - a.id;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../objects/Body": 33,
|
||
|
|
"./Solver": 49
|
||
|
|
} ],
|
||
|
|
51: [ function(_dereq_, module, exports) {
|
||
|
|
var EventTarget = function EventTarget() {};
|
||
|
|
module.exports = EventTarget;
|
||
|
|
EventTarget.prototype = {
|
||
|
|
constructor: EventTarget,
|
||
|
|
addEventListener: function addEventListener(type, listener) {
|
||
|
|
void 0 === this._listeners && (this._listeners = {});
|
||
|
|
var listeners = this._listeners;
|
||
|
|
void 0 === listeners[type] && (listeners[type] = []);
|
||
|
|
-1 === listeners[type].indexOf(listener) && listeners[type].push(listener);
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
hasEventListener: function hasEventListener(type, listener) {
|
||
|
|
if (void 0 === this._listeners) return false;
|
||
|
|
var listeners = this._listeners;
|
||
|
|
if (void 0 !== listeners[type] && -1 !== listeners[type].indexOf(listener)) return true;
|
||
|
|
return false;
|
||
|
|
},
|
||
|
|
hasAnyEventListener: function hasAnyEventListener(type) {
|
||
|
|
if (void 0 === this._listeners) return false;
|
||
|
|
var listeners = this._listeners;
|
||
|
|
return void 0 !== listeners[type];
|
||
|
|
},
|
||
|
|
removeEventListener: function removeEventListener(type, listener) {
|
||
|
|
if (void 0 === this._listeners) return this;
|
||
|
|
var listeners = this._listeners;
|
||
|
|
if (void 0 === listeners[type]) return this;
|
||
|
|
var index = listeners[type].indexOf(listener);
|
||
|
|
-1 !== index && listeners[type].splice(index, 1);
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
dispatchEvent: function dispatchEvent(event) {
|
||
|
|
if (void 0 === this._listeners) return this;
|
||
|
|
var listeners = this._listeners;
|
||
|
|
var listenerArray = listeners[event.type];
|
||
|
|
if (void 0 !== listenerArray) {
|
||
|
|
event.target = this;
|
||
|
|
for (var i = 0, l = listenerArray.length; i < l; i++) listenerArray[i].call(this, event);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
52: [ function(_dereq_, module, exports) {
|
||
|
|
var AABB = _dereq_("../collision/AABB");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
module.exports = Octree;
|
||
|
|
function OctreeNode(options) {
|
||
|
|
options = options || {};
|
||
|
|
this.root = options.root || null;
|
||
|
|
this.aabb = options.aabb ? options.aabb.clone() : new AABB();
|
||
|
|
this.data = [];
|
||
|
|
this.children = [];
|
||
|
|
}
|
||
|
|
function Octree(aabb, options) {
|
||
|
|
options = options || {};
|
||
|
|
options.root = null;
|
||
|
|
options.aabb = aabb;
|
||
|
|
OctreeNode.call(this, options);
|
||
|
|
this.maxDepth = "undefined" !== typeof options.maxDepth ? options.maxDepth : 8;
|
||
|
|
}
|
||
|
|
Octree.prototype = new OctreeNode();
|
||
|
|
OctreeNode.prototype.reset = function(aabb, options) {
|
||
|
|
this.children.length = this.data.length = 0;
|
||
|
|
};
|
||
|
|
OctreeNode.prototype.insert = function(aabb, elementData, level) {
|
||
|
|
var nodeData = this.data;
|
||
|
|
level = level || 0;
|
||
|
|
if (!this.aabb.contains(aabb)) return false;
|
||
|
|
var children = this.children;
|
||
|
|
if (level < (this.maxDepth || this.root.maxDepth)) {
|
||
|
|
var subdivided = false;
|
||
|
|
if (!children.length) {
|
||
|
|
this.subdivide();
|
||
|
|
subdivided = true;
|
||
|
|
}
|
||
|
|
for (var i = 0; 8 !== i; i++) if (children[i].insert(aabb, elementData, level + 1)) return true;
|
||
|
|
subdivided && (children.length = 0);
|
||
|
|
}
|
||
|
|
nodeData.push(elementData);
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
var halfDiagonal = new Vec3();
|
||
|
|
OctreeNode.prototype.subdivide = function() {
|
||
|
|
var aabb = this.aabb;
|
||
|
|
var l = aabb.lowerBound;
|
||
|
|
var u = aabb.upperBound;
|
||
|
|
var children = this.children;
|
||
|
|
children.push(new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(0, 0, 0)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(1, 0, 0)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(1, 1, 0)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(1, 1, 1)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(0, 1, 1)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(0, 0, 1)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(1, 0, 1)
|
||
|
|
})
|
||
|
|
}), new OctreeNode({
|
||
|
|
aabb: new AABB({
|
||
|
|
lowerBound: new Vec3(0, 1, 0)
|
||
|
|
})
|
||
|
|
}));
|
||
|
|
u.vsub(l, halfDiagonal);
|
||
|
|
halfDiagonal.scale(.5, halfDiagonal);
|
||
|
|
var root = this.root || this;
|
||
|
|
for (var i = 0; 8 !== i; i++) {
|
||
|
|
var child = children[i];
|
||
|
|
child.root = root;
|
||
|
|
var lowerBound = child.aabb.lowerBound;
|
||
|
|
lowerBound.x *= halfDiagonal.x;
|
||
|
|
lowerBound.y *= halfDiagonal.y;
|
||
|
|
lowerBound.z *= halfDiagonal.z;
|
||
|
|
lowerBound.vadd(l, lowerBound);
|
||
|
|
lowerBound.vadd(halfDiagonal, child.aabb.upperBound);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
OctreeNode.prototype.aabbQuery = function(aabb, result) {
|
||
|
|
var nodeData = this.data;
|
||
|
|
var children = this.children;
|
||
|
|
var queue = [ this ];
|
||
|
|
while (queue.length) {
|
||
|
|
var node = queue.pop();
|
||
|
|
node.aabb.overlaps(aabb) && Array.prototype.push.apply(result, node.data);
|
||
|
|
Array.prototype.push.apply(queue, node.children);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var tmpAABB = new AABB();
|
||
|
|
OctreeNode.prototype.rayQuery = function(ray, treeTransform, result) {
|
||
|
|
ray.getAABB(tmpAABB);
|
||
|
|
tmpAABB.toLocalFrame(treeTransform, tmpAABB);
|
||
|
|
this.aabbQuery(tmpAABB, result);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
OctreeNode.prototype.removeEmptyNodes = function() {
|
||
|
|
for (var i = this.children.length - 1; i >= 0; i--) {
|
||
|
|
this.children[i].removeEmptyNodes();
|
||
|
|
this.children[i].children.length || this.children[i].data.length || this.children.splice(i, 1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/AABB": 3,
|
||
|
|
"../math/Vec3": 32
|
||
|
|
} ],
|
||
|
|
53: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Pool;
|
||
|
|
function Pool() {
|
||
|
|
this.objects = [];
|
||
|
|
this.type = Object;
|
||
|
|
}
|
||
|
|
Pool.prototype.release = function() {
|
||
|
|
var Nargs = arguments.length;
|
||
|
|
for (var i = 0; i !== Nargs; i++) this.objects.push(arguments[i]);
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
Pool.prototype.get = function() {
|
||
|
|
return 0 === this.objects.length ? this.constructObject() : this.objects.pop();
|
||
|
|
};
|
||
|
|
Pool.prototype.constructObject = function() {
|
||
|
|
throw new Error("constructObject() not implemented in this Pool subclass yet!");
|
||
|
|
};
|
||
|
|
Pool.prototype.resize = function(size) {
|
||
|
|
var objects = this.objects;
|
||
|
|
while (objects.length > size) objects.pop();
|
||
|
|
while (objects.length < size) objects.push(this.constructObject());
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
54: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = TupleDictionary;
|
||
|
|
function TupleDictionary() {
|
||
|
|
this.data = {
|
||
|
|
keys: []
|
||
|
|
};
|
||
|
|
}
|
||
|
|
TupleDictionary.prototype.get = function(i, j) {
|
||
|
|
if (i > j) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
return this.data[i + "-" + j];
|
||
|
|
};
|
||
|
|
TupleDictionary.prototype.set = function(i, j, value) {
|
||
|
|
if (i > j) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
var key = i + "-" + j;
|
||
|
|
this.get(i, j) || this.data.keys.push(key);
|
||
|
|
this.data[key] = value;
|
||
|
|
return this.data[key];
|
||
|
|
};
|
||
|
|
TupleDictionary.prototype.del = function(i, j) {
|
||
|
|
if (i > j) {
|
||
|
|
var temp = j;
|
||
|
|
j = i;
|
||
|
|
i = temp;
|
||
|
|
}
|
||
|
|
var key = i + "-" + j;
|
||
|
|
var index = this.data.keys.indexOf(key);
|
||
|
|
if (index >= 0) {
|
||
|
|
this.data.keys.splice(index, 1);
|
||
|
|
delete this.data[key];
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
TupleDictionary.prototype.reset = function() {
|
||
|
|
this.data = {
|
||
|
|
keys: []
|
||
|
|
};
|
||
|
|
};
|
||
|
|
TupleDictionary.prototype.getLength = function() {
|
||
|
|
return this.data.keys.length;
|
||
|
|
};
|
||
|
|
TupleDictionary.prototype.getKeyByIndex = function(index) {
|
||
|
|
return this.data.keys[index];
|
||
|
|
};
|
||
|
|
TupleDictionary.prototype.getDataByKey = function(Key) {
|
||
|
|
return this.data[Key];
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
55: [ function(_dereq_, module, exports) {
|
||
|
|
function Utils() {}
|
||
|
|
module.exports = Utils;
|
||
|
|
Utils.defaults = function(options, defaults) {
|
||
|
|
options = options || {};
|
||
|
|
for (var key in defaults) key in options || (options[key] = defaults[key]);
|
||
|
|
return options;
|
||
|
|
};
|
||
|
|
}, {} ],
|
||
|
|
56: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Vec3Pool;
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Pool = _dereq_("./Pool");
|
||
|
|
function Vec3Pool() {
|
||
|
|
Pool.call(this);
|
||
|
|
this.type = Vec3;
|
||
|
|
}
|
||
|
|
Vec3Pool.prototype = new Pool();
|
||
|
|
Vec3Pool.prototype.constructObject = function() {
|
||
|
|
return new Vec3();
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"./Pool": 53
|
||
|
|
} ],
|
||
|
|
57: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = Narrowphase;
|
||
|
|
var AABB = _dereq_("../collision/AABB");
|
||
|
|
var Body = _dereq_("../objects/Body");
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var Ray = _dereq_("../collision/Ray");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Transform = _dereq_("../math/Transform");
|
||
|
|
var ConvexPolyhedron = _dereq_("../shapes/ConvexPolyhedron");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var Solver = _dereq_("../solver/Solver");
|
||
|
|
var Vec3Pool = _dereq_("../utils/Vec3Pool");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
var FrictionEquation = _dereq_("../equations/FrictionEquation");
|
||
|
|
function Narrowphase(world) {
|
||
|
|
this.contactPointPool = [];
|
||
|
|
this.frictionEquationPool = [];
|
||
|
|
this.result = [];
|
||
|
|
this.frictionResult = [];
|
||
|
|
this.v3pool = new Vec3Pool();
|
||
|
|
this.world = world;
|
||
|
|
this.currentContactMaterial = null;
|
||
|
|
this.enableFrictionReduction = false;
|
||
|
|
}
|
||
|
|
Narrowphase.prototype.createContactEquation = function(bi, bj, si, sj, overrideShapeA, overrideShapeB) {
|
||
|
|
var c;
|
||
|
|
if (this.contactPointPool.length) {
|
||
|
|
c = this.contactPointPool.pop();
|
||
|
|
c.bi = bi;
|
||
|
|
c.bj = bj;
|
||
|
|
} else c = new ContactEquation(bi, bj);
|
||
|
|
c.enabled = bi.collisionResponse && bj.collisionResponse && si.collisionResponse && sj.collisionResponse;
|
||
|
|
var cm = this.currentContactMaterial;
|
||
|
|
c.restitution = cm.restitution;
|
||
|
|
c.setSpookParams(cm.contactEquationStiffness, cm.contactEquationRelaxation, this.world.dt);
|
||
|
|
var matA = si.material || bi.material;
|
||
|
|
var matB = sj.material || bj.material;
|
||
|
|
matA && matB && matA.restitution >= 0 && matB.restitution >= 0 && (c.restitution = matA.restitution * matB.restitution);
|
||
|
|
c.si = overrideShapeA || si;
|
||
|
|
c.sj = overrideShapeB || sj;
|
||
|
|
return c;
|
||
|
|
};
|
||
|
|
Narrowphase.prototype.createFrictionEquationsFromContact = function(contactEquation, outArray) {
|
||
|
|
var bodyA = contactEquation.bi;
|
||
|
|
var bodyB = contactEquation.bj;
|
||
|
|
var shapeA = contactEquation.si;
|
||
|
|
var shapeB = contactEquation.sj;
|
||
|
|
var world = this.world;
|
||
|
|
var cm = this.currentContactMaterial;
|
||
|
|
var friction = cm.friction;
|
||
|
|
var matA = shapeA.material || bodyA.material;
|
||
|
|
var matB = shapeB.material || bodyB.material;
|
||
|
|
matA && matB && matA.friction >= 0 && matB.friction >= 0 && (friction = matA.friction * matB.friction);
|
||
|
|
if (friction > 0) {
|
||
|
|
var mug = friction * world.gravity.length();
|
||
|
|
var reducedMass = bodyA.invMass + bodyB.invMass;
|
||
|
|
reducedMass > 0 && (reducedMass = 1 / reducedMass);
|
||
|
|
var pool = this.frictionEquationPool;
|
||
|
|
var c1 = pool.length ? pool.pop() : new FrictionEquation(bodyA, bodyB, mug * reducedMass);
|
||
|
|
var c2 = pool.length ? pool.pop() : new FrictionEquation(bodyA, bodyB, mug * reducedMass);
|
||
|
|
c1.bi = c2.bi = bodyA;
|
||
|
|
c1.bj = c2.bj = bodyB;
|
||
|
|
c1.minForce = c2.minForce = -mug * reducedMass;
|
||
|
|
c1.maxForce = c2.maxForce = mug * reducedMass;
|
||
|
|
c1.ri.copy(contactEquation.ri);
|
||
|
|
c1.rj.copy(contactEquation.rj);
|
||
|
|
c2.ri.copy(contactEquation.ri);
|
||
|
|
c2.rj.copy(contactEquation.rj);
|
||
|
|
contactEquation.ni.tangents(c1.t, c2.t);
|
||
|
|
c1.setSpookParams(cm.frictionEquationStiffness, cm.frictionEquationRelaxation, world.dt);
|
||
|
|
c2.setSpookParams(cm.frictionEquationStiffness, cm.frictionEquationRelaxation, world.dt);
|
||
|
|
c1.enabled = c2.enabled = contactEquation.enabled;
|
||
|
|
outArray.push(c1, c2);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
var averageNormal = new Vec3();
|
||
|
|
var averageContactPointA = new Vec3();
|
||
|
|
var averageContactPointB = new Vec3();
|
||
|
|
Narrowphase.prototype.createFrictionFromAverage = function(numContacts) {
|
||
|
|
var c = this.result[this.result.length - 1];
|
||
|
|
if (!this.createFrictionEquationsFromContact(c, this.frictionResult) || 1 === numContacts) return;
|
||
|
|
var f1 = this.frictionResult[this.frictionResult.length - 2];
|
||
|
|
var f2 = this.frictionResult[this.frictionResult.length - 1];
|
||
|
|
averageNormal.setZero();
|
||
|
|
averageContactPointA.setZero();
|
||
|
|
averageContactPointB.setZero();
|
||
|
|
var bodyA = c.bi;
|
||
|
|
var bodyB = c.bj;
|
||
|
|
for (var i = 0; i !== numContacts; i++) {
|
||
|
|
c = this.result[this.result.length - 1 - i];
|
||
|
|
if (c.bodyA !== bodyA) {
|
||
|
|
averageNormal.vadd(c.ni, averageNormal);
|
||
|
|
averageContactPointA.vadd(c.ri, averageContactPointA);
|
||
|
|
averageContactPointB.vadd(c.rj, averageContactPointB);
|
||
|
|
} else {
|
||
|
|
averageNormal.vsub(c.ni, averageNormal);
|
||
|
|
averageContactPointA.vadd(c.rj, averageContactPointA);
|
||
|
|
averageContactPointB.vadd(c.ri, averageContactPointB);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var invNumContacts = 1 / numContacts;
|
||
|
|
averageContactPointA.scale(invNumContacts, f1.ri);
|
||
|
|
averageContactPointB.scale(invNumContacts, f1.rj);
|
||
|
|
f2.ri.copy(f1.ri);
|
||
|
|
f2.rj.copy(f1.rj);
|
||
|
|
averageNormal.normalize();
|
||
|
|
averageNormal.tangents(f1.t, f2.t);
|
||
|
|
};
|
||
|
|
var tmpVec1 = new Vec3();
|
||
|
|
var tmpVec2 = new Vec3();
|
||
|
|
var tmpQuat1 = new Quaternion();
|
||
|
|
var tmpQuat2 = new Quaternion();
|
||
|
|
Narrowphase.prototype.getContacts = function(p1, p2, world, result, oldcontacts, frictionResult, frictionPool) {
|
||
|
|
this.contactPointPool = oldcontacts;
|
||
|
|
this.frictionEquationPool = frictionPool;
|
||
|
|
this.result = result;
|
||
|
|
this.frictionResult = frictionResult;
|
||
|
|
var qi = tmpQuat1;
|
||
|
|
var qj = tmpQuat2;
|
||
|
|
var xi = tmpVec1;
|
||
|
|
var xj = tmpVec2;
|
||
|
|
for (var k = 0, N = p1.length; k !== N; k++) {
|
||
|
|
var bi = p1[k], bj = p2[k];
|
||
|
|
var bodyContactMaterial = null;
|
||
|
|
bi.material && bj.material && (bodyContactMaterial = world.getContactMaterial(bi.material, bj.material) || null);
|
||
|
|
var justTest = false == bi.collisionResponse || false == bj.collisionResponse || bi.type & Body.KINEMATIC && bj.type & Body.STATIC || bi.type & Body.STATIC && bj.type & Body.KINEMATIC || bi.type & Body.KINEMATIC && bj.type & Body.KINEMATIC;
|
||
|
|
for (var i = 0; i < bi.shapes.length; i++) {
|
||
|
|
bi.quaternion.mult(bi.shapeOrientations[i], qi);
|
||
|
|
bi.quaternion.vmult(bi.shapeOffsets[i], xi);
|
||
|
|
xi.vadd(bi.position, xi);
|
||
|
|
var si = bi.shapes[i];
|
||
|
|
for (var j = 0; j < bj.shapes.length; j++) {
|
||
|
|
bj.quaternion.mult(bj.shapeOrientations[j], qj);
|
||
|
|
bj.quaternion.vmult(bj.shapeOffsets[j], xj);
|
||
|
|
xj.vadd(bj.position, xj);
|
||
|
|
var sj = bj.shapes[j];
|
||
|
|
if (!(si.collisionFilterMask & sj.collisionFilterGroup && sj.collisionFilterMask & si.collisionFilterGroup)) continue;
|
||
|
|
if (xi.distanceTo(xj) > si.boundingSphereRadius + sj.boundingSphereRadius) continue;
|
||
|
|
justTest |= false == si.collisionResponse || false == sj.collisionResponse;
|
||
|
|
var shapeContactMaterial = null;
|
||
|
|
si.material && sj.material && (shapeContactMaterial = world.getContactMaterial(si.material, sj.material) || null);
|
||
|
|
this.currentContactMaterial = shapeContactMaterial || bodyContactMaterial || world.defaultContactMaterial;
|
||
|
|
var resolver = this[si.type | sj.type];
|
||
|
|
if (resolver) {
|
||
|
|
var retval = false;
|
||
|
|
retval = si.type < sj.type ? resolver.call(this, si, sj, xi, xj, qi, qj, bi, bj, si, sj, justTest) : resolver.call(this, sj, si, xj, xi, qj, qi, bj, bi, si, sj, justTest);
|
||
|
|
if (retval && justTest) {
|
||
|
|
world.shapeOverlapKeeper.set(si.id, sj.id);
|
||
|
|
world.bodyOverlapKeeper.set(bi.id, bj.id);
|
||
|
|
var data = {
|
||
|
|
si: si,
|
||
|
|
sj: sj
|
||
|
|
};
|
||
|
|
world.triggerDic.set(si.id, sj.id, data);
|
||
|
|
world.oldTriggerDic.set(si.id, sj.id, data);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var numWarnings = 0;
|
||
|
|
var maxWarnings = 10;
|
||
|
|
function warn(msg) {
|
||
|
|
if (numWarnings > maxWarnings) return;
|
||
|
|
numWarnings++;
|
||
|
|
console.warn(msg);
|
||
|
|
}
|
||
|
|
Narrowphase.prototype[Shape.types.BOX | Shape.types.BOX] = Narrowphase.prototype.boxBox = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
si.convexPolyhedronRepresentation.material = si.material;
|
||
|
|
sj.convexPolyhedronRepresentation.material = sj.material;
|
||
|
|
si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse;
|
||
|
|
sj.convexPolyhedronRepresentation.collisionResponse = sj.collisionResponse;
|
||
|
|
return this.convexConvex(si.convexPolyhedronRepresentation, sj.convexPolyhedronRepresentation, xi, xj, qi, qj, bi, bj, si, sj, justTest);
|
||
|
|
};
|
||
|
|
Narrowphase.prototype[Shape.types.BOX | Shape.types.CONVEXPOLYHEDRON] = Narrowphase.prototype.boxConvex = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
si.convexPolyhedronRepresentation.material = si.material;
|
||
|
|
si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse;
|
||
|
|
return this.convexConvex(si.convexPolyhedronRepresentation, sj, xi, xj, qi, qj, bi, bj, si, sj, justTest);
|
||
|
|
};
|
||
|
|
Narrowphase.prototype[Shape.types.BOX | Shape.types.PARTICLE] = Narrowphase.prototype.boxParticle = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
si.convexPolyhedronRepresentation.material = si.material;
|
||
|
|
si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse;
|
||
|
|
return this.convexParticle(si.convexPolyhedronRepresentation, sj, xi, xj, qi, qj, bi, bj, si, sj, justTest);
|
||
|
|
};
|
||
|
|
Narrowphase.prototype[Shape.types.SPHERE] = Narrowphase.prototype.sphereSphere = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
if (justTest) return xi.distanceSquared(xj) < Math.pow(si.radius + sj.radius, 2);
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
xj.vsub(xi, r.ni);
|
||
|
|
r.ni.normalize();
|
||
|
|
r.ri.copy(r.ni);
|
||
|
|
r.rj.copy(r.ni);
|
||
|
|
r.ri.mult(si.radius, r.ri);
|
||
|
|
r.rj.mult(-sj.radius, r.rj);
|
||
|
|
r.ri.vadd(xi, r.ri);
|
||
|
|
r.ri.vsub(bi.position, r.ri);
|
||
|
|
r.rj.vadd(xj, r.rj);
|
||
|
|
r.rj.vsub(bj.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
};
|
||
|
|
var planeTrimesh_normal = new Vec3();
|
||
|
|
var planeTrimesh_relpos = new Vec3();
|
||
|
|
var planeTrimesh_projected = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.PLANE | Shape.types.TRIMESH] = Narrowphase.prototype.planeTrimesh = function(planeShape, trimeshShape, planePos, trimeshPos, planeQuat, trimeshQuat, planeBody, trimeshBody, rsi, rsj, justTest) {
|
||
|
|
var v = new Vec3();
|
||
|
|
var normal = planeTrimesh_normal;
|
||
|
|
normal.set(0, 0, 1);
|
||
|
|
planeQuat.vmult(normal, normal);
|
||
|
|
for (var i = 0; i < trimeshShape.vertices.length / 3; i++) {
|
||
|
|
trimeshShape.getVertex(i, v);
|
||
|
|
var v2 = new Vec3();
|
||
|
|
v2.copy(v);
|
||
|
|
Transform.pointToWorldFrame(trimeshPos, trimeshQuat, v2, v);
|
||
|
|
var relpos = planeTrimesh_relpos;
|
||
|
|
v.vsub(planePos, relpos);
|
||
|
|
var dot = normal.dot(relpos);
|
||
|
|
if (dot <= 0) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(planeBody, trimeshBody, planeShape, trimeshShape, rsi, rsj);
|
||
|
|
r.ni.copy(normal);
|
||
|
|
var projected = planeTrimesh_projected;
|
||
|
|
normal.scale(relpos.dot(normal), projected);
|
||
|
|
v.vsub(projected, projected);
|
||
|
|
r.ri.copy(projected);
|
||
|
|
r.ri.vsub(planeBody.position, r.ri);
|
||
|
|
r.rj.copy(v);
|
||
|
|
r.rj.vsub(trimeshBody.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var sphereTrimesh_normal = new Vec3();
|
||
|
|
var sphereTrimesh_relpos = new Vec3();
|
||
|
|
var sphereTrimesh_projected = new Vec3();
|
||
|
|
var sphereTrimesh_v = new Vec3();
|
||
|
|
var sphereTrimesh_v2 = new Vec3();
|
||
|
|
var sphereTrimesh_edgeVertexA = new Vec3();
|
||
|
|
var sphereTrimesh_edgeVertexB = new Vec3();
|
||
|
|
var sphereTrimesh_edgeVector = new Vec3();
|
||
|
|
var sphereTrimesh_edgeVectorUnit = new Vec3();
|
||
|
|
var sphereTrimesh_localSpherePos = new Vec3();
|
||
|
|
var sphereTrimesh_tmp = new Vec3();
|
||
|
|
var sphereTrimesh_va = new Vec3();
|
||
|
|
var sphereTrimesh_vb = new Vec3();
|
||
|
|
var sphereTrimesh_vc = new Vec3();
|
||
|
|
var sphereTrimesh_localSphereAABB = new AABB();
|
||
|
|
var sphereTrimesh_triangles = [];
|
||
|
|
Narrowphase.prototype[Shape.types.SPHERE | Shape.types.TRIMESH] = Narrowphase.prototype.sphereTrimesh = function(sphereShape, trimeshShape, spherePos, trimeshPos, sphereQuat, trimeshQuat, sphereBody, trimeshBody, rsi, rsj, justTest) {
|
||
|
|
var edgeVertexA = sphereTrimesh_edgeVertexA;
|
||
|
|
var edgeVertexB = sphereTrimesh_edgeVertexB;
|
||
|
|
var edgeVector = sphereTrimesh_edgeVector;
|
||
|
|
var edgeVectorUnit = sphereTrimesh_edgeVectorUnit;
|
||
|
|
var localSpherePos = sphereTrimesh_localSpherePos;
|
||
|
|
var tmp = sphereTrimesh_tmp;
|
||
|
|
var localSphereAABB = sphereTrimesh_localSphereAABB;
|
||
|
|
var v2 = sphereTrimesh_v2;
|
||
|
|
var relpos = sphereTrimesh_relpos;
|
||
|
|
var triangles = sphereTrimesh_triangles;
|
||
|
|
Transform.pointToLocalFrame(trimeshPos, trimeshQuat, spherePos, localSpherePos);
|
||
|
|
var sphereRadius = sphereShape.radius;
|
||
|
|
localSphereAABB.lowerBound.set(localSpherePos.x - sphereRadius, localSpherePos.y - sphereRadius, localSpherePos.z - sphereRadius);
|
||
|
|
localSphereAABB.upperBound.set(localSpherePos.x + sphereRadius, localSpherePos.y + sphereRadius, localSpherePos.z + sphereRadius);
|
||
|
|
trimeshShape.getTrianglesInAABB(localSphereAABB, triangles);
|
||
|
|
var v = sphereTrimesh_v;
|
||
|
|
var radiusSquared = sphereShape.radius * sphereShape.radius;
|
||
|
|
for (var i = 0; i < triangles.length; i++) for (var j = 0; j < 3; j++) {
|
||
|
|
trimeshShape.getVertex(trimeshShape.indices[3 * triangles[i] + j], v);
|
||
|
|
v.vsub(localSpherePos, relpos);
|
||
|
|
if (relpos.norm2() <= radiusSquared) {
|
||
|
|
v2.copy(v);
|
||
|
|
Transform.pointToWorldFrame(trimeshPos, trimeshQuat, v2, v);
|
||
|
|
v.vsub(spherePos, relpos);
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(sphereBody, trimeshBody, sphereShape, trimeshShape, rsi, rsj);
|
||
|
|
r.ni.copy(relpos);
|
||
|
|
r.ni.normalize();
|
||
|
|
r.ri.copy(r.ni);
|
||
|
|
r.ri.scale(sphereShape.radius, r.ri);
|
||
|
|
r.ri.vadd(spherePos, r.ri);
|
||
|
|
r.ri.vsub(sphereBody.position, r.ri);
|
||
|
|
r.rj.copy(v);
|
||
|
|
r.rj.vsub(trimeshBody.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var i = 0; i < triangles.length; i++) for (var j = 0; j < 3; j++) {
|
||
|
|
trimeshShape.getVertex(trimeshShape.indices[3 * triangles[i] + j], edgeVertexA);
|
||
|
|
trimeshShape.getVertex(trimeshShape.indices[3 * triangles[i] + (j + 1) % 3], edgeVertexB);
|
||
|
|
edgeVertexB.vsub(edgeVertexA, edgeVector);
|
||
|
|
localSpherePos.vsub(edgeVertexB, tmp);
|
||
|
|
var positionAlongEdgeB = tmp.dot(edgeVector);
|
||
|
|
localSpherePos.vsub(edgeVertexA, tmp);
|
||
|
|
var positionAlongEdgeA = tmp.dot(edgeVector);
|
||
|
|
if (positionAlongEdgeA > 0 && positionAlongEdgeB < 0) {
|
||
|
|
localSpherePos.vsub(edgeVertexA, tmp);
|
||
|
|
edgeVectorUnit.copy(edgeVector);
|
||
|
|
edgeVectorUnit.normalize();
|
||
|
|
positionAlongEdgeA = tmp.dot(edgeVectorUnit);
|
||
|
|
edgeVectorUnit.scale(positionAlongEdgeA, tmp);
|
||
|
|
tmp.vadd(edgeVertexA, tmp);
|
||
|
|
var dist = tmp.distanceTo(localSpherePos);
|
||
|
|
if (dist < sphereShape.radius) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(sphereBody, trimeshBody, sphereShape, trimeshShape, rsi, rsj);
|
||
|
|
tmp.vsub(localSpherePos, r.ni);
|
||
|
|
r.ni.normalize();
|
||
|
|
r.ni.scale(sphereShape.radius, r.ri);
|
||
|
|
Transform.pointToWorldFrame(trimeshPos, trimeshQuat, tmp, tmp);
|
||
|
|
tmp.vsub(trimeshBody.position, r.rj);
|
||
|
|
Transform.vectorToWorldFrame(trimeshQuat, r.ni, r.ni);
|
||
|
|
Transform.vectorToWorldFrame(trimeshQuat, r.ri, r.ri);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var va = sphereTrimesh_va;
|
||
|
|
var vb = sphereTrimesh_vb;
|
||
|
|
var vc = sphereTrimesh_vc;
|
||
|
|
var normal = sphereTrimesh_normal;
|
||
|
|
for (var i = 0, N = triangles.length; i !== N; i++) {
|
||
|
|
trimeshShape.getTriangleVertices(triangles[i], va, vb, vc);
|
||
|
|
trimeshShape.getNormal(triangles[i], normal);
|
||
|
|
localSpherePos.vsub(va, tmp);
|
||
|
|
var dist = tmp.dot(normal);
|
||
|
|
normal.scale(dist, tmp);
|
||
|
|
localSpherePos.vsub(tmp, tmp);
|
||
|
|
dist = tmp.distanceTo(localSpherePos);
|
||
|
|
if (Ray.pointInTriangle(tmp, va, vb, vc) && dist < sphereShape.radius) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(sphereBody, trimeshBody, sphereShape, trimeshShape, rsi, rsj);
|
||
|
|
tmp.vsub(localSpherePos, r.ni);
|
||
|
|
r.ni.normalize();
|
||
|
|
r.ni.scale(sphereShape.radius, r.ri);
|
||
|
|
Transform.pointToWorldFrame(trimeshPos, trimeshQuat, tmp, tmp);
|
||
|
|
tmp.vsub(trimeshBody.position, r.rj);
|
||
|
|
Transform.vectorToWorldFrame(trimeshQuat, r.ni, r.ni);
|
||
|
|
Transform.vectorToWorldFrame(trimeshQuat, r.ri, r.ri);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
triangles.length = 0;
|
||
|
|
};
|
||
|
|
var point_on_plane_to_sphere = new Vec3();
|
||
|
|
var plane_to_sphere_ortho = new Vec3();
|
||
|
|
var p_s_ni = new Vec3();
|
||
|
|
var p_s_ri = new Vec3();
|
||
|
|
var p_s_rj = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.SPHERE | Shape.types.PLANE] = Narrowphase.prototype.spherePlane = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
p_s_ni.set(0, 0, 1);
|
||
|
|
qj.vmult(p_s_ni, p_s_ni);
|
||
|
|
p_s_ni.negate(p_s_ni);
|
||
|
|
p_s_ni.normalize();
|
||
|
|
p_s_ni.mult(si.radius, p_s_ri);
|
||
|
|
xi.vsub(xj, point_on_plane_to_sphere);
|
||
|
|
p_s_ni.mult(p_s_ni.dot(point_on_plane_to_sphere), plane_to_sphere_ortho);
|
||
|
|
point_on_plane_to_sphere.vsub(plane_to_sphere_ortho, p_s_rj);
|
||
|
|
if (-point_on_plane_to_sphere.dot(p_s_ni) <= si.radius) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
r.ni.copy(p_s_ni);
|
||
|
|
r.ri.copy(p_s_ri);
|
||
|
|
r.rj.copy(p_s_rj);
|
||
|
|
var ri = r.ri;
|
||
|
|
var rj = r.rj;
|
||
|
|
ri.vadd(xi, ri);
|
||
|
|
ri.vsub(bi.position, ri);
|
||
|
|
rj.vadd(xj, rj);
|
||
|
|
rj.vsub(bj.position, rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
var pointInPolygon_edge = new Vec3();
|
||
|
|
var pointInPolygon_edge_x_normal = new Vec3();
|
||
|
|
var pointInPolygon_vtp = new Vec3();
|
||
|
|
function pointInPolygon(verts, normal, p) {
|
||
|
|
var positiveResult = null;
|
||
|
|
var N = verts.length;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var v = verts[i];
|
||
|
|
var edge = pointInPolygon_edge;
|
||
|
|
verts[(i + 1) % N].vsub(v, edge);
|
||
|
|
var edge_x_normal = pointInPolygon_edge_x_normal;
|
||
|
|
edge.cross(normal, edge_x_normal);
|
||
|
|
var vertex_to_p = pointInPolygon_vtp;
|
||
|
|
p.vsub(v, vertex_to_p);
|
||
|
|
var r = edge_x_normal.dot(vertex_to_p);
|
||
|
|
if (null === positiveResult || r > 0 && true === positiveResult || r <= 0 && false === positiveResult) {
|
||
|
|
null === positiveResult && (positiveResult = r > 0);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
var box_to_sphere = new Vec3();
|
||
|
|
var sphereBox_ns = new Vec3();
|
||
|
|
var sphereBox_ns1 = new Vec3();
|
||
|
|
var sphereBox_ns2 = new Vec3();
|
||
|
|
var sphereBox_sides = [ new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3() ];
|
||
|
|
var sphereBox_sphere_to_corner = new Vec3();
|
||
|
|
var sphereBox_side_ns = new Vec3();
|
||
|
|
var sphereBox_side_ns1 = new Vec3();
|
||
|
|
var sphereBox_side_ns2 = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.SPHERE | Shape.types.BOX] = Narrowphase.prototype.sphereBox = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
var v3pool = this.v3pool;
|
||
|
|
var sides = sphereBox_sides;
|
||
|
|
xi.vsub(xj, box_to_sphere);
|
||
|
|
sj.getSideNormals(sides, qj);
|
||
|
|
var R = si.radius;
|
||
|
|
var penetrating_sides = [];
|
||
|
|
var found = false;
|
||
|
|
var side_ns = sphereBox_side_ns;
|
||
|
|
var side_ns1 = sphereBox_side_ns1;
|
||
|
|
var side_ns2 = sphereBox_side_ns2;
|
||
|
|
var side_h = null;
|
||
|
|
var side_penetrations = 0;
|
||
|
|
var side_dot1 = 0;
|
||
|
|
var side_dot2 = 0;
|
||
|
|
var side_distance = null;
|
||
|
|
for (var idx = 0, nsides = sides.length; idx !== nsides && false === found; idx++) {
|
||
|
|
var ns = sphereBox_ns;
|
||
|
|
ns.copy(sides[idx]);
|
||
|
|
var h = ns.norm();
|
||
|
|
ns.normalize();
|
||
|
|
var dot = box_to_sphere.dot(ns);
|
||
|
|
if (dot < h + R && dot > 0) {
|
||
|
|
var ns1 = sphereBox_ns1;
|
||
|
|
var ns2 = sphereBox_ns2;
|
||
|
|
ns1.copy(sides[(idx + 1) % 3]);
|
||
|
|
ns2.copy(sides[(idx + 2) % 3]);
|
||
|
|
var h1 = ns1.norm();
|
||
|
|
var h2 = ns2.norm();
|
||
|
|
ns1.normalize();
|
||
|
|
ns2.normalize();
|
||
|
|
var dot1 = box_to_sphere.dot(ns1);
|
||
|
|
var dot2 = box_to_sphere.dot(ns2);
|
||
|
|
if (dot1 < h1 && dot1 > -h1 && dot2 < h2 && dot2 > -h2) {
|
||
|
|
var dist = Math.abs(dot - h - R);
|
||
|
|
if (null === side_distance || dist < side_distance) {
|
||
|
|
side_distance = dist;
|
||
|
|
side_dot1 = dot1;
|
||
|
|
side_dot2 = dot2;
|
||
|
|
side_h = h;
|
||
|
|
side_ns.copy(ns);
|
||
|
|
side_ns1.copy(ns1);
|
||
|
|
side_ns2.copy(ns2);
|
||
|
|
side_penetrations++;
|
||
|
|
if (justTest) return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (side_penetrations) {
|
||
|
|
found = true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
side_ns.mult(-R, r.ri);
|
||
|
|
r.ni.copy(side_ns);
|
||
|
|
r.ni.negate(r.ni);
|
||
|
|
side_ns.mult(side_h, side_ns);
|
||
|
|
side_ns1.mult(side_dot1, side_ns1);
|
||
|
|
side_ns.vadd(side_ns1, side_ns);
|
||
|
|
side_ns2.mult(side_dot2, side_ns2);
|
||
|
|
side_ns.vadd(side_ns2, r.rj);
|
||
|
|
r.ri.vadd(xi, r.ri);
|
||
|
|
r.ri.vsub(bi.position, r.ri);
|
||
|
|
r.rj.vadd(xj, r.rj);
|
||
|
|
r.rj.vsub(bj.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
var rj = v3pool.get();
|
||
|
|
var sphere_to_corner = sphereBox_sphere_to_corner;
|
||
|
|
for (var j = 0; 2 !== j && !found; j++) for (var k = 0; 2 !== k && !found; k++) for (var l = 0; 2 !== l && !found; l++) {
|
||
|
|
rj.set(0, 0, 0);
|
||
|
|
j ? rj.vadd(sides[0], rj) : rj.vsub(sides[0], rj);
|
||
|
|
k ? rj.vadd(sides[1], rj) : rj.vsub(sides[1], rj);
|
||
|
|
l ? rj.vadd(sides[2], rj) : rj.vsub(sides[2], rj);
|
||
|
|
xj.vadd(rj, sphere_to_corner);
|
||
|
|
sphere_to_corner.vsub(xi, sphere_to_corner);
|
||
|
|
if (sphere_to_corner.norm2() < R * R) {
|
||
|
|
if (justTest) return true;
|
||
|
|
found = true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
r.ri.copy(sphere_to_corner);
|
||
|
|
r.ri.normalize();
|
||
|
|
r.ni.copy(r.ri);
|
||
|
|
r.ri.mult(R, r.ri);
|
||
|
|
r.rj.copy(rj);
|
||
|
|
r.ri.vadd(xi, r.ri);
|
||
|
|
r.ri.vsub(bi.position, r.ri);
|
||
|
|
r.rj.vadd(xj, r.rj);
|
||
|
|
r.rj.vsub(bj.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
v3pool.release(rj);
|
||
|
|
rj = null;
|
||
|
|
var edgeTangent = v3pool.get();
|
||
|
|
var edgeCenter = v3pool.get();
|
||
|
|
var r = v3pool.get();
|
||
|
|
var orthogonal = v3pool.get();
|
||
|
|
var dist = v3pool.get();
|
||
|
|
var Nsides = sides.length;
|
||
|
|
for (var j = 0; j !== Nsides && !found; j++) for (var k = 0; k !== Nsides && !found; k++) if (j % 3 !== k % 3) {
|
||
|
|
sides[k].cross(sides[j], edgeTangent);
|
||
|
|
edgeTangent.normalize();
|
||
|
|
sides[j].vadd(sides[k], edgeCenter);
|
||
|
|
r.copy(xi);
|
||
|
|
r.vsub(edgeCenter, r);
|
||
|
|
r.vsub(xj, r);
|
||
|
|
var orthonorm = r.dot(edgeTangent);
|
||
|
|
edgeTangent.mult(orthonorm, orthogonal);
|
||
|
|
var l = 0;
|
||
|
|
while (l === j % 3 || l === k % 3) l++;
|
||
|
|
dist.copy(xi);
|
||
|
|
dist.vsub(orthogonal, dist);
|
||
|
|
dist.vsub(edgeCenter, dist);
|
||
|
|
dist.vsub(xj, dist);
|
||
|
|
var tdist = Math.abs(orthonorm);
|
||
|
|
var ndist = dist.norm();
|
||
|
|
if (tdist < sides[l].norm() && ndist < R) {
|
||
|
|
if (justTest) return true;
|
||
|
|
found = true;
|
||
|
|
var res = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
edgeCenter.vadd(orthogonal, res.rj);
|
||
|
|
res.rj.copy(res.rj);
|
||
|
|
dist.negate(res.ni);
|
||
|
|
res.ni.normalize();
|
||
|
|
res.ri.copy(res.rj);
|
||
|
|
res.ri.vadd(xj, res.ri);
|
||
|
|
res.ri.vsub(xi, res.ri);
|
||
|
|
res.ri.normalize();
|
||
|
|
res.ri.mult(R, res.ri);
|
||
|
|
res.ri.vadd(xi, res.ri);
|
||
|
|
res.ri.vsub(bi.position, res.ri);
|
||
|
|
res.rj.vadd(xj, res.rj);
|
||
|
|
res.rj.vsub(bj.position, res.rj);
|
||
|
|
this.result.push(res);
|
||
|
|
this.createFrictionEquationsFromContact(res, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
v3pool.release(edgeTangent, edgeCenter, r, orthogonal, dist);
|
||
|
|
};
|
||
|
|
var convex_to_sphere = new Vec3();
|
||
|
|
var sphereConvex_edge = new Vec3();
|
||
|
|
var sphereConvex_edgeUnit = new Vec3();
|
||
|
|
var sphereConvex_sphereToCorner = new Vec3();
|
||
|
|
var sphereConvex_worldCorner = new Vec3();
|
||
|
|
var sphereConvex_worldNormal = new Vec3();
|
||
|
|
var sphereConvex_worldPoint = new Vec3();
|
||
|
|
var sphereConvex_worldSpherePointClosestToPlane = new Vec3();
|
||
|
|
var sphereConvex_penetrationVec = new Vec3();
|
||
|
|
var sphereConvex_sphereToWorldPoint = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.SPHERE | Shape.types.CONVEXPOLYHEDRON] = Narrowphase.prototype.sphereConvex = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
var v3pool = this.v3pool;
|
||
|
|
xi.vsub(xj, convex_to_sphere);
|
||
|
|
var normals = sj.faceNormals;
|
||
|
|
var faces = sj.faces;
|
||
|
|
var verts = sj.vertices;
|
||
|
|
var R = si.radius;
|
||
|
|
var penetrating_sides = [];
|
||
|
|
for (var i = 0; i !== verts.length; i++) {
|
||
|
|
var v = verts[i];
|
||
|
|
var worldCorner = sphereConvex_worldCorner;
|
||
|
|
qj.vmult(v, worldCorner);
|
||
|
|
xj.vadd(worldCorner, worldCorner);
|
||
|
|
var sphere_to_corner = sphereConvex_sphereToCorner;
|
||
|
|
worldCorner.vsub(xi, sphere_to_corner);
|
||
|
|
if (sphere_to_corner.norm2() < R * R) {
|
||
|
|
if (justTest) return true;
|
||
|
|
found = true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
r.ri.copy(sphere_to_corner);
|
||
|
|
r.ri.normalize();
|
||
|
|
r.ni.copy(r.ri);
|
||
|
|
r.ri.mult(R, r.ri);
|
||
|
|
worldCorner.vsub(xj, r.rj);
|
||
|
|
r.ri.vadd(xi, r.ri);
|
||
|
|
r.ri.vsub(bi.position, r.ri);
|
||
|
|
r.rj.vadd(xj, r.rj);
|
||
|
|
r.rj.vsub(bj.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var found = false;
|
||
|
|
for (var i = 0, nfaces = faces.length; i !== nfaces && false === found; i++) {
|
||
|
|
var normal = normals[i];
|
||
|
|
var face = faces[i];
|
||
|
|
var worldNormal = sphereConvex_worldNormal;
|
||
|
|
qj.vmult(normal, worldNormal);
|
||
|
|
var worldPoint = sphereConvex_worldPoint;
|
||
|
|
qj.vmult(verts[face[0]], worldPoint);
|
||
|
|
worldPoint.vadd(xj, worldPoint);
|
||
|
|
var worldSpherePointClosestToPlane = sphereConvex_worldSpherePointClosestToPlane;
|
||
|
|
worldNormal.mult(-R, worldSpherePointClosestToPlane);
|
||
|
|
xi.vadd(worldSpherePointClosestToPlane, worldSpherePointClosestToPlane);
|
||
|
|
var penetrationVec = sphereConvex_penetrationVec;
|
||
|
|
worldSpherePointClosestToPlane.vsub(worldPoint, penetrationVec);
|
||
|
|
var penetration = penetrationVec.dot(worldNormal);
|
||
|
|
var worldPointToSphere = sphereConvex_sphereToWorldPoint;
|
||
|
|
xi.vsub(worldPoint, worldPointToSphere);
|
||
|
|
if (penetration < 0 && worldPointToSphere.dot(worldNormal) > 0) {
|
||
|
|
var faceVerts = [];
|
||
|
|
for (var j = 0, Nverts = face.length; j !== Nverts; j++) {
|
||
|
|
var worldVertex = v3pool.get();
|
||
|
|
qj.vmult(verts[face[j]], worldVertex);
|
||
|
|
xj.vadd(worldVertex, worldVertex);
|
||
|
|
faceVerts.push(worldVertex);
|
||
|
|
}
|
||
|
|
if (pointInPolygon(faceVerts, worldNormal, xi)) {
|
||
|
|
if (justTest) return true;
|
||
|
|
found = true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
worldNormal.mult(-R, r.ri);
|
||
|
|
worldNormal.negate(r.ni);
|
||
|
|
var penetrationVec2 = v3pool.get();
|
||
|
|
worldNormal.mult(-penetration, penetrationVec2);
|
||
|
|
var penetrationSpherePoint = v3pool.get();
|
||
|
|
worldNormal.mult(-R, penetrationSpherePoint);
|
||
|
|
xi.vsub(xj, r.rj);
|
||
|
|
r.rj.vadd(penetrationSpherePoint, r.rj);
|
||
|
|
r.rj.vadd(penetrationVec2, r.rj);
|
||
|
|
r.rj.vadd(xj, r.rj);
|
||
|
|
r.rj.vsub(bj.position, r.rj);
|
||
|
|
r.ri.vadd(xi, r.ri);
|
||
|
|
r.ri.vsub(bi.position, r.ri);
|
||
|
|
v3pool.release(penetrationVec2);
|
||
|
|
v3pool.release(penetrationSpherePoint);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
for (var j = 0, Nfaceverts = faceVerts.length; j !== Nfaceverts; j++) v3pool.release(faceVerts[j]);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (var j = 0; j !== face.length; j++) {
|
||
|
|
var v1 = v3pool.get();
|
||
|
|
var v2 = v3pool.get();
|
||
|
|
qj.vmult(verts[face[(j + 1) % face.length]], v1);
|
||
|
|
qj.vmult(verts[face[(j + 2) % face.length]], v2);
|
||
|
|
xj.vadd(v1, v1);
|
||
|
|
xj.vadd(v2, v2);
|
||
|
|
var edge = sphereConvex_edge;
|
||
|
|
v2.vsub(v1, edge);
|
||
|
|
var edgeUnit = sphereConvex_edgeUnit;
|
||
|
|
edge.unit(edgeUnit);
|
||
|
|
var p = v3pool.get();
|
||
|
|
var v1_to_xi = v3pool.get();
|
||
|
|
xi.vsub(v1, v1_to_xi);
|
||
|
|
var dot = v1_to_xi.dot(edgeUnit);
|
||
|
|
edgeUnit.mult(dot, p);
|
||
|
|
p.vadd(v1, p);
|
||
|
|
var xi_to_p = v3pool.get();
|
||
|
|
p.vsub(xi, xi_to_p);
|
||
|
|
if (dot > 0 && dot * dot < edge.norm2() && xi_to_p.norm2() < R * R) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
p.vsub(xj, r.rj);
|
||
|
|
p.vsub(xi, r.ni);
|
||
|
|
r.ni.normalize();
|
||
|
|
r.ni.mult(R, r.ri);
|
||
|
|
r.rj.vadd(xj, r.rj);
|
||
|
|
r.rj.vsub(bj.position, r.rj);
|
||
|
|
r.ri.vadd(xi, r.ri);
|
||
|
|
r.ri.vsub(bi.position, r.ri);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
for (var j = 0, Nfaceverts = faceVerts.length; j !== Nfaceverts; j++) v3pool.release(faceVerts[j]);
|
||
|
|
v3pool.release(v1);
|
||
|
|
v3pool.release(v2);
|
||
|
|
v3pool.release(p);
|
||
|
|
v3pool.release(xi_to_p);
|
||
|
|
v3pool.release(v1_to_xi);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
v3pool.release(v1);
|
||
|
|
v3pool.release(v2);
|
||
|
|
v3pool.release(p);
|
||
|
|
v3pool.release(xi_to_p);
|
||
|
|
v3pool.release(v1_to_xi);
|
||
|
|
}
|
||
|
|
for (var j = 0, Nfaceverts = faceVerts.length; j !== Nfaceverts; j++) v3pool.release(faceVerts[j]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var planeBox_normal = new Vec3();
|
||
|
|
var plane_to_corner = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.PLANE | Shape.types.BOX] = Narrowphase.prototype.planeBox = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
sj.convexPolyhedronRepresentation.material = sj.material;
|
||
|
|
sj.convexPolyhedronRepresentation.collisionResponse = sj.collisionResponse;
|
||
|
|
sj.convexPolyhedronRepresentation.id = sj.id;
|
||
|
|
return this.planeConvex(si, sj.convexPolyhedronRepresentation, xi, xj, qi, qj, bi, bj, si, sj, justTest);
|
||
|
|
};
|
||
|
|
var planeConvex_v = new Vec3();
|
||
|
|
var planeConvex_normal = new Vec3();
|
||
|
|
var planeConvex_relpos = new Vec3();
|
||
|
|
var planeConvex_projected = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.PLANE | Shape.types.CONVEXPOLYHEDRON] = Narrowphase.prototype.planeConvex = function(planeShape, convexShape, planePosition, convexPosition, planeQuat, convexQuat, planeBody, convexBody, si, sj, justTest) {
|
||
|
|
var worldVertex = planeConvex_v, worldNormal = planeConvex_normal;
|
||
|
|
worldNormal.set(0, 0, 1);
|
||
|
|
planeQuat.vmult(worldNormal, worldNormal);
|
||
|
|
var numContacts = 0;
|
||
|
|
var relpos = planeConvex_relpos;
|
||
|
|
for (var i = 0; i !== convexShape.vertices.length; i++) {
|
||
|
|
worldVertex.copy(convexShape.vertices[i]);
|
||
|
|
convexQuat.vmult(worldVertex, worldVertex);
|
||
|
|
convexPosition.vadd(worldVertex, worldVertex);
|
||
|
|
worldVertex.vsub(planePosition, relpos);
|
||
|
|
var dot = worldNormal.dot(relpos);
|
||
|
|
if (dot <= 0) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(planeBody, convexBody, planeShape, convexShape, si, sj);
|
||
|
|
var projected = planeConvex_projected;
|
||
|
|
worldNormal.mult(worldNormal.dot(relpos), projected);
|
||
|
|
worldVertex.vsub(projected, projected);
|
||
|
|
projected.vsub(planePosition, r.ri);
|
||
|
|
r.ni.copy(worldNormal);
|
||
|
|
worldVertex.vsub(convexPosition, r.rj);
|
||
|
|
r.ri.vadd(planePosition, r.ri);
|
||
|
|
r.ri.vsub(planeBody.position, r.ri);
|
||
|
|
r.rj.vadd(convexPosition, r.rj);
|
||
|
|
r.rj.vsub(convexBody.position, r.rj);
|
||
|
|
this.result.push(r);
|
||
|
|
numContacts++;
|
||
|
|
this.enableFrictionReduction || this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.enableFrictionReduction && numContacts && this.createFrictionFromAverage(numContacts);
|
||
|
|
};
|
||
|
|
var convexConvex_sepAxis = new Vec3();
|
||
|
|
var convexConvex_q = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.CONVEXPOLYHEDRON] = Narrowphase.prototype.convexConvex = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest, faceListA, faceListB) {
|
||
|
|
var sepAxis = convexConvex_sepAxis;
|
||
|
|
if (xi.distanceTo(xj) > si.boundingSphereRadius + sj.boundingSphereRadius) return;
|
||
|
|
if (si.findSeparatingAxis(sj, xi, qi, xj, qj, sepAxis, faceListA, faceListB)) {
|
||
|
|
var res = [];
|
||
|
|
var q = convexConvex_q;
|
||
|
|
si.clipAgainstHull(xi, qi, sj, xj, qj, sepAxis, -100, 100, res);
|
||
|
|
var numContacts = 0;
|
||
|
|
for (var j = 0; j !== res.length; j++) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj), ri = r.ri, rj = r.rj;
|
||
|
|
sepAxis.negate(r.ni);
|
||
|
|
res[j].normal.negate(q);
|
||
|
|
q.mult(res[j].depth, q);
|
||
|
|
res[j].point.vadd(q, ri);
|
||
|
|
rj.copy(res[j].point);
|
||
|
|
ri.vsub(xi, ri);
|
||
|
|
rj.vsub(xj, rj);
|
||
|
|
ri.vadd(xi, ri);
|
||
|
|
ri.vsub(bi.position, ri);
|
||
|
|
rj.vadd(xj, rj);
|
||
|
|
rj.vsub(bj.position, rj);
|
||
|
|
this.result.push(r);
|
||
|
|
numContacts++;
|
||
|
|
this.enableFrictionReduction || this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
this.enableFrictionReduction && numContacts && this.createFrictionFromAverage(numContacts);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var particlePlane_normal = new Vec3();
|
||
|
|
var particlePlane_relpos = new Vec3();
|
||
|
|
var particlePlane_projected = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.PLANE | Shape.types.PARTICLE] = Narrowphase.prototype.planeParticle = function(sj, si, xj, xi, qj, qi, bj, bi, rsi, rsj, justTest) {
|
||
|
|
var normal = particlePlane_normal;
|
||
|
|
normal.set(0, 0, 1);
|
||
|
|
bj.quaternion.vmult(normal, normal);
|
||
|
|
var relpos = particlePlane_relpos;
|
||
|
|
xi.vsub(bj.position, relpos);
|
||
|
|
var dot = normal.dot(relpos);
|
||
|
|
if (dot <= 0) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
r.ni.copy(normal);
|
||
|
|
r.ni.negate(r.ni);
|
||
|
|
r.ri.set(0, 0, 0);
|
||
|
|
var projected = particlePlane_projected;
|
||
|
|
normal.mult(normal.dot(xi), projected);
|
||
|
|
xi.vsub(projected, projected);
|
||
|
|
r.rj.copy(projected);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var particleSphere_normal = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.PARTICLE | Shape.types.SPHERE] = Narrowphase.prototype.sphereParticle = function(sj, si, xj, xi, qj, qi, bj, bi, rsi, rsj, justTest) {
|
||
|
|
var normal = particleSphere_normal;
|
||
|
|
normal.set(0, 0, 1);
|
||
|
|
xi.vsub(xj, normal);
|
||
|
|
var lengthSquared = normal.norm2();
|
||
|
|
if (lengthSquared <= sj.radius * sj.radius) {
|
||
|
|
if (justTest) return true;
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
normal.normalize();
|
||
|
|
r.rj.copy(normal);
|
||
|
|
r.rj.mult(sj.radius, r.rj);
|
||
|
|
r.ni.copy(normal);
|
||
|
|
r.ni.negate(r.ni);
|
||
|
|
r.ri.set(0, 0, 0);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var cqj = new Quaternion();
|
||
|
|
var convexParticle_local = new Vec3();
|
||
|
|
var convexParticle_normal = new Vec3();
|
||
|
|
var convexParticle_penetratedFaceNormal = new Vec3();
|
||
|
|
var convexParticle_vertexToParticle = new Vec3();
|
||
|
|
var convexParticle_worldPenetrationVec = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.PARTICLE | Shape.types.CONVEXPOLYHEDRON] = Narrowphase.prototype.convexParticle = function(sj, si, xj, xi, qj, qi, bj, bi, rsi, rsj, justTest) {
|
||
|
|
var penetratedFaceIndex = -1;
|
||
|
|
var penetratedFaceNormal = convexParticle_penetratedFaceNormal;
|
||
|
|
var worldPenetrationVec = convexParticle_worldPenetrationVec;
|
||
|
|
var minPenetration = null;
|
||
|
|
var numDetectedFaces = 0;
|
||
|
|
var local = convexParticle_local;
|
||
|
|
local.copy(xi);
|
||
|
|
local.vsub(xj, local);
|
||
|
|
qj.conjugate(cqj);
|
||
|
|
cqj.vmult(local, local);
|
||
|
|
if (sj.pointIsInside(local)) {
|
||
|
|
sj.worldVerticesNeedsUpdate && sj.computeWorldVertices(xj, qj);
|
||
|
|
sj.worldFaceNormalsNeedsUpdate && sj.computeWorldFaceNormals(qj);
|
||
|
|
for (var i = 0, nfaces = sj.faces.length; i !== nfaces; i++) {
|
||
|
|
var verts = [ sj.worldVertices[sj.faces[i][0]] ];
|
||
|
|
var normal = sj.worldFaceNormals[i];
|
||
|
|
xi.vsub(verts[0], convexParticle_vertexToParticle);
|
||
|
|
var penetration = -normal.dot(convexParticle_vertexToParticle);
|
||
|
|
if (null === minPenetration || Math.abs(penetration) < Math.abs(minPenetration)) {
|
||
|
|
if (justTest) return true;
|
||
|
|
minPenetration = penetration;
|
||
|
|
penetratedFaceIndex = i;
|
||
|
|
penetratedFaceNormal.copy(normal);
|
||
|
|
numDetectedFaces++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (-1 !== penetratedFaceIndex) {
|
||
|
|
var r = this.createContactEquation(bi, bj, si, sj, rsi, rsj);
|
||
|
|
penetratedFaceNormal.mult(minPenetration, worldPenetrationVec);
|
||
|
|
worldPenetrationVec.vadd(xi, worldPenetrationVec);
|
||
|
|
worldPenetrationVec.vsub(xj, worldPenetrationVec);
|
||
|
|
r.rj.copy(worldPenetrationVec);
|
||
|
|
penetratedFaceNormal.negate(r.ni);
|
||
|
|
r.ri.set(0, 0, 0);
|
||
|
|
var ri = r.ri, rj = r.rj;
|
||
|
|
ri.vadd(xi, ri);
|
||
|
|
ri.vsub(bi.position, ri);
|
||
|
|
rj.vadd(xj, rj);
|
||
|
|
rj.vsub(bj.position, rj);
|
||
|
|
this.result.push(r);
|
||
|
|
this.createFrictionEquationsFromContact(r, this.frictionResult);
|
||
|
|
} else console.warn("Point found inside convex, but did not find penetrating face!");
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Narrowphase.prototype[Shape.types.BOX | Shape.types.HEIGHTFIELD] = Narrowphase.prototype.boxHeightfield = function(si, sj, xi, xj, qi, qj, bi, bj, rsi, rsj, justTest) {
|
||
|
|
si.convexPolyhedronRepresentation.material = si.material;
|
||
|
|
si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse;
|
||
|
|
return this.convexHeightfield(si.convexPolyhedronRepresentation, sj, xi, xj, qi, qj, bi, bj, si, sj, justTest);
|
||
|
|
};
|
||
|
|
var convexHeightfield_tmp1 = new Vec3();
|
||
|
|
var convexHeightfield_tmp2 = new Vec3();
|
||
|
|
var convexHeightfield_faceList = [ 0 ];
|
||
|
|
Narrowphase.prototype[Shape.types.CONVEXPOLYHEDRON | Shape.types.HEIGHTFIELD] = Narrowphase.prototype.convexHeightfield = function(convexShape, hfShape, convexPos, hfPos, convexQuat, hfQuat, convexBody, hfBody, rsi, rsj, justTest) {
|
||
|
|
var data = hfShape.data, w = hfShape.elementSize, radius = convexShape.boundingSphereRadius, worldPillarOffset = convexHeightfield_tmp2, faceList = convexHeightfield_faceList;
|
||
|
|
var localConvexPos = convexHeightfield_tmp1;
|
||
|
|
Transform.pointToLocalFrame(hfPos, hfQuat, convexPos, localConvexPos);
|
||
|
|
var iMinX = Math.floor((localConvexPos.x - radius) / w) - 1, iMaxX = Math.ceil((localConvexPos.x + radius) / w) + 1, iMinY = Math.floor((localConvexPos.y - radius) / w) - 1, iMaxY = Math.ceil((localConvexPos.y + radius) / w) + 1;
|
||
|
|
if (iMaxX < 0 || iMaxY < 0 || iMinX > data.length || iMinY > data[0].length) return;
|
||
|
|
iMinX < 0 && (iMinX = 0);
|
||
|
|
iMaxX < 0 && (iMaxX = 0);
|
||
|
|
iMinY < 0 && (iMinY = 0);
|
||
|
|
iMaxY < 0 && (iMaxY = 0);
|
||
|
|
iMinX >= data.length && (iMinX = data.length - 1);
|
||
|
|
iMaxX >= data.length && (iMaxX = data.length - 1);
|
||
|
|
iMaxY >= data[0].length && (iMaxY = data[0].length - 1);
|
||
|
|
iMinY >= data[0].length && (iMinY = data[0].length - 1);
|
||
|
|
var minMax = [];
|
||
|
|
hfShape.getRectMinMax(iMinX, iMinY, iMaxX, iMaxY, minMax);
|
||
|
|
var min = minMax[0];
|
||
|
|
var max = minMax[1];
|
||
|
|
if (localConvexPos.z - radius > max || localConvexPos.z + radius < min) return;
|
||
|
|
for (var i = iMinX; i < iMaxX; i++) for (var j = iMinY; j < iMaxY; j++) {
|
||
|
|
var intersecting = false;
|
||
|
|
hfShape.getConvexTrianglePillar(i, j, false);
|
||
|
|
Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset);
|
||
|
|
convexPos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + convexShape.boundingSphereRadius && (intersecting = this.convexConvex(convexShape, hfShape.pillarConvex, convexPos, worldPillarOffset, convexQuat, hfQuat, convexBody, hfBody, rsi, rsj, justTest, faceList, null));
|
||
|
|
if (justTest && intersecting) return true;
|
||
|
|
hfShape.getConvexTrianglePillar(i, j, true);
|
||
|
|
Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset);
|
||
|
|
convexPos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + convexShape.boundingSphereRadius && (intersecting = this.convexConvex(convexShape, hfShape.pillarConvex, convexPos, worldPillarOffset, convexQuat, hfQuat, convexBody, hfBody, rsi, rsj, justTest, faceList, null));
|
||
|
|
if (justTest && intersecting) return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var sphereHeightfield_tmp1 = new Vec3();
|
||
|
|
var sphereHeightfield_tmp2 = new Vec3();
|
||
|
|
Narrowphase.prototype[Shape.types.SPHERE | Shape.types.HEIGHTFIELD] = Narrowphase.prototype.sphereHeightfield = function(sphereShape, hfShape, spherePos, hfPos, sphereQuat, hfQuat, sphereBody, hfBody, rsi, rsj, justTest) {
|
||
|
|
var data = hfShape.data, radius = sphereShape.radius, w = hfShape.elementSize, worldPillarOffset = sphereHeightfield_tmp2;
|
||
|
|
var localSpherePos = sphereHeightfield_tmp1;
|
||
|
|
Transform.pointToLocalFrame(hfPos, hfQuat, spherePos, localSpherePos);
|
||
|
|
var iMinX = Math.floor((localSpherePos.x - radius) / w) - 1, iMaxX = Math.ceil((localSpherePos.x + radius) / w) + 1, iMinY = Math.floor((localSpherePos.y - radius) / w) - 1, iMaxY = Math.ceil((localSpherePos.y + radius) / w) + 1;
|
||
|
|
if (iMaxX < 0 || iMaxY < 0 || iMinX > data.length || iMinY > data[0].length) return;
|
||
|
|
iMinX < 0 && (iMinX = 0);
|
||
|
|
iMaxX < 0 && (iMaxX = 0);
|
||
|
|
iMinY < 0 && (iMinY = 0);
|
||
|
|
iMaxY < 0 && (iMaxY = 0);
|
||
|
|
iMinX >= data.length && (iMinX = data.length - 1);
|
||
|
|
iMaxX >= data.length && (iMaxX = data.length - 1);
|
||
|
|
iMaxY >= data[0].length && (iMaxY = data[0].length - 1);
|
||
|
|
iMinY >= data[0].length && (iMinY = data[0].length - 1);
|
||
|
|
var minMax = [];
|
||
|
|
hfShape.getRectMinMax(iMinX, iMinY, iMaxX, iMaxY, minMax);
|
||
|
|
var min = minMax[0];
|
||
|
|
var max = minMax[1];
|
||
|
|
if (localSpherePos.z - radius > max || localSpherePos.z + radius < min) return;
|
||
|
|
var result = this.result;
|
||
|
|
for (var i = iMinX; i < iMaxX; i++) for (var j = iMinY; j < iMaxY; j++) {
|
||
|
|
var numContactsBefore = result.length;
|
||
|
|
var intersecting = false;
|
||
|
|
hfShape.getConvexTrianglePillar(i, j, false);
|
||
|
|
Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset);
|
||
|
|
spherePos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + sphereShape.boundingSphereRadius && (intersecting = this.sphereConvex(sphereShape, hfShape.pillarConvex, spherePos, worldPillarOffset, sphereQuat, hfQuat, sphereBody, hfBody, sphereShape, hfShape, justTest));
|
||
|
|
if (justTest && intersecting) return true;
|
||
|
|
hfShape.getConvexTrianglePillar(i, j, true);
|
||
|
|
Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset);
|
||
|
|
spherePos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + sphereShape.boundingSphereRadius && (intersecting = this.sphereConvex(sphereShape, hfShape.pillarConvex, spherePos, worldPillarOffset, sphereQuat, hfQuat, sphereBody, hfBody, sphereShape, hfShape, justTest));
|
||
|
|
if (justTest && intersecting) return true;
|
||
|
|
var numContacts = result.length - numContactsBefore;
|
||
|
|
if (numContacts > 2) return;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/AABB": 3,
|
||
|
|
"../collision/Ray": 10,
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"../equations/FrictionEquation": 22,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Transform": 31,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../objects/Body": 33,
|
||
|
|
"../shapes/ConvexPolyhedron": 40,
|
||
|
|
"../shapes/Shape": 45,
|
||
|
|
"../solver/Solver": 49,
|
||
|
|
"../utils/Vec3Pool": 56
|
||
|
|
} ],
|
||
|
|
58: [ function(_dereq_, module, exports) {
|
||
|
|
module.exports = World;
|
||
|
|
var Shape = _dereq_("../shapes/Shape");
|
||
|
|
var Vec3 = _dereq_("../math/Vec3");
|
||
|
|
var Quaternion = _dereq_("../math/Quaternion");
|
||
|
|
var GSSolver = _dereq_("../solver/GSSolver");
|
||
|
|
var ContactEquation = _dereq_("../equations/ContactEquation");
|
||
|
|
var FrictionEquation = _dereq_("../equations/FrictionEquation");
|
||
|
|
var Narrowphase = _dereq_("./Narrowphase");
|
||
|
|
var EventTarget = _dereq_("../utils/EventTarget");
|
||
|
|
var ArrayCollisionMatrix = _dereq_("../collision/ArrayCollisionMatrix");
|
||
|
|
var ObjectCollisionMatrix = _dereq_("../collision/ObjectCollisionMatrix");
|
||
|
|
var OverlapKeeper = _dereq_("../collision/OverlapKeeper");
|
||
|
|
var Material = _dereq_("../material/Material");
|
||
|
|
var ContactMaterial = _dereq_("../material/ContactMaterial");
|
||
|
|
var Body = _dereq_("../objects/Body");
|
||
|
|
var TupleDictionary = _dereq_("../utils/TupleDictionary");
|
||
|
|
var RaycastResult = _dereq_("../collision/RaycastResult");
|
||
|
|
var AABB = _dereq_("../collision/AABB");
|
||
|
|
var Ray = _dereq_("../collision/Ray");
|
||
|
|
var NaiveBroadphase = _dereq_("../collision/NaiveBroadphase");
|
||
|
|
function World(options) {
|
||
|
|
options = options || {};
|
||
|
|
EventTarget.apply(this);
|
||
|
|
this.dt = -1;
|
||
|
|
this.allowSleep = !!options.allowSleep;
|
||
|
|
this.contacts = [];
|
||
|
|
this.frictionEquations = [];
|
||
|
|
this.quatNormalizeSkip = void 0 !== options.quatNormalizeSkip ? options.quatNormalizeSkip : 0;
|
||
|
|
this.quatNormalizeFast = void 0 !== options.quatNormalizeFast && options.quatNormalizeFast;
|
||
|
|
this.time = 0;
|
||
|
|
this.timeFixed = 0;
|
||
|
|
this.stepnumber = 0;
|
||
|
|
this.default_dt = 1 / 60;
|
||
|
|
this.nextId = 0;
|
||
|
|
this.gravity = new Vec3();
|
||
|
|
options.gravity && this.gravity.copy(options.gravity);
|
||
|
|
this.broadphase = void 0 !== options.broadphase ? options.broadphase : new NaiveBroadphase();
|
||
|
|
this.bodies = [];
|
||
|
|
this.solver = void 0 !== options.solver ? options.solver : new GSSolver();
|
||
|
|
this.constraints = [];
|
||
|
|
this.narrowphase = new Narrowphase(this);
|
||
|
|
this.collisionMatrix = new ArrayCollisionMatrix();
|
||
|
|
this.collisionMatrixPrevious = new ArrayCollisionMatrix();
|
||
|
|
this.bodyOverlapKeeper = new OverlapKeeper();
|
||
|
|
this.shapeOverlapKeeper = new OverlapKeeper();
|
||
|
|
this.materials = [];
|
||
|
|
this.contactmaterials = [];
|
||
|
|
this.contactMaterialTable = new TupleDictionary();
|
||
|
|
this.defaultMaterial = new Material("default");
|
||
|
|
this.defaultContactMaterial = new ContactMaterial(this.defaultMaterial, this.defaultMaterial, {
|
||
|
|
friction: .3,
|
||
|
|
restitution: 0
|
||
|
|
});
|
||
|
|
this.doProfiling = false;
|
||
|
|
this.profile = {
|
||
|
|
solve: 0,
|
||
|
|
makeContactConstraints: 0,
|
||
|
|
broadphase: 0,
|
||
|
|
integrate: 0,
|
||
|
|
narrowphase: 0
|
||
|
|
};
|
||
|
|
this.accumulator = 0;
|
||
|
|
this.subsystems = [];
|
||
|
|
this.addBodyEvent = {
|
||
|
|
type: "addBody",
|
||
|
|
body: null
|
||
|
|
};
|
||
|
|
this.removeBodyEvent = {
|
||
|
|
type: "removeBody",
|
||
|
|
body: null
|
||
|
|
};
|
||
|
|
this.idToBodyMap = {};
|
||
|
|
this.broadphase.setWorld(this);
|
||
|
|
this.substeps = 0;
|
||
|
|
this.cm = new ObjectCollisionMatrix();
|
||
|
|
this.tm = new ObjectCollisionMatrix();
|
||
|
|
this.triggerDic = new TupleDictionary();
|
||
|
|
this.oldTriggerDic = new TupleDictionary();
|
||
|
|
this.contactsDic = new TupleDictionary();
|
||
|
|
this.oldContactsDic = new TupleDictionary();
|
||
|
|
}
|
||
|
|
World.idToBodyMap = {};
|
||
|
|
World.idToShapeMap = {};
|
||
|
|
World.prototype = new EventTarget();
|
||
|
|
var tmpAABB1 = new AABB();
|
||
|
|
var tmpArray1 = [];
|
||
|
|
var tmpRay = new Ray();
|
||
|
|
World.prototype.getContactMaterial = function(m1, m2) {
|
||
|
|
return this.contactMaterialTable.get(m1.id, m2.id);
|
||
|
|
};
|
||
|
|
World.prototype.numObjects = function() {
|
||
|
|
return this.bodies.length;
|
||
|
|
};
|
||
|
|
World.prototype.collisionMatrixTick = function() {
|
||
|
|
var temp = this.collisionMatrixPrevious;
|
||
|
|
this.collisionMatrixPrevious = this.collisionMatrix;
|
||
|
|
this.collisionMatrix = temp;
|
||
|
|
this.collisionMatrix.reset();
|
||
|
|
this.bodyOverlapKeeper.tick();
|
||
|
|
this.shapeOverlapKeeper.tick();
|
||
|
|
};
|
||
|
|
World.prototype.add = World.prototype.addBody = function(body) {
|
||
|
|
World.SLEEPING = false;
|
||
|
|
if (-1 !== this.bodies.indexOf(body)) return;
|
||
|
|
body.index = this.bodies.length;
|
||
|
|
this.bodies.push(body);
|
||
|
|
body.world = this;
|
||
|
|
body.initPosition.copy(body.position);
|
||
|
|
body.initVelocity.copy(body.velocity);
|
||
|
|
body.timeLastSleepy = this.time;
|
||
|
|
if (body instanceof Body) {
|
||
|
|
body.initAngularVelocity.copy(body.angularVelocity);
|
||
|
|
body.initQuaternion.copy(body.quaternion);
|
||
|
|
}
|
||
|
|
this.collisionMatrix.setNumObjects(this.bodies.length);
|
||
|
|
this.addBodyEvent.body = body;
|
||
|
|
this.cm.setNumObjects(this.bodies.length);
|
||
|
|
World.idToBodyMap[body.id] = body;
|
||
|
|
this.dispatchEvent(this.addBodyEvent);
|
||
|
|
};
|
||
|
|
World.prototype.addConstraint = function(c) {
|
||
|
|
World.SLEEPING = false;
|
||
|
|
this.constraints.push(c);
|
||
|
|
};
|
||
|
|
World.prototype.removeConstraint = function(c) {
|
||
|
|
World.SLEEPING = false;
|
||
|
|
var idx = this.constraints.indexOf(c);
|
||
|
|
-1 !== idx && this.constraints.splice(idx, 1);
|
||
|
|
};
|
||
|
|
World.prototype.rayTest = function(from, to, result) {
|
||
|
|
result instanceof RaycastResult ? this.raycastClosest(from, to, {
|
||
|
|
skipBackfaces: true
|
||
|
|
}, result) : this.raycastAll(from, to, {
|
||
|
|
skipBackfaces: true
|
||
|
|
}, result);
|
||
|
|
};
|
||
|
|
World.prototype.raycastAll = function(from, to, options, callback) {
|
||
|
|
options.mode = Ray.ALL;
|
||
|
|
options.from = from;
|
||
|
|
options.to = to;
|
||
|
|
options.callback = callback;
|
||
|
|
return tmpRay.intersectWorld(this, options);
|
||
|
|
};
|
||
|
|
World.prototype.raycastAny = function(from, to, options, result) {
|
||
|
|
options.mode = Ray.ANY;
|
||
|
|
options.from = from;
|
||
|
|
options.to = to;
|
||
|
|
options.result = result;
|
||
|
|
return tmpRay.intersectWorld(this, options);
|
||
|
|
};
|
||
|
|
World.prototype.raycastClosest = function(from, to, options, result) {
|
||
|
|
options.mode = Ray.CLOSEST;
|
||
|
|
options.from = from;
|
||
|
|
options.to = to;
|
||
|
|
options.result = result;
|
||
|
|
return tmpRay.intersectWorld(this, options);
|
||
|
|
};
|
||
|
|
World.prototype.remove = function(body) {
|
||
|
|
World.SLEEPING = false;
|
||
|
|
body.world = null;
|
||
|
|
var n = this.bodies.length - 1, bodies = this.bodies, idx = bodies.indexOf(body);
|
||
|
|
if (-1 !== idx) {
|
||
|
|
bodies.splice(idx, 1);
|
||
|
|
for (var i = 0; i !== bodies.length; i++) bodies[i].index = i;
|
||
|
|
this.collisionMatrix.setNumObjects(n);
|
||
|
|
this.removeBodyEvent.body = body;
|
||
|
|
delete World.idToBodyMap[body.id];
|
||
|
|
this.cm.setNumObjects(n);
|
||
|
|
this.dispatchEvent(this.removeBodyEvent);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
World.prototype.removeBody = World.prototype.remove;
|
||
|
|
World.prototype.getBodyById = function(id) {
|
||
|
|
return World.idToBodyMap[id];
|
||
|
|
};
|
||
|
|
World.prototype.getShapeById = function(id) {
|
||
|
|
return World.idToShapeMap[id];
|
||
|
|
};
|
||
|
|
World.prototype.addMaterial = function(m) {
|
||
|
|
this.materials.push(m);
|
||
|
|
};
|
||
|
|
World.prototype.addContactMaterial = function(cmat) {
|
||
|
|
this.contactmaterials.push(cmat);
|
||
|
|
this.contactMaterialTable.set(cmat.materials[0].id, cmat.materials[1].id, cmat);
|
||
|
|
};
|
||
|
|
"undefined" === typeof performance && (performance = {});
|
||
|
|
if (!performance.now) {
|
||
|
|
var nowOffset = Date.now();
|
||
|
|
performance.timing && performance.timing.navigationStart && (nowOffset = performance.timing.navigationStart);
|
||
|
|
performance.now = function() {
|
||
|
|
return Date.now() - nowOffset;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
var step_tmp1 = new Vec3();
|
||
|
|
World.prototype.step = function(dt, timeSinceLastCalled, maxSubSteps) {
|
||
|
|
maxSubSteps = maxSubSteps || 10;
|
||
|
|
timeSinceLastCalled = timeSinceLastCalled || 0;
|
||
|
|
if (0 === timeSinceLastCalled) {
|
||
|
|
this.internalStep(dt);
|
||
|
|
this.time += dt;
|
||
|
|
this.substeps = 1;
|
||
|
|
} else {
|
||
|
|
this.accumulator += timeSinceLastCalled;
|
||
|
|
this.substeps = 0;
|
||
|
|
while (this.accumulator >= dt && this.substeps < maxSubSteps) {
|
||
|
|
this.internalStep(dt);
|
||
|
|
this.accumulator -= dt;
|
||
|
|
this.substeps++;
|
||
|
|
}
|
||
|
|
var t = this.accumulator % dt / dt;
|
||
|
|
for (var j = 0; j !== this.bodies.length; j++) {
|
||
|
|
var b = this.bodies[j];
|
||
|
|
b.previousPosition.lerp(b.position, t, b.interpolatedPosition);
|
||
|
|
b.previousQuaternion.slerp(b.quaternion, t, b.interpolatedQuaternion);
|
||
|
|
b.previousQuaternion.normalize();
|
||
|
|
}
|
||
|
|
this.time += timeSinceLastCalled;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var World_step_postStepEvent = {
|
||
|
|
type: "postStep"
|
||
|
|
}, World_step_preStepEvent = {
|
||
|
|
type: "preStep"
|
||
|
|
}, World_step_collideEvent = {
|
||
|
|
type: "collide",
|
||
|
|
body: null,
|
||
|
|
contact: null
|
||
|
|
}, World_step_oldContacts = [], World_step_frictionEquationPool = [], World_step_p1 = [], World_step_p2 = [], World_step_gvec = new Vec3(), World_step_vi = new Vec3(), World_step_vj = new Vec3(), World_step_wi = new Vec3(), World_step_wj = new Vec3(), World_step_t1 = new Vec3(), World_step_t2 = new Vec3(), World_step_rixn = new Vec3(), World_step_rjxn = new Vec3(), World_step_step_q = new Quaternion(), World_step_step_w = new Quaternion(), World_step_step_wq = new Quaternion(), invI_tau_dt = new Vec3();
|
||
|
|
World.prototype.internalStep = function(dt) {
|
||
|
|
this.dt = dt;
|
||
|
|
var world = this, that = this, contacts = this.contacts, p1 = World_step_p1, p2 = World_step_p2, N = this.numObjects(), bodies = this.bodies, solver = this.solver, gravity = this.gravity, doProfiling = this.doProfiling, profile = this.profile, DYNAMIC = Body.DYNAMIC, profilingStart, constraints = this.constraints, frictionEquationPool = World_step_frictionEquationPool, gnorm = gravity.norm(), gx = gravity.x, gy = gravity.y, gz = gravity.z, i = 0;
|
||
|
|
doProfiling && (profilingStart = performance.now());
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
if (bi.useGravity && bi.type === DYNAMIC) {
|
||
|
|
var f = bi.force, m = bi.mass;
|
||
|
|
f.x += m * gx;
|
||
|
|
f.y += m * gy;
|
||
|
|
f.z += m * gz;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var i = 0, Nsubsystems = this.subsystems.length; i !== Nsubsystems; i++) this.subsystems[i].update();
|
||
|
|
doProfiling && (profilingStart = performance.now());
|
||
|
|
p1.length = 0;
|
||
|
|
p2.length = 0;
|
||
|
|
this.broadphase.collisionPairs(this, p1, p2);
|
||
|
|
doProfiling && (profile.broadphase = performance.now() - profilingStart);
|
||
|
|
var Nconstraints = constraints.length;
|
||
|
|
for (i = 0; i !== Nconstraints; i++) {
|
||
|
|
var c = constraints[i];
|
||
|
|
if (!c.collideConnected) for (var j = p1.length - 1; j >= 0; j -= 1) if (c.bodyA === p1[j] && c.bodyB === p2[j] || c.bodyB === p1[j] && c.bodyA === p2[j]) {
|
||
|
|
p1.splice(j, 1);
|
||
|
|
p2.splice(j, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.collisionMatrixTick();
|
||
|
|
doProfiling && (profilingStart = performance.now());
|
||
|
|
var oldcontacts = World_step_oldContacts;
|
||
|
|
var NoldContacts = contacts.length;
|
||
|
|
for (i = 0; i !== NoldContacts; i++) oldcontacts.push(contacts[i]);
|
||
|
|
contacts.length = 0;
|
||
|
|
var NoldFrictionEquations = this.frictionEquations.length;
|
||
|
|
for (i = 0; i !== NoldFrictionEquations; i++) frictionEquationPool.push(this.frictionEquations[i]);
|
||
|
|
this.frictionEquations.length = 0;
|
||
|
|
this.narrowphase.getContacts(p1, p2, this, contacts, oldcontacts, this.frictionEquations, frictionEquationPool);
|
||
|
|
if (0 == contacts.length && World.SLEEPING) return;
|
||
|
|
doProfiling && (profile.narrowphase = performance.now() - profilingStart);
|
||
|
|
doProfiling && (profilingStart = performance.now());
|
||
|
|
for (var i = 0; i < this.frictionEquations.length; i++) solver.addEquation(this.frictionEquations[i]);
|
||
|
|
var ncontacts = contacts.length;
|
||
|
|
for (var k = 0; k !== ncontacts; k++) {
|
||
|
|
var c = contacts[k];
|
||
|
|
var bi = c.bi, bj = c.bj, si = c.si, sj = c.sj;
|
||
|
|
si.material && sj.material ? si.material.restitution >= 0 && sj.material.restitution >= 0 && (c.restitution = si.material.restitution * sj.material.restitution) : bi.material && bj.material && bi.material.restitution >= 0 && bj.material.restitution >= 0 && (c.restitution = bi.material.restitution * bj.material.restitution);
|
||
|
|
solver.addEquation(c);
|
||
|
|
if (bi.allowSleep && bi.type === Body.DYNAMIC && bi.sleepState === Body.SLEEPING && bj.sleepState === Body.AWAKE && bj.type !== Body.STATIC) {
|
||
|
|
var speedSquaredB = bj.velocity.norm2() + bj.angularVelocity.norm2();
|
||
|
|
var speedLimitSquaredB = Math.pow(bj.sleepSpeedLimit, 2);
|
||
|
|
speedSquaredB >= 2 * speedLimitSquaredB && (bi._wakeUpAfterNarrowphase = true);
|
||
|
|
}
|
||
|
|
if (bj.allowSleep && bj.type === Body.DYNAMIC && bj.sleepState === Body.SLEEPING && bi.sleepState === Body.AWAKE && bi.type !== Body.STATIC) {
|
||
|
|
var speedSquaredA = bi.velocity.norm2() + bi.angularVelocity.norm2();
|
||
|
|
var speedLimitSquaredA = Math.pow(bi.sleepSpeedLimit, 2);
|
||
|
|
speedSquaredA >= 2 * speedLimitSquaredA && (bj._wakeUpAfterNarrowphase = true);
|
||
|
|
}
|
||
|
|
this.collisionMatrix.set(bi, bj, true);
|
||
|
|
if (!this.collisionMatrixPrevious.get(bi, bj)) {
|
||
|
|
World_step_collideEvent.body = bj;
|
||
|
|
World_step_collideEvent.contact = c;
|
||
|
|
bi.dispatchEvent(World_step_collideEvent);
|
||
|
|
World_step_collideEvent.body = bi;
|
||
|
|
bj.dispatchEvent(World_step_collideEvent);
|
||
|
|
}
|
||
|
|
this.bodyOverlapKeeper.set(bi.id, bj.id);
|
||
|
|
this.shapeOverlapKeeper.set(si.id, sj.id);
|
||
|
|
}
|
||
|
|
this.emitContactEvents();
|
||
|
|
if (doProfiling) {
|
||
|
|
profile.makeContactConstraints = performance.now() - profilingStart;
|
||
|
|
profilingStart = performance.now();
|
||
|
|
}
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
if (bi._wakeUpAfterNarrowphase) {
|
||
|
|
bi.wakeUp();
|
||
|
|
bi._wakeUpAfterNarrowphase = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var Nconstraints = constraints.length;
|
||
|
|
for (i = 0; i !== Nconstraints; i++) {
|
||
|
|
var c = constraints[i];
|
||
|
|
c.update();
|
||
|
|
for (var j = 0, Neq = c.equations.length; j !== Neq; j++) {
|
||
|
|
var eq = c.equations[j];
|
||
|
|
solver.addEquation(eq);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
solver.solve(dt, this);
|
||
|
|
doProfiling && (profile.solve = performance.now() - profilingStart);
|
||
|
|
solver.removeAllEquations();
|
||
|
|
var pow = Math.pow;
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
if (bi.type & DYNAMIC) {
|
||
|
|
var ld = pow(1 - bi.linearDamping, dt);
|
||
|
|
var v = bi.velocity;
|
||
|
|
v.mult(ld, v);
|
||
|
|
var av = bi.angularVelocity;
|
||
|
|
if (av) {
|
||
|
|
var ad = pow(1 - bi.angularDamping, dt);
|
||
|
|
av.mult(ad, av);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.dispatchEvent(World_step_preStepEvent);
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
bi.preStep && bi.preStep.call(bi);
|
||
|
|
}
|
||
|
|
doProfiling && (profilingStart = performance.now());
|
||
|
|
var stepnumber = this.stepnumber;
|
||
|
|
var quatNormalize = stepnumber % (this.quatNormalizeSkip + 1) === 0;
|
||
|
|
var quatNormalizeFast = this.quatNormalizeFast;
|
||
|
|
for (i = 0; i !== N; i++) bodies[i].integrate(dt, quatNormalize, quatNormalizeFast);
|
||
|
|
this.clearForces();
|
||
|
|
this.broadphase.dirty = true;
|
||
|
|
doProfiling && (profile.integrate = performance.now() - profilingStart);
|
||
|
|
this.time += dt;
|
||
|
|
this.timeFixed += dt;
|
||
|
|
this.stepnumber += 1;
|
||
|
|
this.dispatchEvent(World_step_postStepEvent);
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
var postStep = bi.postStep;
|
||
|
|
postStep && postStep.call(bi);
|
||
|
|
}
|
||
|
|
if (this.allowSleep) {
|
||
|
|
for (i = 0; i !== N; i++) bodies[i].sleepTick(this.time);
|
||
|
|
World.SLEEPING = true;
|
||
|
|
for (i = 0; i !== N; i++) {
|
||
|
|
var bi = bodies[i];
|
||
|
|
if (bi.type != Body.STATIC && !bi.isSleeping()) {
|
||
|
|
World.SLEEPING = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else World.SLEEPING = false;
|
||
|
|
};
|
||
|
|
World.prototype.emitContactEvents = function() {
|
||
|
|
var additions = [];
|
||
|
|
var removals = [];
|
||
|
|
var beginContactEvent = {
|
||
|
|
type: "beginContact",
|
||
|
|
bodyA: null,
|
||
|
|
bodyB: null
|
||
|
|
};
|
||
|
|
var endContactEvent = {
|
||
|
|
type: "endContact",
|
||
|
|
bodyA: null,
|
||
|
|
bodyB: null
|
||
|
|
};
|
||
|
|
var beginShapeContactEvent = {
|
||
|
|
type: "beginShapeContact",
|
||
|
|
bodyA: null,
|
||
|
|
bodyB: null,
|
||
|
|
shapeA: null,
|
||
|
|
shapeB: null
|
||
|
|
};
|
||
|
|
var endShapeContactEvent = {
|
||
|
|
type: "endShapeContact",
|
||
|
|
bodyA: null,
|
||
|
|
bodyB: null,
|
||
|
|
shapeA: null,
|
||
|
|
shapeB: null
|
||
|
|
};
|
||
|
|
return function() {
|
||
|
|
var hasBeginContact = this.hasAnyEventListener("beginContact");
|
||
|
|
var hasEndContact = this.hasAnyEventListener("endContact");
|
||
|
|
(hasBeginContact || hasEndContact) && this.bodyOverlapKeeper.getDiff(additions, removals);
|
||
|
|
if (hasBeginContact) {
|
||
|
|
for (var i = 0, l = additions.length; i < l; i += 2) {
|
||
|
|
beginContactEvent.bodyA = this.getBodyById(additions[i]);
|
||
|
|
beginContactEvent.bodyB = this.getBodyById(additions[i + 1]);
|
||
|
|
this.dispatchEvent(beginContactEvent);
|
||
|
|
}
|
||
|
|
beginContactEvent.bodyA = beginContactEvent.bodyB = null;
|
||
|
|
}
|
||
|
|
if (hasEndContact) {
|
||
|
|
for (var i = 0, l = removals.length; i < l; i += 2) {
|
||
|
|
endContactEvent.bodyA = this.getBodyById(removals[i]);
|
||
|
|
endContactEvent.bodyB = this.getBodyById(removals[i + 1]);
|
||
|
|
this.dispatchEvent(endContactEvent);
|
||
|
|
}
|
||
|
|
endContactEvent.bodyA = endContactEvent.bodyB = null;
|
||
|
|
}
|
||
|
|
additions.length = removals.length = 0;
|
||
|
|
var hasBeginShapeContact = this.hasAnyEventListener("beginShapeContact");
|
||
|
|
var hasEndShapeContact = this.hasAnyEventListener("endShapeContact");
|
||
|
|
(hasBeginShapeContact || hasEndShapeContact) && this.shapeOverlapKeeper.getDiff(additions, removals);
|
||
|
|
if (hasBeginShapeContact) {
|
||
|
|
for (var i = 0, l = additions.length; i < l; i += 2) {
|
||
|
|
var shapeA = this.getShapeById(additions[i]);
|
||
|
|
var shapeB = this.getShapeById(additions[i + 1]);
|
||
|
|
beginShapeContactEvent.shapeA = shapeA;
|
||
|
|
beginShapeContactEvent.shapeB = shapeB;
|
||
|
|
beginShapeContactEvent.bodyA = shapeA.body;
|
||
|
|
beginShapeContactEvent.bodyB = shapeB.body;
|
||
|
|
this.dispatchEvent(beginShapeContactEvent);
|
||
|
|
}
|
||
|
|
beginShapeContactEvent.bodyA = beginShapeContactEvent.bodyB = beginShapeContactEvent.shapeA = beginShapeContactEvent.shapeB = null;
|
||
|
|
}
|
||
|
|
if (hasEndShapeContact) {
|
||
|
|
for (var i = 0, l = removals.length; i < l; i += 2) {
|
||
|
|
var shapeA = this.getShapeById(removals[i]);
|
||
|
|
var shapeB = this.getShapeById(removals[i + 1]);
|
||
|
|
endShapeContactEvent.shapeA = shapeA;
|
||
|
|
endShapeContactEvent.shapeB = shapeB;
|
||
|
|
endShapeContactEvent.bodyA = shapeA.body;
|
||
|
|
endShapeContactEvent.bodyB = shapeB.body;
|
||
|
|
this.dispatchEvent(endShapeContactEvent);
|
||
|
|
}
|
||
|
|
endShapeContactEvent.bodyA = endShapeContactEvent.bodyB = endShapeContactEvent.shapeA = endShapeContactEvent.shapeB = null;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}();
|
||
|
|
World.prototype.clearForces = function() {
|
||
|
|
var bodies = this.bodies;
|
||
|
|
var N = bodies.length;
|
||
|
|
for (var i = 0; i !== N; i++) {
|
||
|
|
var b = bodies[i], force = b.force, tau = b.torque;
|
||
|
|
b.force.set(0, 0, 0);
|
||
|
|
b.torque.set(0, 0, 0);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var cc_trigger = {
|
||
|
|
type: "cc-trigger",
|
||
|
|
event: "",
|
||
|
|
selfBody: null,
|
||
|
|
otherBody: null,
|
||
|
|
selfShape: null,
|
||
|
|
otherShape: null
|
||
|
|
};
|
||
|
|
var cc_collide = {
|
||
|
|
type: "cc-collide",
|
||
|
|
event: "",
|
||
|
|
body: null,
|
||
|
|
selfShape: null,
|
||
|
|
otherShape: null,
|
||
|
|
contacts: null
|
||
|
|
};
|
||
|
|
var cc_oldContacts = [];
|
||
|
|
World.prototype.emitTriggeredEvents = function() {
|
||
|
|
if (0 == this.substeps) return;
|
||
|
|
var key;
|
||
|
|
var data;
|
||
|
|
var i = this.triggerDic.getLength();
|
||
|
|
while (i--) {
|
||
|
|
key = this.triggerDic.getKeyByIndex(i);
|
||
|
|
data = this.triggerDic.getDataByKey(key);
|
||
|
|
if (null == data) continue;
|
||
|
|
var shapeA = data.si;
|
||
|
|
var shapeB = data.sj;
|
||
|
|
if (this.tm.get(shapeA, shapeB)) cc_trigger.event = "onTriggerStay"; else {
|
||
|
|
this.tm.set(shapeA, shapeB, true);
|
||
|
|
cc_trigger.event = "onTriggerEnter";
|
||
|
|
}
|
||
|
|
cc_trigger.selfShape = shapeA;
|
||
|
|
cc_trigger.otherShape = shapeB;
|
||
|
|
cc_trigger.selfBody = shapeA.body;
|
||
|
|
cc_trigger.otherBody = shapeB.body;
|
||
|
|
shapeA.dispatchEvent(cc_trigger);
|
||
|
|
cc_trigger.selfShape = shapeB;
|
||
|
|
cc_trigger.otherShape = shapeA;
|
||
|
|
cc_trigger.selfBody = shapeB.body;
|
||
|
|
cc_trigger.otherBody = shapeA.body;
|
||
|
|
shapeB.dispatchEvent(cc_trigger);
|
||
|
|
}
|
||
|
|
i = this.oldTriggerDic.getLength();
|
||
|
|
while (i > 0) {
|
||
|
|
i--;
|
||
|
|
key = this.oldTriggerDic.getKeyByIndex(i);
|
||
|
|
if (null != this.triggerDic.getDataByKey(key)) continue;
|
||
|
|
data = this.oldTriggerDic.getDataByKey(key);
|
||
|
|
if (null == data) continue;
|
||
|
|
var shapeA = data.si;
|
||
|
|
var shapeB = data.sj;
|
||
|
|
this.tm.set(shapeA, shapeB, false);
|
||
|
|
this.oldTriggerDic.del(shapeA.id, shapeB.id) && i--;
|
||
|
|
cc_trigger.event = "onTriggerExit";
|
||
|
|
cc_trigger.selfShape = shapeA;
|
||
|
|
cc_trigger.otherShape = shapeB;
|
||
|
|
cc_trigger.selfBody = shapeA.body;
|
||
|
|
cc_trigger.otherBody = shapeB.body;
|
||
|
|
shapeA.dispatchEvent(cc_trigger);
|
||
|
|
cc_trigger.selfShape = shapeB;
|
||
|
|
cc_trigger.otherShape = shapeA;
|
||
|
|
cc_trigger.selfBody = shapeB.body;
|
||
|
|
cc_trigger.otherBody = shapeA.body;
|
||
|
|
shapeB.dispatchEvent(cc_trigger);
|
||
|
|
}
|
||
|
|
this.triggerDic.reset();
|
||
|
|
};
|
||
|
|
World.prototype.emitCollisionEvents = function() {
|
||
|
|
if (0 == this.substeps) return;
|
||
|
|
var contacts = this.contacts;
|
||
|
|
var i = this.contacts.length;
|
||
|
|
while (i--) {
|
||
|
|
var c = contacts[i];
|
||
|
|
var si = c.si;
|
||
|
|
var sj = c.sj;
|
||
|
|
var item = this.contactsDic.get(si.id, sj.id);
|
||
|
|
null == item && (item = this.contactsDic.set(si.id, sj.id, []));
|
||
|
|
item.push(c);
|
||
|
|
}
|
||
|
|
var key;
|
||
|
|
var data;
|
||
|
|
var i = this.contactsDic.getLength();
|
||
|
|
while (i--) {
|
||
|
|
key = this.contactsDic.getKeyByIndex(i);
|
||
|
|
data = this.contactsDic.getDataByKey(key);
|
||
|
|
if (null == data) continue;
|
||
|
|
var si = data[0].si;
|
||
|
|
var sj = data[0].sj;
|
||
|
|
var bi = si.body;
|
||
|
|
var bj = sj.body;
|
||
|
|
if (this.cm.get(bi, bj)) cc_collide.event = "onCollisionStay"; else {
|
||
|
|
this.cm.set(bi, bj, true);
|
||
|
|
cc_collide.event = "onCollisionEnter";
|
||
|
|
}
|
||
|
|
cc_collide.bi = bi;
|
||
|
|
cc_collide.contact = data[0];
|
||
|
|
cc_collide.contacts = data;
|
||
|
|
cc_collide.body = bj;
|
||
|
|
cc_collide.selfShape = si;
|
||
|
|
cc_collide.otherShape = sj;
|
||
|
|
bi.dispatchEvent(cc_collide);
|
||
|
|
cc_collide.body = bi;
|
||
|
|
cc_collide.selfShape = sj;
|
||
|
|
cc_collide.otherShape = si;
|
||
|
|
bj.dispatchEvent(cc_collide);
|
||
|
|
}
|
||
|
|
var oldcontacts = cc_oldContacts;
|
||
|
|
for (i = oldcontacts.length; i--; ) {
|
||
|
|
var c = oldcontacts[i];
|
||
|
|
var si = c.si;
|
||
|
|
var sj = c.sj;
|
||
|
|
null == this.oldContactsDic.get(si.id, sj.id) && this.oldContactsDic.set(si.id, sj.id, c);
|
||
|
|
}
|
||
|
|
i = this.oldContactsDic.getLength();
|
||
|
|
while (i--) {
|
||
|
|
key = this.oldContactsDic.getKeyByIndex(i);
|
||
|
|
if (null == this.contactsDic.getDataByKey(key)) {
|
||
|
|
data = this.oldContactsDic.getDataByKey(key);
|
||
|
|
var si = data.si;
|
||
|
|
var sj = data.sj;
|
||
|
|
var bi = si.body;
|
||
|
|
var bj = sj.body;
|
||
|
|
if (this.cm.get(bi, bj) && (!bi.isSleeping() || !bj.isSleeping())) {
|
||
|
|
this.cm.set(bi, bj, false);
|
||
|
|
cc_collide.bi = bi;
|
||
|
|
cc_collide.contact = data;
|
||
|
|
cc_collide.event = "onCollisionExit";
|
||
|
|
cc_collide.body = bj;
|
||
|
|
cc_collide.selfShape = si;
|
||
|
|
cc_collide.otherShape = sj;
|
||
|
|
cc_collide.contacts.length = 0;
|
||
|
|
cc_collide.contacts.push(data);
|
||
|
|
bi.dispatchEvent(cc_collide);
|
||
|
|
cc_collide.body = bi;
|
||
|
|
cc_collide.selfShape = sj;
|
||
|
|
cc_collide.otherShape = si;
|
||
|
|
bj.dispatchEvent(cc_collide);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.contactsDic.reset();
|
||
|
|
this.oldContactsDic.reset();
|
||
|
|
World_step_oldContacts = cc_oldContacts;
|
||
|
|
cc_oldContacts = this.contacts.slice();
|
||
|
|
this.contacts.length = 0;
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
"../collision/AABB": 3,
|
||
|
|
"../collision/ArrayCollisionMatrix": 4,
|
||
|
|
"../collision/NaiveBroadphase": 7,
|
||
|
|
"../collision/ObjectCollisionMatrix": 8,
|
||
|
|
"../collision/OverlapKeeper": 9,
|
||
|
|
"../collision/Ray": 10,
|
||
|
|
"../collision/RaycastResult": 11,
|
||
|
|
"../equations/ContactEquation": 20,
|
||
|
|
"../equations/FrictionEquation": 22,
|
||
|
|
"../material/ContactMaterial": 25,
|
||
|
|
"../material/Material": 26,
|
||
|
|
"../math/Quaternion": 30,
|
||
|
|
"../math/Vec3": 32,
|
||
|
|
"../objects/Body": 33,
|
||
|
|
"../shapes/Shape": 45,
|
||
|
|
"../solver/GSSolver": 48,
|
||
|
|
"../utils/EventTarget": 51,
|
||
|
|
"../utils/TupleDictionary": 54,
|
||
|
|
"./Narrowphase": 57
|
||
|
|
} ]
|
||
|
|
}, {}, [ 2 ])(2);
|
||
|
|
});
|
||
|
|
}).call(this, "undefined" !== typeof global ? global : "undefined" !== typeof self ? self : "undefined" !== typeof window ? window : {});
|
||
|
|
}, {} ]
|
||
|
|
}, {}, [ 10, 9 ]);
|