diff options
author | Teravus Ovares | 2009-04-05 08:35:38 +0000 |
---|---|---|
committer | Teravus Ovares | 2009-04-05 08:35:38 +0000 |
commit | e592d038430ab994ed65df4f66e0cf5c32af476c (patch) | |
tree | fda1471564c4f5d24785df72803668fb117b16c4 | |
parent | Added CreateObject(regionhandle, userID, itemID) to post objects that are to ... (diff) | |
download | opensim-SC-e592d038430ab994ed65df4f66e0cf5c32af476c.zip opensim-SC-e592d038430ab994ed65df4f66e0cf5c32af476c.tar.gz opensim-SC-e592d038430ab994ed65df4f66e0cf5c32af476c.tar.bz2 opensim-SC-e592d038430ab994ed65df4f66e0cf5c32af476c.tar.xz |
* Committing what I have on the BulletDotNETPlugin that I have so far.
* It's not ready to try. It doesn't do what you expect in many ways.
* It throws errors and prints jibberish on the console
* Test it out only if you're brave and you've backed up first.
* The opensim.ini line is physics = BulletDotNETPlugin
-rw-r--r-- | OpenSim/Region/Physics/BulletDotNETPlugin/AssemblyInfo.cs | 58 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETCharacter.cs | 1104 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPlugin.cs | 65 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPluginStructs.cs | 33 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPrim.cs | 2131 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETScene.cs | 642 | ||||
-rw-r--r-- | bin/BulletDotNET.dll | bin | 0 -> 56832 bytes | |||
-rw-r--r-- | bin/BulletDotNET.pdb | bin | 0 -> 189952 bytes | |||
-rw-r--r-- | bin/libbulletnet.dll | bin | 0 -> 350208 bytes | |||
-rw-r--r-- | bin/libbulletnet.so | bin | 0 -> 4212382 bytes | |||
-rw-r--r-- | prebuild.xml | 28 |
11 files changed, 4061 insertions, 0 deletions
diff --git a/OpenSim/Region/Physics/BulletDotNETPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/BulletDotNETPlugin/AssemblyInfo.cs new file mode 100644 index 0000000..d10c8ad --- /dev/null +++ b/OpenSim/Region/Physics/BulletDotNETPlugin/AssemblyInfo.cs | |||
@@ -0,0 +1,58 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSim Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System.Reflection; | ||
29 | using System.Runtime.InteropServices; | ||
30 | |||
31 | // Information about this assembly is defined by the following | ||
32 | // attributes. | ||
33 | // | ||
34 | // change them to the information which is associated with the assembly | ||
35 | // you compile. | ||
36 | |||
37 | [assembly : AssemblyTitle("BulletDotNETPlugin")] | ||
38 | [assembly : AssemblyDescription("")] | ||
39 | [assembly : AssemblyConfiguration("")] | ||
40 | [assembly : AssemblyCompany("http://opensimulator.org")] | ||
41 | [assembly : AssemblyProduct("OdePlugin")] | ||
42 | [assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2009")] | ||
43 | [assembly : AssemblyTrademark("")] | ||
44 | [assembly : AssemblyCulture("")] | ||
45 | |||
46 | // This sets the default COM visibility of types in the assembly to invisible. | ||
47 | // If you need to expose a type to COM, use [ComVisible(true)] on that type. | ||
48 | |||
49 | [assembly : ComVisible(false)] | ||
50 | |||
51 | // The assembly version has following format : | ||
52 | // | ||
53 | // Major.Minor.Build.Revision | ||
54 | // | ||
55 | // You can specify all values by your own or you can build default build and revision | ||
56 | // numbers with the '*' character (the default): | ||
57 | |||
58 | [assembly : AssemblyVersion("0.6.3.*")] | ||
diff --git a/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETCharacter.cs b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETCharacter.cs new file mode 100644 index 0000000..6791671 --- /dev/null +++ b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETCharacter.cs | |||
@@ -0,0 +1,1104 @@ | |||
1 | using System; | ||
2 | using System.Reflection; | ||
3 | using BulletDotNET; | ||
4 | using OpenMetaverse; | ||
5 | using OpenSim.Framework; | ||
6 | using OpenSim.Region.Physics.Manager; | ||
7 | using log4net; | ||
8 | |||
9 | namespace OpenSim.Region.Physics.BulletDotNETPlugin | ||
10 | { | ||
11 | public class BulletDotNETCharacter : PhysicsActor | ||
12 | { | ||
13 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
14 | |||
15 | public btRigidBody Body; | ||
16 | public btCollisionShape Shell; | ||
17 | public btVector3 tempVector1; | ||
18 | public btVector3 tempVector2; | ||
19 | public btVector3 tempVector3; | ||
20 | public btVector3 tempVector4; | ||
21 | |||
22 | public btVector3 tempVector5RayCast; | ||
23 | public btVector3 tempVector6RayCast; | ||
24 | public btVector3 tempVector7RayCast; | ||
25 | |||
26 | public btQuaternion tempQuat1; | ||
27 | public btTransform tempTrans1; | ||
28 | |||
29 | public ClosestNotMeRayResultCallback ClosestCastResult; | ||
30 | private btTransform m_bodyTransform; | ||
31 | private btVector3 m_bodyPosition; | ||
32 | private btVector3 m_CapsuleOrientationAxis; | ||
33 | private btQuaternion m_bodyOrientation; | ||
34 | private btDefaultMotionState m_bodyMotionState; | ||
35 | private btGeneric6DofConstraint m_aMotor; | ||
36 | private PhysicsVector m_movementComparision; | ||
37 | private PhysicsVector m_position; | ||
38 | private PhysicsVector m_zeroPosition; | ||
39 | private bool m_zeroFlag = false; | ||
40 | private bool m_lastUpdateSent = false; | ||
41 | private PhysicsVector m_velocity; | ||
42 | private PhysicsVector m_target_velocity; | ||
43 | private PhysicsVector m_acceleration; | ||
44 | private PhysicsVector m_rotationalVelocity; | ||
45 | private bool m_pidControllerActive = true; | ||
46 | public float PID_D = 80.0f; | ||
47 | public float PID_P = 90.0f; | ||
48 | public float CAPSULE_RADIUS = 0.37f; | ||
49 | public float CAPSULE_LENGTH = 2.140599f; | ||
50 | public float heightFudgeFactor = 0.52f; | ||
51 | public float walkDivisor = 1.3f; | ||
52 | public float runDivisor = 0.8f; | ||
53 | private float m_mass = 80f; | ||
54 | public float m_density = 60f; | ||
55 | private bool m_flying = false; | ||
56 | private bool m_iscolliding = false; | ||
57 | private bool m_iscollidingGround = false; | ||
58 | private bool m_wascolliding = false; | ||
59 | private bool m_wascollidingGround = false; | ||
60 | private bool m_iscollidingObj = false; | ||
61 | private bool m_alwaysRun = false; | ||
62 | private bool m_hackSentFall = false; | ||
63 | private bool m_hackSentFly = false; | ||
64 | public uint m_localID = 0; | ||
65 | public bool m_returnCollisions = false; | ||
66 | // taints and their non-tainted counterparts | ||
67 | public bool m_isPhysical = false; // the current physical status | ||
68 | public bool m_tainted_isPhysical = false; // set when the physical status is tainted (false=not existing in physics engine, true=existing) | ||
69 | private float m_tainted_CAPSULE_LENGTH; // set when the capsule length changes. | ||
70 | private bool m_taintRemove = false; | ||
71 | private bool m_taintedPosition = false; | ||
72 | private PhysicsVector m_taintedPosition_value; | ||
73 | private PhysicsVector m_taintedForce; | ||
74 | |||
75 | private float m_buoyancy = 0f; | ||
76 | |||
77 | // private CollisionLocker ode; | ||
78 | |||
79 | private string m_name = String.Empty; | ||
80 | |||
81 | private bool[] m_colliderarr = new bool[11]; | ||
82 | private bool[] m_colliderGroundarr = new bool[11]; | ||
83 | |||
84 | |||
85 | |||
86 | private BulletDotNETScene m_parent_scene; | ||
87 | |||
88 | public int m_eventsubscription = 0; | ||
89 | private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate(); | ||
90 | |||
91 | public BulletDotNETCharacter(string avName, BulletDotNETScene parent_scene, PhysicsVector pos, PhysicsVector size, float pid_d, float pid_p, float capsule_radius, float tensor, float density, float height_fudge_factor, float walk_divisor, float rundivisor) | ||
92 | { | ||
93 | m_taintedForce = new PhysicsVector(); | ||
94 | m_velocity = new PhysicsVector(); | ||
95 | m_target_velocity = new PhysicsVector(); | ||
96 | m_position = pos; | ||
97 | m_zeroPosition = new PhysicsVector(pos.X, pos.Y, pos.Z); // this is a class, not a struct. Must make new, or m_zeroPosition will == position regardless | ||
98 | m_acceleration = new PhysicsVector(); | ||
99 | m_parent_scene = parent_scene; | ||
100 | PID_D = pid_d; | ||
101 | PID_P = pid_p; | ||
102 | CAPSULE_RADIUS = capsule_radius; | ||
103 | m_density = density; | ||
104 | heightFudgeFactor = height_fudge_factor; | ||
105 | walkDivisor = walk_divisor; | ||
106 | runDivisor = rundivisor; | ||
107 | |||
108 | for (int i = 0; i < 11; i++) | ||
109 | { | ||
110 | m_colliderarr[i] = false; | ||
111 | } | ||
112 | for (int i = 0; i < 11; i++) | ||
113 | { | ||
114 | m_colliderGroundarr[i] = false; | ||
115 | } | ||
116 | CAPSULE_LENGTH = (size.Z * 1.15f) - CAPSULE_RADIUS * 2.0f; | ||
117 | m_tainted_CAPSULE_LENGTH = CAPSULE_LENGTH; | ||
118 | m_isPhysical = false; // current status: no ODE information exists | ||
119 | m_tainted_isPhysical = true; // new tainted status: need to create ODE information | ||
120 | |||
121 | m_parent_scene.AddPhysicsActorTaint(this); | ||
122 | |||
123 | m_name = avName; | ||
124 | tempVector1 = new btVector3(0, 0, 0); | ||
125 | tempVector2 = new btVector3(0, 0, 0); | ||
126 | tempVector3 = new btVector3(0, 0, 0); | ||
127 | tempVector4 = new btVector3(0, 0, 0); | ||
128 | |||
129 | tempVector5RayCast = new btVector3(0, 0, 0); | ||
130 | tempVector6RayCast = new btVector3(0, 0, 0); | ||
131 | tempVector7RayCast = new btVector3(0, 0, 0); | ||
132 | |||
133 | tempQuat1 = new btQuaternion(0, 0, 0, 1); | ||
134 | tempTrans1 = new btTransform(tempQuat1, tempVector1); | ||
135 | m_movementComparision = new PhysicsVector(0, 0, 0); | ||
136 | m_CapsuleOrientationAxis = new btVector3(1, 0, 1); | ||
137 | |||
138 | |||
139 | |||
140 | } | ||
141 | |||
142 | /// <summary> | ||
143 | /// This creates the Avatar's physical Surrogate at the position supplied | ||
144 | /// </summary> | ||
145 | /// <param name="npositionX"></param> | ||
146 | /// <param name="npositionY"></param> | ||
147 | /// <param name="npositionZ"></param> | ||
148 | |||
149 | // WARNING: This MUST NOT be called outside of ProcessTaints, else we can have unsynchronized access | ||
150 | // to ODE internals. ProcessTaints is called from within thread-locked Simulate(), so it is the only | ||
151 | // place that is safe to call this routine AvatarGeomAndBodyCreation. | ||
152 | private void AvatarGeomAndBodyCreation(float npositionX, float npositionY, float npositionZ) | ||
153 | { | ||
154 | |||
155 | if (CAPSULE_LENGTH <= 0) | ||
156 | { | ||
157 | m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!"); | ||
158 | CAPSULE_LENGTH = 0.01f; | ||
159 | |||
160 | } | ||
161 | |||
162 | if (CAPSULE_RADIUS <= 0) | ||
163 | { | ||
164 | m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!"); | ||
165 | CAPSULE_RADIUS = 0.01f; | ||
166 | |||
167 | } | ||
168 | |||
169 | Shell = new btCapsuleShape(CAPSULE_RADIUS, CAPSULE_LENGTH); | ||
170 | |||
171 | if (m_bodyPosition == null) | ||
172 | m_bodyPosition = new btVector3(npositionX, npositionY, npositionZ); | ||
173 | |||
174 | m_bodyPosition.setValue(npositionX, npositionY, npositionZ); | ||
175 | |||
176 | if (m_bodyOrientation == null) | ||
177 | m_bodyOrientation = new btQuaternion(m_CapsuleOrientationAxis, (Utils.DEG_TO_RAD * 90)); | ||
178 | |||
179 | if (m_bodyTransform == null) | ||
180 | m_bodyTransform = new btTransform(m_bodyOrientation, m_bodyPosition); | ||
181 | else | ||
182 | { | ||
183 | m_bodyTransform.Dispose(); | ||
184 | m_bodyTransform = new btTransform(m_bodyOrientation, m_bodyPosition); | ||
185 | } | ||
186 | |||
187 | if (m_bodyMotionState == null) | ||
188 | m_bodyMotionState = new btDefaultMotionState(m_bodyTransform); | ||
189 | else | ||
190 | m_bodyMotionState.setWorldTransform(m_bodyTransform); | ||
191 | |||
192 | m_mass = Mass; | ||
193 | |||
194 | Body = new btRigidBody(m_mass, m_bodyMotionState, Shell); | ||
195 | Body.setUserPointer(new IntPtr((int)Body.Handle)); | ||
196 | |||
197 | if (ClosestCastResult != null) | ||
198 | ClosestCastResult.Dispose(); | ||
199 | ClosestCastResult = new ClosestNotMeRayResultCallback(Body); | ||
200 | |||
201 | m_parent_scene.AddRigidBody(Body); | ||
202 | Body.setActivationState(4); | ||
203 | if (m_aMotor != null) | ||
204 | { | ||
205 | if (m_aMotor.Handle != IntPtr.Zero) | ||
206 | { | ||
207 | m_parent_scene.getBulletWorld().removeConstraint(m_aMotor); | ||
208 | m_aMotor.Dispose(); | ||
209 | } | ||
210 | m_aMotor = null; | ||
211 | } | ||
212 | |||
213 | m_aMotor = new btGeneric6DofConstraint(Body, m_parent_scene.TerrainBody, | ||
214 | m_parent_scene.TransZero, | ||
215 | m_parent_scene.TransZero, false); | ||
216 | m_aMotor.setAngularLowerLimit(m_parent_scene.VectorZero); | ||
217 | m_aMotor.setAngularUpperLimit(m_parent_scene.VectorZero); | ||
218 | |||
219 | |||
220 | } | ||
221 | public void Remove() | ||
222 | { | ||
223 | m_taintRemove = true; | ||
224 | } | ||
225 | public override bool Stopped | ||
226 | { | ||
227 | get { return m_zeroFlag; } | ||
228 | } | ||
229 | |||
230 | public override PhysicsVector Size | ||
231 | { | ||
232 | get { return new PhysicsVector(CAPSULE_RADIUS * 2, CAPSULE_RADIUS * 2, CAPSULE_LENGTH); } | ||
233 | set | ||
234 | { | ||
235 | m_pidControllerActive = true; | ||
236 | |||
237 | PhysicsVector SetSize = value; | ||
238 | m_tainted_CAPSULE_LENGTH = (SetSize.Z * 1.15f) - CAPSULE_RADIUS * 2.0f; | ||
239 | //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString()); | ||
240 | |||
241 | Velocity = new PhysicsVector(0f, 0f, 0f); | ||
242 | |||
243 | m_parent_scene.AddPhysicsActorTaint(this); | ||
244 | } | ||
245 | } | ||
246 | |||
247 | /// <summary> | ||
248 | /// turn the PID controller on or off. | ||
249 | /// The PID Controller will turn on all by itself in many situations | ||
250 | /// </summary> | ||
251 | /// <param name="status"></param> | ||
252 | public void SetPidStatus(bool status) | ||
253 | { | ||
254 | m_pidControllerActive = status; | ||
255 | } | ||
256 | |||
257 | public override PrimitiveBaseShape Shape | ||
258 | { | ||
259 | set { return; } | ||
260 | } | ||
261 | |||
262 | public override uint LocalID | ||
263 | { | ||
264 | set { m_localID = value; } | ||
265 | } | ||
266 | |||
267 | public override bool Grabbed | ||
268 | { | ||
269 | set { return; } | ||
270 | } | ||
271 | |||
272 | public override bool Selected | ||
273 | { | ||
274 | set { return; } | ||
275 | } | ||
276 | |||
277 | |||
278 | public override void CrossingFailure() | ||
279 | { | ||
280 | |||
281 | } | ||
282 | |||
283 | public override void link(PhysicsActor obj) | ||
284 | { | ||
285 | |||
286 | } | ||
287 | |||
288 | public override void delink() | ||
289 | { | ||
290 | |||
291 | } | ||
292 | |||
293 | public override void LockAngularMotion(PhysicsVector axis) | ||
294 | { | ||
295 | |||
296 | } | ||
297 | |||
298 | public override PhysicsVector Position | ||
299 | { | ||
300 | get { return m_position; } | ||
301 | set | ||
302 | { | ||
303 | m_taintedPosition_value = value; | ||
304 | m_position = value; | ||
305 | m_taintedPosition = true; | ||
306 | } | ||
307 | } | ||
308 | |||
309 | public override float Mass | ||
310 | { | ||
311 | get | ||
312 | { | ||
313 | float AVvolume = (float)(Math.PI * Math.Pow(CAPSULE_RADIUS, 2) * CAPSULE_LENGTH); | ||
314 | return m_density * AVvolume; | ||
315 | } | ||
316 | } | ||
317 | |||
318 | public override PhysicsVector Force | ||
319 | { | ||
320 | get { return new PhysicsVector(m_target_velocity.X, m_target_velocity.Y, m_target_velocity.Z); } | ||
321 | set { return; } | ||
322 | } | ||
323 | |||
324 | public override int VehicleType | ||
325 | { | ||
326 | get { return 0; } | ||
327 | set { return; } | ||
328 | } | ||
329 | |||
330 | public override void VehicleFloatParam(int param, float value) | ||
331 | { | ||
332 | |||
333 | } | ||
334 | |||
335 | public override void VehicleVectorParam(int param, PhysicsVector value) | ||
336 | { | ||
337 | |||
338 | } | ||
339 | |||
340 | public override void VehicleRotationParam(int param, Quaternion rotation) | ||
341 | { | ||
342 | |||
343 | } | ||
344 | |||
345 | public override void SetVolumeDetect(int param) | ||
346 | { | ||
347 | |||
348 | } | ||
349 | |||
350 | public override PhysicsVector GeometricCenter | ||
351 | { | ||
352 | get { return PhysicsVector.Zero; } | ||
353 | } | ||
354 | |||
355 | public override PhysicsVector CenterOfMass | ||
356 | { | ||
357 | get { return PhysicsVector.Zero; } | ||
358 | } | ||
359 | |||
360 | public override PhysicsVector Velocity | ||
361 | { | ||
362 | get | ||
363 | { | ||
364 | // There's a problem with PhysicsVector.Zero! Don't Use it Here! | ||
365 | if (m_zeroFlag) | ||
366 | return new PhysicsVector(0f, 0f, 0f); | ||
367 | m_lastUpdateSent = false; | ||
368 | return m_velocity; | ||
369 | } | ||
370 | set | ||
371 | { | ||
372 | m_pidControllerActive = true; | ||
373 | m_target_velocity = value; | ||
374 | } | ||
375 | } | ||
376 | |||
377 | public override PhysicsVector Torque | ||
378 | { | ||
379 | get { return PhysicsVector.Zero; } | ||
380 | set { return; } | ||
381 | } | ||
382 | |||
383 | public override float CollisionScore | ||
384 | { | ||
385 | get { return 0f; } | ||
386 | set { } | ||
387 | } | ||
388 | |||
389 | public override PhysicsVector Acceleration | ||
390 | { | ||
391 | get { return m_acceleration; } | ||
392 | } | ||
393 | |||
394 | public override Quaternion Orientation | ||
395 | { | ||
396 | get { return Quaternion.Identity; } | ||
397 | set | ||
398 | { | ||
399 | |||
400 | } | ||
401 | } | ||
402 | |||
403 | public override int PhysicsActorType | ||
404 | { | ||
405 | get { return (int)ActorTypes.Agent; } | ||
406 | set { return; } | ||
407 | } | ||
408 | |||
409 | public override bool IsPhysical | ||
410 | { | ||
411 | get { return false; } | ||
412 | set { return; } | ||
413 | } | ||
414 | |||
415 | public override bool Flying | ||
416 | { | ||
417 | get { return m_flying; } | ||
418 | set { m_flying = value; } | ||
419 | } | ||
420 | |||
421 | public override bool SetAlwaysRun | ||
422 | { | ||
423 | get { return m_alwaysRun; } | ||
424 | set { m_alwaysRun = value; } | ||
425 | } | ||
426 | |||
427 | |||
428 | public override bool ThrottleUpdates | ||
429 | { | ||
430 | get { return false; } | ||
431 | set { return; } | ||
432 | } | ||
433 | |||
434 | /// <summary> | ||
435 | /// Returns if the avatar is colliding in general. | ||
436 | /// This includes the ground and objects and avatar. | ||
437 | /// </summary> | ||
438 | public override bool IsColliding | ||
439 | { | ||
440 | get { return m_iscolliding; } | ||
441 | set | ||
442 | { | ||
443 | int i; | ||
444 | int truecount = 0; | ||
445 | int falsecount = 0; | ||
446 | |||
447 | if (m_colliderarr.Length >= 10) | ||
448 | { | ||
449 | for (i = 0; i < 10; i++) | ||
450 | { | ||
451 | m_colliderarr[i] = m_colliderarr[i + 1]; | ||
452 | } | ||
453 | } | ||
454 | m_colliderarr[10] = value; | ||
455 | |||
456 | for (i = 0; i < 11; i++) | ||
457 | { | ||
458 | if (m_colliderarr[i]) | ||
459 | { | ||
460 | truecount++; | ||
461 | } | ||
462 | else | ||
463 | { | ||
464 | falsecount++; | ||
465 | } | ||
466 | } | ||
467 | |||
468 | // Equal truecounts and false counts means we're colliding with something. | ||
469 | m_log.DebugFormat("[PHYSICS]: TrueCount:{0}, FalseCount:{1}",truecount,falsecount); | ||
470 | if (falsecount > 1.2 * truecount) | ||
471 | { | ||
472 | m_iscolliding = false; | ||
473 | } | ||
474 | else | ||
475 | { | ||
476 | m_iscolliding = true; | ||
477 | } | ||
478 | if (m_wascolliding != m_iscolliding) | ||
479 | { | ||
480 | //base.SendCollisionUpdate(new CollisionEventUpdate()); | ||
481 | } | ||
482 | m_wascolliding = m_iscolliding; | ||
483 | } | ||
484 | } | ||
485 | |||
486 | /// <summary> | ||
487 | /// Returns if an avatar is colliding with the ground | ||
488 | /// </summary> | ||
489 | public override bool CollidingGround | ||
490 | { | ||
491 | get { return m_iscollidingGround; } | ||
492 | set | ||
493 | { | ||
494 | // Collisions against the ground are not really reliable | ||
495 | // So, to get a consistant value we have to average the current result over time | ||
496 | // Currently we use 1 second = 10 calls to this. | ||
497 | int i; | ||
498 | int truecount = 0; | ||
499 | int falsecount = 0; | ||
500 | |||
501 | if (m_colliderGroundarr.Length >= 10) | ||
502 | { | ||
503 | for (i = 0; i < 10; i++) | ||
504 | { | ||
505 | m_colliderGroundarr[i] = m_colliderGroundarr[i + 1]; | ||
506 | } | ||
507 | } | ||
508 | m_colliderGroundarr[10] = value; | ||
509 | |||
510 | for (i = 0; i < 11; i++) | ||
511 | { | ||
512 | if (m_colliderGroundarr[i]) | ||
513 | { | ||
514 | truecount++; | ||
515 | } | ||
516 | else | ||
517 | { | ||
518 | falsecount++; | ||
519 | } | ||
520 | } | ||
521 | |||
522 | // Equal truecounts and false counts means we're colliding with something. | ||
523 | |||
524 | if (falsecount > 1.2 * truecount) | ||
525 | { | ||
526 | m_iscollidingGround = false; | ||
527 | } | ||
528 | else | ||
529 | { | ||
530 | m_iscollidingGround = true; | ||
531 | } | ||
532 | if (m_wascollidingGround != m_iscollidingGround) | ||
533 | { | ||
534 | //base.SendCollisionUpdate(new CollisionEventUpdate()); | ||
535 | } | ||
536 | m_wascollidingGround = m_iscollidingGround; | ||
537 | } | ||
538 | } | ||
539 | |||
540 | /// <summary> | ||
541 | /// Returns if the avatar is colliding with an object | ||
542 | /// </summary> | ||
543 | public override bool CollidingObj | ||
544 | { | ||
545 | get { return m_iscollidingObj; } | ||
546 | set | ||
547 | { | ||
548 | m_iscollidingObj = value; | ||
549 | if (value) | ||
550 | m_pidControllerActive = false; | ||
551 | else | ||
552 | m_pidControllerActive = true; | ||
553 | } | ||
554 | } | ||
555 | |||
556 | |||
557 | public override bool FloatOnWater | ||
558 | { | ||
559 | set { return; } | ||
560 | } | ||
561 | |||
562 | public override PhysicsVector RotationalVelocity | ||
563 | { | ||
564 | get { return m_rotationalVelocity; } | ||
565 | set { m_rotationalVelocity = value; } | ||
566 | } | ||
567 | |||
568 | public override bool Kinematic | ||
569 | { | ||
570 | get { return false; } | ||
571 | set { } | ||
572 | } | ||
573 | |||
574 | public override float Buoyancy | ||
575 | { | ||
576 | get { return m_buoyancy; } | ||
577 | set { m_buoyancy = value; } | ||
578 | } | ||
579 | |||
580 | public override PhysicsVector PIDTarget { set { return; } } | ||
581 | public override bool PIDActive { set { return; } } | ||
582 | public override float PIDTau { set { return; } } | ||
583 | |||
584 | public override bool PIDHoverActive | ||
585 | { | ||
586 | set { return; } | ||
587 | } | ||
588 | |||
589 | public override float PIDHoverHeight | ||
590 | { | ||
591 | set { return; } | ||
592 | } | ||
593 | |||
594 | public override PIDHoverType PIDHoverType | ||
595 | { | ||
596 | set { return; } | ||
597 | } | ||
598 | |||
599 | public override float PIDHoverTau | ||
600 | { | ||
601 | set { return; } | ||
602 | } | ||
603 | |||
604 | /// <summary> | ||
605 | /// Adds the force supplied to the Target Velocity | ||
606 | /// The PID controller takes this target velocity and tries to make it a reality | ||
607 | /// </summary> | ||
608 | /// <param name="force"></param> | ||
609 | /// <param name="pushforce">Is this a push by a script?</param> | ||
610 | public override void AddForce(PhysicsVector force, bool pushforce) | ||
611 | { | ||
612 | if (pushforce) | ||
613 | { | ||
614 | m_pidControllerActive = false; | ||
615 | force *= 100f; | ||
616 | doForce(force, false); | ||
617 | //System.Console.WriteLine("Push!"); | ||
618 | //_target_velocity.X += force.X; | ||
619 | // _target_velocity.Y += force.Y; | ||
620 | //_target_velocity.Z += force.Z; | ||
621 | } | ||
622 | else | ||
623 | { | ||
624 | m_pidControllerActive = true; | ||
625 | m_target_velocity.X += force.X; | ||
626 | m_target_velocity.Y += force.Y; | ||
627 | m_target_velocity.Z += force.Z; | ||
628 | } | ||
629 | //m_lastUpdateSent = false; | ||
630 | } | ||
631 | |||
632 | public void doForce(PhysicsVector force, bool now) | ||
633 | { | ||
634 | |||
635 | tempVector3.setValue(force.X, force.Y, force.Z); | ||
636 | if (now) | ||
637 | { | ||
638 | Body.applyCentralForce(tempVector3); | ||
639 | } | ||
640 | else | ||
641 | { | ||
642 | m_taintedForce += force; | ||
643 | m_parent_scene.AddPhysicsActorTaint(this); | ||
644 | } | ||
645 | } | ||
646 | |||
647 | public void doImpulse(PhysicsVector force, bool now) | ||
648 | { | ||
649 | |||
650 | tempVector3.setValue(force.X, force.Y, force.Z); | ||
651 | if (now) | ||
652 | { | ||
653 | Body.applyCentralImpulse(tempVector3); | ||
654 | } | ||
655 | else | ||
656 | { | ||
657 | m_taintedForce += force; | ||
658 | m_parent_scene.AddPhysicsActorTaint(this); | ||
659 | } | ||
660 | } | ||
661 | |||
662 | public override void AddAngularForce(PhysicsVector force, bool pushforce) | ||
663 | { | ||
664 | |||
665 | } | ||
666 | |||
667 | public override void SetMomentum(PhysicsVector momentum) | ||
668 | { | ||
669 | |||
670 | } | ||
671 | |||
672 | public override void SubscribeEvents(int ms) | ||
673 | { | ||
674 | m_eventsubscription = ms; | ||
675 | m_parent_scene.addCollisionEventReporting(this); | ||
676 | } | ||
677 | |||
678 | public override void UnSubscribeEvents() | ||
679 | { | ||
680 | m_parent_scene.remCollisionEventReporting(this); | ||
681 | m_eventsubscription = 0; | ||
682 | } | ||
683 | |||
684 | public override bool SubscribedEvents() | ||
685 | { | ||
686 | if (m_eventsubscription > 0) | ||
687 | return true; | ||
688 | return false; | ||
689 | } | ||
690 | |||
691 | internal void Dispose() | ||
692 | { | ||
693 | if (Body.isInWorld()) | ||
694 | m_parent_scene.removeFromWorld(Body); | ||
695 | |||
696 | if (m_aMotor.Handle != IntPtr.Zero) | ||
697 | m_parent_scene.getBulletWorld().removeConstraint(m_aMotor); | ||
698 | |||
699 | m_aMotor.Dispose(); m_aMotor = null; | ||
700 | ClosestCastResult.Dispose(); ClosestCastResult = null; | ||
701 | Body.Dispose(); Body = null; | ||
702 | Shell.Dispose(); Shell = null; | ||
703 | tempQuat1.Dispose(); | ||
704 | tempTrans1.Dispose(); | ||
705 | tempVector1.Dispose(); | ||
706 | tempVector2.Dispose(); | ||
707 | tempVector3.Dispose(); | ||
708 | tempVector4.Dispose(); | ||
709 | tempVector5RayCast.Dispose(); | ||
710 | tempVector6RayCast.Dispose(); | ||
711 | |||
712 | } | ||
713 | |||
714 | public void ProcessTaints(float timestep) | ||
715 | { | ||
716 | |||
717 | if (m_tainted_isPhysical != m_isPhysical) | ||
718 | { | ||
719 | if (m_tainted_isPhysical) | ||
720 | { | ||
721 | // Create avatar capsule and related ODE data | ||
722 | if (!(Shell == null && Body == null)) | ||
723 | { | ||
724 | m_log.Warn("[PHYSICS]: re-creating the following avatar ODE data, even though it already exists - " | ||
725 | + (Shell != null ? "Shell " : "") | ||
726 | + (Body != null ? "Body " : "")); | ||
727 | } | ||
728 | AvatarGeomAndBodyCreation(m_position.X, m_position.Y, m_position.Z); | ||
729 | |||
730 | |||
731 | } | ||
732 | else | ||
733 | { | ||
734 | // destroy avatar capsule and related ODE data | ||
735 | |||
736 | Dispose(); | ||
737 | tempVector1 = new btVector3(0, 0, 0); | ||
738 | tempVector2 = new btVector3(0, 0, 0); | ||
739 | tempVector3 = new btVector3(0, 0, 0); | ||
740 | tempVector4 = new btVector3(0, 0, 0); | ||
741 | |||
742 | tempVector5RayCast = new btVector3(0, 0, 0); | ||
743 | tempVector6RayCast = new btVector3(0, 0, 0); | ||
744 | tempVector7RayCast = new btVector3(0, 0, 0); | ||
745 | |||
746 | tempQuat1 = new btQuaternion(0, 0, 0, 1); | ||
747 | tempTrans1 = new btTransform(tempQuat1, tempVector1); | ||
748 | m_movementComparision = new PhysicsVector(0, 0, 0); | ||
749 | m_CapsuleOrientationAxis = new btVector3(1, 0, 1); | ||
750 | } | ||
751 | |||
752 | m_isPhysical = m_tainted_isPhysical; | ||
753 | } | ||
754 | |||
755 | if (m_tainted_CAPSULE_LENGTH != CAPSULE_LENGTH) | ||
756 | { | ||
757 | if (Body != null) | ||
758 | { | ||
759 | |||
760 | m_pidControllerActive = true; | ||
761 | // no lock needed on _parent_scene.OdeLock because we are called from within the thread lock in OdePlugin's simulate() | ||
762 | //d.JointDestroy(Amotor); | ||
763 | float prevCapsule = CAPSULE_LENGTH; | ||
764 | CAPSULE_LENGTH = m_tainted_CAPSULE_LENGTH; | ||
765 | //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString()); | ||
766 | Dispose(); | ||
767 | |||
768 | tempVector1 = new btVector3(0, 0, 0); | ||
769 | tempVector2 = new btVector3(0, 0, 0); | ||
770 | tempVector3 = new btVector3(0, 0, 0); | ||
771 | tempVector4 = new btVector3(0, 0, 0); | ||
772 | |||
773 | tempVector5RayCast = new btVector3(0, 0, 0); | ||
774 | tempVector6RayCast = new btVector3(0, 0, 0); | ||
775 | tempVector7RayCast = new btVector3(0, 0, 0); | ||
776 | |||
777 | tempQuat1 = new btQuaternion(0, 0, 0, 1); | ||
778 | tempTrans1 = new btTransform(tempQuat1, tempVector1); | ||
779 | m_movementComparision = new PhysicsVector(0, 0, 0); | ||
780 | m_CapsuleOrientationAxis = new btVector3(1, 0, 1); | ||
781 | |||
782 | AvatarGeomAndBodyCreation(m_position.X, m_position.Y, | ||
783 | m_position.Z + (Math.Abs(CAPSULE_LENGTH - prevCapsule) * 2)); | ||
784 | Velocity = new PhysicsVector(0f, 0f, 0f); | ||
785 | |||
786 | } | ||
787 | else | ||
788 | { | ||
789 | m_log.Warn("[PHYSICS]: trying to change capsule size, but the following ODE data is missing - " | ||
790 | + (Shell == null ? "Shell " : "") | ||
791 | + (Body == null ? "Body " : "")); | ||
792 | } | ||
793 | } | ||
794 | if (m_taintRemove) | ||
795 | { | ||
796 | Dispose(); | ||
797 | } | ||
798 | } | ||
799 | |||
800 | /// <summary> | ||
801 | /// Called from Simulate | ||
802 | /// This is the avatar's movement control + PID Controller | ||
803 | /// </summary> | ||
804 | /// <param name="timeStep"></param> | ||
805 | public void Move(float timeStep) | ||
806 | { | ||
807 | // no lock; for now it's only called from within Simulate() | ||
808 | |||
809 | // If the PID Controller isn't active then we set our force | ||
810 | // calculating base velocity to the current position | ||
811 | if (Body == null) | ||
812 | return; | ||
813 | tempTrans1.Dispose(); | ||
814 | tempTrans1 = Body.getInterpolationWorldTransform(); | ||
815 | tempVector1.Dispose(); | ||
816 | tempVector1 = tempTrans1.getOrigin(); | ||
817 | tempVector2.Dispose(); | ||
818 | tempVector2 = Body.getInterpolationLinearVelocity(); | ||
819 | |||
820 | if (m_pidControllerActive == false) | ||
821 | { | ||
822 | m_zeroPosition.X = tempVector1.getX(); | ||
823 | m_zeroPosition.Y = tempVector1.getY(); | ||
824 | m_zeroPosition.Z = tempVector1.getZ(); | ||
825 | } | ||
826 | //PidStatus = true; | ||
827 | |||
828 | PhysicsVector vec = new PhysicsVector(); | ||
829 | |||
830 | PhysicsVector vel = new PhysicsVector(tempVector2.getX(), tempVector2.getY(), tempVector2.getZ()); | ||
831 | |||
832 | float movementdivisor = 1f; | ||
833 | |||
834 | if (!m_alwaysRun) | ||
835 | { | ||
836 | movementdivisor = walkDivisor; | ||
837 | } | ||
838 | else | ||
839 | { | ||
840 | movementdivisor = runDivisor; | ||
841 | } | ||
842 | |||
843 | // if velocity is zero, use position control; otherwise, velocity control | ||
844 | if (m_target_velocity.X == 0.0f && m_target_velocity.Y == 0.0f && m_target_velocity.Z == 0.0f && m_iscolliding) | ||
845 | { | ||
846 | // keep track of where we stopped. No more slippin' & slidin' | ||
847 | if (!m_zeroFlag) | ||
848 | { | ||
849 | m_zeroFlag = true; | ||
850 | m_zeroPosition.X = tempVector1.getX(); | ||
851 | m_zeroPosition.Y = tempVector1.getY(); | ||
852 | m_zeroPosition.Z = tempVector1.getZ(); | ||
853 | } | ||
854 | if (m_pidControllerActive) | ||
855 | { | ||
856 | // We only want to deactivate the PID Controller if we think we want to have our surrogate | ||
857 | // react to the physics scene by moving it's position. | ||
858 | // Avatar to Avatar collisions | ||
859 | // Prim to avatar collisions | ||
860 | |||
861 | PhysicsVector pos = new PhysicsVector(tempVector1.getX(), tempVector1.getY(), tempVector1.getZ()); | ||
862 | vec.X = (m_target_velocity.X - vel.X) * (PID_D) + (m_zeroPosition.X - pos.X) * (PID_P * 2); | ||
863 | vec.Y = (m_target_velocity.Y - vel.Y) * (PID_D) + (m_zeroPosition.Y - pos.Y) * (PID_P * 2); | ||
864 | if (m_flying) | ||
865 | { | ||
866 | vec.Z = (m_target_velocity.Z - vel.Z) * (PID_D) + (m_zeroPosition.Z - pos.Z) * PID_P; | ||
867 | } | ||
868 | } | ||
869 | //PidStatus = true; | ||
870 | } | ||
871 | else | ||
872 | { | ||
873 | m_pidControllerActive = true; | ||
874 | m_zeroFlag = false; | ||
875 | if (m_iscolliding && !m_flying) | ||
876 | { | ||
877 | // We're standing on something | ||
878 | vec.X = ((m_target_velocity.X / movementdivisor) - vel.X) * (PID_D); | ||
879 | vec.Y = ((m_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D); | ||
880 | } | ||
881 | else if (m_iscolliding && m_flying) | ||
882 | { | ||
883 | // We're flying and colliding with something | ||
884 | vec.X = ((m_target_velocity.X / movementdivisor) - vel.X) * (PID_D / 16); | ||
885 | vec.Y = ((m_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D / 16); | ||
886 | } | ||
887 | else if (!m_iscolliding && m_flying) | ||
888 | { | ||
889 | // we're in mid air suspended | ||
890 | vec.X = ((m_target_velocity.X / movementdivisor) - vel.X) * (PID_D / 6); | ||
891 | vec.Y = ((m_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D / 6); | ||
892 | } | ||
893 | |||
894 | if (m_iscolliding && !m_flying && m_target_velocity.Z > 0.0f) | ||
895 | { | ||
896 | // We're colliding with something and we're not flying but we're moving | ||
897 | // This means we're walking or running. | ||
898 | PhysicsVector pos = new PhysicsVector(tempVector1.getX(), tempVector1.getY(), tempVector1.getZ()); | ||
899 | vec.Z = (m_target_velocity.Z - vel.Z) * PID_D + (m_zeroPosition.Z - pos.Z) * PID_P; | ||
900 | if (m_target_velocity.X > 0) | ||
901 | { | ||
902 | vec.X = ((m_target_velocity.X - vel.X) / 1.2f) * PID_D; | ||
903 | } | ||
904 | if (m_target_velocity.Y > 0) | ||
905 | { | ||
906 | vec.Y = ((m_target_velocity.Y - vel.Y) / 1.2f) * PID_D; | ||
907 | } | ||
908 | } | ||
909 | else if (!m_iscolliding && !m_flying) | ||
910 | { | ||
911 | // we're not colliding and we're not flying so that means we're falling! | ||
912 | // m_iscolliding includes collisions with the ground. | ||
913 | |||
914 | // d.Vector3 pos = d.BodyGetPosition(Body); | ||
915 | if (m_target_velocity.X > 0) | ||
916 | { | ||
917 | vec.X = ((m_target_velocity.X - vel.X) / 1.2f) * PID_D; | ||
918 | } | ||
919 | if (m_target_velocity.Y > 0) | ||
920 | { | ||
921 | vec.Y = ((m_target_velocity.Y - vel.Y) / 1.2f) * PID_D; | ||
922 | } | ||
923 | } | ||
924 | |||
925 | |||
926 | if (m_flying) | ||
927 | { | ||
928 | vec.Z = (m_target_velocity.Z - vel.Z) * (PID_D); | ||
929 | } | ||
930 | } | ||
931 | if (m_flying) | ||
932 | { | ||
933 | //vec.Z += ((-1 * m_parent_scene.gravityz) * m_mass); | ||
934 | } | ||
935 | if (Body != null && (((m_target_velocity.X > 0.2f || m_target_velocity.X < -0.2f) || (m_target_velocity.Y > 0.2f || m_target_velocity.Y < -0.2f)))) | ||
936 | { | ||
937 | Body.setFriction(0.001f); | ||
938 | //m_log.DebugFormat("[PHYSICS]: Avatar force applied: {0}, Target:{1}", vec.ToString(), m_target_velocity.ToString()); | ||
939 | } | ||
940 | |||
941 | if (Body != null) | ||
942 | { | ||
943 | int activationstate = Body.getActivationState(); | ||
944 | if (activationstate == 0) | ||
945 | { | ||
946 | Body.forceActivationState(1); | ||
947 | } | ||
948 | |||
949 | |||
950 | } | ||
951 | doImpulse(vec, true); | ||
952 | } | ||
953 | |||
954 | /// <summary> | ||
955 | /// Updates the reported position and velocity. This essentially sends the data up to ScenePresence. | ||
956 | /// </summary> | ||
957 | public void UpdatePositionAndVelocity() | ||
958 | { | ||
959 | if (Body == null) | ||
960 | return; | ||
961 | //int val = Environment.TickCount; | ||
962 | CheckIfStandingOnObject(); | ||
963 | //m_log.DebugFormat("time:{0}", Environment.TickCount - val); | ||
964 | |||
965 | //IsColliding = Body.checkCollideWith(m_parent_scene.TerrainBody); | ||
966 | |||
967 | tempTrans1.Dispose(); | ||
968 | tempTrans1 = Body.getInterpolationWorldTransform(); | ||
969 | tempVector1.Dispose(); | ||
970 | tempVector1 = tempTrans1.getOrigin(); | ||
971 | tempVector2.Dispose(); | ||
972 | tempVector2 = Body.getInterpolationLinearVelocity(); | ||
973 | |||
974 | // no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit! | ||
975 | PhysicsVector vec = new PhysicsVector(tempVector1.getX(),tempVector1.getY(),tempVector1.getZ()); | ||
976 | |||
977 | // kluge to keep things in bounds. ODE lets dead avatars drift away (they should be removed!) | ||
978 | if (vec.X < 0.0f) vec.X = 0.0f; | ||
979 | if (vec.Y < 0.0f) vec.Y = 0.0f; | ||
980 | if (vec.X > (int)Constants.RegionSize - 0.2f) vec.X = (int)Constants.RegionSize - 0.2f; | ||
981 | if (vec.Y > (int)Constants.RegionSize - 0.2f) vec.Y = (int)Constants.RegionSize - 0.2f; | ||
982 | |||
983 | m_position.X = vec.X; | ||
984 | m_position.Y = vec.Y; | ||
985 | m_position.Z = vec.Z; | ||
986 | |||
987 | // Did we move last? = zeroflag | ||
988 | // This helps keep us from sliding all over | ||
989 | |||
990 | if (m_zeroFlag) | ||
991 | { | ||
992 | m_velocity.X = 0.0f; | ||
993 | m_velocity.Y = 0.0f; | ||
994 | m_velocity.Z = 0.0f; | ||
995 | |||
996 | // Did we send out the 'stopped' message? | ||
997 | if (!m_lastUpdateSent) | ||
998 | { | ||
999 | m_lastUpdateSent = true; | ||
1000 | //base.RequestPhysicsterseUpdate(); | ||
1001 | |||
1002 | } | ||
1003 | } | ||
1004 | else | ||
1005 | { | ||
1006 | m_lastUpdateSent = false; | ||
1007 | vec = new PhysicsVector(tempVector2.getX(), tempVector2.getY(), tempVector2.getZ()); | ||
1008 | m_velocity.X = (vec.X); | ||
1009 | m_velocity.Y = (vec.Y); | ||
1010 | |||
1011 | m_velocity.Z = (vec.Z); | ||
1012 | |||
1013 | if (m_velocity.Z < -6 && !m_hackSentFall) | ||
1014 | { | ||
1015 | m_hackSentFall = true; | ||
1016 | m_pidControllerActive = false; | ||
1017 | } | ||
1018 | else if (m_flying && !m_hackSentFly) | ||
1019 | { | ||
1020 | //m_hackSentFly = true; | ||
1021 | //base.SendCollisionUpdate(new CollisionEventUpdate()); | ||
1022 | } | ||
1023 | else | ||
1024 | { | ||
1025 | m_hackSentFly = false; | ||
1026 | m_hackSentFall = false; | ||
1027 | } | ||
1028 | } | ||
1029 | if (Body != null) | ||
1030 | { | ||
1031 | if (Body.getFriction() < 0.9f) | ||
1032 | Body.setFriction(0.9f); | ||
1033 | } | ||
1034 | //if (Body != null) | ||
1035 | // Body.clearForces(); | ||
1036 | } | ||
1037 | |||
1038 | public void CheckIfStandingOnObject() | ||
1039 | { | ||
1040 | |||
1041 | float capsuleHalfHeight = ((CAPSULE_LENGTH + 2*CAPSULE_RADIUS)*0.5f); | ||
1042 | |||
1043 | tempVector5RayCast.setValue(m_position.X, m_position.Y, m_position.Z); | ||
1044 | tempVector6RayCast.setValue(m_position.X, m_position.Y, m_position.Z - 1 * capsuleHalfHeight * 1.1f); | ||
1045 | |||
1046 | |||
1047 | ClosestCastResult.Dispose(); | ||
1048 | ClosestCastResult = new ClosestNotMeRayResultCallback(Body); | ||
1049 | |||
1050 | try | ||
1051 | { | ||
1052 | m_parent_scene.getBulletWorld().rayTest(tempVector5RayCast, tempVector6RayCast, ClosestCastResult); | ||
1053 | } | ||
1054 | catch (AccessViolationException) | ||
1055 | { | ||
1056 | m_log.Debug("BAD!"); | ||
1057 | } | ||
1058 | if (ClosestCastResult.hasHit()) | ||
1059 | { | ||
1060 | |||
1061 | if (tempVector7RayCast != null) | ||
1062 | tempVector7RayCast.Dispose(); | ||
1063 | |||
1064 | //tempVector7RayCast = ClosestCastResult.getHitPointWorld(); | ||
1065 | |||
1066 | /*if (tempVector7RayCast == null) // null == no result also | ||
1067 | { | ||
1068 | CollidingObj = false; | ||
1069 | IsColliding = false; | ||
1070 | CollidingGround = false; | ||
1071 | |||
1072 | return; | ||
1073 | } | ||
1074 | float zVal = tempVector7RayCast.getZ(); | ||
1075 | if (zVal != 0) | ||
1076 | m_log.Debug("[PHYSICS]: HAAAA"); | ||
1077 | if (zVal < m_position.Z && zVal > ((CAPSULE_LENGTH + 2 * CAPSULE_RADIUS) *0.5f)) | ||
1078 | { | ||
1079 | CollidingObj = true; | ||
1080 | IsColliding = true; | ||
1081 | } | ||
1082 | else | ||
1083 | { | ||
1084 | CollidingObj = false; | ||
1085 | IsColliding = false; | ||
1086 | CollidingGround = false; | ||
1087 | }*/ | ||
1088 | |||
1089 | //height+2*radius = capsule full length | ||
1090 | //CollidingObj = true; | ||
1091 | //IsColliding = true; | ||
1092 | m_iscolliding = true; | ||
1093 | } | ||
1094 | else | ||
1095 | { | ||
1096 | //CollidingObj = false; | ||
1097 | //IsColliding = false; | ||
1098 | //CollidingGround = false; | ||
1099 | m_iscolliding = false; | ||
1100 | } | ||
1101 | } | ||
1102 | } | ||
1103 | |||
1104 | } | ||
diff --git a/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPlugin.cs b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPlugin.cs new file mode 100644 index 0000000..262e5c3 --- /dev/null +++ b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPlugin.cs | |||
@@ -0,0 +1,65 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using OpenSim.Region.Physics.Manager; | ||
29 | |||
30 | namespace OpenSim.Region.Physics.BulletDotNETPlugin | ||
31 | { | ||
32 | public class BulletDotNetPlugin : IPhysicsPlugin | ||
33 | { | ||
34 | private BulletDotNETScene m_scene; | ||
35 | private const string m_pluginName = "BulletDotNETPlugin"; | ||
36 | |||
37 | #region IPhysicsPlugin Members | ||
38 | |||
39 | public bool Init() | ||
40 | { | ||
41 | return true; | ||
42 | } | ||
43 | |||
44 | public PhysicsScene GetScene(string sceneIdentifier) | ||
45 | { | ||
46 | if (m_scene == null) | ||
47 | { | ||
48 | m_scene = new BulletDotNETScene(sceneIdentifier); | ||
49 | } | ||
50 | return m_scene; | ||
51 | } | ||
52 | |||
53 | public string GetName() | ||
54 | { | ||
55 | return m_pluginName; | ||
56 | } | ||
57 | |||
58 | public void Dispose() | ||
59 | { | ||
60 | |||
61 | } | ||
62 | |||
63 | #endregion | ||
64 | } | ||
65 | } \ No newline at end of file | ||
diff --git a/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPluginStructs.cs b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPluginStructs.cs new file mode 100644 index 0000000..382f445 --- /dev/null +++ b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPluginStructs.cs | |||
@@ -0,0 +1,33 @@ | |||
1 | using System; | ||
2 | |||
3 | public enum StatusIndicators : int | ||
4 | { | ||
5 | Generic = 0, | ||
6 | Start = 1, | ||
7 | End = 2 | ||
8 | } | ||
9 | |||
10 | public struct sCollisionData | ||
11 | { | ||
12 | public uint ColliderLocalId; | ||
13 | public uint CollidedWithLocalId; | ||
14 | public int NumberOfCollisions; | ||
15 | public int CollisionType; | ||
16 | public int StatusIndicator; | ||
17 | public int lastframe; | ||
18 | } | ||
19 | |||
20 | [Flags] | ||
21 | public enum CollisionCategories : int | ||
22 | { | ||
23 | Disabled = 0, | ||
24 | Geom = 0x00000001, | ||
25 | Body = 0x00000002, | ||
26 | Space = 0x00000004, | ||
27 | Character = 0x00000008, | ||
28 | Land = 0x00000010, | ||
29 | Water = 0x00000020, | ||
30 | Wind = 0x00000040, | ||
31 | Sensor = 0x00000080, | ||
32 | Selected = 0x00000100 | ||
33 | } \ No newline at end of file | ||
diff --git a/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPrim.cs b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPrim.cs new file mode 100644 index 0000000..3e26456 --- /dev/null +++ b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETPrim.cs | |||
@@ -0,0 +1,2131 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSim Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | using System; | ||
28 | using System.Collections.Generic; | ||
29 | using System.Reflection; | ||
30 | using System.Runtime.InteropServices; | ||
31 | using System.Threading; | ||
32 | using log4net; | ||
33 | using OpenMetaverse; | ||
34 | using BulletDotNET; | ||
35 | using OpenSim.Framework; | ||
36 | using OpenSim.Region.Physics.Manager; | ||
37 | |||
38 | namespace OpenSim.Region.Physics.BulletDotNETPlugin | ||
39 | { | ||
40 | public class BulletDotNETPrim : PhysicsActor | ||
41 | { | ||
42 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
43 | |||
44 | private PhysicsVector _position; | ||
45 | private PhysicsVector _velocity; | ||
46 | private PhysicsVector _torque = new PhysicsVector(0, 0, 0); | ||
47 | private PhysicsVector m_lastVelocity = new PhysicsVector(0.0f, 0.0f, 0.0f); | ||
48 | private PhysicsVector m_lastposition = new PhysicsVector(0.0f, 0.0f, 0.0f); | ||
49 | private Quaternion m_lastorientation = new Quaternion(); | ||
50 | private PhysicsVector m_rotationalVelocity; | ||
51 | private PhysicsVector _size; | ||
52 | private PhysicsVector _acceleration; | ||
53 | // private d.Vector3 _zeroPosition = new d.Vector3(0.0f, 0.0f, 0.0f); | ||
54 | private Quaternion _orientation; | ||
55 | private PhysicsVector m_taintposition; | ||
56 | private PhysicsVector m_taintsize; | ||
57 | private PhysicsVector m_taintVelocity = new PhysicsVector(0, 0, 0); | ||
58 | private PhysicsVector m_taintTorque = new PhysicsVector(0, 0, 0); | ||
59 | private Quaternion m_taintrot; | ||
60 | private PhysicsVector m_angularlock = new PhysicsVector(1f, 1f, 1f); | ||
61 | private PhysicsVector m_taintAngularLock = new PhysicsVector(1f, 1f, 1f); | ||
62 | private btGeneric6DofConstraint Amotor; | ||
63 | |||
64 | private PhysicsVector m_PIDTarget = new PhysicsVector(0, 0, 0); | ||
65 | private float m_PIDTau = 0f; | ||
66 | private float m_PIDHoverHeight = 0f; | ||
67 | private float m_PIDHoverTau = 0f; | ||
68 | private bool m_useHoverPID = false; | ||
69 | private PIDHoverType m_PIDHoverType = PIDHoverType.Ground; | ||
70 | private float m_targetHoverHeight = 0f; | ||
71 | private float m_groundHeight = 0f; | ||
72 | private float m_waterHeight = 0f; | ||
73 | private float PID_D = 35f; | ||
74 | private float PID_G = 25f; | ||
75 | private float m_tensor = 5f; | ||
76 | private int body_autodisable_frames = 20; | ||
77 | private IMesh primMesh = null; | ||
78 | |||
79 | private bool m_usePID = false; | ||
80 | |||
81 | |||
82 | private const CollisionCategories m_default_collisionFlags = (CollisionCategories.Geom | ||
83 | | CollisionCategories.Space | ||
84 | | CollisionCategories.Body | ||
85 | | CollisionCategories.Character | ||
86 | ); | ||
87 | |||
88 | private bool m_taintshape = false; | ||
89 | private bool m_taintPhysics = false; | ||
90 | private bool m_collidesLand = true; | ||
91 | private bool m_collidesWater = false; | ||
92 | public bool m_returnCollisions = false; | ||
93 | |||
94 | // Default we're a Geometry | ||
95 | private CollisionCategories m_collisionCategories = (CollisionCategories.Geom); | ||
96 | |||
97 | // Default, Collide with Other Geometries, spaces and Bodies | ||
98 | private CollisionCategories m_collisionFlags = m_default_collisionFlags; | ||
99 | |||
100 | public bool m_taintremove = false; | ||
101 | public bool m_taintdisable = false; | ||
102 | public bool m_disabled = false; | ||
103 | public bool m_taintadd = false; | ||
104 | public bool m_taintselected = false; | ||
105 | public bool m_taintCollidesWater = false; | ||
106 | |||
107 | public uint m_localID = 0; | ||
108 | |||
109 | //public GCHandle gc; | ||
110 | private CollisionLocker ode; | ||
111 | |||
112 | private bool m_taintforce = false; | ||
113 | private bool m_taintaddangularforce = false; | ||
114 | private PhysicsVector m_force = new PhysicsVector(0.0f, 0.0f, 0.0f); | ||
115 | private List<PhysicsVector> m_forcelist = new List<PhysicsVector>(); | ||
116 | private List<PhysicsVector> m_angularforcelist = new List<PhysicsVector>(); | ||
117 | |||
118 | private IMesh _mesh; | ||
119 | private PrimitiveBaseShape _pbs; | ||
120 | private BulletDotNETScene _parent_scene; | ||
121 | public btCollisionShape prim_geom; | ||
122 | public IntPtr _triMeshData; | ||
123 | |||
124 | private PhysicsActor _parent = null; | ||
125 | private PhysicsActor m_taintparent = null; | ||
126 | |||
127 | private List<BulletDotNETPrim> childrenPrim = new List<BulletDotNETPrim>(); | ||
128 | |||
129 | private bool iscolliding = false; | ||
130 | private bool m_isphysical = false; | ||
131 | private bool m_isSelected = false; | ||
132 | |||
133 | internal bool m_isVolumeDetect = false; // If true, this prim only detects collisions but doesn't collide actively | ||
134 | |||
135 | private bool m_throttleUpdates = false; | ||
136 | private int throttleCounter = 0; | ||
137 | public int m_interpenetrationcount = 0; | ||
138 | public float m_collisionscore = 0; | ||
139 | public int m_roundsUnderMotionThreshold = 0; | ||
140 | private int m_crossingfailures = 0; | ||
141 | |||
142 | public float m_buoyancy = 0f; | ||
143 | |||
144 | public bool outofBounds = false; | ||
145 | private float m_density = 10.000006836f; // Aluminum g/cm3; | ||
146 | |||
147 | public bool _zeroFlag = false; | ||
148 | private bool m_lastUpdateSent = false; | ||
149 | |||
150 | |||
151 | private String m_primName; | ||
152 | private PhysicsVector _target_velocity; | ||
153 | |||
154 | public int m_eventsubscription = 0; | ||
155 | private CollisionEventUpdate CollisionEventsThisFrame = null; | ||
156 | |||
157 | public volatile bool childPrim = false; | ||
158 | |||
159 | private btVector3 tempPosition1; | ||
160 | private btVector3 tempPosition2; | ||
161 | private btVector3 tempPosition3; | ||
162 | private btVector3 tempSize1; | ||
163 | private btVector3 tempSize2; | ||
164 | private btVector3 tempLinearVelocity1; | ||
165 | private btVector3 tempLinearVelocity2; | ||
166 | private btVector3 tempAngularVelocity1; | ||
167 | private btVector3 tempAngularVelocity2; | ||
168 | private btVector3 tempInertia1; | ||
169 | private btVector3 tempInertia2; | ||
170 | private btQuaternion tempOrientation1; | ||
171 | private btQuaternion tempOrientation2; | ||
172 | private btMotionState tempMotionState1; | ||
173 | private btMotionState tempMotionState2; | ||
174 | private btMotionState tempMotionState3; | ||
175 | private btTransform tempTransform1; | ||
176 | private btTransform tempTransform2; | ||
177 | private btTransform tempTransform3; | ||
178 | private btTransform tempTransform4; | ||
179 | private btTriangleIndexVertexArray btshapeArray; | ||
180 | |||
181 | public btRigidBody Body; | ||
182 | |||
183 | public BulletDotNETPrim(String primName, BulletDotNETScene parent_scene, PhysicsVector pos, PhysicsVector size, | ||
184 | Quaternion rotation, IMesh mesh, PrimitiveBaseShape pbs, bool pisPhysical) | ||
185 | { | ||
186 | tempPosition1 = new btVector3(0, 0, 0); | ||
187 | tempPosition2 = new btVector3(0, 0, 0); | ||
188 | tempPosition3 = new btVector3(0, 0, 0); | ||
189 | tempSize1 = new btVector3(0, 0, 0); | ||
190 | tempSize2 = new btVector3(0, 0, 0); | ||
191 | tempLinearVelocity1 = new btVector3(0, 0, 0); | ||
192 | tempLinearVelocity2 = new btVector3(0, 0, 0); | ||
193 | tempAngularVelocity1 = new btVector3(0, 0, 0); | ||
194 | tempAngularVelocity2 = new btVector3(0, 0, 0); | ||
195 | tempInertia1 = new btVector3(0, 0, 0); | ||
196 | tempInertia2 = new btVector3(0, 0, 0); | ||
197 | tempOrientation1 = new btQuaternion(0,0,0,1); | ||
198 | tempOrientation2 = new btQuaternion(0, 0, 0, 1); | ||
199 | _parent_scene = parent_scene; | ||
200 | tempTransform1 = new btTransform(_parent_scene.QuatIdentity, _parent_scene.VectorZero); | ||
201 | tempTransform2 = new btTransform(_parent_scene.QuatIdentity, _parent_scene.VectorZero); ; | ||
202 | tempTransform3 = new btTransform(_parent_scene.QuatIdentity, _parent_scene.VectorZero); ; | ||
203 | tempTransform4 = new btTransform(_parent_scene.QuatIdentity, _parent_scene.VectorZero); ; | ||
204 | |||
205 | tempMotionState1 = new btDefaultMotionState(_parent_scene.TransZero); | ||
206 | tempMotionState2 = new btDefaultMotionState(_parent_scene.TransZero); | ||
207 | tempMotionState3 = new btDefaultMotionState(_parent_scene.TransZero); | ||
208 | |||
209 | _target_velocity = new PhysicsVector(0, 0, 0); | ||
210 | _velocity = new PhysicsVector(); | ||
211 | _position = pos; | ||
212 | m_taintposition = pos; | ||
213 | PID_D = parent_scene.bodyPIDD; | ||
214 | PID_G = parent_scene.bodyPIDG; | ||
215 | m_density = parent_scene.geomDefaultDensity; | ||
216 | m_tensor = parent_scene.bodyMotorJointMaxforceTensor; | ||
217 | body_autodisable_frames = parent_scene.bodyFramesAutoDisable; | ||
218 | |||
219 | prim_geom = null; | ||
220 | Body = null; | ||
221 | |||
222 | if (size.X <= 0) size.X = 0.01f; | ||
223 | if (size.Y <= 0) size.Y = 0.01f; | ||
224 | if (size.Z <= 0) size.Z = 0.01f; | ||
225 | |||
226 | _size = size; | ||
227 | m_taintsize = _size; | ||
228 | _acceleration = new PhysicsVector(); | ||
229 | m_rotationalVelocity = PhysicsVector.Zero; | ||
230 | _orientation = rotation; | ||
231 | m_taintrot = _orientation; | ||
232 | _mesh = mesh; | ||
233 | _pbs = pbs; | ||
234 | |||
235 | _parent_scene = parent_scene; | ||
236 | |||
237 | if (pos.Z < 0) | ||
238 | m_isphysical = false; | ||
239 | else | ||
240 | { | ||
241 | m_isphysical = pisPhysical; | ||
242 | // If we're physical, we need to be in the master space for now. | ||
243 | // linksets *should* be in a space together.. but are not currently | ||
244 | } | ||
245 | m_primName = primName; | ||
246 | m_taintadd = true; | ||
247 | _parent_scene.AddPhysicsActorTaint(this); | ||
248 | |||
249 | } | ||
250 | |||
251 | #region PhysicsActor overrides | ||
252 | |||
253 | public override bool Stopped | ||
254 | { | ||
255 | get { return _zeroFlag; } | ||
256 | } | ||
257 | |||
258 | public override PhysicsVector Size | ||
259 | { | ||
260 | get { return _size; } | ||
261 | set { _size = value; } | ||
262 | } | ||
263 | |||
264 | public override PrimitiveBaseShape Shape | ||
265 | { | ||
266 | set | ||
267 | { | ||
268 | _pbs = value; | ||
269 | m_taintshape = true; | ||
270 | } | ||
271 | } | ||
272 | |||
273 | public override uint LocalID | ||
274 | { | ||
275 | set | ||
276 | { | ||
277 | //m_log.Info("[PHYSICS]: Setting TrackerID: " + value); | ||
278 | m_localID = value; | ||
279 | } | ||
280 | } | ||
281 | |||
282 | public override bool Grabbed | ||
283 | { | ||
284 | set { return; } | ||
285 | } | ||
286 | |||
287 | public override bool Selected | ||
288 | { | ||
289 | set | ||
290 | { | ||
291 | // This only makes the object not collidable if the object | ||
292 | // is physical or the object is modified somehow *IN THE FUTURE* | ||
293 | // without this, if an avatar selects prim, they can walk right | ||
294 | // through it while it's selected | ||
295 | m_collisionscore = 0; | ||
296 | if ((m_isphysical && !_zeroFlag) || !value) | ||
297 | { | ||
298 | m_taintselected = value; | ||
299 | _parent_scene.AddPhysicsActorTaint(this); | ||
300 | } | ||
301 | else | ||
302 | { | ||
303 | m_taintselected = value; | ||
304 | m_isSelected = value; | ||
305 | } | ||
306 | } | ||
307 | } | ||
308 | |||
309 | public override void CrossingFailure() | ||
310 | { | ||
311 | m_crossingfailures++; | ||
312 | if (m_crossingfailures > _parent_scene.geomCrossingFailuresBeforeOutofbounds) | ||
313 | { | ||
314 | base.RaiseOutOfBounds(_position); | ||
315 | return; | ||
316 | } | ||
317 | else if (m_crossingfailures == _parent_scene.geomCrossingFailuresBeforeOutofbounds) | ||
318 | { | ||
319 | m_log.Warn("[PHYSICS]: Too many crossing failures for: " + m_primName); | ||
320 | } | ||
321 | } | ||
322 | public override void link(PhysicsActor obj) | ||
323 | { | ||
324 | //TODO: | ||
325 | } | ||
326 | |||
327 | public override void delink() | ||
328 | { | ||
329 | //TODO: | ||
330 | } | ||
331 | |||
332 | public override void LockAngularMotion(PhysicsVector axis) | ||
333 | { | ||
334 | m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z); | ||
335 | m_taintAngularLock = new PhysicsVector(axis.X, axis.Y, axis.Z); | ||
336 | } | ||
337 | |||
338 | public override PhysicsVector Position | ||
339 | { | ||
340 | get { return _position; } | ||
341 | |||
342 | set | ||
343 | { | ||
344 | _position = value; | ||
345 | //m_log.Info("[PHYSICS]: " + _position.ToString()); | ||
346 | } | ||
347 | } | ||
348 | |||
349 | public override float Mass | ||
350 | { | ||
351 | get { return CalculateMass(); } | ||
352 | } | ||
353 | |||
354 | public override PhysicsVector Force | ||
355 | { | ||
356 | //get { return PhysicsVector.Zero; } | ||
357 | get { return m_force; } | ||
358 | set { m_force = value; } | ||
359 | } | ||
360 | |||
361 | public override int VehicleType | ||
362 | { | ||
363 | get { return 0; } | ||
364 | set { return; } | ||
365 | } | ||
366 | |||
367 | public override void VehicleFloatParam(int param, float value) | ||
368 | { | ||
369 | //TODO: | ||
370 | } | ||
371 | |||
372 | public override void VehicleVectorParam(int param, PhysicsVector value) | ||
373 | { | ||
374 | //TODO: | ||
375 | } | ||
376 | |||
377 | public override void VehicleRotationParam(int param, Quaternion rotation) | ||
378 | { | ||
379 | //TODO: | ||
380 | } | ||
381 | |||
382 | public override void SetVolumeDetect(int param) | ||
383 | { | ||
384 | //TODO: GhostObject | ||
385 | m_isVolumeDetect = (param != 0); | ||
386 | |||
387 | } | ||
388 | |||
389 | public override PhysicsVector GeometricCenter | ||
390 | { | ||
391 | get { return PhysicsVector.Zero; } | ||
392 | } | ||
393 | |||
394 | public override PhysicsVector CenterOfMass | ||
395 | { | ||
396 | get { return PhysicsVector.Zero; } | ||
397 | } | ||
398 | |||
399 | public override PhysicsVector Velocity | ||
400 | { | ||
401 | get | ||
402 | { | ||
403 | // Averate previous velocity with the new one so | ||
404 | // client object interpolation works a 'little' better | ||
405 | PhysicsVector returnVelocity = new PhysicsVector(); | ||
406 | returnVelocity.X = (m_lastVelocity.X + _velocity.X) / 2; | ||
407 | returnVelocity.Y = (m_lastVelocity.Y + _velocity.Y) / 2; | ||
408 | returnVelocity.Z = (m_lastVelocity.Z + _velocity.Z) / 2; | ||
409 | return returnVelocity; | ||
410 | } | ||
411 | set | ||
412 | { | ||
413 | _velocity = value; | ||
414 | |||
415 | m_taintVelocity = value; | ||
416 | _parent_scene.AddPhysicsActorTaint(this); | ||
417 | } | ||
418 | } | ||
419 | |||
420 | public override PhysicsVector Torque | ||
421 | { | ||
422 | get | ||
423 | { | ||
424 | if (!m_isphysical || Body.Handle == IntPtr.Zero) | ||
425 | return new PhysicsVector(0, 0, 0); | ||
426 | |||
427 | return _torque; | ||
428 | } | ||
429 | |||
430 | set | ||
431 | { | ||
432 | m_taintTorque = value; | ||
433 | _parent_scene.AddPhysicsActorTaint(this); | ||
434 | } | ||
435 | } | ||
436 | |||
437 | public override float CollisionScore | ||
438 | { | ||
439 | get { return m_collisionscore; } | ||
440 | set { m_collisionscore = value; } | ||
441 | } | ||
442 | |||
443 | public override PhysicsVector Acceleration | ||
444 | { | ||
445 | get { return _acceleration; } | ||
446 | } | ||
447 | |||
448 | public override Quaternion Orientation | ||
449 | { | ||
450 | get { return _orientation; } | ||
451 | set { _orientation = value; } | ||
452 | } | ||
453 | |||
454 | public override int PhysicsActorType | ||
455 | { | ||
456 | get { return (int)ActorTypes.Prim; } | ||
457 | set { return; } | ||
458 | } | ||
459 | |||
460 | public override bool IsPhysical | ||
461 | { | ||
462 | get { return m_isphysical; } | ||
463 | set { m_isphysical = value; } | ||
464 | } | ||
465 | |||
466 | public override bool Flying | ||
467 | { | ||
468 | // no flying prims for you | ||
469 | get { return false; } | ||
470 | set { } | ||
471 | } | ||
472 | |||
473 | public override bool SetAlwaysRun | ||
474 | { | ||
475 | get { return false; } | ||
476 | set { return; } | ||
477 | } | ||
478 | |||
479 | public override bool ThrottleUpdates | ||
480 | { | ||
481 | get { return m_throttleUpdates; } | ||
482 | set { m_throttleUpdates = value; } | ||
483 | } | ||
484 | |||
485 | public override bool IsColliding | ||
486 | { | ||
487 | get { return iscolliding; } | ||
488 | set { iscolliding = value; } | ||
489 | } | ||
490 | |||
491 | public override bool CollidingGround | ||
492 | { | ||
493 | get { return false; } | ||
494 | set { return; } | ||
495 | } | ||
496 | |||
497 | public override bool CollidingObj | ||
498 | { | ||
499 | get { return false; } | ||
500 | set { return; } | ||
501 | } | ||
502 | |||
503 | public override bool FloatOnWater | ||
504 | { | ||
505 | set | ||
506 | { | ||
507 | m_taintCollidesWater = value; | ||
508 | _parent_scene.AddPhysicsActorTaint(this); | ||
509 | } | ||
510 | } | ||
511 | |||
512 | public override PhysicsVector RotationalVelocity | ||
513 | { | ||
514 | get | ||
515 | { | ||
516 | PhysicsVector pv = new PhysicsVector(0, 0, 0); | ||
517 | if (_zeroFlag) | ||
518 | return pv; | ||
519 | m_lastUpdateSent = false; | ||
520 | |||
521 | if (m_rotationalVelocity.IsIdentical(pv, 0.2f)) | ||
522 | return pv; | ||
523 | |||
524 | return m_rotationalVelocity; | ||
525 | } | ||
526 | set { m_rotationalVelocity = value; } | ||
527 | } | ||
528 | |||
529 | public override bool Kinematic | ||
530 | { | ||
531 | get { return false; } | ||
532 | set { } | ||
533 | } | ||
534 | |||
535 | public override float Buoyancy | ||
536 | { | ||
537 | get { return m_buoyancy; } | ||
538 | set { m_buoyancy = value; } | ||
539 | } | ||
540 | |||
541 | public override PhysicsVector PIDTarget { set { m_PIDTarget = value; ; } } | ||
542 | public override bool PIDActive { set { m_usePID = value; } } | ||
543 | public override float PIDTau { set { m_PIDTau = value; } } | ||
544 | |||
545 | public override float PIDHoverHeight { set { m_PIDHoverHeight = value; ; } } | ||
546 | public override bool PIDHoverActive { set { m_useHoverPID = value; } } | ||
547 | public override PIDHoverType PIDHoverType { set { m_PIDHoverType = value; } } | ||
548 | public override float PIDHoverTau { set { m_PIDHoverTau = value; } } | ||
549 | |||
550 | |||
551 | public override void AddForce(PhysicsVector force, bool pushforce) | ||
552 | { | ||
553 | m_forcelist.Add(force); | ||
554 | m_taintforce = true; | ||
555 | //m_log.Info("[PHYSICS]: Added Force:" + force.ToString() + " to prim at " + Position.ToString()); | ||
556 | } | ||
557 | |||
558 | public override void AddAngularForce(PhysicsVector force, bool pushforce) | ||
559 | { | ||
560 | m_angularforcelist.Add(force); | ||
561 | m_taintaddangularforce = true; | ||
562 | } | ||
563 | |||
564 | public override void SetMomentum(PhysicsVector momentum) | ||
565 | { | ||
566 | } | ||
567 | |||
568 | public override void SubscribeEvents(int ms) | ||
569 | { | ||
570 | m_eventsubscription = ms; | ||
571 | _parent_scene.addCollisionEventReporting(this); | ||
572 | } | ||
573 | |||
574 | public override void UnSubscribeEvents() | ||
575 | { | ||
576 | _parent_scene.remCollisionEventReporting(this); | ||
577 | m_eventsubscription = 0; | ||
578 | } | ||
579 | |||
580 | public override bool SubscribedEvents() | ||
581 | { | ||
582 | return (m_eventsubscription > 0); | ||
583 | } | ||
584 | |||
585 | #endregion | ||
586 | |||
587 | |||
588 | |||
589 | internal void Dispose() | ||
590 | { | ||
591 | //TODO: | ||
592 | DisposeOfBody(); | ||
593 | SetCollisionShape(null); | ||
594 | |||
595 | if (tempMotionState3 != null && tempMotionState3.Handle != IntPtr.Zero) | ||
596 | { | ||
597 | tempMotionState3.Dispose(); | ||
598 | tempMotionState3 = null; | ||
599 | } | ||
600 | |||
601 | if (tempMotionState2 != null && tempMotionState2.Handle != IntPtr.Zero) | ||
602 | { | ||
603 | tempMotionState2.Dispose(); | ||
604 | tempMotionState2 = null; | ||
605 | } | ||
606 | |||
607 | if (tempMotionState1 != null && tempMotionState1.Handle != IntPtr.Zero) | ||
608 | { | ||
609 | tempMotionState1.Dispose(); | ||
610 | tempMotionState1 = null; | ||
611 | } | ||
612 | |||
613 | if (tempTransform4 != null && tempTransform4.Handle != IntPtr.Zero) | ||
614 | { | ||
615 | tempTransform4.Dispose(); | ||
616 | tempTransform4 = null; | ||
617 | } | ||
618 | |||
619 | if (tempTransform3 != null && tempTransform3.Handle != IntPtr.Zero) | ||
620 | { | ||
621 | tempTransform3.Dispose(); | ||
622 | tempTransform3 = null; | ||
623 | } | ||
624 | |||
625 | if (tempTransform2 != null && tempTransform2.Handle != IntPtr.Zero) | ||
626 | { | ||
627 | tempTransform2.Dispose(); | ||
628 | tempTransform2 = null; | ||
629 | } | ||
630 | |||
631 | if (tempTransform1 != null && tempTransform1.Handle != IntPtr.Zero) | ||
632 | { | ||
633 | tempTransform1.Dispose(); | ||
634 | tempTransform1 = null; | ||
635 | } | ||
636 | |||
637 | if (tempOrientation2 != null && tempOrientation2.Handle != IntPtr.Zero) | ||
638 | { | ||
639 | tempOrientation2.Dispose(); | ||
640 | tempOrientation2 = null; | ||
641 | } | ||
642 | |||
643 | if (tempOrientation1 != null && tempOrientation1.Handle != IntPtr.Zero) | ||
644 | { | ||
645 | tempOrientation1.Dispose(); | ||
646 | tempOrientation1 = null; | ||
647 | } | ||
648 | |||
649 | if (tempInertia1 != null && tempInertia1.Handle != IntPtr.Zero) | ||
650 | { | ||
651 | tempInertia1.Dispose(); | ||
652 | tempInertia1 = null; | ||
653 | } | ||
654 | |||
655 | if (tempInertia2 != null && tempInertia2.Handle != IntPtr.Zero) | ||
656 | { | ||
657 | tempInertia2.Dispose(); | ||
658 | tempInertia1 = null; | ||
659 | } | ||
660 | |||
661 | |||
662 | if (tempAngularVelocity2 != null && tempAngularVelocity2.Handle != IntPtr.Zero) | ||
663 | { | ||
664 | tempAngularVelocity2.Dispose(); | ||
665 | tempAngularVelocity2 = null; | ||
666 | } | ||
667 | |||
668 | if (tempAngularVelocity1 != null && tempAngularVelocity1.Handle != IntPtr.Zero) | ||
669 | { | ||
670 | tempAngularVelocity1.Dispose(); | ||
671 | tempAngularVelocity1 = null; | ||
672 | } | ||
673 | |||
674 | if (tempLinearVelocity2 != null && tempLinearVelocity2.Handle != IntPtr.Zero) | ||
675 | { | ||
676 | tempLinearVelocity2.Dispose(); | ||
677 | tempLinearVelocity2 = null; | ||
678 | } | ||
679 | |||
680 | if (tempLinearVelocity1 != null && tempLinearVelocity1.Handle != IntPtr.Zero) | ||
681 | { | ||
682 | tempLinearVelocity1.Dispose(); | ||
683 | tempLinearVelocity1 = null; | ||
684 | } | ||
685 | |||
686 | if (tempSize2 != null && tempSize2.Handle != IntPtr.Zero) | ||
687 | { | ||
688 | tempSize2.Dispose(); | ||
689 | tempSize2 = null; | ||
690 | } | ||
691 | |||
692 | if (tempSize1 != null && tempSize1.Handle != IntPtr.Zero) | ||
693 | { | ||
694 | tempSize1.Dispose(); | ||
695 | tempSize1 = null; | ||
696 | } | ||
697 | |||
698 | if (tempPosition3 != null && tempPosition3.Handle != IntPtr.Zero) | ||
699 | { | ||
700 | tempPosition3.Dispose(); | ||
701 | tempPosition3 = null; | ||
702 | } | ||
703 | |||
704 | if (tempPosition2 != null && tempPosition2.Handle != IntPtr.Zero) | ||
705 | { | ||
706 | tempPosition2.Dispose(); | ||
707 | tempPosition2 = null; | ||
708 | } | ||
709 | |||
710 | if (tempPosition1 != null && tempPosition1.Handle != IntPtr.Zero) | ||
711 | { | ||
712 | tempPosition1.Dispose(); | ||
713 | tempPosition1 = null; | ||
714 | } | ||
715 | |||
716 | } | ||
717 | |||
718 | |||
719 | |||
720 | public void ProcessTaints(float timestep) | ||
721 | { | ||
722 | if (m_taintadd) | ||
723 | { | ||
724 | changeadd(timestep); | ||
725 | } | ||
726 | |||
727 | if (prim_geom.Handle == IntPtr.Zero) | ||
728 | { | ||
729 | CreateGeom(IntPtr.Zero, primMesh); | ||
730 | |||
731 | if (IsPhysical) | ||
732 | SetBody(Mass); | ||
733 | else | ||
734 | SetBody(0); | ||
735 | |||
736 | } | ||
737 | |||
738 | if (!_position.IsIdentical(m_taintposition, 0f)) | ||
739 | changemove(timestep); | ||
740 | |||
741 | if (m_taintrot != _orientation) | ||
742 | rotate(timestep); | ||
743 | // | ||
744 | |||
745 | if (m_taintPhysics != m_isphysical && !(m_taintparent != _parent)) | ||
746 | changePhysicsStatus(timestep); | ||
747 | // | ||
748 | |||
749 | if (!_size.IsIdentical(m_taintsize, 0)) | ||
750 | changesize(timestep); | ||
751 | // | ||
752 | |||
753 | if (m_taintshape) | ||
754 | changeshape(timestep); | ||
755 | // | ||
756 | |||
757 | if (m_taintforce) | ||
758 | changeAddForce(timestep); | ||
759 | |||
760 | if (m_taintaddangularforce) | ||
761 | changeAddAngularForce(timestep); | ||
762 | |||
763 | if (!m_taintTorque.IsIdentical(PhysicsVector.Zero, 0.001f)) | ||
764 | changeSetTorque(timestep); | ||
765 | |||
766 | if (m_taintdisable) | ||
767 | changedisable(timestep); | ||
768 | |||
769 | if (m_taintselected != m_isSelected) | ||
770 | changeSelectedStatus(timestep); | ||
771 | |||
772 | if (!m_taintVelocity.IsIdentical(PhysicsVector.Zero, 0.001f)) | ||
773 | changevelocity(timestep); | ||
774 | |||
775 | if (m_taintparent != _parent) | ||
776 | changelink(timestep); | ||
777 | |||
778 | if (m_taintCollidesWater != m_collidesWater) | ||
779 | changefloatonwater(timestep); | ||
780 | |||
781 | if (!m_angularlock.IsIdentical(m_taintAngularLock, 0)) | ||
782 | changeAngularLock(timestep); | ||
783 | |||
784 | |||
785 | } | ||
786 | |||
787 | #region Physics Scene Change Action routines | ||
788 | |||
789 | private void changeadd(float timestep) | ||
790 | { | ||
791 | if (_mesh == null) | ||
792 | { | ||
793 | if (_parent_scene.needsMeshing(_pbs)) | ||
794 | { | ||
795 | // Don't need to re-enable body.. it's done in SetMesh | ||
796 | _mesh = _parent_scene.mesher.CreateMesh(m_primName, _pbs, _size, _parent_scene.meshSculptLOD, IsPhysical); | ||
797 | // createmesh returns null when it's a shape that isn't a cube. | ||
798 | } | ||
799 | } | ||
800 | CreateGeom(IntPtr.Zero, primMesh); | ||
801 | |||
802 | enableBody(); | ||
803 | changeSelectedStatus(timestep); | ||
804 | m_taintadd = false; | ||
805 | |||
806 | } | ||
807 | |||
808 | private void changemove(float timestep) | ||
809 | { | ||
810 | |||
811 | |||
812 | tempTransform2 = Body.getWorldTransform(); | ||
813 | btQuaternion quat = tempTransform2.getRotation(); | ||
814 | tempPosition2.setValue(_position.X, _position.Y, _position.Z); | ||
815 | tempTransform2.Dispose(); | ||
816 | tempTransform2 = new btTransform(quat, tempPosition2); | ||
817 | Body.setWorldTransform(tempTransform2); | ||
818 | |||
819 | changeSelectedStatus(timestep); | ||
820 | |||
821 | resetCollisionAccounting(); | ||
822 | m_taintposition = _position; | ||
823 | } | ||
824 | |||
825 | private void rotate(float timestep) | ||
826 | { | ||
827 | |||
828 | tempTransform2 = Body.getWorldTransform(); | ||
829 | tempOrientation2 = new btQuaternion(_orientation.X, _orientation.Y, _orientation.Z, _orientation.W); | ||
830 | tempTransform2.setRotation(tempOrientation2); | ||
831 | Body.setWorldTransform(tempTransform2); | ||
832 | |||
833 | resetCollisionAccounting(); | ||
834 | m_taintrot = _orientation; | ||
835 | } | ||
836 | |||
837 | private void changePhysicsStatus(float timestep) | ||
838 | { | ||
839 | SetCollisionShape(prim_geom); | ||
840 | SetBody(Mass); | ||
841 | changeSelectedStatus(timestep); | ||
842 | |||
843 | resetCollisionAccounting(); | ||
844 | m_taintPhysics = m_isphysical; | ||
845 | } | ||
846 | |||
847 | private void changesize(float timestep) | ||
848 | { | ||
849 | SetCollisionShape(null); | ||
850 | // Construction of new prim | ||
851 | if (_parent_scene.needsMeshing(_pbs)) | ||
852 | { | ||
853 | float meshlod = _parent_scene.meshSculptLOD; | ||
854 | |||
855 | if (IsPhysical) | ||
856 | meshlod = _parent_scene.MeshSculptphysicalLOD; | ||
857 | // Don't need to re-enable body.. it's done in SetMesh | ||
858 | |||
859 | IMesh mesh = null; | ||
860 | |||
861 | if (_parent_scene.needsMeshing(_pbs)) | ||
862 | mesh = _parent_scene.mesher.CreateMesh(SOPName, _pbs, _size, meshlod, IsPhysical); | ||
863 | |||
864 | //IMesh mesh = _parent_scene.mesher.CreateMesh(oldname, _pbs, _size, meshlod, IsPhysical); | ||
865 | |||
866 | CreateGeom(IntPtr.Zero, mesh); | ||
867 | |||
868 | |||
869 | } | ||
870 | else | ||
871 | { | ||
872 | _mesh = null; | ||
873 | CreateGeom(IntPtr.Zero, _mesh); | ||
874 | } | ||
875 | |||
876 | if (IsPhysical) | ||
877 | SetBody(Mass); | ||
878 | else | ||
879 | SetBody(0); | ||
880 | |||
881 | m_taintsize = _size; | ||
882 | |||
883 | } | ||
884 | |||
885 | private void changeshape(float timestep) | ||
886 | { | ||
887 | // Cleanup of old prim geometry and Bodies | ||
888 | if (IsPhysical && Body != null && Body.Handle != IntPtr.Zero) | ||
889 | { | ||
890 | if (childPrim) | ||
891 | { | ||
892 | if (_parent != null) | ||
893 | { | ||
894 | BulletDotNETPrim parent = (BulletDotNETPrim)_parent; | ||
895 | parent.ChildDelink(this); | ||
896 | } | ||
897 | } | ||
898 | else | ||
899 | { | ||
900 | disableBody(); | ||
901 | } | ||
902 | } | ||
903 | try | ||
904 | { | ||
905 | SetCollisionShape(null); | ||
906 | } | ||
907 | catch (System.AccessViolationException) | ||
908 | { | ||
909 | //prim_geom = IntPtr.Zero; | ||
910 | m_log.Error("[PHYSICS]: PrimGeom dead"); | ||
911 | } | ||
912 | |||
913 | // we don't need to do space calculation because the client sends a position update also. | ||
914 | if (_size.X <= 0) _size.X = 0.01f; | ||
915 | if (_size.Y <= 0) _size.Y = 0.01f; | ||
916 | if (_size.Z <= 0) _size.Z = 0.01f; | ||
917 | // Construction of new prim | ||
918 | |||
919 | if (_parent_scene.needsMeshing(_pbs)) | ||
920 | { | ||
921 | // Don't need to re-enable body.. it's done in SetMesh | ||
922 | float meshlod = _parent_scene.meshSculptLOD; | ||
923 | |||
924 | if (IsPhysical) | ||
925 | meshlod = _parent_scene.MeshSculptphysicalLOD; | ||
926 | |||
927 | IMesh mesh = _parent_scene.mesher.CreateMesh(SOPName, _pbs, _size, meshlod, IsPhysical); | ||
928 | // createmesh returns null when it doesn't mesh. | ||
929 | CreateGeom(IntPtr.Zero, mesh); | ||
930 | } | ||
931 | else | ||
932 | { | ||
933 | _mesh = null; | ||
934 | CreateGeom(IntPtr.Zero, null); | ||
935 | } | ||
936 | tempPosition1.setValue(_position.X, _position.Y, _position.Z); | ||
937 | if (tempOrientation1.Handle != IntPtr.Zero) | ||
938 | tempOrientation1.Dispose(); | ||
939 | tempOrientation1 = new btQuaternion(_orientation.X, Orientation.Y, _orientation.Z, _orientation.W); | ||
940 | if (tempTransform1 != null && tempTransform1.Handle != IntPtr.Zero) | ||
941 | tempTransform1.Dispose(); | ||
942 | tempTransform1 = new btTransform(tempOrientation1, tempPosition1); | ||
943 | |||
944 | |||
945 | |||
946 | |||
947 | //d.GeomBoxSetLengths(prim_geom, _size.X, _size.Y, _size.Z); | ||
948 | if (IsPhysical) | ||
949 | { | ||
950 | SetBody(Mass); | ||
951 | // Re creates body on size. | ||
952 | // EnableBody also does setMass() | ||
953 | |||
954 | } | ||
955 | else | ||
956 | { | ||
957 | SetBody(0); | ||
958 | } | ||
959 | |||
960 | changeSelectedStatus(timestep); | ||
961 | if (childPrim) | ||
962 | { | ||
963 | if (_parent is BulletDotNETPrim) | ||
964 | { | ||
965 | BulletDotNETPrim parent = (BulletDotNETPrim)_parent; | ||
966 | parent.ChildSetGeom(this); | ||
967 | } | ||
968 | } | ||
969 | resetCollisionAccounting(); | ||
970 | m_taintshape = false; | ||
971 | } | ||
972 | |||
973 | private void resetCollisionAccounting() | ||
974 | { | ||
975 | m_collisionscore = 0; | ||
976 | } | ||
977 | |||
978 | private void ChildSetGeom(BulletDotNETPrim bulletDotNETPrim) | ||
979 | { | ||
980 | // TODO: throw new NotImplementedException(); | ||
981 | } | ||
982 | |||
983 | private void changeAddForce(float timestep) | ||
984 | { | ||
985 | // TODO: throw new NotImplementedException(); | ||
986 | } | ||
987 | |||
988 | private void changeAddAngularForce(float timestep) | ||
989 | { | ||
990 | // TODO: throw new NotImplementedException(); | ||
991 | } | ||
992 | |||
993 | private void changeSetTorque(float timestep) | ||
994 | { | ||
995 | // TODO: throw new NotImplementedException(); | ||
996 | } | ||
997 | |||
998 | private void changedisable(float timestep) | ||
999 | { | ||
1000 | // TODO: throw new NotImplementedException(); | ||
1001 | } | ||
1002 | |||
1003 | private void changeSelectedStatus(float timestep) | ||
1004 | { | ||
1005 | // TODO: throw new NotImplementedException(); | ||
1006 | } | ||
1007 | |||
1008 | private void changevelocity(float timestep) | ||
1009 | { | ||
1010 | // TODO: throw new NotImplementedException(); | ||
1011 | } | ||
1012 | |||
1013 | private void changelink(float timestep) | ||
1014 | { | ||
1015 | // TODO: throw new NotImplementedException(); | ||
1016 | } | ||
1017 | |||
1018 | private void changefloatonwater(float timestep) | ||
1019 | { | ||
1020 | // TODO: throw new NotImplementedException(); | ||
1021 | } | ||
1022 | |||
1023 | private void changeAngularLock(float timestep) | ||
1024 | { | ||
1025 | // TODO: throw new NotImplementedException(); | ||
1026 | } | ||
1027 | #endregion | ||
1028 | |||
1029 | |||
1030 | |||
1031 | |||
1032 | internal void Move(float timestep) | ||
1033 | { | ||
1034 | //TODO: | ||
1035 | float fx = 0; | ||
1036 | float fy = 0; | ||
1037 | float fz = 0; | ||
1038 | |||
1039 | if (IsPhysical && Body != null && Body.Handle != IntPtr.Zero && !m_isSelected) | ||
1040 | { | ||
1041 | float m_mass = CalculateMass(); | ||
1042 | |||
1043 | fz = 0f; | ||
1044 | //m_log.Info(m_collisionFlags.ToString()); | ||
1045 | |||
1046 | if (m_buoyancy != 0) | ||
1047 | { | ||
1048 | if (m_buoyancy > 0) | ||
1049 | { | ||
1050 | fz = (((-1 * _parent_scene.gravityz) * m_buoyancy) * m_mass); | ||
1051 | |||
1052 | //d.Vector3 l_velocity = d.BodyGetLinearVel(Body); | ||
1053 | //m_log.Info("Using Buoyancy: " + buoyancy + " G: " + (_parent_scene.gravityz * m_buoyancy) + "mass:" + m_mass + " Pos: " + Position.ToString()); | ||
1054 | } | ||
1055 | else | ||
1056 | { | ||
1057 | fz = (-1 * (((-1 * _parent_scene.gravityz) * (-1 * m_buoyancy)) * m_mass)); | ||
1058 | } | ||
1059 | } | ||
1060 | |||
1061 | if (m_usePID) | ||
1062 | { | ||
1063 | //if (!d.BodyIsEnabled(Body)) | ||
1064 | //d.BodySetForce(Body, 0f, 0f, 0f); | ||
1065 | // If we're using the PID controller, then we have no gravity | ||
1066 | fz = (-1 * _parent_scene.gravityz) * m_mass; | ||
1067 | |||
1068 | // no lock; for now it's only called from within Simulate() | ||
1069 | |||
1070 | // If the PID Controller isn't active then we set our force | ||
1071 | // calculating base velocity to the current position | ||
1072 | |||
1073 | if ((m_PIDTau < 1) && (m_PIDTau != 0)) | ||
1074 | { | ||
1075 | //PID_G = PID_G / m_PIDTau; | ||
1076 | m_PIDTau = 1; | ||
1077 | } | ||
1078 | |||
1079 | if ((PID_G - m_PIDTau) <= 0) | ||
1080 | { | ||
1081 | PID_G = m_PIDTau + 1; | ||
1082 | } | ||
1083 | |||
1084 | // TODO: NEED btVector3 for Linear Velocity | ||
1085 | // NEED btVector3 for Position | ||
1086 | |||
1087 | PhysicsVector pos = new PhysicsVector(0, 0, 0); //TODO: Insert values gotten from bullet | ||
1088 | PhysicsVector vel = new PhysicsVector(0, 0, 0); | ||
1089 | |||
1090 | _target_velocity = | ||
1091 | new PhysicsVector( | ||
1092 | (m_PIDTarget.X - pos.X) * ((PID_G - m_PIDTau) * timestep), | ||
1093 | (m_PIDTarget.Y - pos.Y) * ((PID_G - m_PIDTau) * timestep), | ||
1094 | (m_PIDTarget.Z - pos.Z) * ((PID_G - m_PIDTau) * timestep) | ||
1095 | ); | ||
1096 | |||
1097 | if (_target_velocity.IsIdentical(PhysicsVector.Zero, 0.1f)) | ||
1098 | { | ||
1099 | |||
1100 | /* TODO: Do Bullet equiv | ||
1101 | * | ||
1102 | d.BodySetPosition(Body, m_PIDTarget.X, m_PIDTarget.Y, m_PIDTarget.Z); | ||
1103 | d.BodySetLinearVel(Body, 0, 0, 0); | ||
1104 | d.BodyAddForce(Body, 0, 0, fz); | ||
1105 | return; | ||
1106 | */ | ||
1107 | } | ||
1108 | else | ||
1109 | { | ||
1110 | _zeroFlag = false; | ||
1111 | |||
1112 | fx = ((_target_velocity.X) - vel.X) * (PID_D); | ||
1113 | fy = ((_target_velocity.Y) - vel.Y) * (PID_D); | ||
1114 | fz = fz + ((_target_velocity.Z - vel.Z) * (PID_D) * m_mass); | ||
1115 | |||
1116 | } | ||
1117 | |||
1118 | } | ||
1119 | |||
1120 | if (m_useHoverPID && !m_usePID) | ||
1121 | { | ||
1122 | // If we're using the PID controller, then we have no gravity | ||
1123 | fz = (-1 * _parent_scene.gravityz) * m_mass; | ||
1124 | |||
1125 | // no lock; for now it's only called from within Simulate() | ||
1126 | |||
1127 | // If the PID Controller isn't active then we set our force | ||
1128 | // calculating base velocity to the current position | ||
1129 | |||
1130 | if ((m_PIDTau < 1)) | ||
1131 | { | ||
1132 | PID_G = PID_G / m_PIDTau; | ||
1133 | } | ||
1134 | |||
1135 | if ((PID_G - m_PIDTau) <= 0) | ||
1136 | { | ||
1137 | PID_G = m_PIDTau + 1; | ||
1138 | } | ||
1139 | PhysicsVector pos = new PhysicsVector(0, 0, 0); //TODO: Insert values gotten from bullet | ||
1140 | PhysicsVector vel = new PhysicsVector(0, 0, 0); | ||
1141 | |||
1142 | // determine what our target height really is based on HoverType | ||
1143 | switch (m_PIDHoverType) | ||
1144 | { | ||
1145 | case PIDHoverType.Absolute: | ||
1146 | m_targetHoverHeight = m_PIDHoverHeight; | ||
1147 | break; | ||
1148 | case PIDHoverType.Ground: | ||
1149 | m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y); | ||
1150 | m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight; | ||
1151 | break; | ||
1152 | case PIDHoverType.GroundAndWater: | ||
1153 | m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y); | ||
1154 | m_waterHeight = _parent_scene.GetWaterLevel(); | ||
1155 | if (m_groundHeight > m_waterHeight) | ||
1156 | { | ||
1157 | m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight; | ||
1158 | } | ||
1159 | else | ||
1160 | { | ||
1161 | m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight; | ||
1162 | } | ||
1163 | break; | ||
1164 | case PIDHoverType.Water: | ||
1165 | m_waterHeight = _parent_scene.GetWaterLevel(); | ||
1166 | m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight; | ||
1167 | break; | ||
1168 | } | ||
1169 | |||
1170 | |||
1171 | _target_velocity = | ||
1172 | new PhysicsVector(0.0f, 0.0f, | ||
1173 | (m_targetHoverHeight - pos.Z) * ((PID_G - m_PIDHoverTau) * timestep) | ||
1174 | ); | ||
1175 | |||
1176 | // if velocity is zero, use position control; otherwise, velocity control | ||
1177 | |||
1178 | if (_target_velocity.IsIdentical(PhysicsVector.Zero, 0.1f)) | ||
1179 | { | ||
1180 | |||
1181 | /* TODO: Do Bullet Equiv | ||
1182 | d.BodySetPosition(Body, pos.X, pos.Y, m_targetHoverHeight); | ||
1183 | d.BodySetLinearVel(Body, vel.X, vel.Y, 0); | ||
1184 | d.BodyAddForce(Body, 0, 0, fz); | ||
1185 | */ | ||
1186 | return; | ||
1187 | } | ||
1188 | else | ||
1189 | { | ||
1190 | _zeroFlag = false; | ||
1191 | |||
1192 | // We're flying and colliding with something | ||
1193 | fz = fz + ((_target_velocity.Z - vel.Z) * (PID_D) * m_mass); | ||
1194 | } | ||
1195 | } | ||
1196 | |||
1197 | fx *= m_mass; | ||
1198 | fy *= m_mass; | ||
1199 | //fz *= m_mass; | ||
1200 | |||
1201 | fx += m_force.X; | ||
1202 | fy += m_force.Y; | ||
1203 | fz += m_force.Z; | ||
1204 | |||
1205 | //m_log.Info("[OBJPID]: X:" + fx.ToString() + " Y:" + fy.ToString() + " Z:" + fz.ToString()); | ||
1206 | if (fx != 0 || fy != 0 || fz != 0) | ||
1207 | { | ||
1208 | /* | ||
1209 | * TODO: Do Bullet Equiv | ||
1210 | if (!d.BodyIsEnabled(Body)) | ||
1211 | { | ||
1212 | d.BodySetLinearVel(Body, 0f, 0f, 0f); | ||
1213 | d.BodySetForce(Body, 0, 0, 0); | ||
1214 | enableBodySoft(); | ||
1215 | } | ||
1216 | */ | ||
1217 | // 35x10 = 350n times the mass per second applied maximum. | ||
1218 | |||
1219 | float nmax = 35f * m_mass; | ||
1220 | float nmin = -35f * m_mass; | ||
1221 | |||
1222 | |||
1223 | if (fx > nmax) | ||
1224 | fx = nmax; | ||
1225 | if (fx < nmin) | ||
1226 | fx = nmin; | ||
1227 | if (fy > nmax) | ||
1228 | fy = nmax; | ||
1229 | if (fy < nmin) | ||
1230 | fy = nmin; | ||
1231 | |||
1232 | // TODO: Do Bullet Equiv | ||
1233 | // d.BodyAddForce(Body, fx, fy, fz); | ||
1234 | } | ||
1235 | } | ||
1236 | else | ||
1237 | { | ||
1238 | // _zeroPosition = d.BodyGetPosition(Body); | ||
1239 | return; | ||
1240 | } | ||
1241 | } | ||
1242 | |||
1243 | |||
1244 | |||
1245 | |||
1246 | #region Mass Calculation | ||
1247 | |||
1248 | private float CalculateMass() | ||
1249 | { | ||
1250 | float volume = 0; | ||
1251 | |||
1252 | // No material is passed to the physics engines yet.. soo.. | ||
1253 | // we're using the m_density constant in the class definition | ||
1254 | |||
1255 | float returnMass = 0; | ||
1256 | |||
1257 | switch (_pbs.ProfileShape) | ||
1258 | { | ||
1259 | case ProfileShape.Square: | ||
1260 | // Profile Volume | ||
1261 | |||
1262 | volume = _size.X * _size.Y * _size.Z; | ||
1263 | |||
1264 | // If the user has 'hollowed out' | ||
1265 | // ProfileHollow is one of those 0 to 50000 values :P | ||
1266 | // we like percentages better.. so turning into a percentage | ||
1267 | |||
1268 | if (((float)_pbs.ProfileHollow / 50000f) > 0.0) | ||
1269 | { | ||
1270 | float hollowAmount = (float)_pbs.ProfileHollow / 50000f; | ||
1271 | |||
1272 | // calculate the hollow volume by it's shape compared to the prim shape | ||
1273 | float hollowVolume = 0; | ||
1274 | switch (_pbs.HollowShape) | ||
1275 | { | ||
1276 | case HollowShape.Square: | ||
1277 | case HollowShape.Same: | ||
1278 | // Cube Hollow volume calculation | ||
1279 | float hollowsizex = _size.X * hollowAmount; | ||
1280 | float hollowsizey = _size.Y * hollowAmount; | ||
1281 | float hollowsizez = _size.Z * hollowAmount; | ||
1282 | hollowVolume = hollowsizex * hollowsizey * hollowsizez; | ||
1283 | break; | ||
1284 | |||
1285 | case HollowShape.Circle: | ||
1286 | // Hollow shape is a perfect cyllinder in respect to the cube's scale | ||
1287 | // Cyllinder hollow volume calculation | ||
1288 | float hRadius = _size.X / 2; | ||
1289 | float hLength = _size.Z; | ||
1290 | |||
1291 | // pi * r2 * h | ||
1292 | hollowVolume = ((float)(Math.PI * Math.Pow(hRadius, 2) * hLength) * hollowAmount); | ||
1293 | break; | ||
1294 | |||
1295 | case HollowShape.Triangle: | ||
1296 | // Equilateral Triangular Prism volume hollow calculation | ||
1297 | // Triangle is an Equilateral Triangular Prism with aLength = to _size.Y | ||
1298 | |||
1299 | float aLength = _size.Y; | ||
1300 | // 1/2 abh | ||
1301 | hollowVolume = (float)((0.5 * aLength * _size.X * _size.Z) * hollowAmount); | ||
1302 | break; | ||
1303 | |||
1304 | default: | ||
1305 | hollowVolume = 0; | ||
1306 | break; | ||
1307 | } | ||
1308 | volume = volume - hollowVolume; | ||
1309 | } | ||
1310 | |||
1311 | break; | ||
1312 | case ProfileShape.Circle: | ||
1313 | if (_pbs.PathCurve == (byte)Extrusion.Straight) | ||
1314 | { | ||
1315 | // Cylinder | ||
1316 | float volume1 = (float)(Math.PI * Math.Pow(_size.X / 2, 2) * _size.Z); | ||
1317 | float volume2 = (float)(Math.PI * Math.Pow(_size.Y / 2, 2) * _size.Z); | ||
1318 | |||
1319 | // Approximating the cylinder's irregularity. | ||
1320 | if (volume1 > volume2) | ||
1321 | { | ||
1322 | volume = (float)volume1 - (volume1 - volume2); | ||
1323 | } | ||
1324 | else if (volume2 > volume1) | ||
1325 | { | ||
1326 | volume = (float)volume2 - (volume2 - volume1); | ||
1327 | } | ||
1328 | else | ||
1329 | { | ||
1330 | // Regular cylinder | ||
1331 | volume = volume1; | ||
1332 | } | ||
1333 | } | ||
1334 | else | ||
1335 | { | ||
1336 | // We don't know what the shape is yet, so use default | ||
1337 | volume = _size.X * _size.Y * _size.Z; | ||
1338 | } | ||
1339 | // If the user has 'hollowed out' | ||
1340 | // ProfileHollow is one of those 0 to 50000 values :P | ||
1341 | // we like percentages better.. so turning into a percentage | ||
1342 | |||
1343 | if (((float)_pbs.ProfileHollow / 50000f) > 0.0) | ||
1344 | { | ||
1345 | float hollowAmount = (float)_pbs.ProfileHollow / 50000f; | ||
1346 | |||
1347 | // calculate the hollow volume by it's shape compared to the prim shape | ||
1348 | float hollowVolume = 0; | ||
1349 | switch (_pbs.HollowShape) | ||
1350 | { | ||
1351 | case HollowShape.Same: | ||
1352 | case HollowShape.Circle: | ||
1353 | // Hollow shape is a perfect cyllinder in respect to the cube's scale | ||
1354 | // Cyllinder hollow volume calculation | ||
1355 | float hRadius = _size.X / 2; | ||
1356 | float hLength = _size.Z; | ||
1357 | |||
1358 | // pi * r2 * h | ||
1359 | hollowVolume = ((float)(Math.PI * Math.Pow(hRadius, 2) * hLength) * hollowAmount); | ||
1360 | break; | ||
1361 | |||
1362 | case HollowShape.Square: | ||
1363 | // Cube Hollow volume calculation | ||
1364 | float hollowsizex = _size.X * hollowAmount; | ||
1365 | float hollowsizey = _size.Y * hollowAmount; | ||
1366 | float hollowsizez = _size.Z * hollowAmount; | ||
1367 | hollowVolume = hollowsizex * hollowsizey * hollowsizez; | ||
1368 | break; | ||
1369 | |||
1370 | case HollowShape.Triangle: | ||
1371 | // Equilateral Triangular Prism volume hollow calculation | ||
1372 | // Triangle is an Equilateral Triangular Prism with aLength = to _size.Y | ||
1373 | |||
1374 | float aLength = _size.Y; | ||
1375 | // 1/2 abh | ||
1376 | hollowVolume = (float)((0.5 * aLength * _size.X * _size.Z) * hollowAmount); | ||
1377 | break; | ||
1378 | |||
1379 | default: | ||
1380 | hollowVolume = 0; | ||
1381 | break; | ||
1382 | } | ||
1383 | volume = volume - hollowVolume; | ||
1384 | } | ||
1385 | break; | ||
1386 | |||
1387 | case ProfileShape.HalfCircle: | ||
1388 | if (_pbs.PathCurve == (byte)Extrusion.Curve1) | ||
1389 | { | ||
1390 | if (_size.X == _size.Y && _size.Z == _size.X) | ||
1391 | { | ||
1392 | // regular sphere | ||
1393 | // v = 4/3 * pi * r^3 | ||
1394 | float sradius3 = (float)Math.Pow((_size.X / 2), 3); | ||
1395 | volume = (float)((4 / 3f) * Math.PI * sradius3); | ||
1396 | } | ||
1397 | else | ||
1398 | { | ||
1399 | // we treat this as a box currently | ||
1400 | volume = _size.X * _size.Y * _size.Z; | ||
1401 | } | ||
1402 | } | ||
1403 | else | ||
1404 | { | ||
1405 | // We don't know what the shape is yet, so use default | ||
1406 | volume = _size.X * _size.Y * _size.Z; | ||
1407 | } | ||
1408 | break; | ||
1409 | |||
1410 | case ProfileShape.EquilateralTriangle: | ||
1411 | /* | ||
1412 | v = (abs((xB*yA-xA*yB)+(xC*yB-xB*yC)+(xA*yC-xC*yA))/2) * h | ||
1413 | |||
1414 | // seed mesh | ||
1415 | Vertex MM = new Vertex(-0.25f, -0.45f, 0.0f); | ||
1416 | Vertex PM = new Vertex(+0.5f, 0f, 0.0f); | ||
1417 | Vertex PP = new Vertex(-0.25f, +0.45f, 0.0f); | ||
1418 | */ | ||
1419 | float xA = -0.25f * _size.X; | ||
1420 | float yA = -0.45f * _size.Y; | ||
1421 | |||
1422 | float xB = 0.5f * _size.X; | ||
1423 | float yB = 0; | ||
1424 | |||
1425 | float xC = -0.25f * _size.X; | ||
1426 | float yC = 0.45f * _size.Y; | ||
1427 | |||
1428 | volume = (float)((Math.Abs((xB * yA - xA * yB) + (xC * yB - xB * yC) + (xA * yC - xC * yA)) / 2) * _size.Z); | ||
1429 | |||
1430 | // If the user has 'hollowed out' | ||
1431 | // ProfileHollow is one of those 0 to 50000 values :P | ||
1432 | // we like percentages better.. so turning into a percentage | ||
1433 | float fhollowFactor = ((float)_pbs.ProfileHollow / 1.9f); | ||
1434 | if (((float)fhollowFactor / 50000f) > 0.0) | ||
1435 | { | ||
1436 | float hollowAmount = (float)fhollowFactor / 50000f; | ||
1437 | |||
1438 | // calculate the hollow volume by it's shape compared to the prim shape | ||
1439 | float hollowVolume = 0; | ||
1440 | switch (_pbs.HollowShape) | ||
1441 | { | ||
1442 | case HollowShape.Same: | ||
1443 | case HollowShape.Triangle: | ||
1444 | // Equilateral Triangular Prism volume hollow calculation | ||
1445 | // Triangle is an Equilateral Triangular Prism with aLength = to _size.Y | ||
1446 | |||
1447 | float aLength = _size.Y; | ||
1448 | // 1/2 abh | ||
1449 | hollowVolume = (float)((0.5 * aLength * _size.X * _size.Z) * hollowAmount); | ||
1450 | break; | ||
1451 | |||
1452 | case HollowShape.Square: | ||
1453 | // Cube Hollow volume calculation | ||
1454 | float hollowsizex = _size.X * hollowAmount; | ||
1455 | float hollowsizey = _size.Y * hollowAmount; | ||
1456 | float hollowsizez = _size.Z * hollowAmount; | ||
1457 | hollowVolume = hollowsizex * hollowsizey * hollowsizez; | ||
1458 | break; | ||
1459 | |||
1460 | case HollowShape.Circle: | ||
1461 | // Hollow shape is a perfect cyllinder in respect to the cube's scale | ||
1462 | // Cyllinder hollow volume calculation | ||
1463 | float hRadius = _size.X / 2; | ||
1464 | float hLength = _size.Z; | ||
1465 | |||
1466 | // pi * r2 * h | ||
1467 | hollowVolume = ((float)((Math.PI * Math.Pow(hRadius, 2) * hLength) / 2) * hollowAmount); | ||
1468 | break; | ||
1469 | |||
1470 | default: | ||
1471 | hollowVolume = 0; | ||
1472 | break; | ||
1473 | } | ||
1474 | volume = volume - hollowVolume; | ||
1475 | } | ||
1476 | break; | ||
1477 | |||
1478 | default: | ||
1479 | // we don't have all of the volume formulas yet so | ||
1480 | // use the common volume formula for all | ||
1481 | volume = _size.X * _size.Y * _size.Z; | ||
1482 | break; | ||
1483 | } | ||
1484 | |||
1485 | // Calculate Path cut effect on volume | ||
1486 | // Not exact, in the triangle hollow example | ||
1487 | // They should never be zero or less then zero.. | ||
1488 | // we'll ignore it if it's less then zero | ||
1489 | |||
1490 | // ProfileEnd and ProfileBegin are values | ||
1491 | // from 0 to 50000 | ||
1492 | |||
1493 | // Turning them back into percentages so that I can cut that percentage off the volume | ||
1494 | |||
1495 | float PathCutEndAmount = _pbs.ProfileEnd; | ||
1496 | float PathCutStartAmount = _pbs.ProfileBegin; | ||
1497 | if (((PathCutStartAmount + PathCutEndAmount) / 50000f) > 0.0f) | ||
1498 | { | ||
1499 | float pathCutAmount = ((PathCutStartAmount + PathCutEndAmount) / 50000f); | ||
1500 | |||
1501 | // Check the return amount for sanity | ||
1502 | if (pathCutAmount >= 0.99f) | ||
1503 | pathCutAmount = 0.99f; | ||
1504 | |||
1505 | volume = volume - (volume * pathCutAmount); | ||
1506 | } | ||
1507 | UInt16 taperX = _pbs.PathScaleX; | ||
1508 | UInt16 taperY = _pbs.PathScaleY; | ||
1509 | float taperFactorX = 0; | ||
1510 | float taperFactorY = 0; | ||
1511 | |||
1512 | // Mass = density * volume | ||
1513 | if (taperX != 100) | ||
1514 | { | ||
1515 | if (taperX > 100) | ||
1516 | { | ||
1517 | taperFactorX = 1.0f - ((float)taperX / 200); | ||
1518 | //m_log.Warn("taperTopFactorX: " + extr.taperTopFactorX.ToString()); | ||
1519 | } | ||
1520 | else | ||
1521 | { | ||
1522 | taperFactorX = 1.0f - ((100 - (float)taperX) / 100); | ||
1523 | //m_log.Warn("taperBotFactorX: " + extr.taperBotFactorX.ToString()); | ||
1524 | } | ||
1525 | volume = (float)volume * ((taperFactorX / 3f) + 0.001f); | ||
1526 | } | ||
1527 | |||
1528 | if (taperY != 100) | ||
1529 | { | ||
1530 | if (taperY > 100) | ||
1531 | { | ||
1532 | taperFactorY = 1.0f - ((float)taperY / 200); | ||
1533 | //m_log.Warn("taperTopFactorY: " + extr.taperTopFactorY.ToString()); | ||
1534 | } | ||
1535 | else | ||
1536 | { | ||
1537 | taperFactorY = 1.0f - ((100 - (float)taperY) / 100); | ||
1538 | //m_log.Warn("taperBotFactorY: " + extr.taperBotFactorY.ToString()); | ||
1539 | } | ||
1540 | volume = (float)volume * ((taperFactorY / 3f) + 0.001f); | ||
1541 | } | ||
1542 | returnMass = m_density * volume; | ||
1543 | if (returnMass <= 0) returnMass = 0.0001f;//ckrinke: Mass must be greater then zero. | ||
1544 | |||
1545 | |||
1546 | |||
1547 | // Recursively calculate mass | ||
1548 | bool HasChildPrim = false; | ||
1549 | lock (childrenPrim) | ||
1550 | { | ||
1551 | if (childrenPrim.Count > 0) | ||
1552 | { | ||
1553 | HasChildPrim = true; | ||
1554 | } | ||
1555 | |||
1556 | } | ||
1557 | if (HasChildPrim) | ||
1558 | { | ||
1559 | BulletDotNETPrim[] childPrimArr = new BulletDotNETPrim[0]; | ||
1560 | |||
1561 | lock (childrenPrim) | ||
1562 | childPrimArr = childrenPrim.ToArray(); | ||
1563 | |||
1564 | for (int i = 0; i < childPrimArr.Length; i++) | ||
1565 | { | ||
1566 | if (childPrimArr[i] != null && !childPrimArr[i].m_taintremove) | ||
1567 | returnMass += childPrimArr[i].CalculateMass(); | ||
1568 | // failsafe, this shouldn't happen but with OpenSim, you never know :) | ||
1569 | if (i > 256) | ||
1570 | break; | ||
1571 | } | ||
1572 | } | ||
1573 | |||
1574 | |||
1575 | |||
1576 | |||
1577 | |||
1578 | return returnMass; | ||
1579 | } | ||
1580 | |||
1581 | #endregion | ||
1582 | |||
1583 | |||
1584 | public void CreateGeom(IntPtr m_targetSpace, IMesh p_mesh) | ||
1585 | { | ||
1586 | if (p_mesh != null) | ||
1587 | { | ||
1588 | _mesh = _parent_scene.mesher.CreateMesh(m_primName, _pbs, _size, _parent_scene.meshSculptLOD, IsPhysical); | ||
1589 | setMesh(_parent_scene, _mesh); | ||
1590 | |||
1591 | } | ||
1592 | else | ||
1593 | { | ||
1594 | if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1) | ||
1595 | { | ||
1596 | if (_size.X == _size.Y && _size.Y == _size.Z && _size.X == _size.Z) | ||
1597 | { | ||
1598 | if (((_size.X / 2f) > 0f)) | ||
1599 | { | ||
1600 | //SetGeom to a Regular Sphere | ||
1601 | tempSize1.setValue(_size.X * 0.5f, _size.Y * 0.5f, _size.Z * 0.5f); | ||
1602 | SetCollisionShape(new btSphereShape(_size.X*0.5f)); | ||
1603 | } | ||
1604 | else | ||
1605 | { | ||
1606 | // uses halfextents | ||
1607 | tempSize1.setValue(_size.X*0.5f, _size.Y*0.5f, _size.Z*0.5f); | ||
1608 | SetCollisionShape(new btBoxShape(tempSize1)); | ||
1609 | } | ||
1610 | } | ||
1611 | else | ||
1612 | { | ||
1613 | // uses halfextents | ||
1614 | tempSize1.setValue(_size.X * 0.5f, _size.Y * 0.5f, _size.Z * 0.5f); | ||
1615 | SetCollisionShape(new btBoxShape(tempSize1)); | ||
1616 | } | ||
1617 | |||
1618 | } | ||
1619 | else | ||
1620 | { | ||
1621 | // uses halfextents | ||
1622 | tempSize1.setValue(_size.X * 0.5f, _size.Y * 0.5f, _size.Z * 0.5f); | ||
1623 | SetCollisionShape(new btBoxShape(tempSize1)); | ||
1624 | } | ||
1625 | } | ||
1626 | } | ||
1627 | |||
1628 | private void setMesh(BulletDotNETScene _parent_scene, IMesh mesh) | ||
1629 | { | ||
1630 | // TODO: Set Collision Body Mesh | ||
1631 | // This sleeper is there to moderate how long it takes between | ||
1632 | // setting up the mesh and pre-processing it when we get rapid fire mesh requests on a single object | ||
1633 | |||
1634 | Thread.Sleep(10); | ||
1635 | |||
1636 | //Kill Body so that mesh can re-make the geom | ||
1637 | if (IsPhysical && Body != null && Body.Handle != IntPtr.Zero) | ||
1638 | { | ||
1639 | if (childPrim) | ||
1640 | { | ||
1641 | if (_parent != null) | ||
1642 | { | ||
1643 | BulletDotNETPrim parent = (BulletDotNETPrim)_parent; | ||
1644 | parent.ChildDelink(this); | ||
1645 | } | ||
1646 | } | ||
1647 | else | ||
1648 | { | ||
1649 | disableBody(); | ||
1650 | } | ||
1651 | } | ||
1652 | |||
1653 | IMesh oldMesh = primMesh; | ||
1654 | |||
1655 | primMesh = mesh; | ||
1656 | |||
1657 | float[] vertexList = primMesh.getVertexListAsFloatLocked(); // Note, that vertextList is pinned in memory | ||
1658 | int[] indexList = primMesh.getIndexListAsIntLocked(); // Also pinned, needs release after usage | ||
1659 | //Array.Reverse(indexList); | ||
1660 | primMesh.releaseSourceMeshData(); // free up the original mesh data to save memory | ||
1661 | |||
1662 | int VertexCount = vertexList.GetLength(0) / 3; | ||
1663 | int IndexCount = indexList.GetLength(0); | ||
1664 | |||
1665 | if (btshapeArray != null && btshapeArray.Handle != IntPtr.Zero) | ||
1666 | btshapeArray.Dispose(); | ||
1667 | //Array.Reverse(indexList); | ||
1668 | btshapeArray = new btTriangleIndexVertexArray(IndexCount / 3, indexList, (3 * sizeof(int)), | ||
1669 | VertexCount, vertexList, 3*sizeof (float)); | ||
1670 | SetCollisionShape(new btGImpactMeshShape(btshapeArray)); | ||
1671 | //((btGImpactMeshShape) prim_geom).updateBound(); | ||
1672 | ((btGImpactMeshShape)prim_geom).setLocalScaling(new btVector3(1,1, 1)); | ||
1673 | ((btGImpactMeshShape)prim_geom).updateBound(); | ||
1674 | _parent_scene.SetUsingGImpact(); | ||
1675 | if (oldMesh != null) | ||
1676 | { | ||
1677 | oldMesh.releasePinned(); | ||
1678 | oldMesh = null; | ||
1679 | } | ||
1680 | |||
1681 | } | ||
1682 | |||
1683 | private void SetCollisionShape(btCollisionShape shape) | ||
1684 | { | ||
1685 | if (shape == null) | ||
1686 | m_log.Debug("[PHYSICS]:SetShape!Null"); | ||
1687 | else | ||
1688 | m_log.Debug("[PHYSICS]:SetShape!"); | ||
1689 | |||
1690 | if (Body != null) | ||
1691 | { | ||
1692 | DisposeOfBody(); | ||
1693 | } | ||
1694 | |||
1695 | if (prim_geom != null) | ||
1696 | { | ||
1697 | prim_geom.Dispose(); | ||
1698 | prim_geom = null; | ||
1699 | } | ||
1700 | prim_geom = shape; | ||
1701 | |||
1702 | //Body.set | ||
1703 | } | ||
1704 | |||
1705 | public void SetBody(float mass) | ||
1706 | { | ||
1707 | m_log.DebugFormat("[PHYSICS]: SetBody! {0}",mass); | ||
1708 | if (Body != null && Body.Handle != IntPtr.Zero) | ||
1709 | { | ||
1710 | DisposeOfBody(); | ||
1711 | } | ||
1712 | |||
1713 | if (tempMotionState1 != null && tempMotionState1.Handle != IntPtr.Zero) | ||
1714 | tempMotionState1.Dispose(); | ||
1715 | if (tempTransform2 != null && tempTransform2.Handle != IntPtr.Zero) | ||
1716 | tempTransform2.Dispose(); | ||
1717 | if (tempOrientation2 != null && tempOrientation2.Handle != IntPtr.Zero) | ||
1718 | tempOrientation2.Dispose(); | ||
1719 | |||
1720 | if (tempPosition2 != null && tempPosition2.Handle != IntPtr.Zero) | ||
1721 | tempPosition2.Dispose(); | ||
1722 | |||
1723 | tempOrientation2 = new btQuaternion(_orientation.X, _orientation.Y, _orientation.Z, _orientation.W); | ||
1724 | tempPosition2 = new btVector3(_position.X, _position.Y, _position.Z); | ||
1725 | tempTransform2 = new btTransform(tempOrientation2, tempPosition2); | ||
1726 | tempMotionState1 = new btDefaultMotionState(tempTransform2, _parent_scene.TransZero); | ||
1727 | if (tempInertia1 != null && tempInertia1.Handle != IntPtr.Zero) | ||
1728 | tempInertia1.Dispose(); | ||
1729 | tempInertia1 = new btVector3(0, 0, 0); | ||
1730 | if (prim_geom.Handle == IntPtr.Zero) | ||
1731 | { | ||
1732 | m_log.Warn("[PHYSICS]:PrimGeom is Disposed!"); | ||
1733 | CreateGeom(IntPtr.Zero, primMesh); | ||
1734 | |||
1735 | } | ||
1736 | prim_geom.calculateLocalInertia(mass, tempInertia1); | ||
1737 | |||
1738 | if (mass == 0) | ||
1739 | Body = new btRigidBody(mass, tempMotionState1, prim_geom); | ||
1740 | else | ||
1741 | Body = new btRigidBody(mass, tempMotionState1, prim_geom, tempInertia1); | ||
1742 | |||
1743 | if (prim_geom is btGImpactMeshShape) | ||
1744 | { | ||
1745 | ((btGImpactMeshShape) prim_geom).setLocalScaling(new btVector3(1, 1, 1)); | ||
1746 | ((btGImpactMeshShape) prim_geom).updateBound(); | ||
1747 | } | ||
1748 | _parent_scene.AddPrimToScene(this); | ||
1749 | } | ||
1750 | |||
1751 | private void DisposeOfBody() | ||
1752 | { | ||
1753 | if (Body != null) | ||
1754 | { | ||
1755 | if (Body.Handle != IntPtr.Zero) | ||
1756 | { | ||
1757 | _parent_scene.removeFromWorld(this,Body); | ||
1758 | Body.Dispose(); | ||
1759 | } | ||
1760 | Body = null; | ||
1761 | // TODO: dispose parts that make up body | ||
1762 | } | ||
1763 | } | ||
1764 | |||
1765 | private void ChildDelink(BulletDotNETPrim pPrim) | ||
1766 | { | ||
1767 | // Okay, we have a delinked child.. need to rebuild the body. | ||
1768 | lock (childrenPrim) | ||
1769 | { | ||
1770 | foreach (BulletDotNETPrim prm in childrenPrim) | ||
1771 | { | ||
1772 | prm.childPrim = true; | ||
1773 | prm.disableBody(); | ||
1774 | |||
1775 | } | ||
1776 | } | ||
1777 | disableBody(); | ||
1778 | |||
1779 | lock (childrenPrim) | ||
1780 | { | ||
1781 | childrenPrim.Remove(pPrim); | ||
1782 | } | ||
1783 | |||
1784 | |||
1785 | |||
1786 | |||
1787 | if (Body != null && Body.Handle != IntPtr.Zero) | ||
1788 | { | ||
1789 | _parent_scene.remActivePrim(this); | ||
1790 | } | ||
1791 | |||
1792 | |||
1793 | |||
1794 | lock (childrenPrim) | ||
1795 | { | ||
1796 | foreach (BulletDotNETPrim prm in childrenPrim) | ||
1797 | { | ||
1798 | ParentPrim(prm); | ||
1799 | } | ||
1800 | } | ||
1801 | |||
1802 | } | ||
1803 | |||
1804 | private void ParentPrim(BulletDotNETPrim prm) | ||
1805 | { | ||
1806 | // TODO: Parent Linking algorithm. Use btComplexObject | ||
1807 | } | ||
1808 | |||
1809 | public void disableBody() | ||
1810 | { | ||
1811 | //this kills the body so things like 'mesh' can re-create it. | ||
1812 | lock (this) | ||
1813 | { | ||
1814 | if (!childPrim) | ||
1815 | { | ||
1816 | if (Body != null && Body.Handle != IntPtr.Zero) | ||
1817 | { | ||
1818 | _parent_scene.remActivePrim(this); | ||
1819 | |||
1820 | m_collisionCategories &= ~CollisionCategories.Body; | ||
1821 | m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land); | ||
1822 | |||
1823 | if (prim_geom != null && prim_geom.Handle != IntPtr.Zero) | ||
1824 | { | ||
1825 | // TODO: Set Category bits and Flags | ||
1826 | } | ||
1827 | |||
1828 | // TODO: destroy body | ||
1829 | DisposeOfBody(); | ||
1830 | |||
1831 | lock (childrenPrim) | ||
1832 | { | ||
1833 | if (childrenPrim.Count > 0) | ||
1834 | { | ||
1835 | foreach (BulletDotNETPrim prm in childrenPrim) | ||
1836 | { | ||
1837 | _parent_scene.remActivePrim(prm); | ||
1838 | prm.DisposeOfBody(); | ||
1839 | prm.SetCollisionShape(null); | ||
1840 | } | ||
1841 | } | ||
1842 | |||
1843 | } | ||
1844 | |||
1845 | DisposeOfBody(); | ||
1846 | } | ||
1847 | } | ||
1848 | else | ||
1849 | { | ||
1850 | _parent_scene.remActivePrim(this); | ||
1851 | m_collisionCategories &= ~CollisionCategories.Body; | ||
1852 | m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land); | ||
1853 | |||
1854 | if (prim_geom != null && prim_geom.Handle != IntPtr.Zero) | ||
1855 | { | ||
1856 | // TODO: Set Category bits and Flags | ||
1857 | } | ||
1858 | |||
1859 | DisposeOfBody(); | ||
1860 | } | ||
1861 | |||
1862 | } | ||
1863 | m_disabled = true; | ||
1864 | m_collisionscore = 0; | ||
1865 | } | ||
1866 | |||
1867 | public void disableBodySoft() | ||
1868 | { | ||
1869 | m_disabled = true; | ||
1870 | |||
1871 | if (m_isphysical && Body.Handle != IntPtr.Zero) | ||
1872 | { | ||
1873 | Body.clearForces(); | ||
1874 | Body.forceActivationState(0); | ||
1875 | |||
1876 | } | ||
1877 | |||
1878 | } | ||
1879 | |||
1880 | public void enableBodySoft() | ||
1881 | { | ||
1882 | if (!childPrim) | ||
1883 | { | ||
1884 | if (m_isphysical && Body.Handle != IntPtr.Zero) | ||
1885 | { | ||
1886 | Body.clearForces(); | ||
1887 | Body.forceActivationState(1); | ||
1888 | } | ||
1889 | m_disabled = false; | ||
1890 | } | ||
1891 | } | ||
1892 | |||
1893 | public void enableBody() | ||
1894 | { | ||
1895 | if (!childPrim) | ||
1896 | { | ||
1897 | //SetCollisionShape(prim_geom); | ||
1898 | if (IsPhysical) | ||
1899 | SetBody(Mass); | ||
1900 | else | ||
1901 | SetBody(0); | ||
1902 | |||
1903 | // TODO: Set Collision Category Bits and Flags | ||
1904 | // TODO: Set Auto Disable data | ||
1905 | |||
1906 | m_interpenetrationcount = 0; | ||
1907 | m_collisionscore = 0; | ||
1908 | m_disabled = false; | ||
1909 | // The body doesn't already have a finite rotation mode set here | ||
1910 | if ((!m_angularlock.IsIdentical(PhysicsVector.Zero, 0)) && _parent == null) | ||
1911 | { | ||
1912 | // TODO: Create Angular Motor on Axis Lock! | ||
1913 | } | ||
1914 | _parent_scene.addActivePrim(this); | ||
1915 | } | ||
1916 | } | ||
1917 | |||
1918 | public void UpdatePositionAndVelocity() | ||
1919 | { | ||
1920 | if (_parent == null) | ||
1921 | { | ||
1922 | PhysicsVector pv = new PhysicsVector(0, 0, 0); | ||
1923 | bool lastZeroFlag = _zeroFlag; | ||
1924 | if (tempPosition2 != null && tempPosition2.Handle != IntPtr.Zero) | ||
1925 | tempPosition2.Dispose(); | ||
1926 | if (tempTransform3 != null && tempTransform3.Handle != IntPtr.Zero) | ||
1927 | tempTransform3.Dispose(); | ||
1928 | |||
1929 | if (tempOrientation2 != null && tempOrientation2.Handle != IntPtr.Zero) | ||
1930 | tempOrientation2.Dispose(); | ||
1931 | |||
1932 | if (tempAngularVelocity1 != null && tempAngularVelocity1.Handle != IntPtr.Zero) | ||
1933 | tempAngularVelocity1.Dispose(); | ||
1934 | |||
1935 | if (tempLinearVelocity1 != null && tempLinearVelocity1.Handle != IntPtr.Zero) | ||
1936 | tempLinearVelocity1.Dispose(); | ||
1937 | |||
1938 | |||
1939 | |||
1940 | tempTransform3 = Body.getInterpolationWorldTransform(); | ||
1941 | tempPosition2 = tempTransform3.getOrigin(); // vec | ||
1942 | tempOrientation2 = tempTransform3.getRotation(); // ori | ||
1943 | tempAngularVelocity1 = Body.getInterpolationAngularVelocity(); //rotvel | ||
1944 | tempLinearVelocity1 = Body.getInterpolationLinearVelocity(); // vel | ||
1945 | |||
1946 | _torque.setValues(tempAngularVelocity1.getX(), tempAngularVelocity1.getX(), tempAngularVelocity1.getZ()); | ||
1947 | PhysicsVector l_position = new PhysicsVector(); | ||
1948 | Quaternion l_orientation = new Quaternion(); | ||
1949 | m_lastposition = _position; | ||
1950 | m_lastorientation = _orientation; | ||
1951 | |||
1952 | l_position.X = tempPosition2.getX(); | ||
1953 | l_position.Y = tempPosition2.getY(); | ||
1954 | l_position.Z = tempPosition2.getZ(); | ||
1955 | l_orientation.X = tempOrientation2.getX(); | ||
1956 | l_orientation.Y = tempOrientation2.getY(); | ||
1957 | l_orientation.Z = tempOrientation2.getZ(); | ||
1958 | l_orientation.W = tempOrientation2.getW(); | ||
1959 | |||
1960 | if (l_position.X > 255.95f || l_position.X < 0f || l_position.Y > 255.95f || l_position.Y < 0f) | ||
1961 | { | ||
1962 | //base.RaiseOutOfBounds(l_position); | ||
1963 | |||
1964 | if (m_crossingfailures < _parent_scene.geomCrossingFailuresBeforeOutofbounds) | ||
1965 | { | ||
1966 | _position = l_position; | ||
1967 | //_parent_scene.remActivePrim(this); | ||
1968 | if (_parent == null) | ||
1969 | base.RequestPhysicsterseUpdate(); | ||
1970 | return; | ||
1971 | } | ||
1972 | else | ||
1973 | { | ||
1974 | if (_parent == null) | ||
1975 | base.RaiseOutOfBounds(l_position); | ||
1976 | return; | ||
1977 | } | ||
1978 | } | ||
1979 | |||
1980 | if (l_position.Z < -200000f) | ||
1981 | { | ||
1982 | // This is so prim that get lost underground don't fall forever and suck up | ||
1983 | // | ||
1984 | // Sim resources and memory. | ||
1985 | // Disables the prim's movement physics.... | ||
1986 | // It's a hack and will generate a console message if it fails. | ||
1987 | |||
1988 | //IsPhysical = false; | ||
1989 | //if (_parent == null) | ||
1990 | //base.RaiseOutOfBounds(_position); | ||
1991 | |||
1992 | _acceleration.X = 0; | ||
1993 | _acceleration.Y = 0; | ||
1994 | _acceleration.Z = 0; | ||
1995 | |||
1996 | _velocity.X = 0; | ||
1997 | _velocity.Y = 0; | ||
1998 | _velocity.Z = 0; | ||
1999 | m_rotationalVelocity.X = 0; | ||
2000 | m_rotationalVelocity.Y = 0; | ||
2001 | m_rotationalVelocity.Z = 0; | ||
2002 | |||
2003 | if (_parent == null) | ||
2004 | base.RequestPhysicsterseUpdate(); | ||
2005 | |||
2006 | m_throttleUpdates = false; | ||
2007 | throttleCounter = 0; | ||
2008 | _zeroFlag = true; | ||
2009 | //outofBounds = true; | ||
2010 | } | ||
2011 | |||
2012 | if ((Math.Abs(m_lastposition.X - l_position.X) < 0.02) | ||
2013 | && (Math.Abs(m_lastposition.Y - l_position.Y) < 0.02) | ||
2014 | && (Math.Abs(m_lastposition.Z - l_position.Z) < 0.02) | ||
2015 | && (1.0 - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation)) < 0.01 )) | ||
2016 | { | ||
2017 | _zeroFlag = true; | ||
2018 | m_throttleUpdates = false; | ||
2019 | } | ||
2020 | else | ||
2021 | { | ||
2022 | //m_log.Debug(Math.Abs(m_lastposition.X - l_position.X).ToString()); | ||
2023 | _zeroFlag = false; | ||
2024 | } | ||
2025 | |||
2026 | if (_zeroFlag) | ||
2027 | { | ||
2028 | _velocity.X = 0.0f; | ||
2029 | _velocity.Y = 0.0f; | ||
2030 | _velocity.Z = 0.0f; | ||
2031 | |||
2032 | _acceleration.X = 0; | ||
2033 | _acceleration.Y = 0; | ||
2034 | _acceleration.Z = 0; | ||
2035 | |||
2036 | //_orientation.w = 0f; | ||
2037 | //_orientation.X = 0f; | ||
2038 | //_orientation.Y = 0f; | ||
2039 | //_orientation.Z = 0f; | ||
2040 | m_rotationalVelocity.X = 0; | ||
2041 | m_rotationalVelocity.Y = 0; | ||
2042 | m_rotationalVelocity.Z = 0; | ||
2043 | if (!m_lastUpdateSent) | ||
2044 | { | ||
2045 | m_throttleUpdates = false; | ||
2046 | throttleCounter = 0; | ||
2047 | m_rotationalVelocity = pv; | ||
2048 | |||
2049 | if (_parent == null) | ||
2050 | base.RequestPhysicsterseUpdate(); | ||
2051 | |||
2052 | m_lastUpdateSent = true; | ||
2053 | } | ||
2054 | } | ||
2055 | else | ||
2056 | { | ||
2057 | if (lastZeroFlag != _zeroFlag) | ||
2058 | { | ||
2059 | if (_parent == null) | ||
2060 | base.RequestPhysicsterseUpdate(); | ||
2061 | } | ||
2062 | |||
2063 | m_lastVelocity = _velocity; | ||
2064 | |||
2065 | _position = l_position; | ||
2066 | |||
2067 | _velocity.X = tempLinearVelocity1.getX(); | ||
2068 | _velocity.Y = tempLinearVelocity1.getY(); | ||
2069 | _velocity.Z = tempLinearVelocity1.getZ(); | ||
2070 | |||
2071 | _acceleration = ((_velocity - m_lastVelocity) / 0.1f); | ||
2072 | _acceleration = new PhysicsVector(_velocity.X - m_lastVelocity.X / 0.1f, _velocity.Y - m_lastVelocity.Y / 0.1f, _velocity.Z - m_lastVelocity.Z / 0.1f); | ||
2073 | //m_log.Info("[PHYSICS]: V1: " + _velocity + " V2: " + m_lastVelocity + " Acceleration: " + _acceleration.ToString()); | ||
2074 | |||
2075 | if (_velocity.IsIdentical(pv, 0.5f)) | ||
2076 | { | ||
2077 | m_rotationalVelocity = pv; | ||
2078 | } | ||
2079 | else | ||
2080 | { | ||
2081 | |||
2082 | m_rotationalVelocity.setValues(tempAngularVelocity1.getX(), tempAngularVelocity1.getY(), tempAngularVelocity1.getZ()); | ||
2083 | } | ||
2084 | |||
2085 | //m_log.Debug("ODE: " + m_rotationalVelocity.ToString()); | ||
2086 | |||
2087 | _orientation.X = l_orientation.X; | ||
2088 | _orientation.Y = l_orientation.Y; | ||
2089 | _orientation.Z = l_orientation.Z; | ||
2090 | _orientation.W = l_orientation.W; | ||
2091 | m_lastUpdateSent = false; | ||
2092 | |||
2093 | //if (!m_throttleUpdates || throttleCounter > _parent_scene.geomUpdatesPerThrottledUpdate) | ||
2094 | //{ | ||
2095 | if (_parent == null) | ||
2096 | base.RequestPhysicsterseUpdate(); | ||
2097 | // } | ||
2098 | // else | ||
2099 | // { | ||
2100 | // throttleCounter++; | ||
2101 | //} | ||
2102 | |||
2103 | } | ||
2104 | m_lastposition = l_position; | ||
2105 | } | ||
2106 | else | ||
2107 | { | ||
2108 | // Not a body.. so Make sure the client isn't interpolating | ||
2109 | _velocity.X = 0; | ||
2110 | _velocity.Y = 0; | ||
2111 | _velocity.Z = 0; | ||
2112 | |||
2113 | _acceleration.X = 0; | ||
2114 | _acceleration.Y = 0; | ||
2115 | _acceleration.Z = 0; | ||
2116 | |||
2117 | m_rotationalVelocity.X = 0; | ||
2118 | m_rotationalVelocity.Y = 0; | ||
2119 | m_rotationalVelocity.Z = 0; | ||
2120 | _zeroFlag = true; | ||
2121 | } | ||
2122 | } | ||
2123 | |||
2124 | |||
2125 | internal void setPrimForRemoval() | ||
2126 | { | ||
2127 | m_taintremove = true; | ||
2128 | } | ||
2129 | } | ||
2130 | } | ||
2131 | |||
diff --git a/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETScene.cs b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETScene.cs new file mode 100644 index 0000000..4fcf035 --- /dev/null +++ b/OpenSim/Region/Physics/BulletDotNETPlugin/BulletDotNETScene.cs | |||
@@ -0,0 +1,642 @@ | |||
1 | using System; | ||
2 | using System.Collections.Generic; | ||
3 | using System.Reflection; | ||
4 | using System.IO; | ||
5 | using System.Diagnostics; | ||
6 | using System.Threading; | ||
7 | using log4net; | ||
8 | using Nini.Config; | ||
9 | using OpenSim.Framework; | ||
10 | using OpenSim.Region.Physics.Manager; | ||
11 | using OpenMetaverse; | ||
12 | using BulletDotNET; | ||
13 | |||
14 | namespace OpenSim.Region.Physics.BulletDotNETPlugin | ||
15 | { | ||
16 | public class BulletDotNETScene : PhysicsScene | ||
17 | { | ||
18 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
19 | |||
20 | private string m_sceneIdentifier = string.Empty; | ||
21 | |||
22 | private List<BulletDotNETCharacter> m_characters = new List<BulletDotNETCharacter>(); | ||
23 | private List<BulletDotNETPrim> m_prims = new List<BulletDotNETPrim>(); | ||
24 | private List<BulletDotNETPrim> m_activePrims = new List<BulletDotNETPrim>(); | ||
25 | private List<PhysicsActor> m_taintedActors = new List<PhysicsActor>(); | ||
26 | private btDiscreteDynamicsWorld m_world; | ||
27 | private btAxisSweep3 m_broadphase; | ||
28 | private btCollisionConfiguration m_collisionConfiguration; | ||
29 | private btConstraintSolver m_solver; | ||
30 | private btCollisionDispatcher m_dispatcher; | ||
31 | private btHeightfieldTerrainShape m_terrainShape; | ||
32 | public btRigidBody TerrainBody; | ||
33 | private btVector3 m_terrainPosition; | ||
34 | private btVector3 m_gravity; | ||
35 | public btMotionState m_terrainMotionState; | ||
36 | public btTransform m_terrainTransform; | ||
37 | public btVector3 VectorZero; | ||
38 | public btQuaternion QuatIdentity; | ||
39 | public btTransform TransZero; | ||
40 | |||
41 | public float geomDefaultDensity = 10.000006836f; | ||
42 | |||
43 | private float avPIDD = 65f; | ||
44 | private float avPIDP = 28f; | ||
45 | private float avCapRadius = 0.37f; | ||
46 | private float avStandupTensor = 2000000f; | ||
47 | private float avDensity = 80f; | ||
48 | private float avHeightFudgeFactor = 0.52f; | ||
49 | private float avMovementDivisorWalk = 1.0f; | ||
50 | private float avMovementDivisorRun = 0.75f; | ||
51 | |||
52 | private float minimumGroundFlightOffset = 3f; | ||
53 | |||
54 | public bool meshSculptedPrim = true; | ||
55 | |||
56 | public float meshSculptLOD = 32; | ||
57 | public float MeshSculptphysicalLOD = 16; | ||
58 | |||
59 | public float bodyPIDD = 35f; | ||
60 | public float bodyPIDG = 25; | ||
61 | internal int geomCrossingFailuresBeforeOutofbounds = 4; | ||
62 | |||
63 | public float bodyMotorJointMaxforceTensor = 2; | ||
64 | |||
65 | public int bodyFramesAutoDisable = 20; | ||
66 | |||
67 | public float WorldTimeStep = 10f/60f; | ||
68 | public const float WorldTimeComp = 1/60f; | ||
69 | public float gravityz = -9.8f; | ||
70 | |||
71 | private float[] _origheightmap; // Used for Fly height. Kitto Flora | ||
72 | private bool usingGImpactAlgorithm = false; | ||
73 | |||
74 | private IConfigSource m_config; | ||
75 | private readonly btVector3 worldAabbMin = new btVector3(0, 0, 0); | ||
76 | private readonly btVector3 worldAabbMax = new btVector3(Constants.RegionSize, Constants.RegionSize , 9000); | ||
77 | |||
78 | public IMesher mesher; | ||
79 | |||
80 | public BulletDotNETScene(string sceneIdentifier) | ||
81 | { | ||
82 | m_sceneIdentifier = sceneIdentifier; | ||
83 | VectorZero = new btVector3(0, 0, 0); | ||
84 | QuatIdentity = new btQuaternion(0, 0, 0, 1); | ||
85 | TransZero = new btTransform(QuatIdentity, VectorZero); | ||
86 | m_gravity = new btVector3(0, 0, gravityz); | ||
87 | _origheightmap = new float[(int)Constants.RegionSize * (int)Constants.RegionSize]; | ||
88 | } | ||
89 | |||
90 | public override void Initialise(IMesher meshmerizer, IConfigSource config) | ||
91 | { | ||
92 | mesher = meshmerizer; | ||
93 | m_config = config; | ||
94 | if (Environment.OSVersion.Platform == PlatformID.Unix) | ||
95 | { | ||
96 | m_log.Fatal("[BulletDotNET]: This configuration is not supported on *nix currently"); | ||
97 | Thread.Sleep(5000); | ||
98 | Environment.Exit(0); | ||
99 | } | ||
100 | m_broadphase = new btAxisSweep3(worldAabbMin, worldAabbMax, 16000); | ||
101 | m_collisionConfiguration = new btDefaultCollisionConfiguration(); | ||
102 | m_solver = new btSequentialImpulseConstraintSolver(); | ||
103 | m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); | ||
104 | m_world = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration); | ||
105 | m_world.setGravity(m_gravity); | ||
106 | } | ||
107 | |||
108 | public override PhysicsActor AddAvatar(string avName, PhysicsVector position, PhysicsVector size, bool isFlying) | ||
109 | { | ||
110 | BulletDotNETCharacter chr = new BulletDotNETCharacter(avName, this, position, size, avPIDD, avPIDP, | ||
111 | avCapRadius, avStandupTensor, avDensity, | ||
112 | avHeightFudgeFactor, avMovementDivisorWalk, | ||
113 | avMovementDivisorRun); | ||
114 | m_characters.Add(chr); | ||
115 | AddPhysicsActorTaint(chr); | ||
116 | return chr; | ||
117 | } | ||
118 | |||
119 | public override void RemoveAvatar(PhysicsActor actor) | ||
120 | { | ||
121 | BulletDotNETCharacter chr = (BulletDotNETCharacter) actor; | ||
122 | |||
123 | m_characters.Remove(chr); | ||
124 | m_world.removeRigidBody(chr.Body); | ||
125 | m_world.removeCollisionObject(chr.Body); | ||
126 | |||
127 | chr.Remove(); | ||
128 | AddPhysicsActorTaint(chr); | ||
129 | //chr = null; | ||
130 | } | ||
131 | |||
132 | public override void RemovePrim(PhysicsActor prim) | ||
133 | { | ||
134 | if (prim is BulletDotNETPrim) | ||
135 | { | ||
136 | |||
137 | BulletDotNETPrim p = (BulletDotNETPrim)prim; | ||
138 | |||
139 | p.setPrimForRemoval(); | ||
140 | AddPhysicsActorTaint(prim); | ||
141 | //RemovePrimThreadLocked(p); | ||
142 | |||
143 | } | ||
144 | } | ||
145 | |||
146 | private PhysicsActor AddPrim(String name, PhysicsVector position, PhysicsVector size, Quaternion rotation, | ||
147 | IMesh mesh, PrimitiveBaseShape pbs, bool isphysical) | ||
148 | { | ||
149 | PhysicsVector pos = new PhysicsVector(position.X, position.Y, position.Z); | ||
150 | //pos.X = position.X; | ||
151 | //pos.Y = position.Y; | ||
152 | //pos.Z = position.Z; | ||
153 | PhysicsVector siz = new PhysicsVector(); | ||
154 | siz.X = size.X; | ||
155 | siz.Y = size.Y; | ||
156 | siz.Z = size.Z; | ||
157 | Quaternion rot = rotation; | ||
158 | |||
159 | BulletDotNETPrim newPrim; | ||
160 | |||
161 | newPrim = new BulletDotNETPrim(name, this, pos, siz, rot, mesh, pbs, isphysical); | ||
162 | |||
163 | lock (m_prims) | ||
164 | m_prims.Add(newPrim); | ||
165 | |||
166 | |||
167 | return newPrim; | ||
168 | } | ||
169 | |||
170 | public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, PhysicsVector position, PhysicsVector size, Quaternion rotation) | ||
171 | { | ||
172 | return AddPrimShape(primName, pbs, position, size, rotation, false); | ||
173 | } | ||
174 | |||
175 | public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, PhysicsVector position, PhysicsVector size, Quaternion rotation, bool isPhysical) | ||
176 | { | ||
177 | PhysicsActor result; | ||
178 | IMesh mesh = null; | ||
179 | |||
180 | //switch (pbs.ProfileShape) | ||
181 | //{ | ||
182 | // case ProfileShape.Square: | ||
183 | // //support simple box & hollow box now; later, more shapes | ||
184 | // if (needsMeshing(pbs)) | ||
185 | // { | ||
186 | // mesh = mesher.CreateMesh(primName, pbs, size, 32f, isPhysical); | ||
187 | // } | ||
188 | |||
189 | // break; | ||
190 | //} | ||
191 | |||
192 | if (needsMeshing(pbs)) | ||
193 | mesh = mesher.CreateMesh(primName, pbs, size, 32f, isPhysical); | ||
194 | |||
195 | result = AddPrim(primName, position, size, rotation, mesh, pbs, isPhysical); | ||
196 | |||
197 | return result; | ||
198 | } | ||
199 | |||
200 | public override void AddPhysicsActorTaint(PhysicsActor prim) | ||
201 | { | ||
202 | lock (m_taintedActors) | ||
203 | { | ||
204 | if (!m_taintedActors.Contains(prim)) | ||
205 | { | ||
206 | m_taintedActors.Add(prim); | ||
207 | } | ||
208 | } | ||
209 | } | ||
210 | internal void SetUsingGImpact() | ||
211 | { | ||
212 | if (!usingGImpactAlgorithm) | ||
213 | btGImpactCollisionAlgorithm.registerAlgorithm(m_dispatcher); | ||
214 | usingGImpactAlgorithm = true; | ||
215 | } | ||
216 | |||
217 | public override float Simulate(float timeStep) | ||
218 | { | ||
219 | lock (m_taintedActors) | ||
220 | { | ||
221 | foreach (PhysicsActor act in m_taintedActors) | ||
222 | { | ||
223 | if (act is BulletDotNETCharacter) | ||
224 | ((BulletDotNETCharacter) act).ProcessTaints(timeStep); | ||
225 | if (act is BulletDotNETPrim) | ||
226 | ((BulletDotNETPrim)act).ProcessTaints(timeStep); | ||
227 | } | ||
228 | m_taintedActors.Clear(); | ||
229 | } | ||
230 | |||
231 | lock (m_characters) | ||
232 | { | ||
233 | foreach (BulletDotNETCharacter chr in m_characters) | ||
234 | { | ||
235 | chr.Move(timeStep); | ||
236 | } | ||
237 | } | ||
238 | |||
239 | lock (m_prims) | ||
240 | { | ||
241 | foreach (BulletDotNETPrim prim in m_prims) | ||
242 | { | ||
243 | prim.Move(timeStep); | ||
244 | } | ||
245 | } | ||
246 | float steps = m_world.stepSimulation(WorldTimeStep, 5, WorldTimeComp); | ||
247 | |||
248 | foreach (BulletDotNETCharacter chr in m_characters) | ||
249 | { | ||
250 | chr.UpdatePositionAndVelocity(); | ||
251 | } | ||
252 | |||
253 | foreach (BulletDotNETPrim prm in m_activePrims) | ||
254 | { | ||
255 | prm.UpdatePositionAndVelocity(); | ||
256 | } | ||
257 | |||
258 | return steps; | ||
259 | } | ||
260 | |||
261 | public override void GetResults() | ||
262 | { | ||
263 | |||
264 | } | ||
265 | |||
266 | public override void SetTerrain(float[] heightMap) | ||
267 | { | ||
268 | if (m_terrainShape != null) | ||
269 | DeleteTerrain(); | ||
270 | |||
271 | float hfmax = -9000; | ||
272 | float hfmin = 90000; | ||
273 | |||
274 | for (int i = 0; i <heightMap.Length;i++) | ||
275 | { | ||
276 | if (Single.IsNaN(heightMap[i]) || Single.IsInfinity(heightMap[i])) | ||
277 | { | ||
278 | heightMap[i] = 0f; | ||
279 | } | ||
280 | |||
281 | hfmin = (heightMap[i] < hfmin) ? heightMap[i] : hfmin; | ||
282 | hfmax = (heightMap[i] > hfmax) ? heightMap[i] : hfmax; | ||
283 | } | ||
284 | // store this for later reference. | ||
285 | // Note, we're storing it after we check it for anomolies above | ||
286 | _origheightmap = heightMap; | ||
287 | |||
288 | hfmin = 0; | ||
289 | hfmax = 256; | ||
290 | |||
291 | m_terrainShape = new btHeightfieldTerrainShape((int)Constants.RegionSize, (int)Constants.RegionSize, heightMap, | ||
292 | 1.0f, hfmin, hfmax, (int)btHeightfieldTerrainShape.UPAxis.Z, | ||
293 | (int)btHeightfieldTerrainShape.PHY_ScalarType.PHY_FLOAT, false); | ||
294 | float AabbCenterX = Constants.RegionSize/2f; | ||
295 | float AabbCenterY = Constants.RegionSize/2f; | ||
296 | |||
297 | float AabbCenterZ = 0; | ||
298 | float temphfmin, temphfmax; | ||
299 | |||
300 | temphfmin = hfmin; | ||
301 | temphfmax = hfmax; | ||
302 | |||
303 | if (temphfmin < 0) | ||
304 | { | ||
305 | temphfmax = 0 - temphfmin; | ||
306 | temphfmin = 0 - temphfmin; | ||
307 | } | ||
308 | else if (temphfmin > 0) | ||
309 | { | ||
310 | temphfmax = temphfmax + (0 - temphfmin); | ||
311 | //temphfmin = temphfmin + (0 - temphfmin); | ||
312 | } | ||
313 | AabbCenterZ = temphfmax/2f; | ||
314 | |||
315 | if (m_terrainPosition == null) | ||
316 | { | ||
317 | m_terrainPosition = new btVector3(AabbCenterX, AabbCenterY, AabbCenterZ); | ||
318 | } | ||
319 | else | ||
320 | { | ||
321 | try | ||
322 | { | ||
323 | m_terrainPosition.setValue(AabbCenterX, AabbCenterY, AabbCenterZ); | ||
324 | } | ||
325 | catch (ObjectDisposedException) | ||
326 | { | ||
327 | m_terrainPosition = new btVector3(AabbCenterX, AabbCenterY, AabbCenterZ); | ||
328 | } | ||
329 | } | ||
330 | if (m_terrainMotionState != null) | ||
331 | { | ||
332 | m_terrainMotionState.Dispose(); | ||
333 | m_terrainMotionState = null; | ||
334 | } | ||
335 | m_terrainTransform = new btTransform(QuatIdentity, m_terrainPosition); | ||
336 | m_terrainMotionState = new btDefaultMotionState(m_terrainTransform); | ||
337 | TerrainBody = new btRigidBody(0, m_terrainMotionState, m_terrainShape); | ||
338 | m_world.addRigidBody(TerrainBody); | ||
339 | |||
340 | |||
341 | } | ||
342 | |||
343 | public override void SetWaterLevel(float baseheight) | ||
344 | { | ||
345 | |||
346 | } | ||
347 | |||
348 | public override void DeleteTerrain() | ||
349 | { | ||
350 | if (TerrainBody != null) | ||
351 | { | ||
352 | m_world.removeRigidBody(TerrainBody); | ||
353 | } | ||
354 | |||
355 | if (m_terrainShape != null) | ||
356 | { | ||
357 | m_terrainShape.Dispose(); | ||
358 | m_terrainShape = null; | ||
359 | } | ||
360 | |||
361 | if (m_terrainMotionState != null) | ||
362 | { | ||
363 | m_terrainMotionState.Dispose(); | ||
364 | m_terrainMotionState = null; | ||
365 | } | ||
366 | |||
367 | if (m_terrainTransform != null) | ||
368 | { | ||
369 | m_terrainTransform.Dispose(); | ||
370 | m_terrainTransform = null; | ||
371 | } | ||
372 | |||
373 | if (m_terrainPosition != null) | ||
374 | { | ||
375 | m_terrainPosition.Dispose(); | ||
376 | m_terrainPosition = null; | ||
377 | } | ||
378 | } | ||
379 | |||
380 | public override void Dispose() | ||
381 | { | ||
382 | disposeAllBodies(); | ||
383 | m_world.Dispose(); | ||
384 | m_broadphase.Dispose(); | ||
385 | ((btDefaultCollisionConfiguration) m_collisionConfiguration).Dispose(); | ||
386 | ((btSequentialImpulseConstraintSolver) m_solver).Dispose(); | ||
387 | worldAabbMax.Dispose(); | ||
388 | worldAabbMin.Dispose(); | ||
389 | VectorZero.Dispose(); | ||
390 | QuatIdentity.Dispose(); | ||
391 | m_gravity.Dispose(); | ||
392 | VectorZero = null; | ||
393 | QuatIdentity = null; | ||
394 | } | ||
395 | |||
396 | public override Dictionary<uint, float> GetTopColliders() | ||
397 | { | ||
398 | return new Dictionary<uint, float>(); | ||
399 | } | ||
400 | |||
401 | public btDiscreteDynamicsWorld getBulletWorld() | ||
402 | { | ||
403 | return m_world; | ||
404 | } | ||
405 | |||
406 | private void disposeAllBodies() | ||
407 | { | ||
408 | lock (m_prims) | ||
409 | { | ||
410 | foreach ( BulletDotNETPrim prim in m_prims) | ||
411 | { | ||
412 | if (prim.Body != null) | ||
413 | m_world.removeRigidBody(prim.Body); | ||
414 | |||
415 | prim.Dispose(); | ||
416 | } | ||
417 | m_prims.Clear(); | ||
418 | |||
419 | foreach (BulletDotNETCharacter chr in m_characters) | ||
420 | { | ||
421 | if (chr.Body != null) | ||
422 | m_world.removeRigidBody(chr.Body); | ||
423 | chr.Dispose(); | ||
424 | } | ||
425 | m_characters.Clear(); | ||
426 | } | ||
427 | } | ||
428 | |||
429 | public override bool IsThreaded | ||
430 | { | ||
431 | get { return false; } | ||
432 | } | ||
433 | |||
434 | internal void addCollisionEventReporting(PhysicsActor bulletDotNETCharacter) | ||
435 | { | ||
436 | //TODO: FIXME: | ||
437 | } | ||
438 | |||
439 | internal void remCollisionEventReporting(PhysicsActor bulletDotNETCharacter) | ||
440 | { | ||
441 | //TODO: FIXME: | ||
442 | } | ||
443 | |||
444 | internal void AddRigidBody(btRigidBody Body) | ||
445 | { | ||
446 | m_world.addRigidBody(Body); | ||
447 | } | ||
448 | [Obsolete("bad!")] | ||
449 | internal void removeFromWorld(btRigidBody body) | ||
450 | { | ||
451 | |||
452 | m_world.removeRigidBody(body); | ||
453 | } | ||
454 | |||
455 | internal void removeFromWorld(BulletDotNETPrim prm ,btRigidBody body) | ||
456 | { | ||
457 | lock (m_prims) | ||
458 | { | ||
459 | if (m_prims.Contains(prm)) | ||
460 | { | ||
461 | m_world.removeRigidBody(body); | ||
462 | } | ||
463 | m_prims.Remove(prm); | ||
464 | } | ||
465 | |||
466 | } | ||
467 | |||
468 | internal float GetWaterLevel() | ||
469 | { | ||
470 | throw new NotImplementedException(); | ||
471 | } | ||
472 | |||
473 | // Recovered for use by fly height. Kitto Flora | ||
474 | public float GetTerrainHeightAtXY(float x, float y) | ||
475 | { | ||
476 | // Teravus: Kitto, this code causes recurring errors that stall physics permenantly unless | ||
477 | // the values are checked, so checking below. | ||
478 | // Is there any reason that we don't do this in ScenePresence? | ||
479 | // The only physics engine that benefits from it in the physics plugin is this one | ||
480 | |||
481 | if ((int)x > Constants.RegionSize || (int)y > Constants.RegionSize || | ||
482 | (int)x < 0.001f || (int)y < 0.001f) | ||
483 | return 0; | ||
484 | |||
485 | return _origheightmap[(int)y * Constants.RegionSize + (int)x]; | ||
486 | } | ||
487 | // End recovered. Kitto Flora | ||
488 | |||
489 | /// <summary> | ||
490 | /// Routine to figure out if we need to mesh this prim with our mesher | ||
491 | /// </summary> | ||
492 | /// <param name="pbs"></param> | ||
493 | /// <returns></returns> | ||
494 | public bool needsMeshing(PrimitiveBaseShape pbs) | ||
495 | { | ||
496 | // most of this is redundant now as the mesher will return null if it cant mesh a prim | ||
497 | // but we still need to check for sculptie meshing being enabled so this is the most | ||
498 | // convenient place to do it for now... | ||
499 | |||
500 | // //if (pbs.PathCurve == (byte)Primitive.PathCurve.Circle && pbs.ProfileCurve == (byte)Primitive.ProfileCurve.Circle && pbs.PathScaleY <= 0.75f) | ||
501 | // //m_log.Debug("needsMeshing: " + " pathCurve: " + pbs.PathCurve.ToString() + " profileCurve: " + pbs.ProfileCurve.ToString() + " pathScaleY: " + Primitive.UnpackPathScale(pbs.PathScaleY).ToString()); | ||
502 | int iPropertiesNotSupportedDefault = 0; | ||
503 | |||
504 | if (pbs.SculptEntry && !meshSculptedPrim) | ||
505 | { | ||
506 | #if SPAM | ||
507 | m_log.Warn("NonMesh"); | ||
508 | #endif | ||
509 | return false; | ||
510 | } | ||
511 | |||
512 | // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since ODE can use an internal representation for the prim | ||
513 | if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight) | ||
514 | || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 | ||
515 | && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z)) | ||
516 | { | ||
517 | |||
518 | if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0 | ||
519 | && pbs.ProfileHollow == 0 | ||
520 | && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0 | ||
521 | && pbs.PathBegin == 0 && pbs.PathEnd == 0 | ||
522 | && pbs.PathTaperX == 0 && pbs.PathTaperY == 0 | ||
523 | && pbs.PathScaleX == 100 && pbs.PathScaleY == 100 | ||
524 | && pbs.PathShearX == 0 && pbs.PathShearY == 0) | ||
525 | { | ||
526 | #if SPAM | ||
527 | m_log.Warn("NonMesh"); | ||
528 | #endif | ||
529 | return false; | ||
530 | } | ||
531 | } | ||
532 | |||
533 | if (pbs.ProfileHollow != 0) | ||
534 | iPropertiesNotSupportedDefault++; | ||
535 | |||
536 | if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0)) | ||
537 | iPropertiesNotSupportedDefault++; | ||
538 | |||
539 | if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0) | ||
540 | iPropertiesNotSupportedDefault++; | ||
541 | |||
542 | if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100)) | ||
543 | iPropertiesNotSupportedDefault++; | ||
544 | |||
545 | if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0)) | ||
546 | iPropertiesNotSupportedDefault++; | ||
547 | |||
548 | if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight) | ||
549 | iPropertiesNotSupportedDefault++; | ||
550 | |||
551 | if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 && (pbs.Scale.X != pbs.Scale.Y || pbs.Scale.Y != pbs.Scale.Z || pbs.Scale.Z != pbs.Scale.X)) | ||
552 | iPropertiesNotSupportedDefault++; | ||
553 | |||
554 | if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1) | ||
555 | iPropertiesNotSupportedDefault++; | ||
556 | |||
557 | // test for torus | ||
558 | if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square) | ||
559 | { | ||
560 | if (pbs.PathCurve == (byte)Extrusion.Curve1) | ||
561 | { | ||
562 | iPropertiesNotSupportedDefault++; | ||
563 | } | ||
564 | } | ||
565 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle) | ||
566 | { | ||
567 | if (pbs.PathCurve == (byte)Extrusion.Straight) | ||
568 | { | ||
569 | iPropertiesNotSupportedDefault++; | ||
570 | } | ||
571 | |||
572 | // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits | ||
573 | else if (pbs.PathCurve == (byte)Extrusion.Curve1) | ||
574 | { | ||
575 | iPropertiesNotSupportedDefault++; | ||
576 | } | ||
577 | } | ||
578 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle) | ||
579 | { | ||
580 | if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2) | ||
581 | { | ||
582 | iPropertiesNotSupportedDefault++; | ||
583 | } | ||
584 | } | ||
585 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle) | ||
586 | { | ||
587 | if (pbs.PathCurve == (byte)Extrusion.Straight) | ||
588 | { | ||
589 | iPropertiesNotSupportedDefault++; | ||
590 | } | ||
591 | else if (pbs.PathCurve == (byte)Extrusion.Curve1) | ||
592 | { | ||
593 | iPropertiesNotSupportedDefault++; | ||
594 | } | ||
595 | } | ||
596 | |||
597 | |||
598 | if (iPropertiesNotSupportedDefault == 0) | ||
599 | { | ||
600 | #if SPAM | ||
601 | m_log.Warn("NonMesh"); | ||
602 | #endif | ||
603 | return false; | ||
604 | } | ||
605 | #if SPAM | ||
606 | m_log.Debug("Mesh"); | ||
607 | #endif | ||
608 | return true; | ||
609 | } | ||
610 | |||
611 | internal void addActivePrim(BulletDotNETPrim pPrim) | ||
612 | { | ||
613 | lock (m_activePrims) | ||
614 | { | ||
615 | if (!m_activePrims.Contains(pPrim)) | ||
616 | { | ||
617 | m_activePrims.Add(pPrim); | ||
618 | } | ||
619 | } | ||
620 | } | ||
621 | |||
622 | public void remActivePrim(BulletDotNETPrim pDeactivatePrim) | ||
623 | { | ||
624 | lock (m_activePrims) | ||
625 | { | ||
626 | m_activePrims.Remove(pDeactivatePrim); | ||
627 | } | ||
628 | } | ||
629 | |||
630 | internal void AddPrimToScene(BulletDotNETPrim pPrim) | ||
631 | { | ||
632 | lock (m_prims) | ||
633 | { | ||
634 | if (!m_prims.Contains(pPrim)) | ||
635 | { | ||
636 | m_prims.Add(pPrim); | ||
637 | m_world.addRigidBody(pPrim.Body); | ||
638 | } | ||
639 | } | ||
640 | } | ||
641 | } | ||
642 | } | ||
diff --git a/bin/BulletDotNET.dll b/bin/BulletDotNET.dll new file mode 100644 index 0000000..0696183 --- /dev/null +++ b/bin/BulletDotNET.dll | |||
Binary files differ | |||
diff --git a/bin/BulletDotNET.pdb b/bin/BulletDotNET.pdb new file mode 100644 index 0000000..53a7904 --- /dev/null +++ b/bin/BulletDotNET.pdb | |||
Binary files differ | |||
diff --git a/bin/libbulletnet.dll b/bin/libbulletnet.dll new file mode 100644 index 0000000..f2f9c65 --- /dev/null +++ b/bin/libbulletnet.dll | |||
Binary files differ | |||
diff --git a/bin/libbulletnet.so b/bin/libbulletnet.so new file mode 100644 index 0000000..7530cdb --- /dev/null +++ b/bin/libbulletnet.so | |||
Binary files differ | |||
diff --git a/prebuild.xml b/prebuild.xml index 3acb6d4..ca1a533 100644 --- a/prebuild.xml +++ b/prebuild.xml | |||
@@ -504,6 +504,34 @@ | |||
504 | </Files> | 504 | </Files> |
505 | </Project> | 505 | </Project> |
506 | 506 | ||
507 | <Project name="OpenSim.Region.Physics.BulletDotNETPlugin" path="OpenSim/Region/Physics/BulletDotNETPlugin" type="Library"> | ||
508 | <Configuration name="Debug"> | ||
509 | <Options> | ||
510 | <OutputPath>../../../../bin/Physics/</OutputPath> | ||
511 | </Options> | ||
512 | </Configuration> | ||
513 | <Configuration name="Release"> | ||
514 | <Options> | ||
515 | <OutputPath>../../../../bin/Physics/</OutputPath> | ||
516 | </Options> | ||
517 | </Configuration> | ||
518 | |||
519 | <ReferencePath>../../../../bin/</ReferencePath> | ||
520 | <Reference name="System"/> | ||
521 | <Reference name="OpenMetaverseTypes.dll"/> | ||
522 | <Reference name="Nini.dll" /> | ||
523 | <Reference name="OpenSim.Framework"/> | ||
524 | <Reference name="OpenSim.Framework.Console"/> | ||
525 | <Reference name="OpenSim.Region.Physics.Manager"/> | ||
526 | <Reference name="BulletDotNET.dll" /> | ||
527 | <Reference name="nunit.framework.dll" /> | ||
528 | <Reference name="log4net.dll"/> | ||
529 | |||
530 | <Files> | ||
531 | <Match pattern="*.cs" recurse="true"/> | ||
532 | </Files> | ||
533 | </Project> | ||
534 | |||
507 | <Project name="OpenSim.Region.Physics.Meshing" path="OpenSim/Region/Physics/Meshing" type="Library"> | 535 | <Project name="OpenSim.Region.Physics.Meshing" path="OpenSim/Region/Physics/Meshing" type="Library"> |
508 | <Configuration name="Debug"> | 536 | <Configuration name="Debug"> |
509 | <Options> | 537 | <Options> |