aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/Physics/ChOdePlugin
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/Physics/ChOdePlugin')
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/AssemblyInfo.cs58
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/ODECharacter.cs1353
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.c_comments630
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.cs673
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/ODEPrim.cs3273
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/ODERayCastRequestManager.cs375
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/OdePhysicsJoint.cs48
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs3865
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/Tests/ODETestClass.cs122
-rw-r--r--OpenSim/Region/Physics/ChOdePlugin/drawstuff.cs98
10 files changed, 10495 insertions, 0 deletions
diff --git a/OpenSim/Region/Physics/ChOdePlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/ChOdePlugin/AssemblyInfo.cs
new file mode 100644
index 0000000..d65929a
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/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 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
28using System.Reflection;
29using 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("OdePlugin")]
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.5.*")]
diff --git a/OpenSim/Region/Physics/ChOdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/ChOdePlugin/ODECharacter.cs
new file mode 100644
index 0000000..aa0acb7
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/ODECharacter.cs
@@ -0,0 +1,1353 @@
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
28using System;
29using System.Collections.Generic;
30using System.Reflection;
31using OpenMetaverse;
32using Ode.NET;
33using OpenSim.Framework;
34using OpenSim.Region.Physics.Manager;
35using log4net;
36
37namespace OpenSim.Region.Physics.OdePlugin
38{
39 /// <summary>
40 /// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
41 /// </summary>
42
43 public enum dParam : int
44 {
45 LowStop = 0,
46 HiStop = 1,
47 Vel = 2,
48 FMax = 3,
49 FudgeFactor = 4,
50 Bounce = 5,
51 CFM = 6,
52 StopERP = 7,
53 StopCFM = 8,
54 LoStop2 = 256,
55 HiStop2 = 257,
56 Vel2 = 258,
57 FMax2 = 259,
58 StopERP2 = 7 + 256,
59 StopCFM2 = 8 + 256,
60 LoStop3 = 512,
61 HiStop3 = 513,
62 Vel3 = 514,
63 FMax3 = 515,
64 StopERP3 = 7 + 512,
65 StopCFM3 = 8 + 512
66 }
67 public class OdeCharacter : PhysicsActor
68 {
69 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
70
71 private Vector3 _position;
72 private d.Vector3 _zeroPosition;
73 // private d.Matrix3 m_StandUpRotation;
74 private bool _zeroFlag = false;
75 private bool m_lastUpdateSent = false;
76 private Vector3 _velocity;
77 private Vector3 _target_velocity;
78 private Vector3 _acceleration;
79 private Vector3 m_rotationalVelocity;
80 private float m_mass = 80f;
81 public float m_density = 60f;
82 private bool m_pidControllerActive = true;
83 public float PID_D = 800.0f;
84 public float PID_P = 900.0f;
85 //private static float POSTURE_SERVO = 10000.0f;
86 public float CAPSULE_RADIUS = 0.37f;
87 public float CAPSULE_LENGTH = 2.140599f;
88 public float m_tensor = 3800000f;
89 public float heightFudgeFactor = 0.52f;
90 public float walkDivisor = 1.3f;
91 public float runDivisor = 0.8f;
92 private bool flying = false;
93 private bool m_iscolliding = false;
94 private bool m_iscollidingGround = false;
95 private bool m_wascolliding = false;
96 private bool m_wascollidingGround = false;
97 private bool m_iscollidingObj = false;
98 private bool m_alwaysRun = false;
99 private bool m_hackSentFall = false;
100 private bool m_hackSentFly = false;
101 private int m_requestedUpdateFrequency = 0;
102 private Vector3 m_taintPosition = Vector3.Zero;
103 public uint m_localID = 0;
104 public bool m_returnCollisions = false;
105 // taints and their non-tainted counterparts
106 public bool m_isPhysical = false; // the current physical status
107 public bool m_tainted_isPhysical = false; // set when the physical status is tainted (false=not existing in physics engine, true=existing)
108 public float MinimumGroundFlightOffset = 3f;
109
110 private float m_tainted_CAPSULE_LENGTH; // set when the capsule length changes.
111 private float m_tiltMagnitudeWhenProjectedOnXYPlane = 0.1131371f; // used to introduce a fixed tilt because a straight-up capsule falls through terrain, probably a bug in terrain collider
112
113
114 private float m_buoyancy = 0f;
115
116 // private CollisionLocker ode;
117
118 private string m_name = String.Empty;
119
120 private bool[] m_colliderarr = new bool[11];
121 private bool[] m_colliderGroundarr = new bool[11];
122
123 // Default we're a Character
124 private CollisionCategories m_collisionCategories = (CollisionCategories.Character);
125
126 // Default, Collide with Other Geometries, spaces, bodies and characters.
127 private CollisionCategories m_collisionFlags = (CollisionCategories.Geom
128 | CollisionCategories.Space
129 | CollisionCategories.Body
130 | CollisionCategories.Character
131 | CollisionCategories.Land);
132 public IntPtr Body = IntPtr.Zero;
133 private OdeScene _parent_scene;
134 public IntPtr Shell = IntPtr.Zero;
135 public IntPtr Amotor = IntPtr.Zero;
136 public d.Mass ShellMass;
137 public bool collidelock = false;
138
139 public int m_eventsubscription = 0;
140 private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate();
141
142 // unique UUID of this character object
143 public UUID m_uuid;
144 public bool bad = false;
145
146 public OdeCharacter(String avName, OdeScene parent_scene, Vector3 pos, CollisionLocker dode, Vector3 size, float pid_d, float pid_p, float capsule_radius, float tensor, float density, float height_fudge_factor, float walk_divisor, float rundivisor)
147 {
148 m_uuid = UUID.Random();
149
150 if (pos.IsFinite())
151 {
152 if (pos.Z > 9999999f)
153 {
154 pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
155 }
156 if (pos.Z < -90000f)
157 {
158 pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
159 }
160 _position = pos;
161 m_taintPosition.X = pos.X;
162 m_taintPosition.Y = pos.Y;
163 m_taintPosition.Z = pos.Z;
164 }
165 else
166 {
167 _position = new Vector3(((float)_parent_scene.WorldExtents.X * 0.5f), ((float)_parent_scene.WorldExtents.Y * 0.5f), parent_scene.GetTerrainHeightAtXY(128f, 128f) + 10f);
168 m_taintPosition.X = _position.X;
169 m_taintPosition.Y = _position.Y;
170 m_taintPosition.Z = _position.Z;
171 m_log.Warn("[PHYSICS]: Got NaN Position on Character Create");
172 }
173
174 _parent_scene = parent_scene;
175
176 PID_D = pid_d;
177 PID_P = pid_p;
178 CAPSULE_RADIUS = capsule_radius;
179 m_tensor = tensor;
180 m_density = density;
181 heightFudgeFactor = height_fudge_factor;
182 walkDivisor = walk_divisor;
183 runDivisor = rundivisor;
184
185 // m_StandUpRotation =
186 // new d.Matrix3(0.5f, 0.7071068f, 0.5f, -0.7071068f, 0f, 0.7071068f, 0.5f, -0.7071068f,
187 // 0.5f);
188
189 for (int i = 0; i < 11; i++)
190 {
191 m_colliderarr[i] = false;
192 }
193 CAPSULE_LENGTH = (size.Z * 1.15f) - CAPSULE_RADIUS * 2.0f;
194 //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString());
195 m_tainted_CAPSULE_LENGTH = CAPSULE_LENGTH;
196
197 m_isPhysical = false; // current status: no ODE information exists
198 m_tainted_isPhysical = true; // new tainted status: need to create ODE information
199
200 _parent_scene.AddPhysicsActorTaint(this);
201
202 m_name = avName;
203 }
204
205 public override int PhysicsActorType
206 {
207 get { return (int) ActorTypes.Agent; }
208 set { return; }
209 }
210
211 /// <summary>
212 /// If this is set, the avatar will move faster
213 /// </summary>
214 public override bool SetAlwaysRun
215 {
216 get { return m_alwaysRun; }
217 set { m_alwaysRun = value; }
218 }
219
220 public override uint LocalID
221 {
222 set { m_localID = value; }
223 }
224
225 public override bool Grabbed
226 {
227 set { return; }
228 }
229
230 public override bool Selected
231 {
232 set { return; }
233 }
234
235 public override float Buoyancy
236 {
237 get { return m_buoyancy; }
238 set { m_buoyancy = value; }
239 }
240
241 public override bool FloatOnWater
242 {
243 set { return; }
244 }
245
246 public override bool IsPhysical
247 {
248 get { return false; }
249 set { return; }
250 }
251
252 public override bool ThrottleUpdates
253 {
254 get { return false; }
255 set { return; }
256 }
257
258 public override bool Flying
259 {
260 get { return flying; }
261 set { flying = value; }
262 }
263
264 /// <summary>
265 /// Returns if the avatar is colliding in general.
266 /// This includes the ground and objects and avatar.
267 /// </summary>
268 public override bool IsColliding
269 {
270 get { return m_iscolliding; }
271 set
272 {
273 int i;
274 int truecount = 0;
275 int falsecount = 0;
276
277 if (m_colliderarr.Length >= 10)
278 {
279 for (i = 0; i < 10; i++)
280 {
281 m_colliderarr[i] = m_colliderarr[i + 1];
282 }
283 }
284 m_colliderarr[10] = value;
285
286 for (i = 0; i < 11; i++)
287 {
288 if (m_colliderarr[i])
289 {
290 truecount++;
291 }
292 else
293 {
294 falsecount++;
295 }
296 }
297
298 // Equal truecounts and false counts means we're colliding with something.
299
300 if (falsecount > 1.2*truecount)
301 {
302 m_iscolliding = false;
303 }
304 else
305 {
306 m_iscolliding = true;
307 }
308 if (m_wascolliding != m_iscolliding)
309 {
310 //base.SendCollisionUpdate(new CollisionEventUpdate());
311 }
312 m_wascolliding = m_iscolliding;
313 }
314 }
315
316 /// <summary>
317 /// Returns if an avatar is colliding with the ground
318 /// </summary>
319 public override bool CollidingGround
320 {
321 get { return m_iscollidingGround; }
322 set
323 {
324 // Collisions against the ground are not really reliable
325 // So, to get a consistant value we have to average the current result over time
326 // Currently we use 1 second = 10 calls to this.
327 int i;
328 int truecount = 0;
329 int falsecount = 0;
330
331 if (m_colliderGroundarr.Length >= 10)
332 {
333 for (i = 0; i < 10; i++)
334 {
335 m_colliderGroundarr[i] = m_colliderGroundarr[i + 1];
336 }
337 }
338 m_colliderGroundarr[10] = value;
339
340 for (i = 0; i < 11; i++)
341 {
342 if (m_colliderGroundarr[i])
343 {
344 truecount++;
345 }
346 else
347 {
348 falsecount++;
349 }
350 }
351
352 // Equal truecounts and false counts means we're colliding with something.
353
354 if (falsecount > 1.2*truecount)
355 {
356 m_iscollidingGround = false;
357 }
358 else
359 {
360 m_iscollidingGround = true;
361 }
362 if (m_wascollidingGround != m_iscollidingGround)
363 {
364 //base.SendCollisionUpdate(new CollisionEventUpdate());
365 }
366 m_wascollidingGround = m_iscollidingGround;
367 }
368 }
369
370 /// <summary>
371 /// Returns if the avatar is colliding with an object
372 /// </summary>
373 public override bool CollidingObj
374 {
375 get { return m_iscollidingObj; }
376 set
377 {
378 m_iscollidingObj = value;
379 if (value)
380 m_pidControllerActive = false;
381 else
382 m_pidControllerActive = true;
383 }
384 }
385
386 /// <summary>
387 /// turn the PID controller on or off.
388 /// The PID Controller will turn on all by itself in many situations
389 /// </summary>
390 /// <param name="status"></param>
391 public void SetPidStatus(bool status)
392 {
393 m_pidControllerActive = status;
394 }
395
396 public override bool Stopped
397 {
398 get { return _zeroFlag; }
399 }
400
401 /// <summary>
402 /// This 'puts' an avatar somewhere in the physics space.
403 /// Not really a good choice unless you 'know' it's a good
404 /// spot otherwise you're likely to orbit the avatar.
405 /// </summary>
406 public override Vector3 Position
407 {
408 get { return _position; }
409 set
410 {
411 if (Body == IntPtr.Zero || Shell == IntPtr.Zero)
412 {
413 if (value.IsFinite())
414 {
415 if (value.Z > 9999999f)
416 {
417 value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
418 }
419 if (value.Z < -90000f)
420 {
421 value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
422 }
423
424 _position.X = value.X;
425 _position.Y = value.Y;
426 _position.Z = value.Z;
427
428 m_taintPosition.X = value.X;
429 m_taintPosition.Y = value.Y;
430 m_taintPosition.Z = value.Z;
431 _parent_scene.AddPhysicsActorTaint(this);
432 }
433 else
434 {
435 m_log.Warn("[PHYSICS]: Got a NaN Position from Scene on a Character");
436 }
437 }
438 }
439 }
440
441 public override Vector3 RotationalVelocity
442 {
443 get { return m_rotationalVelocity; }
444 set { m_rotationalVelocity = value; }
445 }
446
447 /// <summary>
448 /// This property sets the height of the avatar only. We use the height to make sure the avatar stands up straight
449 /// and use it to offset landings properly
450 /// </summary>
451 public override Vector3 Size
452 {
453 get { return new Vector3(CAPSULE_RADIUS * 2, CAPSULE_RADIUS * 2, CAPSULE_LENGTH); }
454 set
455 {
456 if (value.IsFinite())
457 {
458 m_pidControllerActive = true;
459
460 Vector3 SetSize = value;
461 m_tainted_CAPSULE_LENGTH = (SetSize.Z*1.15f) - CAPSULE_RADIUS*2.0f;
462 //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString());
463
464 Velocity = Vector3.Zero;
465
466 _parent_scene.AddPhysicsActorTaint(this);
467 }
468 else
469 {
470 m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
471 }
472 }
473 }
474
475 private void AlignAvatarTiltWithCurrentDirectionOfMovement(Vector3 movementVector)
476 {
477 movementVector.Z = 0f;
478 float magnitude = (float)Math.Sqrt((double)(movementVector.X * movementVector.X + movementVector.Y * movementVector.Y));
479 if (magnitude < 0.1f) return;
480
481 // normalize the velocity vector
482 float invMagnitude = 1.0f / magnitude;
483 movementVector.X *= invMagnitude;
484 movementVector.Y *= invMagnitude;
485
486 // if we change the capsule heading too often, the capsule can fall down
487 // therefore we snap movement vector to just 1 of 4 predefined directions (ne, nw, se, sw),
488 // meaning only 4 possible capsule tilt orientations
489 if (movementVector.X > 0)
490 {
491 // east
492 if (movementVector.Y > 0)
493 {
494 // northeast
495 movementVector.X = (float)Math.Sqrt(2.0);
496 movementVector.Y = (float)Math.Sqrt(2.0);
497 }
498 else
499 {
500 // southeast
501 movementVector.X = (float)Math.Sqrt(2.0);
502 movementVector.Y = -(float)Math.Sqrt(2.0);
503 }
504 }
505 else
506 {
507 // west
508 if (movementVector.Y > 0)
509 {
510 // northwest
511 movementVector.X = -(float)Math.Sqrt(2.0);
512 movementVector.Y = (float)Math.Sqrt(2.0);
513 }
514 else
515 {
516 // southwest
517 movementVector.X = -(float)Math.Sqrt(2.0);
518 movementVector.Y = -(float)Math.Sqrt(2.0);
519 }
520 }
521
522
523 // movementVector.Z is zero
524
525 // calculate tilt components based on desired amount of tilt and current (snapped) heading.
526 // the "-" sign is to force the tilt to be OPPOSITE the direction of movement.
527 float xTiltComponent = -movementVector.X * m_tiltMagnitudeWhenProjectedOnXYPlane;
528 float yTiltComponent = -movementVector.Y * m_tiltMagnitudeWhenProjectedOnXYPlane;
529
530 //m_log.Debug("[PHYSICS] changing avatar tilt");
531 d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, xTiltComponent);
532 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, xTiltComponent); // must be same as lowstop, else a different, spurious tilt is introduced
533 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, yTiltComponent);
534 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, yTiltComponent); // same as lowstop
535 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, 0f);
536 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0f); // same as lowstop
537 }
538
539 /// <summary>
540 /// This creates the Avatar's physical Surrogate at the position supplied
541 /// </summary>
542 /// <param name="npositionX"></param>
543 /// <param name="npositionY"></param>
544 /// <param name="npositionZ"></param>
545
546 // WARNING: This MUST NOT be called outside of ProcessTaints, else we can have unsynchronized access
547 // to ODE internals. ProcessTaints is called from within thread-locked Simulate(), so it is the only
548 // place that is safe to call this routine AvatarGeomAndBodyCreation.
549 private void AvatarGeomAndBodyCreation(float npositionX, float npositionY, float npositionZ, float tensor)
550 {
551 //CAPSULE_LENGTH = -5;
552 //CAPSULE_RADIUS = -5;
553 int dAMotorEuler = 1;
554 _parent_scene.waitForSpaceUnlock(_parent_scene.space);
555 if (CAPSULE_LENGTH <= 0)
556 {
557 m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!");
558 CAPSULE_LENGTH = 0.01f;
559
560 }
561
562 if (CAPSULE_RADIUS <= 0)
563 {
564 m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!");
565 CAPSULE_RADIUS = 0.01f;
566
567 }
568 Shell = d.CreateCapsule(_parent_scene.space, CAPSULE_RADIUS, CAPSULE_LENGTH);
569
570 d.GeomSetCategoryBits(Shell, (int)m_collisionCategories);
571 d.GeomSetCollideBits(Shell, (int)m_collisionFlags);
572
573 d.MassSetCapsuleTotal(out ShellMass, m_mass, 2, CAPSULE_RADIUS, CAPSULE_LENGTH);
574 Body = d.BodyCreate(_parent_scene.world);
575 d.BodySetPosition(Body, npositionX, npositionY, npositionZ);
576
577 _position.X = npositionX;
578 _position.Y = npositionY;
579 _position.Z = npositionZ;
580
581
582 m_taintPosition.X = npositionX;
583 m_taintPosition.Y = npositionY;
584 m_taintPosition.Z = npositionZ;
585
586 d.BodySetMass(Body, ref ShellMass);
587 d.Matrix3 m_caprot;
588 // 90 Stand up on the cap of the capped cyllinder
589 if (_parent_scene.IsAvCapsuleTilted)
590 {
591 d.RFromAxisAndAngle(out m_caprot, 1, 0, 1, (float)(Math.PI / 2));
592 }
593 else
594 {
595 d.RFromAxisAndAngle(out m_caprot, 0, 0, 1, (float)(Math.PI / 2));
596 }
597
598
599 d.GeomSetRotation(Shell, ref m_caprot);
600 d.BodySetRotation(Body, ref m_caprot);
601
602 d.GeomSetBody(Shell, Body);
603
604
605 // The purpose of the AMotor here is to keep the avatar's physical
606 // surrogate from rotating while moving
607 Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
608 d.JointAttach(Amotor, Body, IntPtr.Zero);
609 d.JointSetAMotorMode(Amotor, dAMotorEuler);
610 d.JointSetAMotorNumAxes(Amotor, 3);
611 d.JointSetAMotorAxis(Amotor, 0, 0, 1, 0, 0);
612 d.JointSetAMotorAxis(Amotor, 1, 0, 0, 1, 0);
613 d.JointSetAMotorAxis(Amotor, 2, 0, 0, 0, 1);
614 d.JointSetAMotorAngle(Amotor, 0, 0);
615 d.JointSetAMotorAngle(Amotor, 1, 0);
616 d.JointSetAMotorAngle(Amotor, 2, 0);
617
618 // These lowstops and high stops are effectively (no wiggle room)
619 if (_parent_scene.IsAvCapsuleTilted)
620 {
621 d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -0.000000000001f);
622 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -0.000000000001f);
623 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -0.000000000001f);
624 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 0.000000000001f);
625 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0.000000000001f);
626 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 0.000000000001f);
627 }
628 else
629 {
630 #region Documentation of capsule motor LowStop and HighStop parameters
631 // Intentionally introduce some tilt into the capsule by setting
632 // the motor stops to small epsilon values. This small tilt prevents
633 // the capsule from falling into the terrain; a straight-up capsule
634 // (with -0..0 motor stops) falls into the terrain for reasons yet
635 // to be comprehended in their entirety.
636 #endregion
637 AlignAvatarTiltWithCurrentDirectionOfMovement(Vector3.Zero);
638 d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, 0.08f);
639 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -0f);
640 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, 0.08f);
641 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 0.08f); // must be same as lowstop, else a different, spurious tilt is introduced
642 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0f); // same as lowstop
643 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 0.08f); // same as lowstop
644 }
645
646 // Fudge factor is 1f by default, we're setting it to 0. We don't want it to Fudge or the
647 // capped cyllinder will fall over
648 d.JointSetAMotorParam(Amotor, (int)dParam.FudgeFactor, 0f);
649 d.JointSetAMotorParam(Amotor, (int)dParam.FMax, tensor);
650
651 //d.Matrix3 bodyrotation = d.BodyGetRotation(Body);
652 //d.QfromR(
653 //d.Matrix3 checkrotation = new d.Matrix3(0.7071068,0.5, -0.7071068,
654 //
655 //m_log.Info("[PHYSICSAV]: Rotation: " + bodyrotation.M00 + " : " + bodyrotation.M01 + " : " + bodyrotation.M02 + " : " + bodyrotation.M10 + " : " + bodyrotation.M11 + " : " + bodyrotation.M12 + " : " + bodyrotation.M20 + " : " + bodyrotation.M21 + " : " + bodyrotation.M22);
656 //standupStraight();
657 }
658
659 //
660 /// <summary>
661 /// Uses the capped cyllinder volume formula to calculate the avatar's mass.
662 /// This may be used in calculations in the scene/scenepresence
663 /// </summary>
664 public override float Mass
665 {
666 get
667 {
668 float AVvolume = (float) (Math.PI*Math.Pow(CAPSULE_RADIUS, 2)*CAPSULE_LENGTH);
669 return m_density*AVvolume;
670 }
671 }
672 public override void link(PhysicsActor obj)
673 {
674
675 }
676
677 public override void delink()
678 {
679
680 }
681
682 public override void LockAngularMotion(Vector3 axis)
683 {
684
685 }
686
687// This code is very useful. Written by DanX0r. We're just not using it right now.
688// Commented out to prevent a warning.
689//
690// private void standupStraight()
691// {
692// // The purpose of this routine here is to quickly stabilize the Body while it's popped up in the air.
693// // The amotor needs a few seconds to stabilize so without it, the avatar shoots up sky high when you
694// // change appearance and when you enter the simulator
695// // After this routine is done, the amotor stabilizes much quicker
696// d.Vector3 feet;
697// d.Vector3 head;
698// d.BodyGetRelPointPos(Body, 0.0f, 0.0f, -1.0f, out feet);
699// d.BodyGetRelPointPos(Body, 0.0f, 0.0f, 1.0f, out head);
700// float posture = head.Z - feet.Z;
701
702// // restoring force proportional to lack of posture:
703// float servo = (2.5f - posture) * POSTURE_SERVO;
704// d.BodyAddForceAtRelPos(Body, 0.0f, 0.0f, servo, 0.0f, 0.0f, 1.0f);
705// d.BodyAddForceAtRelPos(Body, 0.0f, 0.0f, -servo, 0.0f, 0.0f, -1.0f);
706// //d.Matrix3 bodyrotation = d.BodyGetRotation(Body);
707// //m_log.Info("[PHYSICSAV]: Rotation: " + bodyrotation.M00 + " : " + bodyrotation.M01 + " : " + bodyrotation.M02 + " : " + bodyrotation.M10 + " : " + bodyrotation.M11 + " : " + bodyrotation.M12 + " : " + bodyrotation.M20 + " : " + bodyrotation.M21 + " : " + bodyrotation.M22);
708// }
709
710 public override Vector3 Force
711 {
712 get { return _target_velocity; }
713 set { return; }
714 }
715
716 public override int VehicleType
717 {
718 get { return 0; }
719 set { return; }
720 }
721
722 public override void VehicleFloatParam(int param, float value)
723 {
724
725 }
726
727 public override void VehicleVectorParam(int param, Vector3 value)
728 {
729
730 }
731
732 public override void VehicleRotationParam(int param, Quaternion rotation)
733 {
734
735 }
736
737 public override void SetVolumeDetect(int param)
738 {
739
740 }
741
742 public override Vector3 CenterOfMass
743 {
744 get { return Vector3.Zero; }
745 }
746
747 public override Vector3 GeometricCenter
748 {
749 get { return Vector3.Zero; }
750 }
751
752 public override PrimitiveBaseShape Shape
753 {
754 set { return; }
755 }
756
757 public override Vector3 Velocity
758 {
759 get {
760 // There's a problem with Vector3.Zero! Don't Use it Here!
761 if (_zeroFlag)
762 return Vector3.Zero;
763 m_lastUpdateSent = false;
764 return _velocity;
765 }
766 set
767 {
768 if (value.IsFinite())
769 {
770 m_pidControllerActive = true;
771 _target_velocity = value;
772 }
773 else
774 {
775 m_log.Warn("[PHYSICS]: Got a NaN velocity from Scene in a Character");
776 }
777 }
778 }
779
780 public override Vector3 Torque
781 {
782 get { return Vector3.Zero; }
783 set { return; }
784 }
785
786 public override float CollisionScore
787 {
788 get { return 0f; }
789 set { }
790 }
791
792 public override bool Kinematic
793 {
794 get { return false; }
795 set { }
796 }
797
798 public override Quaternion Orientation
799 {
800 get { return Quaternion.Identity; }
801 set {
802 //Matrix3 or = Orientation.ToRotationMatrix();
803 //d.Matrix3 ord = new d.Matrix3(or.m00, or.m10, or.m20, or.m01, or.m11, or.m21, or.m02, or.m12, or.m22);
804 //d.BodySetRotation(Body, ref ord);
805 }
806 }
807
808 public override Vector3 Acceleration
809 {
810 get { return _acceleration; }
811 }
812
813 public void SetAcceleration(Vector3 accel)
814 {
815 m_pidControllerActive = true;
816 _acceleration = accel;
817 }
818
819 /// <summary>
820 /// Adds the force supplied to the Target Velocity
821 /// The PID controller takes this target velocity and tries to make it a reality
822 /// </summary>
823 /// <param name="force"></param>
824 public override void AddForce(Vector3 force, bool pushforce)
825 {
826 if (force.IsFinite())
827 {
828 if (pushforce)
829 {
830 m_pidControllerActive = false;
831 force *= 100f;
832 doForce(force);
833 // If uncommented, things get pushed off world
834 //
835 // m_log.Debug("Push!");
836 // _target_velocity.X += force.X;
837 // _target_velocity.Y += force.Y;
838 // _target_velocity.Z += force.Z;
839 }
840 else
841 {
842 m_pidControllerActive = true;
843 _target_velocity.X += force.X;
844 _target_velocity.Y += force.Y;
845 _target_velocity.Z += force.Z;
846 }
847 }
848 else
849 {
850 m_log.Warn("[PHYSICS]: Got a NaN force applied to a Character");
851 }
852 //m_lastUpdateSent = false;
853 }
854
855 public override void AddAngularForce(Vector3 force, bool pushforce)
856 {
857
858 }
859
860 /// <summary>
861 /// After all of the forces add up with 'add force' we apply them with doForce
862 /// </summary>
863 /// <param name="force"></param>
864 public void doForce(Vector3 force)
865 {
866 if (!collidelock)
867 {
868 d.BodyAddForce(Body, force.X, force.Y, force.Z);
869 //d.BodySetRotation(Body, ref m_StandUpRotation);
870 //standupStraight();
871
872 }
873 }
874
875 public override void SetMomentum(Vector3 momentum)
876 {
877 }
878
879
880 /// <summary>
881 /// Called from Simulate
882 /// This is the avatar's movement control + PID Controller
883 /// </summary>
884 /// <param name="timeStep"></param>
885 public void Move(float timeStep, List<OdeCharacter> defects)
886 {
887 // no lock; for now it's only called from within Simulate()
888
889 // If the PID Controller isn't active then we set our force
890 // calculating base velocity to the current position
891
892 if (Body == IntPtr.Zero)
893 return;
894
895 if (m_pidControllerActive == false)
896 {
897 _zeroPosition = d.BodyGetPosition(Body);
898 }
899 //PidStatus = true;
900
901 d.Vector3 localpos = d.BodyGetPosition(Body);
902 Vector3 localPos = new Vector3(localpos.X, localpos.Y, localpos.Z);
903
904 if (!localPos.IsFinite())
905 {
906
907 m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
908 defects.Add(this);
909 // _parent_scene.RemoveCharacter(this);
910
911 // destroy avatar capsule and related ODE data
912 if (Amotor != IntPtr.Zero)
913 {
914 // Kill the Amotor
915 d.JointDestroy(Amotor);
916 Amotor = IntPtr.Zero;
917 }
918
919 //kill the Geometry
920 _parent_scene.waitForSpaceUnlock(_parent_scene.space);
921
922 if (Body != IntPtr.Zero)
923 {
924 //kill the body
925 d.BodyDestroy(Body);
926
927 Body = IntPtr.Zero;
928 }
929
930 if (Shell != IntPtr.Zero)
931 {
932 d.GeomDestroy(Shell);
933 _parent_scene.geom_name_map.Remove(Shell);
934 Shell = IntPtr.Zero;
935 }
936
937 return;
938 }
939
940 Vector3 vec = Vector3.Zero;
941 d.Vector3 vel = d.BodyGetLinearVel(Body);
942
943 float movementdivisor = 1f;
944
945 if (!m_alwaysRun)
946 {
947 movementdivisor = walkDivisor;
948 }
949 else
950 {
951 movementdivisor = runDivisor;
952 }
953
954 // if velocity is zero, use position control; otherwise, velocity control
955 if (_target_velocity.X == 0.0f && _target_velocity.Y == 0.0f && _target_velocity.Z == 0.0f && m_iscolliding)
956 {
957 // keep track of where we stopped. No more slippin' & slidin'
958 if (!_zeroFlag)
959 {
960 _zeroFlag = true;
961 _zeroPosition = d.BodyGetPosition(Body);
962 }
963 if (m_pidControllerActive)
964 {
965 // We only want to deactivate the PID Controller if we think we want to have our surrogate
966 // react to the physics scene by moving it's position.
967 // Avatar to Avatar collisions
968 // Prim to avatar collisions
969
970 d.Vector3 pos = d.BodyGetPosition(Body);
971 vec.X = (_target_velocity.X - vel.X) * (PID_D) + (_zeroPosition.X - pos.X) * (PID_P * 2);
972 vec.Y = (_target_velocity.Y - vel.Y)*(PID_D) + (_zeroPosition.Y - pos.Y)* (PID_P * 2);
973 if (flying)
974 {
975 vec.Z = (_target_velocity.Z - vel.Z) * (PID_D) + (_zeroPosition.Z - pos.Z) * PID_P;
976 }
977 }
978 //PidStatus = true;
979 }
980 else
981 {
982 m_pidControllerActive = true;
983 _zeroFlag = false;
984 if (m_iscolliding && !flying)
985 {
986 // We're standing on something
987 vec.X = ((_target_velocity.X / movementdivisor) - vel.X) * (PID_D);
988 vec.Y = ((_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D);
989 }
990 else if (m_iscolliding && flying)
991 {
992 // We're flying and colliding with something
993 vec.X = ((_target_velocity.X/movementdivisor) - vel.X)*(PID_D / 16);
994 vec.Y = ((_target_velocity.Y/movementdivisor) - vel.Y)*(PID_D / 16);
995 }
996 else if (!m_iscolliding && flying)
997 {
998 // we're in mid air suspended
999 vec.X = ((_target_velocity.X / movementdivisor) - vel.X) * (PID_D/6);
1000 vec.Y = ((_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D/6);
1001 }
1002
1003 if (m_iscolliding && !flying && _target_velocity.Z > 0.0f)
1004 {
1005 // We're colliding with something and we're not flying but we're moving
1006 // This means we're walking or running.
1007 d.Vector3 pos = d.BodyGetPosition(Body);
1008 vec.Z = (_target_velocity.Z - vel.Z)*PID_D + (_zeroPosition.Z - pos.Z)*PID_P;
1009 if (_target_velocity.X > 0)
1010 {
1011 vec.X = ((_target_velocity.X - vel.X)/1.2f)*PID_D;
1012 }
1013 if (_target_velocity.Y > 0)
1014 {
1015 vec.Y = ((_target_velocity.Y - vel.Y)/1.2f)*PID_D;
1016 }
1017 }
1018 else if (!m_iscolliding && !flying)
1019 {
1020 // we're not colliding and we're not flying so that means we're falling!
1021 // m_iscolliding includes collisions with the ground.
1022
1023 // d.Vector3 pos = d.BodyGetPosition(Body);
1024 if (_target_velocity.X > 0)
1025 {
1026 vec.X = ((_target_velocity.X - vel.X)/1.2f)*PID_D;
1027 }
1028 if (_target_velocity.Y > 0)
1029 {
1030 vec.Y = ((_target_velocity.Y - vel.Y)/1.2f)*PID_D;
1031 }
1032 }
1033
1034 if (flying)
1035 {
1036 vec.Z = (_target_velocity.Z - vel.Z) * (PID_D);
1037 }
1038 }
1039 if (flying)
1040 {
1041 vec.Z += ((-1 * _parent_scene.gravityz)*m_mass);
1042
1043 //Added for auto fly height. Kitto Flora
1044 //d.Vector3 pos = d.BodyGetPosition(Body);
1045 float target_altitude = _parent_scene.GetTerrainHeightAtXY(_position.X, _position.Y) + MinimumGroundFlightOffset;
1046
1047 if (_position.Z < target_altitude)
1048 {
1049 vec.Z += (target_altitude - _position.Z) * PID_P * 5.0f;
1050 }
1051 // end add Kitto Flora
1052 }
1053 if (vec.IsFinite())
1054 {
1055 doForce(vec);
1056 if (!_zeroFlag)
1057 {
1058 AlignAvatarTiltWithCurrentDirectionOfMovement(vec);
1059 }
1060 }
1061 else
1062 {
1063 m_log.Warn("[PHYSICS]: Got a NaN force vector in Move()");
1064 m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
1065 defects.Add(this);
1066 // _parent_scene.RemoveCharacter(this);
1067 // destroy avatar capsule and related ODE data
1068 if (Amotor != IntPtr.Zero)
1069 {
1070 // Kill the Amotor
1071 d.JointDestroy(Amotor);
1072 Amotor = IntPtr.Zero;
1073 }
1074 //kill the Geometry
1075 _parent_scene.waitForSpaceUnlock(_parent_scene.space);
1076
1077 if (Body != IntPtr.Zero)
1078 {
1079 //kill the body
1080 d.BodyDestroy(Body);
1081
1082 Body = IntPtr.Zero;
1083 }
1084
1085 if (Shell != IntPtr.Zero)
1086 {
1087 d.GeomDestroy(Shell);
1088 _parent_scene.geom_name_map.Remove(Shell);
1089 Shell = IntPtr.Zero;
1090 }
1091 }
1092 }
1093
1094 /// <summary>
1095 /// Updates the reported position and velocity. This essentially sends the data up to ScenePresence.
1096 /// </summary>
1097 public void UpdatePositionAndVelocity()
1098 {
1099 // no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
1100 d.Vector3 vec;
1101 try
1102 {
1103 vec = d.BodyGetPosition(Body);
1104 }
1105 catch (NullReferenceException)
1106 {
1107 bad = true;
1108 _parent_scene.BadCharacter(this);
1109 vec = new d.Vector3(_position.X, _position.Y, _position.Z);
1110 base.RaiseOutOfBounds(_position); // Tells ScenePresence that there's a problem!
1111 m_log.WarnFormat("[ODEPLUGIN]: Avatar Null reference for Avatar {0}, physical actor {1}", m_name, m_uuid);
1112 }
1113
1114
1115 // kluge to keep things in bounds. ODE lets dead avatars drift away (they should be removed!)
1116 if (vec.X < 0.0f) vec.X = 0.0f;
1117 if (vec.Y < 0.0f) vec.Y = 0.0f;
1118 if (vec.X > (int)_parent_scene.WorldExtents.X - 0.05f) vec.X = (int)_parent_scene.WorldExtents.X - 0.05f;
1119 if (vec.Y > (int)_parent_scene.WorldExtents.Y - 0.05f) vec.Y = (int)_parent_scene.WorldExtents.Y - 0.05f;
1120
1121 _position.X = vec.X;
1122 _position.Y = vec.Y;
1123 _position.Z = vec.Z;
1124
1125 // Did we move last? = zeroflag
1126 // This helps keep us from sliding all over
1127
1128 if (_zeroFlag)
1129 {
1130 _velocity.X = 0.0f;
1131 _velocity.Y = 0.0f;
1132 _velocity.Z = 0.0f;
1133
1134 // Did we send out the 'stopped' message?
1135 if (!m_lastUpdateSent)
1136 {
1137 m_lastUpdateSent = true;
1138 //base.RequestPhysicsterseUpdate();
1139
1140 }
1141 }
1142 else
1143 {
1144 m_lastUpdateSent = false;
1145 try
1146 {
1147 vec = d.BodyGetLinearVel(Body);
1148 }
1149 catch (NullReferenceException)
1150 {
1151 vec.X = _velocity.X;
1152 vec.Y = _velocity.Y;
1153 vec.Z = _velocity.Z;
1154 }
1155 _velocity.X = (vec.X);
1156 _velocity.Y = (vec.Y);
1157
1158 _velocity.Z = (vec.Z);
1159
1160 if (_velocity.Z < -6 && !m_hackSentFall)
1161 {
1162 m_hackSentFall = true;
1163 m_pidControllerActive = false;
1164 }
1165 else if (flying && !m_hackSentFly)
1166 {
1167 //m_hackSentFly = true;
1168 //base.SendCollisionUpdate(new CollisionEventUpdate());
1169 }
1170 else
1171 {
1172 m_hackSentFly = false;
1173 m_hackSentFall = false;
1174 }
1175 }
1176 }
1177
1178 /// <summary>
1179 /// Cleanup the things we use in the scene.
1180 /// </summary>
1181 public void Destroy()
1182 {
1183 m_tainted_isPhysical = false;
1184 _parent_scene.AddPhysicsActorTaint(this);
1185 }
1186
1187 public override void CrossingFailure()
1188 {
1189 }
1190
1191 public override Vector3 PIDTarget { set { return; } }
1192 public override bool PIDActive { set { return; } }
1193 public override float PIDTau { set { return; } }
1194
1195 public override float PIDHoverHeight { set { return; } }
1196 public override bool PIDHoverActive { set { return; } }
1197 public override PIDHoverType PIDHoverType { set { return; } }
1198 public override float PIDHoverTau { set { return; } }
1199
1200 public override Quaternion APIDTarget{ set { return; } }
1201
1202 public override bool APIDActive{ set { return; } }
1203
1204 public override float APIDStrength{ set { return; } }
1205
1206 public override float APIDDamping{ set { return; } }
1207
1208
1209 public override void SubscribeEvents(int ms)
1210 {
1211 m_requestedUpdateFrequency = ms;
1212 m_eventsubscription = ms;
1213 _parent_scene.addCollisionEventReporting(this);
1214 }
1215 public override void UnSubscribeEvents()
1216 {
1217 _parent_scene.remCollisionEventReporting(this);
1218 m_requestedUpdateFrequency = 0;
1219 m_eventsubscription = 0;
1220 }
1221 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
1222 {
1223 if (m_eventsubscription > 0)
1224 {
1225 CollisionEventsThisFrame.addCollider(CollidedWith, contact);
1226 }
1227 }
1228
1229 public void SendCollisions()
1230 {
1231 if (m_eventsubscription > m_requestedUpdateFrequency)
1232 {
1233 if (CollisionEventsThisFrame != null)
1234 {
1235 base.SendCollisionUpdate(CollisionEventsThisFrame);
1236 }
1237 CollisionEventsThisFrame = new CollisionEventUpdate();
1238 m_eventsubscription = 0;
1239 }
1240 }
1241 public override bool SubscribedEvents()
1242 {
1243 if (m_eventsubscription > 0)
1244 return true;
1245 return false;
1246 }
1247
1248 public void ProcessTaints(float timestep)
1249 {
1250
1251 if (m_tainted_isPhysical != m_isPhysical)
1252 {
1253 if (m_tainted_isPhysical)
1254 {
1255 // Create avatar capsule and related ODE data
1256 if (!(Shell == IntPtr.Zero && Body == IntPtr.Zero && Amotor == IntPtr.Zero))
1257 {
1258 m_log.Warn("[PHYSICS]: re-creating the following avatar ODE data, even though it already exists - "
1259 + (Shell!=IntPtr.Zero ? "Shell ":"")
1260 + (Body!=IntPtr.Zero ? "Body ":"")
1261 + (Amotor!=IntPtr.Zero ? "Amotor ":""));
1262 }
1263 AvatarGeomAndBodyCreation(_position.X, _position.Y, _position.Z, m_tensor);
1264
1265 _parent_scene.geom_name_map[Shell] = m_name;
1266 _parent_scene.actor_name_map[Shell] = (PhysicsActor)this;
1267 _parent_scene.AddCharacter(this);
1268 }
1269 else
1270 {
1271 _parent_scene.RemoveCharacter(this);
1272 // destroy avatar capsule and related ODE data
1273 if (Amotor != IntPtr.Zero)
1274 {
1275 // Kill the Amotor
1276 d.JointDestroy(Amotor);
1277 Amotor = IntPtr.Zero;
1278 }
1279 //kill the Geometry
1280 _parent_scene.waitForSpaceUnlock(_parent_scene.space);
1281
1282 if (Body != IntPtr.Zero)
1283 {
1284 //kill the body
1285 d.BodyDestroy(Body);
1286
1287 Body = IntPtr.Zero;
1288 }
1289
1290 if (Shell != IntPtr.Zero)
1291 {
1292 d.GeomDestroy(Shell);
1293 _parent_scene.geom_name_map.Remove(Shell);
1294 Shell = IntPtr.Zero;
1295 }
1296
1297 }
1298
1299 m_isPhysical = m_tainted_isPhysical;
1300 }
1301
1302 if (m_tainted_CAPSULE_LENGTH != CAPSULE_LENGTH)
1303 {
1304 if (Shell != IntPtr.Zero && Body != IntPtr.Zero && Amotor != IntPtr.Zero)
1305 {
1306
1307 m_pidControllerActive = true;
1308 // no lock needed on _parent_scene.OdeLock because we are called from within the thread lock in OdePlugin's simulate()
1309 d.JointDestroy(Amotor);
1310 float prevCapsule = CAPSULE_LENGTH;
1311 CAPSULE_LENGTH = m_tainted_CAPSULE_LENGTH;
1312 //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString());
1313 d.BodyDestroy(Body);
1314 d.GeomDestroy(Shell);
1315 AvatarGeomAndBodyCreation(_position.X, _position.Y,
1316 _position.Z + (Math.Abs(CAPSULE_LENGTH - prevCapsule) * 2), m_tensor);
1317 Velocity = Vector3.Zero;
1318
1319 _parent_scene.geom_name_map[Shell] = m_name;
1320 _parent_scene.actor_name_map[Shell] = (PhysicsActor)this;
1321 }
1322 else
1323 {
1324 m_log.Warn("[PHYSICS]: trying to change capsule size, but the following ODE data is missing - "
1325 + (Shell==IntPtr.Zero ? "Shell ":"")
1326 + (Body==IntPtr.Zero ? "Body ":"")
1327 + (Amotor==IntPtr.Zero ? "Amotor ":""));
1328 }
1329 }
1330
1331 if (!m_taintPosition.ApproxEquals(_position, 0.05f))
1332 {
1333 if (Body != IntPtr.Zero)
1334 {
1335 d.BodySetPosition(Body, m_taintPosition.X, m_taintPosition.Y, m_taintPosition.Z);
1336
1337 _position.X = m_taintPosition.X;
1338 _position.Y = m_taintPosition.Y;
1339 _position.Z = m_taintPosition.Z;
1340 }
1341 }
1342
1343 }
1344
1345 internal void AddCollisionFrameTime(int p)
1346 {
1347 // protect it from overflow crashing
1348 if (m_eventsubscription + p >= int.MaxValue)
1349 m_eventsubscription = 0;
1350 m_eventsubscription += p;
1351 }
1352 }
1353}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.c_comments b/OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.c_comments
new file mode 100644
index 0000000..1060aa6
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.c_comments
@@ -0,0 +1,630 @@
1/*
2 * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces
3 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
4 * ODEPrim.cs contains methods dealing with Prim editing, Prim
5 * characteristics and Kinetic motion.
6 * ODEDynamics.cs contains methods dealing with Prim Physical motion
7 * (dynamics) and the associated settings. Old Linear and angular
8 * motors for dynamic motion have been replace with MoveLinear()
9 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
10 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
11 * switch between 'VEHICLE' parameter use and general dynamics
12 * settings use.
13 *
14 * Copyright (c) Contributors, http://opensimulator.org/
15 * See CONTRIBUTORS.TXT for a full list of copyright holders.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are met:
19 * * Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * * Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * * Neither the name of the OpenSimulator Project nor the
25 * names of its contributors may be used to endorse or promote products
26 * derived from this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
29 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
30 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
31 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
33 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
35 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 */
39
40using System;
41using System.Collections.Generic;
42using System.Reflection;
43using System.Runtime.InteropServices;
44using log4net;
45using OpenMetaverse;
46using Ode.NET;
47using OpenSim.Framework;
48using OpenSim.Region.Physics.Manager;
49
50namespace OpenSim.Region.Physics.OdePlugin
51{
52 public class ODEDynamics
53 {
54 public Vehicle Type
55 {
56 get { return m_type; }
57 }
58
59 public IntPtr Body
60 {
61 get { return m_body; }
62 }
63
64 private int frcount = 0; // Used to limit dynamics debug output to
65 // every 100th frame
66
67 // private OdeScene m_parentScene = null;
68 private IntPtr m_body = IntPtr.Zero;
69 private IntPtr m_jointGroup = IntPtr.Zero;
70 private IntPtr m_aMotor = IntPtr.Zero;
71
72
73 // Vehicle properties
74 private Vehicle m_type = Vehicle.TYPE_NONE; // If a 'VEHICLE', and what kind
75 // private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier
76 private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings:
77 // HOVER_TERRAIN_ONLY
78 // HOVER_GLOBAL_HEIGHT
79 // NO_DEFLECTION_UP
80 // HOVER_WATER_ONLY
81 // HOVER_UP_ONLY
82 // LIMIT_MOTOR_UP
83 // LIMIT_ROLL_ONLY
84
85 // Linear properties
86 private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time
87 private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL
88 private Vector3 m_dir = Vector3.Zero; // velocity applied to body
89 private Vector3 m_linearFrictionTimescale = Vector3.Zero;
90 private float m_linearMotorDecayTimescale = 0;
91 private float m_linearMotorTimescale = 0;
92 private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
93 // private bool m_LinearMotorSetLastFrame = false;
94 // private Vector3 m_linearMotorOffset = Vector3.Zero;
95
96 //Angular properties
97 private Vector3 m_angularMotorDirection = Vector3.Zero;
98 private Vector3 m_angularMotorDirectionLASTSET = Vector3.Zero;
99 private Vector3 m_angularFrictionTimescale = Vector3.Zero;
100 private float m_angularMotorDecayTimescale = 0;
101 private float m_angularMotorTimescale = 0;
102 private Vector3 m_lastAngularVelocityVector = Vector3.Zero;
103
104 //Deflection properties
105 // private float m_angularDeflectionEfficiency = 0;
106 // private float m_angularDeflectionTimescale = 0;
107 // private float m_linearDeflectionEfficiency = 0;
108 // private float m_linearDeflectionTimescale = 0;
109
110 //Banking properties
111 // private float m_bankingEfficiency = 0;
112 // private float m_bankingMix = 0;
113 // private float m_bankingTimescale = 0;
114
115 //Hover and Buoyancy properties
116 private float m_VhoverHeight = 0f;
117 private float m_VhoverEfficiency = 0f;
118 private float m_VhoverTimescale = 0f;
119 private float m_VhoverTargetHeight = -1.0f; // if <0 then no hover, else its the current target height
120 private float m_VehicleBuoyancy = 0f; //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle.
121 // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity)
122 // KF: So far I have found no good method to combine a script-requested .Z velocity and gravity.
123 // Therefore only m_VehicleBuoyancy=1 (0g) will use the script-requested .Z velocity.
124
125 //Attractor properties
126 private float m_verticalAttractionEfficiency = 0;
127 private float m_verticalAttractionTimescale = 0;
128
129
130
131
132
133 internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
134 {
135 switch (pParam)
136 {
137 case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
138 if (pValue < 0.01f) pValue = 0.01f;
139 // m_angularDeflectionEfficiency = pValue;
140 break;
141 case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
142 if (pValue < 0.01f) pValue = 0.01f;
143 // m_angularDeflectionTimescale = pValue;
144 break;
145 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
146 if (pValue < 0.01f) pValue = 0.01f;
147 m_angularMotorDecayTimescale = pValue;
148 break;
149 case Vehicle.ANGULAR_MOTOR_TIMESCALE:
150 if (pValue < 0.01f) pValue = 0.01f;
151 m_angularMotorTimescale = pValue;
152 break;
153 case Vehicle.BANKING_EFFICIENCY:
154 if (pValue < 0.01f) pValue = 0.01f;
155 // m_bankingEfficiency = pValue;
156 break;
157 case Vehicle.BANKING_MIX:
158 if (pValue < 0.01f) pValue = 0.01f;
159 // m_bankingMix = pValue;
160 break;
161 case Vehicle.BANKING_TIMESCALE:
162 if (pValue < 0.01f) pValue = 0.01f;
163 // m_bankingTimescale = pValue;
164 break;
165 case Vehicle.BUOYANCY:
166 if (pValue < -1f) pValue = -1f;
167 if (pValue > 1f) pValue = 1f;
168 m_VehicleBuoyancy = pValue;
169 break;
170 case Vehicle.HOVER_EFFICIENCY:
171 if (pValue < 0f) pValue = 0f;
172 if (pValue > 1f) pValue = 1f;
173 m_VhoverEfficiency = pValue;
174 break;
175 case Vehicle.HOVER_HEIGHT:
176 m_VhoverHeight = pValue;
177 break;
178 case Vehicle.HOVER_TIMESCALE:
179 if (pValue < 0.01f) pValue = 0.01f;
180 m_VhoverTimescale = pValue;
181 break;
182 case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
183 if (pValue < 0.01f) pValue = 0.01f;
184 // m_linearDeflectionEfficiency = pValue;
185 break;
186 case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
187 if (pValue < 0.01f) pValue = 0.01f;
188 // m_linearDeflectionTimescale = pValue;
189 break;
190 case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
191 if (pValue < 0.01f) pValue = 0.01f;
192 m_linearMotorDecayTimescale = pValue;
193 break;
194 case Vehicle.LINEAR_MOTOR_TIMESCALE:
195 if (pValue < 0.01f) pValue = 0.01f;
196 m_linearMotorTimescale = pValue;
197 break;
198 case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
199 if (pValue < 0.0f) pValue = 0.0f;
200 if (pValue > 1.0f) pValue = 1.0f;
201 m_verticalAttractionEfficiency = pValue;
202 break;
203 case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
204 if (pValue < 0.01f) pValue = 0.01f;
205 m_verticalAttractionTimescale = pValue;
206 break;
207
208 // These are vector properties but the engine lets you use a single float value to
209 // set all of the components to the same value
210 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
211 m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
212 break;
213 case Vehicle.ANGULAR_MOTOR_DIRECTION:
214 m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
215 m_angularMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
216 break;
217 case Vehicle.LINEAR_FRICTION_TIMESCALE:
218 m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
219 break;
220 case Vehicle.LINEAR_MOTOR_DIRECTION:
221 m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
222 m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
223 break;
224 case Vehicle.LINEAR_MOTOR_OFFSET:
225 // m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
226 break;
227
228 }
229
230 }//end ProcessFloatVehicleParam
231
232 internal void ProcessVectorVehicleParam(Vehicle pParam, PhysicsVector pValue)
233 {
234 switch (pParam)
235 {
236 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
237 m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
238 break;
239 case Vehicle.ANGULAR_MOTOR_DIRECTION:
240 m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
241 m_angularMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
242 break;
243 case Vehicle.LINEAR_FRICTION_TIMESCALE:
244 m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
245 break;
246 case Vehicle.LINEAR_MOTOR_DIRECTION:
247 m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
248 m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
249 break;
250 case Vehicle.LINEAR_MOTOR_OFFSET:
251 // m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
252 break;
253 }
254
255 }//end ProcessVectorVehicleParam
256
257 internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
258 {
259 switch (pParam)
260 {
261 case Vehicle.REFERENCE_FRAME:
262 // m_referenceFrame = pValue;
263 break;
264 }
265
266 }//end ProcessRotationVehicleParam
267
268 internal void ProcessTypeChange(Vehicle pType)
269 {
270Console.WriteLine("ProcessTypeChange to " + pType);
271
272 // Set Defaults For Type
273 m_type = pType;
274 switch (pType)
275 {
276 case Vehicle.TYPE_SLED:
277 m_linearFrictionTimescale = new Vector3(30, 1, 1000);
278 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
279 m_linearMotorDirection = Vector3.Zero;
280 m_linearMotorTimescale = 1000;
281 m_linearMotorDecayTimescale = 120;
282 m_angularMotorDirection = Vector3.Zero;
283 m_angularMotorTimescale = 1000;
284 m_angularMotorDecayTimescale = 120;
285 m_VhoverHeight = 0;
286 m_VhoverEfficiency = 1;
287 m_VhoverTimescale = 10;
288 m_VehicleBuoyancy = 0;
289 // m_linearDeflectionEfficiency = 1;
290 // m_linearDeflectionTimescale = 1;
291 // m_angularDeflectionEfficiency = 1;
292 // m_angularDeflectionTimescale = 1000;
293 // m_bankingEfficiency = 0;
294 // m_bankingMix = 1;
295 // m_bankingTimescale = 10;
296 // m_referenceFrame = Quaternion.Identity;
297 m_flags &=
298 ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
299 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
300 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
301 break;
302 case Vehicle.TYPE_CAR:
303 m_linearFrictionTimescale = new Vector3(100, 2, 1000);
304 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
305 m_linearMotorDirection = Vector3.Zero;
306 m_linearMotorTimescale = 1;
307 m_linearMotorDecayTimescale = 60;
308 m_angularMotorDirection = Vector3.Zero;
309 m_angularMotorTimescale = 1;
310 m_angularMotorDecayTimescale = 0.8f;
311 m_VhoverHeight = 0;
312 m_VhoverEfficiency = 0;
313 m_VhoverTimescale = 1000;
314 m_VehicleBuoyancy = 0;
315 // // m_linearDeflectionEfficiency = 1;
316 // // m_linearDeflectionTimescale = 2;
317 // // m_angularDeflectionEfficiency = 0;
318 // m_angularDeflectionTimescale = 10;
319 m_verticalAttractionEfficiency = 1;
320 m_verticalAttractionTimescale = 10;
321 // m_bankingEfficiency = -0.2f;
322 // m_bankingMix = 1;
323 // m_bankingTimescale = 1;
324 // m_referenceFrame = Quaternion.Identity;
325 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
326 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.HOVER_UP_ONLY |
327 VehicleFlag.LIMIT_MOTOR_UP);
328 break;
329 case Vehicle.TYPE_BOAT:
330 m_linearFrictionTimescale = new Vector3(10, 3, 2);
331 m_angularFrictionTimescale = new Vector3(10,10,10);
332 m_linearMotorDirection = Vector3.Zero;
333 m_linearMotorTimescale = 5;
334 m_linearMotorDecayTimescale = 60;
335 m_angularMotorDirection = Vector3.Zero;
336 m_angularMotorTimescale = 4;
337 m_angularMotorDecayTimescale = 4;
338 m_VhoverHeight = 0;
339 m_VhoverEfficiency = 0.5f;
340 m_VhoverTimescale = 2;
341 m_VehicleBuoyancy = 1;
342 // m_linearDeflectionEfficiency = 0.5f;
343 // m_linearDeflectionTimescale = 3;
344 // m_angularDeflectionEfficiency = 0.5f;
345 // m_angularDeflectionTimescale = 5;
346 m_verticalAttractionEfficiency = 0.5f;
347 m_verticalAttractionTimescale = 5;
348 // m_bankingEfficiency = -0.3f;
349 // m_bankingMix = 0.8f;
350 // m_bankingTimescale = 1;
351 // m_referenceFrame = Quaternion.Identity;
352 m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.LIMIT_ROLL_ONLY |
353 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
354 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY |
355 VehicleFlag.LIMIT_MOTOR_UP);
356 break;
357 case Vehicle.TYPE_AIRPLANE:
358 m_linearFrictionTimescale = new Vector3(200, 10, 5);
359 m_angularFrictionTimescale = new Vector3(20, 20, 20);
360 m_linearMotorDirection = Vector3.Zero;
361 m_linearMotorTimescale = 2;
362 m_linearMotorDecayTimescale = 60;
363 m_angularMotorDirection = Vector3.Zero;
364 m_angularMotorTimescale = 4;
365 m_angularMotorDecayTimescale = 4;
366 m_VhoverHeight = 0;
367 m_VhoverEfficiency = 0.5f;
368 m_VhoverTimescale = 1000;
369 m_VehicleBuoyancy = 0;
370 // m_linearDeflectionEfficiency = 0.5f;
371 // m_linearDeflectionTimescale = 3;
372 // m_angularDeflectionEfficiency = 1;
373 // m_angularDeflectionTimescale = 2;
374 m_verticalAttractionEfficiency = 0.9f;
375 m_verticalAttractionTimescale = 2;
376 // m_bankingEfficiency = 1;
377 // m_bankingMix = 0.7f;
378 // m_bankingTimescale = 2;
379 // m_referenceFrame = Quaternion.Identity;
380 m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
381 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
382 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
383 break;
384 case Vehicle.TYPE_BALLOON:
385 m_linearFrictionTimescale = new Vector3(5, 5, 5);
386 m_angularFrictionTimescale = new Vector3(10, 10, 10);
387 m_linearMotorDirection = Vector3.Zero;
388 m_linearMotorTimescale = 5;
389 m_linearMotorDecayTimescale = 60;
390 m_angularMotorDirection = Vector3.Zero;
391 m_angularMotorTimescale = 6;
392 m_angularMotorDecayTimescale = 10;
393 m_VhoverHeight = 5;
394 m_VhoverEfficiency = 0.8f;
395 m_VhoverTimescale = 10;
396 m_VehicleBuoyancy = 1;
397 // m_linearDeflectionEfficiency = 0;
398 // m_linearDeflectionTimescale = 5;
399 // m_angularDeflectionEfficiency = 0;
400 // m_angularDeflectionTimescale = 5;
401 m_verticalAttractionEfficiency = 1;
402 m_verticalAttractionTimescale = 1000;
403 // m_bankingEfficiency = 0;
404 // m_bankingMix = 0.7f;
405 // m_bankingTimescale = 5;
406 // m_referenceFrame = Quaternion.Identity;
407 m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
408 VehicleFlag.HOVER_UP_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
409 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
410 break;
411
412 }
413 }//end SetDefaultsForType
414
415 internal void Enable(IntPtr pBody, OdeScene pParentScene)
416 {
417//Console.WriteLine("Enable m_type=" + m_type + " m_VehicleBuoyancy=" + m_VehicleBuoyancy);
418 if (m_type == Vehicle.TYPE_NONE)
419 return;
420
421 m_body = pBody;
422 //KF: This used to set up the linear and angular joints
423 }
424
425 internal void Step(float pTimestep, OdeScene pParentScene)
426 {
427 if (m_body == IntPtr.Zero || m_type == Vehicle.TYPE_NONE)
428 return;
429 frcount++; // used to limit debug comment output
430 if (frcount > 100)
431 frcount = 0;
432
433 MoveLinear(pTimestep, pParentScene);
434 MoveAngular(pTimestep);
435 }// end Step
436
437 private void MoveLinear(float pTimestep, OdeScene _pParentScene)
438 {
439 if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f)) // requested m_linearMotorDirection is significant
440 {
441 if(!d.BodyIsEnabled (Body)) d.BodyEnable (Body);
442
443 // add drive to body
444 Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep);
445 m_lastLinearVelocityVector += (addAmount*10); // lastLinearVelocityVector is the current body velocity vector?
446
447 // This will work temporarily, but we really need to compare speed on an axis
448 // KF: Limit body velocity to applied velocity?
449 if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X))
450 m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X;
451 if (Math.Abs(m_lastLinearVelocityVector.Y) > Math.Abs(m_linearMotorDirectionLASTSET.Y))
452 m_lastLinearVelocityVector.Y = m_linearMotorDirectionLASTSET.Y;
453 if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z))
454 m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z;
455
456 // decay applied velocity
457 Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep)));
458 //Console.WriteLine("decay: " + decayfraction);
459 m_linearMotorDirection -= m_linearMotorDirection * decayfraction;
460 //Console.WriteLine("actual: " + m_linearMotorDirection);
461 }
462 else
463 { // requested is not significant
464 // if what remains of applied is small, zero it.
465 if (m_lastLinearVelocityVector.ApproxEquals(Vector3.Zero, 0.01f))
466 m_lastLinearVelocityVector = Vector3.Zero;
467 }
468
469
470 // convert requested object velocity to world-referenced vector
471 m_dir = m_lastLinearVelocityVector;
472 d.Quaternion rot = d.BodyGetQuaternion(Body);
473 Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W); // rotq = rotation of object
474 m_dir *= rotq; // apply obj rotation to velocity vector
475
476 // add Gravity andBuoyancy
477 // KF: So far I have found no good method to combine a script-requested
478 // .Z velocity and gravity. Therefore only 0g will used script-requested
479 // .Z velocity. >0g (m_VehicleBuoyancy < 1) will used modified gravity only.
480 Vector3 grav = Vector3.Zero;
481 if(m_VehicleBuoyancy < 1.0f)
482 {
483 // There is some gravity, make a gravity force vector
484 // that is applied after object velocity.
485 d.Mass objMass;
486 d.BodyGetMass(Body, out objMass);
487 // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g;
488 grav.Z = _pParentScene.gravityz * objMass.mass * (1f - m_VehicleBuoyancy);
489 // Preserve the current Z velocity
490 d.Vector3 vel_now = d.BodyGetLinearVel(Body);
491 m_dir.Z = vel_now.Z; // Preserve the accumulated falling velocity
492 } // else its 1.0, no gravity.
493
494 // Check if hovering
495 if( (m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0)
496 {
497 // We should hover, get the target height
498 d.Vector3 pos = d.BodyGetPosition(Body);
499 if((m_flags & VehicleFlag.HOVER_WATER_ONLY) == VehicleFlag.HOVER_WATER_ONLY)
500 {
501 m_VhoverTargetHeight = _pParentScene.GetWaterLevel() + m_VhoverHeight;
502 }
503 else if((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) == VehicleFlag.HOVER_TERRAIN_ONLY)
504 {
505 m_VhoverTargetHeight = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight;
506 }
507 else if((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) == VehicleFlag.HOVER_GLOBAL_HEIGHT)
508 {
509 m_VhoverTargetHeight = m_VhoverHeight;
510 }
511
512 if((m_flags & VehicleFlag.HOVER_UP_ONLY) == VehicleFlag.HOVER_UP_ONLY)
513 {
514 // If body is aready heigher, use its height as target height
515 if(pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z;
516 }
517
518// m_VhoverEfficiency = 0f; // 0=boucy, 1=Crit.damped
519// m_VhoverTimescale = 0f; // time to acheive height
520// pTimestep is time since last frame,in secs
521 float herr0 = pos.Z - m_VhoverTargetHeight;
522//if(frcount == 0) Console.WriteLine("herr0=" + herr0);
523 // Replace Vertical speed with correction figure if significant
524 if(Math.Abs(herr0) > 0.01f )
525 {
526 d.Mass objMass;
527 d.BodyGetMass(Body, out objMass);
528 m_dir.Z = - ( (herr0 * pTimestep * 50.0f) / m_VhoverTimescale);
529 // m_VhoverEfficiency is not yet implemented
530 }
531 else
532 {
533 m_dir.Z = 0f;
534 }
535 }
536
537 // Apply velocity
538 d.BodySetLinearVel(Body, m_dir.X, m_dir.Y, m_dir.Z);
539//if(frcount == 0) Console.WriteLine("Move " + Body + ":"+ m_dir.X + " " + m_dir.Y + " " + m_dir.Z);
540 // apply gravity force
541 d.BodyAddForce(Body, grav.X, grav.Y, grav.Z);
542//if(frcount == 0) Console.WriteLine("Force " + Body + ":" + grav.X + " " + grav.Y + " " + grav.Z);
543
544
545 // apply friction
546 Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep);
547 m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount;
548 } // end MoveLinear()
549
550 private void MoveAngular(float pTimestep)
551 {
552
553 // m_angularMotorDirection is the latest value from the script, and is decayed here
554 // m_angularMotorDirectionLASTSET is the latest value from the script
555 // m_lastAngularVelocityVector is what is being applied to the Body, varied up and down here
556
557 if (!m_angularMotorDirection.ApproxEquals(Vector3.Zero, 0.01f))
558 {
559 if(!d.BodyIsEnabled (Body)) d.BodyEnable (Body);
560 // ramp up to new value
561 Vector3 addAmount = m_angularMotorDirection / (m_angularMotorTimescale / pTimestep);
562 m_lastAngularVelocityVector += (addAmount * 10f);
563//if(frcount == 0) Console.WriteLine("add: " + addAmount);
564
565 // limit applied value to what was set by script
566 // This will work temporarily, but we really need to compare speed on an axis
567 if (Math.Abs(m_lastAngularVelocityVector.X) > Math.Abs(m_angularMotorDirectionLASTSET.X))
568 m_lastAngularVelocityVector.X = m_angularMotorDirectionLASTSET.X;
569 if (Math.Abs(m_lastAngularVelocityVector.Y) > Math.Abs(m_angularMotorDirectionLASTSET.Y))
570 m_lastAngularVelocityVector.Y = m_angularMotorDirectionLASTSET.Y;
571 if (Math.Abs(m_lastAngularVelocityVector.Z) > Math.Abs(m_angularMotorDirectionLASTSET.Z))
572 m_lastAngularVelocityVector.Z = m_angularMotorDirectionLASTSET.Z;
573
574 // decay the requested value
575 Vector3 decayfraction = ((Vector3.One / (m_angularMotorDecayTimescale / pTimestep)));
576 //Console.WriteLine("decay: " + decayfraction);
577 m_angularMotorDirection -= m_angularMotorDirection * decayfraction;
578 //Console.WriteLine("actual: " + m_linearMotorDirection);
579 }
580 // KF: m_lastAngularVelocityVector is rotational speed in rad/sec ?
581
582 // Vertical attractor section
583
584// d.Mass objMass;
585// d.BodyGetMass(Body, out objMass);
586// float servo = 100f * objMass.mass * m_verticalAttractionEfficiency / (m_verticalAttractionTimescale * pTimestep);
587 float servo = 0.1f * m_verticalAttractionEfficiency / (m_verticalAttractionTimescale * pTimestep);
588 // get present body rotation
589 d.Quaternion rot = d.BodyGetQuaternion(Body);
590 Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);
591 // make a vector pointing up
592 Vector3 verterr = Vector3.Zero;
593 verterr.Z = 1.0f;
594 // rotate it to Body Angle
595 verterr = verterr * rotq;
596 // verterr.X and .Y are the World error ammounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1.
597 // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go
598 // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body.
599 if (verterr.Z < 0.0f)
600 {
601 verterr.X = 2.0f - verterr.X;
602 verterr.Y = 2.0f - verterr.Y;
603 }
604 // Error is 0 (no error) to +/- 2 (max error)
605 // scale it by servo
606 verterr = verterr * servo;
607
608 // rotate to object frame
609 // verterr = verterr * rotq;
610
611 // As the body rotates around the X axis, then verterr.Y increases; Rotated around Y then .X increases, so
612 // Change Body angular velocity X based on Y, and Y based on X. Z is not changed.
613 m_lastAngularVelocityVector.X += verterr.Y;
614 m_lastAngularVelocityVector.Y -= verterr.X;
615/*
616if(frcount == 0)
617 {
618// Console.WriteLine("AngleMotor " + m_lastAngularVelocityVector);
619 Console.WriteLine(String.Format("VA Body:{0} servo:{1} err:<{2},{3},{4}> VAE:{5}",
620 Body, servo, verterr.X, verterr.Y, verterr.Z, m_verticalAttractionEfficiency));
621 }
622 */
623 d.BodySetAngularVel (Body, m_lastAngularVelocityVector.X, m_lastAngularVelocityVector.Y, m_lastAngularVelocityVector.Z);
624 // apply friction
625 Vector3 decayamount = Vector3.One / (m_angularFrictionTimescale / pTimestep);
626 m_lastAngularVelocityVector -= m_lastAngularVelocityVector * decayamount;
627
628 } //end MoveAngular
629 }
630}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.cs b/OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.cs
new file mode 100644
index 0000000..78b15be
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/ODEDynamics.cs
@@ -0,0 +1,673 @@
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 * Revised Aug, Sept 2009 by Kitto Flora. ODEDynamics.cs replaces
28 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
29 * ODEPrim.cs contains methods dealing with Prim editing, Prim
30 * characteristics and Kinetic motion.
31 * ODEDynamics.cs contains methods dealing with Prim Physical motion
32 * (dynamics) and the associated settings. Old Linear and angular
33 * motors for dynamic motion have been replace with MoveLinear()
34 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
35 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
36 * switch between 'VEHICLE' parameter use and general dynamics
37 * settings use.
38 *
39 */
40
41/* Revised Aug, Sept 2009 by Kitto Flora. ODEDynamics.cs replaces
42 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
43 * ODEPrim.cs contains methods dealing with Prim editing, Prim
44 * characteristics and Kinetic motion.
45 * ODEDynamics.cs contains methods dealing with Prim Physical motion
46 * (dynamics) and the associated settings. Old Linear and angular
47 * motors for dynamic motion have been replace with MoveLinear()
48 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
49 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
50 * switch between 'VEHICLE' parameter use and general dynamics
51 * settings use.
52 */
53
54using System;
55using System.Collections.Generic;
56using System.Reflection;
57using System.Runtime.InteropServices;
58using log4net;
59using OpenMetaverse;
60using Ode.NET;
61using OpenSim.Framework;
62using OpenSim.Region.Physics.Manager;
63
64namespace OpenSim.Region.Physics.OdePlugin
65{
66 public class ODEDynamics
67 {
68 public Vehicle Type
69 {
70 get { return m_type; }
71 }
72
73 public IntPtr Body
74 {
75 get { return m_body; }
76 }
77
78 private int frcount = 0; // Used to limit dynamics debug output to
79 // every 100th frame
80
81 // private OdeScene m_parentScene = null;
82 private IntPtr m_body = IntPtr.Zero;
83// private IntPtr m_jointGroup = IntPtr.Zero;
84// private IntPtr m_aMotor = IntPtr.Zero;
85
86
87 // Vehicle properties
88 private Vehicle m_type = Vehicle.TYPE_NONE; // If a 'VEHICLE', and what kind
89 // private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier
90 private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings:
91 // HOVER_TERRAIN_ONLY
92 // HOVER_GLOBAL_HEIGHT
93 // NO_DEFLECTION_UP
94 // HOVER_WATER_ONLY
95 // HOVER_UP_ONLY
96 // LIMIT_MOTOR_UP
97 // LIMIT_ROLL_ONLY
98
99 // Linear properties
100 private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time
101 private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL
102 private Vector3 m_dir = Vector3.Zero; // velocity applied to body
103 private Vector3 m_linearFrictionTimescale = Vector3.Zero;
104 private float m_linearMotorDecayTimescale = 0;
105 private float m_linearMotorTimescale = 0;
106 private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
107 // private bool m_LinearMotorSetLastFrame = false;
108 // private Vector3 m_linearMotorOffset = Vector3.Zero;
109
110 //Angular properties
111 private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor
112 private int m_angularMotorApply = 0; // application frame counter
113 private Vector3 m_angularMotorVelocity = Vector3.Zero; // current angular motor velocity
114 private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate
115 private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate
116 private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate
117 private Vector3 m_lastAngularVelocity = Vector3.Zero; // what was last applied to body
118 // private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body
119
120 //Deflection properties
121 // private float m_angularDeflectionEfficiency = 0;
122 // private float m_angularDeflectionTimescale = 0;
123 // private float m_linearDeflectionEfficiency = 0;
124 // private float m_linearDeflectionTimescale = 0;
125
126 //Banking properties
127 // private float m_bankingEfficiency = 0;
128 // private float m_bankingMix = 0;
129 // private float m_bankingTimescale = 0;
130
131 //Hover and Buoyancy properties
132 private float m_VhoverHeight = 0f;
133// private float m_VhoverEfficiency = 0f;
134 private float m_VhoverTimescale = 0f;
135 private float m_VhoverTargetHeight = -1.0f; // if <0 then no hover, else its the current target height
136 private float m_VehicleBuoyancy = 0f; // Set by VEHICLE_BUOYANCY, for a vehicle.
137 // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity)
138 // KF: So far I have found no good method to combine a script-requested .Z velocity and gravity.
139 // Therefore only m_VehicleBuoyancy=1 (0g) will use the script-requested .Z velocity.
140
141 //Attractor properties
142 private float m_verticalAttractionEfficiency = 1.0f; // damped
143 private float m_verticalAttractionTimescale = 500f; // Timescale > 300 means no vert attractor.
144
145
146
147
148
149 internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
150 {
151 switch (pParam)
152 {
153 case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
154 if (pValue < 0.01f) pValue = 0.01f;
155 // m_angularDeflectionEfficiency = pValue;
156 break;
157 case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
158 if (pValue < 0.01f) pValue = 0.01f;
159 // m_angularDeflectionTimescale = pValue;
160 break;
161 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
162 if (pValue < 0.01f) pValue = 0.01f;
163 m_angularMotorDecayTimescale = pValue;
164 break;
165 case Vehicle.ANGULAR_MOTOR_TIMESCALE:
166 if (pValue < 0.01f) pValue = 0.01f;
167 m_angularMotorTimescale = pValue;
168 break;
169 case Vehicle.BANKING_EFFICIENCY:
170 if (pValue < 0.01f) pValue = 0.01f;
171 // m_bankingEfficiency = pValue;
172 break;
173 case Vehicle.BANKING_MIX:
174 if (pValue < 0.01f) pValue = 0.01f;
175 // m_bankingMix = pValue;
176 break;
177 case Vehicle.BANKING_TIMESCALE:
178 if (pValue < 0.01f) pValue = 0.01f;
179 // m_bankingTimescale = pValue;
180 break;
181 case Vehicle.BUOYANCY:
182 if (pValue < -1f) pValue = -1f;
183 if (pValue > 1f) pValue = 1f;
184 m_VehicleBuoyancy = pValue;
185 break;
186// case Vehicle.HOVER_EFFICIENCY:
187// if (pValue < 0f) pValue = 0f;
188// if (pValue > 1f) pValue = 1f;
189// m_VhoverEfficiency = pValue;
190// break;
191 case Vehicle.HOVER_HEIGHT:
192 m_VhoverHeight = pValue;
193 break;
194 case Vehicle.HOVER_TIMESCALE:
195 if (pValue < 0.01f) pValue = 0.01f;
196 m_VhoverTimescale = pValue;
197 break;
198 case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
199 if (pValue < 0.01f) pValue = 0.01f;
200 // m_linearDeflectionEfficiency = pValue;
201 break;
202 case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
203 if (pValue < 0.01f) pValue = 0.01f;
204 // m_linearDeflectionTimescale = pValue;
205 break;
206 case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
207 if (pValue < 0.01f) pValue = 0.01f;
208 m_linearMotorDecayTimescale = pValue;
209 break;
210 case Vehicle.LINEAR_MOTOR_TIMESCALE:
211 if (pValue < 0.01f) pValue = 0.01f;
212 m_linearMotorTimescale = pValue;
213 break;
214 case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
215 if (pValue < 0.1f) pValue = 0.1f; // Less goes unstable
216 if (pValue > 1.0f) pValue = 1.0f;
217 m_verticalAttractionEfficiency = pValue;
218 break;
219 case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
220 if (pValue < 0.01f) pValue = 0.01f;
221 m_verticalAttractionTimescale = pValue;
222 break;
223
224 // These are vector properties but the engine lets you use a single float value to
225 // set all of the components to the same value
226 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
227 m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
228 break;
229 case Vehicle.ANGULAR_MOTOR_DIRECTION:
230 m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
231 m_angularMotorApply = 10;
232 break;
233 case Vehicle.LINEAR_FRICTION_TIMESCALE:
234 m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
235 break;
236 case Vehicle.LINEAR_MOTOR_DIRECTION:
237 m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
238 m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
239 break;
240 case Vehicle.LINEAR_MOTOR_OFFSET:
241 // m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
242 break;
243
244 }
245
246 }//end ProcessFloatVehicleParam
247
248 internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
249 {
250 switch (pParam)
251 {
252 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
253 m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
254 break;
255 case Vehicle.ANGULAR_MOTOR_DIRECTION:
256 m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
257 // Limit requested angular speed to 2 rps= 4 pi rads/sec
258 if(m_angularMotorDirection.X > 12.56f) m_angularMotorDirection.X = 12.56f;
259 if(m_angularMotorDirection.X < - 12.56f) m_angularMotorDirection.X = - 12.56f;
260 if(m_angularMotorDirection.Y > 12.56f) m_angularMotorDirection.Y = 12.56f;
261 if(m_angularMotorDirection.Y < - 12.56f) m_angularMotorDirection.Y = - 12.56f;
262 if(m_angularMotorDirection.Z > 12.56f) m_angularMotorDirection.Z = 12.56f;
263 if(m_angularMotorDirection.Z < - 12.56f) m_angularMotorDirection.Z = - 12.56f;
264 m_angularMotorApply = 10;
265 break;
266 case Vehicle.LINEAR_FRICTION_TIMESCALE:
267 m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
268 break;
269 case Vehicle.LINEAR_MOTOR_DIRECTION:
270 m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
271 m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
272 break;
273 case Vehicle.LINEAR_MOTOR_OFFSET:
274 // m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
275 break;
276 }
277
278 }//end ProcessVectorVehicleParam
279
280 internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
281 {
282 switch (pParam)
283 {
284 case Vehicle.REFERENCE_FRAME:
285 // m_referenceFrame = pValue;
286 break;
287 }
288
289 }//end ProcessRotationVehicleParam
290
291 internal void ProcessTypeChange(Vehicle pType)
292 {
293 // Set Defaults For Type
294 m_type = pType;
295 switch (pType)
296 {
297 case Vehicle.TYPE_SLED:
298 m_linearFrictionTimescale = new Vector3(30, 1, 1000);
299 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
300 m_linearMotorDirection = Vector3.Zero;
301 m_linearMotorTimescale = 1000;
302 m_linearMotorDecayTimescale = 120;
303 m_angularMotorDirection = Vector3.Zero;
304 m_angularMotorTimescale = 1000;
305 m_angularMotorDecayTimescale = 120;
306 m_VhoverHeight = 0;
307// m_VhoverEfficiency = 1;
308 m_VhoverTimescale = 10;
309 m_VehicleBuoyancy = 0;
310 // m_linearDeflectionEfficiency = 1;
311 // m_linearDeflectionTimescale = 1;
312 // m_angularDeflectionEfficiency = 1;
313 // m_angularDeflectionTimescale = 1000;
314 // m_bankingEfficiency = 0;
315 // m_bankingMix = 1;
316 // m_bankingTimescale = 10;
317 // m_referenceFrame = Quaternion.Identity;
318 m_flags &=
319 ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
320 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
321 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
322 break;
323 case Vehicle.TYPE_CAR:
324 m_linearFrictionTimescale = new Vector3(100, 2, 1000);
325 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
326 m_linearMotorDirection = Vector3.Zero;
327 m_linearMotorTimescale = 1;
328 m_linearMotorDecayTimescale = 60;
329 m_angularMotorDirection = Vector3.Zero;
330 m_angularMotorTimescale = 1;
331 m_angularMotorDecayTimescale = 0.8f;
332 m_VhoverHeight = 0;
333// m_VhoverEfficiency = 0;
334 m_VhoverTimescale = 1000;
335 m_VehicleBuoyancy = 0;
336 // // m_linearDeflectionEfficiency = 1;
337 // // m_linearDeflectionTimescale = 2;
338 // // m_angularDeflectionEfficiency = 0;
339 // m_angularDeflectionTimescale = 10;
340 m_verticalAttractionEfficiency = 1f;
341 m_verticalAttractionTimescale = 10f;
342 // m_bankingEfficiency = -0.2f;
343 // m_bankingMix = 1;
344 // m_bankingTimescale = 1;
345 // m_referenceFrame = Quaternion.Identity;
346 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
347 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.HOVER_UP_ONLY |
348 VehicleFlag.LIMIT_MOTOR_UP);
349 break;
350 case Vehicle.TYPE_BOAT:
351 m_linearFrictionTimescale = new Vector3(10, 3, 2);
352 m_angularFrictionTimescale = new Vector3(10,10,10);
353 m_linearMotorDirection = Vector3.Zero;
354 m_linearMotorTimescale = 5;
355 m_linearMotorDecayTimescale = 60;
356 m_angularMotorDirection = Vector3.Zero;
357 m_angularMotorTimescale = 4;
358 m_angularMotorDecayTimescale = 4;
359 m_VhoverHeight = 0;
360// m_VhoverEfficiency = 0.5f;
361 m_VhoverTimescale = 2;
362 m_VehicleBuoyancy = 1;
363 // m_linearDeflectionEfficiency = 0.5f;
364 // m_linearDeflectionTimescale = 3;
365 // m_angularDeflectionEfficiency = 0.5f;
366 // m_angularDeflectionTimescale = 5;
367 m_verticalAttractionEfficiency = 0.5f;
368 m_verticalAttractionTimescale = 5f;
369 // m_bankingEfficiency = -0.3f;
370 // m_bankingMix = 0.8f;
371 // m_bankingTimescale = 1;
372 // m_referenceFrame = Quaternion.Identity;
373 m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.LIMIT_ROLL_ONLY |
374 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
375 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY |
376 VehicleFlag.LIMIT_MOTOR_UP);
377 break;
378 case Vehicle.TYPE_AIRPLANE:
379 m_linearFrictionTimescale = new Vector3(200, 10, 5);
380 m_angularFrictionTimescale = new Vector3(20, 20, 20);
381 m_linearMotorDirection = Vector3.Zero;
382 m_linearMotorTimescale = 2;
383 m_linearMotorDecayTimescale = 60;
384 m_angularMotorDirection = Vector3.Zero;
385 m_angularMotorTimescale = 4;
386 m_angularMotorDecayTimescale = 4;
387 m_VhoverHeight = 0;
388// m_VhoverEfficiency = 0.5f;
389 m_VhoverTimescale = 1000;
390 m_VehicleBuoyancy = 0;
391 // m_linearDeflectionEfficiency = 0.5f;
392 // m_linearDeflectionTimescale = 3;
393 // m_angularDeflectionEfficiency = 1;
394 // m_angularDeflectionTimescale = 2;
395 m_verticalAttractionEfficiency = 0.9f;
396 m_verticalAttractionTimescale = 2f;
397 // m_bankingEfficiency = 1;
398 // m_bankingMix = 0.7f;
399 // m_bankingTimescale = 2;
400 // m_referenceFrame = Quaternion.Identity;
401 m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
402 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
403 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
404 break;
405 case Vehicle.TYPE_BALLOON:
406 m_linearFrictionTimescale = new Vector3(5, 5, 5);
407 m_angularFrictionTimescale = new Vector3(10, 10, 10);
408 m_linearMotorDirection = Vector3.Zero;
409 m_linearMotorTimescale = 5;
410 m_linearMotorDecayTimescale = 60;
411 m_angularMotorDirection = Vector3.Zero;
412 m_angularMotorTimescale = 6;
413 m_angularMotorDecayTimescale = 10;
414 m_VhoverHeight = 5;
415// m_VhoverEfficiency = 0.8f;
416 m_VhoverTimescale = 10;
417 m_VehicleBuoyancy = 1;
418 // m_linearDeflectionEfficiency = 0;
419 // m_linearDeflectionTimescale = 5;
420 // m_angularDeflectionEfficiency = 0;
421 // m_angularDeflectionTimescale = 5;
422 m_verticalAttractionEfficiency = 1f;
423 m_verticalAttractionTimescale = 100f;
424 // m_bankingEfficiency = 0;
425 // m_bankingMix = 0.7f;
426 // m_bankingTimescale = 5;
427 // m_referenceFrame = Quaternion.Identity;
428 m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
429 VehicleFlag.HOVER_UP_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
430 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
431 break;
432
433 }
434 }//end SetDefaultsForType
435
436 internal void Enable(IntPtr pBody, OdeScene pParentScene)
437 {
438 if (m_type == Vehicle.TYPE_NONE)
439 return;
440
441 m_body = pBody;
442 }
443
444 internal void Step(float pTimestep, OdeScene pParentScene)
445 {
446 if (m_body == IntPtr.Zero || m_type == Vehicle.TYPE_NONE)
447 return;
448 frcount++; // used to limit debug comment output
449 if (frcount > 100)
450 frcount = 0;
451
452 MoveLinear(pTimestep, pParentScene);
453 MoveAngular(pTimestep);
454 }// end Step
455
456 private void MoveLinear(float pTimestep, OdeScene _pParentScene)
457 {
458 if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f)) // requested m_linearMotorDirection is significant
459 {
460 if(!d.BodyIsEnabled (Body)) d.BodyEnable (Body);
461
462 // add drive to body
463 Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep);
464 m_lastLinearVelocityVector += (addAmount*10); // lastLinearVelocityVector is the current body velocity vector?
465
466 // This will work temporarily, but we really need to compare speed on an axis
467 // KF: Limit body velocity to applied velocity?
468 if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X))
469 m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X;
470 if (Math.Abs(m_lastLinearVelocityVector.Y) > Math.Abs(m_linearMotorDirectionLASTSET.Y))
471 m_lastLinearVelocityVector.Y = m_linearMotorDirectionLASTSET.Y;
472 if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z))
473 m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z;
474
475 // decay applied velocity
476 Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep)));
477 //Console.WriteLine("decay: " + decayfraction);
478 m_linearMotorDirection -= m_linearMotorDirection * decayfraction * 0.5f;
479 //Console.WriteLine("actual: " + m_linearMotorDirection);
480 }
481 else
482 { // requested is not significant
483 // if what remains of applied is small, zero it.
484 if (m_lastLinearVelocityVector.ApproxEquals(Vector3.Zero, 0.01f))
485 m_lastLinearVelocityVector = Vector3.Zero;
486 }
487
488
489 // convert requested object velocity to world-referenced vector
490 m_dir = m_lastLinearVelocityVector;
491 d.Quaternion rot = d.BodyGetQuaternion(Body);
492 Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W); // rotq = rotation of object
493 m_dir *= rotq; // apply obj rotation to velocity vector
494
495 // add Gravity and Buoyancy
496 // KF: So far I have found no good method to combine a script-requested
497 // .Z velocity and gravity. Therefore only 0g will used script-requested
498 // .Z velocity. >0g (m_VehicleBuoyancy < 1) will used modified gravity only.
499 Vector3 grav = Vector3.Zero;
500 if(m_VehicleBuoyancy < 1.0f)
501 {
502 // There is some gravity, make a gravity force vector
503 // that is applied after object velocity.
504 d.Mass objMass;
505 d.BodyGetMass(Body, out objMass);
506 // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g;
507 grav.Z = _pParentScene.gravityz * objMass.mass * (1f - m_VehicleBuoyancy);
508 // Preserve the current Z velocity
509 d.Vector3 vel_now = d.BodyGetLinearVel(Body);
510 m_dir.Z = vel_now.Z; // Preserve the accumulated falling velocity
511 } // else its 1.0, no gravity.
512
513 // Check if hovering
514 if( (m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0)
515 {
516 // We should hover, get the target height
517 d.Vector3 pos = d.BodyGetPosition(Body);
518 if((m_flags & VehicleFlag.HOVER_WATER_ONLY) == VehicleFlag.HOVER_WATER_ONLY)
519 {
520 m_VhoverTargetHeight = _pParentScene.GetWaterLevel() + m_VhoverHeight;
521 }
522 else if((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) == VehicleFlag.HOVER_TERRAIN_ONLY)
523 {
524 m_VhoverTargetHeight = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight;
525 }
526 else if((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) == VehicleFlag.HOVER_GLOBAL_HEIGHT)
527 {
528 m_VhoverTargetHeight = m_VhoverHeight;
529 }
530
531 if((m_flags & VehicleFlag.HOVER_UP_ONLY) == VehicleFlag.HOVER_UP_ONLY)
532 {
533 // If body is aready heigher, use its height as target height
534 if(pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z;
535 }
536
537// m_VhoverEfficiency = 0f; // 0=boucy, 1=Crit.damped
538// m_VhoverTimescale = 0f; // time to acheive height
539// pTimestep is time since last frame,in secs
540 float herr0 = pos.Z - m_VhoverTargetHeight;
541 // Replace Vertical speed with correction figure if significant
542 if(Math.Abs(herr0) > 0.01f )
543 {
544 d.Mass objMass;
545 d.BodyGetMass(Body, out objMass);
546 m_dir.Z = - ( (herr0 * pTimestep * 50.0f) / m_VhoverTimescale);
547 //KF: m_VhoverEfficiency is not yet implemented
548 }
549 else
550 {
551 m_dir.Z = 0f;
552 }
553 }
554
555 // Apply velocity
556 d.BodySetLinearVel(Body, m_dir.X, m_dir.Y, m_dir.Z);
557 // apply gravity force
558 d.BodyAddForce(Body, grav.X, grav.Y, grav.Z);
559
560
561 // apply friction
562 Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep);
563 m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount;
564 } // end MoveLinear()
565
566 private void MoveAngular(float pTimestep)
567 {
568 /*
569 private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor
570 private int m_angularMotorApply = 0; // application frame counter
571 private float m_angularMotorVelocity = 0; // current angular motor velocity (ramps up and down)
572 private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate
573 private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate
574 private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate
575 private Vector3 m_lastAngularVelocity = Vector3.Zero; // what was last applied to body
576 */
577//if(frcount == 0) Console.WriteLine("MoveAngular ");
578
579 // Get what the body is doing, this includes 'external' influences
580 d.Vector3 angularVelocity = d.BodyGetAngularVel(Body);
581 // Vector3 angularVelocity = Vector3.Zero;
582
583 if (m_angularMotorApply > 0)
584 {
585 // ramp up to new value
586 // current velocity += error / ( time to get there / step interval )
587 // requested speed - last motor speed
588 m_angularMotorVelocity.X += (m_angularMotorDirection.X - m_angularMotorVelocity.X) / (m_angularMotorTimescale / pTimestep);
589 m_angularMotorVelocity.Y += (m_angularMotorDirection.Y - m_angularMotorVelocity.Y) / (m_angularMotorTimescale / pTimestep);
590 m_angularMotorVelocity.Z += (m_angularMotorDirection.Z - m_angularMotorVelocity.Z) / (m_angularMotorTimescale / pTimestep);
591
592 m_angularMotorApply--; // This is done so that if script request rate is less than phys frame rate the expected
593 // velocity may still be acheived.
594 }
595 else
596 {
597 // no motor recently applied, keep the body velocity
598 /* m_angularMotorVelocity.X = angularVelocity.X;
599 m_angularMotorVelocity.Y = angularVelocity.Y;
600 m_angularMotorVelocity.Z = angularVelocity.Z; */
601
602 // and decay the velocity
603 m_angularMotorVelocity -= m_angularMotorVelocity / (m_angularMotorDecayTimescale / pTimestep);
604 } // end motor section
605
606
607 // Vertical attractor section
608 Vector3 vertattr = Vector3.Zero;
609
610 if(m_verticalAttractionTimescale < 300)
611 {
612 float VAservo = 0.2f / (m_verticalAttractionTimescale * pTimestep);
613 // get present body rotation
614 d.Quaternion rot = d.BodyGetQuaternion(Body);
615 Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);
616 // make a vector pointing up
617 Vector3 verterr = Vector3.Zero;
618 verterr.Z = 1.0f;
619 // rotate it to Body Angle
620 verterr = verterr * rotq;
621 // verterr.X and .Y are the World error ammounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1.
622 // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go
623 // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body.
624 if (verterr.Z < 0.0f)
625 {
626 verterr.X = 2.0f - verterr.X;
627 verterr.Y = 2.0f - verterr.Y;
628 }
629 // Error is 0 (no error) to +/- 2 (max error)
630 // scale it by VAservo
631 verterr = verterr * VAservo;
632//if(frcount == 0) Console.WriteLine("VAerr=" + verterr);
633
634 // As the body rotates around the X axis, then verterr.Y increases; Rotated around Y then .X increases, so
635 // Change Body angular velocity X based on Y, and Y based on X. Z is not changed.
636 vertattr.X = verterr.Y;
637 vertattr.Y = - verterr.X;
638 vertattr.Z = 0f;
639
640 // scaling appears better usingsquare-law
641 float bounce = 1.0f - (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency);
642 vertattr.X += bounce * angularVelocity.X;
643 vertattr.Y += bounce * angularVelocity.Y;
644
645 } // else vertical attractor is off
646
647 // m_lastVertAttractor = vertattr;
648
649 // Bank section tba
650 // Deflection section tba
651
652 // Sum velocities
653 m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // tba: + bank + deflection
654
655 if (!m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f))
656 {
657 if(!d.BodyIsEnabled (Body)) d.BodyEnable (Body);
658 }
659 else
660 {
661 m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero.
662 }
663
664 // apply friction
665 Vector3 decayamount = Vector3.One / (m_angularFrictionTimescale / pTimestep);
666 m_lastAngularVelocity -= m_lastAngularVelocity * decayamount;
667
668 // Apply to the body
669 d.BodySetAngularVel (Body, m_lastAngularVelocity.X, m_lastAngularVelocity.Y, m_lastAngularVelocity.Z);
670
671 } //end MoveAngular
672 }
673}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/ChOdePlugin/ODEPrim.cs
new file mode 100644
index 0000000..0179240
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/ODEPrim.cs
@@ -0,0 +1,3273 @@
1/* Copyright (c) Contributors, http://opensimulator.org/
2 * See CONTRIBUTORS.TXT for a full list of copyright holders.
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are met:
5 * * Redistributions of source code must retain the above copyright
6 * notice, this list of conditions and the following disclaimer.
7 * * Redistributions in binary form must reproduce the above copyright
8 * notice, this list of conditions and the following disclaimer in the
9 * documentation and/or other materials provided with the distribution.
10 * * Neither the name of the OpenSimulator Project nor the
11 * names of its contributors may be used to endorse or promote products
12 * derived from this software without specific prior written permission.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
23 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces
26 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
27 * ODEPrim.cs contains methods dealing with Prim editing, Prim
28 * characteristics and Kinetic motion.
29 * ODEDynamics.cs contains methods dealing with Prim Physical motion
30 * (dynamics) and the associated settings. Old Linear and angular
31 * motors for dynamic motion have been replace with MoveLinear()
32 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
33 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
34 * switch between 'VEHICLE' parameter use and general dynamics
35 * settings use.
36 */
37
38/*
39 * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces
40 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
41 * ODEPrim.cs contains methods dealing with Prim editing, Prim
42 * characteristics and Kinetic motion.
43 * ODEDynamics.cs contains methods dealing with Prim Physical motion
44 * (dynamics) and the associated settings. Old Linear and angular
45 * motors for dynamic motion have been replace with MoveLinear()
46 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
47 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
48 * switch between 'VEHICLE' parameter use and general dynamics
49 * settings use.
50 */
51using System;
52using System.Collections.Generic;
53using System.Reflection;
54using System.Runtime.InteropServices;
55using System.Threading;
56using log4net;
57using OpenMetaverse;
58using Ode.NET;
59using OpenSim.Framework;
60using OpenSim.Region.Physics.Manager;
61
62namespace OpenSim.Region.Physics.OdePlugin
63{
64 /// <summary>
65 /// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
66 /// </summary>
67
68 public class OdePrim : PhysicsActor
69 {
70 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
71
72 private Vector3 _position;
73 private Vector3 _velocity;
74 private Vector3 _torque;
75 private Vector3 m_lastVelocity;
76 private Vector3 m_lastposition;
77 private Quaternion m_lastorientation = new Quaternion();
78 private Vector3 m_rotationalVelocity;
79 private Vector3 _size;
80 private Vector3 _acceleration;
81 // private d.Vector3 _zeroPosition = new d.Vector3(0.0f, 0.0f, 0.0f);
82 private Quaternion _orientation;
83 private Vector3 m_taintposition;
84 private Vector3 m_taintsize;
85 private Vector3 m_taintVelocity;
86 private Vector3 m_taintTorque;
87 private Quaternion m_taintrot;
88 private Vector3 m_angularlock = Vector3.One;
89 private Vector3 m_taintAngularLock = Vector3.One;
90 private IntPtr Amotor = IntPtr.Zero;
91
92 private Vector3 m_PIDTarget;
93 private float m_PIDTau;
94 private float PID_D = 35f;
95 private float PID_G = 25f;
96 private bool m_usePID = false;
97
98 private Quaternion m_APIDTarget = new Quaternion();
99 private float m_APIDStrength = 0.5f;
100 private float m_APIDDamping = 0.5f;
101 private bool m_useAPID = false;
102
103 // KF: These next 7 params apply to llSetHoverHeight(float height, integer water, float tau),
104 // and are for non-VEHICLES only.
105
106 private float m_PIDHoverHeight;
107 private float m_PIDHoverTau;
108 private bool m_useHoverPID;
109 private PIDHoverType m_PIDHoverType = PIDHoverType.Ground;
110 private float m_targetHoverHeight;
111 private float m_groundHeight;
112 private float m_waterHeight;
113 private float m_buoyancy; //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle.
114
115 // private float m_tensor = 5f;
116 private int body_autodisable_frames = 20;
117
118
119 private const CollisionCategories m_default_collisionFlags = (CollisionCategories.Geom
120 | CollisionCategories.Space
121 | CollisionCategories.Body
122 | CollisionCategories.Character
123 );
124 private bool m_taintshape;
125 private bool m_taintPhysics;
126 private bool m_collidesLand = true;
127 private bool m_collidesWater;
128 public bool m_returnCollisions;
129
130 // Default we're a Geometry
131 private CollisionCategories m_collisionCategories = (CollisionCategories.Geom);
132
133 // Default, Collide with Other Geometries, spaces and Bodies
134 private CollisionCategories m_collisionFlags = m_default_collisionFlags;
135
136 public bool m_taintremove;
137 public bool m_taintdisable;
138 public bool m_disabled;
139 public bool m_taintadd;
140 public bool m_taintselected;
141 public bool m_taintCollidesWater;
142
143 public uint m_localID;
144
145 //public GCHandle gc;
146 private CollisionLocker ode;
147
148 private bool m_taintforce = false;
149 private bool m_taintaddangularforce = false;
150 private Vector3 m_force;
151 private List<Vector3> m_forcelist = new List<Vector3>();
152 private List<Vector3> m_angularforcelist = new List<Vector3>();
153
154 private IMesh _mesh;
155 private PrimitiveBaseShape _pbs;
156 private OdeScene _parent_scene;
157 public IntPtr m_targetSpace = IntPtr.Zero;
158 public IntPtr prim_geom;
159 public IntPtr prev_geom;
160 public IntPtr _triMeshData;
161
162 private IntPtr _linkJointGroup = IntPtr.Zero;
163 private PhysicsActor _parent;
164 private PhysicsActor m_taintparent;
165
166 private List<OdePrim> childrenPrim = new List<OdePrim>();
167
168 private bool iscolliding;
169 private bool m_isphysical;
170 private bool m_isSelected;
171
172 internal bool m_isVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively
173
174 private bool m_throttleUpdates;
175 private int throttleCounter;
176 public int m_interpenetrationcount;
177 public float m_collisionscore;
178 public int m_roundsUnderMotionThreshold;
179 private int m_crossingfailures;
180
181 public bool outofBounds;
182 private float m_density = 10.000006836f; // Aluminum g/cm3;
183
184 public bool _zeroFlag;
185 private bool m_lastUpdateSent;
186
187 public IntPtr Body = IntPtr.Zero;
188 public String m_primName;
189 private Vector3 _target_velocity;
190 public d.Mass pMass;
191
192 public int m_eventsubscription;
193 private CollisionEventUpdate CollisionEventsThisFrame;
194
195 private IntPtr m_linkJoint = IntPtr.Zero;
196
197 public volatile bool childPrim;
198
199 private ODEDynamics m_vehicle;
200
201 internal int m_material = (int)Material.Wood;
202
203 private int frcount = 0; // Used to limit dynamics debug output to
204
205
206 public OdePrim(String primName, OdeScene parent_scene, Vector3 pos, Vector3 size,
207 Quaternion rotation, IMesh mesh, PrimitiveBaseShape pbs, bool pisPhysical, CollisionLocker dode)
208 {
209 m_vehicle = new ODEDynamics();
210 //gc = GCHandle.Alloc(prim_geom, GCHandleType.Pinned);
211 ode = dode;
212 if (!pos.IsFinite())
213 {
214 pos = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f),
215 parent_scene.GetTerrainHeightAtXY(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f)) + 0.5f);
216 m_log.Warn("[PHYSICS]: Got nonFinite Object create Position");
217 }
218
219 _position = pos;
220 m_taintposition = pos;
221 PID_D = parent_scene.bodyPIDD;
222 PID_G = parent_scene.bodyPIDG;
223 m_density = parent_scene.geomDefaultDensity;
224 // m_tensor = parent_scene.bodyMotorJointMaxforceTensor;
225 body_autodisable_frames = parent_scene.bodyFramesAutoDisable;
226
227
228 prim_geom = IntPtr.Zero;
229 prev_geom = IntPtr.Zero;
230
231 if (!pos.IsFinite())
232 {
233 size = new Vector3(0.5f, 0.5f, 0.5f);
234 m_log.Warn("[PHYSICS]: Got nonFinite Object create Size");
235 }
236
237 if (size.X <= 0) size.X = 0.01f;
238 if (size.Y <= 0) size.Y = 0.01f;
239 if (size.Z <= 0) size.Z = 0.01f;
240
241 _size = size;
242 m_taintsize = _size;
243
244 if (!QuaternionIsFinite(rotation))
245 {
246 rotation = Quaternion.Identity;
247 m_log.Warn("[PHYSICS]: Got nonFinite Object create Rotation");
248 }
249
250 _orientation = rotation;
251 m_taintrot = _orientation;
252 _mesh = mesh;
253 _pbs = pbs;
254
255 _parent_scene = parent_scene;
256 m_targetSpace = (IntPtr)0;
257
258// if (pos.Z < 0)
259 if (pos.Z < parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y))
260 m_isphysical = false;
261 else
262 {
263 m_isphysical = pisPhysical;
264 // If we're physical, we need to be in the master space for now.
265 // linksets *should* be in a space together.. but are not currently
266 if (m_isphysical)
267 m_targetSpace = _parent_scene.space;
268 }
269 m_primName = primName;
270 m_taintadd = true;
271 _parent_scene.AddPhysicsActorTaint(this);
272 // don't do .add() here; old geoms get recycled with the same hash
273 }
274
275 public override int PhysicsActorType
276 {
277 get { return (int) ActorTypes.Prim; }
278 set { return; }
279 }
280
281 public override bool SetAlwaysRun
282 {
283 get { return false; }
284 set { return; }
285 }
286
287 public override uint LocalID
288 {
289 set {
290 //m_log.Info("[PHYSICS]: Setting TrackerID: " + value);
291 m_localID = value; }
292 }
293
294 public override bool Grabbed
295 {
296 set { return; }
297 }
298
299 public override bool Selected
300 {
301 set {
302
303
304 // This only makes the object not collidable if the object
305 // is physical or the object is modified somehow *IN THE FUTURE*
306 // without this, if an avatar selects prim, they can walk right
307 // through it while it's selected
308 m_collisionscore = 0;
309 if ((m_isphysical && !_zeroFlag) || !value)
310 {
311 m_taintselected = value;
312 _parent_scene.AddPhysicsActorTaint(this);
313 }
314 else
315 {
316 m_taintselected = value;
317 m_isSelected = value;
318 }
319 if(m_isSelected) disableBodySoft();
320 }
321 }
322
323 public void SetGeom(IntPtr geom)
324 {
325 prev_geom = prim_geom;
326 prim_geom = geom;
327//Console.WriteLine("SetGeom to " + prim_geom + " for " + m_primName);
328 if (prim_geom != IntPtr.Zero)
329 {
330 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
331 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
332 }
333
334 if (childPrim)
335 {
336 if (_parent != null && _parent is OdePrim)
337 {
338 OdePrim parent = (OdePrim)_parent;
339//Console.WriteLine("SetGeom calls ChildSetGeom");
340 parent.ChildSetGeom(this);
341 }
342 }
343 //m_log.Warn("Setting Geom to: " + prim_geom);
344 }
345
346
347
348 public void enableBodySoft()
349 {
350 if (!childPrim)
351 {
352 if (m_isphysical && Body != IntPtr.Zero)
353 {
354 d.BodyEnable(Body);
355 if (m_vehicle.Type != Vehicle.TYPE_NONE)
356 m_vehicle.Enable(Body, _parent_scene);
357 }
358
359 m_disabled = false;
360 }
361 }
362
363 public void disableBodySoft()
364 {
365 m_disabled = true;
366
367 if (m_isphysical && Body != IntPtr.Zero)
368 {
369 d.BodyDisable(Body);
370 }
371 }
372
373 public void enableBody()
374 {
375 // Don't enable this body if we're a child prim
376 // this should be taken care of in the parent function not here
377 if (!childPrim)
378 {
379 // Sets the geom to a body
380 Body = d.BodyCreate(_parent_scene.world);
381
382 setMass();
383 d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
384 d.Quaternion myrot = new d.Quaternion();
385 myrot.X = _orientation.X;
386 myrot.Y = _orientation.Y;
387 myrot.Z = _orientation.Z;
388 myrot.W = _orientation.W;
389 d.BodySetQuaternion(Body, ref myrot);
390 d.GeomSetBody(prim_geom, Body);
391 m_collisionCategories |= CollisionCategories.Body;
392 m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
393
394 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
395 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
396
397 d.BodySetAutoDisableFlag(Body, true);
398 d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
399
400 // disconnect from world gravity so we can apply buoyancy
401 d.BodySetGravityMode (Body, false);
402
403 m_interpenetrationcount = 0;
404 m_collisionscore = 0;
405 m_disabled = false;
406
407 // The body doesn't already have a finite rotation mode set here
408 if ((!m_angularlock.ApproxEquals(Vector3.Zero, 0.0f)) && _parent == null)
409 {
410 createAMotor(m_angularlock);
411 }
412 if (m_vehicle.Type != Vehicle.TYPE_NONE)
413 {
414 m_vehicle.Enable(Body, _parent_scene);
415 }
416
417 _parent_scene.addActivePrim(this);
418 }
419 }
420
421 #region Mass Calculation
422
423 private float CalculateMass()
424 {
425 float volume = 0;
426
427 // No material is passed to the physics engines yet.. soo..
428 // we're using the m_density constant in the class definition
429
430 float returnMass = 0;
431
432 switch (_pbs.ProfileShape)
433 {
434 case ProfileShape.Square:
435 // Profile Volume
436
437 volume = _size.X*_size.Y*_size.Z;
438
439 // If the user has 'hollowed out'
440 // ProfileHollow is one of those 0 to 50000 values :P
441 // we like percentages better.. so turning into a percentage
442
443 if (((float) _pbs.ProfileHollow/50000f) > 0.0)
444 {
445 float hollowAmount = (float) _pbs.ProfileHollow/50000f;
446
447 // calculate the hollow volume by it's shape compared to the prim shape
448 float hollowVolume = 0;
449 switch (_pbs.HollowShape)
450 {
451 case HollowShape.Square:
452 case HollowShape.Same:
453 // Cube Hollow volume calculation
454 float hollowsizex = _size.X*hollowAmount;
455 float hollowsizey = _size.Y*hollowAmount;
456 float hollowsizez = _size.Z*hollowAmount;
457 hollowVolume = hollowsizex*hollowsizey*hollowsizez;
458 break;
459
460 case HollowShape.Circle:
461 // Hollow shape is a perfect cyllinder in respect to the cube's scale
462 // Cyllinder hollow volume calculation
463 float hRadius = _size.X/2;
464 float hLength = _size.Z;
465
466 // pi * r2 * h
467 hollowVolume = ((float) (Math.PI*Math.Pow(hRadius, 2)*hLength)*hollowAmount);
468 break;
469
470 case HollowShape.Triangle:
471 // Equilateral Triangular Prism volume hollow calculation
472 // Triangle is an Equilateral Triangular Prism with aLength = to _size.Y
473
474 float aLength = _size.Y;
475 // 1/2 abh
476 hollowVolume = (float) ((0.5*aLength*_size.X*_size.Z)*hollowAmount);
477 break;
478
479 default:
480 hollowVolume = 0;
481 break;
482 }
483 volume = volume - hollowVolume;
484 }
485
486 break;
487 case ProfileShape.Circle:
488 if (_pbs.PathCurve == (byte)Extrusion.Straight)
489 {
490 // Cylinder
491 float volume1 = (float)(Math.PI * Math.Pow(_size.X/2, 2) * _size.Z);
492 float volume2 = (float)(Math.PI * Math.Pow(_size.Y/2, 2) * _size.Z);
493
494 // Approximating the cylinder's irregularity.
495 if (volume1 > volume2)
496 {
497 volume = (float)volume1 - (volume1 - volume2);
498 }
499 else if (volume2 > volume1)
500 {
501 volume = (float)volume2 - (volume2 - volume1);
502 }
503 else
504 {
505 // Regular cylinder
506 volume = volume1;
507 }
508 }
509 else
510 {
511 // We don't know what the shape is yet, so use default
512 volume = _size.X * _size.Y * _size.Z;
513 }
514 // If the user has 'hollowed out'
515 // ProfileHollow is one of those 0 to 50000 values :P
516 // we like percentages better.. so turning into a percentage
517
518 if (((float)_pbs.ProfileHollow / 50000f) > 0.0)
519 {
520 float hollowAmount = (float)_pbs.ProfileHollow / 50000f;
521
522 // calculate the hollow volume by it's shape compared to the prim shape
523 float hollowVolume = 0;
524 switch (_pbs.HollowShape)
525 {
526 case HollowShape.Same:
527 case HollowShape.Circle:
528 // Hollow shape is a perfect cyllinder in respect to the cube's scale
529 // Cyllinder hollow volume calculation
530 float hRadius = _size.X / 2;
531 float hLength = _size.Z;
532
533 // pi * r2 * h
534 hollowVolume = ((float)(Math.PI * Math.Pow(hRadius, 2) * hLength) * hollowAmount);
535 break;
536
537 case HollowShape.Square:
538 // Cube Hollow volume calculation
539 float hollowsizex = _size.X * hollowAmount;
540 float hollowsizey = _size.Y * hollowAmount;
541 float hollowsizez = _size.Z * hollowAmount;
542 hollowVolume = hollowsizex * hollowsizey * hollowsizez;
543 break;
544
545 case HollowShape.Triangle:
546 // Equilateral Triangular Prism volume hollow calculation
547 // Triangle is an Equilateral Triangular Prism with aLength = to _size.Y
548
549 float aLength = _size.Y;
550 // 1/2 abh
551 hollowVolume = (float)((0.5 * aLength * _size.X * _size.Z) * hollowAmount);
552 break;
553
554 default:
555 hollowVolume = 0;
556 break;
557 }
558 volume = volume - hollowVolume;
559 }
560 break;
561
562 case ProfileShape.HalfCircle:
563 if (_pbs.PathCurve == (byte)Extrusion.Curve1)
564 {
565 if (_size.X == _size.Y && _size.Y == _size.Z)
566 {
567 // regular sphere
568 // v = 4/3 * pi * r^3
569 float sradius3 = (float)Math.Pow((_size.X / 2), 3);
570 volume = (float)((4f / 3f) * Math.PI * sradius3);
571 }
572 else
573 {
574 // we treat this as a box currently
575 volume = _size.X * _size.Y * _size.Z;
576 }
577 }
578 else
579 {
580 // We don't know what the shape is yet, so use default
581 volume = _size.X * _size.Y * _size.Z;
582 }
583 break;
584
585 case ProfileShape.EquilateralTriangle:
586 /*
587 v = (abs((xB*yA-xA*yB)+(xC*yB-xB*yC)+(xA*yC-xC*yA))/2) * h
588
589 // seed mesh
590 Vertex MM = new Vertex(-0.25f, -0.45f, 0.0f);
591 Vertex PM = new Vertex(+0.5f, 0f, 0.0f);
592 Vertex PP = new Vertex(-0.25f, +0.45f, 0.0f);
593 */
594 float xA = -0.25f * _size.X;
595 float yA = -0.45f * _size.Y;
596
597 float xB = 0.5f * _size.X;
598 float yB = 0;
599
600 float xC = -0.25f * _size.X;
601 float yC = 0.45f * _size.Y;
602
603 volume = (float)((Math.Abs((xB * yA - xA * yB) + (xC * yB - xB * yC) + (xA * yC - xC * yA)) / 2) * _size.Z);
604
605 // If the user has 'hollowed out'
606 // ProfileHollow is one of those 0 to 50000 values :P
607 // we like percentages better.. so turning into a percentage
608 float fhollowFactor = ((float)_pbs.ProfileHollow / 1.9f);
609 if (((float)fhollowFactor / 50000f) > 0.0)
610 {
611 float hollowAmount = (float)fhollowFactor / 50000f;
612
613 // calculate the hollow volume by it's shape compared to the prim shape
614 float hollowVolume = 0;
615 switch (_pbs.HollowShape)
616 {
617 case HollowShape.Same:
618 case HollowShape.Triangle:
619 // Equilateral Triangular Prism volume hollow calculation
620 // Triangle is an Equilateral Triangular Prism with aLength = to _size.Y
621
622 float aLength = _size.Y;
623 // 1/2 abh
624 hollowVolume = (float)((0.5 * aLength * _size.X * _size.Z) * hollowAmount);
625 break;
626
627 case HollowShape.Square:
628 // Cube Hollow volume calculation
629 float hollowsizex = _size.X * hollowAmount;
630 float hollowsizey = _size.Y * hollowAmount;
631 float hollowsizez = _size.Z * hollowAmount;
632 hollowVolume = hollowsizex * hollowsizey * hollowsizez;
633 break;
634
635 case HollowShape.Circle:
636 // Hollow shape is a perfect cyllinder in respect to the cube's scale
637 // Cyllinder hollow volume calculation
638 float hRadius = _size.X / 2;
639 float hLength = _size.Z;
640
641 // pi * r2 * h
642 hollowVolume = ((float)((Math.PI * Math.Pow(hRadius, 2) * hLength)/2) * hollowAmount);
643 break;
644
645 default:
646 hollowVolume = 0;
647 break;
648 }
649 volume = volume - hollowVolume;
650 }
651 break;
652
653 default:
654 // we don't have all of the volume formulas yet so
655 // use the common volume formula for all
656 volume = _size.X*_size.Y*_size.Z;
657 break;
658 }
659
660 // Calculate Path cut effect on volume
661 // Not exact, in the triangle hollow example
662 // They should never be zero or less then zero..
663 // we'll ignore it if it's less then zero
664
665 // ProfileEnd and ProfileBegin are values
666 // from 0 to 50000
667
668 // Turning them back into percentages so that I can cut that percentage off the volume
669
670 float PathCutEndAmount = _pbs.ProfileEnd;
671 float PathCutStartAmount = _pbs.ProfileBegin;
672 if (((PathCutStartAmount + PathCutEndAmount)/50000f) > 0.0f)
673 {
674 float pathCutAmount = ((PathCutStartAmount + PathCutEndAmount)/50000f);
675
676 // Check the return amount for sanity
677 if (pathCutAmount >= 0.99f)
678 pathCutAmount = 0.99f;
679
680 volume = volume - (volume*pathCutAmount);
681 }
682 UInt16 taperX = _pbs.PathScaleX;
683 UInt16 taperY = _pbs.PathScaleY;
684 float taperFactorX = 0;
685 float taperFactorY = 0;
686
687 // Mass = density * volume
688 if (taperX != 100)
689 {
690 if (taperX > 100)
691 {
692 taperFactorX = 1.0f - ((float)taperX / 200);
693 //m_log.Warn("taperTopFactorX: " + extr.taperTopFactorX.ToString());
694 }
695 else
696 {
697 taperFactorX = 1.0f - ((100 - (float)taperX) / 100);
698 //m_log.Warn("taperBotFactorX: " + extr.taperBotFactorX.ToString());
699 }
700 volume = (float)volume * ((taperFactorX / 3f) + 0.001f);
701 }
702
703 if (taperY != 100)
704 {
705 if (taperY > 100)
706 {
707 taperFactorY = 1.0f - ((float)taperY / 200);
708 //m_log.Warn("taperTopFactorY: " + extr.taperTopFactorY.ToString());
709 }
710 else
711 {
712 taperFactorY = 1.0f - ((100 - (float)taperY) / 100);
713 //m_log.Warn("taperBotFactorY: " + extr.taperBotFactorY.ToString());
714 }
715 volume = (float)volume * ((taperFactorY / 3f) + 0.001f);
716 }
717 returnMass = m_density*volume;
718 if (returnMass <= 0) returnMass = 0.0001f;//ckrinke: Mass must be greater then zero.
719
720
721
722 // Recursively calculate mass
723 bool HasChildPrim = false;
724 lock (childrenPrim)
725 {
726 if (childrenPrim.Count > 0)
727 {
728 HasChildPrim = true;
729 }
730
731 }
732 if (HasChildPrim)
733 {
734 OdePrim[] childPrimArr = new OdePrim[0];
735
736 lock (childrenPrim)
737 childPrimArr = childrenPrim.ToArray();
738
739 for (int i = 0; i < childPrimArr.Length; i++)
740 {
741 if (childPrimArr[i] != null && !childPrimArr[i].m_taintremove)
742 returnMass += childPrimArr[i].CalculateMass();
743 // failsafe, this shouldn't happen but with OpenSim, you never know :)
744 if (i > 256)
745 break;
746 }
747 }
748 if (returnMass > _parent_scene.maximumMassObject)
749 returnMass = _parent_scene.maximumMassObject;
750 return returnMass;
751 }// end CalculateMass
752
753 #endregion
754
755 public void setMass()
756 {
757 if (Body != (IntPtr) 0)
758 {
759 float newmass = CalculateMass();
760
761 //m_log.Info("[PHYSICS]: New Mass: " + newmass.ToString());
762
763 d.MassSetBoxTotal(out pMass, newmass, _size.X, _size.Y, _size.Z);
764 d.BodySetMass(Body, ref pMass);
765 }
766 }
767
768 public void disableBody()
769 {
770 //this kills the body so things like 'mesh' can re-create it.
771 lock (this)
772 {
773 if (!childPrim)
774 {
775 if (Body != IntPtr.Zero)
776 {
777 _parent_scene.remActivePrim(this);
778 m_collisionCategories &= ~CollisionCategories.Body;
779 m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
780
781 if (prim_geom != IntPtr.Zero)
782 {
783 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
784 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
785 }
786
787
788 d.BodyDestroy(Body);
789 lock (childrenPrim)
790 {
791 if (childrenPrim.Count > 0)
792 {
793 foreach (OdePrim prm in childrenPrim)
794 {
795 _parent_scene.remActivePrim(prm);
796 prm.Body = IntPtr.Zero;
797 }
798 }
799 }
800 Body = IntPtr.Zero;
801 }
802 }
803 else
804 {
805 _parent_scene.remActivePrim(this);
806
807 m_collisionCategories &= ~CollisionCategories.Body;
808 m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
809
810 if (prim_geom != IntPtr.Zero)
811 {
812 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
813 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
814 }
815
816
817 Body = IntPtr.Zero;
818 }
819 }
820 m_disabled = true;
821 m_collisionscore = 0;
822 }
823
824 private static Dictionary<IMesh, IntPtr> m_MeshToTriMeshMap = new Dictionary<IMesh, IntPtr>();
825
826 public void setMesh(OdeScene parent_scene, IMesh mesh)
827 {
828 // This sleeper is there to moderate how long it takes between
829 // setting up the mesh and pre-processing it when we get rapid fire mesh requests on a single object
830
831 //Thread.Sleep(10);
832
833 //Kill Body so that mesh can re-make the geom
834 if (IsPhysical && Body != IntPtr.Zero)
835 {
836 if (childPrim)
837 {
838 if (_parent != null)
839 {
840 OdePrim parent = (OdePrim)_parent;
841 parent.ChildDelink(this);
842 }
843 }
844 else
845 {
846 disableBody();
847 }
848 }
849
850 IntPtr vertices, indices;
851 int vertexCount, indexCount;
852 int vertexStride, triStride;
853 mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount); // Note, that vertices are fixed in unmanaged heap
854 mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount); // Also fixed, needs release after usage
855
856 mesh.releaseSourceMeshData(); // free up the original mesh data to save memory
857 if (m_MeshToTriMeshMap.ContainsKey(mesh))
858 {
859 _triMeshData = m_MeshToTriMeshMap[mesh];
860 }
861 else
862 {
863 _triMeshData = d.GeomTriMeshDataCreate();
864
865 d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);
866 d.GeomTriMeshDataPreprocess(_triMeshData);
867 m_MeshToTriMeshMap[mesh] = _triMeshData;
868 }
869
870 _parent_scene.waitForSpaceUnlock(m_targetSpace);
871 try
872 {
873 if (prim_geom == IntPtr.Zero)
874 {
875 SetGeom(d.CreateTriMesh(m_targetSpace, _triMeshData, parent_scene.triCallback, null, null));
876 }
877 }
878 catch (AccessViolationException)
879 {
880 m_log.Error("[PHYSICS]: MESH LOCKED");
881 return;
882 }
883
884
885 // if (IsPhysical && Body == (IntPtr) 0)
886 // {
887 // Recreate the body
888 // m_interpenetrationcount = 0;
889 // m_collisionscore = 0;
890
891 // enableBody();
892 // }
893 }
894
895 public void ProcessTaints(float timestep)
896 {
897//Console.WriteLine("ProcessTaints for " + m_primName );
898 if (m_taintadd)
899 {
900 changeadd(timestep);
901 }
902
903 if (prim_geom != IntPtr.Zero)
904 {
905 if (!_position.ApproxEquals(m_taintposition, 0f))
906 changemove(timestep);
907
908 if (m_taintrot != _orientation)
909 {
910 if(childPrim && IsPhysical) // For physical child prim...
911 {
912 rotate(timestep);
913 // KF: ODE will also rotate the parent prim!
914 // so rotate the root back to where it was
915 OdePrim parent = (OdePrim)_parent;
916 parent.rotate(timestep);
917 }
918 else
919 {
920 //Just rotate the prim
921 rotate(timestep);
922 }
923 }
924 //
925
926 if (m_taintPhysics != m_isphysical && !(m_taintparent != _parent))
927 changePhysicsStatus(timestep);
928 //
929
930 if (!_size.ApproxEquals(m_taintsize,0f))
931 changesize(timestep);
932 //
933
934 if (m_taintshape)
935 changeshape(timestep);
936 //
937
938 if (m_taintforce)
939 changeAddForce(timestep);
940
941 if (m_taintaddangularforce)
942 changeAddAngularForce(timestep);
943
944 if (!m_taintTorque.ApproxEquals(Vector3.Zero, 0.001f))
945 changeSetTorque(timestep);
946
947 if (m_taintdisable)
948 changedisable(timestep);
949
950 if (m_taintselected != m_isSelected)
951 changeSelectedStatus(timestep);
952
953 if (!m_taintVelocity.ApproxEquals(Vector3.Zero, 0.001f))
954 changevelocity(timestep);
955
956 if (m_taintparent != _parent)
957 changelink(timestep);
958
959 if (m_taintCollidesWater != m_collidesWater)
960 changefloatonwater(timestep);
961
962 if (!m_angularlock.ApproxEquals(m_taintAngularLock,0f))
963 changeAngularLock(timestep);
964
965 }
966 else
967 {
968 m_log.Error("[PHYSICS]: The scene reused a disposed PhysActor! *waves finger*, Don't be evil. A couple of things can cause this. An improper prim breakdown(be sure to set prim_geom to zero after d.GeomDestroy! An improper buildup (creating the geom failed). Or, the Scene Reused a physics actor after disposing it.)");
969 }
970 }
971
972
973 private void changeAngularLock(float timestep)
974 {
975 // do we have a Physical object?
976 if (Body != IntPtr.Zero)
977 {
978 //Check that we have a Parent
979 //If we have a parent then we're not authorative here
980 if (_parent == null)
981 {
982 if (!m_taintAngularLock.ApproxEquals(Vector3.One, 0f))
983 {
984 //d.BodySetFiniteRotationMode(Body, 0);
985 //d.BodySetFiniteRotationAxis(Body,m_taintAngularLock.X,m_taintAngularLock.Y,m_taintAngularLock.Z);
986 createAMotor(m_taintAngularLock);
987 }
988 else
989 {
990 if (Amotor != IntPtr.Zero)
991 {
992 d.JointDestroy(Amotor);
993 Amotor = IntPtr.Zero;
994 }
995 }
996 }
997 }
998 // Store this for later in case we get turned into a separate body
999 m_angularlock = m_taintAngularLock;
1000
1001 }
1002
1003 private void changelink(float timestep)
1004 {
1005 // If the newly set parent is not null
1006 // create link
1007 if (_parent == null && m_taintparent != null)
1008 {
1009 if (m_taintparent.PhysicsActorType == (int)ActorTypes.Prim)
1010 {
1011 OdePrim obj = (OdePrim)m_taintparent;
1012 //obj.disableBody();
1013//Console.WriteLine("changelink calls ParentPrim");
1014 obj.ParentPrim(this);
1015
1016 /*
1017 if (obj.Body != (IntPtr)0 && Body != (IntPtr)0 && obj.Body != Body)
1018 {
1019 _linkJointGroup = d.JointGroupCreate(0);
1020 m_linkJoint = d.JointCreateFixed(_parent_scene.world, _linkJointGroup);
1021 d.JointAttach(m_linkJoint, obj.Body, Body);
1022 d.JointSetFixed(m_linkJoint);
1023 }
1024 */
1025 }
1026 }
1027 // If the newly set parent is null
1028 // destroy link
1029 else if (_parent != null && m_taintparent == null)
1030 {
1031//Console.WriteLine(" changelink B");
1032
1033 if (_parent is OdePrim)
1034 {
1035 OdePrim obj = (OdePrim)_parent;
1036 obj.ChildDelink(this);
1037 childPrim = false;
1038 //_parent = null;
1039 }
1040
1041 /*
1042 if (Body != (IntPtr)0 && _linkJointGroup != (IntPtr)0)
1043 d.JointGroupDestroy(_linkJointGroup);
1044
1045 _linkJointGroup = (IntPtr)0;
1046 m_linkJoint = (IntPtr)0;
1047 */
1048 }
1049
1050 _parent = m_taintparent;
1051 m_taintPhysics = m_isphysical;
1052 }
1053
1054 // I'm the parent
1055 // prim is the child
1056 public void ParentPrim(OdePrim prim)
1057 {
1058//Console.WriteLine("ParentPrim " + m_primName);
1059 if (this.m_localID != prim.m_localID)
1060 {
1061 if (Body == IntPtr.Zero)
1062 {
1063 Body = d.BodyCreate(_parent_scene.world);
1064 setMass();
1065 }
1066 if (Body != IntPtr.Zero)
1067 {
1068 lock (childrenPrim)
1069 {
1070 if (!childrenPrim.Contains(prim))
1071 {
1072//Console.WriteLine("childrenPrim.Add " + prim);
1073 childrenPrim.Add(prim);
1074
1075 foreach (OdePrim prm in childrenPrim)
1076 {
1077 d.Mass m2;
1078 d.MassSetZero(out m2);
1079 d.MassSetBoxTotal(out m2, prim.CalculateMass(), prm._size.X, prm._size.Y, prm._size.Z);
1080
1081
1082 d.Quaternion quat = new d.Quaternion();
1083 quat.W = prm._orientation.W;
1084 quat.X = prm._orientation.X;
1085 quat.Y = prm._orientation.Y;
1086 quat.Z = prm._orientation.Z;
1087
1088 d.Matrix3 mat = new d.Matrix3();
1089 d.RfromQ(out mat, ref quat);
1090 d.MassRotate(ref m2, ref mat);
1091 d.MassTranslate(ref m2, Position.X - prm.Position.X, Position.Y - prm.Position.Y, Position.Z - prm.Position.Z);
1092 d.MassAdd(ref pMass, ref m2);
1093 }
1094 foreach (OdePrim prm in childrenPrim)
1095 {
1096
1097 prm.m_collisionCategories |= CollisionCategories.Body;
1098 prm.m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
1099
1100 if (prm.prim_geom == IntPtr.Zero)
1101 {
1102 m_log.Warn("[PHYSICS]: Unable to link one of the linkset elements. No geom yet");
1103 continue;
1104 }
1105//Console.WriteLine(" GeomSetCategoryBits 1: " + prm.prim_geom + " - " + (int)prm.m_collisionCategories + " for " + m_primName);
1106 d.GeomSetCategoryBits(prm.prim_geom, (int)prm.m_collisionCategories);
1107 d.GeomSetCollideBits(prm.prim_geom, (int)prm.m_collisionFlags);
1108
1109
1110 d.Quaternion quat = new d.Quaternion();
1111 quat.W = prm._orientation.W;
1112 quat.X = prm._orientation.X;
1113 quat.Y = prm._orientation.Y;
1114 quat.Z = prm._orientation.Z;
1115
1116 d.Matrix3 mat = new d.Matrix3();
1117 d.RfromQ(out mat, ref quat);
1118 if (Body != IntPtr.Zero)
1119 {
1120 d.GeomSetBody(prm.prim_geom, Body);
1121 prm.childPrim = true;
1122 d.GeomSetOffsetWorldPosition(prm.prim_geom, prm.Position.X , prm.Position.Y, prm.Position.Z);
1123 //d.GeomSetOffsetPosition(prim.prim_geom,
1124 // (Position.X - prm.Position.X) - pMass.c.X,
1125 // (Position.Y - prm.Position.Y) - pMass.c.Y,
1126 // (Position.Z - prm.Position.Z) - pMass.c.Z);
1127 d.GeomSetOffsetWorldRotation(prm.prim_geom, ref mat);
1128 //d.GeomSetOffsetRotation(prm.prim_geom, ref mat);
1129 d.MassTranslate(ref pMass, -pMass.c.X, -pMass.c.Y, -pMass.c.Z);
1130 d.BodySetMass(Body, ref pMass);
1131 }
1132 else
1133 {
1134 m_log.Debug("[PHYSICS]:I ain't got no boooooooooddy, no body");
1135 }
1136
1137
1138 prm.m_interpenetrationcount = 0;
1139 prm.m_collisionscore = 0;
1140 prm.m_disabled = false;
1141
1142 // The body doesn't already have a finite rotation mode set here
1143 if ((!m_angularlock.ApproxEquals(Vector3.Zero, 0f)) && _parent == null)
1144 {
1145 prm.createAMotor(m_angularlock);
1146 }
1147 prm.Body = Body;
1148 _parent_scene.addActivePrim(prm);
1149 }
1150 m_collisionCategories |= CollisionCategories.Body;
1151 m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
1152
1153//Console.WriteLine("GeomSetCategoryBits 2: " + prim_geom + " - " + (int)m_collisionCategories + " for " + m_primName);
1154 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
1155//Console.WriteLine(" Post GeomSetCategoryBits 2");
1156 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
1157
1158
1159 d.Quaternion quat2 = new d.Quaternion();
1160 quat2.W = _orientation.W;
1161 quat2.X = _orientation.X;
1162 quat2.Y = _orientation.Y;
1163 quat2.Z = _orientation.Z;
1164
1165 d.Matrix3 mat2 = new d.Matrix3();
1166 d.RfromQ(out mat2, ref quat2);
1167 d.GeomSetBody(prim_geom, Body);
1168 d.GeomSetOffsetWorldPosition(prim_geom, Position.X - pMass.c.X, Position.Y - pMass.c.Y, Position.Z - pMass.c.Z);
1169 //d.GeomSetOffsetPosition(prim.prim_geom,
1170 // (Position.X - prm.Position.X) - pMass.c.X,
1171 // (Position.Y - prm.Position.Y) - pMass.c.Y,
1172 // (Position.Z - prm.Position.Z) - pMass.c.Z);
1173 //d.GeomSetOffsetRotation(prim_geom, ref mat2);
1174 d.MassTranslate(ref pMass, -pMass.c.X, -pMass.c.Y, -pMass.c.Z);
1175 d.BodySetMass(Body, ref pMass);
1176
1177 d.BodySetAutoDisableFlag(Body, true);
1178 d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
1179
1180
1181 m_interpenetrationcount = 0;
1182 m_collisionscore = 0;
1183 m_disabled = false;
1184
1185 // The body doesn't already have a finite rotation mode set here
1186 if ((!m_angularlock.ApproxEquals(Vector3.Zero, 0f)) && _parent == null)
1187 {
1188 createAMotor(m_angularlock);
1189 }
1190 d.BodySetPosition(Body, Position.X, Position.Y, Position.Z);
1191 if (m_vehicle.Type != Vehicle.TYPE_NONE) m_vehicle.Enable(Body, _parent_scene);
1192 _parent_scene.addActivePrim(this);
1193 }
1194 }
1195 }
1196 }
1197
1198 }
1199
1200 private void ChildSetGeom(OdePrim odePrim)
1201 {
1202 //if (m_isphysical && Body != IntPtr.Zero)
1203 lock (childrenPrim)
1204 {
1205 foreach (OdePrim prm in childrenPrim)
1206 {
1207 //prm.childPrim = true;
1208 prm.disableBody();
1209 //prm.m_taintparent = null;
1210 //prm._parent = null;
1211 //prm.m_taintPhysics = false;
1212 //prm.m_disabled = true;
1213 //prm.childPrim = false;
1214 }
1215 }
1216 disableBody();
1217
1218
1219 if (Body != IntPtr.Zero)
1220 {
1221 _parent_scene.remActivePrim(this);
1222 }
1223
1224 lock (childrenPrim)
1225 {
1226 foreach (OdePrim prm in childrenPrim)
1227 {
1228//Console.WriteLine("ChildSetGeom calls ParentPrim");
1229 ParentPrim(prm);
1230 }
1231 }
1232
1233 }
1234
1235 private void ChildDelink(OdePrim odePrim)
1236 {
1237 // Okay, we have a delinked child.. need to rebuild the body.
1238 lock (childrenPrim)
1239 {
1240 foreach (OdePrim prm in childrenPrim)
1241 {
1242 prm.childPrim = true;
1243 prm.disableBody();
1244 //prm.m_taintparent = null;
1245 //prm._parent = null;
1246 //prm.m_taintPhysics = false;
1247 //prm.m_disabled = true;
1248 //prm.childPrim = false;
1249 }
1250 }
1251 disableBody();
1252
1253 lock (childrenPrim)
1254 {
1255 //Console.WriteLine("childrenPrim.Remove " + odePrim);
1256 childrenPrim.Remove(odePrim);
1257 }
1258
1259
1260
1261
1262 if (Body != IntPtr.Zero)
1263 {
1264 _parent_scene.remActivePrim(this);
1265 }
1266
1267
1268
1269 lock (childrenPrim)
1270 {
1271 foreach (OdePrim prm in childrenPrim)
1272 {
1273//Console.WriteLine("ChildDelink calls ParentPrim");
1274 ParentPrim(prm);
1275 }
1276 }
1277
1278
1279 }
1280
1281 private void changeSelectedStatus(float timestep)
1282 {
1283 if (m_taintselected)
1284 {
1285 m_collisionCategories = CollisionCategories.Selected;
1286 m_collisionFlags = (CollisionCategories.Sensor | CollisionCategories.Space);
1287
1288 // We do the body disable soft twice because 'in theory' a collision could have happened
1289 // in between the disabling and the collision properties setting
1290 // which would wake the physical body up from a soft disabling and potentially cause it to fall
1291 // through the ground.
1292
1293 // NOTE FOR JOINTS: this doesn't always work for jointed assemblies because if you select
1294 // just one part of the assembly, the rest of the assembly is non-selected and still simulating,
1295 // so that causes the selected part to wake up and continue moving.
1296
1297 // even if you select all parts of a jointed assembly, it is not guaranteed that the entire
1298 // assembly will stop simulating during the selection, because of the lack of atomicity
1299 // of select operations (their processing could be interrupted by a thread switch, causing
1300 // simulation to continue before all of the selected object notifications trickle down to
1301 // the physics engine).
1302
1303 // e.g. we select 100 prims that are connected by joints. non-atomically, the first 50 are
1304 // selected and disabled. then, due to a thread switch, the selection processing is
1305 // interrupted and the physics engine continues to simulate, so the last 50 items, whose
1306 // selection was not yet processed, continues to simulate. this wakes up ALL of the
1307 // first 50 again. then the last 50 are disabled. then the first 50, which were just woken
1308 // up, start simulating again, which in turn wakes up the last 50.
1309
1310 if (m_isphysical)
1311 {
1312 disableBodySoft();
1313 }
1314
1315 if (prim_geom != IntPtr.Zero)
1316 {
1317 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
1318 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
1319 }
1320
1321 if (m_isphysical)
1322 {
1323 disableBodySoft();
1324 }
1325 }
1326 else
1327 {
1328 m_collisionCategories = CollisionCategories.Geom;
1329
1330 if (m_isphysical)
1331 m_collisionCategories |= CollisionCategories.Body;
1332
1333 m_collisionFlags = m_default_collisionFlags;
1334
1335 if (m_collidesLand)
1336 m_collisionFlags |= CollisionCategories.Land;
1337 if (m_collidesWater)
1338 m_collisionFlags |= CollisionCategories.Water;
1339
1340 if (prim_geom != IntPtr.Zero)
1341 {
1342 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
1343 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
1344 }
1345 if (m_isphysical)
1346 {
1347 if (Body != IntPtr.Zero)
1348 {
1349 d.BodySetLinearVel(Body, 0f, 0f, 0f);
1350 d.BodySetForce(Body, 0, 0, 0);
1351 enableBodySoft();
1352 }
1353 }
1354 }
1355
1356 resetCollisionAccounting();
1357 m_isSelected = m_taintselected;
1358 }//end changeSelectedStatus
1359
1360 public void ResetTaints()
1361 {
1362 m_taintposition = _position;
1363 m_taintrot = _orientation;
1364 m_taintPhysics = m_isphysical;
1365 m_taintselected = m_isSelected;
1366 m_taintsize = _size;
1367 m_taintshape = false;
1368 m_taintforce = false;
1369 m_taintdisable = false;
1370 m_taintVelocity = Vector3.Zero;
1371 }
1372
1373 public void CreateGeom(IntPtr m_targetSpace, IMesh _mesh)
1374 {
1375//Console.WriteLine("CreateGeom:");
1376 if (_mesh != null)
1377 {
1378 setMesh(_parent_scene, _mesh);
1379 }
1380 else
1381 {
1382 if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1)
1383 {
1384 if (_size.X == _size.Y && _size.Y == _size.Z && _size.X == _size.Z)
1385 {
1386 if (((_size.X / 2f) > 0f))
1387 {
1388 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1389 try
1390 {
1391//Console.WriteLine(" CreateGeom 1");
1392 SetGeom(d.CreateSphere(m_targetSpace, _size.X / 2));
1393 }
1394 catch (AccessViolationException)
1395 {
1396 m_log.Warn("[PHYSICS]: Unable to create physics proxy for object");
1397 ode.dunlock(_parent_scene.world);
1398 return;
1399 }
1400 }
1401 else
1402 {
1403 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1404 try
1405 {
1406//Console.WriteLine(" CreateGeom 2");
1407 SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
1408 }
1409 catch (AccessViolationException)
1410 {
1411 m_log.Warn("[PHYSICS]: Unable to create physics proxy for object");
1412 ode.dunlock(_parent_scene.world);
1413 return;
1414 }
1415 }
1416 }
1417 else
1418 {
1419 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1420 try
1421 {
1422//Console.WriteLine(" CreateGeom 3");
1423 SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
1424 }
1425 catch (AccessViolationException)
1426 {
1427 m_log.Warn("[PHYSICS]: Unable to create physics proxy for object");
1428 ode.dunlock(_parent_scene.world);
1429 return;
1430 }
1431 }
1432 }
1433
1434 else
1435 {
1436 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1437 try
1438 {
1439//Console.WriteLine(" CreateGeom 4");
1440 SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
1441 }
1442 catch (AccessViolationException)
1443 {
1444 m_log.Warn("[PHYSICS]: Unable to create physics proxy for object");
1445 ode.dunlock(_parent_scene.world);
1446 return;
1447 }
1448 }
1449 }
1450 }
1451
1452 public void changeadd(float timestep)
1453 {
1454 int[] iprimspaceArrItem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
1455 IntPtr targetspace = _parent_scene.calculateSpaceForGeom(_position);
1456
1457 if (targetspace == IntPtr.Zero)
1458 targetspace = _parent_scene.createprimspace(iprimspaceArrItem[0], iprimspaceArrItem[1]);
1459
1460 m_targetSpace = targetspace;
1461
1462 if (_mesh == null)
1463 {
1464 if (_parent_scene.needsMeshing(_pbs))
1465 {
1466 // Don't need to re-enable body.. it's done in SetMesh
1467 _mesh = _parent_scene.mesher.CreateMesh(m_primName, _pbs, _size, _parent_scene.meshSculptLOD, IsPhysical);
1468 // createmesh returns null when it's a shape that isn't a cube.
1469 // m_log.Debug(m_localID);
1470 }
1471 }
1472
1473
1474 lock (_parent_scene.OdeLock)
1475 {
1476//Console.WriteLine("changeadd 1");
1477 CreateGeom(m_targetSpace, _mesh);
1478
1479 if (prim_geom != IntPtr.Zero)
1480 {
1481 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
1482 d.Quaternion myrot = new d.Quaternion();
1483 myrot.X = _orientation.X;
1484 myrot.Y = _orientation.Y;
1485 myrot.Z = _orientation.Z;
1486 myrot.W = _orientation.W;
1487 d.GeomSetQuaternion(prim_geom, ref myrot);
1488 }
1489
1490 if (m_isphysical && Body == IntPtr.Zero)
1491 {
1492 enableBody();
1493 }
1494 }
1495
1496 _parent_scene.geom_name_map[prim_geom] = this.m_primName;
1497 _parent_scene.actor_name_map[prim_geom] = (PhysicsActor)this;
1498
1499 changeSelectedStatus(timestep);
1500
1501 m_taintadd = false;
1502 }
1503
1504 public void changemove(float timestep)
1505 {
1506 if (m_isphysical)
1507 {
1508
1509 if (!m_disabled && !m_taintremove && !childPrim)
1510 {
1511 if (Body == IntPtr.Zero)
1512 enableBody();
1513 //Prim auto disable after 20 frames,
1514 //if you move it, re-enable the prim manually.
1515 if (_parent != null)
1516 {
1517 if (m_linkJoint != IntPtr.Zero)
1518 {
1519 d.JointDestroy(m_linkJoint);
1520 m_linkJoint = IntPtr.Zero;
1521 }
1522 }
1523 if (Body != IntPtr.Zero)
1524 {
1525 d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
1526
1527 if (_parent != null)
1528 {
1529 OdePrim odParent = (OdePrim)_parent;
1530 if (Body != (IntPtr)0 && odParent.Body != (IntPtr)0 && Body != odParent.Body)
1531 {
1532// KF: Fixed Joints were removed? Anyway - this Console.WriteLine does not show up, so routine is not used??
1533Console.WriteLine(" JointCreateFixed");
1534 m_linkJoint = d.JointCreateFixed(_parent_scene.world, _linkJointGroup);
1535 d.JointAttach(m_linkJoint, Body, odParent.Body);
1536 d.JointSetFixed(m_linkJoint);
1537 }
1538 }
1539 d.BodyEnable(Body);
1540 if (m_vehicle.Type != Vehicle.TYPE_NONE)
1541 {
1542 m_vehicle.Enable(Body, _parent_scene);
1543 }
1544 }
1545 else
1546 {
1547 m_log.Warn("[PHYSICS]: Body Still null after enableBody(). This is a crash scenario.");
1548 }
1549 }
1550 //else
1551 // {
1552 //m_log.Debug("[BUG]: race!");
1553 //}
1554 }
1555 else
1556 {
1557 // string primScenAvatarIn = _parent_scene.whichspaceamIin(_position);
1558 // int[] arrayitem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
1559 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1560
1561 IntPtr tempspace = _parent_scene.recalculateSpaceForGeom(prim_geom, _position, m_targetSpace);
1562 m_targetSpace = tempspace;
1563
1564 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1565 if (prim_geom != IntPtr.Zero)
1566 {
1567 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
1568
1569 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1570 d.SpaceAdd(m_targetSpace, prim_geom);
1571 }
1572 }
1573
1574 changeSelectedStatus(timestep);
1575
1576 resetCollisionAccounting();
1577 m_taintposition = _position;
1578 }
1579
1580 public void Move(float timestep)
1581 {
1582 float fx = 0;
1583 float fy = 0;
1584 float fz = 0;
1585
1586 frcount++; // used to limit debug comment output
1587 if (frcount > 100)
1588 frcount = 0;
1589
1590 if (IsPhysical && (Body != IntPtr.Zero) && !m_isSelected && !childPrim) // KF: Only move root prims.
1591 {
1592//if(frcount == 0) Console.WriteLine("Move " + m_primName + " VTyp " + m_vehicle.Type +
1593 // " usePID=" + m_usePID + " seHover=" + m_useHoverPID + " useAPID=" + m_useAPID);
1594 if (m_vehicle.Type != Vehicle.TYPE_NONE)
1595 {
1596 // 'VEHICLES' are dealt with in ODEDynamics.cs
1597 m_vehicle.Step(timestep, _parent_scene);
1598 }
1599 else
1600 {
1601 if(!d.BodyIsEnabled (Body)) d.BodyEnable (Body); // KF add 161009
1602 // NON-'VEHICLES' are dealt with here
1603 if (d.BodyIsEnabled(Body) && !m_angularlock.ApproxEquals(Vector3.Zero, 0.003f))
1604 {
1605 d.Vector3 avel2 = d.BodyGetAngularVel(Body);
1606 if (m_angularlock.X == 1)
1607 avel2.X = 0;
1608 if (m_angularlock.Y == 1)
1609 avel2.Y = 0;
1610 if (m_angularlock.Z == 1)
1611 avel2.Z = 0;
1612 d.BodySetAngularVel(Body, avel2.X, avel2.Y, avel2.Z);
1613 }
1614 //float PID_P = 900.0f;
1615
1616 float m_mass = CalculateMass();
1617
1618// fz = 0f;
1619 //m_log.Info(m_collisionFlags.ToString());
1620
1621
1622 //KF: m_buoyancy is set by llSetBuoyancy() and is for non-vehicle.
1623 // m_buoyancy: (unlimited value) <0=Falls fast; 0=1g; 1=0g; >1 = floats up
1624 // NB Prims in ODE are no subject to global gravity
1625 fz = _parent_scene.gravityz * (1.0f - m_buoyancy) * m_mass; // force = acceleration * mass
1626
1627 if (m_usePID)
1628 {
1629//if(frcount == 0) Console.WriteLine("PID " + m_primName);
1630 // KF - this is for object MoveToTarget.
1631
1632 //if (!d.BodyIsEnabled(Body))
1633 //d.BodySetForce(Body, 0f, 0f, 0f);
1634
1635 // no lock; for now it's only called from within Simulate()
1636
1637 // If the PID Controller isn't active then we set our force
1638 // calculating base velocity to the current position
1639
1640 if ((m_PIDTau < 1) && (m_PIDTau != 0))
1641 {
1642 //PID_G = PID_G / m_PIDTau;
1643 m_PIDTau = 1;
1644 }
1645
1646 if ((PID_G - m_PIDTau) <= 0)
1647 {
1648 PID_G = m_PIDTau + 1;
1649 }
1650 //PidStatus = true;
1651
1652 // PhysicsVector vec = new PhysicsVector();
1653 d.Vector3 vel = d.BodyGetLinearVel(Body);
1654
1655 d.Vector3 pos = d.BodyGetPosition(Body);
1656 _target_velocity =
1657 new Vector3(
1658 (m_PIDTarget.X - pos.X) * ((PID_G - m_PIDTau) * timestep),
1659 (m_PIDTarget.Y - pos.Y) * ((PID_G - m_PIDTau) * timestep),
1660 (m_PIDTarget.Z - pos.Z) * ((PID_G - m_PIDTau) * timestep)
1661 );
1662
1663 // if velocity is zero, use position control; otherwise, velocity control
1664
1665 if (_target_velocity.ApproxEquals(Vector3.Zero,0.1f))
1666 {
1667 // keep track of where we stopped. No more slippin' & slidin'
1668
1669 // We only want to deactivate the PID Controller if we think we want to have our surrogate
1670 // react to the physics scene by moving it's position.
1671 // Avatar to Avatar collisions
1672 // Prim to avatar collisions
1673
1674 //fx = (_target_velocity.X - vel.X) * (PID_D) + (_zeroPosition.X - pos.X) * (PID_P * 2);
1675 //fy = (_target_velocity.Y - vel.Y) * (PID_D) + (_zeroPosition.Y - pos.Y) * (PID_P * 2);
1676 //fz = fz + (_target_velocity.Z - vel.Z) * (PID_D) + (_zeroPosition.Z - pos.Z) * PID_P;
1677 d.BodySetPosition(Body, m_PIDTarget.X, m_PIDTarget.Y, m_PIDTarget.Z);
1678 d.BodySetLinearVel(Body, 0, 0, 0);
1679 d.BodyAddForce(Body, 0, 0, fz);
1680 return;
1681 }
1682 else
1683 {
1684 _zeroFlag = false;
1685
1686 // We're flying and colliding with something
1687 fx = ((_target_velocity.X) - vel.X) * (PID_D);
1688 fy = ((_target_velocity.Y) - vel.Y) * (PID_D);
1689
1690 // vec.Z = (_target_velocity.Z - vel.Z) * PID_D + (_zeroPosition.Z - pos.Z) * PID_P;
1691
1692 fz = fz + ((_target_velocity.Z - vel.Z) * (PID_D) * m_mass);
1693 }
1694 } // end if (m_usePID)
1695
1696 // Hover PID Controller needs to be mutually exlusive to MoveTo PID controller
1697 if (m_useHoverPID && !m_usePID)
1698 {
1699//Console.WriteLine("Hover " + m_primName);
1700
1701 // If we're using the PID controller, then we have no gravity
1702 fz = (-1 * _parent_scene.gravityz) * m_mass;
1703
1704 // no lock; for now it's only called from within Simulate()
1705
1706 // If the PID Controller isn't active then we set our force
1707 // calculating base velocity to the current position
1708
1709 if ((m_PIDTau < 1))
1710 {
1711 PID_G = PID_G / m_PIDTau;
1712 }
1713
1714 if ((PID_G - m_PIDTau) <= 0)
1715 {
1716 PID_G = m_PIDTau + 1;
1717 }
1718
1719
1720 // Where are we, and where are we headed?
1721 d.Vector3 pos = d.BodyGetPosition(Body);
1722 d.Vector3 vel = d.BodyGetLinearVel(Body);
1723
1724
1725 // Non-Vehicles have a limited set of Hover options.
1726 // determine what our target height really is based on HoverType
1727 switch (m_PIDHoverType)
1728 {
1729 case PIDHoverType.Ground:
1730 m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y);
1731 m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
1732 break;
1733 case PIDHoverType.GroundAndWater:
1734 m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y);
1735 m_waterHeight = _parent_scene.GetWaterLevel();
1736 if (m_groundHeight > m_waterHeight)
1737 {
1738 m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
1739 }
1740 else
1741 {
1742 m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight;
1743 }
1744 break;
1745
1746 } // end switch (m_PIDHoverType)
1747
1748
1749 _target_velocity =
1750 new Vector3(0.0f, 0.0f,
1751 (m_targetHoverHeight - pos.Z) * ((PID_G - m_PIDHoverTau) * timestep)
1752 );
1753
1754 // if velocity is zero, use position control; otherwise, velocity control
1755
1756 if (_target_velocity.ApproxEquals(Vector3.Zero, 0.1f))
1757 {
1758 // keep track of where we stopped. No more slippin' & slidin'
1759
1760 // We only want to deactivate the PID Controller if we think we want to have our surrogate
1761 // react to the physics scene by moving it's position.
1762 // Avatar to Avatar collisions
1763 // Prim to avatar collisions
1764
1765 d.BodySetPosition(Body, pos.X, pos.Y, m_targetHoverHeight);
1766 d.BodySetLinearVel(Body, vel.X, vel.Y, 0);
1767 d.BodyAddForce(Body, 0, 0, fz);
1768 //KF this prevents furthur motions return;
1769 }
1770 else
1771 {
1772 _zeroFlag = false;
1773
1774 // We're flying and colliding with something
1775 fz = fz + ((_target_velocity.Z - vel.Z) * (PID_D) * m_mass);
1776 }
1777 } // end m_useHoverPID && !m_usePID
1778
1779 if (m_useAPID)
1780 {
1781 // RotLookAt, apparently overrides all other rotation sources. Inputs:
1782 // Quaternion m_APIDTarget
1783 // float m_APIDStrength // From SL experiments, this is the time to get there
1784 // float m_APIDDamping // From SL experiments, this is damping, 1.0 = damped, 0.1 = wobbly
1785 // Also in SL the mass of the object has no effect on time to get there.
1786 // Factors:
1787//if(frcount == 0) Console.WriteLine("APID ");
1788 // get present body rotation
1789 float limit = 1.0f;
1790 float scaler = 50f; // adjusts damping time
1791 float RLAservo = 0f;
1792
1793 d.Quaternion rot = d.BodyGetQuaternion(Body);
1794 Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);
1795 Quaternion rot_diff = Quaternion.Inverse(rotq) * m_APIDTarget;
1796 float diff_angle;
1797 Vector3 diff_axis;
1798 rot_diff.GetAxisAngle(out diff_axis, out diff_angle);
1799 diff_axis.Normalize();
1800 if(diff_angle > 0.01f) // diff_angle is always +ve
1801 {
1802// PhysicsVector rotforce = new PhysicsVector(diff_axis.X, diff_axis.Y, diff_axis.Z);
1803 Vector3 rotforce = new Vector3(diff_axis.X, diff_axis.Y, diff_axis.Z);
1804 rotforce = rotforce * rotq;
1805 if(diff_angle > limit) diff_angle = limit; // cap the rotate rate
1806// RLAservo = timestep / m_APIDStrength * m_mass * scaler;
1807 // rotforce = rotforce * RLAservo * diff_angle ;
1808 // d.BodyAddRelTorque(Body, rotforce.X, rotforce.Y, rotforce.Z);
1809 RLAservo = timestep / m_APIDStrength * scaler;
1810 rotforce = rotforce * RLAservo * diff_angle ;
1811 d.BodySetAngularVel (Body, rotforce.X, rotforce.Y, rotforce.Z);
1812//Console.WriteLine("axis= " + diff_axis + " angle= " + diff_angle + "servo= " + RLAservo);
1813 }
1814//if(frcount == 0) Console.WriteLine("mass= " + m_mass + " servo= " + RLAservo + " angle= " + diff_angle);
1815 } // end m_useAPID
1816
1817 fx *= m_mass;
1818 fy *= m_mass;
1819 //fz *= m_mass;
1820
1821 fx += m_force.X;
1822 fy += m_force.Y;
1823 fz += m_force.Z;
1824
1825 //m_log.Info("[OBJPID]: X:" + fx.ToString() + " Y:" + fy.ToString() + " Z:" + fz.ToString());
1826 if (fx != 0 || fy != 0 || fz != 0)
1827 {
1828 //m_taintdisable = true;
1829 //base.RaiseOutOfBounds(Position);
1830 //d.BodySetLinearVel(Body, fx, fy, 0f);
1831 if (!d.BodyIsEnabled(Body))
1832 {
1833 // A physical body at rest on a surface will auto-disable after a while,
1834 // this appears to re-enable it incase the surface it is upon vanishes,
1835 // and the body should fall again.
1836 d.BodySetLinearVel(Body, 0f, 0f, 0f);
1837 d.BodySetForce(Body, 0, 0, 0);
1838 enableBodySoft();
1839 }
1840
1841 // 35x10 = 350n times the mass per second applied maximum.
1842 float nmax = 35f * m_mass;
1843 float nmin = -35f * m_mass;
1844
1845
1846 if (fx > nmax)
1847 fx = nmax;
1848 if (fx < nmin)
1849 fx = nmin;
1850 if (fy > nmax)
1851 fy = nmax;
1852 if (fy < nmin)
1853 fy = nmin;
1854 d.BodyAddForce(Body, fx, fy, fz);
1855//Console.WriteLine("AddForce " + fx + "," + fy + "," + fz);
1856 }
1857 }
1858 }
1859 else
1860 { // is not physical, or is not a body or is selected
1861 // _zeroPosition = d.BodyGetPosition(Body);
1862 return;
1863//Console.WriteLine("Nothing " + m_primName);
1864
1865 }
1866 }
1867
1868
1869
1870 public void rotate(float timestep)
1871 {
1872 d.Quaternion myrot = new d.Quaternion();
1873 myrot.X = _orientation.X;
1874 myrot.Y = _orientation.Y;
1875 myrot.Z = _orientation.Z;
1876 myrot.W = _orientation.W;
1877 if (Body != IntPtr.Zero)
1878 {
1879 // KF: If this is a root prim do BodySet
1880 d.BodySetQuaternion(Body, ref myrot);
1881 if (m_isphysical)
1882 {
1883 if (!m_angularlock.ApproxEquals(Vector3.One, 0f))
1884 createAMotor(m_angularlock);
1885 }
1886 }
1887 else
1888 {
1889 // daughter prim, do Geom set
1890 d.GeomSetQuaternion(prim_geom, ref myrot);
1891 }
1892
1893 resetCollisionAccounting();
1894 m_taintrot = _orientation;
1895 }
1896
1897 private void resetCollisionAccounting()
1898 {
1899 m_collisionscore = 0;
1900 m_interpenetrationcount = 0;
1901 m_disabled = false;
1902 }
1903
1904 public void changedisable(float timestep)
1905 {
1906 m_disabled = true;
1907 if (Body != IntPtr.Zero)
1908 {
1909 d.BodyDisable(Body);
1910 Body = IntPtr.Zero;
1911 }
1912
1913 m_taintdisable = false;
1914 }
1915
1916 public void changePhysicsStatus(float timestep)
1917 {
1918 if (m_isphysical == true)
1919 {
1920 if (Body == IntPtr.Zero)
1921 {
1922 if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
1923 {
1924 changeshape(2f);
1925 }
1926 else
1927 {
1928 enableBody();
1929 }
1930 }
1931 }
1932 else
1933 {
1934 if (Body != IntPtr.Zero)
1935 {
1936 if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
1937 {
1938
1939
1940 if (prim_geom != IntPtr.Zero)
1941 {
1942 try
1943 {
1944 d.GeomDestroy(prim_geom);
1945 prim_geom = IntPtr.Zero;
1946 _mesh = null;
1947 }
1948 catch (System.AccessViolationException)
1949 {
1950 prim_geom = IntPtr.Zero;
1951 m_log.Error("[PHYSICS]: PrimGeom dead");
1952 }
1953 }
1954//Console.WriteLine("changePhysicsStatus for " + m_primName );
1955 changeadd(2f);
1956 }
1957 if (childPrim)
1958 {
1959 if (_parent != null)
1960 {
1961 OdePrim parent = (OdePrim)_parent;
1962 parent.ChildDelink(this);
1963 }
1964 }
1965 else
1966 {
1967 disableBody();
1968 }
1969 }
1970 }
1971
1972 changeSelectedStatus(timestep);
1973
1974 resetCollisionAccounting();
1975 m_taintPhysics = m_isphysical;
1976 }
1977
1978 public void changesize(float timestamp)
1979 {
1980
1981 string oldname = _parent_scene.geom_name_map[prim_geom];
1982
1983 if (_size.X <= 0) _size.X = 0.01f;
1984 if (_size.Y <= 0) _size.Y = 0.01f;
1985 if (_size.Z <= 0) _size.Z = 0.01f;
1986
1987 // Cleanup of old prim geometry
1988 if (_mesh != null)
1989 {
1990 // Cleanup meshing here
1991 }
1992 //kill body to rebuild
1993 if (IsPhysical && Body != IntPtr.Zero)
1994 {
1995 if (childPrim)
1996 {
1997 if (_parent != null)
1998 {
1999 OdePrim parent = (OdePrim)_parent;
2000 parent.ChildDelink(this);
2001 }
2002 }
2003 else
2004 {
2005 disableBody();
2006 }
2007 }
2008 if (d.SpaceQuery(m_targetSpace, prim_geom))
2009 {
2010 _parent_scene.waitForSpaceUnlock(m_targetSpace);
2011 d.SpaceRemove(m_targetSpace, prim_geom);
2012 }
2013 d.GeomDestroy(prim_geom);
2014 prim_geom = IntPtr.Zero;
2015 // we don't need to do space calculation because the client sends a position update also.
2016
2017 // Construction of new prim
2018 if (_parent_scene.needsMeshing(_pbs))
2019 {
2020 float meshlod = _parent_scene.meshSculptLOD;
2021
2022 if (IsPhysical)
2023 meshlod = _parent_scene.MeshSculptphysicalLOD;
2024 // Don't need to re-enable body.. it's done in SetMesh
2025
2026 IMesh mesh = null;
2027
2028 if (_parent_scene.needsMeshing(_pbs))
2029 mesh = _parent_scene.mesher.CreateMesh(oldname, _pbs, _size, meshlod, IsPhysical);
2030
2031 //IMesh mesh = _parent_scene.mesher.CreateMesh(oldname, _pbs, _size, meshlod, IsPhysical);
2032//Console.WriteLine("changesize 1");
2033 CreateGeom(m_targetSpace, mesh);
2034
2035
2036 }
2037 else
2038 {
2039 _mesh = null;
2040//Console.WriteLine("changesize 2");
2041 CreateGeom(m_targetSpace, _mesh);
2042 }
2043
2044 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
2045 d.Quaternion myrot = new d.Quaternion();
2046 myrot.X = _orientation.X;
2047 myrot.Y = _orientation.Y;
2048 myrot.Z = _orientation.Z;
2049 myrot.W = _orientation.W;
2050 d.GeomSetQuaternion(prim_geom, ref myrot);
2051
2052 //d.GeomBoxSetLengths(prim_geom, _size.X, _size.Y, _size.Z);
2053 if (IsPhysical && Body == IntPtr.Zero && !childPrim)
2054 {
2055 // Re creates body on size.
2056 // EnableBody also does setMass()
2057 enableBody();
2058 d.BodyEnable(Body);
2059 }
2060
2061 _parent_scene.geom_name_map[prim_geom] = oldname;
2062
2063 changeSelectedStatus(timestamp);
2064 if (childPrim)
2065 {
2066 if (_parent is OdePrim)
2067 {
2068 OdePrim parent = (OdePrim)_parent;
2069 parent.ChildSetGeom(this);
2070 }
2071 }
2072 resetCollisionAccounting();
2073 m_taintsize = _size;
2074 }
2075
2076
2077
2078 public void changefloatonwater(float timestep)
2079 {
2080 m_collidesWater = m_taintCollidesWater;
2081
2082 if (prim_geom != IntPtr.Zero)
2083 {
2084 if (m_collidesWater)
2085 {
2086 m_collisionFlags |= CollisionCategories.Water;
2087 }
2088 else
2089 {
2090 m_collisionFlags &= ~CollisionCategories.Water;
2091 }
2092 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
2093 }
2094 }
2095
2096 public void changeshape(float timestamp)
2097 {
2098 string oldname = _parent_scene.geom_name_map[prim_geom];
2099
2100 // Cleanup of old prim geometry and Bodies
2101 if (IsPhysical && Body != IntPtr.Zero)
2102 {
2103 if (childPrim)
2104 {
2105 if (_parent != null)
2106 {
2107 OdePrim parent = (OdePrim)_parent;
2108 parent.ChildDelink(this);
2109 }
2110 }
2111 else
2112 {
2113 disableBody();
2114 }
2115 }
2116 try
2117 {
2118 d.GeomDestroy(prim_geom);
2119 }
2120 catch (System.AccessViolationException)
2121 {
2122 prim_geom = IntPtr.Zero;
2123 m_log.Error("[PHYSICS]: PrimGeom dead");
2124 }
2125 prim_geom = IntPtr.Zero;
2126 // we don't need to do space calculation because the client sends a position update also.
2127 if (_size.X <= 0) _size.X = 0.01f;
2128 if (_size.Y <= 0) _size.Y = 0.01f;
2129 if (_size.Z <= 0) _size.Z = 0.01f;
2130 // Construction of new prim
2131
2132 if (_parent_scene.needsMeshing(_pbs))
2133 {
2134 // Don't need to re-enable body.. it's done in SetMesh
2135 float meshlod = _parent_scene.meshSculptLOD;
2136
2137 if (IsPhysical)
2138 meshlod = _parent_scene.MeshSculptphysicalLOD;
2139
2140 IMesh mesh = _parent_scene.mesher.CreateMesh(oldname, _pbs, _size, meshlod, IsPhysical);
2141 // createmesh returns null when it doesn't mesh.
2142 CreateGeom(m_targetSpace, mesh);
2143 }
2144 else
2145 {
2146 _mesh = null;
2147//Console.WriteLine("changeshape");
2148 CreateGeom(m_targetSpace, null);
2149 }
2150
2151 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
2152 d.Quaternion myrot = new d.Quaternion();
2153 //myrot.W = _orientation.w;
2154 myrot.W = _orientation.W;
2155 myrot.X = _orientation.X;
2156 myrot.Y = _orientation.Y;
2157 myrot.Z = _orientation.Z;
2158 d.GeomSetQuaternion(prim_geom, ref myrot);
2159
2160 //d.GeomBoxSetLengths(prim_geom, _size.X, _size.Y, _size.Z);
2161 if (IsPhysical && Body == IntPtr.Zero)
2162 {
2163 // Re creates body on size.
2164 // EnableBody also does setMass()
2165 enableBody();
2166 if (Body != IntPtr.Zero)
2167 {
2168 d.BodyEnable(Body);
2169 }
2170 }
2171 _parent_scene.geom_name_map[prim_geom] = oldname;
2172
2173 changeSelectedStatus(timestamp);
2174 if (childPrim)
2175 {
2176 if (_parent is OdePrim)
2177 {
2178 OdePrim parent = (OdePrim)_parent;
2179 parent.ChildSetGeom(this);
2180 }
2181 }
2182 resetCollisionAccounting();
2183 m_taintshape = false;
2184 }
2185
2186 public void changeAddForce(float timestamp)
2187 {
2188 if (!m_isSelected)
2189 {
2190 lock (m_forcelist)
2191 {
2192 //m_log.Info("[PHYSICS]: dequeing forcelist");
2193 if (IsPhysical)
2194 {
2195 Vector3 iforce = Vector3.Zero;
2196 int i = 0;
2197 try
2198 {
2199 for (i = 0; i < m_forcelist.Count; i++)
2200 {
2201
2202 iforce = iforce + (m_forcelist[i] * 100);
2203 }
2204 }
2205 catch (IndexOutOfRangeException)
2206 {
2207 m_forcelist = new List<Vector3>();
2208 m_collisionscore = 0;
2209 m_interpenetrationcount = 0;
2210 m_taintforce = false;
2211 return;
2212 }
2213 catch (ArgumentOutOfRangeException)
2214 {
2215 m_forcelist = new List<Vector3>();
2216 m_collisionscore = 0;
2217 m_interpenetrationcount = 0;
2218 m_taintforce = false;
2219 return;
2220 }
2221 d.BodyEnable(Body);
2222 d.BodyAddForce(Body, iforce.X, iforce.Y, iforce.Z);
2223 }
2224 m_forcelist.Clear();
2225 }
2226
2227 m_collisionscore = 0;
2228 m_interpenetrationcount = 0;
2229 }
2230
2231 m_taintforce = false;
2232
2233 }
2234
2235
2236
2237 public void changeSetTorque(float timestamp)
2238 {
2239 if (!m_isSelected)
2240 {
2241 if (IsPhysical && Body != IntPtr.Zero)
2242 {
2243 d.BodySetTorque(Body, m_taintTorque.X, m_taintTorque.Y, m_taintTorque.Z);
2244 }
2245 }
2246
2247 m_taintTorque = Vector3.Zero;
2248 }
2249
2250 public void changeAddAngularForce(float timestamp)
2251 {
2252 if (!m_isSelected)
2253 {
2254 lock (m_angularforcelist)
2255 {
2256 //m_log.Info("[PHYSICS]: dequeing forcelist");
2257 if (IsPhysical)
2258 {
2259 Vector3 iforce = Vector3.Zero;
2260 for (int i = 0; i < m_angularforcelist.Count; i++)
2261 {
2262 iforce = iforce + (m_angularforcelist[i] * 100);
2263 }
2264 d.BodyEnable(Body);
2265 d.BodyAddTorque(Body, iforce.X, iforce.Y, iforce.Z);
2266
2267 }
2268 m_angularforcelist.Clear();
2269 }
2270
2271 m_collisionscore = 0;
2272 m_interpenetrationcount = 0;
2273 }
2274
2275 m_taintaddangularforce = false;
2276 }
2277
2278 private void changevelocity(float timestep)
2279 {
2280 if (!m_isSelected)
2281 {
2282 Thread.Sleep(20);
2283 if (IsPhysical)
2284 {
2285 if (Body != IntPtr.Zero)
2286 {
2287 d.BodySetLinearVel(Body, m_taintVelocity.X, m_taintVelocity.Y, m_taintVelocity.Z);
2288 }
2289 }
2290
2291 //resetCollisionAccounting();
2292 }
2293 m_taintVelocity = Vector3.Zero;
2294 }
2295
2296 public override bool IsPhysical
2297 {
2298 get { return m_isphysical; }
2299 set {
2300 m_isphysical = value;
2301 if (!m_isphysical) // Zero the remembered last velocity
2302 m_lastVelocity = Vector3.Zero;
2303 }
2304 }
2305
2306 public void setPrimForRemoval()
2307 {
2308 m_taintremove = true;
2309 }
2310
2311 public override bool Flying
2312 {
2313 // no flying prims for you
2314 get { return false; }
2315 set { }
2316 }
2317
2318 public override bool IsColliding
2319 {
2320 get { return iscolliding; }
2321 set { iscolliding = value; }
2322 }
2323
2324 public override bool CollidingGround
2325 {
2326 get { return false; }
2327 set { return; }
2328 }
2329
2330 public override bool CollidingObj
2331 {
2332 get { return false; }
2333 set { return; }
2334 }
2335
2336 public override bool ThrottleUpdates
2337 {
2338 get { return m_throttleUpdates; }
2339 set { m_throttleUpdates = value; }
2340 }
2341
2342 public override bool Stopped
2343 {
2344 get { return _zeroFlag; }
2345 }
2346
2347 public override Vector3 Position
2348 {
2349 get { return _position; }
2350
2351 set { _position = value;
2352 //m_log.Info("[PHYSICS]: " + _position.ToString());
2353 }
2354 }
2355
2356 public override Vector3 Size
2357 {
2358 get { return _size; }
2359 set
2360 {
2361 if (value.IsFinite())
2362 {
2363 _size = value;
2364 }
2365 else
2366 {
2367 m_log.Warn("[PHYSICS]: Got NaN Size on object");
2368 }
2369 }
2370 }
2371
2372 public override float Mass
2373 {
2374 get { return CalculateMass(); }
2375 }
2376
2377 public override Vector3 Force
2378 {
2379 //get { return Vector3.Zero; }
2380 get { return m_force; }
2381 set
2382 {
2383 if (value.IsFinite())
2384 {
2385 m_force = value;
2386 }
2387 else
2388 {
2389 m_log.Warn("[PHYSICS]: NaN in Force Applied to an Object");
2390 }
2391 }
2392 }
2393
2394 public override int VehicleType
2395 {
2396 get { return (int)m_vehicle.Type; }
2397 set { m_vehicle.ProcessTypeChange((Vehicle)value); }
2398 }
2399
2400 public override void VehicleFloatParam(int param, float value)
2401 {
2402 m_vehicle.ProcessFloatVehicleParam((Vehicle) param, value);
2403 }
2404
2405 public override void VehicleVectorParam(int param, Vector3 value)
2406 {
2407 m_vehicle.ProcessVectorVehicleParam((Vehicle) param, value);
2408 }
2409
2410 public override void VehicleRotationParam(int param, Quaternion rotation)
2411 {
2412 m_vehicle.ProcessRotationVehicleParam((Vehicle) param, rotation);
2413 }
2414
2415 public override void SetVolumeDetect(int param)
2416 {
2417 lock (_parent_scene.OdeLock)
2418 {
2419 m_isVolumeDetect = (param!=0);
2420 }
2421 }
2422
2423 public override Vector3 CenterOfMass
2424 {
2425 get { return Vector3.Zero; }
2426 }
2427
2428 public override Vector3 GeometricCenter
2429 {
2430 get { return Vector3.Zero; }
2431 }
2432
2433 public override PrimitiveBaseShape Shape
2434 {
2435 set
2436 {
2437 _pbs = value;
2438 m_taintshape = true;
2439 }
2440 }
2441
2442 public override Vector3 Velocity
2443 {
2444 get
2445 {
2446 // Averate previous velocity with the new one so
2447 // client object interpolation works a 'little' better
2448 if (_zeroFlag)
2449 return Vector3.Zero;
2450
2451 Vector3 returnVelocity = Vector3.Zero;
2452 returnVelocity.X = (m_lastVelocity.X + _velocity.X)/2;
2453 returnVelocity.Y = (m_lastVelocity.Y + _velocity.Y)/2;
2454 returnVelocity.Z = (m_lastVelocity.Z + _velocity.Z)/2;
2455 return returnVelocity;
2456 }
2457 set
2458 {
2459 if (value.IsFinite())
2460 {
2461 _velocity = value;
2462
2463 m_taintVelocity = value;
2464 _parent_scene.AddPhysicsActorTaint(this);
2465 }
2466 else
2467 {
2468 m_log.Warn("[PHYSICS]: Got NaN Velocity in Object");
2469 }
2470
2471 }
2472 }
2473
2474 public override Vector3 Torque
2475 {
2476 get
2477 {
2478 if (!m_isphysical || Body == IntPtr.Zero)
2479 return Vector3.Zero;
2480
2481 return _torque;
2482 }
2483
2484 set
2485 {
2486 if (value.IsFinite())
2487 {
2488 m_taintTorque = value;
2489 _parent_scene.AddPhysicsActorTaint(this);
2490 }
2491 else
2492 {
2493 m_log.Warn("[PHYSICS]: Got NaN Torque in Object");
2494 }
2495 }
2496 }
2497
2498 public override float CollisionScore
2499 {
2500 get { return m_collisionscore; }
2501 set { m_collisionscore = value; }
2502 }
2503
2504 public override bool Kinematic
2505 {
2506 get { return false; }
2507 set { }
2508 }
2509
2510 public override Quaternion Orientation
2511 {
2512 get { return _orientation; }
2513 set
2514 {
2515 if (QuaternionIsFinite(value))
2516 {
2517 _orientation = value;
2518 }
2519 else
2520 m_log.Warn("[PHYSICS]: Got NaN quaternion Orientation from Scene in Object");
2521
2522 }
2523 }
2524
2525 internal static bool QuaternionIsFinite(Quaternion q)
2526 {
2527 if (Single.IsNaN(q.X) || Single.IsInfinity(q.X))
2528 return false;
2529 if (Single.IsNaN(q.Y) || Single.IsInfinity(q.Y))
2530 return false;
2531 if (Single.IsNaN(q.Z) || Single.IsInfinity(q.Z))
2532 return false;
2533 if (Single.IsNaN(q.W) || Single.IsInfinity(q.W))
2534 return false;
2535 return true;
2536 }
2537
2538 public override Vector3 Acceleration
2539 {
2540 get { return _acceleration; }
2541 }
2542
2543
2544 public void SetAcceleration(Vector3 accel)
2545 {
2546 _acceleration = accel;
2547 }
2548
2549 public override void AddForce(Vector3 force, bool pushforce)
2550 {
2551 if (force.IsFinite())
2552 {
2553 lock (m_forcelist)
2554 m_forcelist.Add(force);
2555
2556 m_taintforce = true;
2557 }
2558 else
2559 {
2560 m_log.Warn("[PHYSICS]: Got Invalid linear force vector from Scene in Object");
2561 }
2562 //m_log.Info("[PHYSICS]: Added Force:" + force.ToString() + " to prim at " + Position.ToString());
2563 }
2564
2565 public override void AddAngularForce(Vector3 force, bool pushforce)
2566 {
2567 if (force.IsFinite())
2568 {
2569 m_angularforcelist.Add(force);
2570 m_taintaddangularforce = true;
2571 }
2572 else
2573 {
2574 m_log.Warn("[PHYSICS]: Got Invalid Angular force vector from Scene in Object");
2575 }
2576 }
2577
2578 public override Vector3 RotationalVelocity
2579 {
2580 get
2581 {
2582 Vector3 pv = Vector3.Zero;
2583 if (_zeroFlag)
2584 return pv;
2585 m_lastUpdateSent = false;
2586
2587 if (m_rotationalVelocity.ApproxEquals(pv, 0.2f))
2588 return pv;
2589
2590 return m_rotationalVelocity;
2591 }
2592 set
2593 {
2594 if (value.IsFinite())
2595 {
2596 m_rotationalVelocity = value;
2597 }
2598 else
2599 {
2600 m_log.Warn("[PHYSICS]: Got NaN RotationalVelocity in Object");
2601 }
2602 }
2603 }
2604
2605 public override void CrossingFailure()
2606 {
2607 m_crossingfailures++;
2608 if (m_crossingfailures > _parent_scene.geomCrossingFailuresBeforeOutofbounds)
2609 {
2610 base.RaiseOutOfBounds(_position);
2611 return;
2612 }
2613 else if (m_crossingfailures == _parent_scene.geomCrossingFailuresBeforeOutofbounds)
2614 {
2615 m_log.Warn("[PHYSICS]: Too many crossing failures for: " + m_primName);
2616 }
2617 }
2618
2619 public override float Buoyancy
2620 {
2621 get { return m_buoyancy; }
2622 set { m_buoyancy = value; }
2623 }
2624
2625 public override void link(PhysicsActor obj)
2626 {
2627 m_taintparent = obj;
2628 }
2629
2630 public override void delink()
2631 {
2632 m_taintparent = null;
2633 }
2634
2635 public override void LockAngularMotion(Vector3 axis)
2636 {
2637 // reverse the zero/non zero values for ODE.
2638 if (axis.IsFinite())
2639 {
2640 axis.X = (axis.X > 0) ? 1f : 0f;
2641 axis.Y = (axis.Y > 0) ? 1f : 0f;
2642 axis.Z = (axis.Z > 0) ? 1f : 0f;
2643 m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z);
2644 m_taintAngularLock = axis;
2645 }
2646 else
2647 {
2648 m_log.Warn("[PHYSICS]: Got NaN locking axis from Scene on Object");
2649 }
2650 }
2651
2652 public void UpdatePositionAndVelocity()
2653 {
2654 // no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
2655 if (_parent == null)
2656 {
2657 Vector3 pv = Vector3.Zero;
2658 bool lastZeroFlag = _zeroFlag;
2659 if (Body != (IntPtr)0) // FIXME -> or if it is a joint
2660 {
2661 d.Vector3 vec = d.BodyGetPosition(Body);
2662 d.Quaternion ori = d.BodyGetQuaternion(Body);
2663 d.Vector3 vel = d.BodyGetLinearVel(Body);
2664 d.Vector3 rotvel = d.BodyGetAngularVel(Body);
2665 d.Vector3 torque = d.BodyGetTorque(Body);
2666 _torque = new Vector3(torque.X, torque.Y, torque.Z);
2667 Vector3 l_position = Vector3.Zero;
2668 Quaternion l_orientation = Quaternion.Identity;
2669
2670 // kluge to keep things in bounds. ODE lets dead avatars drift away (they should be removed!)
2671 //if (vec.X < 0.0f) { vec.X = 0.0f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
2672 //if (vec.Y < 0.0f) { vec.Y = 0.0f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
2673 //if (vec.X > 255.95f) { vec.X = 255.95f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
2674 //if (vec.Y > 255.95f) { vec.Y = 255.95f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
2675
2676 m_lastposition = _position;
2677 m_lastorientation = _orientation;
2678
2679 l_position.X = vec.X;
2680 l_position.Y = vec.Y;
2681 l_position.Z = vec.Z;
2682 l_orientation.X = ori.X;
2683 l_orientation.Y = ori.Y;
2684 l_orientation.Z = ori.Z;
2685 l_orientation.W = ori.W;
2686
2687// if(l_position.Y != m_lastposition.Y){
2688// Console.WriteLine("UP&V {0} {1}", m_primName, l_position);
2689// }
2690
2691 if (l_position.X > ((int)_parent_scene.WorldExtents.X - 0.05f) || l_position.X < 0f || l_position.Y > ((int)_parent_scene.WorldExtents.Y - 0.05f) || l_position.Y < 0f)
2692 {
2693 //base.RaiseOutOfBounds(l_position);
2694
2695 if (m_crossingfailures < _parent_scene.geomCrossingFailuresBeforeOutofbounds)
2696 {
2697 _position = l_position;
2698 //_parent_scene.remActivePrim(this);
2699 if (_parent == null)
2700 base.RequestPhysicsterseUpdate();
2701 return;
2702 }
2703 else
2704 {
2705 if (_parent == null)
2706 base.RaiseOutOfBounds(l_position);
2707 return;
2708 }
2709 }
2710
2711 if (l_position.Z < 0)
2712 {
2713 // This is so prim that get lost underground don't fall forever and suck up
2714 //
2715 // Sim resources and memory.
2716 // Disables the prim's movement physics....
2717 // It's a hack and will generate a console message if it fails.
2718
2719 //IsPhysical = false;
2720 if (_parent == null)
2721 base.RaiseOutOfBounds(_position);
2722
2723 _acceleration.X = 0;
2724 _acceleration.Y = 0;
2725 _acceleration.Z = 0;
2726
2727 _velocity.X = 0;
2728 _velocity.Y = 0;
2729 _velocity.Z = 0;
2730 m_rotationalVelocity.X = 0;
2731 m_rotationalVelocity.Y = 0;
2732 m_rotationalVelocity.Z = 0;
2733
2734 if (_parent == null)
2735 base.RequestPhysicsterseUpdate();
2736
2737 m_throttleUpdates = false;
2738 throttleCounter = 0;
2739 _zeroFlag = true;
2740 //outofBounds = true;
2741 }
2742
2743 //float Adiff = 1.0f - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation));
2744//Console.WriteLine("Adiff " + m_primName + " = " + Adiff);
2745 if ((Math.Abs(m_lastposition.X - l_position.X) < 0.02)
2746 && (Math.Abs(m_lastposition.Y - l_position.Y) < 0.02)
2747 && (Math.Abs(m_lastposition.Z - l_position.Z) < 0.02)
2748// && (1.0 - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation)) < 0.01))
2749 && (1.0 - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation)) < 0.0001)) // KF 0.01 is far to large
2750 {
2751 _zeroFlag = true;
2752//Console.WriteLine("ZFT 2");
2753 m_throttleUpdates = false;
2754 }
2755 else
2756 {
2757 //m_log.Debug(Math.Abs(m_lastposition.X - l_position.X).ToString());
2758 _zeroFlag = false;
2759 m_lastUpdateSent = false;
2760 //m_throttleUpdates = false;
2761 }
2762
2763 if (_zeroFlag)
2764 {
2765 _velocity.X = 0.0f;
2766 _velocity.Y = 0.0f;
2767 _velocity.Z = 0.0f;
2768
2769 _acceleration.X = 0;
2770 _acceleration.Y = 0;
2771 _acceleration.Z = 0;
2772
2773 //_orientation.w = 0f;
2774 //_orientation.X = 0f;
2775 //_orientation.Y = 0f;
2776 //_orientation.Z = 0f;
2777 m_rotationalVelocity.X = 0;
2778 m_rotationalVelocity.Y = 0;
2779 m_rotationalVelocity.Z = 0;
2780 if (!m_lastUpdateSent)
2781 {
2782 m_throttleUpdates = false;
2783 throttleCounter = 0;
2784 m_rotationalVelocity = pv;
2785
2786 if (_parent == null)
2787 {
2788 base.RequestPhysicsterseUpdate();
2789 }
2790
2791 m_lastUpdateSent = true;
2792 }
2793 }
2794 else
2795 {
2796 if (lastZeroFlag != _zeroFlag)
2797 {
2798 if (_parent == null)
2799 {
2800 base.RequestPhysicsterseUpdate();
2801 }
2802 }
2803
2804 m_lastVelocity = _velocity;
2805
2806 _position = l_position;
2807
2808 _velocity.X = vel.X;
2809 _velocity.Y = vel.Y;
2810 _velocity.Z = vel.Z;
2811
2812 _acceleration = ((_velocity - m_lastVelocity) / 0.1f);
2813 _acceleration = new Vector3(_velocity.X - m_lastVelocity.X / 0.1f, _velocity.Y - m_lastVelocity.Y / 0.1f, _velocity.Z - m_lastVelocity.Z / 0.1f);
2814 //m_log.Info("[PHYSICS]: V1: " + _velocity + " V2: " + m_lastVelocity + " Acceleration: " + _acceleration.ToString());
2815
2816 if (_velocity.ApproxEquals(pv, 0.5f))
2817 {
2818 m_rotationalVelocity = pv;
2819 }
2820 else
2821 {
2822 m_rotationalVelocity = new Vector3(rotvel.X, rotvel.Y, rotvel.Z);
2823 }
2824
2825 //m_log.Debug("ODE: " + m_rotationalVelocity.ToString());
2826 _orientation.X = ori.X;
2827 _orientation.Y = ori.Y;
2828 _orientation.Z = ori.Z;
2829 _orientation.W = ori.W;
2830 m_lastUpdateSent = false;
2831 if (!m_throttleUpdates || throttleCounter > _parent_scene.geomUpdatesPerThrottledUpdate)
2832 {
2833 if (_parent == null)
2834 {
2835 base.RequestPhysicsterseUpdate();
2836 }
2837 }
2838 else
2839 {
2840 throttleCounter++;
2841 }
2842 }
2843 m_lastposition = l_position;
2844 }
2845 else
2846 {
2847 // Not a body.. so Make sure the client isn't interpolating
2848 _velocity.X = 0;
2849 _velocity.Y = 0;
2850 _velocity.Z = 0;
2851
2852 _acceleration.X = 0;
2853 _acceleration.Y = 0;
2854 _acceleration.Z = 0;
2855
2856 m_rotationalVelocity.X = 0;
2857 m_rotationalVelocity.Y = 0;
2858 m_rotationalVelocity.Z = 0;
2859 _zeroFlag = true;
2860 }
2861 }
2862 }
2863
2864 public override bool FloatOnWater
2865 {
2866 set {
2867 m_taintCollidesWater = value;
2868 _parent_scene.AddPhysicsActorTaint(this);
2869 }
2870 }
2871
2872 public override void SetMomentum(Vector3 momentum)
2873 {
2874 }
2875
2876 public override Vector3 PIDTarget
2877 {
2878 set
2879 {
2880 if (value.IsFinite())
2881 {
2882 m_PIDTarget = value;
2883 }
2884 else
2885 m_log.Warn("[PHYSICS]: Got NaN PIDTarget from Scene on Object");
2886 }
2887 }
2888 public override bool PIDActive { set { m_usePID = value; } }
2889 public override float PIDTau { set { m_PIDTau = value; } }
2890
2891 // For RotLookAt
2892 public override Quaternion APIDTarget { set { m_APIDTarget = value; } }
2893 public override bool APIDActive { set { m_useAPID = value; } }
2894 public override float APIDStrength { set { m_APIDStrength = value; } }
2895 public override float APIDDamping { set { m_APIDDamping = value; } }
2896
2897 public override float PIDHoverHeight { set { m_PIDHoverHeight = value; ; } }
2898 public override bool PIDHoverActive { set { m_useHoverPID = value; } }
2899 public override PIDHoverType PIDHoverType { set { m_PIDHoverType = value; } }
2900 public override float PIDHoverTau { set { m_PIDHoverTau = value; } }
2901
2902 private void createAMotor(Vector3 axis)
2903 {
2904 if (Body == IntPtr.Zero)
2905 return;
2906
2907 if (Amotor != IntPtr.Zero)
2908 {
2909 d.JointDestroy(Amotor);
2910 Amotor = IntPtr.Zero;
2911 }
2912
2913 float axisnum = 3;
2914
2915 axisnum = (axisnum - (axis.X + axis.Y + axis.Z));
2916
2917 // PhysicsVector totalSize = new PhysicsVector(_size.X, _size.Y, _size.Z);
2918
2919
2920 // Inverse Inertia Matrix, set the X, Y, and/r Z inertia to 0 then invert it again.
2921 d.Mass objMass;
2922 d.MassSetZero(out objMass);
2923 DMassCopy(ref pMass, ref objMass);
2924
2925 //m_log.DebugFormat("1-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", objMass.I.M00, objMass.I.M01, objMass.I.M02, objMass.I.M10, objMass.I.M11, objMass.I.M12, objMass.I.M20, objMass.I.M21, objMass.I.M22);
2926
2927 Matrix4 dMassMat = FromDMass(objMass);
2928
2929 Matrix4 mathmat = Inverse(dMassMat);
2930
2931 /*
2932 //m_log.DebugFormat("2-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", mathmat[0, 0], mathmat[0, 1], mathmat[0, 2], mathmat[1, 0], mathmat[1, 1], mathmat[1, 2], mathmat[2, 0], mathmat[2, 1], mathmat[2, 2]);
2933
2934 mathmat = Inverse(mathmat);
2935
2936
2937 objMass = FromMatrix4(mathmat, ref objMass);
2938 //m_log.DebugFormat("3-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", objMass.I.M00, objMass.I.M01, objMass.I.M02, objMass.I.M10, objMass.I.M11, objMass.I.M12, objMass.I.M20, objMass.I.M21, objMass.I.M22);
2939
2940 mathmat = Inverse(mathmat);
2941 */
2942 if (axis.X == 0)
2943 {
2944 mathmat.M33 = 50.0000001f;
2945 //objMass.I.M22 = 0;
2946 }
2947 if (axis.Y == 0)
2948 {
2949 mathmat.M22 = 50.0000001f;
2950 //objMass.I.M11 = 0;
2951 }
2952 if (axis.Z == 0)
2953 {
2954 mathmat.M11 = 50.0000001f;
2955 //objMass.I.M00 = 0;
2956 }
2957
2958
2959
2960 mathmat = Inverse(mathmat);
2961 objMass = FromMatrix4(mathmat, ref objMass);
2962 //m_log.DebugFormat("4-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", objMass.I.M00, objMass.I.M01, objMass.I.M02, objMass.I.M10, objMass.I.M11, objMass.I.M12, objMass.I.M20, objMass.I.M21, objMass.I.M22);
2963
2964 //return;
2965 if (d.MassCheck(ref objMass))
2966 {
2967 d.BodySetMass(Body, ref objMass);
2968 }
2969 else
2970 {
2971 //m_log.Debug("[PHYSICS]: Mass invalid, ignoring");
2972 }
2973
2974 if (axisnum <= 0)
2975 return;
2976 // int dAMotorEuler = 1;
2977
2978 Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
2979 d.JointAttach(Amotor, Body, IntPtr.Zero);
2980 d.JointSetAMotorMode(Amotor, 0);
2981
2982 d.JointSetAMotorNumAxes(Amotor,(int)axisnum);
2983 int i = 0;
2984
2985 if (axis.X == 0)
2986 {
2987 d.JointSetAMotorAxis(Amotor, i, 0, 1, 0, 0);
2988 i++;
2989 }
2990
2991 if (axis.Y == 0)
2992 {
2993 d.JointSetAMotorAxis(Amotor, i, 0, 0, 1, 0);
2994 i++;
2995 }
2996
2997 if (axis.Z == 0)
2998 {
2999 d.JointSetAMotorAxis(Amotor, i, 0, 0, 0, 1);
3000 i++;
3001 }
3002
3003 for (int j = 0; j < (int)axisnum; j++)
3004 {
3005 //d.JointSetAMotorAngle(Amotor, j, 0);
3006 }
3007
3008 //d.JointSetAMotorAngle(Amotor, 1, 0);
3009 //d.JointSetAMotorAngle(Amotor, 2, 0);
3010
3011 // These lowstops and high stops are effectively (no wiggle room)
3012 d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -0f);
3013 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -0f);
3014 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -0f);
3015 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 0f);
3016 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0f);
3017 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 0f);
3018 //d.JointSetAMotorParam(Amotor, (int) dParam.Vel, 9000f);
3019 d.JointSetAMotorParam(Amotor, (int)dParam.FudgeFactor, 0f);
3020 d.JointSetAMotorParam(Amotor, (int)dParam.FMax, Mass * 50f);//
3021
3022 }
3023
3024 public Matrix4 FromDMass(d.Mass pMass)
3025 {
3026 Matrix4 obj;
3027 obj.M11 = pMass.I.M00;
3028 obj.M12 = pMass.I.M01;
3029 obj.M13 = pMass.I.M02;
3030 obj.M14 = 0;
3031 obj.M21 = pMass.I.M10;
3032 obj.M22 = pMass.I.M11;
3033 obj.M23 = pMass.I.M12;
3034 obj.M24 = 0;
3035 obj.M31 = pMass.I.M20;
3036 obj.M32 = pMass.I.M21;
3037 obj.M33 = pMass.I.M22;
3038 obj.M34 = 0;
3039 obj.M41 = 0;
3040 obj.M42 = 0;
3041 obj.M43 = 0;
3042 obj.M44 = 1;
3043 return obj;
3044 }
3045
3046 public d.Mass FromMatrix4(Matrix4 pMat, ref d.Mass obj)
3047 {
3048 obj.I.M00 = pMat[0, 0];
3049 obj.I.M01 = pMat[0, 1];
3050 obj.I.M02 = pMat[0, 2];
3051 obj.I.M10 = pMat[1, 0];
3052 obj.I.M11 = pMat[1, 1];
3053 obj.I.M12 = pMat[1, 2];
3054 obj.I.M20 = pMat[2, 0];
3055 obj.I.M21 = pMat[2, 1];
3056 obj.I.M22 = pMat[2, 2];
3057 return obj;
3058 }
3059
3060 public override void SubscribeEvents(int ms)
3061 {
3062 m_eventsubscription = ms;
3063 _parent_scene.addCollisionEventReporting(this);
3064 }
3065
3066 public override void UnSubscribeEvents()
3067 {
3068 _parent_scene.remCollisionEventReporting(this);
3069 m_eventsubscription = 0;
3070 }
3071
3072 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
3073 {
3074 if (CollisionEventsThisFrame == null)
3075 CollisionEventsThisFrame = new CollisionEventUpdate();
3076 CollisionEventsThisFrame.addCollider(CollidedWith, contact);
3077 }
3078
3079 public void SendCollisions()
3080 {
3081 if (CollisionEventsThisFrame == null)
3082 return;
3083
3084 base.SendCollisionUpdate(CollisionEventsThisFrame);
3085
3086 if (CollisionEventsThisFrame.m_objCollisionList.Count == 0)
3087 CollisionEventsThisFrame = null;
3088 else
3089 CollisionEventsThisFrame = new CollisionEventUpdate();
3090 }
3091
3092 public override bool SubscribedEvents()
3093 {
3094 if (m_eventsubscription > 0)
3095 return true;
3096 return false;
3097 }
3098
3099 public static Matrix4 Inverse(Matrix4 pMat)
3100 {
3101 if (determinant3x3(pMat) == 0)
3102 {
3103 return Matrix4.Identity; // should probably throw an error. singluar matrix inverse not possible
3104 }
3105
3106
3107
3108 return (Adjoint(pMat) / determinant3x3(pMat));
3109 }
3110
3111 public static Matrix4 Adjoint(Matrix4 pMat)
3112 {
3113 Matrix4 adjointMatrix = new Matrix4();
3114 for (int i=0; i<4; i++)
3115 {
3116 for (int j=0; j<4; j++)
3117 {
3118 Matrix4SetValue(ref adjointMatrix, i, j, (float)(Math.Pow(-1, i + j) * (determinant3x3(Minor(pMat, i, j)))));
3119 }
3120 }
3121
3122 adjointMatrix = Transpose(adjointMatrix);
3123 return adjointMatrix;
3124 }
3125
3126 public static Matrix4 Minor(Matrix4 matrix, int iRow, int iCol)
3127 {
3128 Matrix4 minor = new Matrix4();
3129 int m = 0, n = 0;
3130 for (int i = 0; i < 4; i++)
3131 {
3132 if (i == iRow)
3133 continue;
3134 n = 0;
3135 for (int j = 0; j < 4; j++)
3136 {
3137 if (j == iCol)
3138 continue;
3139 Matrix4SetValue(ref minor, m,n, matrix[i, j]);
3140 n++;
3141 }
3142 m++;
3143 }
3144 return minor;
3145 }
3146
3147 public static Matrix4 Transpose(Matrix4 pMat)
3148 {
3149 Matrix4 transposeMatrix = new Matrix4();
3150 for (int i = 0; i < 4; i++)
3151 for (int j = 0; j < 4; j++)
3152 Matrix4SetValue(ref transposeMatrix, i, j, pMat[j, i]);
3153 return transposeMatrix;
3154 }
3155
3156 public static void Matrix4SetValue(ref Matrix4 pMat, int r, int c, float val)
3157 {
3158 switch (r)
3159 {
3160 case 0:
3161 switch (c)
3162 {
3163 case 0:
3164 pMat.M11 = val;
3165 break;
3166 case 1:
3167 pMat.M12 = val;
3168 break;
3169 case 2:
3170 pMat.M13 = val;
3171 break;
3172 case 3:
3173 pMat.M14 = val;
3174 break;
3175 }
3176
3177 break;
3178 case 1:
3179 switch (c)
3180 {
3181 case 0:
3182 pMat.M21 = val;
3183 break;
3184 case 1:
3185 pMat.M22 = val;
3186 break;
3187 case 2:
3188 pMat.M23 = val;
3189 break;
3190 case 3:
3191 pMat.M24 = val;
3192 break;
3193 }
3194
3195 break;
3196 case 2:
3197 switch (c)
3198 {
3199 case 0:
3200 pMat.M31 = val;
3201 break;
3202 case 1:
3203 pMat.M32 = val;
3204 break;
3205 case 2:
3206 pMat.M33 = val;
3207 break;
3208 case 3:
3209 pMat.M34 = val;
3210 break;
3211 }
3212
3213 break;
3214 case 3:
3215 switch (c)
3216 {
3217 case 0:
3218 pMat.M41 = val;
3219 break;
3220 case 1:
3221 pMat.M42 = val;
3222 break;
3223 case 2:
3224 pMat.M43 = val;
3225 break;
3226 case 3:
3227 pMat.M44 = val;
3228 break;
3229 }
3230
3231 break;
3232 }
3233 }
3234 private static float determinant3x3(Matrix4 pMat)
3235 {
3236 float det = 0;
3237 float diag1 = pMat[0, 0]*pMat[1, 1]*pMat[2, 2];
3238 float diag2 = pMat[0, 1]*pMat[2, 1]*pMat[2, 0];
3239 float diag3 = pMat[0, 2]*pMat[1, 0]*pMat[2, 1];
3240 float diag4 = pMat[2, 0]*pMat[1, 1]*pMat[0, 2];
3241 float diag5 = pMat[2, 1]*pMat[1, 2]*pMat[0, 0];
3242 float diag6 = pMat[2, 2]*pMat[1, 0]*pMat[0, 1];
3243
3244 det = diag1 + diag2 + diag3 - (diag4 + diag5 + diag6);
3245 return det;
3246
3247 }
3248
3249 private static void DMassCopy(ref d.Mass src, ref d.Mass dst)
3250 {
3251 dst.c.W = src.c.W;
3252 dst.c.X = src.c.X;
3253 dst.c.Y = src.c.Y;
3254 dst.c.Z = src.c.Z;
3255 dst.mass = src.mass;
3256 dst.I.M00 = src.I.M00;
3257 dst.I.M01 = src.I.M01;
3258 dst.I.M02 = src.I.M02;
3259 dst.I.M10 = src.I.M10;
3260 dst.I.M11 = src.I.M11;
3261 dst.I.M12 = src.I.M12;
3262 dst.I.M20 = src.I.M20;
3263 dst.I.M21 = src.I.M21;
3264 dst.I.M22 = src.I.M22;
3265 }
3266
3267 public override void SetMaterial(int pMaterial)
3268 {
3269 m_material = pMaterial;
3270 }
3271
3272 }
3273}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/ODERayCastRequestManager.cs b/OpenSim/Region/Physics/ChOdePlugin/ODERayCastRequestManager.cs
new file mode 100644
index 0000000..7314107
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/ODERayCastRequestManager.cs
@@ -0,0 +1,375 @@
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
28using System;
29using System.Collections.Generic;
30using System.Reflection;
31using System.Runtime.InteropServices;
32using System.Text;
33using OpenMetaverse;
34using OpenSim.Region.Physics.Manager;
35using Ode.NET;
36using log4net;
37
38namespace OpenSim.Region.Physics.OdePlugin
39{
40 /// <summary>
41 /// Processes raycast requests as ODE is in a state to be able to do them.
42 /// This ensures that it's thread safe and there will be no conflicts.
43 /// Requests get returned by a different thread then they were requested by.
44 /// </summary>
45 public class ODERayCastRequestManager
46 {
47 /// <summary>
48 /// Pending Raycast Requests
49 /// </summary>
50 protected List<ODERayCastRequest> m_PendingRequests = new List<ODERayCastRequest>();
51
52 /// <summary>
53 /// Scene that created this object.
54 /// </summary>
55 private OdeScene m_scene;
56
57 /// <summary>
58 /// ODE contact array to be filled by the collision testing
59 /// </summary>
60 d.ContactGeom[] contacts = new d.ContactGeom[5];
61
62 /// <summary>
63 /// ODE near callback delegate
64 /// </summary>
65 private d.NearCallback nearCallback;
66 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
67 private List<ContactResult> m_contactResults = new List<ContactResult>();
68
69
70 public ODERayCastRequestManager(OdeScene pScene)
71 {
72 m_scene = pScene;
73 nearCallback = near;
74
75 }
76
77 /// <summary>
78 /// Queues a raycast
79 /// </summary>
80 /// <param name="position">Origin of Ray</param>
81 /// <param name="direction">Ray normal</param>
82 /// <param name="length">Ray length</param>
83 /// <param name="retMethod">Return method to send the results</param>
84 public void QueueRequest(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
85 {
86 lock (m_PendingRequests)
87 {
88 ODERayCastRequest req = new ODERayCastRequest();
89 req.callbackMethod = retMethod;
90 req.length = length;
91 req.Normal = direction;
92 req.Origin = position;
93
94 m_PendingRequests.Add(req);
95 }
96 }
97
98 /// <summary>
99 /// Process all queued raycast requests
100 /// </summary>
101 /// <returns>Time in MS the raycasts took to process.</returns>
102 public int ProcessQueuedRequests()
103 {
104 int time = System.Environment.TickCount;
105 lock (m_PendingRequests)
106 {
107 if (m_PendingRequests.Count > 0)
108 {
109 ODERayCastRequest[] reqs = m_PendingRequests.ToArray();
110 for (int i = 0; i < reqs.Length; i++)
111 {
112 if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast
113 RayCast(reqs[i]); // if there isn't anyone to send results
114 }
115 /*
116 foreach (ODERayCastRequest req in m_PendingRequests)
117 {
118 if (req.callbackMethod != null) // quick optimization here, don't raycast
119 RayCast(req); // if there isn't anyone to send results to
120
121 }
122 */
123 m_PendingRequests.Clear();
124 }
125 }
126
127 lock (m_contactResults)
128 m_contactResults.Clear();
129
130 return System.Environment.TickCount - time;
131 }
132
133 /// <summary>
134 /// Method that actually initiates the raycast
135 /// </summary>
136 /// <param name="req"></param>
137 private void RayCast(ODERayCastRequest req)
138 {
139 // Create the ray
140 IntPtr ray = d.CreateRay(m_scene.space, req.length);
141 d.GeomRaySet(ray, req.Origin.X, req.Origin.Y, req.Origin.Z, req.Normal.X, req.Normal.Y, req.Normal.Z);
142
143 // Collide test
144 d.SpaceCollide2(m_scene.space, ray, IntPtr.Zero, nearCallback);
145
146 // Remove Ray
147 d.GeomDestroy(ray);
148
149
150 // Define default results
151 bool hitYN = false;
152 uint hitConsumerID = 0;
153 float distance = 999999999999f;
154 Vector3 closestcontact = new Vector3(99999f, 99999f, 99999f);
155 Vector3 snormal = Vector3.Zero;
156
157 // Find closest contact and object.
158 lock (m_contactResults)
159 {
160 foreach (ContactResult cResult in m_contactResults)
161 {
162 if (Vector3.Distance(req.Origin, cResult.Pos) < Vector3.Distance(req.Origin, closestcontact))
163 {
164 closestcontact = cResult.Pos;
165 hitConsumerID = cResult.ConsumerID;
166 distance = cResult.Depth;
167 hitYN = true;
168 snormal = cResult.Normal;
169 }
170 }
171
172 m_contactResults.Clear();
173 }
174
175 // Return results
176 if (req.callbackMethod != null)
177 req.callbackMethod(hitYN, closestcontact, hitConsumerID, distance, snormal);
178 }
179
180 // This is the standard Near. Uses space AABBs to speed up detection.
181 private void near(IntPtr space, IntPtr g1, IntPtr g2)
182 {
183
184 //Don't test against heightfield Geom, or you'll be sorry!
185
186 /*
187 terminate called after throwing an instance of 'std::bad_alloc'
188 what(): std::bad_alloc
189 Stacktrace:
190
191 at (wrapper managed-to-native) Ode.NET.d.Collide (intptr,intptr,int,Ode.NET.d/ContactGeom[],int) <0x00004>
192 at (wrapper managed-to-native) Ode.NET.d.Collide (intptr,intptr,int,Ode.NET.d/ContactGeom[],int) <0xffffffff>
193 at OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.near (intptr,intptr,intptr) <0x00280>
194 at (wrapper native-to-managed) OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.near (intptr,intptr,intptr) <0xfff
195 fffff>
196 at (wrapper managed-to-native) Ode.NET.d.SpaceCollide2 (intptr,intptr,intptr,Ode.NET.d/NearCallback) <0x00004>
197 at (wrapper managed-to-native) Ode.NET.d.SpaceCollide2 (intptr,intptr,intptr,Ode.NET.d/NearCallback) <0xffffffff>
198 at OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.RayCast (OpenSim.Region.Physics.OdePlugin.ODERayCastRequest) <
199 0x00114>
200 at OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.ProcessQueuedRequests () <0x000eb>
201 at OpenSim.Region.Physics.OdePlugin.OdeScene.Simulate (single) <0x017e6>
202 at OpenSim.Region.Framework.Scenes.SceneGraph.UpdatePhysics (double) <0x00042>
203 at OpenSim.Region.Framework.Scenes.Scene.Update () <0x0039e>
204 at OpenSim.Region.Framework.Scenes.Scene.Heartbeat (object) <0x00019>
205 at (wrapper runtime-invoke) object.runtime_invoke_void__this___object (object,intptr,intptr,intptr) <0xffffffff>
206
207 Native stacktrace:
208
209 mono [0x80d2a42]
210 [0xb7f5840c]
211 /lib/i686/cmov/libc.so.6(abort+0x188) [0xb7d1a018]
212 /usr/lib/libstdc++.so.6(_ZN9__gnu_cxx27__verbose_terminate_handlerEv+0x158) [0xb45fc988]
213 /usr/lib/libstdc++.so.6 [0xb45fa865]
214 /usr/lib/libstdc++.so.6 [0xb45fa8a2]
215 /usr/lib/libstdc++.so.6 [0xb45fa9da]
216 /usr/lib/libstdc++.so.6(_Znwj+0x83) [0xb45fb033]
217 /usr/lib/libstdc++.so.6(_Znaj+0x1d) [0xb45fb11d]
218 libode.so(_ZN13dxHeightfield23dCollideHeightfieldZoneEiiiiP6dxGeomiiP12dContactGeomi+0xd04) [0xb46678e4]
219 libode.so(_Z19dCollideHeightfieldP6dxGeomS0_iP12dContactGeomi+0x54b) [0xb466832b]
220 libode.so(dCollide+0x102) [0xb46571b2]
221 [0x95cfdec9]
222 [0x8ea07fe1]
223 [0xab260146]
224 libode.so [0xb465a5c4]
225 libode.so(_ZN11dxHashSpace8collide2EPvP6dxGeomPFvS0_S2_S2_E+0x75) [0xb465bcf5]
226 libode.so(dSpaceCollide2+0x177) [0xb465ac67]
227 [0x95cf978e]
228 [0x8ea07945]
229 [0x95cf2bbc]
230 [0xab2787e7]
231 [0xab419fb3]
232 [0xab416657]
233 [0xab415bda]
234 [0xb609b08e]
235 mono(mono_runtime_delegate_invoke+0x34) [0x8192534]
236 mono [0x81a2f0f]
237 mono [0x81d28b6]
238 mono [0x81ea2c6]
239 /lib/i686/cmov/libpthread.so.0 [0xb7e744c0]
240 /lib/i686/cmov/libc.so.6(clone+0x5e) [0xb7dcd6de]
241 */
242
243 // Exclude heightfield geom
244
245 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
246 return;
247 if (d.GeomGetClass(g1) == d.GeomClassID.HeightfieldClass || d.GeomGetClass(g2) == d.GeomClassID.HeightfieldClass)
248 return;
249
250 // Raytest against AABBs of spaces first, then dig into the spaces it hits for actual geoms.
251 if (d.GeomIsSpace(g1) || d.GeomIsSpace(g2))
252 {
253 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
254 return;
255
256 // Separating static prim geometry spaces.
257 // We'll be calling near recursivly if one
258 // of them is a space to find all of the
259 // contact points in the space
260 try
261 {
262 d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
263 }
264 catch (AccessViolationException)
265 {
266 m_log.Warn("[PHYSICS]: Unable to collide test a space");
267 return;
268 }
269 //Colliding a space or a geom with a space or a geom. so drill down
270
271 //Collide all geoms in each space..
272 //if (d.GeomIsSpace(g1)) d.SpaceCollide(g1, IntPtr.Zero, nearCallback);
273 //if (d.GeomIsSpace(g2)) d.SpaceCollide(g2, IntPtr.Zero, nearCallback);
274 return;
275 }
276
277 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
278 return;
279
280 int count = 0;
281 try
282 {
283
284 if (g1 == g2)
285 return; // Can't collide with yourself
286
287 lock (contacts)
288 {
289 count = d.Collide(g1, g2, contacts.GetLength(0), contacts, d.ContactGeom.SizeOf);
290 }
291 }
292 catch (SEHException)
293 {
294 m_log.Error("[PHYSICS]: The Operating system shut down ODE because of corrupt memory. This could be a result of really irregular terrain. If this repeats continuously, restart using Basic Physics and terrain fill your terrain. Restarting the sim.");
295 }
296 catch (Exception e)
297 {
298 m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
299 return;
300 }
301
302 PhysicsActor p1 = null;
303 PhysicsActor p2 = null;
304
305 if (g1 != IntPtr.Zero)
306 m_scene.actor_name_map.TryGetValue(g1, out p1);
307
308 if (g2 != IntPtr.Zero)
309 m_scene.actor_name_map.TryGetValue(g1, out p2);
310
311 // Loop over contacts, build results.
312 for (int i = 0; i < count; i++)
313 {
314 if (p1 != null) {
315 if (p1 is OdePrim)
316 {
317 ContactResult collisionresult = new ContactResult();
318
319 collisionresult.ConsumerID = ((OdePrim)p1).m_localID;
320 collisionresult.Pos = new Vector3(contacts[i].pos.X, contacts[i].pos.Y, contacts[i].pos.Z);
321 collisionresult.Depth = contacts[i].depth;
322 collisionresult.Normal = new Vector3(contacts[i].normal.X, contacts[i].normal.Y,
323 contacts[i].normal.Z);
324 lock (m_contactResults)
325 m_contactResults.Add(collisionresult);
326 }
327 }
328
329 if (p2 != null)
330 {
331 if (p2 is OdePrim)
332 {
333 ContactResult collisionresult = new ContactResult();
334
335 collisionresult.ConsumerID = ((OdePrim)p2).m_localID;
336 collisionresult.Pos = new Vector3(contacts[i].pos.X, contacts[i].pos.Y, contacts[i].pos.Z);
337 collisionresult.Depth = contacts[i].depth;
338 collisionresult.Normal = new Vector3(contacts[i].normal.X, contacts[i].normal.Y,
339 contacts[i].normal.Z);
340
341 lock (m_contactResults)
342 m_contactResults.Add(collisionresult);
343 }
344 }
345
346
347 }
348
349 }
350
351 /// <summary>
352 /// Dereference the creator scene so that it can be garbage collected if needed.
353 /// </summary>
354 internal void Dispose()
355 {
356 m_scene = null;
357 }
358 }
359
360 public struct ODERayCastRequest
361 {
362 public Vector3 Origin;
363 public Vector3 Normal;
364 public float length;
365 public RaycastCallback callbackMethod;
366 }
367
368 public struct ContactResult
369 {
370 public Vector3 Pos;
371 public float Depth;
372 public uint ConsumerID;
373 public Vector3 Normal;
374 }
375}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/OdePhysicsJoint.cs b/OpenSim/Region/Physics/ChOdePlugin/OdePhysicsJoint.cs
new file mode 100644
index 0000000..b4a3c48
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/OdePhysicsJoint.cs
@@ -0,0 +1,48 @@
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
28using System;
29using OpenMetaverse;
30using Ode.NET;
31using OpenSim.Framework;
32using OpenSim.Region.Physics.Manager;
33using OpenSim.Region.Physics.OdePlugin;
34
35namespace OpenSim.Region.Physics.OdePlugin
36{
37 class OdePhysicsJoint : PhysicsJoint
38 {
39 public override bool IsInPhysicsEngine
40 {
41 get
42 {
43 return (jointID != IntPtr.Zero);
44 }
45 }
46 public IntPtr jointID;
47 }
48}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs
new file mode 100644
index 0000000..f48649e
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs
@@ -0,0 +1,3865 @@
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//#define USE_DRAWSTUFF
29
30using System;
31using System.Collections.Generic;
32using System.Reflection;
33using System.Runtime.InteropServices;
34using System.Threading;
35using System.IO;
36using System.Diagnostics;
37using log4net;
38using Nini.Config;
39using Ode.NET;
40#if USE_DRAWSTUFF
41using Drawstuff.NET;
42#endif
43using OpenSim.Framework;
44using OpenSim.Region.Physics.Manager;
45using OpenMetaverse;
46
47//using OpenSim.Region.Physics.OdePlugin.Meshing;
48
49namespace OpenSim.Region.Physics.OdePlugin
50{
51 /// <summary>
52 /// ODE plugin
53 /// </summary>
54 public class OdePlugin : IPhysicsPlugin
55 {
56 //private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
57
58 private CollisionLocker ode;
59 private OdeScene _mScene;
60
61 public OdePlugin()
62 {
63 ode = new CollisionLocker();
64 }
65
66 public bool Init()
67 {
68 return true;
69 }
70
71 public PhysicsScene GetScene(String sceneIdentifier)
72 {
73 if (_mScene == null)
74 {
75 // Initializing ODE only when a scene is created allows alternative ODE plugins to co-habit (according to
76 // http://opensimulator.org/mantis/view.php?id=2750).
77 d.InitODE();
78
79 _mScene = new OdeScene(ode, sceneIdentifier);
80 }
81 return (_mScene);
82 }
83
84 public string GetName()
85 {
86 return ("ChODE");
87 }
88
89 public void Dispose()
90 {
91 }
92 }
93
94 public enum StatusIndicators : int
95 {
96 Generic = 0,
97 Start = 1,
98 End = 2
99 }
100
101 public struct sCollisionData
102 {
103 public uint ColliderLocalId;
104 public uint CollidedWithLocalId;
105 public int NumberOfCollisions;
106 public int CollisionType;
107 public int StatusIndicator;
108 public int lastframe;
109 }
110
111 [Flags]
112 public enum CollisionCategories : int
113 {
114 Disabled = 0,
115 Geom = 0x00000001,
116 Body = 0x00000002,
117 Space = 0x00000004,
118 Character = 0x00000008,
119 Land = 0x00000010,
120 Water = 0x00000020,
121 Wind = 0x00000040,
122 Sensor = 0x00000080,
123 Selected = 0x00000100
124 }
125
126 /// <summary>
127 /// Material type for a primitive
128 /// </summary>
129 public enum Material : int
130 {
131 /// <summary></summary>
132 Stone = 0,
133 /// <summary></summary>
134 Metal = 1,
135 /// <summary></summary>
136 Glass = 2,
137 /// <summary></summary>
138 Wood = 3,
139 /// <summary></summary>
140 Flesh = 4,
141 /// <summary></summary>
142 Plastic = 5,
143 /// <summary></summary>
144 Rubber = 6
145
146 }
147
148 public sealed class OdeScene : PhysicsScene
149 {
150 private readonly ILog m_log;
151 // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
152
153 CollisionLocker ode;
154
155 private Random fluidRandomizer = new Random(Environment.TickCount);
156
157 private const uint m_regionWidth = Constants.RegionSize;
158 private const uint m_regionHeight = Constants.RegionSize;
159
160 private float ODE_STEPSIZE = 0.020f;
161 private float metersInSpace = 29.9f;
162 private float m_timeDilation = 1.0f;
163
164 public float gravityx = 0f;
165 public float gravityy = 0f;
166 public float gravityz = -9.8f;
167
168 private float contactsurfacelayer = 0.001f;
169
170 private int worldHashspaceLow = -4;
171 private int worldHashspaceHigh = 128;
172
173 private int smallHashspaceLow = -4;
174 private int smallHashspaceHigh = 66;
175
176 private float waterlevel = 0f;
177 private int framecount = 0;
178 //private int m_returncollisions = 10;
179
180 private readonly IntPtr contactgroup;
181
182 internal IntPtr LandGeom;
183 internal IntPtr WaterGeom;
184
185 private float nmTerrainContactFriction = 255.0f;
186 private float nmTerrainContactBounce = 0.1f;
187 private float nmTerrainContactERP = 0.1025f;
188
189 private float mTerrainContactFriction = 75f;
190 private float mTerrainContactBounce = 0.1f;
191 private float mTerrainContactERP = 0.05025f;
192
193 private float nmAvatarObjectContactFriction = 250f;
194 private float nmAvatarObjectContactBounce = 0.1f;
195
196 private float mAvatarObjectContactFriction = 75f;
197 private float mAvatarObjectContactBounce = 0.1f;
198
199 private float avPIDD = 3200f;
200 private float avPIDP = 1400f;
201 private float avCapRadius = 0.37f;
202 private float avStandupTensor = 2000000f;
203 private bool avCapsuleTilted = true; // true = old compatibility mode with leaning capsule; false = new corrected mode
204 public bool IsAvCapsuleTilted { get { return avCapsuleTilted; } set { avCapsuleTilted = value; } }
205 private float avDensity = 80f;
206 private float avHeightFudgeFactor = 0.52f;
207 private float avMovementDivisorWalk = 1.3f;
208 private float avMovementDivisorRun = 0.8f;
209 private float minimumGroundFlightOffset = 3f;
210 public float maximumMassObject = 10000.01f;
211
212 public bool meshSculptedPrim = true;
213 public bool forceSimplePrimMeshing = false;
214
215 public float meshSculptLOD = 32;
216 public float MeshSculptphysicalLOD = 16;
217
218 public float geomDefaultDensity = 10.000006836f;
219
220 public int geomContactPointsStartthrottle = 3;
221 public int geomUpdatesPerThrottledUpdate = 15;
222
223 public float bodyPIDD = 35f;
224 public float bodyPIDG = 25;
225
226 public int geomCrossingFailuresBeforeOutofbounds = 5;
227
228 public float bodyMotorJointMaxforceTensor = 2;
229
230 public int bodyFramesAutoDisable = 20;
231
232
233
234 private float[] _watermap;
235 private bool m_filterCollisions = true;
236
237 private d.NearCallback nearCallback;
238 public d.TriCallback triCallback;
239 public d.TriArrayCallback triArrayCallback;
240 private readonly HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
241 private readonly HashSet<OdePrim> _prims = new HashSet<OdePrim>();
242 private readonly HashSet<OdePrim> _activeprims = new HashSet<OdePrim>();
243 private readonly HashSet<OdePrim> _taintedPrimH = new HashSet<OdePrim>();
244 private readonly Object _taintedPrimLock = new Object();
245 private readonly List<OdePrim> _taintedPrimL = new List<OdePrim>();
246 private readonly HashSet<OdeCharacter> _taintedActors = new HashSet<OdeCharacter>();
247 private readonly List<d.ContactGeom> _perloopContact = new List<d.ContactGeom>();
248 private readonly List<PhysicsActor> _collisionEventPrim = new List<PhysicsActor>();
249 private readonly HashSet<OdeCharacter> _badCharacter = new HashSet<OdeCharacter>();
250 public Dictionary<IntPtr, String> geom_name_map = new Dictionary<IntPtr, String>();
251 public Dictionary<IntPtr, PhysicsActor> actor_name_map = new Dictionary<IntPtr, PhysicsActor>();
252 private bool m_NINJA_physics_joints_enabled = false;
253 //private Dictionary<String, IntPtr> jointpart_name_map = new Dictionary<String,IntPtr>();
254 private readonly Dictionary<String, List<PhysicsJoint>> joints_connecting_actor = new Dictionary<String, List<PhysicsJoint>>();
255 private d.ContactGeom[] contacts;
256 private readonly List<PhysicsJoint> requestedJointsToBeCreated = new List<PhysicsJoint>(); // lock only briefly. accessed by external code (to request new joints) and by OdeScene.Simulate() to move those joints into pending/active
257 private readonly List<PhysicsJoint> pendingJoints = new List<PhysicsJoint>(); // can lock for longer. accessed only by OdeScene.
258 private readonly List<PhysicsJoint> activeJoints = new List<PhysicsJoint>(); // can lock for longer. accessed only by OdeScene.
259 private readonly List<string> requestedJointsToBeDeleted = new List<string>(); // lock only briefly. accessed by external code (to request deletion of joints) and by OdeScene.Simulate() to move those joints out of pending/active
260 private Object externalJointRequestsLock = new Object();
261 private readonly Dictionary<String, PhysicsJoint> SOPName_to_activeJoint = new Dictionary<String, PhysicsJoint>();
262 private readonly Dictionary<String, PhysicsJoint> SOPName_to_pendingJoint = new Dictionary<String, PhysicsJoint>();
263 private readonly DoubleDictionary<Vector3, IntPtr, IntPtr> RegionTerrain = new DoubleDictionary<Vector3, IntPtr, IntPtr>();
264 private readonly Dictionary<IntPtr,float[]> TerrainHeightFieldHeights = new Dictionary<IntPtr, float[]>();
265
266 private d.Contact contact;
267 private d.Contact TerrainContact;
268 private d.Contact AvatarMovementprimContact;
269 private d.Contact AvatarMovementTerrainContact;
270 private d.Contact WaterContact;
271 private d.Contact[,] m_materialContacts;
272
273//Ckrinke: Comment out until used. We declare it, initialize it, but do not use it
274//Ckrinke private int m_randomizeWater = 200;
275 private int m_physicsiterations = 10;
276 private const float m_SkipFramesAtms = 0.40f; // Drop frames gracefully at a 400 ms lag
277 private readonly PhysicsActor PANull = new NullPhysicsActor();
278 private float step_time = 0.0f;
279//Ckrinke: Comment out until used. We declare it, initialize it, but do not use it
280//Ckrinke private int ms = 0;
281 public IntPtr world;
282 //private bool returncollisions = false;
283 // private uint obj1LocalID = 0;
284 private uint obj2LocalID = 0;
285 //private int ctype = 0;
286 private OdeCharacter cc1;
287 private OdePrim cp1;
288 private OdeCharacter cc2;
289 private OdePrim cp2;
290 //private int cStartStop = 0;
291 //private string cDictKey = "";
292
293 public IntPtr space;
294
295 //private IntPtr tmpSpace;
296 // split static geometry collision handling into spaces of 30 meters
297 public IntPtr[,] staticPrimspace;
298
299 public Object OdeLock;
300
301 public IMesher mesher;
302
303 private IConfigSource m_config;
304
305 public bool physics_logging = false;
306 public int physics_logging_interval = 0;
307 public bool physics_logging_append_existing_logfile = false;
308
309 public d.Vector3 xyz = new d.Vector3(128.1640f, 128.3079f, 25.7600f);
310 public d.Vector3 hpr = new d.Vector3(125.5000f, -17.0000f, 0.0000f);
311
312 // TODO: unused: private uint heightmapWidth = m_regionWidth + 1;
313 // TODO: unused: private uint heightmapHeight = m_regionHeight + 1;
314 // TODO: unused: private uint heightmapWidthSamples;
315 // TODO: unused: private uint heightmapHeightSamples;
316
317 private volatile int m_global_contactcount = 0;
318
319 private Vector3 m_worldOffset = Vector3.Zero;
320 public Vector2 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
321 private PhysicsScene m_parentScene = null;
322
323 private ODERayCastRequestManager m_rayCastManager;
324
325 /// <summary>
326 /// Initiailizes the scene
327 /// Sets many properties that ODE requires to be stable
328 /// These settings need to be tweaked 'exactly' right or weird stuff happens.
329 /// </summary>
330 public OdeScene(CollisionLocker dode, string sceneIdentifier)
331 {
332 m_log
333 = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + sceneIdentifier);
334
335 OdeLock = new Object();
336 ode = dode;
337 nearCallback = near;
338 triCallback = TriCallback;
339 triArrayCallback = TriArrayCallback;
340 m_rayCastManager = new ODERayCastRequestManager(this);
341 lock (OdeLock)
342 {
343 // Create the world and the first space
344 world = d.WorldCreate();
345 space = d.HashSpaceCreate(IntPtr.Zero);
346
347
348 contactgroup = d.JointGroupCreate(0);
349 //contactgroup
350
351 d.WorldSetAutoDisableFlag(world, false);
352 #if USE_DRAWSTUFF
353
354 Thread viewthread = new Thread(new ParameterizedThreadStart(startvisualization));
355 viewthread.Start();
356 #endif
357 }
358
359
360 _watermap = new float[258 * 258];
361
362 // Zero out the prim spaces array (we split our space into smaller spaces so
363 // we can hit test less.
364 }
365
366#if USE_DRAWSTUFF
367 public void startvisualization(object o)
368 {
369 ds.Functions fn;
370 fn.version = ds.VERSION;
371 fn.start = new ds.CallbackFunction(start);
372 fn.step = new ds.CallbackFunction(step);
373 fn.command = new ds.CallbackFunction(command);
374 fn.stop = null;
375 fn.path_to_textures = "./textures";
376 string[] args = new string[0];
377 ds.SimulationLoop(args.Length, args, 352, 288, ref fn);
378 }
379#endif
380
381 // Initialize the mesh plugin
382 public override void Initialise(IMesher meshmerizer, IConfigSource config)
383 {
384 mesher = meshmerizer;
385 m_config = config;
386 // Defaults
387
388 if (Environment.OSVersion.Platform == PlatformID.Unix)
389 {
390 avPIDD = 3200.0f;
391 avPIDP = 1400.0f;
392 avStandupTensor = 2000000f;
393 }
394 else
395 {
396 avPIDD = 2200.0f;
397 avPIDP = 900.0f;
398 avStandupTensor = 550000f;
399 }
400
401 int contactsPerCollision = 80;
402
403 if (m_config != null)
404 {
405 IConfig physicsconfig = m_config.Configs["ODEPhysicsSettings"];
406 if (physicsconfig != null)
407 {
408 gravityx = physicsconfig.GetFloat("world_gravityx", 0f);
409 gravityy = physicsconfig.GetFloat("world_gravityy", 0f);
410 gravityz = physicsconfig.GetFloat("world_gravityz", -9.8f);
411
412 worldHashspaceLow = physicsconfig.GetInt("world_hashspace_size_low", -4);
413 worldHashspaceHigh = physicsconfig.GetInt("world_hashspace_size_high", 128);
414
415 metersInSpace = physicsconfig.GetFloat("meters_in_small_space", 29.9f);
416 smallHashspaceLow = physicsconfig.GetInt("small_hashspace_size_low", -4);
417 smallHashspaceHigh = physicsconfig.GetInt("small_hashspace_size_high", 66);
418
419 contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", 0.001f);
420
421 nmTerrainContactFriction = physicsconfig.GetFloat("nm_terraincontact_friction", 255.0f);
422 nmTerrainContactBounce = physicsconfig.GetFloat("nm_terraincontact_bounce", 0.1f);
423 nmTerrainContactERP = physicsconfig.GetFloat("nm_terraincontact_erp", 0.1025f);
424
425 mTerrainContactFriction = physicsconfig.GetFloat("m_terraincontact_friction", 75f);
426 mTerrainContactBounce = physicsconfig.GetFloat("m_terraincontact_bounce", 0.05f);
427 mTerrainContactERP = physicsconfig.GetFloat("m_terraincontact_erp", 0.05025f);
428
429 nmAvatarObjectContactFriction = physicsconfig.GetFloat("objectcontact_friction", 250f);
430 nmAvatarObjectContactBounce = physicsconfig.GetFloat("objectcontact_bounce", 0.2f);
431
432 mAvatarObjectContactFriction = physicsconfig.GetFloat("m_avatarobjectcontact_friction", 75f);
433 mAvatarObjectContactBounce = physicsconfig.GetFloat("m_avatarobjectcontact_bounce", 0.1f);
434
435 ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", 0.020f);
436 m_physicsiterations = physicsconfig.GetInt("world_internal_steps_without_collisions", 10);
437
438 avDensity = physicsconfig.GetFloat("av_density", 80f);
439 avHeightFudgeFactor = physicsconfig.GetFloat("av_height_fudge_factor", 0.52f);
440 avMovementDivisorWalk = physicsconfig.GetFloat("av_movement_divisor_walk", 1.3f);
441 avMovementDivisorRun = physicsconfig.GetFloat("av_movement_divisor_run", 0.8f);
442 avCapRadius = physicsconfig.GetFloat("av_capsule_radius", 0.37f);
443 avCapsuleTilted = physicsconfig.GetBoolean("av_capsule_tilted", false);
444
445 contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", 80);
446
447 geomContactPointsStartthrottle = physicsconfig.GetInt("geom_contactpoints_start_throttling", 3);
448 geomUpdatesPerThrottledUpdate = physicsconfig.GetInt("geom_updates_before_throttled_update", 15);
449 geomCrossingFailuresBeforeOutofbounds = physicsconfig.GetInt("geom_crossing_failures_before_outofbounds", 5);
450
451 geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", 10.000006836f);
452 bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", 20);
453
454 bodyPIDD = physicsconfig.GetFloat("body_pid_derivative", 35f);
455 bodyPIDG = physicsconfig.GetFloat("body_pid_gain", 25f);
456
457 forceSimplePrimMeshing = physicsconfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
458 meshSculptedPrim = physicsconfig.GetBoolean("mesh_sculpted_prim", true);
459 meshSculptLOD = physicsconfig.GetFloat("mesh_lod", 32f);
460 MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", 16f);
461 m_filterCollisions = physicsconfig.GetBoolean("filter_collisions", false);
462
463 if (Environment.OSVersion.Platform == PlatformID.Unix)
464 {
465 avPIDD = physicsconfig.GetFloat("av_pid_derivative_linux", 2200.0f);
466 avPIDP = physicsconfig.GetFloat("av_pid_proportional_linux", 900.0f);
467 avStandupTensor = physicsconfig.GetFloat("av_capsule_standup_tensor_linux", 550000f);
468 bodyMotorJointMaxforceTensor = physicsconfig.GetFloat("body_motor_joint_maxforce_tensor_linux", 5f);
469 }
470 else
471 {
472 avPIDD = physicsconfig.GetFloat("av_pid_derivative_win", 2200.0f);
473 avPIDP = physicsconfig.GetFloat("av_pid_proportional_win", 900.0f);
474 avStandupTensor = physicsconfig.GetFloat("av_capsule_standup_tensor_win", 550000f);
475 bodyMotorJointMaxforceTensor = physicsconfig.GetFloat("body_motor_joint_maxforce_tensor_win", 5f);
476 }
477
478 physics_logging = physicsconfig.GetBoolean("physics_logging", false);
479 physics_logging_interval = physicsconfig.GetInt("physics_logging_interval", 0);
480 physics_logging_append_existing_logfile = physicsconfig.GetBoolean("physics_logging_append_existing_logfile", false);
481
482 m_NINJA_physics_joints_enabled = physicsconfig.GetBoolean("use_NINJA_physics_joints", false);
483 minimumGroundFlightOffset = physicsconfig.GetFloat("minimum_ground_flight_offset", 3f);
484 maximumMassObject = physicsconfig.GetFloat("maximum_mass_object", 10000.01f);
485 }
486 }
487
488 contacts = new d.ContactGeom[contactsPerCollision];
489
490 staticPrimspace = new IntPtr[(int)(300 / metersInSpace), (int)(300 / metersInSpace)];
491
492 // Centeral contact friction and bounce
493 // ckrinke 11/10/08 Enabling soft_erp but not soft_cfm until I figure out why
494 // an avatar falls through in Z but not in X or Y when walking on a prim.
495 contact.surface.mode |= d.ContactFlags.SoftERP;
496 contact.surface.mu = nmAvatarObjectContactFriction;
497 contact.surface.bounce = nmAvatarObjectContactBounce;
498 contact.surface.soft_cfm = 0.010f;
499 contact.surface.soft_erp = 0.010f;
500
501 // Terrain contact friction and Bounce
502 // This is the *non* moving version. Use this when an avatar
503 // isn't moving to keep it in place better
504 TerrainContact.surface.mode |= d.ContactFlags.SoftERP;
505 TerrainContact.surface.mu = nmTerrainContactFriction;
506 TerrainContact.surface.bounce = nmTerrainContactBounce;
507 TerrainContact.surface.soft_erp = nmTerrainContactERP;
508
509 WaterContact.surface.mode |= (d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM);
510 WaterContact.surface.mu = 0f; // No friction
511 WaterContact.surface.bounce = 0.0f; // No bounce
512 WaterContact.surface.soft_cfm = 0.010f;
513 WaterContact.surface.soft_erp = 0.010f;
514
515 // Prim contact friction and bounce
516 // THis is the *non* moving version of friction and bounce
517 // Use this when an avatar comes in contact with a prim
518 // and is moving
519 AvatarMovementprimContact.surface.mu = mAvatarObjectContactFriction;
520 AvatarMovementprimContact.surface.bounce = mAvatarObjectContactBounce;
521
522 // Terrain contact friction bounce and various error correcting calculations
523 // Use this when an avatar is in contact with the terrain and moving.
524 AvatarMovementTerrainContact.surface.mode |= d.ContactFlags.SoftERP;
525 AvatarMovementTerrainContact.surface.mu = mTerrainContactFriction;
526 AvatarMovementTerrainContact.surface.bounce = mTerrainContactBounce;
527 AvatarMovementTerrainContact.surface.soft_erp = mTerrainContactERP;
528
529
530 /*
531 <summary></summary>
532 Stone = 0,
533 /// <summary></summary>
534 Metal = 1,
535 /// <summary></summary>
536 Glass = 2,
537 /// <summary></summary>
538 Wood = 3,
539 /// <summary></summary>
540 Flesh = 4,
541 /// <summary></summary>
542 Plastic = 5,
543 /// <summary></summary>
544 Rubber = 6
545 */
546
547 m_materialContacts = new d.Contact[7,2];
548
549 m_materialContacts[(int)Material.Stone, 0] = new d.Contact();
550 m_materialContacts[(int)Material.Stone, 0].surface.mode |= d.ContactFlags.SoftERP;
551 m_materialContacts[(int)Material.Stone, 0].surface.mu = nmAvatarObjectContactFriction;
552 m_materialContacts[(int)Material.Stone, 0].surface.bounce = nmAvatarObjectContactBounce;
553 m_materialContacts[(int)Material.Stone, 0].surface.soft_cfm = 0.010f;
554 m_materialContacts[(int)Material.Stone, 0].surface.soft_erp = 0.010f;
555
556 m_materialContacts[(int)Material.Stone, 1] = new d.Contact();
557 m_materialContacts[(int)Material.Stone, 1].surface.mode |= d.ContactFlags.SoftERP;
558 m_materialContacts[(int)Material.Stone, 1].surface.mu = mAvatarObjectContactFriction;
559 m_materialContacts[(int)Material.Stone, 1].surface.bounce = mAvatarObjectContactBounce;
560 m_materialContacts[(int)Material.Stone, 1].surface.soft_cfm = 0.010f;
561 m_materialContacts[(int)Material.Stone, 1].surface.soft_erp = 0.010f;
562
563 m_materialContacts[(int)Material.Metal, 0] = new d.Contact();
564 m_materialContacts[(int)Material.Metal, 0].surface.mode |= d.ContactFlags.SoftERP;
565 m_materialContacts[(int)Material.Metal, 0].surface.mu = nmAvatarObjectContactFriction;
566 m_materialContacts[(int)Material.Metal, 0].surface.bounce = nmAvatarObjectContactBounce;
567 m_materialContacts[(int)Material.Metal, 0].surface.soft_cfm = 0.010f;
568 m_materialContacts[(int)Material.Metal, 0].surface.soft_erp = 0.010f;
569
570 m_materialContacts[(int)Material.Metal, 1] = new d.Contact();
571 m_materialContacts[(int)Material.Metal, 1].surface.mode |= d.ContactFlags.SoftERP;
572 m_materialContacts[(int)Material.Metal, 1].surface.mu = mAvatarObjectContactFriction;
573 m_materialContacts[(int)Material.Metal, 1].surface.bounce = mAvatarObjectContactBounce;
574 m_materialContacts[(int)Material.Metal, 1].surface.soft_cfm = 0.010f;
575 m_materialContacts[(int)Material.Metal, 1].surface.soft_erp = 0.010f;
576
577 m_materialContacts[(int)Material.Glass, 0] = new d.Contact();
578 m_materialContacts[(int)Material.Glass, 0].surface.mode |= d.ContactFlags.SoftERP;
579 m_materialContacts[(int)Material.Glass, 0].surface.mu = 1f;
580 m_materialContacts[(int)Material.Glass, 0].surface.bounce = 0.5f;
581 m_materialContacts[(int)Material.Glass, 0].surface.soft_cfm = 0.010f;
582 m_materialContacts[(int)Material.Glass, 0].surface.soft_erp = 0.010f;
583
584 /*
585 private float nmAvatarObjectContactFriction = 250f;
586 private float nmAvatarObjectContactBounce = 0.1f;
587
588 private float mAvatarObjectContactFriction = 75f;
589 private float mAvatarObjectContactBounce = 0.1f;
590 */
591 m_materialContacts[(int)Material.Glass, 1] = new d.Contact();
592 m_materialContacts[(int)Material.Glass, 1].surface.mode |= d.ContactFlags.SoftERP;
593 m_materialContacts[(int)Material.Glass, 1].surface.mu = 1f;
594 m_materialContacts[(int)Material.Glass, 1].surface.bounce = 0.5f;
595 m_materialContacts[(int)Material.Glass, 1].surface.soft_cfm = 0.010f;
596 m_materialContacts[(int)Material.Glass, 1].surface.soft_erp = 0.010f;
597
598 m_materialContacts[(int)Material.Wood, 0] = new d.Contact();
599 m_materialContacts[(int)Material.Wood, 0].surface.mode |= d.ContactFlags.SoftERP;
600 m_materialContacts[(int)Material.Wood, 0].surface.mu = nmAvatarObjectContactFriction;
601 m_materialContacts[(int)Material.Wood, 0].surface.bounce = nmAvatarObjectContactBounce;
602 m_materialContacts[(int)Material.Wood, 0].surface.soft_cfm = 0.010f;
603 m_materialContacts[(int)Material.Wood, 0].surface.soft_erp = 0.010f;
604
605 m_materialContacts[(int)Material.Wood, 1] = new d.Contact();
606 m_materialContacts[(int)Material.Wood, 1].surface.mode |= d.ContactFlags.SoftERP;
607 m_materialContacts[(int)Material.Wood, 1].surface.mu = mAvatarObjectContactFriction;
608 m_materialContacts[(int)Material.Wood, 1].surface.bounce = mAvatarObjectContactBounce;
609 m_materialContacts[(int)Material.Wood, 1].surface.soft_cfm = 0.010f;
610 m_materialContacts[(int)Material.Wood, 1].surface.soft_erp = 0.010f;
611
612 m_materialContacts[(int)Material.Flesh, 0] = new d.Contact();
613 m_materialContacts[(int)Material.Flesh, 0].surface.mode |= d.ContactFlags.SoftERP;
614 m_materialContacts[(int)Material.Flesh, 0].surface.mu = nmAvatarObjectContactFriction;
615 m_materialContacts[(int)Material.Flesh, 0].surface.bounce = nmAvatarObjectContactBounce;
616 m_materialContacts[(int)Material.Flesh, 0].surface.soft_cfm = 0.010f;
617 m_materialContacts[(int)Material.Flesh, 0].surface.soft_erp = 0.010f;
618
619 m_materialContacts[(int)Material.Flesh, 1] = new d.Contact();
620 m_materialContacts[(int)Material.Flesh, 1].surface.mode |= d.ContactFlags.SoftERP;
621 m_materialContacts[(int)Material.Flesh, 1].surface.mu = mAvatarObjectContactFriction;
622 m_materialContacts[(int)Material.Flesh, 1].surface.bounce = mAvatarObjectContactBounce;
623 m_materialContacts[(int)Material.Flesh, 1].surface.soft_cfm = 0.010f;
624 m_materialContacts[(int)Material.Flesh, 1].surface.soft_erp = 0.010f;
625
626 m_materialContacts[(int)Material.Plastic, 0] = new d.Contact();
627 m_materialContacts[(int)Material.Plastic, 0].surface.mode |= d.ContactFlags.SoftERP;
628 m_materialContacts[(int)Material.Plastic, 0].surface.mu = nmAvatarObjectContactFriction;
629 m_materialContacts[(int)Material.Plastic, 0].surface.bounce = nmAvatarObjectContactBounce;
630 m_materialContacts[(int)Material.Plastic, 0].surface.soft_cfm = 0.010f;
631 m_materialContacts[(int)Material.Plastic, 0].surface.soft_erp = 0.010f;
632
633 m_materialContacts[(int)Material.Plastic, 1] = new d.Contact();
634 m_materialContacts[(int)Material.Plastic, 1].surface.mode |= d.ContactFlags.SoftERP;
635 m_materialContacts[(int)Material.Plastic, 1].surface.mu = mAvatarObjectContactFriction;
636 m_materialContacts[(int)Material.Plastic, 1].surface.bounce = mAvatarObjectContactBounce;
637 m_materialContacts[(int)Material.Plastic, 1].surface.soft_cfm = 0.010f;
638 m_materialContacts[(int)Material.Plastic, 1].surface.soft_erp = 0.010f;
639
640 m_materialContacts[(int)Material.Rubber, 0] = new d.Contact();
641 m_materialContacts[(int)Material.Rubber, 0].surface.mode |= d.ContactFlags.SoftERP;
642 m_materialContacts[(int)Material.Rubber, 0].surface.mu = nmAvatarObjectContactFriction;
643 m_materialContacts[(int)Material.Rubber, 0].surface.bounce = nmAvatarObjectContactBounce;
644 m_materialContacts[(int)Material.Rubber, 0].surface.soft_cfm = 0.010f;
645 m_materialContacts[(int)Material.Rubber, 0].surface.soft_erp = 0.010f;
646
647 m_materialContacts[(int)Material.Rubber, 1] = new d.Contact();
648 m_materialContacts[(int)Material.Rubber, 1].surface.mode |= d.ContactFlags.SoftERP;
649 m_materialContacts[(int)Material.Rubber, 1].surface.mu = mAvatarObjectContactFriction;
650 m_materialContacts[(int)Material.Rubber, 1].surface.bounce = mAvatarObjectContactBounce;
651 m_materialContacts[(int)Material.Rubber, 1].surface.soft_cfm = 0.010f;
652 m_materialContacts[(int)Material.Rubber, 1].surface.soft_erp = 0.010f;
653
654 d.HashSpaceSetLevels(space, worldHashspaceLow, worldHashspaceHigh);
655
656 // Set the gravity,, don't disable things automatically (we set it explicitly on some things)
657
658 d.WorldSetGravity(world, gravityx, gravityy, gravityz);
659 d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
660
661 d.WorldSetLinearDamping(world, 256f);
662 d.WorldSetAngularDamping(world, 256f);
663 d.WorldSetAngularDampingThreshold(world, 256f);
664 d.WorldSetLinearDampingThreshold(world, 256f);
665 d.WorldSetMaxAngularSpeed(world, 256f);
666
667 // Set how many steps we go without running collision testing
668 // This is in addition to the step size.
669 // Essentially Steps * m_physicsiterations
670 d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
671 //d.WorldSetContactMaxCorrectingVel(world, 1000.0f);
672
673
674
675 for (int i = 0; i < staticPrimspace.GetLength(0); i++)
676 {
677 for (int j = 0; j < staticPrimspace.GetLength(1); j++)
678 {
679 staticPrimspace[i, j] = IntPtr.Zero;
680 }
681 }
682 }
683
684 internal void waitForSpaceUnlock(IntPtr space)
685 {
686 //if (space != IntPtr.Zero)
687 //while (d.SpaceLockQuery(space)) { } // Wait and do nothing
688 }
689
690 /// <summary>
691 /// Debug space message for printing the space that a prim/avatar is in.
692 /// </summary>
693 /// <param name="pos"></param>
694 /// <returns>Returns which split up space the given position is in.</returns>
695 public string whichspaceamIin(Vector3 pos)
696 {
697 return calculateSpaceForGeom(pos).ToString();
698 }
699
700 #region Collision Detection
701
702 /// <summary>
703 /// This is our near callback. A geometry is near a body
704 /// </summary>
705 /// <param name="space">The space that contains the geoms. Remember, spaces are also geoms</param>
706 /// <param name="g1">a geometry or space</param>
707 /// <param name="g2">another geometry or space</param>
708 private void near(IntPtr space, IntPtr g1, IntPtr g2)
709 {
710 // no lock here! It's invoked from within Simulate(), which is thread-locked
711
712 // Test if we're colliding a geom with a space.
713 // If so we have to drill down into the space recursively
714
715 if (d.GeomIsSpace(g1) || d.GeomIsSpace(g2))
716 {
717 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
718 return;
719
720 // Separating static prim geometry spaces.
721 // We'll be calling near recursivly if one
722 // of them is a space to find all of the
723 // contact points in the space
724 try
725 {
726 d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
727 }
728 catch (AccessViolationException)
729 {
730 m_log.Warn("[PHYSICS]: Unable to collide test a space");
731 return;
732 }
733 //Colliding a space or a geom with a space or a geom. so drill down
734
735 //Collide all geoms in each space..
736 //if (d.GeomIsSpace(g1)) d.SpaceCollide(g1, IntPtr.Zero, nearCallback);
737 //if (d.GeomIsSpace(g2)) d.SpaceCollide(g2, IntPtr.Zero, nearCallback);
738 return;
739 }
740
741 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
742 return;
743
744 IntPtr b1 = d.GeomGetBody(g1);
745 IntPtr b2 = d.GeomGetBody(g2);
746
747 // d.GeomClassID id = d.GeomGetClass(g1);
748
749 String name1 = null;
750 String name2 = null;
751
752 if (!geom_name_map.TryGetValue(g1, out name1))
753 {
754 name1 = "null";
755 }
756 if (!geom_name_map.TryGetValue(g2, out name2))
757 {
758 name2 = "null";
759 }
760
761 //if (id == d.GeomClassId.TriMeshClass)
762 //{
763 // m_log.InfoFormat("near: A collision was detected between {1} and {2}", 0, name1, name2);
764 //m_log.Debug("near: A collision was detected between {1} and {2}", 0, name1, name2);
765 //}
766
767 // Figure out how many contact points we have
768 int count = 0;
769 try
770 {
771 // Colliding Geom To Geom
772 // This portion of the function 'was' blatantly ripped off from BoxStack.cs
773
774 if (g1 == g2)
775 return; // Can't collide with yourself
776
777 if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
778 return;
779
780 lock (contacts)
781 {
782 count = d.Collide(g1, g2, contacts.Length, contacts, d.ContactGeom.SizeOf);
783 if (count > contacts.Length)
784 m_log.Error("[PHYSICS]: Got " + count + " contacts when we asked for a maximum of " + contacts.Length);
785 }
786 }
787 catch (SEHException)
788 {
789 m_log.Error("[PHYSICS]: The Operating system shut down ODE because of corrupt memory. This could be a result of really irregular terrain. If this repeats continuously, restart using Basic Physics and terrain fill your terrain. Restarting the sim.");
790 ode.drelease(world);
791 base.TriggerPhysicsBasedRestart();
792 }
793 catch (Exception e)
794 {
795 m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
796 return;
797 }
798
799 PhysicsActor p1;
800 PhysicsActor p2;
801
802 if (!actor_name_map.TryGetValue(g1, out p1))
803 {
804 p1 = PANull;
805 }
806
807 if (!actor_name_map.TryGetValue(g2, out p2))
808 {
809 p2 = PANull;
810 }
811
812 ContactPoint maxDepthContact = new ContactPoint();
813 if (p1.CollisionScore + count >= float.MaxValue)
814 p1.CollisionScore = 0;
815 p1.CollisionScore += count;
816
817 if (p2.CollisionScore + count >= float.MaxValue)
818 p2.CollisionScore = 0;
819 p2.CollisionScore += count;
820
821 for (int i = 0; i < count; i++)
822 {
823 d.ContactGeom curContact = contacts[i];
824
825 if (curContact.depth > maxDepthContact.PenetrationDepth)
826 {
827 maxDepthContact = new ContactPoint(
828 new Vector3(curContact.pos.X, curContact.pos.Y, curContact.pos.Z),
829 new Vector3(curContact.normal.X, curContact.normal.Y, curContact.normal.Z),
830 curContact.depth
831 );
832 }
833
834 //m_log.Warn("[CCOUNT]: " + count);
835 IntPtr joint;
836 // If we're colliding with terrain, use 'TerrainContact' instead of contact.
837 // allows us to have different settings
838
839 // We only need to test p2 for 'jump crouch purposes'
840 if (p2 is OdeCharacter && p1.PhysicsActorType == (int)ActorTypes.Prim)
841 {
842 // Testing if the collision is at the feet of the avatar
843
844 //m_log.DebugFormat("[PHYSICS]: {0} - {1} - {2} - {3}", curContact.pos.Z, p2.Position.Z, (p2.Position.Z - curContact.pos.Z), (p2.Size.Z * 0.6f));
845 if ((p2.Position.Z - curContact.pos.Z) > (p2.Size.Z * 0.6f))
846 p2.IsColliding = true;
847 }
848 else
849 {
850 p2.IsColliding = true;
851 }
852
853 //if ((framecount % m_returncollisions) == 0)
854
855 switch (p1.PhysicsActorType)
856 {
857 case (int)ActorTypes.Agent:
858 p2.CollidingObj = true;
859 break;
860 case (int)ActorTypes.Prim:
861 if (p2.Velocity.LengthSquared() > 0.0f)
862 p2.CollidingObj = true;
863 break;
864 case (int)ActorTypes.Unknown:
865 p2.CollidingGround = true;
866 break;
867 default:
868 p2.CollidingGround = true;
869 break;
870 }
871
872 // we don't want prim or avatar to explode
873
874 #region InterPenetration Handling - Unintended physics explosions
875# region disabled code1
876
877 if (curContact.depth >= 0.08f)
878 {
879 //This is disabled at the moment only because it needs more tweaking
880 //It will eventually be uncommented
881 /*
882 if (contact.depth >= 1.00f)
883 {
884 //m_log.Debug("[PHYSICS]: " + contact.depth.ToString());
885 }
886
887 //If you interpenetrate a prim with an agent
888 if ((p2.PhysicsActorType == (int) ActorTypes.Agent &&
889 p1.PhysicsActorType == (int) ActorTypes.Prim) ||
890 (p1.PhysicsActorType == (int) ActorTypes.Agent &&
891 p2.PhysicsActorType == (int) ActorTypes.Prim))
892 {
893
894 //contact.depth = contact.depth * 4.15f;
895 /*
896 if (p2.PhysicsActorType == (int) ActorTypes.Agent)
897 {
898 p2.CollidingObj = true;
899 contact.depth = 0.003f;
900 p2.Velocity = p2.Velocity + new PhysicsVector(0, 0, 2.5f);
901 OdeCharacter character = (OdeCharacter) p2;
902 character.SetPidStatus(true);
903 contact.pos = new d.Vector3(contact.pos.X + (p1.Size.X / 2), contact.pos.Y + (p1.Size.Y / 2), contact.pos.Z + (p1.Size.Z / 2));
904
905 }
906 else
907 {
908
909 //contact.depth = 0.0000000f;
910 }
911 if (p1.PhysicsActorType == (int) ActorTypes.Agent)
912 {
913
914 p1.CollidingObj = true;
915 contact.depth = 0.003f;
916 p1.Velocity = p1.Velocity + new PhysicsVector(0, 0, 2.5f);
917 contact.pos = new d.Vector3(contact.pos.X + (p2.Size.X / 2), contact.pos.Y + (p2.Size.Y / 2), contact.pos.Z + (p2.Size.Z / 2));
918 OdeCharacter character = (OdeCharacter)p1;
919 character.SetPidStatus(true);
920 }
921 else
922 {
923
924 //contact.depth = 0.0000000f;
925 }
926
927
928
929 }
930*/
931 // If you interpenetrate a prim with another prim
932 /*
933 if (p1.PhysicsActorType == (int) ActorTypes.Prim && p2.PhysicsActorType == (int) ActorTypes.Prim)
934 {
935 #region disabledcode2
936 //OdePrim op1 = (OdePrim)p1;
937 //OdePrim op2 = (OdePrim)p2;
938 //op1.m_collisionscore++;
939 //op2.m_collisionscore++;
940
941 //if (op1.m_collisionscore > 8000 || op2.m_collisionscore > 8000)
942 //{
943 //op1.m_taintdisable = true;
944 //AddPhysicsActorTaint(p1);
945 //op2.m_taintdisable = true;
946 //AddPhysicsActorTaint(p2);
947 //}
948
949 //if (contact.depth >= 0.25f)
950 //{
951 // Don't collide, one or both prim will expld.
952
953 //op1.m_interpenetrationcount++;
954 //op2.m_interpenetrationcount++;
955 //interpenetrations_before_disable = 200;
956 //if (op1.m_interpenetrationcount >= interpenetrations_before_disable)
957 //{
958 //op1.m_taintdisable = true;
959 //AddPhysicsActorTaint(p1);
960 //}
961 //if (op2.m_interpenetrationcount >= interpenetrations_before_disable)
962 //{
963 // op2.m_taintdisable = true;
964 //AddPhysicsActorTaint(p2);
965 //}
966
967 //contact.depth = contact.depth / 8f;
968 //contact.normal = new d.Vector3(0, 0, 1);
969 //}
970 //if (op1.m_disabled || op2.m_disabled)
971 //{
972 //Manually disabled objects stay disabled
973 //contact.depth = 0f;
974 //}
975 #endregion
976 }
977 */
978#endregion
979 if (curContact.depth >= 1.00f)
980 {
981 //m_log.Info("[P]: " + contact.depth.ToString());
982 if ((p2.PhysicsActorType == (int) ActorTypes.Agent &&
983 p1.PhysicsActorType == (int) ActorTypes.Unknown) ||
984 (p1.PhysicsActorType == (int) ActorTypes.Agent &&
985 p2.PhysicsActorType == (int) ActorTypes.Unknown))
986 {
987 if (p2.PhysicsActorType == (int) ActorTypes.Agent)
988 {
989 if (p2 is OdeCharacter)
990 {
991 OdeCharacter character = (OdeCharacter) p2;
992
993 //p2.CollidingObj = true;
994 curContact.depth = 0.00000003f;
995 p2.Velocity = p2.Velocity + new Vector3(0f, 0f, 0.5f);
996 curContact.pos =
997 new d.Vector3(curContact.pos.X + (p1.Size.X/2),
998 curContact.pos.Y + (p1.Size.Y/2),
999 curContact.pos.Z + (p1.Size.Z/2));
1000 character.SetPidStatus(true);
1001 }
1002 }
1003
1004
1005 if (p1.PhysicsActorType == (int) ActorTypes.Agent)
1006 {
1007 if (p1 is OdeCharacter)
1008 {
1009 OdeCharacter character = (OdeCharacter) p1;
1010
1011 //p2.CollidingObj = true;
1012 curContact.depth = 0.00000003f;
1013 p1.Velocity = p1.Velocity + new Vector3(0f, 0f, 0.5f);
1014 curContact.pos =
1015 new d.Vector3(curContact.pos.X + (p1.Size.X/2),
1016 curContact.pos.Y + (p1.Size.Y/2),
1017 curContact.pos.Z + (p1.Size.Z/2));
1018 character.SetPidStatus(true);
1019 }
1020 }
1021 }
1022 }
1023 }
1024
1025 #endregion
1026
1027 // Logic for collision handling
1028 // Note, that if *all* contacts are skipped (VolumeDetect)
1029 // The prim still detects (and forwards) collision events but
1030 // appears to be phantom for the world
1031 Boolean skipThisContact = false;
1032
1033 if ((p1 is OdePrim) && (((OdePrim)p1).m_isVolumeDetect))
1034 skipThisContact = true; // No collision on volume detect prims
1035
1036 if (!skipThisContact && (p2 is OdePrim) && (((OdePrim)p2).m_isVolumeDetect))
1037 skipThisContact = true; // No collision on volume detect prims
1038
1039 if (!skipThisContact && curContact.depth < 0f)
1040 skipThisContact = true;
1041
1042 if (!skipThisContact && checkDupe(curContact, p2.PhysicsActorType))
1043 skipThisContact = true;
1044
1045 const int maxContactsbeforedeath = 4000;
1046 joint = IntPtr.Zero;
1047
1048 if (!skipThisContact)
1049 {
1050 // If we're colliding against terrain
1051 if (name1 == "Terrain" || name2 == "Terrain")
1052 {
1053 // If we're moving
1054 if ((p2.PhysicsActorType == (int) ActorTypes.Agent) &&
1055 (Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f))
1056 {
1057 // Use the movement terrain contact
1058 AvatarMovementTerrainContact.geom = curContact;
1059 _perloopContact.Add(curContact);
1060 if (m_global_contactcount < maxContactsbeforedeath)
1061 {
1062 joint = d.JointCreateContact(world, contactgroup, ref AvatarMovementTerrainContact);
1063 m_global_contactcount++;
1064 }
1065 }
1066 else
1067 {
1068 if (p2.PhysicsActorType == (int)ActorTypes.Agent)
1069 {
1070 // Use the non moving terrain contact
1071 TerrainContact.geom = curContact;
1072 _perloopContact.Add(curContact);
1073 if (m_global_contactcount < maxContactsbeforedeath)
1074 {
1075 joint = d.JointCreateContact(world, contactgroup, ref TerrainContact);
1076 m_global_contactcount++;
1077 }
1078 }
1079 else
1080 {
1081 if (p2.PhysicsActorType == (int)ActorTypes.Prim && p1.PhysicsActorType == (int)ActorTypes.Prim)
1082 {
1083 // prim prim contact
1084 // int pj294950 = 0;
1085 int movintYN = 0;
1086 int material = (int) Material.Wood;
1087 // prim terrain contact
1088 if (Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f)
1089 {
1090 movintYN = 1;
1091 }
1092
1093 if (p2 is OdePrim)
1094 material = ((OdePrim)p2).m_material;
1095
1096 //m_log.DebugFormat("Material: {0}", material);
1097 m_materialContacts[material, movintYN].geom = curContact;
1098 _perloopContact.Add(curContact);
1099
1100 if (m_global_contactcount < maxContactsbeforedeath)
1101 {
1102 joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, movintYN]);
1103 m_global_contactcount++;
1104
1105 }
1106
1107 }
1108 else
1109 {
1110
1111 int movintYN = 0;
1112 // prim terrain contact
1113 if (Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f)
1114 {
1115 movintYN = 1;
1116 }
1117
1118 int material = (int)Material.Wood;
1119
1120 if (p2 is OdePrim)
1121 material = ((OdePrim)p2).m_material;
1122 //m_log.DebugFormat("Material: {0}", material);
1123 m_materialContacts[material, movintYN].geom = curContact;
1124 _perloopContact.Add(curContact);
1125
1126 if (m_global_contactcount < maxContactsbeforedeath)
1127 {
1128 joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, movintYN]);
1129 m_global_contactcount++;
1130
1131 }
1132 }
1133 }
1134 }
1135 //if (p2.PhysicsActorType == (int)ActorTypes.Prim)
1136 //{
1137 //m_log.Debug("[PHYSICS]: prim contacting with ground");
1138 //}
1139 }
1140 else if (name1 == "Water" || name2 == "Water")
1141 {
1142 /*
1143 if ((p2.PhysicsActorType == (int) ActorTypes.Prim))
1144 {
1145 }
1146 else
1147 {
1148 }
1149 */
1150 //WaterContact.surface.soft_cfm = 0.0000f;
1151 //WaterContact.surface.soft_erp = 0.00000f;
1152 if (curContact.depth > 0.1f)
1153 {
1154 curContact.depth *= 52;
1155 //contact.normal = new d.Vector3(0, 0, 1);
1156 //contact.pos = new d.Vector3(0, 0, contact.pos.Z - 5f);
1157 }
1158 WaterContact.geom = curContact;
1159 _perloopContact.Add(curContact);
1160 if (m_global_contactcount < maxContactsbeforedeath)
1161 {
1162 joint = d.JointCreateContact(world, contactgroup, ref WaterContact);
1163 m_global_contactcount++;
1164 }
1165 //m_log.Info("[PHYSICS]: Prim Water Contact" + contact.depth);
1166 }
1167 else
1168 {
1169 // we're colliding with prim or avatar
1170 // check if we're moving
1171 if ((p2.PhysicsActorType == (int)ActorTypes.Agent))
1172 {
1173 if ((Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f))
1174 {
1175 // Use the Movement prim contact
1176 AvatarMovementprimContact.geom = curContact;
1177 _perloopContact.Add(curContact);
1178 if (m_global_contactcount < maxContactsbeforedeath)
1179 {
1180 joint = d.JointCreateContact(world, contactgroup, ref AvatarMovementprimContact);
1181 m_global_contactcount++;
1182 }
1183 }
1184 else
1185 {
1186 // Use the non movement contact
1187 contact.geom = curContact;
1188 _perloopContact.Add(curContact);
1189
1190 if (m_global_contactcount < maxContactsbeforedeath)
1191 {
1192 joint = d.JointCreateContact(world, contactgroup, ref contact);
1193 m_global_contactcount++;
1194 }
1195 }
1196 }
1197 else if (p2.PhysicsActorType == (int)ActorTypes.Prim)
1198 {
1199 //p1.PhysicsActorType
1200 int material = (int)Material.Wood;
1201
1202 if (p2 is OdePrim)
1203 material = ((OdePrim)p2).m_material;
1204
1205 //m_log.DebugFormat("Material: {0}", material);
1206 m_materialContacts[material, 0].geom = curContact;
1207 _perloopContact.Add(curContact);
1208
1209 if (m_global_contactcount < maxContactsbeforedeath)
1210 {
1211 joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, 0]);
1212 m_global_contactcount++;
1213
1214 }
1215 }
1216 }
1217
1218 if (m_global_contactcount < maxContactsbeforedeath && joint != IntPtr.Zero) // stack collide!
1219 {
1220 d.JointAttach(joint, b1, b2);
1221 m_global_contactcount++;
1222 }
1223
1224 }
1225 collision_accounting_events(p1, p2, maxDepthContact);
1226 if (count > geomContactPointsStartthrottle)
1227 {
1228 // If there are more then 3 contact points, it's likely
1229 // that we've got a pile of objects, so ...
1230 // We don't want to send out hundreds of terse updates over and over again
1231 // so lets throttle them and send them again after it's somewhat sorted out.
1232 p2.ThrottleUpdates = true;
1233 }
1234 //m_log.Debug(count.ToString());
1235 //m_log.Debug("near: A collision was detected between {1} and {2}", 0, name1, name2);
1236 }
1237 }
1238
1239 private bool checkDupe(d.ContactGeom contactGeom, int atype)
1240 {
1241 bool result = false;
1242 //return result;
1243 if (!m_filterCollisions)
1244 return false;
1245
1246 ActorTypes at = (ActorTypes)atype;
1247 lock (_perloopContact)
1248 {
1249 foreach (d.ContactGeom contact in _perloopContact)
1250 {
1251 //if ((contact.g1 == contactGeom.g1 && contact.g2 == contactGeom.g2))
1252 //{
1253 // || (contact.g2 == contactGeom.g1 && contact.g1 == contactGeom.g2)
1254 if (at == ActorTypes.Agent)
1255 {
1256 if (((Math.Abs(contactGeom.normal.X - contact.normal.X) < 1.026f) && (Math.Abs(contactGeom.normal.Y - contact.normal.Y) < 0.303f) && (Math.Abs(contactGeom.normal.Z - contact.normal.Z) < 0.065f)) && contactGeom.g1 != LandGeom && contactGeom.g2 != LandGeom)
1257 {
1258
1259 if (Math.Abs(contact.depth - contactGeom.depth) < 0.052f)
1260 {
1261 //contactGeom.depth *= .00005f;
1262 //m_log.DebugFormat("[Collsion]: Depth {0}", Math.Abs(contact.depth - contactGeom.depth));
1263 // m_log.DebugFormat("[Collision]: <{0},{1},{2}>", Math.Abs(contactGeom.normal.X - contact.normal.X), Math.Abs(contactGeom.normal.Y - contact.normal.Y), Math.Abs(contactGeom.normal.Z - contact.normal.Z));
1264 result = true;
1265 break;
1266 }
1267 else
1268 {
1269 //m_log.DebugFormat("[Collsion]: Depth {0}", Math.Abs(contact.depth - contactGeom.depth));
1270 }
1271 }
1272 else
1273 {
1274 //m_log.DebugFormat("[Collision]: <{0},{1},{2}>", Math.Abs(contactGeom.normal.X - contact.normal.X), Math.Abs(contactGeom.normal.Y - contact.normal.Y), Math.Abs(contactGeom.normal.Z - contact.normal.Z));
1275 //int i = 0;
1276 }
1277 }
1278 else if (at == ActorTypes.Prim)
1279 {
1280 //d.AABB aabb1 = new d.AABB();
1281 //d.AABB aabb2 = new d.AABB();
1282
1283 //d.GeomGetAABB(contactGeom.g2, out aabb2);
1284 //d.GeomGetAABB(contactGeom.g1, out aabb1);
1285 //aabb1.
1286 if (((Math.Abs(contactGeom.normal.X - contact.normal.X) < 1.026f) && (Math.Abs(contactGeom.normal.Y - contact.normal.Y) < 0.303f) && (Math.Abs(contactGeom.normal.Z - contact.normal.Z) < 0.065f)) && contactGeom.g1 != LandGeom && contactGeom.g2 != LandGeom)
1287 {
1288 if (contactGeom.normal.X == contact.normal.X && contactGeom.normal.Y == contact.normal.Y && contactGeom.normal.Z == contact.normal.Z)
1289 {
1290 if (Math.Abs(contact.depth - contactGeom.depth) < 0.272f)
1291 {
1292 result = true;
1293 break;
1294 }
1295 }
1296 //m_log.DebugFormat("[Collsion]: Depth {0}", Math.Abs(contact.depth - contactGeom.depth));
1297 //m_log.DebugFormat("[Collision]: <{0},{1},{2}>", Math.Abs(contactGeom.normal.X - contact.normal.X), Math.Abs(contactGeom.normal.Y - contact.normal.Y), Math.Abs(contactGeom.normal.Z - contact.normal.Z));
1298 }
1299
1300 }
1301
1302 //}
1303
1304 }
1305 }
1306 return result;
1307 }
1308
1309 private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
1310 {
1311 // obj1LocalID = 0;
1312 //returncollisions = false;
1313 obj2LocalID = 0;
1314 //ctype = 0;
1315 //cStartStop = 0;
1316 if (!p2.SubscribedEvents() && !p1.SubscribedEvents())
1317 return;
1318
1319 switch ((ActorTypes)p2.PhysicsActorType)
1320 {
1321 case ActorTypes.Agent:
1322 cc2 = (OdeCharacter)p2;
1323
1324 // obj1LocalID = cc2.m_localID;
1325 switch ((ActorTypes)p1.PhysicsActorType)
1326 {
1327 case ActorTypes.Agent:
1328 cc1 = (OdeCharacter)p1;
1329 obj2LocalID = cc1.m_localID;
1330 cc1.AddCollisionEvent(cc2.m_localID, contact);
1331 //ctype = (int)CollisionCategories.Character;
1332
1333 //if (cc1.CollidingObj)
1334 //cStartStop = (int)StatusIndicators.Generic;
1335 //else
1336 //cStartStop = (int)StatusIndicators.Start;
1337
1338 //returncollisions = true;
1339 break;
1340 case ActorTypes.Prim:
1341 if (p1 is OdePrim)
1342 {
1343 cp1 = (OdePrim) p1;
1344 obj2LocalID = cp1.m_localID;
1345 cp1.AddCollisionEvent(cc2.m_localID, contact);
1346 }
1347 //ctype = (int)CollisionCategories.Geom;
1348
1349 //if (cp1.CollidingObj)
1350 //cStartStop = (int)StatusIndicators.Generic;
1351 //else
1352 //cStartStop = (int)StatusIndicators.Start;
1353
1354 //returncollisions = true;
1355 break;
1356
1357 case ActorTypes.Ground:
1358 case ActorTypes.Unknown:
1359 obj2LocalID = 0;
1360 //ctype = (int)CollisionCategories.Land;
1361 //returncollisions = true;
1362 break;
1363 }
1364
1365 cc2.AddCollisionEvent(obj2LocalID, contact);
1366 break;
1367 case ActorTypes.Prim:
1368
1369 if (p2 is OdePrim)
1370 {
1371 cp2 = (OdePrim) p2;
1372
1373 // obj1LocalID = cp2.m_localID;
1374 switch ((ActorTypes) p1.PhysicsActorType)
1375 {
1376 case ActorTypes.Agent:
1377 if (p1 is OdeCharacter)
1378 {
1379 cc1 = (OdeCharacter) p1;
1380 obj2LocalID = cc1.m_localID;
1381 cc1.AddCollisionEvent(cp2.m_localID, contact);
1382 //ctype = (int)CollisionCategories.Character;
1383
1384 //if (cc1.CollidingObj)
1385 //cStartStop = (int)StatusIndicators.Generic;
1386 //else
1387 //cStartStop = (int)StatusIndicators.Start;
1388 //returncollisions = true;
1389 }
1390 break;
1391 case ActorTypes.Prim:
1392
1393 if (p1 is OdePrim)
1394 {
1395 cp1 = (OdePrim) p1;
1396 obj2LocalID = cp1.m_localID;
1397 cp1.AddCollisionEvent(cp2.m_localID, contact);
1398 //ctype = (int)CollisionCategories.Geom;
1399
1400 //if (cp1.CollidingObj)
1401 //cStartStop = (int)StatusIndicators.Generic;
1402 //else
1403 //cStartStop = (int)StatusIndicators.Start;
1404
1405 //returncollisions = true;
1406 }
1407 break;
1408
1409 case ActorTypes.Ground:
1410 case ActorTypes.Unknown:
1411 obj2LocalID = 0;
1412 //ctype = (int)CollisionCategories.Land;
1413
1414 //returncollisions = true;
1415 break;
1416 }
1417
1418 cp2.AddCollisionEvent(obj2LocalID, contact);
1419 }
1420 break;
1421 }
1422 //if (returncollisions)
1423 //{
1424
1425 //lock (m_storedCollisions)
1426 //{
1427 //cDictKey = obj1LocalID.ToString() + obj2LocalID.ToString() + cStartStop.ToString() + ctype.ToString();
1428 //if (m_storedCollisions.ContainsKey(cDictKey))
1429 //{
1430 //sCollisionData objd = m_storedCollisions[cDictKey];
1431 //objd.NumberOfCollisions += 1;
1432 //objd.lastframe = framecount;
1433 //m_storedCollisions[cDictKey] = objd;
1434 //}
1435 //else
1436 //{
1437 //sCollisionData objd = new sCollisionData();
1438 //objd.ColliderLocalId = obj1LocalID;
1439 //objd.CollidedWithLocalId = obj2LocalID;
1440 //objd.CollisionType = ctype;
1441 //objd.NumberOfCollisions = 1;
1442 //objd.lastframe = framecount;
1443 //objd.StatusIndicator = cStartStop;
1444 //m_storedCollisions.Add(cDictKey, objd);
1445 //}
1446 //}
1447 // }
1448 }
1449
1450 public int TriArrayCallback(IntPtr trimesh, IntPtr refObject, int[] triangleIndex, int triCount)
1451 {
1452 /* String name1 = null;
1453 String name2 = null;
1454
1455 if (!geom_name_map.TryGetValue(trimesh, out name1))
1456 {
1457 name1 = "null";
1458 }
1459 if (!geom_name_map.TryGetValue(refObject, out name2))
1460 {
1461 name2 = "null";
1462 }
1463
1464 m_log.InfoFormat("TriArrayCallback: A collision was detected between {1} and {2}", 0, name1, name2);
1465 */
1466 return 1;
1467 }
1468
1469 public int TriCallback(IntPtr trimesh, IntPtr refObject, int triangleIndex)
1470 {
1471 String name1 = null;
1472 String name2 = null;
1473
1474 if (!geom_name_map.TryGetValue(trimesh, out name1))
1475 {
1476 name1 = "null";
1477 }
1478
1479 if (!geom_name_map.TryGetValue(refObject, out name2))
1480 {
1481 name2 = "null";
1482 }
1483
1484 // m_log.InfoFormat("TriCallback: A collision was detected between {1} and {2}. Index was {3}", 0, name1, name2, triangleIndex);
1485
1486 d.Vector3 v0 = new d.Vector3();
1487 d.Vector3 v1 = new d.Vector3();
1488 d.Vector3 v2 = new d.Vector3();
1489
1490 d.GeomTriMeshGetTriangle(trimesh, 0, ref v0, ref v1, ref v2);
1491 // m_log.DebugFormat("Triangle {0} is <{1},{2},{3}>, <{4},{5},{6}>, <{7},{8},{9}>", triangleIndex, v0.X, v0.Y, v0.Z, v1.X, v1.Y, v1.Z, v2.X, v2.Y, v2.Z);
1492
1493 return 1;
1494 }
1495
1496 /// <summary>
1497 /// This is our collision testing routine in ODE
1498 /// </summary>
1499 /// <param name="timeStep"></param>
1500 private void collision_optimized(float timeStep)
1501 {
1502 _perloopContact.Clear();
1503
1504 lock (_characters)
1505 {
1506 foreach (OdeCharacter chr in _characters)
1507 {
1508 // Reset the collision values to false
1509 // since we don't know if we're colliding yet
1510
1511 // For some reason this can happen. Don't ask...
1512 //
1513 if (chr == null)
1514 continue;
1515
1516 if (chr.Shell == IntPtr.Zero || chr.Body == IntPtr.Zero)
1517 continue;
1518
1519 chr.IsColliding = false;
1520 chr.CollidingGround = false;
1521 chr.CollidingObj = false;
1522
1523 // test the avatar's geometry for collision with the space
1524 // This will return near and the space that they are the closest to
1525 // And we'll run this again against the avatar and the space segment
1526 // This will return with a bunch of possible objects in the space segment
1527 // and we'll run it again on all of them.
1528 try
1529 {
1530 d.SpaceCollide2(space, chr.Shell, IntPtr.Zero, nearCallback);
1531 }
1532 catch (AccessViolationException)
1533 {
1534 m_log.Warn("[PHYSICS]: Unable to space collide");
1535 }
1536 //float terrainheight = GetTerrainHeightAtXY(chr.Position.X, chr.Position.Y);
1537 //if (chr.Position.Z + (chr.Velocity.Z * timeStep) < terrainheight + 10)
1538 //{
1539 //chr.Position.Z = terrainheight + 10.0f;
1540 //forcedZ = true;
1541 //}
1542 }
1543 }
1544
1545 lock (_activeprims)
1546 {
1547 List<OdePrim> removeprims = null;
1548 foreach (OdePrim chr in _activeprims)
1549 {
1550 if (chr.Body != IntPtr.Zero && d.BodyIsEnabled(chr.Body) && (!chr.m_disabled))
1551 {
1552 try
1553 {
1554 lock (chr)
1555 {
1556 if (space != IntPtr.Zero && chr.prim_geom != IntPtr.Zero && chr.m_taintremove == false)
1557 {
1558 d.SpaceCollide2(space, chr.prim_geom, IntPtr.Zero, nearCallback);
1559 }
1560 else
1561 {
1562 if (removeprims == null)
1563 {
1564 removeprims = new List<OdePrim>();
1565 }
1566 removeprims.Add(chr);
1567 m_log.Debug("[PHYSICS]: unable to collide test active prim against space. The space was zero, the geom was zero or it was in the process of being removed. Removed it from the active prim list. This needs to be fixed!");
1568 }
1569 }
1570 }
1571 catch (AccessViolationException)
1572 {
1573 m_log.Warn("[PHYSICS]: Unable to space collide");
1574 }
1575 }
1576 }
1577 if (removeprims != null)
1578 {
1579 foreach (OdePrim chr in removeprims)
1580 {
1581 _activeprims.Remove(chr);
1582 }
1583 }
1584 }
1585
1586 _perloopContact.Clear();
1587 }
1588
1589 #endregion
1590
1591 public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
1592 {
1593 m_worldOffset = offset;
1594 WorldExtents = new Vector2(extents.X, extents.Y);
1595 m_parentScene = pScene;
1596
1597 }
1598
1599 // Recovered for use by fly height. Kitto Flora
1600 public float GetTerrainHeightAtXY(float x, float y)
1601 {
1602
1603 int offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
1604 int offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
1605
1606 IntPtr heightFieldGeom = IntPtr.Zero;
1607
1608 if (RegionTerrain.TryGetValue(new Vector3(offsetX,offsetY,0), out heightFieldGeom))
1609 {
1610 if (heightFieldGeom != IntPtr.Zero)
1611 {
1612 if (TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
1613 {
1614
1615 int index;
1616
1617
1618 if ((int)x > WorldExtents.X || (int)y > WorldExtents.Y ||
1619 (int)x < 0.001f || (int)y < 0.001f)
1620 return 0;
1621
1622 x = x - offsetX;
1623 y = y - offsetY;
1624
1625 index = (int)((int)x * ((int)Constants.RegionSize + 2) + (int)y);
1626
1627 if (index < TerrainHeightFieldHeights[heightFieldGeom].Length)
1628 {
1629 //m_log.DebugFormat("x{0} y{1} = {2}", x, y, (float)TerrainHeightFieldHeights[heightFieldGeom][index]);
1630 return (float)TerrainHeightFieldHeights[heightFieldGeom][index];
1631 }
1632
1633 else
1634 return 0f;
1635 }
1636 else
1637 {
1638 return 0f;
1639 }
1640
1641 }
1642 else
1643 {
1644 return 0f;
1645 }
1646
1647 }
1648 else
1649 {
1650 return 0f;
1651 }
1652
1653
1654 }
1655// End recovered. Kitto Flora
1656
1657 public void addCollisionEventReporting(PhysicsActor obj)
1658 {
1659 lock (_collisionEventPrim)
1660 {
1661 if (!_collisionEventPrim.Contains(obj))
1662 _collisionEventPrim.Add(obj);
1663 }
1664 }
1665
1666 public void remCollisionEventReporting(PhysicsActor obj)
1667 {
1668 lock (_collisionEventPrim)
1669 {
1670 if (!_collisionEventPrim.Contains(obj))
1671 _collisionEventPrim.Remove(obj);
1672 }
1673 }
1674
1675 #region Add/Remove Entities
1676
1677 public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
1678 {
1679 Vector3 pos;
1680 pos.X = position.X;
1681 pos.Y = position.Y;
1682 pos.Z = position.Z;
1683 OdeCharacter newAv = new OdeCharacter(avName, this, pos, ode, size, avPIDD, avPIDP, avCapRadius, avStandupTensor, avDensity, avHeightFudgeFactor, avMovementDivisorWalk, avMovementDivisorRun);
1684 newAv.Flying = isFlying;
1685 newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
1686
1687 return newAv;
1688 }
1689
1690 public void AddCharacter(OdeCharacter chr)
1691 {
1692 lock (_characters)
1693 {
1694 if (!_characters.Contains(chr))
1695 {
1696 _characters.Add(chr);
1697 if (chr.bad)
1698 m_log.DebugFormat("[PHYSICS] Added BAD actor {0} to characters list", chr.m_uuid);
1699 }
1700 }
1701 }
1702
1703 public void RemoveCharacter(OdeCharacter chr)
1704 {
1705 lock (_characters)
1706 {
1707 if (_characters.Contains(chr))
1708 {
1709 _characters.Remove(chr);
1710 }
1711 }
1712 }
1713 public void BadCharacter(OdeCharacter chr)
1714 {
1715 lock (_badCharacter)
1716 {
1717 if (!_badCharacter.Contains(chr))
1718 _badCharacter.Add(chr);
1719 }
1720 }
1721
1722 public override void RemoveAvatar(PhysicsActor actor)
1723 {
1724 //m_log.Debug("[PHYSICS]:ODELOCK");
1725 ((OdeCharacter) actor).Destroy();
1726
1727 }
1728
1729 private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
1730 IMesh mesh, PrimitiveBaseShape pbs, bool isphysical)
1731 {
1732
1733 Vector3 pos = position;
1734 Vector3 siz = size;
1735 Quaternion rot = rotation;
1736
1737 OdePrim newPrim;
1738 lock (OdeLock)
1739 {
1740 newPrim = new OdePrim(name, this, pos, siz, rot, mesh, pbs, isphysical, ode);
1741
1742 lock (_prims)
1743 _prims.Add(newPrim);
1744 }
1745
1746 return newPrim;
1747 }
1748
1749 public void addActivePrim(OdePrim activatePrim)
1750 {
1751 // adds active prim.. (ones that should be iterated over in collisions_optimized
1752 lock (_activeprims)
1753 {
1754 if (!_activeprims.Contains(activatePrim))
1755 _activeprims.Add(activatePrim);
1756 //else
1757 // m_log.Warn("[PHYSICS]: Double Entry in _activeprims detected, potential crash immenent");
1758 }
1759 }
1760
1761 public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
1762 Vector3 size, Quaternion rotation) //To be removed
1763 {
1764 return AddPrimShape(primName, pbs, position, size, rotation, false);
1765 }
1766
1767 public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
1768 Vector3 size, Quaternion rotation, bool isPhysical)
1769 {
1770 PhysicsActor result;
1771 IMesh mesh = null;
1772
1773 if (needsMeshing(pbs))
1774 mesh = mesher.CreateMesh(primName, pbs, size, 32f, isPhysical);
1775
1776 result = AddPrim(primName, position, size, rotation, mesh, pbs, isPhysical);
1777
1778 return result;
1779 }
1780
1781 public override float TimeDilation
1782 {
1783 get { return m_timeDilation; }
1784 }
1785
1786 public override bool SupportsNINJAJoints
1787 {
1788 get { return m_NINJA_physics_joints_enabled; }
1789 }
1790
1791 // internal utility function: must be called within a lock (OdeLock)
1792 private void InternalAddActiveJoint(PhysicsJoint joint)
1793 {
1794 activeJoints.Add(joint);
1795 SOPName_to_activeJoint.Add(joint.ObjectNameInScene, joint);
1796 }
1797
1798 // internal utility function: must be called within a lock (OdeLock)
1799 private void InternalAddPendingJoint(OdePhysicsJoint joint)
1800 {
1801 pendingJoints.Add(joint);
1802 SOPName_to_pendingJoint.Add(joint.ObjectNameInScene, joint);
1803 }
1804
1805 // internal utility function: must be called within a lock (OdeLock)
1806 private void InternalRemovePendingJoint(PhysicsJoint joint)
1807 {
1808 pendingJoints.Remove(joint);
1809 SOPName_to_pendingJoint.Remove(joint.ObjectNameInScene);
1810 }
1811
1812 // internal utility function: must be called within a lock (OdeLock)
1813 private void InternalRemoveActiveJoint(PhysicsJoint joint)
1814 {
1815 activeJoints.Remove(joint);
1816 SOPName_to_activeJoint.Remove(joint.ObjectNameInScene);
1817 }
1818
1819 public override void DumpJointInfo()
1820 {
1821 string hdr = "[NINJA] JOINTINFO: ";
1822 foreach (PhysicsJoint j in pendingJoints)
1823 {
1824 m_log.Debug(hdr + " pending joint, Name: " + j.ObjectNameInScene + " raw parms:" + j.RawParams);
1825 }
1826 m_log.Debug(hdr + pendingJoints.Count + " total pending joints");
1827 foreach (string jointName in SOPName_to_pendingJoint.Keys)
1828 {
1829 m_log.Debug(hdr + " pending joints dict contains Name: " + jointName);
1830 }
1831 m_log.Debug(hdr + SOPName_to_pendingJoint.Keys.Count + " total pending joints dict entries");
1832 foreach (PhysicsJoint j in activeJoints)
1833 {
1834 m_log.Debug(hdr + " active joint, Name: " + j.ObjectNameInScene + " raw parms:" + j.RawParams);
1835 }
1836 m_log.Debug(hdr + activeJoints.Count + " total active joints");
1837 foreach (string jointName in SOPName_to_activeJoint.Keys)
1838 {
1839 m_log.Debug(hdr + " active joints dict contains Name: " + jointName);
1840 }
1841 m_log.Debug(hdr + SOPName_to_activeJoint.Keys.Count + " total active joints dict entries");
1842
1843 m_log.Debug(hdr + " Per-body joint connectivity information follows.");
1844 m_log.Debug(hdr + joints_connecting_actor.Keys.Count + " bodies are connected by joints.");
1845 foreach (string actorName in joints_connecting_actor.Keys)
1846 {
1847 m_log.Debug(hdr + " Actor " + actorName + " has the following joints connecting it");
1848 foreach (PhysicsJoint j in joints_connecting_actor[actorName])
1849 {
1850 m_log.Debug(hdr + " * joint Name: " + j.ObjectNameInScene + " raw parms:" + j.RawParams);
1851 }
1852 m_log.Debug(hdr + joints_connecting_actor[actorName].Count + " connecting joints total for this actor");
1853 }
1854 }
1855
1856 public override void RequestJointDeletion(string ObjectNameInScene)
1857 {
1858 lock (externalJointRequestsLock)
1859 {
1860 if (!requestedJointsToBeDeleted.Contains(ObjectNameInScene)) // forbid same deletion request from entering twice to prevent spurious deletions processed asynchronously
1861 {
1862 requestedJointsToBeDeleted.Add(ObjectNameInScene);
1863 }
1864 }
1865 }
1866
1867 private void DeleteRequestedJoints()
1868 {
1869 List<string> myRequestedJointsToBeDeleted;
1870 lock (externalJointRequestsLock)
1871 {
1872 // make a local copy of the shared list for processing (threading issues)
1873 myRequestedJointsToBeDeleted = new List<string>(requestedJointsToBeDeleted);
1874 }
1875
1876 foreach (string jointName in myRequestedJointsToBeDeleted)
1877 {
1878 lock (OdeLock)
1879 {
1880 //m_log.Debug("[NINJA] trying to deleting requested joint " + jointName);
1881 if (SOPName_to_activeJoint.ContainsKey(jointName) || SOPName_to_pendingJoint.ContainsKey(jointName))
1882 {
1883 OdePhysicsJoint joint = null;
1884 if (SOPName_to_activeJoint.ContainsKey(jointName))
1885 {
1886 joint = SOPName_to_activeJoint[jointName] as OdePhysicsJoint;
1887 InternalRemoveActiveJoint(joint);
1888 }
1889 else if (SOPName_to_pendingJoint.ContainsKey(jointName))
1890 {
1891 joint = SOPName_to_pendingJoint[jointName] as OdePhysicsJoint;
1892 InternalRemovePendingJoint(joint);
1893 }
1894
1895 if (joint != null)
1896 {
1897 //m_log.Debug("joint.BodyNames.Count is " + joint.BodyNames.Count + " and contents " + joint.BodyNames);
1898 for (int iBodyName = 0; iBodyName < 2; iBodyName++)
1899 {
1900 string bodyName = joint.BodyNames[iBodyName];
1901 if (bodyName != "NULL")
1902 {
1903 joints_connecting_actor[bodyName].Remove(joint);
1904 if (joints_connecting_actor[bodyName].Count == 0)
1905 {
1906 joints_connecting_actor.Remove(bodyName);
1907 }
1908 }
1909 }
1910
1911 DoJointDeactivated(joint);
1912 if (joint.jointID != IntPtr.Zero)
1913 {
1914 d.JointDestroy(joint.jointID);
1915 joint.jointID = IntPtr.Zero;
1916 //DoJointErrorMessage(joint, "successfully destroyed joint " + jointName);
1917 }
1918 else
1919 {
1920 //m_log.Warn("[NINJA] Ignoring re-request to destroy joint " + jointName);
1921 }
1922 }
1923 else
1924 {
1925 // DoJointErrorMessage(joint, "coult not find joint to destroy based on name " + jointName);
1926 }
1927 }
1928 else
1929 {
1930 // DoJointErrorMessage(joint, "WARNING - joint removal failed, joint " + jointName);
1931 }
1932 }
1933 }
1934
1935 // remove processed joints from the shared list
1936 lock (externalJointRequestsLock)
1937 {
1938 foreach (string jointName in myRequestedJointsToBeDeleted)
1939 {
1940 requestedJointsToBeDeleted.Remove(jointName);
1941 }
1942 }
1943 }
1944
1945 // for pending joints we don't know if their associated bodies exist yet or not.
1946 // the joint is actually created during processing of the taints
1947 private void CreateRequestedJoints()
1948 {
1949 List<PhysicsJoint> myRequestedJointsToBeCreated;
1950 lock (externalJointRequestsLock)
1951 {
1952 // make a local copy of the shared list for processing (threading issues)
1953 myRequestedJointsToBeCreated = new List<PhysicsJoint>(requestedJointsToBeCreated);
1954 }
1955
1956 foreach (PhysicsJoint joint in myRequestedJointsToBeCreated)
1957 {
1958 lock (OdeLock)
1959 {
1960 if (SOPName_to_pendingJoint.ContainsKey(joint.ObjectNameInScene) && SOPName_to_pendingJoint[joint.ObjectNameInScene] != null)
1961 {
1962 DoJointErrorMessage(joint, "WARNING: ignoring request to re-add already pending joint Name:" + joint.ObjectNameInScene + " type:" + joint.Type + " parms: " + joint.RawParams + " pos: " + joint.Position + " rot:" + joint.Rotation);
1963 continue;
1964 }
1965 if (SOPName_to_activeJoint.ContainsKey(joint.ObjectNameInScene) && SOPName_to_activeJoint[joint.ObjectNameInScene] != null)
1966 {
1967 DoJointErrorMessage(joint, "WARNING: ignoring request to re-add already active joint Name:" + joint.ObjectNameInScene + " type:" + joint.Type + " parms: " + joint.RawParams + " pos: " + joint.Position + " rot:" + joint.Rotation);
1968 continue;
1969 }
1970
1971 InternalAddPendingJoint(joint as OdePhysicsJoint);
1972
1973 if (joint.BodyNames.Count >= 2)
1974 {
1975 for (int iBodyName = 0; iBodyName < 2; iBodyName++)
1976 {
1977 string bodyName = joint.BodyNames[iBodyName];
1978 if (bodyName != "NULL")
1979 {
1980 if (!joints_connecting_actor.ContainsKey(bodyName))
1981 {
1982 joints_connecting_actor.Add(bodyName, new List<PhysicsJoint>());
1983 }
1984 joints_connecting_actor[bodyName].Add(joint);
1985 }
1986 }
1987 }
1988 }
1989 }
1990
1991 // remove processed joints from shared list
1992 lock (externalJointRequestsLock)
1993 {
1994 foreach (PhysicsJoint joint in myRequestedJointsToBeCreated)
1995 {
1996 requestedJointsToBeCreated.Remove(joint);
1997 }
1998 }
1999
2000 }
2001
2002 // public function to add an request for joint creation
2003 // this joint will just be added to a waiting list that is NOT processed during the main
2004 // Simulate() loop (to avoid deadlocks). After Simulate() is finished, we handle unprocessed joint requests.
2005
2006 public override PhysicsJoint RequestJointCreation(string objectNameInScene, PhysicsJointType jointType, Vector3 position,
2007 Quaternion rotation, string parms, List<string> bodyNames, string trackedBodyName, Quaternion localRotation)
2008
2009 {
2010
2011 OdePhysicsJoint joint = new OdePhysicsJoint();
2012 joint.ObjectNameInScene = objectNameInScene;
2013 joint.Type = jointType;
2014 joint.Position = position;
2015 joint.Rotation = rotation;
2016 joint.RawParams = parms;
2017 joint.BodyNames = new List<string>(bodyNames);
2018 joint.TrackedBodyName = trackedBodyName;
2019 joint.LocalRotation = localRotation;
2020 joint.jointID = IntPtr.Zero;
2021 joint.ErrorMessageCount = 0;
2022
2023 lock (externalJointRequestsLock)
2024 {
2025 if (!requestedJointsToBeCreated.Contains(joint)) // forbid same creation request from entering twice
2026 {
2027 requestedJointsToBeCreated.Add(joint);
2028 }
2029 }
2030 return joint;
2031 }
2032
2033 private void RemoveAllJointsConnectedToActor(PhysicsActor actor)
2034 {
2035 //m_log.Debug("RemoveAllJointsConnectedToActor: start");
2036 if (actor.SOPName != null && joints_connecting_actor.ContainsKey(actor.SOPName) && joints_connecting_actor[actor.SOPName] != null)
2037 {
2038
2039 List<PhysicsJoint> jointsToRemove = new List<PhysicsJoint>();
2040 //TODO: merge these 2 loops (originally it was needed to avoid altering a list being iterated over, but it is no longer needed due to the joint request queue mechanism)
2041 foreach (PhysicsJoint j in joints_connecting_actor[actor.SOPName])
2042 {
2043 jointsToRemove.Add(j);
2044 }
2045 foreach (PhysicsJoint j in jointsToRemove)
2046 {
2047 //m_log.Debug("RemoveAllJointsConnectedToActor: about to request deletion of " + j.ObjectNameInScene);
2048 RequestJointDeletion(j.ObjectNameInScene);
2049 //m_log.Debug("RemoveAllJointsConnectedToActor: done request deletion of " + j.ObjectNameInScene);
2050 j.TrackedBodyName = null; // *IMMEDIATELY* prevent any further movement of this joint (else a deleted actor might cause spurious tracking motion of the joint for a few frames, leading to the joint proxy object disappearing)
2051 }
2052 }
2053 }
2054
2055 public override void RemoveAllJointsConnectedToActorThreadLocked(PhysicsActor actor)
2056 {
2057 //m_log.Debug("RemoveAllJointsConnectedToActorThreadLocked: start");
2058 lock (OdeLock)
2059 {
2060 //m_log.Debug("RemoveAllJointsConnectedToActorThreadLocked: got lock");
2061 RemoveAllJointsConnectedToActor(actor);
2062 }
2063 }
2064
2065 // normally called from within OnJointMoved, which is called from within a lock (OdeLock)
2066 public override Vector3 GetJointAnchor(PhysicsJoint joint)
2067 {
2068 Debug.Assert(joint.IsInPhysicsEngine);
2069 d.Vector3 pos = new d.Vector3();
2070
2071 if (!(joint is OdePhysicsJoint))
2072 {
2073 DoJointErrorMessage(joint, "warning: non-ODE joint requesting anchor: " + joint.ObjectNameInScene);
2074 }
2075 else
2076 {
2077 OdePhysicsJoint odeJoint = (OdePhysicsJoint)joint;
2078 switch (odeJoint.Type)
2079 {
2080 case PhysicsJointType.Ball:
2081 d.JointGetBallAnchor(odeJoint.jointID, out pos);
2082 break;
2083 case PhysicsJointType.Hinge:
2084 d.JointGetHingeAnchor(odeJoint.jointID, out pos);
2085 break;
2086 }
2087 }
2088 return new Vector3(pos.X, pos.Y, pos.Z);
2089 }
2090
2091 // normally called from within OnJointMoved, which is called from within a lock (OdeLock)
2092 // WARNING: ODE sometimes returns <0,0,0> as the joint axis! Therefore this function
2093 // appears to be unreliable. Fortunately we can compute the joint axis ourselves by
2094 // keeping track of the joint's original orientation relative to one of the involved bodies.
2095 public override Vector3 GetJointAxis(PhysicsJoint joint)
2096 {
2097 Debug.Assert(joint.IsInPhysicsEngine);
2098 d.Vector3 axis = new d.Vector3();
2099
2100 if (!(joint is OdePhysicsJoint))
2101 {
2102 DoJointErrorMessage(joint, "warning: non-ODE joint requesting anchor: " + joint.ObjectNameInScene);
2103 }
2104 else
2105 {
2106 OdePhysicsJoint odeJoint = (OdePhysicsJoint)joint;
2107 switch (odeJoint.Type)
2108 {
2109 case PhysicsJointType.Ball:
2110 DoJointErrorMessage(joint, "warning - axis requested for ball joint: " + joint.ObjectNameInScene);
2111 break;
2112 case PhysicsJointType.Hinge:
2113 d.JointGetHingeAxis(odeJoint.jointID, out axis);
2114 break;
2115 }
2116 }
2117 return new Vector3(axis.X, axis.Y, axis.Z);
2118 }
2119
2120
2121 public void remActivePrim(OdePrim deactivatePrim)
2122 {
2123 lock (_activeprims)
2124 {
2125 _activeprims.Remove(deactivatePrim);
2126 }
2127 }
2128
2129 public override void RemovePrim(PhysicsActor prim)
2130 {
2131 if (prim is OdePrim)
2132 {
2133 lock (OdeLock)
2134 {
2135 OdePrim p = (OdePrim) prim;
2136
2137 p.setPrimForRemoval();
2138 AddPhysicsActorTaint(prim);
2139 //RemovePrimThreadLocked(p);
2140 }
2141 }
2142 }
2143
2144 /// <summary>
2145 /// This is called from within simulate but outside the locked portion
2146 /// We need to do our own locking here
2147 /// Essentially, we need to remove the prim from our space segment, whatever segment it's in.
2148 ///
2149 /// If there are no more prim in the segment, we need to empty (spacedestroy)the segment and reclaim memory
2150 /// that the space was using.
2151 /// </summary>
2152 /// <param name="prim"></param>
2153 public void RemovePrimThreadLocked(OdePrim prim)
2154 {
2155//Console.WriteLine("RemovePrimThreadLocked " + prim.m_primName);
2156 lock (prim)
2157 {
2158 remCollisionEventReporting(prim);
2159 lock (ode)
2160 {
2161 if (prim.prim_geom != IntPtr.Zero)
2162 {
2163 prim.ResetTaints();
2164
2165 if (prim.IsPhysical)
2166 {
2167 prim.disableBody();
2168 if (prim.childPrim)
2169 {
2170 prim.childPrim = false;
2171 prim.Body = IntPtr.Zero;
2172 prim.m_disabled = true;
2173 prim.IsPhysical = false;
2174 }
2175
2176
2177 }
2178 // we don't want to remove the main space
2179
2180 // If the geometry is in the targetspace, remove it from the target space
2181 //m_log.Warn(prim.m_targetSpace);
2182
2183 //if (prim.m_targetSpace != IntPtr.Zero)
2184 //{
2185 //if (d.SpaceQuery(prim.m_targetSpace, prim.prim_geom))
2186 //{
2187
2188 //if (d.GeomIsSpace(prim.m_targetSpace))
2189 //{
2190 //waitForSpaceUnlock(prim.m_targetSpace);
2191 //d.SpaceRemove(prim.m_targetSpace, prim.prim_geom);
2192 prim.m_targetSpace = IntPtr.Zero;
2193 //}
2194 //else
2195 //{
2196 // m_log.Info("[Physics]: Invalid Scene passed to 'removeprim from scene':" +
2197 //((OdePrim)prim).m_targetSpace.ToString());
2198 //}
2199
2200 //}
2201 //}
2202 //m_log.Warn(prim.prim_geom);
2203 try
2204 {
2205 if (prim.prim_geom != IntPtr.Zero)
2206 {
2207 d.GeomDestroy(prim.prim_geom);
2208 prim.prim_geom = IntPtr.Zero;
2209 }
2210 else
2211 {
2212 m_log.Warn("[PHYSICS]: Unable to remove prim from physics scene");
2213 }
2214 }
2215 catch (AccessViolationException)
2216 {
2217 m_log.Info("[PHYSICS]: Couldn't remove prim from physics scene, it was already be removed.");
2218 }
2219 lock (_prims)
2220 _prims.Remove(prim);
2221
2222 //If there are no more geometries in the sub-space, we don't need it in the main space anymore
2223 //if (d.SpaceGetNumGeoms(prim.m_targetSpace) == 0)
2224 //{
2225 //if (prim.m_targetSpace != null)
2226 //{
2227 //if (d.GeomIsSpace(prim.m_targetSpace))
2228 //{
2229 //waitForSpaceUnlock(prim.m_targetSpace);
2230 //d.SpaceRemove(space, prim.m_targetSpace);
2231 // free up memory used by the space.
2232 //d.SpaceDestroy(prim.m_targetSpace);
2233 //int[] xyspace = calculateSpaceArrayItemFromPos(prim.Position);
2234 //resetSpaceArrayItemToZero(xyspace[0], xyspace[1]);
2235 //}
2236 //else
2237 //{
2238 //m_log.Info("[Physics]: Invalid Scene passed to 'removeprim from scene':" +
2239 //((OdePrim) prim).m_targetSpace.ToString());
2240 //}
2241 //}
2242 //}
2243
2244 if (SupportsNINJAJoints)
2245 {
2246 RemoveAllJointsConnectedToActorThreadLocked(prim);
2247 }
2248 }
2249 }
2250 }
2251 }
2252
2253 #endregion
2254
2255 #region Space Separation Calculation
2256
2257 /// <summary>
2258 /// Takes a space pointer and zeros out the array we're using to hold the spaces
2259 /// </summary>
2260 /// <param name="pSpace"></param>
2261 public void resetSpaceArrayItemToZero(IntPtr pSpace)
2262 {
2263 for (int x = 0; x < staticPrimspace.GetLength(0); x++)
2264 {
2265 for (int y = 0; y < staticPrimspace.GetLength(1); y++)
2266 {
2267 if (staticPrimspace[x, y] == pSpace)
2268 staticPrimspace[x, y] = IntPtr.Zero;
2269 }
2270 }
2271 }
2272
2273 public void resetSpaceArrayItemToZero(int arrayitemX, int arrayitemY)
2274 {
2275 staticPrimspace[arrayitemX, arrayitemY] = IntPtr.Zero;
2276 }
2277
2278 /// <summary>
2279 /// Called when a static prim moves. Allocates a space for the prim based on its position
2280 /// </summary>
2281 /// <param name="geom">the pointer to the geom that moved</param>
2282 /// <param name="pos">the position that the geom moved to</param>
2283 /// <param name="currentspace">a pointer to the space it was in before it was moved.</param>
2284 /// <returns>a pointer to the new space it's in</returns>
2285 public IntPtr recalculateSpaceForGeom(IntPtr geom, Vector3 pos, IntPtr currentspace)
2286 {
2287 // Called from setting the Position and Size of an ODEPrim so
2288 // it's already in locked space.
2289
2290 // we don't want to remove the main space
2291 // we don't need to test physical here because this function should
2292 // never be called if the prim is physical(active)
2293
2294 // All physical prim end up in the root space
2295 //Thread.Sleep(20);
2296 if (currentspace != space)
2297 {
2298 //m_log.Info("[SPACE]: C:" + currentspace.ToString() + " g:" + geom.ToString());
2299 //if (currentspace == IntPtr.Zero)
2300 //{
2301 //int adfadf = 0;
2302 //}
2303 if (d.SpaceQuery(currentspace, geom) && currentspace != IntPtr.Zero)
2304 {
2305 if (d.GeomIsSpace(currentspace))
2306 {
2307 waitForSpaceUnlock(currentspace);
2308 d.SpaceRemove(currentspace, geom);
2309 }
2310 else
2311 {
2312 m_log.Info("[Physics]: Invalid Scene passed to 'recalculatespace':" + currentspace +
2313 " Geom:" + geom);
2314 }
2315 }
2316 else
2317 {
2318 IntPtr sGeomIsIn = d.GeomGetSpace(geom);
2319 if (sGeomIsIn != IntPtr.Zero)
2320 {
2321 if (d.GeomIsSpace(currentspace))
2322 {
2323 waitForSpaceUnlock(sGeomIsIn);
2324 d.SpaceRemove(sGeomIsIn, geom);
2325 }
2326 else
2327 {
2328 m_log.Info("[Physics]: Invalid Scene passed to 'recalculatespace':" +
2329 sGeomIsIn + " Geom:" + geom);
2330 }
2331 }
2332 }
2333
2334 //If there are no more geometries in the sub-space, we don't need it in the main space anymore
2335 if (d.SpaceGetNumGeoms(currentspace) == 0)
2336 {
2337 if (currentspace != IntPtr.Zero)
2338 {
2339 if (d.GeomIsSpace(currentspace))
2340 {
2341 waitForSpaceUnlock(currentspace);
2342 waitForSpaceUnlock(space);
2343 d.SpaceRemove(space, currentspace);
2344 // free up memory used by the space.
2345
2346 //d.SpaceDestroy(currentspace);
2347 resetSpaceArrayItemToZero(currentspace);
2348 }
2349 else
2350 {
2351 m_log.Info("[Physics]: Invalid Scene passed to 'recalculatespace':" +
2352 currentspace + " Geom:" + geom);
2353 }
2354 }
2355 }
2356 }
2357 else
2358 {
2359 // this is a physical object that got disabled. ;.;
2360 if (currentspace != IntPtr.Zero && geom != IntPtr.Zero)
2361 {
2362 if (d.SpaceQuery(currentspace, geom))
2363 {
2364 if (d.GeomIsSpace(currentspace))
2365 {
2366 waitForSpaceUnlock(currentspace);
2367 d.SpaceRemove(currentspace, geom);
2368 }
2369 else
2370 {
2371 m_log.Info("[Physics]: Invalid Scene passed to 'recalculatespace':" +
2372 currentspace + " Geom:" + geom);
2373 }
2374 }
2375 else
2376 {
2377 IntPtr sGeomIsIn = d.GeomGetSpace(geom);
2378 if (sGeomIsIn != IntPtr.Zero)
2379 {
2380 if (d.GeomIsSpace(sGeomIsIn))
2381 {
2382 waitForSpaceUnlock(sGeomIsIn);
2383 d.SpaceRemove(sGeomIsIn, geom);
2384 }
2385 else
2386 {
2387 m_log.Info("[Physics]: Invalid Scene passed to 'recalculatespace':" +
2388 sGeomIsIn + " Geom:" + geom);
2389 }
2390 }
2391 }
2392 }
2393 }
2394
2395 // The routines in the Position and Size sections do the 'inserting' into the space,
2396 // so all we have to do is make sure that the space that we're putting the prim into
2397 // is in the 'main' space.
2398 int[] iprimspaceArrItem = calculateSpaceArrayItemFromPos(pos);
2399 IntPtr newspace = calculateSpaceForGeom(pos);
2400
2401 if (newspace == IntPtr.Zero)
2402 {
2403 newspace = createprimspace(iprimspaceArrItem[0], iprimspaceArrItem[1]);
2404 d.HashSpaceSetLevels(newspace, smallHashspaceLow, smallHashspaceHigh);
2405 }
2406
2407 return newspace;
2408 }
2409
2410 /// <summary>
2411 /// Creates a new space at X Y
2412 /// </summary>
2413 /// <param name="iprimspaceArrItemX"></param>
2414 /// <param name="iprimspaceArrItemY"></param>
2415 /// <returns>A pointer to the created space</returns>
2416 public IntPtr createprimspace(int iprimspaceArrItemX, int iprimspaceArrItemY)
2417 {
2418 // creating a new space for prim and inserting it into main space.
2419 staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY] = d.HashSpaceCreate(IntPtr.Zero);
2420 d.GeomSetCategoryBits(staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY], (int)CollisionCategories.Space);
2421 waitForSpaceUnlock(space);
2422 d.SpaceSetSublevel(space, 1);
2423 d.SpaceAdd(space, staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY]);
2424 return staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY];
2425 }
2426
2427 /// <summary>
2428 /// Calculates the space the prim should be in by its position
2429 /// </summary>
2430 /// <param name="pos"></param>
2431 /// <returns>a pointer to the space. This could be a new space or reused space.</returns>
2432 public IntPtr calculateSpaceForGeom(Vector3 pos)
2433 {
2434 int[] xyspace = calculateSpaceArrayItemFromPos(pos);
2435 //m_log.Info("[Physics]: Attempting to use arrayItem: " + xyspace[0].ToString() + "," + xyspace[1].ToString());
2436 return staticPrimspace[xyspace[0], xyspace[1]];
2437 }
2438
2439 /// <summary>
2440 /// Holds the space allocation logic
2441 /// </summary>
2442 /// <param name="pos"></param>
2443 /// <returns>an array item based on the position</returns>
2444 public int[] calculateSpaceArrayItemFromPos(Vector3 pos)
2445 {
2446 int[] returnint = new int[2];
2447
2448 returnint[0] = (int) (pos.X/metersInSpace);
2449
2450 if (returnint[0] > ((int) (259f/metersInSpace)))
2451 returnint[0] = ((int) (259f/metersInSpace));
2452 if (returnint[0] < 0)
2453 returnint[0] = 0;
2454
2455 returnint[1] = (int) (pos.Y/metersInSpace);
2456 if (returnint[1] > ((int) (259f/metersInSpace)))
2457 returnint[1] = ((int) (259f/metersInSpace));
2458 if (returnint[1] < 0)
2459 returnint[1] = 0;
2460
2461 return returnint;
2462 }
2463
2464 #endregion
2465
2466 /// <summary>
2467 /// Routine to figure out if we need to mesh this prim with our mesher
2468 /// </summary>
2469 /// <param name="pbs"></param>
2470 /// <returns></returns>
2471 public bool needsMeshing(PrimitiveBaseShape pbs)
2472 {
2473 // most of this is redundant now as the mesher will return null if it cant mesh a prim
2474 // but we still need to check for sculptie meshing being enabled so this is the most
2475 // convenient place to do it for now...
2476
2477 // //if (pbs.PathCurve == (byte)Primitive.PathCurve.Circle && pbs.ProfileCurve == (byte)Primitive.ProfileCurve.Circle && pbs.PathScaleY <= 0.75f)
2478 // //m_log.Debug("needsMeshing: " + " pathCurve: " + pbs.PathCurve.ToString() + " profileCurve: " + pbs.ProfileCurve.ToString() + " pathScaleY: " + Primitive.UnpackPathScale(pbs.PathScaleY).ToString());
2479 int iPropertiesNotSupportedDefault = 0;
2480
2481 if (pbs.SculptEntry && !meshSculptedPrim)
2482 {
2483#if SPAM
2484 m_log.Warn("NonMesh");
2485#endif
2486 return false;
2487 }
2488
2489 // 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
2490 if (!forceSimplePrimMeshing)
2491 {
2492 if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
2493 || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
2494 && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
2495 {
2496
2497 if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
2498 && pbs.ProfileHollow == 0
2499 && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
2500 && pbs.PathBegin == 0 && pbs.PathEnd == 0
2501 && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
2502 && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
2503 && pbs.PathShearX == 0 && pbs.PathShearY == 0)
2504 {
2505#if SPAM
2506 m_log.Warn("NonMesh");
2507#endif
2508 return false;
2509 }
2510 }
2511 }
2512
2513 if (pbs.ProfileHollow != 0)
2514 iPropertiesNotSupportedDefault++;
2515
2516 if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
2517 iPropertiesNotSupportedDefault++;
2518
2519 if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
2520 iPropertiesNotSupportedDefault++;
2521
2522 if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
2523 iPropertiesNotSupportedDefault++;
2524
2525 if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
2526 iPropertiesNotSupportedDefault++;
2527
2528 if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
2529 iPropertiesNotSupportedDefault++;
2530
2531 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))
2532 iPropertiesNotSupportedDefault++;
2533
2534 if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1)
2535 iPropertiesNotSupportedDefault++;
2536
2537 // test for torus
2538 if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
2539 {
2540 if (pbs.PathCurve == (byte)Extrusion.Curve1)
2541 {
2542 iPropertiesNotSupportedDefault++;
2543 }
2544 }
2545 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
2546 {
2547 if (pbs.PathCurve == (byte)Extrusion.Straight)
2548 {
2549 iPropertiesNotSupportedDefault++;
2550 }
2551
2552 // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
2553 else if (pbs.PathCurve == (byte)Extrusion.Curve1)
2554 {
2555 iPropertiesNotSupportedDefault++;
2556 }
2557 }
2558 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
2559 {
2560 if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
2561 {
2562 iPropertiesNotSupportedDefault++;
2563 }
2564 }
2565 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
2566 {
2567 if (pbs.PathCurve == (byte)Extrusion.Straight)
2568 {
2569 iPropertiesNotSupportedDefault++;
2570 }
2571 else if (pbs.PathCurve == (byte)Extrusion.Curve1)
2572 {
2573 iPropertiesNotSupportedDefault++;
2574 }
2575 }
2576
2577
2578 if (iPropertiesNotSupportedDefault == 0)
2579 {
2580#if SPAM
2581 m_log.Warn("NonMesh");
2582#endif
2583 return false;
2584 }
2585#if SPAM
2586 m_log.Debug("Mesh");
2587#endif
2588 return true;
2589 }
2590
2591 /// <summary>
2592 /// Called after our prim properties are set Scale, position etc.
2593 /// We use this event queue like method to keep changes to the physical scene occuring in the threadlocked mutex
2594 /// This assures us that we have no race conditions
2595 /// </summary>
2596 /// <param name="prim"></param>
2597 public override void AddPhysicsActorTaint(PhysicsActor prim)
2598 {
2599
2600 if (prim is OdePrim)
2601 {
2602 OdePrim taintedprim = ((OdePrim) prim);
2603 lock (_taintedPrimLock)
2604 {
2605 if (!(_taintedPrimH.Contains(taintedprim)))
2606 {
2607//Console.WriteLine("AddPhysicsActorTaint to " + taintedprim.m_primName);
2608 _taintedPrimH.Add(taintedprim); // HashSet for searching
2609 _taintedPrimL.Add(taintedprim); // List for ordered readout
2610 }
2611 }
2612 return;
2613 }
2614 else if (prim is OdeCharacter)
2615 {
2616 OdeCharacter taintedchar = ((OdeCharacter)prim);
2617 lock (_taintedActors)
2618 {
2619 if (!(_taintedActors.Contains(taintedchar)))
2620 {
2621 _taintedActors.Add(taintedchar);
2622 if (taintedchar.bad)
2623 m_log.DebugFormat("[PHYSICS]: Added BAD actor {0} to tainted actors", taintedchar.m_uuid);
2624 }
2625 }
2626 }
2627 }
2628
2629 /// <summary>
2630 /// This is our main simulate loop
2631 /// It's thread locked by a Mutex in the scene.
2632 /// It holds Collisions, it instructs ODE to step through the physical reactions
2633 /// It moves the objects around in memory
2634 /// It calls the methods that report back to the object owners.. (scenepresence, SceneObjectGroup)
2635 /// </summary>
2636 /// <param name="timeStep"></param>
2637 /// <returns></returns>
2638 public override float Simulate(float timeStep)
2639 {
2640 if (framecount >= int.MaxValue)
2641 framecount = 0;
2642
2643 //if (m_worldOffset != Vector3.Zero)
2644 // return 0;
2645
2646 framecount++;
2647
2648 float fps = 0;
2649 //m_log.Info(timeStep.ToString());
2650 step_time += timeStep;
2651
2652 // If We're loaded down by something else,
2653 // or debugging with the Visual Studio project on pause
2654 // skip a few frames to catch up gracefully.
2655 // without shooting the physicsactors all over the place
2656
2657 if (step_time >= m_SkipFramesAtms)
2658 {
2659 // Instead of trying to catch up, it'll do 5 physics frames only
2660 step_time = ODE_STEPSIZE;
2661 m_physicsiterations = 5;
2662 }
2663 else
2664 {
2665 m_physicsiterations = 10;
2666 }
2667
2668 if (SupportsNINJAJoints)
2669 {
2670 DeleteRequestedJoints(); // this must be outside of the lock (OdeLock) to avoid deadlocks
2671 CreateRequestedJoints(); // this must be outside of the lock (OdeLock) to avoid deadlocks
2672 }
2673
2674 lock (OdeLock)
2675 {
2676 // Process 10 frames if the sim is running normal..
2677 // process 5 frames if the sim is running slow
2678 //try
2679 //{
2680 //d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
2681 //}
2682 //catch (StackOverflowException)
2683 //{
2684 // m_log.Error("[PHYSICS]: The operating system wasn't able to allocate enough memory for the simulation. Restarting the sim.");
2685 // ode.drelease(world);
2686 //base.TriggerPhysicsBasedRestart();
2687 //}
2688
2689 int i = 0;
2690
2691 // Figure out the Frames Per Second we're going at.
2692 //(step_time == 0.004f, there's 250 of those per second. Times the step time/step size
2693
2694 fps = (step_time / ODE_STEPSIZE) * 1000;
2695 // HACK: Using a time dilation of 1.0 to debug rubberbanding issues
2696 //m_timeDilation = Math.Min((step_time / ODE_STEPSIZE) / (0.09375f / ODE_STEPSIZE), 1.0f);
2697
2698 step_time = 0.09375f;
2699
2700 while (step_time > 0.0f)
2701 {
2702 //lock (ode)
2703 //{
2704 //if (!ode.lockquery())
2705 //{
2706 // ode.dlock(world);
2707 try
2708 {
2709 // Insert, remove Characters
2710 bool processedtaints = false;
2711
2712 lock (_taintedActors)
2713 {
2714 if (_taintedActors.Count > 0)
2715 {
2716 foreach (OdeCharacter character in _taintedActors)
2717 {
2718
2719 character.ProcessTaints(timeStep);
2720
2721 processedtaints = true;
2722 //character.m_collisionscore = 0;
2723 }
2724
2725 if (processedtaints)
2726 _taintedActors.Clear();
2727 }
2728 }
2729
2730 // Modify other objects in the scene.
2731 processedtaints = false;
2732
2733 lock (_taintedPrimLock)
2734 {
2735 foreach (OdePrim prim in _taintedPrimL)
2736 {
2737 if (prim.m_taintremove)
2738 {
2739 //Console.WriteLine("Simulate calls RemovePrimThreadLocked");
2740 RemovePrimThreadLocked(prim);
2741 }
2742 else
2743 {
2744 //Console.WriteLine("Simulate calls ProcessTaints");
2745 prim.ProcessTaints(timeStep);
2746 }
2747 processedtaints = true;
2748 prim.m_collisionscore = 0;
2749
2750 // This loop can block up the Heartbeat for a very long time on large regions.
2751 // We need to let the Watchdog know that the Heartbeat is not dead
2752 // NOTE: This is currently commented out, but if things like OAR loading are
2753 // timing the heartbeat out we will need to uncomment it
2754 //Watchdog.UpdateThread();
2755 }
2756
2757 if (SupportsNINJAJoints)
2758 {
2759 // Create pending joints, if possible
2760
2761 // joints can only be processed after ALL bodies are processed (and exist in ODE), since creating
2762 // a joint requires specifying the body id of both involved bodies
2763 if (pendingJoints.Count > 0)
2764 {
2765 List<PhysicsJoint> successfullyProcessedPendingJoints = new List<PhysicsJoint>();
2766 //DoJointErrorMessage(joints_connecting_actor, "taint: " + pendingJoints.Count + " pending joints");
2767 foreach (PhysicsJoint joint in pendingJoints)
2768 {
2769 //DoJointErrorMessage(joint, "taint: time to create joint with parms: " + joint.RawParams);
2770 string[] jointParams = joint.RawParams.Split(" ".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
2771 List<IntPtr> jointBodies = new List<IntPtr>();
2772 bool allJointBodiesAreReady = true;
2773 foreach (string jointParam in jointParams)
2774 {
2775 if (jointParam == "NULL")
2776 {
2777 //DoJointErrorMessage(joint, "attaching NULL joint to world");
2778 jointBodies.Add(IntPtr.Zero);
2779 }
2780 else
2781 {
2782 //DoJointErrorMessage(joint, "looking for prim name: " + jointParam);
2783 bool foundPrim = false;
2784 lock (_prims)
2785 {
2786 foreach (OdePrim prim in _prims) // FIXME: inefficient
2787 {
2788 if (prim.SOPName == jointParam)
2789 {
2790 //DoJointErrorMessage(joint, "found for prim name: " + jointParam);
2791 if (prim.IsPhysical && prim.Body != IntPtr.Zero)
2792 {
2793 jointBodies.Add(prim.Body);
2794 foundPrim = true;
2795 break;
2796 }
2797 else
2798 {
2799 DoJointErrorMessage(joint, "prim name " + jointParam +
2800 " exists but is not (yet) physical; deferring joint creation. " +
2801 "IsPhysical property is " + prim.IsPhysical +
2802 " and body is " + prim.Body);
2803 foundPrim = false;
2804 break;
2805 }
2806 }
2807 }
2808 }
2809 if (foundPrim)
2810 {
2811 // all is fine
2812 }
2813 else
2814 {
2815 allJointBodiesAreReady = false;
2816 break;
2817 }
2818 }
2819 }
2820 if (allJointBodiesAreReady)
2821 {
2822 //DoJointErrorMessage(joint, "allJointBodiesAreReady for " + joint.ObjectNameInScene + " with parms " + joint.RawParams);
2823 if (jointBodies[0] == jointBodies[1])
2824 {
2825 DoJointErrorMessage(joint, "ERROR: joint cannot be created; the joint bodies are the same, body1==body2. Raw body is " + jointBodies[0] + ". raw parms: " + joint.RawParams);
2826 }
2827 else
2828 {
2829 switch (joint.Type)
2830 {
2831 case PhysicsJointType.Ball:
2832 {
2833 IntPtr odeJoint;
2834 //DoJointErrorMessage(joint, "ODE creating ball joint ");
2835 odeJoint = d.JointCreateBall(world, IntPtr.Zero);
2836 //DoJointErrorMessage(joint, "ODE attaching ball joint: " + odeJoint + " with b1:" + jointBodies[0] + " b2:" + jointBodies[1]);
2837 d.JointAttach(odeJoint, jointBodies[0], jointBodies[1]);
2838 //DoJointErrorMessage(joint, "ODE setting ball anchor: " + odeJoint + " to vec:" + joint.Position);
2839 d.JointSetBallAnchor(odeJoint,
2840 joint.Position.X,
2841 joint.Position.Y,
2842 joint.Position.Z);
2843 //DoJointErrorMessage(joint, "ODE joint setting OK");
2844 //DoJointErrorMessage(joint, "The ball joint's bodies are here: b0: ");
2845 //DoJointErrorMessage(joint, "" + (jointBodies[0] != IntPtr.Zero ? "" + d.BodyGetPosition(jointBodies[0]) : "fixed environment"));
2846 //DoJointErrorMessage(joint, "The ball joint's bodies are here: b1: ");
2847 //DoJointErrorMessage(joint, "" + (jointBodies[1] != IntPtr.Zero ? "" + d.BodyGetPosition(jointBodies[1]) : "fixed environment"));
2848
2849 if (joint is OdePhysicsJoint)
2850 {
2851 ((OdePhysicsJoint)joint).jointID = odeJoint;
2852 }
2853 else
2854 {
2855 DoJointErrorMessage(joint, "WARNING: non-ode joint in ODE!");
2856 }
2857 }
2858 break;
2859 case PhysicsJointType.Hinge:
2860 {
2861 IntPtr odeJoint;
2862 //DoJointErrorMessage(joint, "ODE creating hinge joint ");
2863 odeJoint = d.JointCreateHinge(world, IntPtr.Zero);
2864 //DoJointErrorMessage(joint, "ODE attaching hinge joint: " + odeJoint + " with b1:" + jointBodies[0] + " b2:" + jointBodies[1]);
2865 d.JointAttach(odeJoint, jointBodies[0], jointBodies[1]);
2866 //DoJointErrorMessage(joint, "ODE setting hinge anchor: " + odeJoint + " to vec:" + joint.Position);
2867 d.JointSetHingeAnchor(odeJoint,
2868 joint.Position.X,
2869 joint.Position.Y,
2870 joint.Position.Z);
2871 // We use the orientation of the x-axis of the joint's coordinate frame
2872 // as the axis for the hinge.
2873
2874 // Therefore, we must get the joint's coordinate frame based on the
2875 // joint.Rotation field, which originates from the orientation of the
2876 // joint's proxy object in the scene.
2877
2878 // The joint's coordinate frame is defined as the transformation matrix
2879 // that converts a vector from joint-local coordinates into world coordinates.
2880 // World coordinates are defined as the XYZ coordinate system of the sim,
2881 // as shown in the top status-bar of the viewer.
2882
2883 // Once we have the joint's coordinate frame, we extract its X axis (AtAxis)
2884 // and use that as the hinge axis.
2885
2886 //joint.Rotation.Normalize();
2887 Matrix4 proxyFrame = Matrix4.CreateFromQuaternion(joint.Rotation);
2888
2889 // Now extract the X axis of the joint's coordinate frame.
2890
2891 // Do not try to use proxyFrame.AtAxis or you will become mired in the
2892 // tar pit of transposed, inverted, and generally messed-up orientations.
2893 // (In other words, Matrix4.AtAxis() is borked.)
2894 // Vector3 jointAxis = proxyFrame.AtAxis; <--- this path leadeth to madness
2895
2896 // Instead, compute the X axis of the coordinate frame by transforming
2897 // the (1,0,0) vector. At least that works.
2898
2899 //m_log.Debug("PHY: making axis: complete matrix is " + proxyFrame);
2900 Vector3 jointAxis = Vector3.Transform(Vector3.UnitX, proxyFrame);
2901 //m_log.Debug("PHY: making axis: hinge joint axis is " + jointAxis);
2902 //DoJointErrorMessage(joint, "ODE setting hinge axis: " + odeJoint + " to vec:" + jointAxis);
2903 d.JointSetHingeAxis(odeJoint,
2904 jointAxis.X,
2905 jointAxis.Y,
2906 jointAxis.Z);
2907 //d.JointSetHingeParam(odeJoint, (int)dParam.CFM, 0.1f);
2908 if (joint is OdePhysicsJoint)
2909 {
2910 ((OdePhysicsJoint)joint).jointID = odeJoint;
2911 }
2912 else
2913 {
2914 DoJointErrorMessage(joint, "WARNING: non-ode joint in ODE!");
2915 }
2916 }
2917 break;
2918 }
2919 successfullyProcessedPendingJoints.Add(joint);
2920 }
2921 }
2922 else
2923 {
2924 DoJointErrorMessage(joint, "joint could not yet be created; still pending");
2925 }
2926 }
2927 foreach (PhysicsJoint successfullyProcessedJoint in successfullyProcessedPendingJoints)
2928 {
2929 //DoJointErrorMessage(successfullyProcessedJoint, "finalizing succesfully procsssed joint " + successfullyProcessedJoint.ObjectNameInScene + " parms " + successfullyProcessedJoint.RawParams);
2930 //DoJointErrorMessage(successfullyProcessedJoint, "removing from pending");
2931 InternalRemovePendingJoint(successfullyProcessedJoint);
2932 //DoJointErrorMessage(successfullyProcessedJoint, "adding to active");
2933 InternalAddActiveJoint(successfullyProcessedJoint);
2934 //DoJointErrorMessage(successfullyProcessedJoint, "done");
2935 }
2936 }
2937 }
2938
2939 if (processedtaints)
2940//Console.WriteLine("Simulate calls Clear of _taintedPrim list");
2941 _taintedPrimH.Clear();
2942 _taintedPrimL.Clear();
2943 }
2944
2945 // Move characters
2946 lock (_characters)
2947 {
2948 List<OdeCharacter> defects = new List<OdeCharacter>();
2949 foreach (OdeCharacter actor in _characters)
2950 {
2951 if (actor != null)
2952 actor.Move(timeStep, defects);
2953 }
2954 if (0 != defects.Count)
2955 {
2956 foreach (OdeCharacter defect in defects)
2957 {
2958 RemoveCharacter(defect);
2959 }
2960 }
2961 }
2962
2963 // Move other active objects
2964 lock (_activeprims)
2965 {
2966 foreach (OdePrim prim in _activeprims)
2967 {
2968 prim.m_collisionscore = 0;
2969 prim.Move(timeStep);
2970 }
2971 }
2972
2973 //if ((framecount % m_randomizeWater) == 0)
2974 // randomizeWater(waterlevel);
2975
2976 //int RayCastTimeMS = m_rayCastManager.ProcessQueuedRequests();
2977 m_rayCastManager.ProcessQueuedRequests();
2978
2979 collision_optimized(timeStep);
2980
2981 lock (_collisionEventPrim)
2982 {
2983 foreach (PhysicsActor obj in _collisionEventPrim)
2984 {
2985 if (obj == null)
2986 continue;
2987
2988 switch ((ActorTypes)obj.PhysicsActorType)
2989 {
2990 case ActorTypes.Agent:
2991 OdeCharacter cobj = (OdeCharacter)obj;
2992 cobj.AddCollisionFrameTime(100);
2993 cobj.SendCollisions();
2994 break;
2995 case ActorTypes.Prim:
2996 OdePrim pobj = (OdePrim)obj;
2997 pobj.SendCollisions();
2998 break;
2999 }
3000 }
3001 }
3002
3003 //if (m_global_contactcount > 5)
3004 //{
3005 // m_log.DebugFormat("[PHYSICS]: Contacts:{0}", m_global_contactcount);
3006 //}
3007
3008 m_global_contactcount = 0;
3009
3010 d.WorldQuickStep(world, ODE_STEPSIZE);
3011 d.JointGroupEmpty(contactgroup);
3012 //ode.dunlock(world);
3013 }
3014 catch (Exception e)
3015 {
3016 m_log.ErrorFormat("[PHYSICS]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
3017 ode.dunlock(world);
3018 }
3019
3020 step_time -= ODE_STEPSIZE;
3021 i++;
3022 //}
3023 //else
3024 //{
3025 //fps = 0;
3026 //}
3027 //}
3028 }
3029
3030 lock (_characters)
3031 {
3032 foreach (OdeCharacter actor in _characters)
3033 {
3034 if (actor != null)
3035 {
3036 if (actor.bad)
3037 m_log.WarnFormat("[PHYSICS]: BAD Actor {0} in _characters list was not removed?", actor.m_uuid);
3038 actor.UpdatePositionAndVelocity();
3039 }
3040 }
3041 }
3042
3043 lock (_badCharacter)
3044 {
3045 if (_badCharacter.Count > 0)
3046 {
3047 foreach (OdeCharacter chr in _badCharacter)
3048 {
3049 RemoveCharacter(chr);
3050 }
3051 _badCharacter.Clear();
3052 }
3053 }
3054
3055 lock (_activeprims)
3056 {
3057 //if (timeStep < 0.2f)
3058 {
3059 foreach (OdePrim actor in _activeprims)
3060 {
3061 if (actor.IsPhysical && (d.BodyIsEnabled(actor.Body) || !actor._zeroFlag))
3062 {
3063 actor.UpdatePositionAndVelocity();
3064
3065 if (SupportsNINJAJoints)
3066 {
3067 // If an actor moved, move its joint proxy objects as well.
3068 // There seems to be an event PhysicsActor.OnPositionUpdate that could be used
3069 // for this purpose but it is never called! So we just do the joint
3070 // movement code here.
3071
3072 if (actor.SOPName != null &&
3073 joints_connecting_actor.ContainsKey(actor.SOPName) &&
3074 joints_connecting_actor[actor.SOPName] != null &&
3075 joints_connecting_actor[actor.SOPName].Count > 0)
3076 {
3077 foreach (PhysicsJoint affectedJoint in joints_connecting_actor[actor.SOPName])
3078 {
3079 if (affectedJoint.IsInPhysicsEngine)
3080 {
3081 DoJointMoved(affectedJoint);
3082 }
3083 else
3084 {
3085 DoJointErrorMessage(affectedJoint, "a body connected to a joint was moved, but the joint doesn't exist yet! this will lead to joint error. joint was: " + affectedJoint.ObjectNameInScene + " parms:" + affectedJoint.RawParams);
3086 }
3087 }
3088 }
3089 }
3090 }
3091 }
3092 }
3093 }
3094
3095 //DumpJointInfo();
3096
3097 // Finished with all sim stepping. If requested, dump world state to file for debugging.
3098 // TODO: This call to the export function is already inside lock (OdeLock) - but is an extra lock needed?
3099 // TODO: This overwrites all dump files in-place. Should this be a growing logfile, or separate snapshots?
3100 if (physics_logging && (physics_logging_interval>0) && (framecount % physics_logging_interval == 0))
3101 {
3102 string fname = "state-" + world.ToString() + ".DIF"; // give each physics world a separate filename
3103 string prefix = "world" + world.ToString(); // prefix for variable names in exported .DIF file
3104
3105 if (physics_logging_append_existing_logfile)
3106 {
3107 string header = "-------------- START OF PHYSICS FRAME " + framecount.ToString() + " --------------";
3108 TextWriter fwriter = File.AppendText(fname);
3109 fwriter.WriteLine(header);
3110 fwriter.Close();
3111 }
3112 d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
3113 }
3114 }
3115
3116 return fps;
3117 }
3118
3119 public override void GetResults()
3120 {
3121 }
3122
3123 public override bool IsThreaded
3124 {
3125 // for now we won't be multithreaded
3126 get { return (false); }
3127 }
3128
3129 #region ODE Specific Terrain Fixes
3130 public float[] ResizeTerrain512NearestNeighbour(float[] heightMap)
3131 {
3132 float[] returnarr = new float[262144];
3133 float[,] resultarr = new float[(int)WorldExtents.X, (int)WorldExtents.Y];
3134
3135 // Filling out the array into its multi-dimensional components
3136 for (int y = 0; y < WorldExtents.Y; y++)
3137 {
3138 for (int x = 0; x < WorldExtents.X; x++)
3139 {
3140 resultarr[y, x] = heightMap[y * (int)WorldExtents.Y + x];
3141 }
3142 }
3143
3144 // Resize using Nearest Neighbour
3145
3146 // This particular way is quick but it only works on a multiple of the original
3147
3148 // The idea behind this method can be described with the following diagrams
3149 // second pass and third pass happen in the same loop really.. just separated
3150 // them to show what this does.
3151
3152 // First Pass
3153 // ResultArr:
3154 // 1,1,1,1,1,1
3155 // 1,1,1,1,1,1
3156 // 1,1,1,1,1,1
3157 // 1,1,1,1,1,1
3158 // 1,1,1,1,1,1
3159 // 1,1,1,1,1,1
3160
3161 // Second Pass
3162 // ResultArr2:
3163 // 1,,1,,1,,1,,1,,1,
3164 // ,,,,,,,,,,
3165 // 1,,1,,1,,1,,1,,1,
3166 // ,,,,,,,,,,
3167 // 1,,1,,1,,1,,1,,1,
3168 // ,,,,,,,,,,
3169 // 1,,1,,1,,1,,1,,1,
3170 // ,,,,,,,,,,
3171 // 1,,1,,1,,1,,1,,1,
3172 // ,,,,,,,,,,
3173 // 1,,1,,1,,1,,1,,1,
3174
3175 // Third pass fills in the blanks
3176 // ResultArr2:
3177 // 1,1,1,1,1,1,1,1,1,1,1,1
3178 // 1,1,1,1,1,1,1,1,1,1,1,1
3179 // 1,1,1,1,1,1,1,1,1,1,1,1
3180 // 1,1,1,1,1,1,1,1,1,1,1,1
3181 // 1,1,1,1,1,1,1,1,1,1,1,1
3182 // 1,1,1,1,1,1,1,1,1,1,1,1
3183 // 1,1,1,1,1,1,1,1,1,1,1,1
3184 // 1,1,1,1,1,1,1,1,1,1,1,1
3185 // 1,1,1,1,1,1,1,1,1,1,1,1
3186 // 1,1,1,1,1,1,1,1,1,1,1,1
3187 // 1,1,1,1,1,1,1,1,1,1,1,1
3188
3189 // X,Y = .
3190 // X+1,y = ^
3191 // X,Y+1 = *
3192 // X+1,Y+1 = #
3193
3194 // Filling in like this;
3195 // .*
3196 // ^#
3197 // 1st .
3198 // 2nd *
3199 // 3rd ^
3200 // 4th #
3201 // on single loop.
3202
3203 float[,] resultarr2 = new float[512, 512];
3204 for (int y = 0; y < WorldExtents.Y; y++)
3205 {
3206 for (int x = 0; x < WorldExtents.X; x++)
3207 {
3208 resultarr2[y * 2, x * 2] = resultarr[y, x];
3209
3210 if (y < WorldExtents.Y)
3211 {
3212 resultarr2[(y * 2) + 1, x * 2] = resultarr[y, x];
3213 }
3214 if (x < WorldExtents.X)
3215 {
3216 resultarr2[y * 2, (x * 2) + 1] = resultarr[y, x];
3217 }
3218 if (x < WorldExtents.X && y < WorldExtents.Y)
3219 {
3220 resultarr2[(y * 2) + 1, (x * 2) + 1] = resultarr[y, x];
3221 }
3222 }
3223 }
3224
3225 //Flatten out the array
3226 int i = 0;
3227 for (int y = 0; y < 512; y++)
3228 {
3229 for (int x = 0; x < 512; x++)
3230 {
3231 if (resultarr2[y, x] <= 0)
3232 returnarr[i] = 0.0000001f;
3233 else
3234 returnarr[i] = resultarr2[y, x];
3235
3236 i++;
3237 }
3238 }
3239
3240 return returnarr;
3241 }
3242
3243 public float[] ResizeTerrain512Interpolation(float[] heightMap)
3244 {
3245 float[] returnarr = new float[262144];
3246 float[,] resultarr = new float[512,512];
3247
3248 // Filling out the array into its multi-dimensional components
3249 for (int y = 0; y < 256; y++)
3250 {
3251 for (int x = 0; x < 256; x++)
3252 {
3253 resultarr[y, x] = heightMap[y * 256 + x];
3254 }
3255 }
3256
3257 // Resize using interpolation
3258
3259 // This particular way is quick but it only works on a multiple of the original
3260
3261 // The idea behind this method can be described with the following diagrams
3262 // second pass and third pass happen in the same loop really.. just separated
3263 // them to show what this does.
3264
3265 // First Pass
3266 // ResultArr:
3267 // 1,1,1,1,1,1
3268 // 1,1,1,1,1,1
3269 // 1,1,1,1,1,1
3270 // 1,1,1,1,1,1
3271 // 1,1,1,1,1,1
3272 // 1,1,1,1,1,1
3273
3274 // Second Pass
3275 // ResultArr2:
3276 // 1,,1,,1,,1,,1,,1,
3277 // ,,,,,,,,,,
3278 // 1,,1,,1,,1,,1,,1,
3279 // ,,,,,,,,,,
3280 // 1,,1,,1,,1,,1,,1,
3281 // ,,,,,,,,,,
3282 // 1,,1,,1,,1,,1,,1,
3283 // ,,,,,,,,,,
3284 // 1,,1,,1,,1,,1,,1,
3285 // ,,,,,,,,,,
3286 // 1,,1,,1,,1,,1,,1,
3287
3288 // Third pass fills in the blanks
3289 // ResultArr2:
3290 // 1,1,1,1,1,1,1,1,1,1,1,1
3291 // 1,1,1,1,1,1,1,1,1,1,1,1
3292 // 1,1,1,1,1,1,1,1,1,1,1,1
3293 // 1,1,1,1,1,1,1,1,1,1,1,1
3294 // 1,1,1,1,1,1,1,1,1,1,1,1
3295 // 1,1,1,1,1,1,1,1,1,1,1,1
3296 // 1,1,1,1,1,1,1,1,1,1,1,1
3297 // 1,1,1,1,1,1,1,1,1,1,1,1
3298 // 1,1,1,1,1,1,1,1,1,1,1,1
3299 // 1,1,1,1,1,1,1,1,1,1,1,1
3300 // 1,1,1,1,1,1,1,1,1,1,1,1
3301
3302 // X,Y = .
3303 // X+1,y = ^
3304 // X,Y+1 = *
3305 // X+1,Y+1 = #
3306
3307 // Filling in like this;
3308 // .*
3309 // ^#
3310 // 1st .
3311 // 2nd *
3312 // 3rd ^
3313 // 4th #
3314 // on single loop.
3315
3316 float[,] resultarr2 = new float[512,512];
3317 for (int y = 0; y < (int)Constants.RegionSize; y++)
3318 {
3319 for (int x = 0; x < (int)Constants.RegionSize; x++)
3320 {
3321 resultarr2[y*2, x*2] = resultarr[y, x];
3322
3323 if (y < (int)Constants.RegionSize)
3324 {
3325 if (y + 1 < (int)Constants.RegionSize)
3326 {
3327 if (x + 1 < (int)Constants.RegionSize)
3328 {
3329 resultarr2[(y*2) + 1, x*2] = ((resultarr[y, x] + resultarr[y + 1, x] +
3330 resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
3331 }
3332 else
3333 {
3334 resultarr2[(y*2) + 1, x*2] = ((resultarr[y, x] + resultarr[y + 1, x])/2);
3335 }
3336 }
3337 else
3338 {
3339 resultarr2[(y*2) + 1, x*2] = resultarr[y, x];
3340 }
3341 }
3342 if (x < (int)Constants.RegionSize)
3343 {
3344 if (x + 1 < (int)Constants.RegionSize)
3345 {
3346 if (y + 1 < (int)Constants.RegionSize)
3347 {
3348 resultarr2[y*2, (x*2) + 1] = ((resultarr[y, x] + resultarr[y + 1, x] +
3349 resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
3350 }
3351 else
3352 {
3353 resultarr2[y*2, (x*2) + 1] = ((resultarr[y, x] + resultarr[y, x + 1])/2);
3354 }
3355 }
3356 else
3357 {
3358 resultarr2[y*2, (x*2) + 1] = resultarr[y, x];
3359 }
3360 }
3361 if (x < (int)Constants.RegionSize && y < (int)Constants.RegionSize)
3362 {
3363 if ((x + 1 < (int)Constants.RegionSize) && (y + 1 < (int)Constants.RegionSize))
3364 {
3365 resultarr2[(y*2) + 1, (x*2) + 1] = ((resultarr[y, x] + resultarr[y + 1, x] +
3366 resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
3367 }
3368 else
3369 {
3370 resultarr2[(y*2) + 1, (x*2) + 1] = resultarr[y, x];
3371 }
3372 }
3373 }
3374 }
3375 //Flatten out the array
3376 int i = 0;
3377 for (int y = 0; y < 512; y++)
3378 {
3379 for (int x = 0; x < 512; x++)
3380 {
3381 if (Single.IsNaN(resultarr2[y, x]) || Single.IsInfinity(resultarr2[y, x]))
3382 {
3383 m_log.Warn("[PHYSICS]: Non finite heightfield element detected. Setting it to 0");
3384 resultarr2[y, x] = 0;
3385 }
3386 returnarr[i] = resultarr2[y, x];
3387 i++;
3388 }
3389 }
3390
3391 return returnarr;
3392 }
3393
3394 #endregion
3395
3396 public override void SetTerrain(float[] heightMap)
3397 {
3398 if (m_worldOffset != Vector3.Zero && m_parentScene != null)
3399 {
3400 if (m_parentScene is OdeScene)
3401 {
3402 ((OdeScene)m_parentScene).SetTerrain(heightMap, m_worldOffset);
3403 }
3404 }
3405 else
3406 {
3407 SetTerrain(heightMap, m_worldOffset);
3408 }
3409 }
3410
3411 public void SetTerrain(float[] heightMap, Vector3 pOffset)
3412 {
3413 // this._heightmap[i] = (double)heightMap[i];
3414 // dbm (danx0r) -- creating a buffer zone of one extra sample all around
3415 //_origheightmap = heightMap;
3416
3417 float[] _heightmap;
3418
3419 // zero out a heightmap array float array (single dimension [flattened]))
3420 //if ((int)Constants.RegionSize == 256)
3421 // _heightmap = new float[514 * 514];
3422 //else
3423
3424 _heightmap = new float[(((int)Constants.RegionSize + 2) * ((int)Constants.RegionSize + 2))];
3425
3426 uint heightmapWidth = Constants.RegionSize + 1;
3427 uint heightmapHeight = Constants.RegionSize + 1;
3428
3429 uint heightmapWidthSamples;
3430
3431 uint heightmapHeightSamples;
3432
3433 //if (((int)Constants.RegionSize) == 256)
3434 //{
3435 // heightmapWidthSamples = 2 * (uint)Constants.RegionSize + 2;
3436 // heightmapHeightSamples = 2 * (uint)Constants.RegionSize + 2;
3437 // heightmapWidth++;
3438 // heightmapHeight++;
3439 //}
3440 //else
3441 //{
3442
3443 heightmapWidthSamples = (uint)Constants.RegionSize + 1;
3444 heightmapHeightSamples = (uint)Constants.RegionSize + 1;
3445 //}
3446
3447 const float scale = 1.0f;
3448 const float offset = 0.0f;
3449 const float thickness = 0.2f;
3450 const int wrap = 0;
3451
3452 int regionsize = (int) Constants.RegionSize + 2;
3453 //Double resolution
3454 //if (((int)Constants.RegionSize) == 256)
3455 // heightMap = ResizeTerrain512Interpolation(heightMap);
3456
3457
3458 // if (((int)Constants.RegionSize) == 256 && (int)Constants.RegionSize == 256)
3459 // regionsize = 512;
3460
3461 float hfmin = 2000;
3462 float hfmax = -2000;
3463
3464 for (int x = 0; x < heightmapWidthSamples; x++)
3465 {
3466 for (int y = 0; y < heightmapHeightSamples; y++)
3467 {
3468 int xx = Util.Clip(x - 1, 0, regionsize - 1);
3469 int yy = Util.Clip(y - 1, 0, regionsize - 1);
3470
3471
3472 float val= heightMap[yy * (int)Constants.RegionSize + xx];
3473 _heightmap[x * ((int)Constants.RegionSize + 2) + y] = val;
3474
3475 hfmin = (val < hfmin) ? val : hfmin;
3476 hfmax = (val > hfmax) ? val : hfmax;
3477 }
3478 }
3479
3480
3481
3482
3483 lock (OdeLock)
3484 {
3485 IntPtr GroundGeom = IntPtr.Zero;
3486 if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
3487 {
3488 RegionTerrain.Remove(pOffset);
3489 if (GroundGeom != IntPtr.Zero)
3490 {
3491 if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
3492 {
3493 TerrainHeightFieldHeights.Remove(GroundGeom);
3494 }
3495 d.SpaceRemove(space, GroundGeom);
3496 d.GeomDestroy(GroundGeom);
3497 }
3498
3499 }
3500 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
3501 d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmap, 0, heightmapWidth + 1, heightmapHeight + 1,
3502 (int)heightmapWidthSamples + 1, (int)heightmapHeightSamples + 1, scale,
3503 offset, thickness, wrap);
3504 d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
3505 GroundGeom = d.CreateHeightfield(space, HeightmapData, 1);
3506 if (GroundGeom != IntPtr.Zero)
3507 {
3508 d.GeomSetCategoryBits(GroundGeom, (int)(CollisionCategories.Land));
3509 d.GeomSetCollideBits(GroundGeom, (int)(CollisionCategories.Space));
3510
3511 }
3512 geom_name_map[GroundGeom] = "Terrain";
3513
3514 d.Matrix3 R = new d.Matrix3();
3515
3516 Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
3517 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
3518 //Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
3519
3520 q1 = q1 * q2;
3521 //q1 = q1 * q3;
3522 Vector3 v3;
3523 float angle;
3524 q1.GetAxisAngle(out v3, out angle);
3525
3526 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
3527 d.GeomSetRotation(GroundGeom, ref R);
3528 d.GeomSetPosition(GroundGeom, (pOffset.X + ((int)Constants.RegionSize * 0.5f)) - 1, (pOffset.Y + ((int)Constants.RegionSize * 0.5f)) - 1, 0);
3529 IntPtr testGround = IntPtr.Zero;
3530 if (RegionTerrain.TryGetValue(pOffset, out testGround))
3531 {
3532 RegionTerrain.Remove(pOffset);
3533 }
3534 RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
3535 TerrainHeightFieldHeights.Add(GroundGeom,_heightmap);
3536
3537 }
3538 }
3539
3540 public override void DeleteTerrain()
3541 {
3542 }
3543
3544 public float GetWaterLevel()
3545 {
3546 return waterlevel;
3547 }
3548
3549 public override bool SupportsCombining()
3550 {
3551 return true;
3552 }
3553
3554 public override void UnCombine(PhysicsScene pScene)
3555 {
3556 IntPtr localGround = IntPtr.Zero;
3557// float[] localHeightfield;
3558 bool proceed = false;
3559 List<IntPtr> geomDestroyList = new List<IntPtr>();
3560
3561 lock (OdeLock)
3562 {
3563 if (RegionTerrain.TryGetValue(Vector3.Zero, out localGround))
3564 {
3565 foreach (IntPtr geom in TerrainHeightFieldHeights.Keys)
3566 {
3567 if (geom == localGround)
3568 {
3569// localHeightfield = TerrainHeightFieldHeights[geom];
3570 proceed = true;
3571 }
3572 else
3573 {
3574 geomDestroyList.Add(geom);
3575 }
3576 }
3577
3578 if (proceed)
3579 {
3580 m_worldOffset = Vector3.Zero;
3581 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
3582 m_parentScene = null;
3583
3584 foreach (IntPtr g in geomDestroyList)
3585 {
3586 // removingHeightField needs to be done or the garbage collector will
3587 // collect the terrain data before we tell ODE to destroy it causing
3588 // memory corruption
3589 if (TerrainHeightFieldHeights.ContainsKey(g))
3590 {
3591// float[] removingHeightField = TerrainHeightFieldHeights[g];
3592 TerrainHeightFieldHeights.Remove(g);
3593
3594 if (RegionTerrain.ContainsKey(g))
3595 {
3596 RegionTerrain.Remove(g);
3597 }
3598
3599 d.GeomDestroy(g);
3600 //removingHeightField = new float[0];
3601 }
3602 }
3603
3604 }
3605 else
3606 {
3607 m_log.Warn("[PHYSICS]: Couldn't proceed with UnCombine. Region has inconsistant data.");
3608
3609 }
3610 }
3611 }
3612 }
3613
3614 public override void SetWaterLevel(float baseheight)
3615 {
3616 waterlevel = baseheight;
3617 randomizeWater(waterlevel);
3618 }
3619
3620 public void randomizeWater(float baseheight)
3621 {
3622 const uint heightmapWidth = m_regionWidth + 2;
3623 const uint heightmapHeight = m_regionHeight + 2;
3624 const uint heightmapWidthSamples = m_regionWidth + 2;
3625 const uint heightmapHeightSamples = m_regionHeight + 2;
3626 const float scale = 1.0f;
3627 const float offset = 0.0f;
3628 const float thickness = 2.9f;
3629 const int wrap = 0;
3630
3631 for (int i = 0; i < (258 * 258); i++)
3632 {
3633 _watermap[i] = (baseheight-0.1f) + ((float)fluidRandomizer.Next(1,9) / 10f);
3634 // m_log.Info((baseheight - 0.1f) + ((float)fluidRandomizer.Next(1, 9) / 10f));
3635 }
3636
3637 lock (OdeLock)
3638 {
3639 if (WaterGeom != IntPtr.Zero)
3640 {
3641 d.SpaceRemove(space, WaterGeom);
3642 }
3643 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
3644 d.GeomHeightfieldDataBuildSingle(HeightmapData, _watermap, 0, heightmapWidth, heightmapHeight,
3645 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
3646 offset, thickness, wrap);
3647 d.GeomHeightfieldDataSetBounds(HeightmapData, m_regionWidth, m_regionHeight);
3648 WaterGeom = d.CreateHeightfield(space, HeightmapData, 1);
3649 if (WaterGeom != IntPtr.Zero)
3650 {
3651 d.GeomSetCategoryBits(WaterGeom, (int)(CollisionCategories.Water));
3652 d.GeomSetCollideBits(WaterGeom, (int)(CollisionCategories.Space));
3653
3654 }
3655 geom_name_map[WaterGeom] = "Water";
3656
3657 d.Matrix3 R = new d.Matrix3();
3658
3659 Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
3660 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
3661 //Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
3662
3663 q1 = q1 * q2;
3664 //q1 = q1 * q3;
3665 Vector3 v3;
3666 float angle;
3667 q1.GetAxisAngle(out v3, out angle);
3668
3669 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
3670 d.GeomSetRotation(WaterGeom, ref R);
3671 d.GeomSetPosition(WaterGeom, 128, 128, 0);
3672
3673 }
3674
3675 }
3676
3677 public override void Dispose()
3678 {
3679 m_rayCastManager.Dispose();
3680 m_rayCastManager = null;
3681
3682 lock (OdeLock)
3683 {
3684 lock (_prims)
3685 {
3686 foreach (OdePrim prm in _prims)
3687 {
3688 RemovePrim(prm);
3689 }
3690 }
3691
3692 //foreach (OdeCharacter act in _characters)
3693 //{
3694 //RemoveAvatar(act);
3695 //}
3696 d.WorldDestroy(world);
3697 //d.CloseODE();
3698 }
3699 }
3700 public override Dictionary<uint, float> GetTopColliders()
3701 {
3702 Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
3703 int cnt = 0;
3704 lock (_prims)
3705 {
3706 foreach (OdePrim prm in _prims)
3707 {
3708 if (prm.CollisionScore > 0)
3709 {
3710 returncolliders.Add(prm.m_localID, prm.CollisionScore);
3711 cnt++;
3712 prm.CollisionScore = 0f;
3713 if (cnt > 25)
3714 {
3715 break;
3716 }
3717 }
3718 }
3719 }
3720 return returncolliders;
3721 }
3722
3723 public override bool SupportsRayCast()
3724 {
3725 return true;
3726 }
3727
3728 public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
3729 {
3730 if (retMethod != null)
3731 {
3732 m_rayCastManager.QueueRequest(position, direction, length, retMethod);
3733 }
3734 }
3735
3736#if USE_DRAWSTUFF
3737 // Keyboard callback
3738 public void command(int cmd)
3739 {
3740 IntPtr geom;
3741 d.Mass mass;
3742 d.Vector3 sides = new d.Vector3(d.RandReal() * 0.5f + 0.1f, d.RandReal() * 0.5f + 0.1f, d.RandReal() * 0.5f + 0.1f);
3743
3744
3745
3746 Char ch = Char.ToLower((Char)cmd);
3747 switch ((Char)ch)
3748 {
3749 case 'w':
3750 try
3751 {
3752 Vector3 rotate = (new Vector3(1, 0, 0) * Quaternion.CreateFromEulers(hpr.Z * Utils.DEG_TO_RAD, hpr.Y * Utils.DEG_TO_RAD, hpr.X * Utils.DEG_TO_RAD));
3753
3754 xyz.X += rotate.X; xyz.Y += rotate.Y; xyz.Z += rotate.Z;
3755 ds.SetViewpoint(ref xyz, ref hpr);
3756 }
3757 catch (ArgumentException)
3758 { hpr.X = 0; }
3759 break;
3760
3761 case 'a':
3762 hpr.X++;
3763 ds.SetViewpoint(ref xyz, ref hpr);
3764 break;
3765
3766 case 's':
3767 try
3768 {
3769 Vector3 rotate2 = (new Vector3(-1, 0, 0) * Quaternion.CreateFromEulers(hpr.Z * Utils.DEG_TO_RAD, hpr.Y * Utils.DEG_TO_RAD, hpr.X * Utils.DEG_TO_RAD));
3770
3771 xyz.X += rotate2.X; xyz.Y += rotate2.Y; xyz.Z += rotate2.Z;
3772 ds.SetViewpoint(ref xyz, ref hpr);
3773 }
3774 catch (ArgumentException)
3775 { hpr.X = 0; }
3776 break;
3777 case 'd':
3778 hpr.X--;
3779 ds.SetViewpoint(ref xyz, ref hpr);
3780 break;
3781 case 'r':
3782 xyz.Z++;
3783 ds.SetViewpoint(ref xyz, ref hpr);
3784 break;
3785 case 'f':
3786 xyz.Z--;
3787 ds.SetViewpoint(ref xyz, ref hpr);
3788 break;
3789 case 'e':
3790 xyz.Y++;
3791 ds.SetViewpoint(ref xyz, ref hpr);
3792 break;
3793 case 'q':
3794 xyz.Y--;
3795 ds.SetViewpoint(ref xyz, ref hpr);
3796 break;
3797 }
3798 }
3799
3800 public void step(int pause)
3801 {
3802
3803 ds.SetColor(1.0f, 1.0f, 0.0f);
3804 ds.SetTexture(ds.Texture.Wood);
3805 lock (_prims)
3806 {
3807 foreach (OdePrim prm in _prims)
3808 {
3809 //IntPtr body = d.GeomGetBody(prm.prim_geom);
3810 if (prm.prim_geom != IntPtr.Zero)
3811 {
3812 d.Vector3 pos;
3813 d.GeomCopyPosition(prm.prim_geom, out pos);
3814 //d.BodyCopyPosition(body, out pos);
3815
3816 d.Matrix3 R;
3817 d.GeomCopyRotation(prm.prim_geom, out R);
3818 //d.BodyCopyRotation(body, out R);
3819
3820
3821 d.Vector3 sides = new d.Vector3();
3822 sides.X = prm.Size.X;
3823 sides.Y = prm.Size.Y;
3824 sides.Z = prm.Size.Z;
3825
3826 ds.DrawBox(ref pos, ref R, ref sides);
3827 }
3828 }
3829 }
3830 ds.SetColor(1.0f, 0.0f, 0.0f);
3831 lock (_characters)
3832 {
3833 foreach (OdeCharacter chr in _characters)
3834 {
3835 if (chr.Shell != IntPtr.Zero)
3836 {
3837 IntPtr body = d.GeomGetBody(chr.Shell);
3838
3839 d.Vector3 pos;
3840 d.GeomCopyPosition(chr.Shell, out pos);
3841 //d.BodyCopyPosition(body, out pos);
3842
3843 d.Matrix3 R;
3844 d.GeomCopyRotation(chr.Shell, out R);
3845 //d.BodyCopyRotation(body, out R);
3846
3847 ds.DrawCapsule(ref pos, ref R, chr.Size.Z, 0.35f);
3848 d.Vector3 sides = new d.Vector3();
3849 sides.X = 0.5f;
3850 sides.Y = 0.5f;
3851 sides.Z = 0.5f;
3852
3853 ds.DrawBox(ref pos, ref R, ref sides);
3854 }
3855 }
3856 }
3857 }
3858
3859 public void start(int unused)
3860 {
3861 ds.SetViewpoint(ref xyz, ref hpr);
3862 }
3863#endif
3864 }
3865}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/Tests/ODETestClass.cs b/OpenSim/Region/Physics/ChOdePlugin/Tests/ODETestClass.cs
new file mode 100644
index 0000000..69e2d03
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/Tests/ODETestClass.cs
@@ -0,0 +1,122 @@
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
28using System;
29using Nini.Config;
30using NUnit.Framework;
31using OpenMetaverse;
32using OpenSim.Framework;
33using OpenSim.Region.Physics.Manager;
34using log4net;
35using System.Reflection;
36
37namespace OpenSim.Region.Physics.OdePlugin
38{
39 [TestFixture]
40 public class ODETestClass
41 {
42 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
43
44 private OdePlugin cbt;
45 private PhysicsScene ps;
46 private IMeshingPlugin imp;
47
48 [SetUp]
49 public void Initialize()
50 {
51 // Loading ODEPlugin
52 cbt = new OdePlugin();
53 // Loading Zero Mesher
54 imp = new ZeroMesherPlugin();
55 // Getting Physics Scene
56 ps = cbt.GetScene("test");
57 // Initializing Physics Scene.
58 ps.Initialise(imp.GetMesher(),null);
59 float[] _heightmap = new float[(int)Constants.RegionSize * (int)Constants.RegionSize];
60 for (int i = 0; i < ((int)Constants.RegionSize * (int)Constants.RegionSize); i++)
61 {
62 _heightmap[i] = 21f;
63 }
64 ps.SetTerrain(_heightmap);
65 }
66
67 [TearDown]
68 public void Terminate()
69 {
70 ps.DeleteTerrain();
71 ps.Dispose();
72
73 }
74
75 [Test]
76 public void CreateAndDropPhysicalCube()
77 {
78 PrimitiveBaseShape newcube = PrimitiveBaseShape.CreateBox();
79 Vector3 position = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f), 128f);
80 Vector3 size = new Vector3(0.5f, 0.5f, 0.5f);
81 Quaternion rot = Quaternion.Identity;
82 PhysicsActor prim = ps.AddPrimShape("CoolShape", newcube, position, size, rot, true);
83 OdePrim oprim = (OdePrim)prim;
84 OdeScene pscene = (OdeScene) ps;
85
86 Assert.That(oprim.m_taintadd);
87
88 prim.LocalID = 5;
89
90 for (int i = 0; i < 58; i++)
91 {
92 ps.Simulate(0.133f);
93
94 Assert.That(oprim.prim_geom != (IntPtr)0);
95
96 Assert.That(oprim.m_targetSpace != (IntPtr)0);
97
98 //Assert.That(oprim.m_targetSpace == pscene.space);
99 m_log.Info("TargetSpace: " + oprim.m_targetSpace + " - SceneMainSpace: " + pscene.space);
100
101 Assert.That(!oprim.m_taintadd);
102 m_log.Info("Prim Position (" + oprim.m_localID + "): " + prim.Position.ToString());
103
104 // Make sure we're above the ground
105 //Assert.That(prim.Position.Z > 20f);
106 //m_log.Info("PrimCollisionScore (" + oprim.m_localID + "): " + oprim.m_collisionscore);
107
108 // Make sure we've got a Body
109 Assert.That(oprim.Body != (IntPtr)0);
110 //m_log.Info(
111 }
112
113 // Make sure we're not somewhere above the ground
114 Assert.That(prim.Position.Z < 21.5f);
115
116 ps.RemovePrim(prim);
117 Assert.That(oprim.m_taintremove);
118 ps.Simulate(0.133f);
119 Assert.That(oprim.Body == (IntPtr)0);
120 }
121 }
122}
diff --git a/OpenSim/Region/Physics/ChOdePlugin/drawstuff.cs b/OpenSim/Region/Physics/ChOdePlugin/drawstuff.cs
new file mode 100644
index 0000000..87ca446
--- /dev/null
+++ b/OpenSim/Region/Physics/ChOdePlugin/drawstuff.cs
@@ -0,0 +1,98 @@
1/*
2 * Copyright ODE
3 * Ode.NET - .NET bindings for ODE
4 * Jason Perkins (starkos@industriousone.com)
5 * Licensed under the New BSD
6 * Part of the OpenDynamicsEngine
7Open Dynamics Engine
8Copyright (c) 2001-2007, Russell L. Smith.
9All rights reserved.
10
11Redistribution and use in source and binary forms, with or without
12modification, are permitted provided that the following conditions
13are met:
14
15Redistributions of source code must retain the above copyright notice,
16this list of conditions and the following disclaimer.
17
18Redistributions in binary form must reproduce the above copyright notice,
19this list of conditions and the following disclaimer in the documentation
20and/or other materials provided with the distribution.
21
22Neither the names of ODE's copyright owner nor the names of its
23contributors may be used to endorse or promote products derived from
24this software without specific prior written permission.
25
26THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
29FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
32TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 *
38 *
39 */
40
41using System;
42using System.Runtime.InteropServices;
43using Ode.NET;
44
45namespace Drawstuff.NET
46{
47#if dDOUBLE
48 using dReal = System.Double;
49#else
50 using dReal = System.Single;
51#endif
52
53 public static class ds
54 {
55 public const int VERSION = 2;
56
57 public enum Texture
58 {
59 None,
60 Wood
61 }
62
63 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
64 public delegate void CallbackFunction(int arg);
65
66 [StructLayout(LayoutKind.Sequential)]
67 public struct Functions
68 {
69 public int version;
70 public CallbackFunction start;
71 public CallbackFunction step;
72 public CallbackFunction command;
73 public CallbackFunction stop;
74 public string path_to_textures;
75 }
76
77 [DllImport("drawstuff", EntryPoint = "dsDrawBox")]
78 public static extern void DrawBox(ref d.Vector3 pos, ref d.Matrix3 R, ref d.Vector3 sides);
79
80 [DllImport("drawstuff", EntryPoint = "dsDrawCapsule")]
81 public static extern void DrawCapsule(ref d.Vector3 pos, ref d.Matrix3 R, dReal length, dReal radius);
82
83 [DllImport("drawstuff", EntryPoint = "dsDrawConvex")]
84 public static extern void DrawConvex(ref d.Vector3 pos, ref d.Matrix3 R, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons);
85
86 [DllImport("drawstuff", EntryPoint = "dsSetColor")]
87 public static extern void SetColor(float red, float green, float blue);
88
89 [DllImport("drawstuff", EntryPoint = "dsSetTexture")]
90 public static extern void SetTexture(Texture texture);
91
92 [DllImport("drawstuff", EntryPoint = "dsSetViewpoint")]
93 public static extern void SetViewpoint(ref d.Vector3 xyz, ref d.Vector3 hpr);
94
95 [DllImport("drawstuff", EntryPoint = "dsSimulationLoop")]
96 public static extern void SimulationLoop(int argc, string[] argv, int window_width, int window_height, ref Functions fn);
97 }
98}