@galacean/engine-physics-physx 0.9.0-beta.82 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/browser.js +1349 -1337
  2. package/dist/main.js +54 -42
  3. package/dist/main.js.map +1 -1
  4. package/dist/miniprogram.js +1325 -978
  5. package/dist/module.js +54 -42
  6. package/dist/module.js.map +1 -1
  7. package/package.json +4 -4
package/dist/browser.js CHANGED
@@ -1,1372 +1,1384 @@
1
1
  (function (global, factory) {
2
- typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@galacean/engine')) :
3
- typeof define === 'function' && define.amd ? define(['exports', '@galacean/engine'], factory) :
4
- (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Galacean = global.Galacean || {}, global.Galacean.PhysicsPhysX = {}), global.Galacean));
2
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@galacean/engine')) :
3
+ typeof define === 'function' && define.amd ? define(['exports', '@galacean/engine'], factory) :
4
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Galacean = global.Galacean || {}, global.Galacean.PhysicsPhysX = {}), global.Galacean));
5
5
  })(this, (function (exports, engine) { 'use strict';
6
6
 
7
- function _instanceof(left, right) {
8
- if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
9
- return !!right[Symbol.hasInstance](left);
10
- } else {
11
- return left instanceof right;
7
+ function _instanceof(left, right) {
8
+ if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
9
+ return !!right[Symbol.hasInstance](left);
10
+ } else return left instanceof right;
12
11
  }
13
- }
14
12
 
15
- /******************************************************************************
16
- Copyright (c) Microsoft Corporation.
13
+ /******************************************************************************
14
+ Copyright (c) Microsoft Corporation.
17
15
 
18
- Permission to use, copy, modify, and/or distribute this software for any
19
- purpose with or without fee is hereby granted.
16
+ Permission to use, copy, modify, and/or distribute this software for any
17
+ purpose with or without fee is hereby granted.
20
18
 
21
- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
22
- REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
23
- AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
24
- INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
25
- LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
26
- OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
27
- PERFORMANCE OF THIS SOFTWARE.
28
- ***************************************************************************** */
19
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
20
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
21
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
22
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
23
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
24
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
25
+ PERFORMANCE OF THIS SOFTWARE.
26
+ ***************************************************************************** */
29
27
 
30
- function __decorate(decorators, target, key, desc) {
31
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
32
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
33
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
34
- return c > 3 && r && Object.defineProperty(target, key, r), r;
35
- }
36
-
37
- /**
38
- * PhysX runtime mode.
39
- */ exports.PhysXRuntimeMode = void 0;
40
- (function(PhysXRuntimeMode) {
41
- PhysXRuntimeMode[PhysXRuntimeMode[/** Use webAssembly mode first, if WebAssembly mode is not supported, roll back to JavaScript mode. */ "Auto"] = 0] = "Auto";
42
- PhysXRuntimeMode[PhysXRuntimeMode[/** WebAssembly mode. */ "WebAssembly"] = 1] = "WebAssembly";
43
- PhysXRuntimeMode[PhysXRuntimeMode[/** JavaScript mode. */ "JavaScript"] = 2] = "JavaScript";
44
- })(exports.PhysXRuntimeMode || (exports.PhysXRuntimeMode = {}));
28
+ function __decorate(decorators, target, key, desc) {
29
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
30
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
31
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
32
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
33
+ }
45
34
 
46
- function setPrototypeOf(o, p) {
47
- setPrototypeOf = Object.setPrototypeOf || function setPrototypeOf(o, p) {
48
- o.__proto__ = p;
49
- return o;
50
- };
35
+ /**
36
+ * PhysX runtime mode.
37
+ */ exports.PhysXRuntimeMode = void 0;
38
+ (function(PhysXRuntimeMode) {
39
+ PhysXRuntimeMode[PhysXRuntimeMode[/** Use webAssembly mode first, if WebAssembly mode is not supported, roll back to JavaScript mode. */ "Auto"] = 0] = "Auto";
40
+ PhysXRuntimeMode[PhysXRuntimeMode[/** WebAssembly mode. */ "WebAssembly"] = 1] = "WebAssembly";
41
+ PhysXRuntimeMode[PhysXRuntimeMode[/** JavaScript mode. */ "JavaScript"] = 2] = "JavaScript";
42
+ })(exports.PhysXRuntimeMode || (exports.PhysXRuntimeMode = {}));
51
43
 
52
- return setPrototypeOf(o, p);
53
- }
44
+ function _set_prototype_of(o, p) {
45
+ _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
46
+ o.__proto__ = p;
54
47
 
55
- function _setPrototypeOf(o, p) {
56
- return setPrototypeOf(o, p);
57
- }
48
+ return o;
49
+ };
58
50
 
59
- function _inherits(subClass, superClass) {
60
- if (typeof superClass !== "function" && superClass !== null) {
61
- throw new TypeError("Super expression must either be null or a function");
51
+ return _set_prototype_of(o, p);
62
52
  }
63
53
 
64
- subClass.prototype = Object.create(superClass && superClass.prototype, {
65
- constructor: {
66
- value: subClass,
67
- writable: true,
68
- configurable: true
69
- }
70
- });
71
- if (superClass) _setPrototypeOf(subClass, superClass);
72
- }
54
+ function _inherits(subClass, superClass) {
55
+ if (typeof superClass !== "function" && superClass !== null) {
56
+ throw new TypeError("Super expression must either be null or a function");
57
+ }
58
+
59
+ subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
73
60
 
74
- /**
75
- * a base interface providing common functionality for PhysX joints
76
- */ var PhysXJoint = /*#__PURE__*/ function() {
77
- function PhysXJoint() {
78
- this._connectedAnchor = new engine.Vector3();
79
- this._breakForce = Number.MAX_VALUE;
80
- this._breakTorque = Number.MAX_VALUE;
81
- }
82
- var _proto = PhysXJoint.prototype;
83
- /**
84
- * {@inheritDoc IJoint.setConnectedCollider }
85
- */ _proto.setConnectedCollider = function setConnectedCollider(value) {
86
- var _this__collider;
87
- this._pxJoint.setActors((value == null ? void 0 : value._pxActor) || null, ((_this__collider = this._collider) == null ? void 0 : _this__collider._pxActor) || null);
88
- };
89
- /**
90
- * {@inheritDoc IJoint.setConnectedAnchor }
91
- */ _proto.setConnectedAnchor = function setConnectedAnchor(value) {
92
- this._connectedAnchor.copyFrom(value);
93
- this._setLocalPose(0, value, PhysXJoint._defaultQuat);
94
- };
95
- /**
96
- * {@inheritDoc IJoint.setConnectedMassScale }
97
- */ _proto.setConnectedMassScale = function setConnectedMassScale(value) {
98
- this._pxJoint.setInvMassScale0(1 / value);
99
- };
100
- /**
101
- * {@inheritDoc IJoint.setConnectedInertiaScale }
102
- */ _proto.setConnectedInertiaScale = function setConnectedInertiaScale(value) {
103
- this._pxJoint.setInvInertiaScale0(1 / value);
104
- };
105
- /**
106
- * {@inheritDoc IJoint.setMassScale }
107
- */ _proto.setMassScale = function setMassScale(value) {
108
- this._pxJoint.setInvMassScale1(1 / value);
109
- };
110
- /**
111
- * {@inheritDoc IJoint.setInertiaScale }
112
- */ _proto.setInertiaScale = function setInertiaScale(value) {
113
- this._pxJoint.setInvInertiaScale1(1 / value);
114
- };
115
- /**
116
- * {@inheritDoc IJoint.setBreakForce }
117
- */ _proto.setBreakForce = function setBreakForce(value) {
118
- this._breakForce = value;
119
- this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
120
- };
121
- /**
122
- * {@inheritDoc IJoint.setBreakTorque }
123
- */ _proto.setBreakTorque = function setBreakTorque(value) {
124
- this._breakTorque = value;
125
- this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
126
- };
127
- /**
128
- * Set the joint local pose for an actor.
129
- * @param actor 0 for the first actor, 1 for the second actor.
130
- * @param position the local position for the actor this joint
131
- * @param rotation the local rotation for the actor this joint
132
- */ _proto._setLocalPose = function _setLocalPose(actor, position, rotation) {
133
- this._pxJoint.setLocalPose(actor, position, rotation);
134
- };
135
- return PhysXJoint;
136
- }();
137
- PhysXJoint._xAxis = new engine.Vector3(1, 0, 0);
138
- PhysXJoint._defaultVec = new engine.Vector3();
139
- PhysXJoint._defaultQuat = new engine.Quaternion();
61
+ if (superClass) _set_prototype_of(subClass, superClass);
62
+ }
63
+
64
+ /**
65
+ * a base interface providing common functionality for PhysX joints
66
+ */ var PhysXJoint = /*#__PURE__*/ function() {
67
+ function PhysXJoint() {
68
+ this._connectedAnchor = new engine.Vector3();
69
+ this._breakForce = Number.MAX_VALUE;
70
+ this._breakTorque = Number.MAX_VALUE;
71
+ }
72
+ var _proto = PhysXJoint.prototype;
73
+ /**
74
+ * {@inheritDoc IJoint.setConnectedCollider }
75
+ */ _proto.setConnectedCollider = function setConnectedCollider(value) {
76
+ var _this__collider;
77
+ this._pxJoint.setActors((value == null ? void 0 : value._pxActor) || null, ((_this__collider = this._collider) == null ? void 0 : _this__collider._pxActor) || null);
78
+ };
79
+ /**
80
+ * {@inheritDoc IJoint.setConnectedAnchor }
81
+ */ _proto.setConnectedAnchor = function setConnectedAnchor(value) {
82
+ this._connectedAnchor.copyFrom(value);
83
+ this._setLocalPose(0, value, PhysXJoint._defaultQuat);
84
+ };
85
+ /**
86
+ * {@inheritDoc IJoint.setConnectedMassScale }
87
+ */ _proto.setConnectedMassScale = function setConnectedMassScale(value) {
88
+ this._pxJoint.setInvMassScale0(1 / value);
89
+ };
90
+ /**
91
+ * {@inheritDoc IJoint.setConnectedInertiaScale }
92
+ */ _proto.setConnectedInertiaScale = function setConnectedInertiaScale(value) {
93
+ this._pxJoint.setInvInertiaScale0(1 / value);
94
+ };
95
+ /**
96
+ * {@inheritDoc IJoint.setMassScale }
97
+ */ _proto.setMassScale = function setMassScale(value) {
98
+ this._pxJoint.setInvMassScale1(1 / value);
99
+ };
100
+ /**
101
+ * {@inheritDoc IJoint.setInertiaScale }
102
+ */ _proto.setInertiaScale = function setInertiaScale(value) {
103
+ this._pxJoint.setInvInertiaScale1(1 / value);
104
+ };
105
+ /**
106
+ * {@inheritDoc IJoint.setBreakForce }
107
+ */ _proto.setBreakForce = function setBreakForce(value) {
108
+ this._breakForce = value;
109
+ this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
110
+ };
111
+ /**
112
+ * {@inheritDoc IJoint.setBreakTorque }
113
+ */ _proto.setBreakTorque = function setBreakTorque(value) {
114
+ this._breakTorque = value;
115
+ this._pxJoint.setBreakForce(this._breakForce, this._breakTorque);
116
+ };
117
+ /**
118
+ * Set the joint local pose for an actor.
119
+ * @param actor 0 for the first actor, 1 for the second actor.
120
+ * @param position the local position for the actor this joint
121
+ * @param rotation the local rotation for the actor this joint
122
+ */ _proto._setLocalPose = function _setLocalPose(actor, position, rotation) {
123
+ this._pxJoint.setLocalPose(actor, position, rotation);
124
+ };
125
+ return PhysXJoint;
126
+ }();
127
+ (function() {
128
+ PhysXJoint._xAxis = new engine.Vector3(1, 0, 0);
129
+ })();
130
+ (function() {
131
+ PhysXJoint._defaultVec = new engine.Vector3();
132
+ })();
133
+ (function() {
134
+ PhysXJoint._defaultQuat = new engine.Quaternion();
135
+ })();
140
136
 
141
- /**
142
- * A fixed joint permits no relative movement between two colliders. ie the bodies are glued together.
143
- */ var PhysXFixedJoint = /*#__PURE__*/ function(PhysXJoint1) {
144
- _inherits(PhysXFixedJoint, PhysXJoint1);
145
- function PhysXFixedJoint(collider) {
146
- var _this;
147
- _this = PhysXJoint1.call(this) || this;
148
- _this._collider = collider;
149
- _this._pxJoint = exports.PhysXPhysics._pxPhysics.createFixedJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
150
- return _this;
151
- }
152
- return PhysXFixedJoint;
153
- }(PhysXJoint);
137
+ /**
138
+ * A fixed joint permits no relative movement between two colliders. ie the bodies are glued together.
139
+ */ var PhysXFixedJoint = /*#__PURE__*/ function(PhysXJoint1) {
140
+ _inherits(PhysXFixedJoint, PhysXJoint1);
141
+ function PhysXFixedJoint(collider) {
142
+ var _this;
143
+ _this = PhysXJoint1.call(this) || this;
144
+ _this._collider = collider;
145
+ _this._pxJoint = exports.PhysXPhysics._pxPhysics.createFixedJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
146
+ return _this;
147
+ }
148
+ return PhysXFixedJoint;
149
+ }(PhysXJoint);
154
150
 
155
- /**
156
- * A joint which behaves in a similar way to a hinge or axle.
157
- */ var PhysXHingeJoint = /*#__PURE__*/ function(PhysXJoint1) {
158
- _inherits(PhysXHingeJoint, PhysXJoint1);
159
- function PhysXHingeJoint(collider) {
160
- var _this;
161
- _this = PhysXJoint1.call(this) || this;
162
- _this._axisRotationQuaternion = new engine.Quaternion();
163
- _this._swingOffset = new engine.Vector3();
164
- _this._velocity = new engine.Vector3();
165
- _this._collider = collider;
166
- _this._pxJoint = exports.PhysXPhysics._pxPhysics.createRevoluteJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
167
- return _this;
168
- }
169
- var _proto = PhysXHingeJoint.prototype;
170
- /**
171
- * {@inheritDoc IHingeJoint.setAxis }
172
- */ _proto.setAxis = function setAxis(value) {
173
- var xAxis = PhysXJoint._xAxis;
174
- var axisRotationQuaternion = this._axisRotationQuaternion;
175
- xAxis.set(1, 0, 0);
176
- value.normalize();
177
- var angle = Math.acos(engine.Vector3.dot(xAxis, value));
178
- engine.Vector3.cross(xAxis, value, xAxis);
179
- engine.Quaternion.rotationAxisAngle(xAxis, angle, axisRotationQuaternion);
180
- this._setLocalPose(0, this._swingOffset, axisRotationQuaternion);
181
- };
182
- /**
183
- * {@inheritDoc IHingeJoint.setSwingOffset }
184
- */ _proto.setSwingOffset = function setSwingOffset(value) {
185
- this._swingOffset.copyFrom(value);
186
- this._setLocalPose(1, this._swingOffset, this._axisRotationQuaternion);
187
- };
188
- /**
189
- * {@inheritDoc IHingeJoint.getAngle }
190
- */ _proto.getAngle = function getAngle() {
191
- return this._pxJoint.getAngle();
192
- };
193
- /**
194
- * {@inheritDoc IHingeJoint.getVelocity }
195
- */ _proto.getVelocity = function getVelocity() {
196
- var velocity = this._velocity;
197
- velocity.copyFrom(this._pxJoint.getVelocity());
198
- return velocity;
199
- };
200
- /**
201
- * {@inheritDoc IHingeJoint.setHardLimitCone }
202
- */ _proto.setHardLimit = function setHardLimit(lowerLimit, upperLimit, contactDist) {
203
- this._pxJoint.setHardLimit(lowerLimit, upperLimit, contactDist);
204
- };
205
- /**
206
- * {@inheritDoc IHingeJoint.setHardLimitCone }
207
- */ _proto.setSoftLimit = function setSoftLimit(lowerLimit, upperLimit, stiffness, damping) {
208
- this._pxJoint.setSoftLimit(lowerLimit, upperLimit, stiffness, damping);
209
- };
210
- /**
211
- * {@inheritDoc IHingeJoint.setDriveVelocity }
212
- */ _proto.setDriveVelocity = function setDriveVelocity(velocity) {
213
- this._pxJoint.setDriveVelocity(velocity);
214
- };
215
- /**
216
- * {@inheritDoc IHingeJoint.setDriveForceLimit }
217
- */ _proto.setDriveForceLimit = function setDriveForceLimit(limit) {
218
- this._pxJoint.setDriveForceLimit(limit);
219
- };
220
- /**
221
- * {@inheritDoc IHingeJoint.setDriveGearRatio }
222
- */ _proto.setDriveGearRatio = function setDriveGearRatio(ratio) {
223
- this._pxJoint.setDriveGearRatio(ratio);
224
- };
225
- /**
226
- * {@inheritDoc IHingeJoint.setHingeJointFlag }
227
- */ _proto.setHingeJointFlag = function setHingeJointFlag(flag, value) {
228
- this._pxJoint.setRevoluteJointFlag(flag, value);
229
- };
230
- return PhysXHingeJoint;
231
- }(PhysXJoint);
151
+ /**
152
+ * A joint which behaves in a similar way to a hinge or axle.
153
+ */ var PhysXHingeJoint = /*#__PURE__*/ function(PhysXJoint1) {
154
+ _inherits(PhysXHingeJoint, PhysXJoint1);
155
+ function PhysXHingeJoint(collider) {
156
+ var _this;
157
+ _this = PhysXJoint1.call(this) || this;
158
+ _this._axisRotationQuaternion = new engine.Quaternion();
159
+ _this._swingOffset = new engine.Vector3();
160
+ _this._velocity = new engine.Vector3();
161
+ _this._collider = collider;
162
+ _this._pxJoint = exports.PhysXPhysics._pxPhysics.createRevoluteJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
163
+ return _this;
164
+ }
165
+ var _proto = PhysXHingeJoint.prototype;
166
+ /**
167
+ * {@inheritDoc IHingeJoint.setAxis }
168
+ */ _proto.setAxis = function setAxis(value) {
169
+ var xAxis = PhysXJoint._xAxis;
170
+ var axisRotationQuaternion = this._axisRotationQuaternion;
171
+ xAxis.set(1, 0, 0);
172
+ value.normalize();
173
+ var angle = Math.acos(engine.Vector3.dot(xAxis, value));
174
+ engine.Vector3.cross(xAxis, value, xAxis);
175
+ engine.Quaternion.rotationAxisAngle(xAxis, angle, axisRotationQuaternion);
176
+ this._setLocalPose(0, this._swingOffset, axisRotationQuaternion);
177
+ };
178
+ /**
179
+ * {@inheritDoc IHingeJoint.setSwingOffset }
180
+ */ _proto.setSwingOffset = function setSwingOffset(value) {
181
+ this._swingOffset.copyFrom(value);
182
+ this._setLocalPose(1, this._swingOffset, this._axisRotationQuaternion);
183
+ };
184
+ /**
185
+ * {@inheritDoc IHingeJoint.getAngle }
186
+ */ _proto.getAngle = function getAngle() {
187
+ return this._pxJoint.getAngle();
188
+ };
189
+ /**
190
+ * {@inheritDoc IHingeJoint.getVelocity }
191
+ */ _proto.getVelocity = function getVelocity() {
192
+ var velocity = this._velocity;
193
+ velocity.copyFrom(this._pxJoint.getVelocity());
194
+ return velocity;
195
+ };
196
+ /**
197
+ * {@inheritDoc IHingeJoint.setHardLimitCone }
198
+ */ _proto.setHardLimit = function setHardLimit(lowerLimit, upperLimit, contactDist) {
199
+ this._pxJoint.setHardLimit(lowerLimit, upperLimit, contactDist);
200
+ };
201
+ /**
202
+ * {@inheritDoc IHingeJoint.setHardLimitCone }
203
+ */ _proto.setSoftLimit = function setSoftLimit(lowerLimit, upperLimit, stiffness, damping) {
204
+ this._pxJoint.setSoftLimit(lowerLimit, upperLimit, stiffness, damping);
205
+ };
206
+ /**
207
+ * {@inheritDoc IHingeJoint.setDriveVelocity }
208
+ */ _proto.setDriveVelocity = function setDriveVelocity(velocity) {
209
+ this._pxJoint.setDriveVelocity(velocity);
210
+ };
211
+ /**
212
+ * {@inheritDoc IHingeJoint.setDriveForceLimit }
213
+ */ _proto.setDriveForceLimit = function setDriveForceLimit(limit) {
214
+ this._pxJoint.setDriveForceLimit(limit);
215
+ };
216
+ /**
217
+ * {@inheritDoc IHingeJoint.setDriveGearRatio }
218
+ */ _proto.setDriveGearRatio = function setDriveGearRatio(ratio) {
219
+ this._pxJoint.setDriveGearRatio(ratio);
220
+ };
221
+ /**
222
+ * {@inheritDoc IHingeJoint.setHingeJointFlag }
223
+ */ _proto.setHingeJointFlag = function setHingeJointFlag(flag, value) {
224
+ this._pxJoint.setRevoluteJointFlag(flag, value);
225
+ };
226
+ return PhysXHingeJoint;
227
+ }(PhysXJoint);
232
228
 
233
- /**
234
- * a joint that maintains an upper or lower bound (or both) on the distance between two points on different objects
235
- */ var PhysXSpringJoint = /*#__PURE__*/ function(PhysXJoint1) {
236
- _inherits(PhysXSpringJoint, PhysXJoint1);
237
- function PhysXSpringJoint(collider) {
238
- var _this;
239
- _this = PhysXJoint1.call(this) || this;
240
- _this._swingOffset = new engine.Vector3();
241
- _this._collider = collider;
242
- _this._pxJoint = exports.PhysXPhysics._pxPhysics.createDistanceJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
243
- _this._pxJoint.setDistanceJointFlag(2, true); // enable max distance;
244
- _this._pxJoint.setDistanceJointFlag(4, true); // enable min distance;
245
- _this._pxJoint.setDistanceJointFlag(8, true); // enable spring;
246
- return _this;
247
- }
248
- var _proto = PhysXSpringJoint.prototype;
249
- /**
250
- * {@inheritDoc ISpringJoint.setSwingOffset }
251
- */ _proto.setSwingOffset = function setSwingOffset(value) {
252
- this._swingOffset.copyFrom(value);
253
- this._setLocalPose(1, value, PhysXJoint._defaultQuat);
254
- };
255
- /**
256
- * {@inheritDoc ISpringJoint.setMinDistance }
257
- */ _proto.setMinDistance = function setMinDistance(distance) {
258
- this._pxJoint.setMinDistance(distance);
259
- };
260
- /**
261
- * {@inheritDoc ISpringJoint.setMaxDistance }
262
- */ _proto.setMaxDistance = function setMaxDistance(distance) {
263
- this._pxJoint.setMaxDistance(distance);
264
- };
265
- /**
266
- * {@inheritDoc ISpringJoint.setTolerance }
267
- */ _proto.setTolerance = function setTolerance(tolerance) {
268
- this._pxJoint.setTolerance(tolerance);
269
- };
270
- /**
271
- * {@inheritDoc ISpringJoint.setStiffness }
272
- */ _proto.setStiffness = function setStiffness(stiffness) {
273
- this._pxJoint.setStiffness(stiffness);
274
- };
275
- /**
276
- * {@inheritDoc ISpringJoint.setDamping }
277
- */ _proto.setDamping = function setDamping(damping) {
278
- this._pxJoint.setDamping(damping);
279
- };
280
- return PhysXSpringJoint;
281
- }(PhysXJoint);
229
+ /**
230
+ * a joint that maintains an upper or lower bound (or both) on the distance between two points on different objects
231
+ */ var PhysXSpringJoint = /*#__PURE__*/ function(PhysXJoint1) {
232
+ _inherits(PhysXSpringJoint, PhysXJoint1);
233
+ function PhysXSpringJoint(collider) {
234
+ var _this;
235
+ _this = PhysXJoint1.call(this) || this;
236
+ _this._swingOffset = new engine.Vector3();
237
+ _this._collider = collider;
238
+ _this._pxJoint = exports.PhysXPhysics._pxPhysics.createDistanceJoint(null, PhysXJoint._defaultVec, PhysXJoint._defaultQuat, collider._pxActor, PhysXJoint._defaultVec, PhysXJoint._defaultQuat);
239
+ _this._pxJoint.setDistanceJointFlag(2, true); // enable max distance;
240
+ _this._pxJoint.setDistanceJointFlag(4, true); // enable min distance;
241
+ _this._pxJoint.setDistanceJointFlag(8, true); // enable spring;
242
+ return _this;
243
+ }
244
+ var _proto = PhysXSpringJoint.prototype;
245
+ /**
246
+ * {@inheritDoc ISpringJoint.setSwingOffset }
247
+ */ _proto.setSwingOffset = function setSwingOffset(value) {
248
+ this._swingOffset.copyFrom(value);
249
+ this._setLocalPose(1, value, PhysXJoint._defaultQuat);
250
+ };
251
+ /**
252
+ * {@inheritDoc ISpringJoint.setMinDistance }
253
+ */ _proto.setMinDistance = function setMinDistance(distance) {
254
+ this._pxJoint.setMinDistance(distance);
255
+ };
256
+ /**
257
+ * {@inheritDoc ISpringJoint.setMaxDistance }
258
+ */ _proto.setMaxDistance = function setMaxDistance(distance) {
259
+ this._pxJoint.setMaxDistance(distance);
260
+ };
261
+ /**
262
+ * {@inheritDoc ISpringJoint.setTolerance }
263
+ */ _proto.setTolerance = function setTolerance(tolerance) {
264
+ this._pxJoint.setTolerance(tolerance);
265
+ };
266
+ /**
267
+ * {@inheritDoc ISpringJoint.setStiffness }
268
+ */ _proto.setStiffness = function setStiffness(stiffness) {
269
+ this._pxJoint.setStiffness(stiffness);
270
+ };
271
+ /**
272
+ * {@inheritDoc ISpringJoint.setDamping }
273
+ */ _proto.setDamping = function setDamping(damping) {
274
+ this._pxJoint.setDamping(damping);
275
+ };
276
+ return PhysXSpringJoint;
277
+ }(PhysXJoint);
282
278
 
283
- /**
284
- * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
285
- */ var DisorderedArray = /*#__PURE__*/ function() {
286
- function DisorderedArray(count) {
287
- if (count === void 0) count = 0;
288
- this.length = 0;
289
- this._elements = new Array(count);
290
- }
291
- var _proto = DisorderedArray.prototype;
292
- _proto.add = function add(element) {
293
- if (this.length === this._elements.length) this._elements.push(element);
294
- else this._elements[this.length] = element;
295
- this.length++;
296
- };
297
- _proto.delete = function _delete(element) {
298
- //TODO: It can be optimized for custom binary search and other algorithms, currently this._elements>=this.length wastes performance.
299
- var index = this._elements.indexOf(element);
300
- this.deleteByIndex(index);
301
- };
302
- _proto.get = function get(index) {
303
- if (index >= this.length) {
304
- throw "Index is out of range.";
305
- }
306
- return this._elements[index];
307
- };
308
- /**
309
- *
310
- * @param index
311
- * @returns The replaced item is used to reset its index.
312
- */ _proto.deleteByIndex = function deleteByIndex(index) {
313
- var elements = this._elements;
314
- var end = null;
315
- var lastIndex = this.length - 1;
316
- if (index !== lastIndex) {
317
- end = elements[lastIndex];
318
- elements[index] = end;
319
- }
320
- this.length--;
321
- return end;
322
- };
323
- _proto.garbageCollection = function garbageCollection() {
324
- this._elements.length = this.length;
325
- };
326
- return DisorderedArray;
327
- }();
279
+ /**
280
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
281
+ */ var DisorderedArray = /*#__PURE__*/ function() {
282
+ function DisorderedArray(count) {
283
+ if (count === void 0) count = 0;
284
+ this.length = 0;
285
+ this._elements = new Array(count);
286
+ }
287
+ var _proto = DisorderedArray.prototype;
288
+ _proto.add = function add(element) {
289
+ if (this.length === this._elements.length) this._elements.push(element);
290
+ else this._elements[this.length] = element;
291
+ this.length++;
292
+ };
293
+ _proto.delete = function _delete(element) {
294
+ //TODO: It can be optimized for custom binary search and other algorithms, currently this._elements>=this.length wastes performance.
295
+ var index = this._elements.indexOf(element);
296
+ this.deleteByIndex(index);
297
+ };
298
+ _proto.get = function get(index) {
299
+ if (index >= this.length) {
300
+ throw "Index is out of range.";
301
+ }
302
+ return this._elements[index];
303
+ };
304
+ /**
305
+ *
306
+ * @param index
307
+ * @returns The replaced item is used to reset its index.
308
+ */ _proto.deleteByIndex = function deleteByIndex(index) {
309
+ var elements = this._elements;
310
+ var end = null;
311
+ var lastIndex = this.length - 1;
312
+ if (index !== lastIndex) {
313
+ end = elements[lastIndex];
314
+ elements[index] = end;
315
+ }
316
+ this.length--;
317
+ return end;
318
+ };
319
+ _proto.garbageCollection = function garbageCollection() {
320
+ this._elements.length = this.length;
321
+ };
322
+ return DisorderedArray;
323
+ }();
328
324
 
329
- var ShapeFlag;
330
- (function(ShapeFlag) {
331
- ShapeFlag[ShapeFlag[/** The shape will partake in collision in the physical simulation. */ "SIMULATION_SHAPE"] = 1] = "SIMULATION_SHAPE";
332
- ShapeFlag[ShapeFlag[/** The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). */ "SCENE_QUERY_SHAPE"] = 2] = "SCENE_QUERY_SHAPE";
333
- ShapeFlag[ShapeFlag[/** The shape is a trigger which can send reports whenever other shapes enter/leave its volume. */ "TRIGGER_SHAPE"] = 4] = "TRIGGER_SHAPE";
334
- })(ShapeFlag || (ShapeFlag = {}));
335
- /**
336
- * Abstract class for collider shapes.
337
- */ var PhysXColliderShape = /*#__PURE__*/ function() {
338
- function PhysXColliderShape() {
339
- /** @internal */ this._controllers = new DisorderedArray();
340
- this._scale = new engine.Vector3(1, 1, 1);
341
- this._position = new engine.Vector3();
342
- this._rotation = null;
343
- this._axis = null;
344
- this._physxRotation = new engine.Quaternion();
345
- this._shapeFlags = 2 | 1;
346
- /** @internal */ this._pxMaterials = new Array(1);
347
- }
348
- var _proto = PhysXColliderShape.prototype;
349
- /**
350
- * {@inheritDoc IColliderShape.setRotation }
351
- */ _proto.setRotation = function setRotation(value) {
352
- this._rotation = value;
353
- engine.Quaternion.rotationYawPitchRoll(value.x, value.y, value.z, this._physxRotation);
354
- this._axis && engine.Quaternion.multiply(this._physxRotation, this._axis, this._physxRotation);
355
- this._physxRotation.normalize();
356
- this._setLocalPose();
357
- };
358
- /**
359
- * {@inheritDoc IColliderShape.setPosition }
360
- */ _proto.setPosition = function setPosition(value) {
361
- if (value !== this._position) {
362
- this._position.copyFrom(value);
363
- }
364
- this._setLocalPose();
365
- };
366
- /**
367
- * {@inheritDoc IColliderShape.setContactOffset }
368
- * @default 0.02f * PxTolerancesScale::length
369
- */ _proto.setContactOffset = function setContactOffset(offset) {
370
- this._pxShape.setContactOffset(offset);
371
- var controllers = this._controllers;
372
- for(var i = 0, n = controllers.length; i < n; i++){
373
- controllers.get(i)._pxController.setContactOffset(offset);
374
- }
375
- };
376
- /**
377
- * {@inheritDoc IColliderShape.setMaterial }
378
- */ _proto.setMaterial = function setMaterial(value) {
379
- this._pxMaterials[0] = value._pxMaterial;
380
- this._pxShape.setMaterials(this._pxMaterials);
381
- };
382
- /**
383
- * {@inheritDoc IColliderShape.setIsTrigger }
384
- */ _proto.setIsTrigger = function setIsTrigger(value) {
385
- this._modifyFlag(1, !value);
386
- this._modifyFlag(4, value);
387
- this._setShapeFlags(this._shapeFlags);
388
- };
389
- /**
390
- * {@inheritDoc IColliderShape.destroy }
391
- */ _proto.destroy = function destroy() {
392
- this._pxShape.release();
393
- };
394
- /**
395
- * @internal
396
- */ _proto._setShapeFlags = function _setShapeFlags(flags) {
397
- this._shapeFlags = flags;
398
- this._pxShape.setFlags(new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
399
- };
400
- _proto._setLocalPose = function _setLocalPose() {
401
- var transform = PhysXColliderShape.transform;
402
- engine.Vector3.multiply(this._position, this._scale, transform.translation);
403
- transform.rotation = this._physxRotation;
404
- this._pxShape.setLocalPose(transform);
405
- };
406
- _proto._initialize = function _initialize(material, id) {
407
- this._id = id;
408
- this._pxMaterials[0] = material._pxMaterial;
409
- this._pxShape = exports.PhysXPhysics._pxPhysics.createShape(this._pxGeometry, material._pxMaterial, true, new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
410
- this._pxShape.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(id, 0, 0, 0));
411
- };
412
- _proto._modifyFlag = function _modifyFlag(flag, value) {
413
- this._shapeFlags = value ? this._shapeFlags | flag : this._shapeFlags & ~flag;
414
- };
415
- return PhysXColliderShape;
416
- }();
417
- PhysXColliderShape.halfSqrt = 0.70710678118655;
418
- PhysXColliderShape.transform = {
419
- translation: new engine.Vector3(),
420
- rotation: null
421
- };
325
+ var ShapeFlag;
326
+ (function(ShapeFlag) {
327
+ ShapeFlag[ShapeFlag[/** The shape will partake in collision in the physical simulation. */ "SIMULATION_SHAPE"] = 1] = "SIMULATION_SHAPE";
328
+ ShapeFlag[ShapeFlag[/** The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). */ "SCENE_QUERY_SHAPE"] = 2] = "SCENE_QUERY_SHAPE";
329
+ ShapeFlag[ShapeFlag[/** The shape is a trigger which can send reports whenever other shapes enter/leave its volume. */ "TRIGGER_SHAPE"] = 4] = "TRIGGER_SHAPE";
330
+ })(ShapeFlag || (ShapeFlag = {}));
331
+ /**
332
+ * Abstract class for collider shapes.
333
+ */ var PhysXColliderShape = /*#__PURE__*/ function() {
334
+ function PhysXColliderShape() {
335
+ /** @internal */ this._controllers = new DisorderedArray();
336
+ this._scale = new engine.Vector3(1, 1, 1);
337
+ this._position = new engine.Vector3();
338
+ this._rotation = null;
339
+ this._axis = null;
340
+ this._physxRotation = new engine.Quaternion();
341
+ this._shapeFlags = 2 | 1;
342
+ /** @internal */ this._pxMaterials = new Array(1);
343
+ }
344
+ var _proto = PhysXColliderShape.prototype;
345
+ /**
346
+ * {@inheritDoc IColliderShape.setRotation }
347
+ */ _proto.setRotation = function setRotation(value) {
348
+ this._rotation = value;
349
+ engine.Quaternion.rotationYawPitchRoll(value.x, value.y, value.z, this._physxRotation);
350
+ this._axis && engine.Quaternion.multiply(this._physxRotation, this._axis, this._physxRotation);
351
+ this._physxRotation.normalize();
352
+ this._setLocalPose();
353
+ };
354
+ /**
355
+ * {@inheritDoc IColliderShape.setPosition }
356
+ */ _proto.setPosition = function setPosition(value) {
357
+ if (value !== this._position) {
358
+ this._position.copyFrom(value);
359
+ }
360
+ this._setLocalPose();
361
+ };
362
+ /**
363
+ * {@inheritDoc IColliderShape.setContactOffset }
364
+ * @default 0.02f * PxTolerancesScale::length
365
+ */ _proto.setContactOffset = function setContactOffset(offset) {
366
+ this._pxShape.setContactOffset(offset);
367
+ var controllers = this._controllers;
368
+ for(var i = 0, n = controllers.length; i < n; i++){
369
+ controllers.get(i)._pxController.setContactOffset(offset);
370
+ }
371
+ };
372
+ /**
373
+ * {@inheritDoc IColliderShape.setMaterial }
374
+ */ _proto.setMaterial = function setMaterial(value) {
375
+ this._pxMaterials[0] = value._pxMaterial;
376
+ this._pxShape.setMaterials(this._pxMaterials);
377
+ };
378
+ /**
379
+ * {@inheritDoc IColliderShape.setIsTrigger }
380
+ */ _proto.setIsTrigger = function setIsTrigger(value) {
381
+ this._modifyFlag(1, !value);
382
+ this._modifyFlag(4, value);
383
+ this._setShapeFlags(this._shapeFlags);
384
+ };
385
+ /**
386
+ * {@inheritDoc IColliderShape.destroy }
387
+ */ _proto.destroy = function destroy() {
388
+ this._pxShape.release();
389
+ };
390
+ /**
391
+ * @internal
392
+ */ _proto._setShapeFlags = function _setShapeFlags(flags) {
393
+ this._shapeFlags = flags;
394
+ this._pxShape.setFlags(new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
395
+ };
396
+ _proto._setLocalPose = function _setLocalPose() {
397
+ var transform = PhysXColliderShape.transform;
398
+ engine.Vector3.multiply(this._position, this._scale, transform.translation);
399
+ transform.rotation = this._physxRotation;
400
+ this._pxShape.setLocalPose(transform);
401
+ };
402
+ _proto._initialize = function _initialize(material, id) {
403
+ this._id = id;
404
+ this._pxMaterials[0] = material._pxMaterial;
405
+ this._pxShape = exports.PhysXPhysics._pxPhysics.createShape(this._pxGeometry, material._pxMaterial, true, new exports.PhysXPhysics._physX.PxShapeFlags(this._shapeFlags));
406
+ this._pxShape.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(id, 0, 0, 0));
407
+ };
408
+ _proto._modifyFlag = function _modifyFlag(flag, value) {
409
+ this._shapeFlags = value ? this._shapeFlags | flag : this._shapeFlags & ~flag;
410
+ };
411
+ return PhysXColliderShape;
412
+ }();
413
+ (function() {
414
+ PhysXColliderShape.halfSqrt = 0.70710678118655;
415
+ })();
416
+ (function() {
417
+ PhysXColliderShape.transform = {
418
+ translation: new engine.Vector3(),
419
+ rotation: null
420
+ };
421
+ })();
422
422
 
423
- /**
424
- * Box collider shape in PhysX.
425
- */ var PhysXBoxColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
426
- _inherits(PhysXBoxColliderShape, PhysXColliderShape);
427
- function PhysXBoxColliderShape(uniqueID, size, material) {
428
- var _this;
429
- _this = PhysXColliderShape.call(this) || this;
430
- /** @internal */ _this._halfSize = new engine.Vector3();
431
- _this._halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
432
- _this._pxGeometry = new exports.PhysXPhysics._physX.PxBoxGeometry(_this._halfSize.x * _this._scale.x, _this._halfSize.y * _this._scale.y, _this._halfSize.z * _this._scale.z);
433
- _this._initialize(material, uniqueID);
434
- _this._setLocalPose();
435
- return _this;
436
- }
437
- var _proto = PhysXBoxColliderShape.prototype;
438
- /**
439
- * {@inheritDoc IBoxColliderShape.setSize }
440
- */ _proto.setSize = function setSize(value) {
441
- this._halfSize.set(value.x * 0.5, value.y * 0.5, value.z * 0.5);
442
- engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
443
- this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
444
- this._pxShape.setGeometry(this._pxGeometry);
445
- var controllers = this._controllers;
446
- for(var i = 0, n = controllers.length; i < n; i++){
447
- var pxController = controllers.get(i)._pxController;
448
- pxController.setHalfHeight(this._halfSize.x);
449
- pxController.setHalfSideExtent(this._halfSize.y);
450
- pxController.setHalfForwardExtent(this._halfSize.z);
451
- }
452
- };
453
- /**
454
- * {@inheritDoc IColliderShape.setWorldScale }
455
- */ _proto.setWorldScale = function setWorldScale(scale) {
456
- this._scale.copyFrom(scale);
457
- this._setLocalPose();
458
- engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
459
- this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
460
- this._pxShape.setGeometry(this._pxGeometry);
461
- };
462
- return PhysXBoxColliderShape;
463
- }(PhysXColliderShape);
464
- PhysXBoxColliderShape._tempHalfExtents = new engine.Vector3();
423
+ /**
424
+ * Box collider shape in PhysX.
425
+ */ var PhysXBoxColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
426
+ _inherits(PhysXBoxColliderShape, PhysXColliderShape);
427
+ function PhysXBoxColliderShape(uniqueID, size, material) {
428
+ var _this;
429
+ _this = PhysXColliderShape.call(this) || this;
430
+ /** @internal */ _this._halfSize = new engine.Vector3();
431
+ _this._halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
432
+ _this._pxGeometry = new exports.PhysXPhysics._physX.PxBoxGeometry(_this._halfSize.x * _this._scale.x, _this._halfSize.y * _this._scale.y, _this._halfSize.z * _this._scale.z);
433
+ _this._initialize(material, uniqueID);
434
+ _this._setLocalPose();
435
+ return _this;
436
+ }
437
+ var _proto = PhysXBoxColliderShape.prototype;
438
+ /**
439
+ * {@inheritDoc IBoxColliderShape.setSize }
440
+ */ _proto.setSize = function setSize(value) {
441
+ this._halfSize.set(value.x * 0.5, value.y * 0.5, value.z * 0.5);
442
+ engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
443
+ this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
444
+ this._pxShape.setGeometry(this._pxGeometry);
445
+ var controllers = this._controllers;
446
+ for(var i = 0, n = controllers.length; i < n; i++){
447
+ var pxController = controllers.get(i)._pxController;
448
+ pxController.setHalfHeight(this._halfSize.x);
449
+ pxController.setHalfSideExtent(this._halfSize.y);
450
+ pxController.setHalfForwardExtent(this._halfSize.z);
451
+ }
452
+ };
453
+ /**
454
+ * {@inheritDoc IColliderShape.setWorldScale }
455
+ */ _proto.setWorldScale = function setWorldScale(scale) {
456
+ this._scale.copyFrom(scale);
457
+ this._setLocalPose();
458
+ engine.Vector3.multiply(this._halfSize, this._scale, PhysXBoxColliderShape._tempHalfExtents);
459
+ this._pxGeometry.halfExtents = PhysXBoxColliderShape._tempHalfExtents;
460
+ this._pxShape.setGeometry(this._pxGeometry);
461
+ };
462
+ return PhysXBoxColliderShape;
463
+ }(PhysXColliderShape);
464
+ (function() {
465
+ PhysXBoxColliderShape._tempHalfExtents = new engine.Vector3();
466
+ })();
465
467
 
466
- /**
467
- * Capsule collider shape in PhysX.
468
- */ var PhysXCapsuleColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
469
- _inherits(PhysXCapsuleColliderShape, PhysXColliderShape1);
470
- function PhysXCapsuleColliderShape(uniqueID, radius, height, material) {
471
- var _this;
472
- _this = PhysXColliderShape1.call(this) || this;
473
- _this._upAxis = /** Up axis is Y. */ 1;
474
- _this._radius = radius;
475
- _this._halfHeight = height * 0.5;
476
- _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
477
- _this._physxRotation.copyFrom(_this._axis);
478
- _this._pxGeometry = new exports.PhysXPhysics._physX.PxCapsuleGeometry(_this._radius, _this._halfHeight);
479
- _this._initialize(material, uniqueID);
480
- _this._setLocalPose();
481
- return _this;
482
- }
483
- var _proto = PhysXCapsuleColliderShape.prototype;
484
- /**
485
- * {@inheritDoc ICapsuleColliderShape.setRadius }
486
- */ _proto.setRadius = function setRadius(value) {
487
- this._radius = value;
488
- switch(this._upAxis){
489
- case /** Up axis is X. */ 0:
490
- this._pxGeometry.radius = this._radius * Math.max(this._scale.y, this._scale.z);
491
- break;
492
- case 1:
493
- this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.z);
494
- break;
495
- case /** Up axis is Z. */ 2:
496
- this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.y);
497
- break;
498
- }
499
- this._pxShape.setGeometry(this._pxGeometry);
500
- var controllers = this._controllers;
501
- for(var i = 0, n = controllers.length; i < n; i++){
502
- controllers.get(i)._pxController.setRadius(value);
503
- }
504
- };
505
- /**
506
- * {@inheritDoc ICapsuleColliderShape.setHeight }
507
- */ _proto.setHeight = function setHeight(value) {
508
- this._halfHeight = value * 0.5;
509
- switch(this._upAxis){
510
- case 0:
511
- this._pxGeometry.halfHeight = this._halfHeight * this._scale.x;
512
- break;
513
- case 1:
514
- this._pxGeometry.halfHeight = this._halfHeight * this._scale.y;
515
- break;
516
- case 2:
517
- this._pxGeometry.halfHeight = this._halfHeight * this._scale.z;
518
- break;
519
- }
520
- this._pxShape.setGeometry(this._pxGeometry);
521
- var controllers = this._controllers;
522
- for(var i = 0, n = controllers.length; i < n; i++){
523
- controllers.get(i)._pxController.setHeight(value);
524
- }
525
- };
526
- /**
527
- * {@inheritDoc ICapsuleColliderShape.setUpAxis }
528
- */ _proto.setUpAxis = function setUpAxis(upAxis) {
529
- var _this = this, rotation = _this._rotation, axis = _this._axis, physxRotation = _this._physxRotation;
530
- this._upAxis = upAxis;
531
- switch(this._upAxis){
532
- case 0:
533
- axis.set(0, 0, 0, 1);
534
- break;
535
- case 1:
536
- axis.set(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
537
- break;
538
- case 2:
539
- axis.set(0, PhysXColliderShape.halfSqrt, 0, PhysXColliderShape.halfSqrt);
540
- break;
541
- }
542
- if (rotation) {
543
- engine.Quaternion.rotationYawPitchRoll(rotation.x, rotation.y, rotation.z, physxRotation);
544
- engine.Quaternion.multiply(physxRotation, axis, physxRotation);
545
- } else {
546
- physxRotation.copyFrom(axis);
547
- }
548
- this._setLocalPose();
549
- };
550
- /**
551
- * {@inheritDoc IColliderShape.setWorldScale }
552
- */ _proto.setWorldScale = function setWorldScale(scale) {
553
- this._scale.copyFrom(scale);
554
- this._setLocalPose();
555
- switch(this._upAxis){
556
- case 0:
557
- this._pxGeometry.radius = this._radius * Math.max(scale.y, scale.z);
558
- this._pxGeometry.halfHeight = this._halfHeight * scale.x;
559
- break;
560
- case 1:
561
- this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.z);
562
- this._pxGeometry.halfHeight = this._halfHeight * scale.y;
563
- break;
564
- case 2:
565
- this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.y);
566
- this._pxGeometry.halfHeight = this._halfHeight * scale.z;
567
- break;
568
- }
569
- this._pxShape.setGeometry(this._pxGeometry);
570
- };
571
- return PhysXCapsuleColliderShape;
572
- }(PhysXColliderShape);
573
- var /**
574
- * The up axis of the collider shape.
575
- */ ColliderShapeUpAxis;
576
- (function(ColliderShapeUpAxis) {
577
- ColliderShapeUpAxis[ColliderShapeUpAxis["X"] = 0] = "X";
578
- ColliderShapeUpAxis[ColliderShapeUpAxis["Y"] = 1] = "Y";
579
- ColliderShapeUpAxis[ColliderShapeUpAxis["Z"] = 2] = "Z";
580
- })(ColliderShapeUpAxis || (ColliderShapeUpAxis = {}));
468
+ /**
469
+ * Capsule collider shape in PhysX.
470
+ */ var PhysXCapsuleColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
471
+ _inherits(PhysXCapsuleColliderShape, PhysXColliderShape1);
472
+ function PhysXCapsuleColliderShape(uniqueID, radius, height, material) {
473
+ var _this;
474
+ _this = PhysXColliderShape1.call(this) || this;
475
+ _this._upAxis = /** Up axis is Y. */ 1;
476
+ _this._radius = radius;
477
+ _this._halfHeight = height * 0.5;
478
+ _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
479
+ _this._physxRotation.copyFrom(_this._axis);
480
+ _this._pxGeometry = new exports.PhysXPhysics._physX.PxCapsuleGeometry(_this._radius, _this._halfHeight);
481
+ _this._initialize(material, uniqueID);
482
+ _this._setLocalPose();
483
+ return _this;
484
+ }
485
+ var _proto = PhysXCapsuleColliderShape.prototype;
486
+ /**
487
+ * {@inheritDoc ICapsuleColliderShape.setRadius }
488
+ */ _proto.setRadius = function setRadius(value) {
489
+ this._radius = value;
490
+ switch(this._upAxis){
491
+ case /** Up axis is X. */ 0:
492
+ this._pxGeometry.radius = this._radius * Math.max(this._scale.y, this._scale.z);
493
+ break;
494
+ case 1:
495
+ this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.z);
496
+ break;
497
+ case /** Up axis is Z. */ 2:
498
+ this._pxGeometry.radius = this._radius * Math.max(this._scale.x, this._scale.y);
499
+ break;
500
+ }
501
+ this._pxShape.setGeometry(this._pxGeometry);
502
+ var controllers = this._controllers;
503
+ for(var i = 0, n = controllers.length; i < n; i++){
504
+ controllers.get(i)._pxController.setRadius(value);
505
+ }
506
+ };
507
+ /**
508
+ * {@inheritDoc ICapsuleColliderShape.setHeight }
509
+ */ _proto.setHeight = function setHeight(value) {
510
+ this._halfHeight = value * 0.5;
511
+ switch(this._upAxis){
512
+ case 0:
513
+ this._pxGeometry.halfHeight = this._halfHeight * this._scale.x;
514
+ break;
515
+ case 1:
516
+ this._pxGeometry.halfHeight = this._halfHeight * this._scale.y;
517
+ break;
518
+ case 2:
519
+ this._pxGeometry.halfHeight = this._halfHeight * this._scale.z;
520
+ break;
521
+ }
522
+ this._pxShape.setGeometry(this._pxGeometry);
523
+ var controllers = this._controllers;
524
+ for(var i = 0, n = controllers.length; i < n; i++){
525
+ controllers.get(i)._pxController.setHeight(value);
526
+ }
527
+ };
528
+ /**
529
+ * {@inheritDoc ICapsuleColliderShape.setUpAxis }
530
+ */ _proto.setUpAxis = function setUpAxis(upAxis) {
531
+ var _this = this, rotation = _this._rotation, axis = _this._axis, physxRotation = _this._physxRotation;
532
+ this._upAxis = upAxis;
533
+ switch(this._upAxis){
534
+ case 0:
535
+ axis.set(0, 0, 0, 1);
536
+ break;
537
+ case 1:
538
+ axis.set(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
539
+ break;
540
+ case 2:
541
+ axis.set(0, PhysXColliderShape.halfSqrt, 0, PhysXColliderShape.halfSqrt);
542
+ break;
543
+ }
544
+ if (rotation) {
545
+ engine.Quaternion.rotationYawPitchRoll(rotation.x, rotation.y, rotation.z, physxRotation);
546
+ engine.Quaternion.multiply(physxRotation, axis, physxRotation);
547
+ } else {
548
+ physxRotation.copyFrom(axis);
549
+ }
550
+ this._setLocalPose();
551
+ };
552
+ /**
553
+ * {@inheritDoc IColliderShape.setWorldScale }
554
+ */ _proto.setWorldScale = function setWorldScale(scale) {
555
+ this._scale.copyFrom(scale);
556
+ this._setLocalPose();
557
+ switch(this._upAxis){
558
+ case 0:
559
+ this._pxGeometry.radius = this._radius * Math.max(scale.y, scale.z);
560
+ this._pxGeometry.halfHeight = this._halfHeight * scale.x;
561
+ break;
562
+ case 1:
563
+ this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.z);
564
+ this._pxGeometry.halfHeight = this._halfHeight * scale.y;
565
+ break;
566
+ case 2:
567
+ this._pxGeometry.radius = this._radius * Math.max(scale.x, scale.y);
568
+ this._pxGeometry.halfHeight = this._halfHeight * scale.z;
569
+ break;
570
+ }
571
+ this._pxShape.setGeometry(this._pxGeometry);
572
+ };
573
+ return PhysXCapsuleColliderShape;
574
+ }(PhysXColliderShape);
575
+ var /**
576
+ * The up axis of the collider shape.
577
+ */ ColliderShapeUpAxis;
578
+ (function(ColliderShapeUpAxis) {
579
+ ColliderShapeUpAxis[ColliderShapeUpAxis["X"] = 0] = "X";
580
+ ColliderShapeUpAxis[ColliderShapeUpAxis["Y"] = 1] = "Y";
581
+ ColliderShapeUpAxis[ColliderShapeUpAxis["Z"] = 2] = "Z";
582
+ })(ColliderShapeUpAxis || (ColliderShapeUpAxis = {}));
581
583
 
582
- /**
583
- * Base class for character controllers.
584
- */ var PhysXCharacterController = /*#__PURE__*/ function() {
585
- function PhysXCharacterController() {}
586
- var _proto = PhysXCharacterController.prototype;
587
- /**
588
- * {@inheritDoc ICharacterController.move }
589
- */ _proto.move = function move(disp, minDist, elapsedTime) {
590
- return this._pxController.move(disp, minDist, elapsedTime);
591
- };
592
- /**
593
- * {@inheritDoc ICharacterController.setWorldPosition }
594
- */ _proto.setWorldPosition = function setWorldPosition(position) {
595
- this._pxController && this._pxController.setPosition(position);
596
- };
597
- /**
598
- * {@inheritDoc ICharacterController.getWorldPosition }
599
- */ _proto.getWorldPosition = function getWorldPosition(position) {
600
- position.copyFrom(this._pxController.getPosition());
601
- };
602
- /**
603
- * {@inheritDoc ICharacterController.setStepOffset }
604
- */ _proto.setStepOffset = function setStepOffset(offset) {
605
- this._pxController.setStepOffset(offset);
606
- };
607
- /**
608
- * {@inheritDoc ICharacterController.setNonWalkableMode }
609
- */ _proto.setNonWalkableMode = function setNonWalkableMode(flag) {
610
- this._pxController.setNonWalkableMode(flag);
611
- };
612
- /**
613
- * {@inheritDoc ICharacterController.setUpDirection }
614
- */ _proto.setUpDirection = function setUpDirection(up) {
615
- this._pxController.setUpDirection(up);
616
- };
617
- /**
618
- * {@inheritDoc ICharacterController.setSlopeLimit }
619
- */ _proto.setSlopeLimit = function setSlopeLimit(slopeLimit) {
620
- this._pxController.setSlopeLimit(slopeLimit);
621
- };
622
- /**
623
- * {@inheritDoc ICharacterController.addShape }
624
- */ _proto.addShape = function addShape(shape) {
625
- this._pxManager && this._createPXController(this._pxManager, shape);
626
- this._shape = shape;
627
- shape._controllers.add(this);
628
- };
629
- /**
630
- * {@inheritDoc ICharacterController.removeShape }
631
- */ _proto.removeShape = function removeShape(shape) {
632
- this._destroyPXController();
633
- this._shape = null;
634
- shape._controllers.delete(this);
635
- };
636
- /**
637
- * {@inheritDoc ICharacterController.destroy }
638
- */ _proto.destroy = function destroy() {
639
- this._destroyPXController();
640
- };
641
- /**
642
- * @internal
643
- */ _proto._createPXController = function _createPXController(pxManager, shape) {
644
- var desc;
645
- if (_instanceof(shape, PhysXBoxColliderShape)) {
646
- desc = new exports.PhysXPhysics._physX.PxBoxControllerDesc();
647
- desc.halfHeight = shape._halfSize.x;
648
- desc.halfSideExtent = shape._halfSize.y;
649
- desc.halfForwardExtent = shape._halfSize.z;
650
- } else if (_instanceof(shape, PhysXCapsuleColliderShape)) {
651
- desc = new exports.PhysXPhysics._physX.PxCapsuleControllerDesc();
652
- desc.radius = shape._radius;
653
- desc.height = shape._halfHeight * 2;
654
- desc.climbingMode = 1; // constraint mode
655
- } else {
656
- throw "unsupported shape type";
657
- }
658
- desc.setMaterial(shape._pxMaterials[0]);
659
- this._pxController = pxManager._getControllerManager().createController(desc);
660
- this._pxController.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(shape._id, 0, 0, 0));
661
- };
662
- /**
663
- * @internal
664
- */ _proto._destroyPXController = function _destroyPXController() {
665
- if (this._pxController) {
666
- this._pxController.release();
667
- this._pxController = null;
668
- }
669
- };
670
- return PhysXCharacterController;
671
- }();
584
+ /**
585
+ * Base class for character controllers.
586
+ */ var PhysXCharacterController = /*#__PURE__*/ function() {
587
+ function PhysXCharacterController() {}
588
+ var _proto = PhysXCharacterController.prototype;
589
+ /**
590
+ * {@inheritDoc ICharacterController.move }
591
+ */ _proto.move = function move(disp, minDist, elapsedTime) {
592
+ return this._pxController.move(disp, minDist, elapsedTime);
593
+ };
594
+ /**
595
+ * {@inheritDoc ICharacterController.setWorldPosition }
596
+ */ _proto.setWorldPosition = function setWorldPosition(position) {
597
+ this._pxController && this._pxController.setPosition(position);
598
+ };
599
+ /**
600
+ * {@inheritDoc ICharacterController.getWorldPosition }
601
+ */ _proto.getWorldPosition = function getWorldPosition(position) {
602
+ position.copyFrom(this._pxController.getPosition());
603
+ };
604
+ /**
605
+ * {@inheritDoc ICharacterController.setStepOffset }
606
+ */ _proto.setStepOffset = function setStepOffset(offset) {
607
+ this._pxController.setStepOffset(offset);
608
+ };
609
+ /**
610
+ * {@inheritDoc ICharacterController.setNonWalkableMode }
611
+ */ _proto.setNonWalkableMode = function setNonWalkableMode(flag) {
612
+ this._pxController.setNonWalkableMode(flag);
613
+ };
614
+ /**
615
+ * {@inheritDoc ICharacterController.setUpDirection }
616
+ */ _proto.setUpDirection = function setUpDirection(up) {
617
+ this._pxController.setUpDirection(up);
618
+ };
619
+ /**
620
+ * {@inheritDoc ICharacterController.setSlopeLimit }
621
+ */ _proto.setSlopeLimit = function setSlopeLimit(slopeLimit) {
622
+ this._pxController.setSlopeLimit(slopeLimit);
623
+ };
624
+ /**
625
+ * {@inheritDoc ICharacterController.addShape }
626
+ */ _proto.addShape = function addShape(shape) {
627
+ this._pxManager && this._createPXController(this._pxManager, shape);
628
+ this._shape = shape;
629
+ shape._controllers.add(this);
630
+ };
631
+ /**
632
+ * {@inheritDoc ICharacterController.removeShape }
633
+ */ _proto.removeShape = function removeShape(shape) {
634
+ this._destroyPXController();
635
+ this._shape = null;
636
+ shape._controllers.delete(this);
637
+ };
638
+ /**
639
+ * {@inheritDoc ICharacterController.destroy }
640
+ */ _proto.destroy = function destroy() {
641
+ this._destroyPXController();
642
+ };
643
+ /**
644
+ * @internal
645
+ */ _proto._createPXController = function _createPXController(pxManager, shape) {
646
+ var desc;
647
+ if (_instanceof(shape, PhysXBoxColliderShape)) {
648
+ desc = new exports.PhysXPhysics._physX.PxBoxControllerDesc();
649
+ desc.halfHeight = shape._halfSize.x;
650
+ desc.halfSideExtent = shape._halfSize.y;
651
+ desc.halfForwardExtent = shape._halfSize.z;
652
+ } else if (_instanceof(shape, PhysXCapsuleColliderShape)) {
653
+ desc = new exports.PhysXPhysics._physX.PxCapsuleControllerDesc();
654
+ desc.radius = shape._radius;
655
+ desc.height = shape._halfHeight * 2;
656
+ desc.climbingMode = 1; // constraint mode
657
+ } else {
658
+ throw "unsupported shape type";
659
+ }
660
+ desc.setMaterial(shape._pxMaterials[0]);
661
+ this._pxController = pxManager._getControllerManager().createController(desc);
662
+ this._pxController.setQueryFilterData(new exports.PhysXPhysics._physX.PxFilterData(shape._id, 0, 0, 0));
663
+ };
664
+ /**
665
+ * @internal
666
+ */ _proto._destroyPXController = function _destroyPXController() {
667
+ if (this._pxController) {
668
+ this._pxController.release();
669
+ this._pxController = null;
670
+ }
671
+ };
672
+ return PhysXCharacterController;
673
+ }();
672
674
 
673
- /**
674
- * Abstract class of physical collider.
675
- */ var PhysXCollider = /*#__PURE__*/ function() {
676
- function PhysXCollider() {}
677
- var _proto = PhysXCollider.prototype;
678
- /**
679
- * {@inheritDoc ICollider.addShape }
680
- */ _proto.addShape = function addShape(shape) {
681
- this._pxActor.attachShape(shape._pxShape);
682
- };
683
- /**
684
- * {@inheritDoc ICollider.removeShape }
685
- */ _proto.removeShape = function removeShape(shape) {
686
- this._pxActor.detachShape(shape._pxShape, true);
687
- };
688
- /**
689
- * {@inheritDoc ICollider.setWorldTransform }
690
- */ _proto.setWorldTransform = function setWorldTransform(position, rotation) {
691
- this._pxActor.setGlobalPose(this._transform(position, rotation), true);
692
- };
693
- /**
694
- * {@inheritDoc ICollider.getWorldTransform }
695
- */ _proto.getWorldTransform = function getWorldTransform(outPosition, outRotation) {
696
- var transform = this._pxActor.getGlobalPose();
697
- outPosition.set(transform.translation.x, transform.translation.y, transform.translation.z);
698
- outRotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z, transform.rotation.w);
699
- };
700
- /**
701
- * {@inheritDoc ICollider.destroy }
702
- */ _proto.destroy = function destroy() {
703
- this._pxActor.release();
704
- };
705
- /**
706
- * @internal
707
- */ _proto._transform = function _transform(pos, rot) {
708
- var transform = PhysXCollider._tempTransform;
709
- transform.translation = pos;
710
- transform.rotation = rot.normalize();
711
- return transform;
712
- };
713
- return PhysXCollider;
714
- }();
715
- PhysXCollider._tempTransform = {
716
- translation: null,
717
- rotation: null
718
- };
675
+ /**
676
+ * Abstract class of physical collider.
677
+ */ var PhysXCollider = /*#__PURE__*/ function() {
678
+ function PhysXCollider() {}
679
+ var _proto = PhysXCollider.prototype;
680
+ /**
681
+ * {@inheritDoc ICollider.addShape }
682
+ */ _proto.addShape = function addShape(shape) {
683
+ this._pxActor.attachShape(shape._pxShape);
684
+ };
685
+ /**
686
+ * {@inheritDoc ICollider.removeShape }
687
+ */ _proto.removeShape = function removeShape(shape) {
688
+ this._pxActor.detachShape(shape._pxShape, true);
689
+ };
690
+ /**
691
+ * {@inheritDoc ICollider.setWorldTransform }
692
+ */ _proto.setWorldTransform = function setWorldTransform(position, rotation) {
693
+ this._pxActor.setGlobalPose(this._transform(position, rotation), true);
694
+ };
695
+ /**
696
+ * {@inheritDoc ICollider.getWorldTransform }
697
+ */ _proto.getWorldTransform = function getWorldTransform(outPosition, outRotation) {
698
+ var transform = this._pxActor.getGlobalPose();
699
+ outPosition.set(transform.translation.x, transform.translation.y, transform.translation.z);
700
+ outRotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z, transform.rotation.w);
701
+ };
702
+ /**
703
+ * {@inheritDoc ICollider.destroy }
704
+ */ _proto.destroy = function destroy() {
705
+ this._pxActor.release();
706
+ };
707
+ /**
708
+ * @internal
709
+ */ _proto._transform = function _transform(pos, rot) {
710
+ var transform = PhysXCollider._tempTransform;
711
+ transform.translation = pos;
712
+ transform.rotation = rot.normalize();
713
+ return transform;
714
+ };
715
+ return PhysXCollider;
716
+ }();
717
+ (function() {
718
+ PhysXCollider._tempTransform = {
719
+ translation: null,
720
+ rotation: null
721
+ };
722
+ })();
719
723
 
720
- var CollisionDetectionMode;
721
- (function(CollisionDetectionMode) {
722
- CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is off for this dynamic collider. */ "Discrete"] = 0] = "Discrete";
723
- CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static mesh geometry. */ "Continuous"] = 1] = "Continuous";
724
- CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static and dynamic geometry. */ "ContinuousDynamic"] = 2] = "ContinuousDynamic";
725
- CollisionDetectionMode[CollisionDetectionMode[/** Speculative continuous collision detection is on for static and dynamic geometries */ "ContinuousSpeculative"] = 3] = "ContinuousSpeculative";
726
- })(CollisionDetectionMode || (CollisionDetectionMode = {}));
727
- /**
728
- * A dynamic collider can act with self-defined movement or physical force
729
- */ var PhysXDynamicCollider = /*#__PURE__*/ function(PhysXCollider) {
730
- _inherits(PhysXDynamicCollider, PhysXCollider);
731
- function PhysXDynamicCollider(position, rotation) {
732
- var _this;
733
- _this = PhysXCollider.call(this) || this;
734
- var transform = _this._transform(position, rotation);
735
- _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidDynamic(transform);
736
- return _this;
737
- }
738
- var _proto = PhysXDynamicCollider.prototype;
739
- /**
740
- * {@inheritDoc IDynamicCollider.setLinearDamping }
741
- */ _proto.setLinearDamping = function setLinearDamping(value) {
742
- this._pxActor.setLinearDamping(value);
743
- };
744
- /**
745
- * {@inheritDoc IDynamicCollider.setAngularDamping }
746
- */ _proto.setAngularDamping = function setAngularDamping(value) {
747
- this._pxActor.setAngularDamping(value);
748
- };
749
- /**
750
- * {@inheritDoc IDynamicCollider.setLinearVelocity }
751
- */ _proto.setLinearVelocity = function setLinearVelocity(value) {
752
- this._pxActor.setLinearVelocity(value, true);
753
- };
754
- /**
755
- * {@inheritDoc IDynamicCollider.setAngularVelocity }
756
- */ _proto.setAngularVelocity = function setAngularVelocity(value) {
757
- this._pxActor.setAngularVelocity(value, true);
758
- };
759
- /**
760
- * {@inheritDoc IDynamicCollider.setMass }
761
- */ _proto.setMass = function setMass(value) {
762
- this._pxActor.setMass(value);
763
- };
764
- /**
765
- * {@inheritDoc IDynamicCollider.setCenterOfMass }
766
- */ _proto.setCenterOfMass = function setCenterOfMass(position) {
767
- this._pxActor.setCMassLocalPose(position);
768
- };
769
- /**
770
- * {@inheritDoc IDynamicCollider.setInertiaTensor }
771
- */ _proto.setInertiaTensor = function setInertiaTensor(value) {
772
- this._pxActor.setMassSpaceInertiaTensor(value);
773
- };
774
- /**
775
- * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
776
- */ _proto.setMaxAngularVelocity = function setMaxAngularVelocity(value) {
777
- this._pxActor.setMaxAngularVelocity(value);
778
- };
779
- /**
780
- * {@inheritDoc IDynamicCollider.setMaxDepenetrationVelocity }
781
- */ _proto.setMaxDepenetrationVelocity = function setMaxDepenetrationVelocity(value) {
782
- this._pxActor.setMaxDepenetrationVelocity(value);
783
- };
784
- /**
785
- * {@inheritDoc IDynamicCollider.setSleepThreshold }
786
- * @default 1e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
787
- */ _proto.setSleepThreshold = function setSleepThreshold(value) {
788
- this._pxActor.setSleepThreshold(value);
789
- };
790
- /**
791
- * {@inheritDoc IDynamicCollider.setSolverIterations }
792
- */ _proto.setSolverIterations = function setSolverIterations(value) {
793
- this._pxActor.setSolverIterationCounts(value, 1);
794
- };
795
- /**
796
- * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
797
- */ _proto.setCollisionDetectionMode = function setCollisionDetectionMode(value) {
798
- switch(value){
799
- case 1:
800
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, true);
801
- break;
802
- case 2:
803
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
804
- break;
805
- case 3:
806
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
807
- break;
808
- case 0:
809
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, false);
810
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
811
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
812
- break;
813
- }
814
- };
815
- /**
816
- * {@inheritDoc IDynamicCollider.setIsKinematic }
817
- */ _proto.setIsKinematic = function setIsKinematic(value) {
818
- if (value) {
819
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
820
- } else {
821
- this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
822
- }
823
- };
824
- /**
825
- * {@inheritDoc IDynamicCollider.setConstraints }
826
- */ _proto.setConstraints = function setConstraints(flags) {
827
- this._pxActor.setRigidDynamicLockFlags(flags);
828
- };
829
- /**
830
- * {@inheritDoc IDynamicCollider.addForce }
831
- */ _proto.addForce = function addForce(force) {
832
- this._pxActor.addForce({
833
- x: force.x,
834
- y: force.y,
835
- z: force.z
836
- });
837
- };
838
- /**
839
- * {@inheritDoc IDynamicCollider.addTorque }
840
- */ _proto.addTorque = function addTorque(torque) {
841
- this._pxActor.addTorque({
842
- x: torque.x,
843
- y: torque.y,
844
- z: torque.z
845
- });
846
- };
847
- /**
848
- * {@inheritDoc IDynamicCollider.move }
849
- */ _proto.move = function move(positionOrRotation, rotation) {
850
- if (rotation) {
851
- this._pxActor.setKinematicTarget(positionOrRotation, rotation);
852
- return;
853
- }
854
- var tempTranslation = PhysXDynamicCollider._tempTranslation;
855
- var tempRotation = PhysXDynamicCollider._tempRotation;
856
- this.getWorldTransform(tempTranslation, tempRotation);
857
- if (_instanceof(positionOrRotation, engine.Vector3)) {
858
- this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
859
- } else {
860
- this._pxActor.setKinematicTarget(tempTranslation, positionOrRotation);
861
- }
862
- };
863
- /**
864
- * {@inheritDoc IDynamicCollider.sleep }
865
- */ _proto.sleep = function sleep() {
866
- return this._pxActor.putToSleep();
867
- };
868
- /**
869
- * {@inheritDoc IDynamicCollider.wakeUp }
870
- */ _proto.wakeUp = function wakeUp() {
871
- return this._pxActor.wakeUp();
872
- };
873
- return PhysXDynamicCollider;
874
- }(PhysXCollider);
875
- PhysXDynamicCollider._tempTranslation = new engine.Vector3();
876
- PhysXDynamicCollider._tempRotation = new engine.Quaternion();
724
+ var CollisionDetectionMode;
725
+ (function(CollisionDetectionMode) {
726
+ CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is off for this dynamic collider. */ "Discrete"] = 0] = "Discrete";
727
+ CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static mesh geometry. */ "Continuous"] = 1] = "Continuous";
728
+ CollisionDetectionMode[CollisionDetectionMode[/** Continuous collision detection is on for colliding with static and dynamic geometry. */ "ContinuousDynamic"] = 2] = "ContinuousDynamic";
729
+ CollisionDetectionMode[CollisionDetectionMode[/** Speculative continuous collision detection is on for static and dynamic geometries */ "ContinuousSpeculative"] = 3] = "ContinuousSpeculative";
730
+ })(CollisionDetectionMode || (CollisionDetectionMode = {}));
731
+ /**
732
+ * A dynamic collider can act with self-defined movement or physical force
733
+ */ var PhysXDynamicCollider = /*#__PURE__*/ function(PhysXCollider) {
734
+ _inherits(PhysXDynamicCollider, PhysXCollider);
735
+ function PhysXDynamicCollider(position, rotation) {
736
+ var _this;
737
+ _this = PhysXCollider.call(this) || this;
738
+ var transform = _this._transform(position, rotation);
739
+ _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidDynamic(transform);
740
+ return _this;
741
+ }
742
+ var _proto = PhysXDynamicCollider.prototype;
743
+ /**
744
+ * {@inheritDoc IDynamicCollider.setLinearDamping }
745
+ */ _proto.setLinearDamping = function setLinearDamping(value) {
746
+ this._pxActor.setLinearDamping(value);
747
+ };
748
+ /**
749
+ * {@inheritDoc IDynamicCollider.setAngularDamping }
750
+ */ _proto.setAngularDamping = function setAngularDamping(value) {
751
+ this._pxActor.setAngularDamping(value);
752
+ };
753
+ /**
754
+ * {@inheritDoc IDynamicCollider.setLinearVelocity }
755
+ */ _proto.setLinearVelocity = function setLinearVelocity(value) {
756
+ this._pxActor.setLinearVelocity(value, true);
757
+ };
758
+ /**
759
+ * {@inheritDoc IDynamicCollider.setAngularVelocity }
760
+ */ _proto.setAngularVelocity = function setAngularVelocity(value) {
761
+ this._pxActor.setAngularVelocity(value, true);
762
+ };
763
+ /**
764
+ * {@inheritDoc IDynamicCollider.setMass }
765
+ */ _proto.setMass = function setMass(value) {
766
+ this._pxActor.setMass(value);
767
+ };
768
+ /**
769
+ * {@inheritDoc IDynamicCollider.setCenterOfMass }
770
+ */ _proto.setCenterOfMass = function setCenterOfMass(position) {
771
+ this._pxActor.setCMassLocalPose(position);
772
+ };
773
+ /**
774
+ * {@inheritDoc IDynamicCollider.setInertiaTensor }
775
+ */ _proto.setInertiaTensor = function setInertiaTensor(value) {
776
+ this._pxActor.setMassSpaceInertiaTensor(value);
777
+ };
778
+ /**
779
+ * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
780
+ */ _proto.setMaxAngularVelocity = function setMaxAngularVelocity(value) {
781
+ this._pxActor.setMaxAngularVelocity(value);
782
+ };
783
+ /**
784
+ * {@inheritDoc IDynamicCollider.setMaxDepenetrationVelocity }
785
+ */ _proto.setMaxDepenetrationVelocity = function setMaxDepenetrationVelocity(value) {
786
+ this._pxActor.setMaxDepenetrationVelocity(value);
787
+ };
788
+ /**
789
+ * {@inheritDoc IDynamicCollider.setSleepThreshold }
790
+ * @default 1e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
791
+ */ _proto.setSleepThreshold = function setSleepThreshold(value) {
792
+ this._pxActor.setSleepThreshold(value);
793
+ };
794
+ /**
795
+ * {@inheritDoc IDynamicCollider.setSolverIterations }
796
+ */ _proto.setSolverIterations = function setSolverIterations(value) {
797
+ this._pxActor.setSolverIterationCounts(value, 1);
798
+ };
799
+ /**
800
+ * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
801
+ */ _proto.setCollisionDetectionMode = function setCollisionDetectionMode(value) {
802
+ switch(value){
803
+ case 1:
804
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, true);
805
+ break;
806
+ case 2:
807
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
808
+ break;
809
+ case 3:
810
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
811
+ break;
812
+ case 0:
813
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD, false);
814
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
815
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
816
+ break;
817
+ }
818
+ };
819
+ /**
820
+ * {@inheritDoc IDynamicCollider.setIsKinematic }
821
+ */ _proto.setIsKinematic = function setIsKinematic(value) {
822
+ if (value) {
823
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
824
+ } else {
825
+ this._pxActor.setRigidBodyFlag(exports.PhysXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
826
+ }
827
+ };
828
+ /**
829
+ * {@inheritDoc IDynamicCollider.setConstraints }
830
+ */ _proto.setConstraints = function setConstraints(flags) {
831
+ this._pxActor.setRigidDynamicLockFlags(flags);
832
+ };
833
+ /**
834
+ * {@inheritDoc IDynamicCollider.addForce }
835
+ */ _proto.addForce = function addForce(force) {
836
+ this._pxActor.addForce({
837
+ x: force.x,
838
+ y: force.y,
839
+ z: force.z
840
+ });
841
+ };
842
+ /**
843
+ * {@inheritDoc IDynamicCollider.addTorque }
844
+ */ _proto.addTorque = function addTorque(torque) {
845
+ this._pxActor.addTorque({
846
+ x: torque.x,
847
+ y: torque.y,
848
+ z: torque.z
849
+ });
850
+ };
851
+ /**
852
+ * {@inheritDoc IDynamicCollider.move }
853
+ */ _proto.move = function move(positionOrRotation, rotation) {
854
+ if (rotation) {
855
+ this._pxActor.setKinematicTarget(positionOrRotation, rotation);
856
+ return;
857
+ }
858
+ var tempTranslation = PhysXDynamicCollider._tempTranslation;
859
+ var tempRotation = PhysXDynamicCollider._tempRotation;
860
+ this.getWorldTransform(tempTranslation, tempRotation);
861
+ if (_instanceof(positionOrRotation, engine.Vector3)) {
862
+ this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
863
+ } else {
864
+ this._pxActor.setKinematicTarget(tempTranslation, positionOrRotation);
865
+ }
866
+ };
867
+ /**
868
+ * {@inheritDoc IDynamicCollider.sleep }
869
+ */ _proto.sleep = function sleep() {
870
+ return this._pxActor.putToSleep();
871
+ };
872
+ /**
873
+ * {@inheritDoc IDynamicCollider.wakeUp }
874
+ */ _proto.wakeUp = function wakeUp() {
875
+ return this._pxActor.wakeUp();
876
+ };
877
+ return PhysXDynamicCollider;
878
+ }(PhysXCollider);
879
+ (function() {
880
+ PhysXDynamicCollider._tempTranslation = new engine.Vector3();
881
+ })();
882
+ (function() {
883
+ PhysXDynamicCollider._tempRotation = new engine.Quaternion();
884
+ })();
877
885
 
878
- /**
879
- * A manager is a collection of colliders and constraints which can interact.
880
- */ var PhysXPhysicsManager = /*#__PURE__*/ function() {
881
- function PhysXPhysicsManager(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
882
- var _this = this;
883
- /** @internal */ this._pxControllerManager = null;
884
- this._currentEvents = new DisorderedArray();
885
- this._eventMap = {};
886
- this._eventPool = [];
887
- this._onContactEnter = onContactEnter;
888
- this._onContactExit = onContactExit;
889
- this._onContactStay = onContactStay;
890
- this._onTriggerEnter = onTriggerEnter;
891
- this._onTriggerExit = onTriggerExit;
892
- this._onTriggerStay = onTriggerStay;
893
- var triggerCallback = {
894
- onContactBegin: function(obj1, obj2) {
895
- var index1 = obj1.getQueryFilterData().word0;
896
- var index2 = obj2.getQueryFilterData().word0;
897
- _this._onContactEnter(index1, index2);
898
- },
899
- onContactEnd: function(obj1, obj2) {
900
- var index1 = obj1.getQueryFilterData().word0;
901
- var index2 = obj2.getQueryFilterData().word0;
902
- _this._onContactExit(index1, index2);
903
- },
904
- onContactPersist: function(obj1, obj2) {
905
- var index1 = obj1.getQueryFilterData().word0;
906
- var index2 = obj2.getQueryFilterData().word0;
907
- _this._onContactStay(index1, index2);
908
- },
909
- onTriggerBegin: function(obj1, obj2) {
910
- var index1 = obj1.getQueryFilterData().word0;
911
- var index2 = obj2.getQueryFilterData().word0;
912
- var event = index1 < index2 ? _this._getTrigger(index1, index2) : _this._getTrigger(index2, index1);
913
- event.state = 0;
914
- _this._currentEvents.add(event);
915
- },
916
- onTriggerEnd: function(obj1, obj2) {
917
- var index1 = obj1.getQueryFilterData().word0;
918
- var index2 = obj2.getQueryFilterData().word0;
919
- var event;
920
- if (index1 < index2) {
921
- var subMap = _this._eventMap[index1];
922
- event = subMap[index2];
923
- subMap[index2] = undefined;
924
- } else {
925
- var subMap1 = _this._eventMap[index2];
926
- event = subMap1[index1];
927
- subMap1[index1] = undefined;
928
- }
929
- event.state = 2;
930
- }
931
- };
932
- var PHYSXSimulationCallbackInstance = exports.PhysXPhysics._physX.PxSimulationEventCallback.implement(triggerCallback);
933
- var sceneDesc = exports.PhysXPhysics._physX.getDefaultSceneDesc(exports.PhysXPhysics._pxPhysics.getTolerancesScale(), 0, PHYSXSimulationCallbackInstance);
934
- this._pxScene = exports.PhysXPhysics._pxPhysics.createScene(sceneDesc);
935
- }
936
- var _proto = PhysXPhysicsManager.prototype;
937
- /**
938
- * {@inheritDoc IPhysicsManager.setGravity }
939
- */ _proto.setGravity = function setGravity(value) {
940
- this._pxScene.setGravity(value);
941
- };
942
- /**
943
- * {@inheritDoc IPhysicsManager.addColliderShape }
944
- */ _proto.addColliderShape = function addColliderShape(colliderShape) {
945
- this._eventMap[colliderShape._id] = {};
946
- };
947
- /**
948
- * {@inheritDoc IPhysicsManager.removeColliderShape }
949
- */ _proto.removeColliderShape = function removeColliderShape(colliderShape) {
950
- var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
951
- var shapeID = colliderShape._id;
952
- for(var i = currentEvents.length - 1; i >= 0; i--){
953
- var event = currentEvents.get(i);
954
- if (event.index1 == shapeID || event.index2 == shapeID) {
955
- currentEvents.deleteByIndex(i);
956
- eventPool.push(event);
957
- }
958
- }
959
- delete this._eventMap[shapeID];
960
- };
961
- /**
962
- * {@inheritDoc IPhysicsManager.addCollider }
963
- */ _proto.addCollider = function addCollider(collider) {
964
- this._pxScene.addActor(collider._pxActor, null);
965
- };
966
- /**
967
- * {@inheritDoc IPhysicsManager.removeCollider }
968
- */ _proto.removeCollider = function removeCollider(collider) {
969
- this._pxScene.removeActor(collider._pxActor, true);
970
- };
971
- /**
972
- * {@inheritDoc IPhysicsManager.addCharacterController }
973
- */ _proto.addCharacterController = function addCharacterController(characterController) {
974
- var lastPXManager = characterController._pxManager;
975
- var shape = characterController._shape;
976
- if (shape) {
977
- if (lastPXManager !== this) {
978
- lastPXManager && characterController._destroyPXController();
979
- characterController._createPXController(this, shape);
980
- }
981
- this._pxScene.addController(characterController._pxController);
982
- }
983
- characterController._pxManager = this;
984
- };
985
- /**
986
- * {@inheritDoc IPhysicsManager.removeCharacterController }
987
- */ _proto.removeCharacterController = function removeCharacterController(characterController) {
988
- if (characterController._shape) {
989
- this._pxScene.removeController(characterController._pxController);
990
- }
991
- characterController._pxManager = null;
992
- };
993
- /**
994
- * {@inheritDoc IPhysicsManager.update }
995
- */ _proto.update = function update(elapsedTime) {
996
- this._simulate(elapsedTime);
997
- this._fetchResults();
998
- this._fireEvent();
999
- };
1000
- /**
1001
- * {@inheritDoc IPhysicsManager.raycast }
1002
- */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
1003
- var pxHitResult = PhysXPhysicsManager._pxRaycastHit;
1004
- distance = Math.min(distance, 3.4e38); // float32 max value limit in physx raycast.
1005
- var raycastCallback = {
1006
- preFilter: function(filterData, shape, actor) {
1007
- var index = shape.getQueryFilterData().word0;
1008
- if (onRaycast(index)) {
1009
- return 2; // eBLOCK
1010
- } else {
1011
- return 0; // eNONE
1012
- }
1013
- },
1014
- postFilter: function(filterData, hit) {}
1015
- };
1016
- var result = this._pxScene.raycastSingle(ray.origin, ray.direction, distance, pxHitResult, PhysXPhysicsManager._pxFilterData, exports.PhysXPhysics._physX.PxQueryFilterCallback.implement(raycastCallback));
1017
- if (result && hit != undefined) {
1018
- var position = PhysXPhysicsManager._tempPosition, normal = PhysXPhysicsManager._tempNormal;
1019
- var pxPosition = pxHitResult.position, pxNormal = pxHitResult.normal;
1020
- position.set(pxPosition.x, pxPosition.y, pxPosition.z);
1021
- normal.set(pxNormal.x, pxNormal.y, pxNormal.z);
1022
- hit(pxHitResult.getShape().getQueryFilterData().word0, pxHitResult.distance, position, normal);
1023
- }
1024
- return result;
1025
- };
1026
- /**
1027
- * @internal
1028
- */ _proto._getControllerManager = function _getControllerManager() {
1029
- var pxControllerManager = this._pxControllerManager;
1030
- if (pxControllerManager === null) {
1031
- this._pxControllerManager = pxControllerManager = this._pxScene.createControllerManager();
1032
- }
1033
- return pxControllerManager;
1034
- };
1035
- _proto._simulate = function _simulate(elapsedTime) {
1036
- this._pxScene.simulate(elapsedTime, true);
1037
- };
1038
- _proto._fetchResults = function _fetchResults(block) {
1039
- if (block === void 0) block = true;
1040
- this._pxScene.fetchResults(block);
1041
- };
1042
- _proto._getTrigger = function _getTrigger(index1, index2) {
1043
- var event;
1044
- if (this._eventPool.length) {
1045
- event = this._eventPool.pop();
1046
- event.index1 = index1;
1047
- event.index2 = index2;
1048
- } else {
1049
- event = new TriggerEvent(index1, index2);
1050
- }
1051
- this._eventMap[index1][index2] = event;
1052
- return event;
1053
- };
1054
- _proto._fireEvent = function _fireEvent() {
1055
- var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
1056
- for(var i = currentEvents.length - 1; i >= 0; i--){
1057
- var event = currentEvents.get(i);
1058
- if (event.state == 0) {
1059
- this._onTriggerEnter(event.index1, event.index2);
1060
- event.state = 1;
1061
- } else if (event.state == 1) {
1062
- this._onTriggerStay(event.index1, event.index2);
1063
- } else if (event.state == 2) {
1064
- this._onTriggerExit(event.index1, event.index2);
1065
- currentEvents.deleteByIndex(i);
1066
- eventPool.push(event);
1067
- }
1068
- }
1069
- };
1070
- PhysXPhysicsManager._init = function _init() {
1071
- PhysXPhysicsManager._pxRaycastHit = new exports.PhysXPhysics._physX.PxRaycastHit();
1072
- PhysXPhysicsManager._pxFilterData = new exports.PhysXPhysics._physX.PxQueryFilterData();
1073
- PhysXPhysicsManager._pxFilterData.flags = new exports.PhysXPhysics._physX.PxQueryFlags(1 | 2 | 4);
1074
- };
1075
- return PhysXPhysicsManager;
1076
- }();
1077
- PhysXPhysicsManager._tempPosition = new engine.Vector3();
1078
- PhysXPhysicsManager._tempNormal = new engine.Vector3();
1079
- var /**
1080
- * Filtering flags for scene queries.
1081
- */ QueryFlag;
1082
- (function(QueryFlag) {
1083
- QueryFlag[QueryFlag["STATIC"] = 1] = "STATIC";
1084
- QueryFlag[QueryFlag["DYNAMIC"] = 2] = "DYNAMIC";
1085
- QueryFlag[QueryFlag["PRE_FILTER"] = 4] = "PRE_FILTER";
1086
- QueryFlag[QueryFlag["POST_FILTER"] = 8] = "POST_FILTER";
1087
- QueryFlag[QueryFlag["ANY_HIT"] = 16] = "ANY_HIT";
1088
- QueryFlag[QueryFlag["NO_BLOCK"] = 32] = "NO_BLOCK";
1089
- })(QueryFlag || (QueryFlag = {}));
1090
- var /**
1091
- * Physics state
1092
- */ TriggerEventState;
1093
- (function(TriggerEventState) {
1094
- TriggerEventState[TriggerEventState["Enter"] = 0] = "Enter";
1095
- TriggerEventState[TriggerEventState["Stay"] = 1] = "Stay";
1096
- TriggerEventState[TriggerEventState["Exit"] = 2] = "Exit";
1097
- })(TriggerEventState || (TriggerEventState = {}));
1098
- /**
1099
- * Trigger event to store interactive object ids and state.
1100
- */ var TriggerEvent = function TriggerEvent(index1, index2) {
1101
- this.index1 = index1;
1102
- this.index2 = index2;
1103
- };
886
+ /**
887
+ * A manager is a collection of colliders and constraints which can interact.
888
+ */ var PhysXPhysicsManager = /*#__PURE__*/ function() {
889
+ function PhysXPhysicsManager(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
890
+ var _this = this;
891
+ /** @internal */ this._pxControllerManager = null;
892
+ this._currentEvents = new DisorderedArray();
893
+ this._eventMap = {};
894
+ this._eventPool = [];
895
+ this._onContactEnter = onContactEnter;
896
+ this._onContactExit = onContactExit;
897
+ this._onContactStay = onContactStay;
898
+ this._onTriggerEnter = onTriggerEnter;
899
+ this._onTriggerExit = onTriggerExit;
900
+ this._onTriggerStay = onTriggerStay;
901
+ var triggerCallback = {
902
+ onContactBegin: function(obj1, obj2) {
903
+ var index1 = obj1.getQueryFilterData().word0;
904
+ var index2 = obj2.getQueryFilterData().word0;
905
+ _this._onContactEnter(index1, index2);
906
+ },
907
+ onContactEnd: function(obj1, obj2) {
908
+ var index1 = obj1.getQueryFilterData().word0;
909
+ var index2 = obj2.getQueryFilterData().word0;
910
+ _this._onContactExit(index1, index2);
911
+ },
912
+ onContactPersist: function(obj1, obj2) {
913
+ var index1 = obj1.getQueryFilterData().word0;
914
+ var index2 = obj2.getQueryFilterData().word0;
915
+ _this._onContactStay(index1, index2);
916
+ },
917
+ onTriggerBegin: function(obj1, obj2) {
918
+ var index1 = obj1.getQueryFilterData().word0;
919
+ var index2 = obj2.getQueryFilterData().word0;
920
+ var event = index1 < index2 ? _this._getTrigger(index1, index2) : _this._getTrigger(index2, index1);
921
+ event.state = 0;
922
+ _this._currentEvents.add(event);
923
+ },
924
+ onTriggerEnd: function(obj1, obj2) {
925
+ var index1 = obj1.getQueryFilterData().word0;
926
+ var index2 = obj2.getQueryFilterData().word0;
927
+ var event;
928
+ if (index1 < index2) {
929
+ var subMap = _this._eventMap[index1];
930
+ event = subMap[index2];
931
+ subMap[index2] = undefined;
932
+ } else {
933
+ var subMap1 = _this._eventMap[index2];
934
+ event = subMap1[index1];
935
+ subMap1[index1] = undefined;
936
+ }
937
+ event.state = 2;
938
+ }
939
+ };
940
+ var PHYSXSimulationCallbackInstance = exports.PhysXPhysics._physX.PxSimulationEventCallback.implement(triggerCallback);
941
+ var sceneDesc = exports.PhysXPhysics._physX.getDefaultSceneDesc(exports.PhysXPhysics._pxPhysics.getTolerancesScale(), 0, PHYSXSimulationCallbackInstance);
942
+ this._pxScene = exports.PhysXPhysics._pxPhysics.createScene(sceneDesc);
943
+ }
944
+ var _proto = PhysXPhysicsManager.prototype;
945
+ /**
946
+ * {@inheritDoc IPhysicsManager.setGravity }
947
+ */ _proto.setGravity = function setGravity(value) {
948
+ this._pxScene.setGravity(value);
949
+ };
950
+ /**
951
+ * {@inheritDoc IPhysicsManager.addColliderShape }
952
+ */ _proto.addColliderShape = function addColliderShape(colliderShape) {
953
+ this._eventMap[colliderShape._id] = {};
954
+ };
955
+ /**
956
+ * {@inheritDoc IPhysicsManager.removeColliderShape }
957
+ */ _proto.removeColliderShape = function removeColliderShape(colliderShape) {
958
+ var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
959
+ var shapeID = colliderShape._id;
960
+ for(var i = currentEvents.length - 1; i >= 0; i--){
961
+ var event = currentEvents.get(i);
962
+ if (event.index1 == shapeID || event.index2 == shapeID) {
963
+ currentEvents.deleteByIndex(i);
964
+ eventPool.push(event);
965
+ }
966
+ }
967
+ delete this._eventMap[shapeID];
968
+ };
969
+ /**
970
+ * {@inheritDoc IPhysicsManager.addCollider }
971
+ */ _proto.addCollider = function addCollider(collider) {
972
+ this._pxScene.addActor(collider._pxActor, null);
973
+ };
974
+ /**
975
+ * {@inheritDoc IPhysicsManager.removeCollider }
976
+ */ _proto.removeCollider = function removeCollider(collider) {
977
+ this._pxScene.removeActor(collider._pxActor, true);
978
+ };
979
+ /**
980
+ * {@inheritDoc IPhysicsManager.addCharacterController }
981
+ */ _proto.addCharacterController = function addCharacterController(characterController) {
982
+ var lastPXManager = characterController._pxManager;
983
+ var shape = characterController._shape;
984
+ if (shape) {
985
+ if (lastPXManager !== this) {
986
+ lastPXManager && characterController._destroyPXController();
987
+ characterController._createPXController(this, shape);
988
+ }
989
+ this._pxScene.addController(characterController._pxController);
990
+ }
991
+ characterController._pxManager = this;
992
+ };
993
+ /**
994
+ * {@inheritDoc IPhysicsManager.removeCharacterController }
995
+ */ _proto.removeCharacterController = function removeCharacterController(characterController) {
996
+ if (characterController._shape) {
997
+ this._pxScene.removeController(characterController._pxController);
998
+ }
999
+ characterController._pxManager = null;
1000
+ };
1001
+ /**
1002
+ * {@inheritDoc IPhysicsManager.update }
1003
+ */ _proto.update = function update(elapsedTime) {
1004
+ this._simulate(elapsedTime);
1005
+ this._fetchResults();
1006
+ this._fireEvent();
1007
+ };
1008
+ /**
1009
+ * {@inheritDoc IPhysicsManager.raycast }
1010
+ */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
1011
+ var pxHitResult = PhysXPhysicsManager._pxRaycastHit;
1012
+ distance = Math.min(distance, 3.4e38); // float32 max value limit in physx raycast.
1013
+ var raycastCallback = {
1014
+ preFilter: function(filterData, shape, actor) {
1015
+ var index = shape.getQueryFilterData().word0;
1016
+ if (onRaycast(index)) {
1017
+ return 2; // eBLOCK
1018
+ } else {
1019
+ return 0; // eNONE
1020
+ }
1021
+ },
1022
+ postFilter: function(filterData, hit) {}
1023
+ };
1024
+ var result = this._pxScene.raycastSingle(ray.origin, ray.direction, distance, pxHitResult, PhysXPhysicsManager._pxFilterData, exports.PhysXPhysics._physX.PxQueryFilterCallback.implement(raycastCallback));
1025
+ if (result && hit != undefined) {
1026
+ var position = PhysXPhysicsManager._tempPosition, normal = PhysXPhysicsManager._tempNormal;
1027
+ var pxPosition = pxHitResult.position, pxNormal = pxHitResult.normal;
1028
+ position.set(pxPosition.x, pxPosition.y, pxPosition.z);
1029
+ normal.set(pxNormal.x, pxNormal.y, pxNormal.z);
1030
+ hit(pxHitResult.getShape().getQueryFilterData().word0, pxHitResult.distance, position, normal);
1031
+ }
1032
+ return result;
1033
+ };
1034
+ /**
1035
+ * @internal
1036
+ */ _proto._getControllerManager = function _getControllerManager() {
1037
+ var pxControllerManager = this._pxControllerManager;
1038
+ if (pxControllerManager === null) {
1039
+ this._pxControllerManager = pxControllerManager = this._pxScene.createControllerManager();
1040
+ }
1041
+ return pxControllerManager;
1042
+ };
1043
+ _proto._simulate = function _simulate(elapsedTime) {
1044
+ this._pxScene.simulate(elapsedTime, true);
1045
+ };
1046
+ _proto._fetchResults = function _fetchResults(block) {
1047
+ if (block === void 0) block = true;
1048
+ this._pxScene.fetchResults(block);
1049
+ };
1050
+ _proto._getTrigger = function _getTrigger(index1, index2) {
1051
+ var event;
1052
+ if (this._eventPool.length) {
1053
+ event = this._eventPool.pop();
1054
+ event.index1 = index1;
1055
+ event.index2 = index2;
1056
+ } else {
1057
+ event = new TriggerEvent(index1, index2);
1058
+ }
1059
+ this._eventMap[index1][index2] = event;
1060
+ return event;
1061
+ };
1062
+ _proto._fireEvent = function _fireEvent() {
1063
+ var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
1064
+ for(var i = currentEvents.length - 1; i >= 0; i--){
1065
+ var event = currentEvents.get(i);
1066
+ if (event.state == 0) {
1067
+ this._onTriggerEnter(event.index1, event.index2);
1068
+ event.state = 1;
1069
+ } else if (event.state == 1) {
1070
+ this._onTriggerStay(event.index1, event.index2);
1071
+ } else if (event.state == 2) {
1072
+ this._onTriggerExit(event.index1, event.index2);
1073
+ currentEvents.deleteByIndex(i);
1074
+ eventPool.push(event);
1075
+ }
1076
+ }
1077
+ };
1078
+ PhysXPhysicsManager._init = function _init() {
1079
+ PhysXPhysicsManager._pxRaycastHit = new exports.PhysXPhysics._physX.PxRaycastHit();
1080
+ PhysXPhysicsManager._pxFilterData = new exports.PhysXPhysics._physX.PxQueryFilterData();
1081
+ PhysXPhysicsManager._pxFilterData.flags = new exports.PhysXPhysics._physX.PxQueryFlags(1 | 2 | 4);
1082
+ };
1083
+ return PhysXPhysicsManager;
1084
+ }();
1085
+ (function() {
1086
+ PhysXPhysicsManager._tempPosition = new engine.Vector3();
1087
+ })();
1088
+ (function() {
1089
+ PhysXPhysicsManager._tempNormal = new engine.Vector3();
1090
+ })();
1091
+ var /**
1092
+ * Filtering flags for scene queries.
1093
+ */ QueryFlag;
1094
+ (function(QueryFlag) {
1095
+ QueryFlag[QueryFlag["STATIC"] = 1] = "STATIC";
1096
+ QueryFlag[QueryFlag["DYNAMIC"] = 2] = "DYNAMIC";
1097
+ QueryFlag[QueryFlag["PRE_FILTER"] = 4] = "PRE_FILTER";
1098
+ QueryFlag[QueryFlag["POST_FILTER"] = 8] = "POST_FILTER";
1099
+ QueryFlag[QueryFlag["ANY_HIT"] = 16] = "ANY_HIT";
1100
+ QueryFlag[QueryFlag["NO_BLOCK"] = 32] = "NO_BLOCK";
1101
+ })(QueryFlag || (QueryFlag = {}));
1102
+ var /**
1103
+ * Physics state
1104
+ */ TriggerEventState;
1105
+ (function(TriggerEventState) {
1106
+ TriggerEventState[TriggerEventState["Enter"] = 0] = "Enter";
1107
+ TriggerEventState[TriggerEventState["Stay"] = 1] = "Stay";
1108
+ TriggerEventState[TriggerEventState["Exit"] = 2] = "Exit";
1109
+ })(TriggerEventState || (TriggerEventState = {}));
1110
+ /**
1111
+ * Trigger event to store interactive object ids and state.
1112
+ */ var TriggerEvent = function TriggerEvent(index1, index2) {
1113
+ this.index1 = index1;
1114
+ this.index2 = index2;
1115
+ };
1104
1116
 
1105
- /**
1106
- * Physics material describes how to handle colliding objects (friction, bounciness).
1107
- */ var PhysXPhysicsMaterial = /*#__PURE__*/ function() {
1108
- function PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
1109
- var pxMaterial = exports.PhysXPhysics._pxPhysics.createMaterial(staticFriction, dynamicFriction, bounciness);
1110
- pxMaterial.setFrictionCombineMode(frictionCombine);
1111
- pxMaterial.setRestitutionCombineMode(bounceCombine);
1112
- this._pxMaterial = pxMaterial;
1113
- }
1114
- var _proto = PhysXPhysicsMaterial.prototype;
1115
- /**
1116
- * {@inheritDoc IPhysicsMaterial.setBounciness }
1117
- */ _proto.setBounciness = function setBounciness(value) {
1118
- this._pxMaterial.setRestitution(value);
1119
- };
1120
- /**
1121
- * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
1122
- */ _proto.setDynamicFriction = function setDynamicFriction(value) {
1123
- this._pxMaterial.setDynamicFriction(value);
1124
- };
1125
- /**
1126
- * {@inheritDoc IPhysicsMaterial.setStaticFriction }
1127
- */ _proto.setStaticFriction = function setStaticFriction(value) {
1128
- this._pxMaterial.setStaticFriction(value);
1129
- };
1130
- /**
1131
- * {@inheritDoc IPhysicsMaterial.setBounceCombine }
1132
- */ _proto.setBounceCombine = function setBounceCombine(value) {
1133
- this._pxMaterial.setRestitutionCombineMode(value);
1134
- };
1135
- /**
1136
- * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
1137
- */ _proto.setFrictionCombine = function setFrictionCombine(value) {
1138
- this._pxMaterial.setFrictionCombineMode(value);
1139
- };
1140
- /**
1141
- * {@inheritDoc IPhysicsMaterial.destroy }
1142
- */ _proto.destroy = function destroy() {
1143
- this._pxMaterial.release();
1144
- };
1145
- return PhysXPhysicsMaterial;
1146
- }();
1147
- var /**
1148
- * Describes how physics materials of the colliding objects are combined.
1149
- */ CombineMode;
1150
- (function(CombineMode) {
1151
- CombineMode[CombineMode[/** Averages the friction/bounce of the two colliding materials. */ "Average"] = 0] = "Average";
1152
- CombineMode[CombineMode[/** Uses the smaller friction/bounce of the two colliding materials. */ "Minimum"] = 1] = "Minimum";
1153
- CombineMode[CombineMode[/** Multiplies the friction/bounce of the two colliding materials. */ "Multiply"] = 2] = "Multiply";
1154
- CombineMode[CombineMode[/** Uses the larger friction/bounce of the two colliding materials. */ "Maximum"] = 3] = "Maximum";
1155
- })(CombineMode || (CombineMode = {}));
1117
+ /**
1118
+ * Physics material describes how to handle colliding objects (friction, bounciness).
1119
+ */ var PhysXPhysicsMaterial = /*#__PURE__*/ function() {
1120
+ function PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
1121
+ var pxMaterial = exports.PhysXPhysics._pxPhysics.createMaterial(staticFriction, dynamicFriction, bounciness);
1122
+ pxMaterial.setFrictionCombineMode(frictionCombine);
1123
+ pxMaterial.setRestitutionCombineMode(bounceCombine);
1124
+ this._pxMaterial = pxMaterial;
1125
+ }
1126
+ var _proto = PhysXPhysicsMaterial.prototype;
1127
+ /**
1128
+ * {@inheritDoc IPhysicsMaterial.setBounciness }
1129
+ */ _proto.setBounciness = function setBounciness(value) {
1130
+ this._pxMaterial.setRestitution(value);
1131
+ };
1132
+ /**
1133
+ * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
1134
+ */ _proto.setDynamicFriction = function setDynamicFriction(value) {
1135
+ this._pxMaterial.setDynamicFriction(value);
1136
+ };
1137
+ /**
1138
+ * {@inheritDoc IPhysicsMaterial.setStaticFriction }
1139
+ */ _proto.setStaticFriction = function setStaticFriction(value) {
1140
+ this._pxMaterial.setStaticFriction(value);
1141
+ };
1142
+ /**
1143
+ * {@inheritDoc IPhysicsMaterial.setBounceCombine }
1144
+ */ _proto.setBounceCombine = function setBounceCombine(value) {
1145
+ this._pxMaterial.setRestitutionCombineMode(value);
1146
+ };
1147
+ /**
1148
+ * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
1149
+ */ _proto.setFrictionCombine = function setFrictionCombine(value) {
1150
+ this._pxMaterial.setFrictionCombineMode(value);
1151
+ };
1152
+ /**
1153
+ * {@inheritDoc IPhysicsMaterial.destroy }
1154
+ */ _proto.destroy = function destroy() {
1155
+ this._pxMaterial.release();
1156
+ };
1157
+ return PhysXPhysicsMaterial;
1158
+ }();
1159
+ var /**
1160
+ * Describes how physics materials of the colliding objects are combined.
1161
+ */ CombineMode;
1162
+ (function(CombineMode) {
1163
+ CombineMode[CombineMode[/** Averages the friction/bounce of the two colliding materials. */ "Average"] = 0] = "Average";
1164
+ CombineMode[CombineMode[/** Uses the smaller friction/bounce of the two colliding materials. */ "Minimum"] = 1] = "Minimum";
1165
+ CombineMode[CombineMode[/** Multiplies the friction/bounce of the two colliding materials. */ "Multiply"] = 2] = "Multiply";
1166
+ CombineMode[CombineMode[/** Uses the larger friction/bounce of the two colliding materials. */ "Maximum"] = 3] = "Maximum";
1167
+ })(CombineMode || (CombineMode = {}));
1156
1168
 
1157
- /**
1158
- * A static collider component that will not move.
1159
- * @remarks Mostly used for object which always stays at the same place and never moves around.
1160
- */ var PhysXStaticCollider = /*#__PURE__*/ function(PhysXCollider) {
1161
- _inherits(PhysXStaticCollider, PhysXCollider);
1162
- function PhysXStaticCollider(position, rotation) {
1163
- var _this;
1164
- _this = PhysXCollider.call(this) || this;
1165
- _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidStatic(_this._transform(position, rotation));
1166
- return _this;
1167
- }
1168
- return PhysXStaticCollider;
1169
- }(PhysXCollider);
1169
+ /**
1170
+ * A static collider component that will not move.
1171
+ * @remarks Mostly used for object which always stays at the same place and never moves around.
1172
+ */ var PhysXStaticCollider = /*#__PURE__*/ function(PhysXCollider) {
1173
+ _inherits(PhysXStaticCollider, PhysXCollider);
1174
+ function PhysXStaticCollider(position, rotation) {
1175
+ var _this;
1176
+ _this = PhysXCollider.call(this) || this;
1177
+ _this._pxActor = exports.PhysXPhysics._pxPhysics.createRigidStatic(_this._transform(position, rotation));
1178
+ return _this;
1179
+ }
1180
+ return PhysXStaticCollider;
1181
+ }(PhysXCollider);
1170
1182
 
1171
- /**
1172
- * Plane collider shape in PhysX.
1173
- */ var PhysXPlaneColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
1174
- _inherits(PhysXPlaneColliderShape, PhysXColliderShape1);
1175
- function PhysXPlaneColliderShape(uniqueID, material) {
1176
- var _this;
1177
- _this = PhysXColliderShape1.call(this) || this;
1178
- _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
1179
- _this._physxRotation.copyFrom(_this._axis);
1180
- _this._pxGeometry = new exports.PhysXPhysics._physX.PxPlaneGeometry();
1181
- _this._initialize(material, uniqueID);
1182
- _this._setLocalPose();
1183
- return _this;
1184
- }
1185
- var _proto = PhysXPlaneColliderShape.prototype;
1186
- /**
1187
- * {@inheritDoc IColliderShape.setWorldScale }
1188
- */ _proto.setWorldScale = function setWorldScale(scale) {
1189
- this._scale.copyFrom(scale);
1190
- this._setLocalPose();
1191
- };
1192
- return PhysXPlaneColliderShape;
1193
- }(PhysXColliderShape);
1183
+ /**
1184
+ * Plane collider shape in PhysX.
1185
+ */ var PhysXPlaneColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
1186
+ _inherits(PhysXPlaneColliderShape, PhysXColliderShape1);
1187
+ function PhysXPlaneColliderShape(uniqueID, material) {
1188
+ var _this;
1189
+ _this = PhysXColliderShape1.call(this) || this;
1190
+ _this._axis = new engine.Quaternion(0, 0, PhysXColliderShape.halfSqrt, PhysXColliderShape.halfSqrt);
1191
+ _this._physxRotation.copyFrom(_this._axis);
1192
+ _this._pxGeometry = new exports.PhysXPhysics._physX.PxPlaneGeometry();
1193
+ _this._initialize(material, uniqueID);
1194
+ _this._setLocalPose();
1195
+ return _this;
1196
+ }
1197
+ var _proto = PhysXPlaneColliderShape.prototype;
1198
+ /**
1199
+ * {@inheritDoc IColliderShape.setWorldScale }
1200
+ */ _proto.setWorldScale = function setWorldScale(scale) {
1201
+ this._scale.copyFrom(scale);
1202
+ this._setLocalPose();
1203
+ };
1204
+ return PhysXPlaneColliderShape;
1205
+ }(PhysXColliderShape);
1194
1206
 
1195
- /**
1196
- * Sphere collider shape in PhysX.
1197
- */ var PhysXSphereColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
1198
- _inherits(PhysXSphereColliderShape, PhysXColliderShape);
1199
- function PhysXSphereColliderShape(uniqueID, radius, material) {
1200
- var _this;
1201
- _this = PhysXColliderShape.call(this) || this;
1202
- _this._maxScale = 1;
1203
- _this._radius = radius;
1204
- _this._pxGeometry = new exports.PhysXPhysics._physX.PxSphereGeometry(_this._radius * _this._maxScale);
1205
- _this._initialize(material, uniqueID);
1206
- _this._setLocalPose();
1207
- return _this;
1208
- }
1209
- var _proto = PhysXSphereColliderShape.prototype;
1210
- /**
1211
- * {@inheritDoc ISphereColliderShape.setRadius }
1212
- */ _proto.setRadius = function setRadius(value) {
1213
- this._radius = value;
1214
- this._pxGeometry.radius = value * this._maxScale;
1215
- this._pxShape.setGeometry(this._pxGeometry);
1216
- };
1217
- /**
1218
- * {@inheritDoc IColliderShape.setWorldScale }
1219
- */ _proto.setWorldScale = function setWorldScale(scale) {
1220
- this._scale.copyFrom(scale);
1221
- this._setLocalPose();
1222
- this._maxScale = Math.max(scale.x, Math.max(scale.x, scale.y));
1223
- this._pxGeometry.radius = this._radius * this._maxScale;
1224
- this._pxShape.setGeometry(this._pxGeometry);
1225
- };
1226
- return PhysXSphereColliderShape;
1227
- }(PhysXColliderShape);
1207
+ /**
1208
+ * Sphere collider shape in PhysX.
1209
+ */ var PhysXSphereColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
1210
+ _inherits(PhysXSphereColliderShape, PhysXColliderShape);
1211
+ function PhysXSphereColliderShape(uniqueID, radius, material) {
1212
+ var _this;
1213
+ _this = PhysXColliderShape.call(this) || this;
1214
+ _this._maxScale = 1;
1215
+ _this._radius = radius;
1216
+ _this._pxGeometry = new exports.PhysXPhysics._physX.PxSphereGeometry(_this._radius * _this._maxScale);
1217
+ _this._initialize(material, uniqueID);
1218
+ _this._setLocalPose();
1219
+ return _this;
1220
+ }
1221
+ var _proto = PhysXSphereColliderShape.prototype;
1222
+ /**
1223
+ * {@inheritDoc ISphereColliderShape.setRadius }
1224
+ */ _proto.setRadius = function setRadius(value) {
1225
+ this._radius = value;
1226
+ this._pxGeometry.radius = value * this._maxScale;
1227
+ this._pxShape.setGeometry(this._pxGeometry);
1228
+ };
1229
+ /**
1230
+ * {@inheritDoc IColliderShape.setWorldScale }
1231
+ */ _proto.setWorldScale = function setWorldScale(scale) {
1232
+ this._scale.copyFrom(scale);
1233
+ this._setLocalPose();
1234
+ this._maxScale = Math.max(scale.x, Math.max(scale.x, scale.y));
1235
+ this._pxGeometry.radius = this._radius * this._maxScale;
1236
+ this._pxShape.setGeometry(this._pxGeometry);
1237
+ };
1238
+ return PhysXSphereColliderShape;
1239
+ }(PhysXColliderShape);
1228
1240
 
1229
- /**
1230
- * Static interface implement decorator.
1231
- * https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
1232
- */ function StaticInterfaceImplement() {
1233
- return function(constructor) {
1234
- };
1235
- }
1241
+ /**
1242
+ * Static interface implement decorator.
1243
+ * https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
1244
+ */ function StaticInterfaceImplement() {
1245
+ return function(constructor) {
1246
+ };
1247
+ }
1236
1248
 
1237
- exports.PhysXPhysics = /*#__PURE__*/ function() {
1238
- function PhysXPhysics1() {}
1239
- /**
1240
- * Initialize PhysXPhysics.
1241
- * @param runtimeMode - Runtime mode
1242
- * @returns Promise object
1243
- */ PhysXPhysics1.initialize = function initialize(runtimeMode) {
1244
- if (runtimeMode === void 0) runtimeMode = exports.PhysXRuntimeMode.Auto;
1245
- var scriptPromise = new Promise(function(resolve, reject) {
1246
- var script = document.createElement("script");
1247
- document.body.appendChild(script);
1248
- script.async = true;
1249
- script.onload = resolve;
1250
- script.onerror = reject;
1251
- if (runtimeMode == exports.PhysXRuntimeMode.Auto) {
1252
- var supported = function() {
1253
- try {
1254
- if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") {
1255
- var module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
1256
- if (_instanceof(module, WebAssembly.Module)) return _instanceof(new WebAssembly.Instance(module), WebAssembly.Instance);
1257
- }
1258
- } catch (e) {}
1259
- return false;
1260
- }();
1261
- if (supported) {
1262
- runtimeMode = exports.PhysXRuntimeMode.WebAssembly;
1263
- } else {
1264
- runtimeMode = exports.PhysXRuntimeMode.JavaScript;
1265
- }
1266
- }
1267
- if (runtimeMode == exports.PhysXRuntimeMode.JavaScript) {
1268
- script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js.js";
1269
- } else if (runtimeMode == exports.PhysXRuntimeMode.WebAssembly) {
1270
- script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js";
1271
- }
1272
- });
1273
- return new Promise(function(resolve, reject) {
1274
- scriptPromise.then(function() {
1275
- return window.PHYSX().then(function(PHYSX) {
1276
- exports.PhysXPhysics._init(PHYSX);
1277
- console.log("PhysX loaded.");
1278
- resolve();
1279
- }, reject);
1280
- }, reject).catch(reject);
1281
- });
1282
- };
1283
- /**
1284
- * Destroy PhysXPhysics.
1285
- */ PhysXPhysics1.destroy = function destroy() {
1286
- this._pxFoundation.release();
1287
- this._pxPhysics.release();
1288
- this._physX = null;
1289
- this._pxFoundation = null;
1290
- this._pxPhysics = null;
1291
- };
1292
- /**
1293
- * {@inheritDoc IPhysics.createPhysicsManager }
1294
- */ PhysXPhysics1.createPhysicsManager = function createPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay) {
1295
- return new PhysXPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay);
1296
- };
1297
- /**
1298
- * {@inheritDoc IPhysics.createStaticCollider }
1299
- */ PhysXPhysics1.createStaticCollider = function createStaticCollider(position, rotation) {
1300
- return new PhysXStaticCollider(position, rotation);
1301
- };
1302
- /**
1303
- * {@inheritDoc IPhysics.createDynamicCollider }
1304
- */ PhysXPhysics1.createDynamicCollider = function createDynamicCollider(position, rotation) {
1305
- return new PhysXDynamicCollider(position, rotation);
1306
- };
1307
- /**
1308
- * {@inheritDoc IPhysics.createCharacterController }
1309
- */ PhysXPhysics1.createCharacterController = function createCharacterController() {
1310
- return new PhysXCharacterController();
1311
- };
1312
- /**
1313
- * {@inheritDoc IPhysics.createPhysicsMaterial }
1314
- */ PhysXPhysics1.createPhysicsMaterial = function createPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
1315
- return new PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine);
1316
- };
1317
- /**
1318
- * {@inheritDoc IPhysics.createBoxColliderShape }
1319
- */ PhysXPhysics1.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
1320
- return new PhysXBoxColliderShape(uniqueID, size, material);
1321
- };
1322
- /**
1323
- * {@inheritDoc IPhysics.createSphereColliderShape }
1324
- */ PhysXPhysics1.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
1325
- return new PhysXSphereColliderShape(uniqueID, radius, material);
1326
- };
1327
- /**
1328
- * {@inheritDoc IPhysics.createPlaneColliderShape }
1329
- */ PhysXPhysics1.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
1330
- return new PhysXPlaneColliderShape(uniqueID, material);
1331
- };
1332
- /**
1333
- * {@inheritDoc IPhysics.createCapsuleColliderShape }
1334
- */ PhysXPhysics1.createCapsuleColliderShape = function createCapsuleColliderShape(uniqueID, radius, height, material) {
1335
- return new PhysXCapsuleColliderShape(uniqueID, radius, height, material);
1336
- };
1337
- /**
1338
- * {@inheritDoc IPhysics.createFixedJoint }
1339
- */ PhysXPhysics1.createFixedJoint = function createFixedJoint(collider) {
1340
- return new PhysXFixedJoint(collider);
1341
- };
1342
- /**
1343
- * {@inheritDoc IPhysics.createHingeJoint }
1344
- */ PhysXPhysics1.createHingeJoint = function createHingeJoint(collider) {
1345
- return new PhysXHingeJoint(collider);
1346
- };
1347
- /**
1348
- * {@inheritDoc IPhysics.createSpringJoint }
1349
- */ PhysXPhysics1.createSpringJoint = function createSpringJoint(collider) {
1350
- return new PhysXSpringJoint(collider);
1351
- };
1352
- PhysXPhysics1._init = function _init(physX) {
1353
- var version = physX.PX_PHYSICS_VERSION;
1354
- var defaultErrorCallback = new physX.PxDefaultErrorCallback();
1355
- var allocator = new physX.PxDefaultAllocator();
1356
- var pxFoundation = physX.PxCreateFoundation(version, allocator, defaultErrorCallback);
1357
- var pxPhysics = physX.PxCreatePhysics(version, pxFoundation, new physX.PxTolerancesScale(), false, null);
1358
- physX.PxInitExtensions(pxPhysics, null);
1359
- exports.PhysXPhysics._physX = physX;
1360
- exports.PhysXPhysics._pxFoundation = pxFoundation;
1361
- exports.PhysXPhysics._pxPhysics = pxPhysics;
1362
- PhysXPhysicsManager._init();
1363
- };
1364
- return PhysXPhysics1;
1365
- }();
1366
- exports.PhysXPhysics = __decorate([
1367
- StaticInterfaceImplement()
1368
- ], exports.PhysXPhysics);
1249
+ exports.PhysXPhysics = /*#__PURE__*/ function() {
1250
+ function PhysXPhysics1() {}
1251
+ /**
1252
+ * Initialize PhysXPhysics.
1253
+ * @param runtimeMode - Runtime mode
1254
+ * @returns Promise object
1255
+ */ PhysXPhysics1.initialize = function initialize(runtimeMode) {
1256
+ if (runtimeMode === void 0) runtimeMode = exports.PhysXRuntimeMode.Auto;
1257
+ var scriptPromise = new Promise(function(resolve, reject) {
1258
+ var script = document.createElement("script");
1259
+ document.body.appendChild(script);
1260
+ script.async = true;
1261
+ script.onload = resolve;
1262
+ script.onerror = reject;
1263
+ if (runtimeMode == exports.PhysXRuntimeMode.Auto) {
1264
+ var supported = function() {
1265
+ try {
1266
+ if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") {
1267
+ var module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
1268
+ if (_instanceof(module, WebAssembly.Module)) return _instanceof(new WebAssembly.Instance(module), WebAssembly.Instance);
1269
+ }
1270
+ } catch (e) {}
1271
+ return false;
1272
+ }();
1273
+ if (supported) {
1274
+ runtimeMode = exports.PhysXRuntimeMode.WebAssembly;
1275
+ } else {
1276
+ runtimeMode = exports.PhysXRuntimeMode.JavaScript;
1277
+ }
1278
+ }
1279
+ if (runtimeMode == exports.PhysXRuntimeMode.JavaScript) {
1280
+ script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js.js";
1281
+ } else if (runtimeMode == exports.PhysXRuntimeMode.WebAssembly) {
1282
+ script.src = "https://gw.alipayobjects.com/os/lib/oasis-engine/physics-physx/0.9.0-beta.56/libs/physx.release.js";
1283
+ }
1284
+ });
1285
+ return new Promise(function(resolve, reject) {
1286
+ scriptPromise.then(function() {
1287
+ return window.PHYSX().then(function(PHYSX) {
1288
+ exports.PhysXPhysics._init(PHYSX);
1289
+ console.log("PhysX loaded.");
1290
+ resolve();
1291
+ }, reject);
1292
+ }, reject).catch(reject);
1293
+ });
1294
+ };
1295
+ /**
1296
+ * Destroy PhysXPhysics.
1297
+ */ PhysXPhysics1.destroy = function destroy() {
1298
+ this._pxFoundation.release();
1299
+ this._pxPhysics.release();
1300
+ this._physX = null;
1301
+ this._pxFoundation = null;
1302
+ this._pxPhysics = null;
1303
+ };
1304
+ /**
1305
+ * {@inheritDoc IPhysics.createPhysicsManager }
1306
+ */ PhysXPhysics1.createPhysicsManager = function createPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay) {
1307
+ return new PhysXPhysicsManager(onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay);
1308
+ };
1309
+ /**
1310
+ * {@inheritDoc IPhysics.createStaticCollider }
1311
+ */ PhysXPhysics1.createStaticCollider = function createStaticCollider(position, rotation) {
1312
+ return new PhysXStaticCollider(position, rotation);
1313
+ };
1314
+ /**
1315
+ * {@inheritDoc IPhysics.createDynamicCollider }
1316
+ */ PhysXPhysics1.createDynamicCollider = function createDynamicCollider(position, rotation) {
1317
+ return new PhysXDynamicCollider(position, rotation);
1318
+ };
1319
+ /**
1320
+ * {@inheritDoc IPhysics.createCharacterController }
1321
+ */ PhysXPhysics1.createCharacterController = function createCharacterController() {
1322
+ return new PhysXCharacterController();
1323
+ };
1324
+ /**
1325
+ * {@inheritDoc IPhysics.createPhysicsMaterial }
1326
+ */ PhysXPhysics1.createPhysicsMaterial = function createPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
1327
+ return new PhysXPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine);
1328
+ };
1329
+ /**
1330
+ * {@inheritDoc IPhysics.createBoxColliderShape }
1331
+ */ PhysXPhysics1.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
1332
+ return new PhysXBoxColliderShape(uniqueID, size, material);
1333
+ };
1334
+ /**
1335
+ * {@inheritDoc IPhysics.createSphereColliderShape }
1336
+ */ PhysXPhysics1.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
1337
+ return new PhysXSphereColliderShape(uniqueID, radius, material);
1338
+ };
1339
+ /**
1340
+ * {@inheritDoc IPhysics.createPlaneColliderShape }
1341
+ */ PhysXPhysics1.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
1342
+ return new PhysXPlaneColliderShape(uniqueID, material);
1343
+ };
1344
+ /**
1345
+ * {@inheritDoc IPhysics.createCapsuleColliderShape }
1346
+ */ PhysXPhysics1.createCapsuleColliderShape = function createCapsuleColliderShape(uniqueID, radius, height, material) {
1347
+ return new PhysXCapsuleColliderShape(uniqueID, radius, height, material);
1348
+ };
1349
+ /**
1350
+ * {@inheritDoc IPhysics.createFixedJoint }
1351
+ */ PhysXPhysics1.createFixedJoint = function createFixedJoint(collider) {
1352
+ return new PhysXFixedJoint(collider);
1353
+ };
1354
+ /**
1355
+ * {@inheritDoc IPhysics.createHingeJoint }
1356
+ */ PhysXPhysics1.createHingeJoint = function createHingeJoint(collider) {
1357
+ return new PhysXHingeJoint(collider);
1358
+ };
1359
+ /**
1360
+ * {@inheritDoc IPhysics.createSpringJoint }
1361
+ */ PhysXPhysics1.createSpringJoint = function createSpringJoint(collider) {
1362
+ return new PhysXSpringJoint(collider);
1363
+ };
1364
+ PhysXPhysics1._init = function _init(physX) {
1365
+ var version = physX.PX_PHYSICS_VERSION;
1366
+ var defaultErrorCallback = new physX.PxDefaultErrorCallback();
1367
+ var allocator = new physX.PxDefaultAllocator();
1368
+ var pxFoundation = physX.PxCreateFoundation(version, allocator, defaultErrorCallback);
1369
+ var pxPhysics = physX.PxCreatePhysics(version, pxFoundation, new physX.PxTolerancesScale(), false, null);
1370
+ physX.PxInitExtensions(pxPhysics, null);
1371
+ exports.PhysXPhysics._physX = physX;
1372
+ exports.PhysXPhysics._pxFoundation = pxFoundation;
1373
+ exports.PhysXPhysics._pxPhysics = pxPhysics;
1374
+ PhysXPhysicsManager._init();
1375
+ };
1376
+ return PhysXPhysics1;
1377
+ }();
1378
+ exports.PhysXPhysics = __decorate([
1379
+ StaticInterfaceImplement()
1380
+ ], exports.PhysXPhysics);
1369
1381
 
1370
- Object.defineProperty(exports, '__esModule', { value: true });
1382
+ Object.defineProperty(exports, '__esModule', { value: true });
1371
1383
 
1372
1384
  }));