aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/Physics/UbitOdePlugin
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/Physics/UbitOdePlugin')
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/AssemblyInfo.cs58
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs1470
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs1003
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs3958
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs603
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/OdeApi.cs2005
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/OdePlugin.cs90
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs2696
8 files changed, 11883 insertions, 0 deletions
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/UbitOdePlugin/AssemblyInfo.cs
new file mode 100644
index 0000000..d46341b
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/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("Ubit Variation")]
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/UbitOdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
new file mode 100644
index 0000000..326fe97
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
@@ -0,0 +1,1470 @@
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
29// Revision by Ubit 2011/12
30
31using System;
32using System.Collections.Generic;
33using System.Reflection;
34using OpenMetaverse;
35using OdeAPI;
36using OpenSim.Framework;
37using OpenSim.Region.Physics.Manager;
38using log4net;
39
40namespace OpenSim.Region.Physics.OdePlugin
41{
42 /// <summary>
43 /// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
44 /// </summary>
45
46 public enum dParam : int
47 {
48 LowStop = 0,
49 HiStop = 1,
50 Vel = 2,
51 FMax = 3,
52 FudgeFactor = 4,
53 Bounce = 5,
54 CFM = 6,
55 StopERP = 7,
56 StopCFM = 8,
57 LoStop2 = 256,
58 HiStop2 = 257,
59 Vel2 = 258,
60 FMax2 = 259,
61 StopERP2 = 7 + 256,
62 StopCFM2 = 8 + 256,
63 LoStop3 = 512,
64 HiStop3 = 513,
65 Vel3 = 514,
66 FMax3 = 515,
67 StopERP3 = 7 + 512,
68 StopCFM3 = 8 + 512
69 }
70
71 public class OdeCharacter : PhysicsActor
72 {
73 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
74
75 private Vector3 _position;
76 private Vector3 _zeroPosition;
77 private bool _zeroFlag = false;
78 private Vector3 _velocity;
79 private Vector3 _target_velocity;
80 private Vector3 _acceleration;
81 private Vector3 m_rotationalVelocity;
82 private float m_mass = 80f;
83 public float m_density = 60f;
84 private bool m_pidControllerActive = true;
85 public float PID_D = 800.0f;
86 public float PID_P = 900.0f;
87 //private static float POSTURE_SERVO = 10000.0f;
88 public float CAPSULE_RADIUS = 0.37f;
89 public float CAPSULE_LENGTH = 2.140599f;
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_iscollidingObj = false;
96 private bool m_alwaysRun = false;
97 private int m_requestedUpdateFrequency = 0;
98 public uint m_localID = 0;
99 public bool m_returnCollisions = false;
100 // taints and their non-tainted counterparts
101 public bool m_isPhysical = false; // the current physical status
102 public float MinimumGroundFlightOffset = 3f;
103
104 private float m_buoyancy = 0f;
105
106 private bool m_freemove = false;
107 // private CollisionLocker ode;
108
109 private string m_name = String.Empty;
110 // other filter control
111 int m_colliderfilter = 0;
112 int m_colliderGroundfilter = 0;
113 int m_colliderObjectfilter = 0;
114
115 // Default we're a Character
116 private CollisionCategories m_collisionCategories = (CollisionCategories.Character);
117
118 // Default, Collide with Other Geometries, spaces, bodies and characters.
119 private CollisionCategories m_collisionFlags = (CollisionCategories.Character
120 | CollisionCategories.Geom
121 | CollisionCategories.VolumeDtc
122 );
123 // we do land collisions not ode | CollisionCategories.Land);
124 public IntPtr Body = IntPtr.Zero;
125 private OdeScene _parent_scene;
126 public IntPtr Shell = IntPtr.Zero;
127 public IntPtr Amotor = IntPtr.Zero;
128 public d.Mass ShellMass;
129// public bool collidelock = false;
130
131 private bool m_haseventsubscription = false;
132 public int m_eventsubscription = 0;
133 private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate();
134
135 // unique UUID of this character object
136 public UUID m_uuid;
137 public bool bad = false;
138
139 float mu;
140
141 public OdeCharacter(String avName, OdeScene parent_scene, Vector3 pos, Vector3 size, float pid_d, float pid_p, float capsule_radius, float density, float walk_divisor, float rundivisor)
142 {
143 m_uuid = UUID.Random();
144
145 if (pos.IsFinite())
146 {
147 if (pos.Z > 99999f)
148 {
149 pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
150 }
151 if (pos.Z < -100f) // shouldn't this be 0 ?
152 {
153 pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
154 }
155 _position = pos;
156 }
157 else
158 {
159 _position = new Vector3(((float)_parent_scene.WorldExtents.X * 0.5f), ((float)_parent_scene.WorldExtents.Y * 0.5f), parent_scene.GetTerrainHeightAtXY(128f, 128f) + 10f);
160 m_log.Warn("[PHYSICS]: Got NaN Position on Character Create");
161 }
162
163 _parent_scene = parent_scene;
164
165 PID_D = pid_d;
166 PID_P = pid_p;
167 CAPSULE_RADIUS = capsule_radius;
168 m_density = density;
169 m_mass = 80f; // sure we have a default
170
171 mu = parent_scene.AvatarFriction;
172
173 walkDivisor = walk_divisor;
174 runDivisor = rundivisor;
175
176 CAPSULE_LENGTH = size.Z * 1.15f - CAPSULE_RADIUS * 2.0f;
177 //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString());
178
179 m_isPhysical = false; // current status: no ODE information exists
180
181 m_name = avName;
182
183 AddChange(changes.Add, null);
184 }
185
186 public override int PhysicsActorType
187 {
188 get { return (int)ActorTypes.Agent; }
189 set { return; }
190 }
191
192 public override void getContactData(ref ContactData cdata)
193 {
194 cdata.mu = mu;
195 cdata.bounce = 0;
196 cdata.softcolide = false;
197 }
198
199 public override bool Building { get; set; }
200
201 /// <summary>
202 /// If this is set, the avatar will move faster
203 /// </summary>
204 public override bool SetAlwaysRun
205 {
206 get { return m_alwaysRun; }
207 set { m_alwaysRun = value; }
208 }
209
210 public override uint LocalID
211 {
212 set { m_localID = value; }
213 }
214
215 public override bool Grabbed
216 {
217 set { return; }
218 }
219
220 public override bool Selected
221 {
222 set { return; }
223 }
224
225 public override float Buoyancy
226 {
227 get { return m_buoyancy; }
228 set { m_buoyancy = value; }
229 }
230
231 public override bool FloatOnWater
232 {
233 set { return; }
234 }
235
236 public override bool IsPhysical
237 {
238 get { return false; }
239 set { return; }
240 }
241
242 public override bool ThrottleUpdates
243 {
244 get { return false; }
245 set { return; }
246 }
247
248 public override bool Flying
249 {
250 get { return flying; }
251 set
252 {
253 flying = value;
254 // m_log.DebugFormat("[PHYSICS]: Set OdeCharacter Flying to {0}", flying);
255 }
256 }
257
258 /// <summary>
259 /// Returns if the avatar is colliding in general.
260 /// This includes the ground and objects and avatar.
261 /// </summary>
262 public override bool IsColliding
263 {
264 get { return (m_iscolliding || m_iscollidingGround); }
265 set
266 {
267 if (value)
268 {
269 m_colliderfilter += 2;
270 if (m_colliderfilter > 2)
271 m_colliderfilter = 2;
272 }
273 else
274 {
275 m_colliderfilter--;
276 if (m_colliderfilter < 0)
277 m_colliderfilter = 0;
278 }
279
280 if (m_colliderfilter == 0)
281 m_iscolliding = false;
282 else
283 {
284 m_pidControllerActive = true;
285 m_iscolliding = true;
286 }
287 }
288 }
289
290 /// <summary>
291 /// Returns if an avatar is colliding with the ground
292 /// </summary>
293 public override bool CollidingGround
294 {
295 get { return m_iscollidingGround; }
296 set
297 {
298 /* we now control this
299 if (value)
300 {
301 m_colliderGroundfilter += 2;
302 if (m_colliderGroundfilter > 2)
303 m_colliderGroundfilter = 2;
304 }
305 else
306 {
307 m_colliderGroundfilter--;
308 if (m_colliderGroundfilter < 0)
309 m_colliderGroundfilter = 0;
310 }
311
312 if (m_colliderGroundfilter == 0)
313 m_iscollidingGround = false;
314 else
315 m_iscollidingGround = true;
316 */
317 }
318
319 }
320
321 /// <summary>
322 /// Returns if the avatar is colliding with an object
323 /// </summary>
324 public override bool CollidingObj
325 {
326 get { return m_iscollidingObj; }
327 set
328 {
329 // Ubit filter this also
330 if (value)
331 {
332 m_colliderObjectfilter += 2;
333 if (m_colliderObjectfilter > 2)
334 m_colliderObjectfilter = 2;
335 }
336 else
337 {
338 m_colliderObjectfilter--;
339 if (m_colliderObjectfilter < 0)
340 m_colliderObjectfilter = 0;
341 }
342
343 if (m_colliderObjectfilter == 0)
344 m_iscollidingObj = false;
345 else
346 m_iscollidingObj = true;
347
348 // m_iscollidingObj = value;
349
350 if (m_iscollidingObj)
351 m_pidControllerActive = false;
352 else
353 m_pidControllerActive = true;
354 }
355 }
356
357 /// <summary>
358 /// turn the PID controller on or off.
359 /// The PID Controller will turn on all by itself in many situations
360 /// </summary>
361 /// <param name="status"></param>
362 public void SetPidStatus(bool status)
363 {
364 m_pidControllerActive = status;
365 }
366
367 public override bool Stopped
368 {
369 get { return _zeroFlag; }
370 }
371
372 /// <summary>
373 /// This 'puts' an avatar somewhere in the physics space.
374 /// Not really a good choice unless you 'know' it's a good
375 /// spot otherwise you're likely to orbit the avatar.
376 /// </summary>
377 public override Vector3 Position
378 {
379 get { return _position; }
380 set
381 {
382 if (value.IsFinite())
383 {
384 if (value.Z > 9999999f)
385 {
386 value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
387 }
388 if (value.Z < -100f)
389 {
390 value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
391 }
392 AddChange(changes.Position, value);
393 }
394 else
395 {
396 m_log.Warn("[PHYSICS]: Got a NaN Position from Scene on a Character");
397 }
398 }
399 }
400
401 public override Vector3 RotationalVelocity
402 {
403 get { return m_rotationalVelocity; }
404 set { m_rotationalVelocity = value; }
405 }
406
407 /// <summary>
408 /// This property sets the height of the avatar only. We use the height to make sure the avatar stands up straight
409 /// and use it to offset landings properly
410 /// </summary>
411 public override Vector3 Size
412 {
413 get {
414 float d = CAPSULE_RADIUS * 2;
415 return new Vector3(d, d, (CAPSULE_LENGTH +d)/1.15f); }
416 set
417 {
418 if (value.IsFinite())
419 {
420 AddChange(changes.Size, value);
421 }
422 else
423 {
424 m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
425 }
426 }
427 }
428
429 /// <summary>
430 /// This creates the Avatar's physical Surrogate at the position supplied
431 /// </summary>
432 /// <param name="npositionX"></param>
433 /// <param name="npositionY"></param>
434 /// <param name="npositionZ"></param>
435
436 //
437 /// <summary>
438 /// Uses the capped cyllinder volume formula to calculate the avatar's mass.
439 /// This may be used in calculations in the scene/scenepresence
440 /// </summary>
441 public override float Mass
442 {
443 get
444 {
445 float AVvolume = (float)(Math.PI * CAPSULE_RADIUS * CAPSULE_RADIUS * (1.3333333333f * CAPSULE_RADIUS + CAPSULE_LENGTH));
446 return m_density * AVvolume;
447 }
448 }
449 public override void link(PhysicsActor obj)
450 {
451
452 }
453
454 public override void delink()
455 {
456
457 }
458
459 public override void LockAngularMotion(Vector3 axis)
460 {
461
462 }
463
464
465 public override Vector3 Force
466 {
467 get { return _target_velocity; }
468 set { return; }
469 }
470
471 public override int VehicleType
472 {
473 get { return 0; }
474 set { return; }
475 }
476
477 public override void VehicleFloatParam(int param, float value)
478 {
479
480 }
481
482 public override void VehicleVectorParam(int param, Vector3 value)
483 {
484
485 }
486
487 public override void VehicleRotationParam(int param, Quaternion rotation)
488 {
489
490 }
491
492 public override void VehicleFlags(int param, bool remove)
493 {
494
495 }
496
497 public override void SetVolumeDetect(int param)
498 {
499
500 }
501
502 public override Vector3 CenterOfMass
503 {
504 get
505 {
506 Vector3 pos = _position;
507 return pos;
508 }
509 }
510
511 public override Vector3 GeometricCenter
512 {
513 get
514 {
515 Vector3 pos = _position;
516 return pos;
517 }
518 }
519
520 //UBit mess
521 /* for later use
522 public override Vector3 PrimOOBsize
523 {
524 get
525 {
526 Vector3 s=Size;
527 s.X *=0.5f;
528 s.Y *=0.5f;
529 s.Z *=0.5f;
530 return s;
531 }
532 }
533
534 public override Vector3 PrimOOBoffset
535 {
536 get
537 {
538 return Vector3.Zero;
539 }
540 }
541 */
542
543 public override PrimitiveBaseShape Shape
544 {
545 set { return; }
546 }
547
548 public override Vector3 Velocity
549 {
550 get
551 {
552 return _velocity;
553 }
554 set
555 {
556 if (value.IsFinite())
557 {
558 AddChange(changes.Velocity, value);
559 }
560 else
561 {
562 m_log.Warn("[PHYSICS]: Got a NaN velocity from Scene in a Character");
563 }
564 }
565 }
566
567 public override Vector3 Torque
568 {
569 get { return Vector3.Zero; }
570 set { return; }
571 }
572
573 public override float CollisionScore
574 {
575 get { return 0f; }
576 set { }
577 }
578
579 public override bool Kinematic
580 {
581 get { return false; }
582 set { }
583 }
584
585 public override Quaternion Orientation
586 {
587 get { return Quaternion.Identity; }
588 set
589 {
590 }
591 }
592
593 public override Vector3 Acceleration
594 {
595 get { return _acceleration; }
596 set { }
597 }
598
599 public void SetAcceleration(Vector3 accel)
600 {
601 m_pidControllerActive = true;
602 _acceleration = accel;
603 }
604
605 /// <summary>
606 /// Adds the force supplied to the Target Velocity
607 /// The PID controller takes this target velocity and tries to make it a reality
608 /// </summary>
609 /// <param name="force"></param>
610 public override void AddForce(Vector3 force, bool pushforce)
611 {
612 if (force.IsFinite())
613 {
614 if (pushforce)
615 {
616 AddChange(changes.Force, force * m_density / (_parent_scene.ODE_STEPSIZE * 28f));
617 }
618 else
619 {
620 AddChange(changes.Velocity, force);
621 }
622 }
623 else
624 {
625 m_log.Warn("[PHYSICS]: Got a NaN force applied to a Character");
626 }
627 //m_lastUpdateSent = false;
628 }
629
630 public override void AddAngularForce(Vector3 force, bool pushforce)
631 {
632
633 }
634
635 public override void SetMomentum(Vector3 momentum)
636 {
637 if (momentum.IsFinite())
638 AddChange(changes.Momentum, momentum);
639 }
640
641
642 // WARNING: This MUST NOT be called outside of ProcessTaints, else we can have unsynchronized access
643 // to ODE internals. ProcessTaints is called from within thread-locked Simulate(), so it is the only
644 // place that is safe to call this routine AvatarGeomAndBodyCreation.
645 private void AvatarGeomAndBodyCreation(float npositionX, float npositionY, float npositionZ)
646 {
647 _parent_scene.waitForSpaceUnlock(_parent_scene.ActiveSpace);
648 if (CAPSULE_LENGTH <= 0)
649 {
650 m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!");
651 CAPSULE_LENGTH = 0.01f;
652
653 }
654
655 if (CAPSULE_RADIUS <= 0)
656 {
657 m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!");
658 CAPSULE_RADIUS = 0.01f;
659
660 }
661 Shell = d.CreateCapsule(_parent_scene.ActiveSpace, CAPSULE_RADIUS, CAPSULE_LENGTH);
662
663 d.GeomSetCategoryBits(Shell, (uint)m_collisionCategories);
664 d.GeomSetCollideBits(Shell, (uint)m_collisionFlags);
665
666 d.MassSetCapsule(out ShellMass, m_density, 3, CAPSULE_RADIUS, CAPSULE_LENGTH);
667
668 m_mass = ShellMass.mass; // update mass
669
670 // rescale PID parameters
671 PID_D = _parent_scene.avPIDD;
672 PID_P = _parent_scene.avPIDP;
673
674 // rescale PID parameters so that this aren't affected by mass
675 // and so don't get unstable for some masses
676 // also scale by ode time step so you don't need to refix them
677
678 PID_D /= 50 * 80; //scale to original mass of around 80 and 50 ODE fps
679 PID_D *= m_mass / _parent_scene.ODE_STEPSIZE;
680 PID_P /= 50 * 80;
681 PID_P *= m_mass / _parent_scene.ODE_STEPSIZE;
682
683 Body = d.BodyCreate(_parent_scene.world);
684
685 _zeroFlag = false;
686 m_pidControllerActive = true;
687 m_freemove = false;
688
689 d.BodySetAutoDisableFlag(Body, false);
690 d.BodySetPosition(Body, npositionX, npositionY, npositionZ);
691
692 _position.X = npositionX;
693 _position.Y = npositionY;
694 _position.Z = npositionZ;
695
696 d.BodySetMass(Body, ref ShellMass);
697 d.GeomSetBody(Shell, Body);
698
699 // The purpose of the AMotor here is to keep the avatar's physical
700 // surrogate from rotating while moving
701 Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
702 d.JointAttach(Amotor, Body, IntPtr.Zero);
703
704 d.JointSetAMotorMode(Amotor, 0);
705 d.JointSetAMotorNumAxes(Amotor, 3);
706 d.JointSetAMotorAxis(Amotor, 0, 0, 1, 0, 0);
707 d.JointSetAMotorAxis(Amotor, 1, 0, 0, 1, 0);
708 d.JointSetAMotorAxis(Amotor, 2, 0, 0, 0, 1);
709
710 d.JointSetAMotorAngle(Amotor, 0, 0);
711 d.JointSetAMotorAngle(Amotor, 1, 0);
712 d.JointSetAMotorAngle(Amotor, 2, 0);
713
714 d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM, 0f); // make it HARD
715 d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM2, 0f);
716 d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM3, 0f);
717 d.JointSetAMotorParam(Amotor, (int)dParam.StopERP, 0.8f);
718 d.JointSetAMotorParam(Amotor, (int)dParam.StopERP2, 0.8f);
719 d.JointSetAMotorParam(Amotor, (int)dParam.StopERP3, 0.8f);
720
721 // These lowstops and high stops are effectively (no wiggle room)
722 d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -1e-5f);
723 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 1e-5f);
724 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -1e-5f);
725 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 1e-5f);
726 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -1e-5f);
727 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 1e-5f);
728
729 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel, 0);
730 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel2, 0);
731 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel3, 0);
732
733 d.JointSetAMotorParam(Amotor, (int)dParam.FMax, 5e6f);
734 d.JointSetAMotorParam(Amotor, (int)dParam.FMax2, 5e6f);
735 d.JointSetAMotorParam(Amotor, (int)dParam.FMax3, 5e6f);
736 }
737
738 /// <summary>
739 /// Destroys the avatar body and geom
740
741 private void AvatarGeomAndBodyDestroy()
742 {
743 // Kill the Amotor
744 if (Amotor != IntPtr.Zero)
745 {
746 d.JointDestroy(Amotor);
747 Amotor = IntPtr.Zero;
748 }
749
750 if (Body != IntPtr.Zero)
751 {
752 //kill the body
753 d.BodyDestroy(Body);
754 Body = IntPtr.Zero;
755 }
756
757 //kill the Geometry
758 if (Shell != IntPtr.Zero)
759 {
760 _parent_scene.geom_name_map.Remove(Shell);
761 _parent_scene.waitForSpaceUnlock(_parent_scene.ActiveSpace);
762 d.GeomDestroy(Shell);
763 Shell = IntPtr.Zero;
764 }
765 }
766
767 /// <summary>
768 /// Called from Simulate
769 /// This is the avatar's movement control + PID Controller
770 /// </summary>
771 /// <param name="timeStep"></param>
772 public void Move(float timeStep, List<OdeCharacter> defects)
773 {
774 if (Body == IntPtr.Zero)
775 return;
776
777 d.Vector3 dtmp = d.BodyGetPosition(Body);
778 Vector3 localpos = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
779
780 // the Amotor still lets avatar rotation to drift during colisions
781 // so force it back to identity
782
783 d.Quaternion qtmp;
784 qtmp.W = 1;
785 qtmp.X = 0;
786 qtmp.Y = 0;
787 qtmp.Z = 0;
788 d.BodySetQuaternion(Body, ref qtmp);
789
790 if (m_pidControllerActive == false)
791 {
792 _zeroPosition = localpos;
793 }
794
795 if (!localpos.IsFinite())
796 {
797 m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
798 defects.Add(this);
799 // _parent_scene.RemoveCharacter(this);
800
801 // destroy avatar capsule and related ODE data
802 AvatarGeomAndBodyDestroy();
803 return;
804 }
805
806 // check outbounds forcing to be in world
807 bool fixbody = false;
808 if (localpos.X < 0.0f)
809 {
810 fixbody = true;
811 localpos.X = 0.1f;
812 }
813 else if (localpos.X > _parent_scene.WorldExtents.X - 0.1f)
814 {
815 fixbody = true;
816 localpos.X = _parent_scene.WorldExtents.X - 0.1f;
817 }
818 if (localpos.Y < 0.0f)
819 {
820 fixbody = true;
821 localpos.Y = 0.1f;
822 }
823 else if (localpos.Y > _parent_scene.WorldExtents.Y - 0.1)
824 {
825 fixbody = true;
826 localpos.Y = _parent_scene.WorldExtents.Y - 0.1f;
827 }
828 if (fixbody)
829 {
830 m_freemove = false;
831 d.BodySetPosition(Body, localpos.X, localpos.Y, localpos.Z);
832 }
833
834 float breakfactor;
835
836 Vector3 vec = Vector3.Zero;
837 dtmp = d.BodyGetLinearVel(Body);
838 Vector3 vel = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
839 float velLengthSquared = vel.LengthSquared();
840
841 float movementdivisor = 1f;
842 //Ubit change divisions into multiplications below
843 if (!m_alwaysRun)
844 movementdivisor = 1 / walkDivisor;
845 else
846 movementdivisor = 1 / runDivisor;
847
848 //******************************************
849 // colide with land
850 d.AABB aabb;
851 d.GeomGetAABB(Shell, out aabb);
852 float chrminZ = aabb.MinZ;
853
854 Vector3 posch = localpos;
855
856 float ftmp;
857
858 if (flying)
859 {
860 ftmp = timeStep;
861 posch.X += vel.X * ftmp;
862 posch.Y += vel.Y * ftmp;
863 }
864
865 float terrainheight = _parent_scene.GetTerrainHeightAtXY(posch.X, posch.Y);
866 if (chrminZ < terrainheight)
867 {
868 float depth = terrainheight - chrminZ;
869 if (!flying)
870 {
871 vec.Z = -vel.Z * PID_D * 1.5f + depth * PID_P * 50;
872 }
873 else
874 vec.Z = depth * PID_P * 50;
875
876 if (depth < 0.1f)
877 {
878 m_colliderGroundfilter++;
879 if (m_colliderGroundfilter > 2)
880 {
881 m_iscolliding = true;
882 m_colliderfilter = 2;
883
884 if (m_colliderGroundfilter > 10)
885 {
886 m_colliderGroundfilter = 10;
887 m_freemove = false;
888 }
889
890 m_iscollidingGround = true;
891
892 ContactPoint contact = new ContactPoint();
893 contact.PenetrationDepth = depth;
894 contact.Position.X = localpos.X;
895 contact.Position.Y = localpos.Y;
896 contact.Position.Z = chrminZ;
897 contact.SurfaceNormal.X = 0f;
898 contact.SurfaceNormal.Y = 0f;
899 contact.SurfaceNormal.Z = -1f;
900 AddCollisionEvent(0, contact);
901
902 vec.Z *= 0.5f;
903 }
904 }
905
906 else
907 {
908 m_colliderGroundfilter = 0;
909 m_iscollidingGround = false;
910 }
911 }
912 else
913 {
914 m_colliderGroundfilter = 0;
915 m_iscollidingGround = false;
916 }
917
918 //******************************************
919
920 bool tviszero = (_target_velocity.X == 0.0f && _target_velocity.Y == 0.0f && _target_velocity.Z == 0.0f);
921
922 // if (!tviszero || m_iscolliding || velLengthSquared <0.01)
923 if (!tviszero)
924 m_freemove = false;
925
926 if (!m_freemove)
927 {
928
929 // if velocity is zero, use position control; otherwise, velocity control
930 if (tviszero && m_iscolliding)
931 {
932 // keep track of where we stopped. No more slippin' & slidin'
933 if (!_zeroFlag)
934 {
935 _zeroFlag = true;
936 _zeroPosition = localpos;
937 }
938 if (m_pidControllerActive)
939 {
940 // We only want to deactivate the PID Controller if we think we want to have our surrogate
941 // react to the physics scene by moving it's position.
942 // Avatar to Avatar collisions
943 // Prim to avatar collisions
944
945 vec.X = -vel.X * PID_D + (_zeroPosition.X - localpos.X) * (PID_P * 2);
946 vec.Y = -vel.Y * PID_D + (_zeroPosition.Y - localpos.Y) * (PID_P * 2);
947 if (flying)
948 {
949 vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P;
950 }
951 }
952 //PidStatus = true;
953 }
954 else
955 {
956 m_pidControllerActive = true;
957 _zeroFlag = false;
958
959 if (m_iscolliding)
960 {
961 if (!flying)
962 {
963 if (_target_velocity.Z > 0.0f)
964 {
965 // We're colliding with something and we're not flying but we're moving
966 // This means we're walking or running. JUMPING
967 vec.Z += (_target_velocity.Z - vel.Z) * PID_D * 1.2f;// +(_zeroPosition.Z - localpos.Z) * PID_P;
968 }
969 // We're standing on something
970 vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D);
971 vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D);
972 }
973 else
974 {
975 // We're flying and colliding with something
976 vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D * 0.0625f);
977 vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D * 0.0625f);
978 vec.Z += (_target_velocity.Z - vel.Z) * (PID_D);
979 }
980 }
981 else // ie not colliding
982 {
983 if (flying) //(!m_iscolliding && flying)
984 {
985 // we're in mid air suspended
986 vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D * 1.667f);
987 vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D * 1.667f);
988 vec.Z += (_target_velocity.Z - vel.Z) * (PID_D);
989 }
990
991 else
992 {
993 // we're not colliding and we're not flying so that means we're falling!
994 // m_iscolliding includes collisions with the ground.
995
996 // d.Vector3 pos = d.BodyGetPosition(Body);
997 vec.X = (_target_velocity.X - vel.X) * PID_D * 0.833f;
998 vec.Y = (_target_velocity.Y - vel.Y) * PID_D * 0.833f;
999 }
1000 }
1001 }
1002
1003 if (velLengthSquared > 2500.0f) // 50m/s apply breaks
1004 {
1005 breakfactor = 0.16f * m_mass;
1006 vec.X -= breakfactor * vel.X;
1007 vec.Y -= breakfactor * vel.Y;
1008 vec.Z -= breakfactor * vel.Z;
1009 }
1010 }
1011 else
1012 {
1013 breakfactor = m_mass;
1014 vec.X -= breakfactor * vel.X;
1015 vec.Y -= breakfactor * vel.Y;
1016 if (flying)
1017 vec.Z -= breakfactor * vel.Z;
1018 else
1019 vec.Z -= .5f* m_mass * vel.Z;
1020 }
1021
1022 if (flying)
1023 {
1024 vec.Z -= _parent_scene.gravityz * m_mass;
1025
1026 //Added for auto fly height. Kitto Flora
1027 float target_altitude = _parent_scene.GetTerrainHeightAtXY(localpos.X, localpos.Y) + MinimumGroundFlightOffset;
1028
1029 if (localpos.Z < target_altitude)
1030 {
1031 vec.Z += (target_altitude - localpos.Z) * PID_P * 5.0f;
1032 }
1033 // end add Kitto Flora
1034 }
1035
1036 if (vec.IsFinite())
1037 {
1038 if (vec.X != 0 || vec.Y !=0 || vec.Z !=0)
1039 d.BodyAddForce(Body, vec.X, vec.Y, vec.Z);
1040 }
1041 else
1042 {
1043 m_log.Warn("[PHYSICS]: Got a NaN force vector in Move()");
1044 m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
1045 defects.Add(this);
1046 // _parent_scene.RemoveCharacter(this);
1047 // destroy avatar capsule and related ODE data
1048 AvatarGeomAndBodyDestroy();
1049 return;
1050 }
1051
1052 // update our local ideia of position velocity and aceleration
1053 _position = localpos;
1054 if (_zeroFlag)
1055 {
1056 _velocity = Vector3.Zero;
1057 _acceleration = Vector3.Zero;
1058 }
1059 else
1060 {
1061 _acceleration = _velocity; // previus velocity
1062 _velocity = vel;
1063 _acceleration = (vel - _acceleration) / timeStep;
1064 }
1065
1066 }
1067
1068 /// <summary>
1069 /// Updates the reported position and velocity.
1070 /// Used to copy variables from unmanaged space at heartbeat rate and also trigger scene updates acording
1071 /// also outbounds checking
1072 /// copy and outbounds now done in move(..) at ode rate
1073 ///
1074 /// </summary>
1075 public void UpdatePositionAndVelocity()
1076 {
1077 return;
1078
1079// if (Body == IntPtr.Zero)
1080// return;
1081
1082 }
1083
1084 /// <summary>
1085 /// Cleanup the things we use in the scene.
1086 /// </summary>
1087 public void Destroy()
1088 {
1089 AddChange(changes.Remove, null);
1090 }
1091
1092 public override void CrossingFailure()
1093 {
1094 }
1095
1096 public override Vector3 PIDTarget { set { return; } }
1097 public override bool PIDActive { set { return; } }
1098 public override float PIDTau { set { return; } }
1099
1100 public override float PIDHoverHeight { set { return; } }
1101 public override bool PIDHoverActive { set { return; } }
1102 public override PIDHoverType PIDHoverType { set { return; } }
1103 public override float PIDHoverTau { set { return; } }
1104
1105 public override Quaternion APIDTarget { set { return; } }
1106
1107 public override bool APIDActive { set { return; } }
1108
1109 public override float APIDStrength { set { return; } }
1110
1111 public override float APIDDamping { set { return; } }
1112
1113
1114 public override void SubscribeEvents(int ms)
1115 {
1116 m_requestedUpdateFrequency = ms;
1117 m_eventsubscription = ms;
1118 _parent_scene.AddCollisionEventReporting(this);
1119 m_haseventsubscription = true;
1120 }
1121
1122 public override void UnSubscribeEvents()
1123 {
1124 m_haseventsubscription = false;
1125 _parent_scene.RemoveCollisionEventReporting(this);
1126 m_requestedUpdateFrequency = 0;
1127 m_eventsubscription = 0;
1128 }
1129
1130 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
1131 {
1132 if (m_haseventsubscription)
1133 {
1134 // m_log.DebugFormat(
1135 // "[PHYSICS]: Adding collision event for {0}, collidedWith {1}, contact {2}", "", CollidedWith, contact);
1136
1137 CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
1138 }
1139 }
1140
1141 public void SendCollisions()
1142 {
1143 if (m_haseventsubscription && m_eventsubscription > m_requestedUpdateFrequency)
1144 {
1145 if (CollisionEventsThisFrame != null)
1146 {
1147 base.SendCollisionUpdate(CollisionEventsThisFrame);
1148 }
1149 CollisionEventsThisFrame = new CollisionEventUpdate();
1150 m_eventsubscription = 0;
1151 }
1152 }
1153
1154 public override bool SubscribedEvents()
1155 {
1156 return m_haseventsubscription;
1157 }
1158
1159 private void changePhysicsStatus(bool NewStatus)
1160 {
1161 if (NewStatus != m_isPhysical)
1162 {
1163 if (NewStatus)
1164 {
1165 // Create avatar capsule and related ODE data
1166 if ((Shell != IntPtr.Zero))
1167 {
1168 // a lost shell ?
1169 m_log.Warn("[PHYSICS]: re-creating the following avatar ODE data, even though it already exists - "
1170 + (Shell != IntPtr.Zero ? "Shell " : "")
1171 + (Body != IntPtr.Zero ? "Body " : "")
1172 + (Amotor != IntPtr.Zero ? "Amotor " : ""));
1173 AvatarGeomAndBodyDestroy();
1174 }
1175
1176 AvatarGeomAndBodyCreation(_position.X, _position.Y, _position.Z);
1177 _parent_scene.geom_name_map[Shell] = m_name;
1178 _parent_scene.actor_name_map[Shell] = (PhysicsActor)this;
1179 _parent_scene.AddCharacter(this);
1180 }
1181 else
1182 {
1183 _parent_scene.RemoveCharacter(this);
1184 // destroy avatar capsule and related ODE data
1185 AvatarGeomAndBodyDestroy();
1186 }
1187
1188 m_isPhysical = NewStatus;
1189 }
1190 }
1191
1192 private void changeAdd()
1193 {
1194 changePhysicsStatus(true);
1195 }
1196
1197 private void changeRemove()
1198 {
1199 changePhysicsStatus(false);
1200 }
1201
1202 private void changeShape(PrimitiveBaseShape arg)
1203 {
1204 }
1205
1206 private void changeSize(Vector3 Size)
1207 {
1208 if (Size.IsFinite())
1209 {
1210 float caplen = Size.Z;
1211
1212 caplen = caplen * 1.15f - CAPSULE_RADIUS * 2.0f;
1213
1214 if (caplen != CAPSULE_LENGTH)
1215 {
1216 if (Shell != IntPtr.Zero && Body != IntPtr.Zero && Amotor != IntPtr.Zero)
1217 {
1218 AvatarGeomAndBodyDestroy();
1219
1220 float prevCapsule = CAPSULE_LENGTH;
1221 CAPSULE_LENGTH = caplen;
1222
1223 AvatarGeomAndBodyCreation(_position.X, _position.Y,
1224 _position.Z + (CAPSULE_LENGTH - prevCapsule) * 0.5f);
1225
1226 Velocity = Vector3.Zero;
1227
1228 _parent_scene.geom_name_map[Shell] = m_name;
1229 _parent_scene.actor_name_map[Shell] = (PhysicsActor)this;
1230 }
1231 else
1232 {
1233 m_log.Warn("[PHYSICS]: trying to change capsule size, but the following ODE data is missing - "
1234 + (Shell == IntPtr.Zero ? "Shell " : "")
1235 + (Body == IntPtr.Zero ? "Body " : "")
1236 + (Amotor == IntPtr.Zero ? "Amotor " : ""));
1237 }
1238 }
1239
1240 m_pidControllerActive = true;
1241 }
1242 else
1243 {
1244 m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
1245 }
1246 }
1247
1248 private void changePosition( Vector3 newPos)
1249 {
1250 if (Body != IntPtr.Zero)
1251 d.BodySetPosition(Body, newPos.X, newPos.Y, newPos.Z);
1252 _position = newPos;
1253 m_pidControllerActive = true;
1254 }
1255
1256 private void changeOrientation(Quaternion newOri)
1257 {
1258 }
1259
1260 private void changeVelocity(Vector3 newVel)
1261 {
1262 m_pidControllerActive = true;
1263 _target_velocity = newVel;
1264 }
1265
1266 private void changeSetTorque(Vector3 newTorque)
1267 {
1268 }
1269
1270 private void changeAddForce(Vector3 newForce)
1271 {
1272 }
1273
1274 private void changeAddAngularForce(Vector3 arg)
1275 {
1276 }
1277
1278 private void changeAngularLock(Vector3 arg)
1279 {
1280 }
1281
1282 private void changeFloatOnWater(bool arg)
1283 {
1284 }
1285
1286 private void changeVolumedetetion(bool arg)
1287 {
1288 }
1289
1290 private void changeSelectedStatus(bool arg)
1291 {
1292 }
1293
1294 private void changeDisable(bool arg)
1295 {
1296 }
1297
1298 private void changeBuilding(bool arg)
1299 {
1300 }
1301
1302 private void setFreeMove()
1303 {
1304 m_pidControllerActive = true;
1305 _zeroFlag = false;
1306 _target_velocity = Vector3.Zero;
1307 m_freemove = true;
1308 m_colliderfilter = -2;
1309 m_colliderObjectfilter = -2;
1310 m_colliderGroundfilter = -2;
1311
1312 m_iscolliding = false;
1313 m_iscollidingGround = false;
1314 m_iscollidingObj = false;
1315
1316 CollisionEventsThisFrame = new CollisionEventUpdate();
1317 m_eventsubscription = 0;
1318 }
1319
1320 private void changeForce(Vector3 newForce)
1321 {
1322 setFreeMove();
1323
1324 if (Body != IntPtr.Zero)
1325 {
1326 if (newForce.X != 0f || newForce.Y != 0f || newForce.Z != 0)
1327 d.BodyAddForce(Body, newForce.X, newForce.Y, newForce.Z);
1328 }
1329 }
1330
1331 // for now momentum is actually velocity
1332 private void changeMomentum(Vector3 newmomentum)
1333 {
1334 _velocity = newmomentum;
1335 setFreeMove();
1336
1337 if (Body != IntPtr.Zero)
1338 d.BodySetLinearVel(Body, newmomentum.X, newmomentum.Y, newmomentum.Z);
1339 }
1340
1341 private void donullchange()
1342 {
1343 }
1344
1345 public bool DoAChange(changes what, object arg)
1346 {
1347 if (Shell == IntPtr.Zero && what != changes.Add && what != changes.Remove)
1348 {
1349 return false;
1350 }
1351
1352 // nasty switch
1353 switch (what)
1354 {
1355 case changes.Add:
1356 changeAdd();
1357 break;
1358 case changes.Remove:
1359 changeRemove();
1360 break;
1361
1362 case changes.Position:
1363 changePosition((Vector3)arg);
1364 break;
1365
1366 case changes.Orientation:
1367 changeOrientation((Quaternion)arg);
1368 break;
1369
1370 case changes.PosOffset:
1371 donullchange();
1372 break;
1373
1374 case changes.OriOffset:
1375 donullchange();
1376 break;
1377
1378 case changes.Velocity:
1379 changeVelocity((Vector3)arg);
1380 break;
1381
1382 // case changes.Acceleration:
1383 // changeacceleration((Vector3)arg);
1384 // break;
1385 // case changes.AngVelocity:
1386 // changeangvelocity((Vector3)arg);
1387 // break;
1388
1389 case changes.Force:
1390 changeForce((Vector3)arg);
1391 break;
1392
1393 case changes.Torque:
1394 changeSetTorque((Vector3)arg);
1395 break;
1396
1397 case changes.AddForce:
1398 changeAddForce((Vector3)arg);
1399 break;
1400
1401 case changes.AddAngForce:
1402 changeAddAngularForce((Vector3)arg);
1403 break;
1404
1405 case changes.AngLock:
1406 changeAngularLock((Vector3)arg);
1407 break;
1408
1409 case changes.Size:
1410 changeSize((Vector3)arg);
1411 break;
1412
1413 case changes.Momentum:
1414 changeMomentum((Vector3)arg);
1415 break;
1416/* not in use for now
1417 case changes.Shape:
1418 changeShape((PrimitiveBaseShape)arg);
1419 break;
1420
1421 case changes.CollidesWater:
1422 changeFloatOnWater((bool)arg);
1423 break;
1424
1425 case changes.VolumeDtc:
1426 changeVolumedetetion((bool)arg);
1427 break;
1428
1429 case changes.Physical:
1430 changePhysicsStatus((bool)arg);
1431 break;
1432
1433 case changes.Selected:
1434 changeSelectedStatus((bool)arg);
1435 break;
1436
1437 case changes.disabled:
1438 changeDisable((bool)arg);
1439 break;
1440
1441 case changes.building:
1442 changeBuilding((bool)arg);
1443 break;
1444*/
1445 case changes.Null:
1446 donullchange();
1447 break;
1448
1449 default:
1450 donullchange();
1451 break;
1452 }
1453 return false;
1454 }
1455
1456 public void AddChange(changes what, object arg)
1457 {
1458 _parent_scene.AddChange((PhysicsActor)this, what, arg);
1459 }
1460
1461
1462 internal void AddCollisionFrameTime(int p)
1463 {
1464 // protect it from overflow crashing
1465 if (m_eventsubscription + p >= int.MaxValue)
1466 m_eventsubscription = 0;
1467 m_eventsubscription += p;
1468 }
1469 }
1470}
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs
new file mode 100644
index 0000000..d106677
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs
@@ -0,0 +1,1003 @@
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/* Revised Aug, Sept 2009 by Kitto Flora. ODEDynamics.cs replaces
29 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
30 * ODEPrim.cs contains methods dealing with Prim editing, Prim
31 * characteristics and Kinetic motion.
32 * ODEDynamics.cs contains methods dealing with Prim Physical motion
33 * (dynamics) and the associated settings. Old Linear and angular
34 * motors for dynamic motion have been replace with MoveLinear()
35 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
36 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
37 * switch between 'VEHICLE' parameter use and general dynamics
38 * settings use.
39 */
40
41// Extensive change Ubit 2012
42
43using System;
44using System.Collections.Generic;
45using System.Reflection;
46using System.Runtime.InteropServices;
47using log4net;
48using OpenMetaverse;
49using OdeAPI;
50using OpenSim.Framework;
51using OpenSim.Region.Physics.Manager;
52
53namespace OpenSim.Region.Physics.OdePlugin
54{
55 public class ODEDynamics
56 {
57 public Vehicle Type
58 {
59 get { return m_type; }
60 }
61
62 private OdePrim rootPrim;
63 private OdeScene _pParentScene;
64
65 // Vehicle properties
66 private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier
67 private Quaternion m_RollreferenceFrame = Quaternion.Identity; // what hell is this ?
68
69 private Vehicle m_type = Vehicle.TYPE_NONE; // If a 'VEHICLE', and what kind
70
71 private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings:
72 // HOVER_TERRAIN_ONLY
73 // HOVER_GLOBAL_HEIGHT
74 // NO_DEFLECTION_UP
75 // HOVER_WATER_ONLY
76 // HOVER_UP_ONLY
77 // LIMIT_MOTOR_UP
78 // LIMIT_ROLL_ONLY
79 private Vector3 m_BlockingEndPoint = Vector3.Zero; // not sl
80
81 // Linear properties
82 private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time
83 private Vector3 m_linearFrictionTimescale = new Vector3(1000, 1000, 1000);
84 private float m_linearMotorDecayTimescale = 120;
85 private float m_linearMotorTimescale = 1000;
86 private Vector3 m_linearMotorOffset = Vector3.Zero;
87
88 //Angular properties
89 private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor
90 private float m_angularMotorTimescale = 1000; // motor angular velocity ramp up rate
91 private float m_angularMotorDecayTimescale = 120; // motor angular velocity decay rate
92 private Vector3 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); // body angular velocity decay rate
93
94 //Deflection properties
95 private float m_angularDeflectionEfficiency = 0;
96 private float m_angularDeflectionTimescale = 1000;
97 private float m_linearDeflectionEfficiency = 0;
98 private float m_linearDeflectionTimescale = 1000;
99
100 //Banking properties
101 private float m_bankingEfficiency = 0;
102 private float m_bankingMix = 0;
103 private float m_bankingTimescale = 1000;
104
105 //Hover and Buoyancy properties
106 private float m_VhoverHeight = 0f;
107 private float m_VhoverEfficiency = 0f;
108 private float m_VhoverTimescale = 1000f;
109 private float m_VehicleBuoyancy = 0f; //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle.
110 // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity)
111 // KF: So far I have found no good method to combine a script-requested .Z velocity and gravity.
112 // Therefore only m_VehicleBuoyancy=1 (0g) will use the script-requested .Z velocity.
113
114 //Attractor properties
115 private float m_verticalAttractionEfficiency = 1.0f; // damped
116 private float m_verticalAttractionTimescale = 1000f; // Timescale > 300 means no vert attractor.
117
118
119 // auxiliar
120 private float m_lmEfect = 0; // current linear motor eficiency
121 private float m_amEfect = 0; // current angular motor eficiency
122 private float m_ffactor = 1.0f;
123
124 private float m_timestep = 0.02f;
125 private float m_invtimestep = 50;
126
127 public float FrictionFactor
128 {
129 get
130 {
131 return m_ffactor;
132 }
133 }
134
135 public ODEDynamics(OdePrim rootp)
136 {
137 rootPrim = rootp;
138 _pParentScene = rootPrim._parent_scene;
139 m_timestep = _pParentScene.ODE_STEPSIZE;
140 m_invtimestep = 1.0f / m_timestep;
141 }
142
143 public void DoSetVehicle(VehicleData vd)
144 {
145 m_type = vd.m_type;
146 m_flags = vd.m_flags;
147
148 // Linear properties
149 m_linearMotorDirection = vd.m_linearMotorDirection;
150
151 m_linearFrictionTimescale = vd.m_linearFrictionTimescale;
152 if (m_linearFrictionTimescale.X < m_timestep) m_linearFrictionTimescale.X = m_timestep;
153 if (m_linearFrictionTimescale.Y < m_timestep) m_linearFrictionTimescale.Y = m_timestep;
154 if (m_linearFrictionTimescale.Z < m_timestep) m_linearFrictionTimescale.Z = m_timestep;
155
156 m_linearMotorDecayTimescale = vd.m_linearMotorDecayTimescale;
157 if (m_linearMotorDecayTimescale < m_timestep) m_linearMotorDecayTimescale = m_timestep;
158 m_linearMotorDecayTimescale *= m_invtimestep;
159
160 m_linearMotorTimescale = vd.m_linearMotorTimescale;
161 if (m_linearMotorTimescale < m_timestep) m_linearMotorTimescale = m_timestep;
162
163 m_linearMotorOffset = vd.m_linearMotorOffset;
164
165 //Angular properties
166 m_angularMotorDirection = vd.m_angularMotorDirection;
167 m_angularMotorTimescale = vd.m_angularMotorTimescale;
168 if (m_angularMotorTimescale < m_timestep) m_angularMotorTimescale = m_timestep;
169
170 m_angularMotorDecayTimescale = vd.m_angularMotorDecayTimescale;
171 if (m_angularMotorDecayTimescale < m_timestep) m_angularMotorDecayTimescale = m_timestep;
172 m_angularMotorDecayTimescale *= m_invtimestep;
173
174 m_angularFrictionTimescale = vd.m_angularFrictionTimescale;
175 if (m_angularFrictionTimescale.X < m_timestep) m_angularFrictionTimescale.X = m_timestep;
176 if (m_angularFrictionTimescale.Y < m_timestep) m_angularFrictionTimescale.Y = m_timestep;
177 if (m_angularFrictionTimescale.Z < m_timestep) m_angularFrictionTimescale.Z = m_timestep;
178
179 //Deflection properties
180 m_angularDeflectionEfficiency = vd.m_angularDeflectionEfficiency;
181 m_angularDeflectionTimescale = vd.m_angularDeflectionTimescale;
182 if (m_angularDeflectionTimescale < m_timestep) m_angularDeflectionTimescale = m_timestep;
183
184 m_linearDeflectionEfficiency = vd.m_linearDeflectionEfficiency;
185 m_linearDeflectionTimescale = vd.m_linearDeflectionTimescale;
186 if (m_linearDeflectionTimescale < m_timestep) m_linearDeflectionTimescale = m_timestep;
187
188 //Banking properties
189 m_bankingEfficiency = vd.m_bankingEfficiency;
190 m_bankingMix = vd.m_bankingMix;
191 m_bankingTimescale = vd.m_bankingTimescale;
192 if (m_bankingTimescale < m_timestep) m_bankingTimescale = m_timestep;
193
194 //Hover and Buoyancy properties
195 m_VhoverHeight = vd.m_VhoverHeight;
196 m_VhoverEfficiency = vd.m_VhoverEfficiency;
197 m_VhoverTimescale = vd.m_VhoverTimescale;
198 if (m_VhoverTimescale < m_timestep) m_VhoverTimescale = m_timestep;
199
200 m_VehicleBuoyancy = vd.m_VehicleBuoyancy;
201
202 //Attractor properties
203 m_verticalAttractionEfficiency = vd.m_verticalAttractionEfficiency;
204 m_verticalAttractionTimescale = vd.m_verticalAttractionTimescale;
205 if (m_verticalAttractionTimescale < m_timestep) m_verticalAttractionTimescale = m_timestep;
206
207 // Axis
208 m_referenceFrame = vd.m_referenceFrame;
209
210 m_lmEfect = 0;
211 m_amEfect = 0;
212 m_ffactor = 1.0f;
213 }
214
215 internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
216 {
217 float len;
218
219 switch (pParam)
220 {
221 case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
222 if (pValue < 0f) pValue = 0f;
223 if (pValue > 1f) pValue = 1f;
224 m_angularDeflectionEfficiency = pValue;
225 break;
226 case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
227 if (pValue < m_timestep) pValue = m_timestep;
228 m_angularDeflectionTimescale = pValue;
229 break;
230 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
231 if (pValue < m_timestep) pValue = m_timestep;
232 else if (pValue > 120) pValue = 120;
233 m_angularMotorDecayTimescale = pValue * m_invtimestep;
234 break;
235 case Vehicle.ANGULAR_MOTOR_TIMESCALE:
236 if (pValue < m_timestep) pValue = m_timestep;
237 m_angularMotorTimescale = pValue;
238 break;
239 case Vehicle.BANKING_EFFICIENCY:
240 if (pValue < -1f) pValue = -1f;
241 if (pValue > 1f) pValue = 1f;
242 m_bankingEfficiency = pValue;
243 break;
244 case Vehicle.BANKING_MIX:
245 if (pValue < 0f) pValue = 0f;
246 if (pValue > 1f) pValue = 1f;
247 m_bankingMix = pValue;
248 break;
249 case Vehicle.BANKING_TIMESCALE:
250 if (pValue < m_timestep) pValue = m_timestep;
251 m_bankingTimescale = pValue;
252 break;
253 case Vehicle.BUOYANCY:
254 if (pValue < -1f) pValue = -1f;
255 if (pValue > 1f) pValue = 1f;
256 m_VehicleBuoyancy = pValue;
257 break;
258 case Vehicle.HOVER_EFFICIENCY:
259 if (pValue < 0f) pValue = 0f;
260 if (pValue > 1f) pValue = 1f;
261 m_VhoverEfficiency = pValue;
262 break;
263 case Vehicle.HOVER_HEIGHT:
264 m_VhoverHeight = pValue;
265 break;
266 case Vehicle.HOVER_TIMESCALE:
267 if (pValue < m_timestep) pValue = m_timestep;
268 m_VhoverTimescale = pValue;
269 break;
270 case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
271 if (pValue < 0f) pValue = 0f;
272 if (pValue > 1f) pValue = 1f;
273 m_linearDeflectionEfficiency = pValue;
274 break;
275 case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
276 if (pValue < m_timestep) pValue = m_timestep;
277 m_linearDeflectionTimescale = pValue;
278 break;
279 case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
280 if (pValue < m_timestep) pValue = m_timestep;
281 else if (pValue > 120) pValue = 120;
282 m_linearMotorDecayTimescale = pValue * m_invtimestep;
283 break;
284 case Vehicle.LINEAR_MOTOR_TIMESCALE:
285 if (pValue < m_timestep) pValue = m_timestep;
286 m_linearMotorTimescale = pValue;
287 break;
288 case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
289 if (pValue < 0f) pValue = 0f;
290 if (pValue > 1f) pValue = 1f;
291 m_verticalAttractionEfficiency = pValue;
292 break;
293 case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
294 if (pValue < m_timestep) pValue = m_timestep;
295 m_verticalAttractionTimescale = pValue;
296 break;
297
298 // These are vector properties but the engine lets you use a single float value to
299 // set all of the components to the same value
300 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
301 if (pValue < m_timestep) pValue = m_timestep;
302 m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
303 break;
304 case Vehicle.ANGULAR_MOTOR_DIRECTION:
305 m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
306 len = m_angularMotorDirection.Length();
307 if (len > 12.566f)
308 m_angularMotorDirection *= (12.566f / len);
309 m_amEfect = 1.0f; // turn it on
310 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
311 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
312 d.BodyEnable(rootPrim.Body);
313 break;
314 case Vehicle.LINEAR_FRICTION_TIMESCALE:
315 if (pValue < m_timestep) pValue = m_timestep;
316 m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
317 break;
318 case Vehicle.LINEAR_MOTOR_DIRECTION:
319 m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
320 len = m_linearMotorDirection.Length();
321 if (len > 30.0f)
322 m_linearMotorDirection *= (30.0f / len);
323 m_lmEfect = 1.0f; // turn it on
324 m_ffactor = 0.01f;
325 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
326 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
327 d.BodyEnable(rootPrim.Body);
328 break;
329 case Vehicle.LINEAR_MOTOR_OFFSET:
330 m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
331 len = m_linearMotorOffset.Length();
332 if (len > 100.0f)
333 m_linearMotorOffset *= (100.0f / len);
334 break;
335 }
336 }//end ProcessFloatVehicleParam
337
338 internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
339 {
340 float len;
341
342 switch (pParam)
343 {
344 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
345 if (pValue.X < m_timestep) pValue.X = m_timestep;
346 if (pValue.Y < m_timestep) pValue.Y = m_timestep;
347 if (pValue.Z < m_timestep) pValue.Z = m_timestep;
348
349 m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
350 break;
351 case Vehicle.ANGULAR_MOTOR_DIRECTION:
352 m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
353 // Limit requested angular speed to 2 rps= 4 pi rads/sec
354 len = m_angularMotorDirection.Length();
355 if (len > 12.566f)
356 m_angularMotorDirection *= (12.566f / len);
357 m_amEfect = 1.0f; // turn it on
358 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
359 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
360 d.BodyEnable(rootPrim.Body);
361 break;
362 case Vehicle.LINEAR_FRICTION_TIMESCALE:
363 if (pValue.X < m_timestep) pValue.X = m_timestep;
364 if (pValue.Y < m_timestep) pValue.Y = m_timestep;
365 if (pValue.Z < m_timestep) pValue.Z = m_timestep;
366 m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
367 break;
368 case Vehicle.LINEAR_MOTOR_DIRECTION:
369 m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
370 len = m_linearMotorDirection.Length();
371 if (len > 30.0f)
372 m_linearMotorDirection *= (30.0f / len);
373 m_lmEfect = 1.0f; // turn it on
374 m_ffactor = 0.01f;
375 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
376 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
377 d.BodyEnable(rootPrim.Body);
378 break;
379 case Vehicle.LINEAR_MOTOR_OFFSET:
380 m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
381 len = m_linearMotorOffset.Length();
382 if (len > 100.0f)
383 m_linearMotorOffset *= (100.0f / len);
384 break;
385 case Vehicle.BLOCK_EXIT:
386 m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
387 break;
388 }
389 }//end ProcessVectorVehicleParam
390
391 internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
392 {
393 switch (pParam)
394 {
395 case Vehicle.REFERENCE_FRAME:
396 m_referenceFrame = Quaternion.Inverse(pValue);
397 break;
398 case Vehicle.ROLL_FRAME:
399 m_RollreferenceFrame = pValue;
400 break;
401 }
402 }//end ProcessRotationVehicleParam
403
404 internal void ProcessVehicleFlags(int pParam, bool remove)
405 {
406 if (remove)
407 {
408 m_flags &= ~((VehicleFlag)pParam);
409 }
410 else
411 {
412 m_flags |= (VehicleFlag)pParam;
413 }
414 }//end ProcessVehicleFlags
415
416 internal void ProcessTypeChange(Vehicle pType)
417 {
418 m_lmEfect = 0;
419 m_amEfect = 0;
420 m_ffactor = 1f;
421
422 m_linearMotorDirection = Vector3.Zero;
423 m_angularMotorDirection = Vector3.Zero;
424
425 m_BlockingEndPoint = Vector3.Zero;
426 m_RollreferenceFrame = Quaternion.Identity;
427 m_linearMotorOffset = Vector3.Zero;
428
429 m_referenceFrame = Quaternion.Identity;
430
431 // Set Defaults For Type
432 m_type = pType;
433 switch (pType)
434 {
435 case Vehicle.TYPE_NONE:
436 m_linearFrictionTimescale = new Vector3(1000, 1000, 1000);
437 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
438 m_linearMotorTimescale = 1000;
439 m_linearMotorDecayTimescale = 120 * m_invtimestep;
440 m_angularMotorTimescale = 1000;
441 m_angularMotorDecayTimescale = 1000 * m_invtimestep;
442 m_VhoverHeight = 0;
443 m_VhoverEfficiency = 1;
444 m_VhoverTimescale = 1000;
445 m_VehicleBuoyancy = 0;
446 m_linearDeflectionEfficiency = 0;
447 m_linearDeflectionTimescale = 1000;
448 m_angularDeflectionEfficiency = 0;
449 m_angularDeflectionTimescale = 1000;
450 m_bankingEfficiency = 0;
451 m_bankingMix = 1;
452 m_bankingTimescale = 1000;
453 m_verticalAttractionEfficiency = 0;
454 m_verticalAttractionTimescale = 1000;
455
456 m_flags = (VehicleFlag)0;
457 break;
458
459 case Vehicle.TYPE_SLED:
460 m_linearFrictionTimescale = new Vector3(30, 1, 1000);
461 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
462 m_linearMotorTimescale = 1000;
463 m_linearMotorDecayTimescale = 120 * m_invtimestep;
464 m_angularMotorTimescale = 1000;
465 m_angularMotorDecayTimescale = 120 * m_invtimestep;
466 m_VhoverHeight = 0;
467 m_VhoverEfficiency = 1;
468 m_VhoverTimescale = 10;
469 m_VehicleBuoyancy = 0;
470 m_linearDeflectionEfficiency = 1;
471 m_linearDeflectionTimescale = 1;
472 m_angularDeflectionEfficiency = 0;
473 m_angularDeflectionTimescale = 1000;
474 m_bankingEfficiency = 0;
475 m_bankingMix = 1;
476 m_bankingTimescale = 10;
477 m_flags &=
478 ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
479 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
480 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
481 break;
482 case Vehicle.TYPE_CAR:
483 m_linearFrictionTimescale = new Vector3(100, 2, 1000);
484 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
485 m_linearMotorTimescale = 1;
486 m_linearMotorDecayTimescale = 60 * m_invtimestep;
487 m_angularMotorTimescale = 1;
488 m_angularMotorDecayTimescale = 0.8f * m_invtimestep;
489 m_VhoverHeight = 0;
490 m_VhoverEfficiency = 0;
491 m_VhoverTimescale = 1000;
492 m_VehicleBuoyancy = 0;
493 m_linearDeflectionEfficiency = 1;
494 m_linearDeflectionTimescale = 2;
495 m_angularDeflectionEfficiency = 0;
496 m_angularDeflectionTimescale = 10;
497 m_verticalAttractionEfficiency = 1f;
498 m_verticalAttractionTimescale = 10f;
499 m_bankingEfficiency = -0.2f;
500 m_bankingMix = 1;
501 m_bankingTimescale = 1;
502 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
503 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY |
504 VehicleFlag.LIMIT_MOTOR_UP | VehicleFlag.HOVER_UP_ONLY);
505 break;
506 case Vehicle.TYPE_BOAT:
507 m_linearFrictionTimescale = new Vector3(10, 3, 2);
508 m_angularFrictionTimescale = new Vector3(10, 10, 10);
509 m_linearMotorTimescale = 5;
510 m_linearMotorDecayTimescale = 60 * m_invtimestep;
511 m_angularMotorTimescale = 4;
512 m_angularMotorDecayTimescale = 4 * m_invtimestep;
513 m_VhoverHeight = 0;
514 m_VhoverEfficiency = 0.5f;
515 m_VhoverTimescale = 2;
516 m_VehicleBuoyancy = 1;
517 m_linearDeflectionEfficiency = 0.5f;
518 m_linearDeflectionTimescale = 3;
519 m_angularDeflectionEfficiency = 0.5f;
520 m_angularDeflectionTimescale = 5;
521 m_verticalAttractionEfficiency = 0.5f;
522 m_verticalAttractionTimescale = 5f;
523 m_bankingEfficiency = -0.3f;
524 m_bankingMix = 0.8f;
525 m_bankingTimescale = 1;
526 m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
527 VehicleFlag.HOVER_GLOBAL_HEIGHT |
528 VehicleFlag.HOVER_UP_ONLY |
529 VehicleFlag.LIMIT_ROLL_ONLY);
530 m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
531 VehicleFlag.LIMIT_MOTOR_UP |
532 VehicleFlag.HOVER_WATER_ONLY);
533 break;
534 case Vehicle.TYPE_AIRPLANE:
535 m_linearFrictionTimescale = new Vector3(200, 10, 5);
536 m_angularFrictionTimescale = new Vector3(20, 20, 20);
537 m_linearMotorTimescale = 2;
538 m_linearMotorDecayTimescale = 60 * m_invtimestep;
539 m_angularMotorTimescale = 4;
540 m_angularMotorDecayTimescale = 8 * m_invtimestep;
541 m_VhoverHeight = 0;
542 m_VhoverEfficiency = 0.5f;
543 m_VhoverTimescale = 1000;
544 m_VehicleBuoyancy = 0;
545 m_linearDeflectionEfficiency = 0.5f;
546 m_linearDeflectionTimescale = 0.5f;
547 m_angularDeflectionEfficiency = 1;
548 m_angularDeflectionTimescale = 2;
549 m_verticalAttractionEfficiency = 0.9f;
550 m_verticalAttractionTimescale = 2f;
551 m_bankingEfficiency = 1;
552 m_bankingMix = 0.7f;
553 m_bankingTimescale = 2;
554 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
555 VehicleFlag.HOVER_TERRAIN_ONLY |
556 VehicleFlag.HOVER_GLOBAL_HEIGHT |
557 VehicleFlag.HOVER_UP_ONLY |
558 VehicleFlag.NO_DEFLECTION_UP |
559 VehicleFlag.LIMIT_MOTOR_UP);
560 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
561 break;
562 case Vehicle.TYPE_BALLOON:
563 m_linearFrictionTimescale = new Vector3(5, 5, 5);
564 m_angularFrictionTimescale = new Vector3(10, 10, 10);
565 m_linearMotorTimescale = 5;
566 m_linearMotorDecayTimescale = 60 * m_invtimestep;
567 m_angularMotorTimescale = 6;
568 m_angularMotorDecayTimescale = 10 * m_invtimestep;
569 m_VhoverHeight = 5;
570 m_VhoverEfficiency = 0.8f;
571 m_VhoverTimescale = 10;
572 m_VehicleBuoyancy = 1;
573 m_linearDeflectionEfficiency = 0;
574 m_linearDeflectionTimescale = 5 * m_invtimestep;
575 m_angularDeflectionEfficiency = 0;
576 m_angularDeflectionTimescale = 5;
577 m_verticalAttractionEfficiency = 0f;
578 m_verticalAttractionTimescale = 1000f;
579 m_bankingEfficiency = 0;
580 m_bankingMix = 0.7f;
581 m_bankingTimescale = 5;
582 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
583 VehicleFlag.HOVER_TERRAIN_ONLY |
584 VehicleFlag.HOVER_UP_ONLY |
585 VehicleFlag.NO_DEFLECTION_UP |
586 VehicleFlag.LIMIT_MOTOR_UP);
587 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY |
588 VehicleFlag.HOVER_GLOBAL_HEIGHT);
589 break;
590 }
591
592 }//end SetDefaultsForType
593
594 internal void Stop()
595 {
596 m_lmEfect = 0;
597 m_amEfect = 0;
598 m_ffactor = 1f;
599 }
600
601 public static Vector3 Xrot(Quaternion rot)
602 {
603 Vector3 vec;
604 rot.Normalize(); // just in case
605 vec.X = 2 * (rot.X * rot.X + rot.W * rot.W) - 1;
606 vec.Y = 2 * (rot.X * rot.Y + rot.Z * rot.W);
607 vec.Z = 2 * (rot.X * rot.Z - rot.Y * rot.W);
608 return vec;
609 }
610
611 public static Vector3 Zrot(Quaternion rot)
612 {
613 Vector3 vec;
614 rot.Normalize(); // just in case
615 vec.X = 2 * (rot.X * rot.Z + rot.Y * rot.W);
616 vec.Y = 2 * (rot.Y * rot.Z - rot.X * rot.W);
617 vec.Z = 2 * (rot.Z * rot.Z + rot.W * rot.W) - 1;
618
619 return vec;
620 }
621
622 private const float pi = (float)Math.PI;
623 private const float halfpi = 0.5f * (float)Math.PI;
624
625 public static Vector3 ubitRot2Euler(Quaternion rot)
626 {
627 // returns roll in X
628 // pitch in Y
629 // yaw in Z
630 Vector3 vec;
631
632 // assuming rot is normalised
633 // rot.Normalize();
634
635 float zX = rot.X * rot.Z + rot.Y * rot.W;
636
637 if (zX < -0.49999f)
638 {
639 vec.X = 0;
640 vec.Y = -halfpi;
641 vec.Z = (float)(-2d * Math.Atan(rot.X / rot.W));
642 }
643 else if (zX > 0.49999f)
644 {
645 vec.X = 0;
646 vec.Y = halfpi;
647 vec.Z = (float)(2d * Math.Atan(rot.X / rot.W));
648 }
649 else
650 {
651 vec.Y = (float)Math.Asin(2 * zX);
652
653 float sqw = rot.W * rot.W;
654
655 float minuszY = rot.X * rot.W - rot.Y * rot.Z;
656 float zZ = rot.Z * rot.Z + sqw - 0.5f;
657
658 vec.X = (float)Math.Atan2(minuszY, zZ);
659
660 float yX = rot.Z * rot.W - rot.X * rot.Y; //( have negative ?)
661 float yY = rot.X * rot.X + sqw - 0.5f;
662 vec.Z = (float)Math.Atan2(yX, yY);
663 }
664 return vec;
665 }
666
667 public static void GetRollPitch(Quaternion rot, out float roll, out float pitch)
668 {
669 // assuming rot is normalised
670 // rot.Normalize();
671
672 float zX = rot.X * rot.Z + rot.Y * rot.W;
673
674 if (zX < -0.49999f)
675 {
676 roll = 0;
677 pitch = -halfpi;
678 }
679 else if (zX > 0.49999f)
680 {
681 roll = 0;
682 pitch = halfpi;
683 }
684 else
685 {
686 pitch = (float)Math.Asin(2 * zX);
687
688 float minuszY = rot.X * rot.W - rot.Y * rot.Z;
689 float zZ = rot.Z * rot.Z + rot.W * rot.W - 0.5f;
690
691 roll = (float)Math.Atan2(minuszY, zZ);
692 }
693 return ;
694 }
695
696 internal void Step()
697 {
698 IntPtr Body = rootPrim.Body;
699
700 d.Quaternion rot = d.BodyGetQuaternion(Body);
701 Quaternion objrotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W); // rotq = rotation of object
702 Quaternion rotq = objrotq; // rotq = rotation of object
703 rotq *= m_referenceFrame; // rotq is now rotation in vehicle reference frame
704 Quaternion irotq = Quaternion.Inverse(rotq);
705
706 d.Vector3 dvtmp;
707 Vector3 tmpV;
708 Vector3 curVel; // velocity in world
709 Vector3 curAngVel; // angular velocity in world
710 Vector3 force = Vector3.Zero; // actually linear aceleration until mult by mass in world frame
711 Vector3 torque = Vector3.Zero;// actually angular aceleration until mult by Inertia in vehicle frame
712 d.Vector3 dtorque = new d.Vector3();
713
714 dvtmp = d.BodyGetLinearVel(Body);
715 curVel.X = dvtmp.X;
716 curVel.Y = dvtmp.Y;
717 curVel.Z = dvtmp.Z;
718 Vector3 curLocalVel = curVel * irotq; // current velocity in local
719
720 dvtmp = d.BodyGetAngularVel(Body);
721 curAngVel.X = dvtmp.X;
722 curAngVel.Y = dvtmp.Y;
723 curAngVel.Z = dvtmp.Z;
724 Vector3 curLocalAngVel = curAngVel * irotq; // current angular velocity in local
725
726 // linear motor
727 if (m_lmEfect > 0.01 && m_linearMotorTimescale < 1000)
728 {
729 tmpV = m_linearMotorDirection - curLocalVel; // velocity error
730 tmpV *= m_lmEfect / m_linearMotorTimescale; // error to correct in this timestep
731 tmpV *= rotq; // to world
732
733 if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != 0)
734 tmpV.Z = 0;
735
736 if (m_linearMotorOffset.X != 0 || m_linearMotorOffset.Y != 0 || m_linearMotorOffset.Z != 0)
737 {
738 // have offset, do it now
739 tmpV *= rootPrim.Mass;
740 d.BodyAddForceAtRelPos(Body, tmpV.X, tmpV.Y, tmpV.Z, m_linearMotorOffset.X, m_linearMotorOffset.Y, m_linearMotorOffset.Z);
741 }
742 else
743 {
744 force.X += tmpV.X;
745 force.Y += tmpV.Y;
746 force.Z += tmpV.Z;
747 }
748 m_lmEfect *= (1.0f - 1.0f / m_linearMotorDecayTimescale);
749
750 m_ffactor = 0.01f + 1e-4f * curVel.LengthSquared();
751 }
752 else
753 {
754 m_lmEfect = 0;
755 m_ffactor = 1f;
756 }
757
758 // friction
759 if (curLocalVel.X != 0 || curLocalVel.Y != 0 || curLocalVel.Z != 0)
760 {
761 tmpV.X = -curLocalVel.X / m_linearFrictionTimescale.X;
762 tmpV.Y = -curLocalVel.Y / m_linearFrictionTimescale.Y;
763 tmpV.Z = -curLocalVel.Z / m_linearFrictionTimescale.Z;
764 tmpV *= rotq; // to world
765 force.X += tmpV.X;
766 force.Y += tmpV.Y;
767 force.Z += tmpV.Z;
768 }
769
770 // hover
771 if (m_VhoverTimescale < 300)
772 {
773 d.Vector3 pos = d.BodyGetPosition(Body);
774
775 float t = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y);
776 float perr;
777
778 // default to global but don't go underground
779 if (t < m_VhoverHeight)
780 perr = m_VhoverHeight - pos.Z;
781 else
782 perr = t - pos.Z; ;
783
784 if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) == 0)
785 {
786 if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0)
787 {
788 perr += _pParentScene.GetWaterLevel();
789 }
790 else if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
791 {
792 perr += t;
793 }
794 else
795 {
796 float w = _pParentScene.GetWaterLevel();
797 if (t > w)
798 perr += t;
799 else
800 perr += w;
801 }
802 }
803 if ((m_flags & VehicleFlag.HOVER_UP_ONLY) == 0 || perr > 0)
804 {
805 force.Z += (perr / m_VhoverTimescale / m_VhoverTimescale - curVel.Z * m_VhoverEfficiency) / m_timestep;
806 force.Z += _pParentScene.gravityz * (1f - m_VehicleBuoyancy);
807 }
808 else // no buoyancy
809 force.Z += _pParentScene.gravityz;
810 }
811 else
812 {
813 // default gravity and Buoyancy
814 force.Z += _pParentScene.gravityz * (1f - m_VehicleBuoyancy);
815 }
816
817 // linear deflection
818 if (m_linearDeflectionEfficiency > 0)
819 {
820 float len = curVel.Length();
821 if (len > 0.01) // if moving
822 {
823
824 Vector3 atAxis;
825 atAxis = Xrot(rotq); // where are we pointing to
826 atAxis *= len; // make it same size as world velocity vector
827
828 tmpV = -atAxis; // oposite direction
829 atAxis -= curVel; // error to one direction
830 len = atAxis.LengthSquared();
831
832 tmpV -= curVel; // error to oposite
833 float lens = tmpV.LengthSquared();
834
835 if (len > 0.01 || lens > 0.01) // do nothing if close enougth
836 {
837 if (len < lens)
838 tmpV = atAxis;
839
840 tmpV *= (m_linearDeflectionEfficiency / m_linearDeflectionTimescale); // error to correct in this timestep
841 force.X += tmpV.X;
842 force.Y += tmpV.Y;
843 if ((m_flags & VehicleFlag.NO_DEFLECTION_UP) == 0)
844 force.Z += tmpV.Z;
845 }
846 }
847 }
848
849 // angular motor
850 if (m_amEfect > 0.01 && m_angularMotorTimescale < 1000)
851 {
852 tmpV = m_angularMotorDirection - curLocalAngVel; // velocity error
853 tmpV *= m_amEfect / m_angularMotorTimescale; // error to correct in this timestep
854 torque.X += tmpV.X;
855 torque.Y += tmpV.Y;
856 torque.Z += tmpV.Z;
857 m_amEfect *= (1 - 1.0f / m_angularMotorDecayTimescale);
858 }
859 else
860 m_amEfect = 0;
861
862 // angular friction
863 if (curLocalAngVel.X != 0 || curLocalAngVel.Y != 0 || curLocalAngVel.Z != 0)
864 {
865 torque.X -= curLocalAngVel.X / m_angularFrictionTimescale.X;
866 torque.Y -= curLocalAngVel.Y / m_angularFrictionTimescale.Y;
867 torque.Z -= curLocalAngVel.Z / m_angularFrictionTimescale.Z;
868 }
869
870 // angular deflection
871 if (m_angularDeflectionEfficiency > 0)
872 {
873 Vector3 dirv;
874
875 if (curLocalVel.X > 0.01f)
876 dirv = curLocalVel;
877 else if (curLocalVel.X < -0.01f)
878 // use oposite
879 dirv = -curLocalVel;
880 else
881 {
882 // make it fall into small positive x case
883 dirv.X = 0.01f;
884 dirv.Y = curLocalVel.Y;
885 dirv.Z = curLocalVel.Z;
886 }
887
888 float ftmp = m_angularDeflectionEfficiency / m_angularDeflectionTimescale;
889
890 if (Math.Abs(dirv.Z) > 0.01)
891 {
892 torque.Y += - (float)Math.Atan2(dirv.Z, dirv.X) * ftmp;
893 }
894
895 if (Math.Abs(dirv.Y) > 0.01)
896 {
897 torque.Z += (float)Math.Atan2(dirv.Y, dirv.X) * ftmp;
898 }
899 }
900
901 // vertical atractor
902 if (m_verticalAttractionTimescale < 300)
903 {
904 float roll;
905 float pitch;
906
907 GetRollPitch(irotq, out roll, out pitch);
908
909 float ftmp = 1.0f / m_verticalAttractionTimescale / m_verticalAttractionTimescale * m_invtimestep;
910 float ftmp2;
911 if (m_bankingEfficiency == 0)
912 ftmp2 = m_verticalAttractionEfficiency * m_invtimestep;
913 else
914 ftmp2 = 0;
915
916 if (roll > halfpi)
917 roll = pi - roll;
918 else if (roll < -halfpi)
919 roll = -pi - roll;
920
921 float effroll = pitch / halfpi;
922 effroll *= effroll;
923 effroll = 1 - effroll;
924 effroll *= roll;
925
926 if (Math.Abs(effroll) > 0.01) // roll
927 {
928 torque.X -= -effroll * ftmp + curLocalAngVel.X * ftmp2;
929 }
930
931 if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) == 0)
932 {
933 float effpitch = roll / halfpi;
934 effpitch *= effpitch;
935 effpitch = 1 - effpitch;
936 effpitch *= pitch;
937
938 if (Math.Abs(effpitch) > 0.01) // pitch
939 {
940 torque.Y -= -effpitch * ftmp + curLocalAngVel.Y * ftmp2;
941 }
942 }
943
944 if (m_bankingEfficiency != 0 && Math.Abs(effroll) > 0.01)
945 {
946
947 float broll = effroll;
948/*
949 if (broll > halfpi)
950 broll = pi - broll;
951 else if (broll < -halfpi)
952 broll = -pi - broll;
953*/
954 broll *= m_bankingEfficiency;
955 if (m_bankingMix != 0)
956 {
957 float vfact = Math.Abs(curLocalVel.X) / 10.0f;
958 if (vfact > 1.0f) vfact = 1.0f;
959
960 if (curLocalVel.X >= 0)
961 broll *= (1 + (vfact - 1) * m_bankingMix);
962 else
963 broll *= -(1 + (vfact - 1) * m_bankingMix);
964 }
965 // make z rot be in world Z not local as seems to be in sl
966
967 broll = broll / m_bankingTimescale;
968
969 ftmp = -Math.Abs(m_bankingEfficiency) / m_bankingTimescale;
970
971 tmpV.X = ftmp * curAngVel.X;
972 tmpV.Y = ftmp * curAngVel.Y;
973 tmpV.Z = broll + ftmp * curAngVel.Z;
974 tmpV *= irotq;
975
976 torque.X += tmpV.X;
977 torque.Y += tmpV.Y;
978 torque.Z += tmpV.Z;
979 }
980 }
981
982 d.Mass dmass;
983 d.BodyGetMass(Body,out dmass);
984
985 if (force.X != 0 || force.Y != 0 || force.Z != 0)
986 {
987 force *= dmass.mass;
988 d.BodySetForce(Body, force.X, force.Y, force.Z);
989 }
990
991 if (torque.X != 0 || torque.Y != 0 || torque.Z != 0)
992 {
993 torque *= m_referenceFrame; // to object frame
994 dtorque.X = torque.X ;
995 dtorque.Y = torque.Y;
996 dtorque.Z = torque.Z;
997
998 d.MultiplyM3V3(out dvtmp, ref dmass.I, ref dtorque);
999 d.BodyAddRelTorque(Body, dvtmp.X, dvtmp.Y, dvtmp.Z); // add torque in object frame
1000 }
1001 }
1002 }
1003}
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
new file mode 100644
index 0000000..c9a453d
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
@@ -0,0 +1,3958 @@
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/* Revision 2011/12 by Ubit Umarov
29 *
30 *
31 */
32
33/*
34 * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces
35 * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
36 * ODEPrim.cs contains methods dealing with Prim editing, Prim
37 * characteristics and Kinetic motion.
38 * ODEDynamics.cs contains methods dealing with Prim Physical motion
39 * (dynamics) and the associated settings. Old Linear and angular
40 * motors for dynamic motion have been replace with MoveLinear()
41 * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
42 * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
43 * switch between 'VEHICLE' parameter use and general dynamics
44 * settings use.
45 */
46
47//#define SPAM
48
49using System;
50using System.Collections.Generic;
51using System.Reflection;
52using System.Runtime.InteropServices;
53using System.Threading;
54using log4net;
55using OpenMetaverse;
56using OdeAPI;
57using OpenSim.Framework;
58using OpenSim.Region.Physics.Manager;
59
60
61namespace OpenSim.Region.Physics.OdePlugin
62{
63 public class OdePrim : PhysicsActor
64 {
65 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
66
67 private bool m_isphysical;
68 private bool m_fakeisphysical;
69 private bool m_isphantom;
70 private bool m_fakeisphantom;
71 internal bool m_isVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively
72 private bool m_fakeisVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively
73
74 protected bool m_building;
75 protected bool m_forcePosOrRotation;
76 private bool m_iscolliding;
77
78 internal bool m_isSelected;
79 private bool m_delaySelect;
80 private bool m_lastdoneSelected;
81 internal bool m_outbounds;
82
83 private Quaternion m_lastorientation = new Quaternion();
84 private Quaternion _orientation;
85
86 private Vector3 _position;
87 private Vector3 _velocity;
88 private Vector3 _torque;
89 private Vector3 m_lastVelocity;
90 private Vector3 m_lastposition;
91 private Vector3 m_rotationalVelocity;
92 private Vector3 _size;
93 private Vector3 _acceleration;
94 private Vector3 m_angularlock = Vector3.One;
95 private IntPtr Amotor = IntPtr.Zero;
96
97 private Vector3 m_force;
98 private Vector3 m_forceacc;
99 private Vector3 m_angularForceacc;
100
101 private float m_invTimeStep = 50.0f;
102 private float m_timeStep = .02f;
103
104
105 private Vector3 m_PIDTarget;
106 private float m_PIDTau;
107 private bool m_usePID;
108
109 // KF: These next 7 params apply to llSetHoverHeight(float height, integer water, float tau),
110 // and are for non-VEHICLES only.
111
112 private float m_PIDHoverHeight;
113 private float m_PIDHoverTau;
114 private bool m_useHoverPID;
115 private PIDHoverType m_PIDHoverType = PIDHoverType.Ground;
116 private float m_targetHoverHeight;
117 private float m_groundHeight;
118 private float m_waterHeight;
119 private float m_buoyancy; //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle.
120
121 private int body_autodisable_frames = 5;
122 private int bodydisablecontrol = 0;
123
124
125 // Default we're a Geometry
126 private CollisionCategories m_collisionCategories = (CollisionCategories.Geom);
127 // Default colide nonphysical don't try to colide with anything
128 private const CollisionCategories m_default_collisionFlagsNotPhysical = 0;
129
130 private const CollisionCategories m_default_collisionFlagsPhysical = (CollisionCategories.Geom |
131 CollisionCategories.Character |
132 CollisionCategories.Land |
133 CollisionCategories.VolumeDtc);
134
135// private bool m_collidesLand = true;
136 private bool m_collidesWater;
137 public bool m_returnCollisions;
138
139 private bool m_NoColide; // for now only for internal use for bad meshs
140
141
142 // Default, Collide with Other Geometries, spaces and Bodies
143 private CollisionCategories m_collisionFlags = m_default_collisionFlagsNotPhysical;
144
145 public bool m_disabled;
146
147 public uint m_localID;
148
149 private IMesh m_mesh;
150 private object m_meshlock = new object();
151 private PrimitiveBaseShape _pbs;
152 public OdeScene _parent_scene;
153
154 /// <summary>
155 /// The physics space which contains prim geometry
156 /// </summary>
157 public IntPtr m_targetSpace = IntPtr.Zero;
158
159 public IntPtr prim_geom;
160 public IntPtr _triMeshData;
161
162 private PhysicsActor _parent;
163
164 private List<OdePrim> childrenPrim = new List<OdePrim>();
165
166
167 private bool m_throttleUpdates;
168 private int throttleCounter;
169 public float m_collisionscore;
170 int m_colliderfilter = 0;
171
172 public IntPtr collide_geom; // for objects: geom if single prim space it linkset
173
174 private float m_density = 10.000006836f; // Aluminum g/cm3;
175 private byte m_shapetype;
176 public bool _zeroFlag;
177 private bool m_lastUpdateSent;
178
179 public IntPtr Body = IntPtr.Zero;
180 public String Name { get; private set; }
181 private Vector3 _target_velocity;
182
183 public Vector3 primOOBsize; // prim real dimensions from mesh
184 public Vector3 primOOBoffset; // its centroid out of mesh or rest aabb
185 public float primOOBradiusSQ;
186 public d.Mass primdMass; // prim inertia information on it's own referencial
187 float primMass; // prim own mass
188 float primVolume; // prim own volume;
189 float _mass; // object mass acording to case
190 private bool hasOOBoffsetFromMesh = false; // if true we did compute it form mesh centroid, else from aabb
191
192 public int givefakepos = 0;
193 private Vector3 fakepos;
194 public int givefakeori = 0;
195 private Quaternion fakeori;
196
197 public int m_eventsubscription;
198 private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate();
199
200 public volatile bool childPrim;
201
202 public ODEDynamics m_vehicle;
203
204 internal int m_material = (int)Material.Wood;
205 private float mu;
206 private float bounce;
207
208 /// <summary>
209 /// Is this prim subject to physics? Even if not, it's still solid for collision purposes.
210 /// </summary>
211 public override bool IsPhysical // this is not reliable for internal use
212 {
213 get { return m_fakeisphysical; }
214 set
215 {
216 m_fakeisphysical = value; // we show imediatly to outside that we changed physical
217 // and also to stop imediatly some updates
218 // but real change will only happen in taintprocessing
219
220 if (!value) // Zero the remembered last velocity
221 m_lastVelocity = Vector3.Zero;
222 AddChange(changes.Physical, value);
223 }
224 }
225
226 public override bool IsVolumeDtc
227 {
228 get { return m_fakeisVolumeDetect; }
229 set
230 {
231 m_fakeisVolumeDetect = value;
232 AddChange(changes.VolumeDtc, value);
233 }
234 }
235
236
237 public override bool Phantom // this is not reliable for internal use
238 {
239 get { return m_fakeisphantom; }
240 set
241 {
242 m_fakeisphantom = value;
243 AddChange(changes.Phantom, value);
244 }
245 }
246
247 public override bool Building // this is not reliable for internal use
248 {
249 get { return m_building; }
250 set
251 {
252 if (value)
253 m_building = true;
254 AddChange(changes.building, value);
255 }
256 }
257
258 public override void getContactData(ref ContactData cdata)
259 {
260 cdata.mu = mu;
261 cdata.bounce = bounce;
262
263 // cdata.softcolide = m_softcolide;
264 cdata.softcolide = false;
265
266 if (m_isphysical)
267 {
268 ODEDynamics veh;
269 if (_parent != null)
270 veh = ((OdePrim)_parent).m_vehicle;
271 else
272 veh = m_vehicle;
273
274 if (veh != null && veh.Type != Vehicle.TYPE_NONE)
275 cdata.mu *= veh.FrictionFactor;
276 }
277 }
278
279 public override int PhysicsActorType
280 {
281 get { return (int)ActorTypes.Prim; }
282 set { return; }
283 }
284
285 public override bool SetAlwaysRun
286 {
287 get { return false; }
288 set { return; }
289 }
290
291 public override uint LocalID
292 {
293 get
294 {
295 return m_localID;
296 }
297 set
298 {
299 //m_log.Info("[PHYSICS]: Setting TrackerID: " + value);
300 m_localID = value;
301 }
302 }
303
304 public override bool Grabbed
305 {
306 set { return; }
307 }
308
309 public override bool Selected
310 {
311 set
312 {
313 if (value)
314 m_isSelected = value; // if true set imediatly to stop moves etc
315 AddChange(changes.Selected, value);
316 }
317 }
318
319 public override bool Flying
320 {
321 // no flying prims for you
322 get { return false; }
323 set { }
324 }
325
326 public override bool IsColliding
327 {
328 get { return m_iscolliding; }
329 set
330 {
331 if (value)
332 {
333 m_colliderfilter += 2;
334 if (m_colliderfilter > 2)
335 m_colliderfilter = 2;
336 }
337 else
338 {
339 m_colliderfilter--;
340 if (m_colliderfilter < 0)
341 m_colliderfilter = 0;
342 }
343
344 if (m_colliderfilter == 0)
345 m_iscolliding = false;
346 else
347 m_iscolliding = true;
348 }
349 }
350
351 public override bool CollidingGround
352 {
353 get { return false; }
354 set { return; }
355 }
356
357 public override bool CollidingObj
358 {
359 get { return false; }
360 set { return; }
361 }
362
363 public override bool ThrottleUpdates
364 {
365 get { return m_throttleUpdates; }
366 set { m_throttleUpdates = value; }
367 }
368
369 public override bool Stopped
370 {
371 get { return _zeroFlag; }
372 }
373
374 public override Vector3 Position
375 {
376 get
377 {
378 if (givefakepos > 0)
379 return fakepos;
380 else
381 return _position;
382 }
383
384 set
385 {
386 fakepos = value;
387 givefakepos++;
388 AddChange(changes.Position, value);
389 }
390 }
391
392 public override Vector3 Size
393 {
394 get { return _size; }
395 set
396 {
397 if (value.IsFinite())
398 {
399 AddChange(changes.Size, value);
400 }
401 else
402 {
403 m_log.WarnFormat("[PHYSICS]: Got NaN Size on object {0}", Name);
404 }
405 }
406 }
407
408 public override float Mass
409 {
410 get { return primMass; }
411 }
412
413 public override Vector3 Force
414 {
415 //get { return Vector3.Zero; }
416 get { return m_force; }
417 set
418 {
419 if (value.IsFinite())
420 {
421 AddChange(changes.Force, value);
422 }
423 else
424 {
425 m_log.WarnFormat("[PHYSICS]: NaN in Force Applied to an Object {0}", Name);
426 }
427 }
428 }
429
430 public override void SetVolumeDetect(int param)
431 {
432 m_fakeisVolumeDetect = (param != 0);
433 AddChange(changes.VolumeDtc, m_fakeisVolumeDetect);
434 }
435
436 public override Vector3 GeometricCenter
437 {
438 // this is not real geometric center but a average of positions relative to root prim acording to
439 // http://wiki.secondlife.com/wiki/llGetGeometricCenter
440 // ignoring tortured prims details since sl also seems to ignore
441 // so no real use in doing it on physics
442 get
443 {
444 return Vector3.Zero;
445 }
446 }
447
448 public override Vector3 CenterOfMass
449 {
450 get
451 {
452 d.Vector3 dtmp;
453 if (!childPrim && Body != IntPtr.Zero)
454 {
455 dtmp = d.BodyGetPosition(Body);
456 return new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
457 }
458 else if (prim_geom != IntPtr.Zero)
459 {
460 d.Quaternion dq;
461 d.GeomCopyQuaternion(prim_geom, out dq);
462 Quaternion q;
463 q.X = dq.X;
464 q.Y = dq.Y;
465 q.Z = dq.Z;
466 q.W = dq.W;
467
468 Vector3 Ptot = primOOBoffset * q;
469 dtmp = d.GeomGetPosition(prim_geom);
470 Ptot.X += dtmp.X;
471 Ptot.Y += dtmp.Y;
472 Ptot.Z += dtmp.Z;
473
474// if(childPrim) we only know about physical linksets
475 return Ptot;
476/*
477 float tmass = _mass;
478 Ptot *= tmass;
479
480 float m;
481
482 foreach (OdePrim prm in childrenPrim)
483 {
484 m = prm._mass;
485 Ptot += prm.CenterOfMass * m;
486 tmass += m;
487 }
488
489 if (tmass == 0)
490 tmass = 0;
491 else
492 tmass = 1.0f / tmass;
493
494 Ptot *= tmass;
495 return Ptot;
496 */
497 }
498 else
499 return _position;
500 }
501 }
502 /*
503 public override Vector3 PrimOOBsize
504 {
505 get
506 {
507 return primOOBsize;
508 }
509 }
510
511 public override Vector3 PrimOOBoffset
512 {
513 get
514 {
515 return primOOBoffset;
516 }
517 }
518
519 public override float PrimOOBRadiusSQ
520 {
521 get
522 {
523 return primOOBradiusSQ;
524 }
525 }
526 */
527 public override PrimitiveBaseShape Shape
528 {
529 set
530 {
531/*
532 IMesh mesh = null;
533 if (_parent_scene.needsMeshing(value))
534 {
535 bool convex;
536 if (m_shapetype == 0)
537 convex = false;
538 else
539 convex = true;
540 mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, (int)LevelOfDetail.High, true, convex);
541 }
542
543 if (mesh != null)
544 {
545 lock (m_meshlock)
546 m_mesh = mesh;
547 }
548*/
549 AddChange(changes.Shape, value);
550 }
551 }
552
553 public override byte PhysicsShapeType
554 {
555 get
556 {
557 return m_shapetype;
558 }
559 set
560 {
561 m_shapetype = value;
562 AddChange(changes.Shape, null);
563 }
564 }
565
566
567 public override Vector3 Velocity
568 {
569 get
570 {
571 if (_zeroFlag)
572 return Vector3.Zero;
573 return _velocity;
574 }
575 set
576 {
577 if (value.IsFinite())
578 {
579 AddChange(changes.Velocity, value);
580 // _velocity = value;
581
582 }
583 else
584 {
585 m_log.WarnFormat("[PHYSICS]: Got NaN Velocity in Object {0}", Name);
586 }
587
588 }
589 }
590
591 public override Vector3 Torque
592 {
593 get
594 {
595 if (!IsPhysical || Body == IntPtr.Zero)
596 return Vector3.Zero;
597
598 return _torque;
599 }
600
601 set
602 {
603 if (value.IsFinite())
604 {
605 AddChange(changes.Torque, value);
606 }
607 else
608 {
609 m_log.WarnFormat("[PHYSICS]: Got NaN Torque in Object {0}", Name);
610 }
611 }
612 }
613
614 public override float CollisionScore
615 {
616 get { return m_collisionscore; }
617 set { m_collisionscore = value; }
618 }
619
620 public override bool Kinematic
621 {
622 get { return false; }
623 set { }
624 }
625
626 public override Quaternion Orientation
627 {
628 get
629 {
630 if (givefakeori > 0)
631 return fakeori;
632 else
633
634 return _orientation;
635 }
636 set
637 {
638 if (QuaternionIsFinite(value))
639 {
640 fakeori = value;
641 givefakeori++;
642 AddChange(changes.Orientation, value);
643 }
644 else
645 m_log.WarnFormat("[PHYSICS]: Got NaN quaternion Orientation from Scene in Object {0}", Name);
646
647 }
648 }
649
650 public override Vector3 Acceleration
651 {
652 get { return _acceleration; }
653 set { }
654 }
655
656 public override Vector3 RotationalVelocity
657 {
658 get
659 {
660 Vector3 pv = Vector3.Zero;
661 if (_zeroFlag)
662 return pv;
663
664 if (m_rotationalVelocity.ApproxEquals(pv, 0.0001f))
665 return pv;
666
667 return m_rotationalVelocity;
668 }
669 set
670 {
671 if (value.IsFinite())
672 {
673 m_rotationalVelocity = value;
674 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
675 d.BodyEnable(Body);
676 }
677 else
678 {
679 m_log.WarnFormat("[PHYSICS]: Got NaN RotationalVelocity in Object {0}", Name);
680 }
681 }
682 }
683
684
685 public override float Buoyancy
686 {
687 get { return m_buoyancy; }
688 set
689 {
690 m_buoyancy = value;
691 }
692 }
693
694 public override bool FloatOnWater
695 {
696 set
697 {
698 AddChange(changes.CollidesWater, value);
699 }
700 }
701
702 public override Vector3 PIDTarget
703 {
704 set
705 {
706 if (value.IsFinite())
707 {
708 m_PIDTarget = value;
709 }
710 else
711 m_log.WarnFormat("[PHYSICS]: Got NaN PIDTarget from Scene on Object {0}", Name);
712 }
713 }
714
715 public override bool PIDActive { set { m_usePID = value; } }
716 public override float PIDTau
717 {
718 set
719 {
720 if (value <= 0)
721 m_PIDTau = 0;
722 else
723 {
724 float mint = (0.05f > m_timeStep ? 0.05f : m_timeStep);
725 if (value < mint)
726 m_PIDTau = mint;
727 else
728 m_PIDTau = value;
729 }
730 }
731 }
732
733 public override float PIDHoverHeight
734 {
735 set
736 {
737 m_PIDHoverHeight = value;
738 if (value == 0)
739 m_useHoverPID = false;
740 }
741 }
742 public override bool PIDHoverActive { set { m_useHoverPID = value; } }
743 public override PIDHoverType PIDHoverType { set { m_PIDHoverType = value; } }
744 public override float PIDHoverTau
745 {
746 set
747 {
748 if (value <= 0)
749 m_PIDHoverTau = 0;
750 else
751 {
752 float mint = (0.05f > m_timeStep ? 0.05f : m_timeStep);
753 if (value < mint)
754 m_PIDHoverTau = mint;
755 else
756 m_PIDHoverTau = value;
757 }
758 }
759 }
760
761 public override Quaternion APIDTarget { set { return; } }
762
763 public override bool APIDActive { set { return; } }
764
765 public override float APIDStrength { set { return; } }
766
767 public override float APIDDamping { set { return; } }
768
769 public override int VehicleType
770 {
771 // we may need to put a fake on this
772 get
773 {
774 if (m_vehicle == null)
775 return (int)Vehicle.TYPE_NONE;
776 else
777 return (int)m_vehicle.Type;
778 }
779 set
780 {
781 AddChange(changes.VehicleType, value);
782 }
783 }
784
785 public override void VehicleFloatParam(int param, float value)
786 {
787 strVehicleFloatParam fp = new strVehicleFloatParam();
788 fp.param = param;
789 fp.value = value;
790 AddChange(changes.VehicleFloatParam, fp);
791 }
792
793 public override void VehicleVectorParam(int param, Vector3 value)
794 {
795 strVehicleVectorParam fp = new strVehicleVectorParam();
796 fp.param = param;
797 fp.value = value;
798 AddChange(changes.VehicleVectorParam, fp);
799 }
800
801 public override void VehicleRotationParam(int param, Quaternion value)
802 {
803 strVehicleQuatParam fp = new strVehicleQuatParam();
804 fp.param = param;
805 fp.value = value;
806 AddChange(changes.VehicleRotationParam, fp);
807 }
808
809 public override void VehicleFlags(int param, bool value)
810 {
811 strVehicleBoolParam bp = new strVehicleBoolParam();
812 bp.param = param;
813 bp.value = value;
814 AddChange(changes.VehicleFlags, bp);
815 }
816
817 public override void SetVehicle(object vdata)
818 {
819 AddChange(changes.SetVehicle, vdata);
820 }
821 public void SetAcceleration(Vector3 accel)
822 {
823 _acceleration = accel;
824 }
825
826 public override void AddForce(Vector3 force, bool pushforce)
827 {
828 if (force.IsFinite())
829 {
830 AddChange(changes.AddForce, force * m_invTimeStep);
831 }
832 else
833 {
834 m_log.WarnFormat("[PHYSICS]: Got Invalid linear force vector from Scene in Object {0}", Name);
835 }
836 //m_log.Info("[PHYSICS]: Added Force:" + force.ToString() + " to prim at " + Position.ToString());
837 }
838
839 public override void AddAngularForce(Vector3 force, bool pushforce)
840 {
841 if (force.IsFinite())
842 {
843 AddChange(changes.AddAngForce, force * m_invTimeStep);
844 }
845 else
846 {
847 m_log.WarnFormat("[PHYSICS]: Got Invalid Angular force vector from Scene in Object {0}", Name);
848 }
849 }
850
851 public override void CrossingFailure()
852 {
853 if (m_outbounds)
854 {
855 _position.X = Util.Clip(_position.X, 0.5f, _parent_scene.WorldExtents.X - 0.5f);
856 _position.Y = Util.Clip(_position.Y, 0.5f, _parent_scene.WorldExtents.Y - 0.5f);
857 _position.Z = Util.Clip(_position.Z + 0.2f, -100f, 50000f);
858
859 m_lastposition = _position;
860 _velocity.X = 0;
861 _velocity.Y = 0;
862 _velocity.Z = 0;
863
864 m_lastVelocity = _velocity;
865 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
866 m_vehicle.Stop();
867
868 if(Body != IntPtr.Zero)
869 d.BodySetLinearVel(Body, 0, 0, 0); // stop it
870 if (prim_geom != IntPtr.Zero)
871 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
872
873 m_outbounds = false;
874 changeDisable(false);
875 base.RequestPhysicsterseUpdate();
876 }
877 }
878
879 public override void SetMomentum(Vector3 momentum)
880 {
881 }
882
883 public override void SetMaterial(int pMaterial)
884 {
885 m_material = pMaterial;
886 mu = _parent_scene.m_materialContactsData[pMaterial].mu;
887 bounce = _parent_scene.m_materialContactsData[pMaterial].bounce;
888 }
889
890 public void setPrimForRemoval()
891 {
892 AddChange(changes.Remove, null);
893 }
894
895 public override void link(PhysicsActor obj)
896 {
897 AddChange(changes.Link, obj);
898 }
899
900 public override void delink()
901 {
902 AddChange(changes.DeLink, null);
903 }
904
905 public override void LockAngularMotion(Vector3 axis)
906 {
907 // reverse the zero/non zero values for ODE.
908 if (axis.IsFinite())
909 {
910 axis.X = (axis.X > 0) ? 1f : 0f;
911 axis.Y = (axis.Y > 0) ? 1f : 0f;
912 axis.Z = (axis.Z > 0) ? 1f : 0f;
913 m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z);
914 AddChange(changes.AngLock, axis);
915 }
916 else
917 {
918 m_log.WarnFormat("[PHYSICS]: Got NaN locking axis from Scene on Object {0}", Name);
919 }
920 }
921
922 public override void SubscribeEvents(int ms)
923 {
924 m_eventsubscription = ms;
925 _parent_scene.AddCollisionEventReporting(this);
926 }
927
928 public override void UnSubscribeEvents()
929 {
930 _parent_scene.RemoveCollisionEventReporting(this);
931 m_eventsubscription = 0;
932 }
933
934 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
935 {
936 if (CollisionEventsThisFrame == null)
937 CollisionEventsThisFrame = new CollisionEventUpdate();
938
939 CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
940 }
941
942 public void SendCollisions()
943 {
944 if (CollisionEventsThisFrame == null)
945 return;
946
947 base.SendCollisionUpdate(CollisionEventsThisFrame);
948
949 if (CollisionEventsThisFrame.m_objCollisionList.Count == 0)
950 CollisionEventsThisFrame = null;
951 else
952 CollisionEventsThisFrame = new CollisionEventUpdate();
953 }
954
955 public override bool SubscribedEvents()
956 {
957 if (m_eventsubscription > 0)
958 return true;
959 return false;
960 }
961
962
963 public OdePrim(String primName, OdeScene parent_scene, Vector3 pos, Vector3 size,
964 Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical,bool pisPhantom,byte _shapeType,uint plocalID)
965 {
966 Name = primName;
967 LocalID = plocalID;
968
969 m_vehicle = null;
970
971 if (!pos.IsFinite())
972 {
973 pos = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f),
974 parent_scene.GetTerrainHeightAtXY(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f)) + 0.5f);
975 m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Position for {0}", Name);
976 }
977 _position = pos;
978 givefakepos = 0;
979
980 m_timeStep = parent_scene.ODE_STEPSIZE;
981 m_invTimeStep = 1f / m_timeStep;
982
983 m_density = parent_scene.geomDefaultDensity;
984 // m_tensor = parent_scene.bodyMotorJointMaxforceTensor;
985 body_autodisable_frames = parent_scene.bodyFramesAutoDisable;
986
987 prim_geom = IntPtr.Zero;
988 collide_geom = IntPtr.Zero;
989 Body = IntPtr.Zero;
990
991 if (!size.IsFinite())
992 {
993 size = new Vector3(0.5f, 0.5f, 0.5f);
994 m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Size for {0}", Name);
995 }
996
997 if (size.X <= 0) size.X = 0.01f;
998 if (size.Y <= 0) size.Y = 0.01f;
999 if (size.Z <= 0) size.Z = 0.01f;
1000
1001 _size = size;
1002
1003 if (!QuaternionIsFinite(rotation))
1004 {
1005 rotation = Quaternion.Identity;
1006 m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Rotation for {0}", Name);
1007 }
1008
1009 _orientation = rotation;
1010 givefakeori = 0;
1011
1012 _pbs = pbs;
1013
1014 _parent_scene = parent_scene;
1015 m_targetSpace = IntPtr.Zero;
1016
1017 if (pos.Z < 0)
1018 {
1019 m_isphysical = false;
1020 }
1021 else
1022 {
1023 m_isphysical = pisPhysical;
1024 }
1025 m_fakeisphysical = m_isphysical;
1026
1027 m_isVolumeDetect = false;
1028 m_fakeisVolumeDetect = false;
1029
1030 m_force = Vector3.Zero;
1031
1032 m_iscolliding = false;
1033 m_colliderfilter = 0;
1034 m_NoColide = false;
1035
1036 hasOOBoffsetFromMesh = false;
1037 _triMeshData = IntPtr.Zero;
1038
1039 m_shapetype = _shapeType;
1040
1041 m_lastdoneSelected = false;
1042 m_isSelected = false;
1043 m_delaySelect = false;
1044
1045 m_isphantom = pisPhantom;
1046 m_fakeisphantom = pisPhantom;
1047
1048 mu = parent_scene.m_materialContactsData[(int)Material.Wood].mu;
1049 bounce = parent_scene.m_materialContactsData[(int)Material.Wood].bounce;
1050
1051 CalcPrimBodyData();
1052
1053 m_mesh = null;
1054 if (_parent_scene.needsMeshing(pbs))
1055 {
1056 bool convex;
1057 if (m_shapetype == 0)
1058 convex = false;
1059 else
1060 convex = true;
1061
1062 m_mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, (int)LevelOfDetail.High, true, convex);
1063 }
1064
1065
1066 m_building = true; // control must set this to false when done
1067
1068 AddChange(changes.Add, null);
1069 }
1070
1071 private void resetCollisionAccounting()
1072 {
1073 m_collisionscore = 0;
1074 }
1075
1076 private void UpdateCollisionCatFlags()
1077 {
1078 if(m_isphysical && m_disabled)
1079 {
1080 m_collisionCategories = 0;
1081 m_collisionFlags = 0;
1082 }
1083
1084 else if (m_isSelected)
1085 {
1086 m_collisionCategories = CollisionCategories.Selected;
1087 m_collisionFlags = 0;
1088 }
1089
1090 else if (m_isVolumeDetect)
1091 {
1092 m_collisionCategories = CollisionCategories.VolumeDtc;
1093 if (m_isphysical)
1094 m_collisionFlags = CollisionCategories.Geom | CollisionCategories.Character;
1095 else
1096 m_collisionFlags = 0;
1097 }
1098 else if (m_isphantom)
1099 {
1100 m_collisionCategories = CollisionCategories.Phantom;
1101 if (m_isphysical)
1102 m_collisionFlags = CollisionCategories.Land;
1103 else
1104 m_collisionFlags = 0;
1105 }
1106 else
1107 {
1108 m_collisionCategories = CollisionCategories.Geom;
1109 if (m_isphysical)
1110 m_collisionFlags = m_default_collisionFlagsPhysical;
1111 else
1112 m_collisionFlags = m_default_collisionFlagsNotPhysical;
1113 }
1114 }
1115
1116 private void ApplyCollisionCatFlags()
1117 {
1118 if (prim_geom != IntPtr.Zero)
1119 {
1120 if (!childPrim && childrenPrim.Count > 0)
1121 {
1122 foreach (OdePrim prm in childrenPrim)
1123 {
1124 if (m_isphysical && m_disabled)
1125 {
1126 prm.m_collisionCategories = 0;
1127 prm.m_collisionFlags = 0;
1128 }
1129 else
1130 {
1131 // preserve some
1132 if (prm.m_isSelected)
1133 {
1134 prm.m_collisionCategories = CollisionCategories.Selected;
1135 prm.m_collisionFlags = 0;
1136 }
1137 else if (prm.m_isVolumeDetect)
1138 {
1139 prm.m_collisionCategories = CollisionCategories.VolumeDtc;
1140 if (m_isphysical)
1141 prm.m_collisionFlags = CollisionCategories.Geom | CollisionCategories.Character;
1142 else
1143 prm.m_collisionFlags = 0;
1144 }
1145 else if (prm.m_isphantom)
1146 {
1147 prm.m_collisionCategories = CollisionCategories.Phantom;
1148 if (m_isphysical)
1149 prm.m_collisionFlags = CollisionCategories.Land;
1150 else
1151 prm.m_collisionFlags = 0;
1152 }
1153 else
1154 {
1155 prm.m_collisionCategories = m_collisionCategories;
1156 prm.m_collisionFlags = m_collisionFlags;
1157 }
1158 }
1159
1160 if (prm.prim_geom != IntPtr.Zero)
1161 {
1162 if (prm.m_NoColide)
1163 {
1164 d.GeomSetCategoryBits(prm.prim_geom, 0);
1165 if (m_isphysical)
1166 d.GeomSetCollideBits(prm.prim_geom, (int)CollisionCategories.Land);
1167 else
1168 d.GeomSetCollideBits(prm.prim_geom, 0);
1169 }
1170 else
1171 {
1172 d.GeomSetCategoryBits(prm.prim_geom, (uint)prm.m_collisionCategories);
1173 d.GeomSetCollideBits(prm.prim_geom, (uint)prm.m_collisionFlags);
1174 }
1175 }
1176 }
1177 }
1178
1179 if (m_NoColide)
1180 {
1181 d.GeomSetCategoryBits(prim_geom, 0);
1182 d.GeomSetCollideBits(prim_geom, (uint)CollisionCategories.Land);
1183 if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)
1184 {
1185 d.GeomSetCategoryBits(collide_geom, 0);
1186 d.GeomSetCollideBits(collide_geom, (uint)CollisionCategories.Land);
1187 }
1188 }
1189 else
1190 {
1191 d.GeomSetCategoryBits(prim_geom, (uint)m_collisionCategories);
1192 d.GeomSetCollideBits(prim_geom, (uint)m_collisionFlags);
1193 if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)
1194 {
1195 d.GeomSetCategoryBits(collide_geom, (uint)m_collisionCategories);
1196 d.GeomSetCollideBits(collide_geom, (uint)m_collisionFlags);
1197 }
1198 }
1199 }
1200 }
1201
1202 private void createAMotor(Vector3 axis)
1203 {
1204 if (Body == IntPtr.Zero)
1205 return;
1206
1207 if (Amotor != IntPtr.Zero)
1208 {
1209 d.JointDestroy(Amotor);
1210 Amotor = IntPtr.Zero;
1211 }
1212
1213 int axisnum = 3 - (int)(axis.X + axis.Y + axis.Z);
1214
1215 if (axisnum <= 0)
1216 return;
1217
1218 // stop it
1219 d.BodySetTorque(Body, 0, 0, 0);
1220 d.BodySetAngularVel(Body, 0, 0, 0);
1221
1222 Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
1223 d.JointAttach(Amotor, Body, IntPtr.Zero);
1224
1225 d.JointSetAMotorMode(Amotor, 0);
1226
1227 d.JointSetAMotorNumAxes(Amotor, axisnum);
1228
1229 // get current orientation to lock
1230
1231 d.Quaternion dcur = d.BodyGetQuaternion(Body);
1232 Quaternion curr; // crap convertion between identical things
1233 curr.X = dcur.X;
1234 curr.Y = dcur.Y;
1235 curr.Z = dcur.Z;
1236 curr.W = dcur.W;
1237 Vector3 ax;
1238
1239 int i = 0;
1240 int j = 0;
1241 if (axis.X == 0)
1242 {
1243 ax = (new Vector3(1, 0, 0)) * curr; // rotate world X to current local X
1244 // ODE should do this with axis relative to body 1 but seems to fail
1245 d.JointSetAMotorAxis(Amotor, 0, 0, ax.X, ax.Y, ax.Z);
1246 d.JointSetAMotorAngle(Amotor, 0, 0);
1247 d.JointSetAMotorParam(Amotor, (int)d.JointParam.LoStop, -0.000001f);
1248 d.JointSetAMotorParam(Amotor, (int)d.JointParam.HiStop, 0.000001f);
1249 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel, 0);
1250 d.JointSetAMotorParam(Amotor, (int)d.JointParam.FudgeFactor, 0.0001f);
1251 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Bounce, 0f);
1252 d.JointSetAMotorParam(Amotor, (int)d.JointParam.FMax, 5e8f);
1253 d.JointSetAMotorParam(Amotor, (int)d.JointParam.StopCFM, 0f);
1254 d.JointSetAMotorParam(Amotor, (int)d.JointParam.StopERP, 0.8f);
1255 i++;
1256 j = 256; // move to next axis set
1257 }
1258
1259 if (axis.Y == 0)
1260 {
1261 ax = (new Vector3(0, 1, 0)) * curr;
1262 d.JointSetAMotorAxis(Amotor, i, 0, ax.X, ax.Y, ax.Z);
1263 d.JointSetAMotorAngle(Amotor, i, 0);
1264 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.LoStop, -0.000001f);
1265 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.HiStop, 0.000001f);
1266 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Vel, 0);
1267 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FudgeFactor, 0.0001f);
1268 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Bounce, 0f);
1269 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FMax, 5e8f);
1270 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopCFM, 0f);
1271 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopERP, 0.8f);
1272 i++;
1273 j += 256;
1274 }
1275
1276 if (axis.Z == 0)
1277 {
1278 ax = (new Vector3(0, 0, 1)) * curr;
1279 d.JointSetAMotorAxis(Amotor, i, 0, ax.X, ax.Y, ax.Z);
1280 d.JointSetAMotorAngle(Amotor, i, 0);
1281 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.LoStop, -0.000001f);
1282 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.HiStop, 0.000001f);
1283 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Vel, 0);
1284 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FudgeFactor, 0.0001f);
1285 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Bounce, 0f);
1286 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FMax, 5e8f);
1287 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopCFM, 0f);
1288 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopERP, 0.8f);
1289 }
1290 }
1291
1292 private bool setMesh(OdeScene parent_scene)
1293 {
1294 IntPtr vertices, indices;
1295 int vertexCount, indexCount;
1296 int vertexStride, triStride;
1297
1298 if (Body != IntPtr.Zero)
1299 {
1300 if (childPrim)
1301 {
1302 if (_parent != null)
1303 {
1304 OdePrim parent = (OdePrim)_parent;
1305 parent.ChildDelink(this, false);
1306 }
1307 }
1308 else
1309 {
1310 DestroyBody();
1311 }
1312 }
1313
1314 IMesh mesh = null;
1315
1316
1317 lock (m_meshlock)
1318 {
1319 if (m_mesh == null)
1320 {
1321 bool convex;
1322 if (m_shapetype == 0)
1323 convex = false;
1324 else
1325 convex = true;
1326
1327 mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, (int)LevelOfDetail.High, true, convex);
1328 }
1329 else
1330 {
1331 mesh = m_mesh;
1332 }
1333
1334 if (mesh == null)
1335 {
1336 m_log.WarnFormat("[PHYSICS]: CreateMesh Failed on prim {0} at <{1},{2},{3}>.", Name, _position.X, _position.Y, _position.Z);
1337 return false;
1338 }
1339
1340
1341 mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount); // Note, that vertices are fixed in unmanaged heap
1342 mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount); // Also fixed, needs release after usage
1343
1344 if (vertexCount == 0 || indexCount == 0)
1345 {
1346 m_log.WarnFormat("[PHYSICS]: Got invalid mesh on prim {0} at <{1},{2},{3}>. mesh UUID {4}",
1347 Name, _position.X, _position.Y, _position.Z, _pbs.SculptTexture.ToString());
1348 mesh.releaseSourceMeshData();
1349 return false;
1350 }
1351
1352 primOOBoffset = mesh.GetCentroid();
1353 hasOOBoffsetFromMesh = true;
1354
1355 mesh.releaseSourceMeshData();
1356 m_mesh = null;
1357 }
1358
1359 IntPtr geo = IntPtr.Zero;
1360
1361 try
1362 {
1363 _triMeshData = d.GeomTriMeshDataCreate();
1364
1365 d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);
1366 d.GeomTriMeshDataPreprocess(_triMeshData);
1367
1368 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1369 geo = d.CreateTriMesh(m_targetSpace, _triMeshData, null, null, null);
1370 }
1371
1372 catch (Exception e)
1373 {
1374 m_log.ErrorFormat("[PHYSICS]: SetGeom Mesh failed for {0} exception: {1}", Name, e);
1375 if (_triMeshData != IntPtr.Zero)
1376 {
1377 d.GeomTriMeshDataDestroy(_triMeshData);
1378 _triMeshData = IntPtr.Zero;
1379 }
1380 return false;
1381 }
1382
1383 SetGeom(geo);
1384 return true;
1385 }
1386
1387 private void SetGeom(IntPtr geom)
1388 {
1389 prim_geom = geom;
1390 //Console.WriteLine("SetGeom to " + prim_geom + " for " + Name);
1391 if (prim_geom != IntPtr.Zero)
1392 {
1393 if (m_NoColide)
1394 {
1395 d.GeomSetCategoryBits(prim_geom, 0);
1396 if (m_isphysical)
1397 {
1398 d.GeomSetCollideBits(prim_geom, (uint)CollisionCategories.Land);
1399 }
1400 else
1401 {
1402 d.GeomSetCollideBits(prim_geom, 0);
1403 d.GeomDisable(prim_geom);
1404 }
1405 }
1406 else
1407 {
1408 d.GeomSetCategoryBits(prim_geom, (uint)m_collisionCategories);
1409 d.GeomSetCollideBits(prim_geom, (uint)m_collisionFlags);
1410 }
1411
1412 CalcPrimBodyData();
1413
1414 _parent_scene.geom_name_map[prim_geom] = Name;
1415 _parent_scene.actor_name_map[prim_geom] = this;
1416
1417 }
1418 else
1419 m_log.Warn("Setting bad Geom");
1420 }
1421
1422
1423 /// <summary>
1424 /// Create a geometry for the given mesh in the given target space.
1425 /// </summary>
1426 /// <param name="m_targetSpace"></param>
1427 /// <param name="mesh">If null, then a mesh is used that is based on the profile shape data.</param>
1428 private void CreateGeom()
1429 {
1430 if (_triMeshData != IntPtr.Zero)
1431 {
1432 d.GeomTriMeshDataDestroy(_triMeshData);
1433 _triMeshData = IntPtr.Zero;
1434 }
1435
1436 bool haveMesh = false;
1437 hasOOBoffsetFromMesh = false;
1438 m_NoColide = false;
1439
1440 if (_parent_scene.needsMeshing(_pbs))
1441 {
1442 haveMesh = setMesh(_parent_scene); // this will give a mesh to non trivial known prims
1443 if (!haveMesh)
1444 m_NoColide = true;
1445 }
1446
1447 if (!haveMesh)
1448 {
1449 if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1
1450 && _size.X == _size.Y && _size.Y == _size.Z)
1451 { // it's a sphere
1452 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1453 try
1454 {
1455 SetGeom(d.CreateSphere(m_targetSpace, _size.X * 0.5f));
1456 }
1457 catch (Exception e)
1458 {
1459 m_log.WarnFormat("[PHYSICS]: Create sphere failed: {0}", e);
1460 return;
1461 }
1462 }
1463 else
1464 {// do it as a box
1465 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1466 try
1467 {
1468 //Console.WriteLine(" CreateGeom 4");
1469 SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
1470 }
1471 catch (Exception e)
1472 {
1473 m_log.Warn("[PHYSICS]: Create box failed: {0}", e);
1474 return;
1475 }
1476 }
1477 }
1478 }
1479
1480 /// <summary>
1481 /// Set a new geometry for this prim.
1482 /// </summary>
1483 /// <param name="geom"></param>
1484 private void RemoveGeom()
1485 {
1486 if (prim_geom != IntPtr.Zero)
1487 {
1488 _parent_scene.geom_name_map.Remove(prim_geom);
1489 _parent_scene.actor_name_map.Remove(prim_geom);
1490 try
1491 {
1492 d.GeomDestroy(prim_geom);
1493 if (_triMeshData != IntPtr.Zero)
1494 {
1495 d.GeomTriMeshDataDestroy(_triMeshData);
1496 _triMeshData = IntPtr.Zero;
1497 }
1498 }
1499 // catch (System.AccessViolationException)
1500 catch (Exception e)
1501 {
1502 m_log.ErrorFormat("[PHYSICS]: PrimGeom destruction failed for {0} exception {1}", Name, e);
1503 }
1504
1505 prim_geom = IntPtr.Zero;
1506 collide_geom = IntPtr.Zero;
1507 }
1508 else
1509 {
1510 m_log.ErrorFormat("[PHYSICS]: PrimGeom destruction BAD {0}", Name);
1511 }
1512 Body = IntPtr.Zero;
1513 hasOOBoffsetFromMesh = false;
1514 CalcPrimBodyData();
1515 }
1516/*
1517 private void ChildSetGeom(OdePrim odePrim)
1518 {
1519 // well..
1520 DestroyBody();
1521 MakeBody();
1522 }
1523*/
1524 //sets non physical prim m_targetSpace to right space in spaces grid for static prims
1525 // should only be called for non physical prims unless they are becoming non physical
1526 private void SetInStaticSpace(OdePrim prim)
1527 {
1528 IntPtr targetSpace = _parent_scene.MoveGeomToStaticSpace(prim.prim_geom, prim._position, prim.m_targetSpace);
1529 prim.m_targetSpace = targetSpace;
1530 collide_geom = IntPtr.Zero;
1531 }
1532
1533 public void enableBodySoft()
1534 {
1535 m_disabled = false;
1536 if (!childPrim && !m_isSelected)
1537 {
1538 if (m_isphysical && Body != IntPtr.Zero)
1539 {
1540 UpdateCollisionCatFlags();
1541 ApplyCollisionCatFlags();
1542
1543 d.BodyEnable(Body);
1544 }
1545 }
1546 resetCollisionAccounting();
1547 }
1548
1549 private void disableBodySoft()
1550 {
1551 m_disabled = true;
1552 if (!childPrim)
1553 {
1554 if (m_isphysical && Body != IntPtr.Zero)
1555 {
1556 if (m_isSelected)
1557 m_collisionFlags = CollisionCategories.Selected;
1558 else
1559 m_collisionCategories = 0;
1560 m_collisionFlags = 0;
1561 ApplyCollisionCatFlags();
1562 d.BodyDisable(Body);
1563 }
1564 }
1565 }
1566
1567 private void MakeBody()
1568 {
1569 if (!m_isphysical) // only physical get bodies
1570 return;
1571
1572 if (childPrim) // child prims don't get bodies;
1573 return;
1574
1575 if (m_building)
1576 return;
1577
1578 if (prim_geom == IntPtr.Zero)
1579 {
1580 m_log.Warn("[PHYSICS]: Unable to link the linkset. Root has no geom yet");
1581 return;
1582 }
1583
1584 if (Body != IntPtr.Zero)
1585 {
1586 d.BodyDestroy(Body);
1587 Body = IntPtr.Zero;
1588 m_log.Warn("[PHYSICS]: MakeBody called having a body");
1589 }
1590
1591
1592 if (d.GeomGetBody(prim_geom) != IntPtr.Zero)
1593 {
1594 d.GeomSetBody(prim_geom, IntPtr.Zero);
1595 m_log.Warn("[PHYSICS]: MakeBody root geom already had a body");
1596 }
1597
1598 d.Matrix3 mymat = new d.Matrix3();
1599 d.Quaternion myrot = new d.Quaternion();
1600 d.Mass objdmass = new d.Mass { };
1601
1602 Body = d.BodyCreate(_parent_scene.world);
1603
1604 DMassDup(ref primdMass, out objdmass);
1605
1606 // rotate inertia
1607 myrot.X = _orientation.X;
1608 myrot.Y = _orientation.Y;
1609 myrot.Z = _orientation.Z;
1610 myrot.W = _orientation.W;
1611
1612 d.RfromQ(out mymat, ref myrot);
1613 d.MassRotate(ref objdmass, ref mymat);
1614
1615 // set the body rotation
1616 d.BodySetRotation(Body, ref mymat);
1617
1618 // recompute full object inertia if needed
1619 if (childrenPrim.Count > 0)
1620 {
1621 d.Matrix3 mat = new d.Matrix3();
1622 d.Quaternion quat = new d.Quaternion();
1623 d.Mass tmpdmass = new d.Mass { };
1624 Vector3 rcm;
1625
1626 rcm.X = _position.X + objdmass.c.X;
1627 rcm.Y = _position.Y + objdmass.c.Y;
1628 rcm.Z = _position.Z + objdmass.c.Z;
1629
1630 lock (childrenPrim)
1631 {
1632 foreach (OdePrim prm in childrenPrim)
1633 {
1634 if (prm.prim_geom == IntPtr.Zero)
1635 {
1636 m_log.Warn("[PHYSICS]: Unable to link one of the linkset elements, skipping it. No geom yet");
1637 continue;
1638 }
1639
1640 DMassCopy(ref prm.primdMass, ref tmpdmass);
1641
1642 // apply prim current rotation to inertia
1643 quat.X = prm._orientation.X;
1644 quat.Y = prm._orientation.Y;
1645 quat.Z = prm._orientation.Z;
1646 quat.W = prm._orientation.W;
1647 d.RfromQ(out mat, ref quat);
1648 d.MassRotate(ref tmpdmass, ref mat);
1649
1650 Vector3 ppos = prm._position;
1651 ppos.X += tmpdmass.c.X - rcm.X;
1652 ppos.Y += tmpdmass.c.Y - rcm.Y;
1653 ppos.Z += tmpdmass.c.Z - rcm.Z;
1654
1655 // refer inertia to root prim center of mass position
1656 d.MassTranslate(ref tmpdmass,
1657 ppos.X,
1658 ppos.Y,
1659 ppos.Z);
1660
1661 d.MassAdd(ref objdmass, ref tmpdmass); // add to total object inertia
1662 // fix prim colision cats
1663
1664 if (d.GeomGetBody(prm.prim_geom) != IntPtr.Zero)
1665 {
1666 d.GeomSetBody(prm.prim_geom, IntPtr.Zero);
1667 m_log.Warn("[PHYSICS]: MakeBody child geom already had a body");
1668 }
1669
1670 d.GeomClearOffset(prm.prim_geom);
1671 d.GeomSetBody(prm.prim_geom, Body);
1672 prm.Body = Body;
1673 d.GeomSetOffsetWorldRotation(prm.prim_geom, ref mat); // set relative rotation
1674 }
1675 }
1676 }
1677
1678 d.GeomClearOffset(prim_geom); // make sure we don't have a hidden offset
1679 // associate root geom with body
1680 d.GeomSetBody(prim_geom, Body);
1681
1682 d.BodySetPosition(Body, _position.X + objdmass.c.X, _position.Y + objdmass.c.Y, _position.Z + objdmass.c.Z);
1683 d.GeomSetOffsetWorldPosition(prim_geom, _position.X, _position.Y, _position.Z);
1684
1685 d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body
1686 myrot.W = -myrot.W;
1687 d.RfromQ(out mymat, ref myrot);
1688 d.MassRotate(ref objdmass, ref mymat);
1689 d.BodySetMass(Body, ref objdmass);
1690 _mass = objdmass.mass;
1691
1692 // disconnect from world gravity so we can apply buoyancy
1693 d.BodySetGravityMode(Body, false);
1694
1695 d.BodySetAutoDisableFlag(Body, true);
1696 d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
1697 // d.BodySetLinearDampingThreshold(Body, 0.01f);
1698 // d.BodySetAngularDampingThreshold(Body, 0.001f);
1699 d.BodySetDamping(Body, .002f, .002f);
1700
1701 if (m_targetSpace != IntPtr.Zero)
1702 {
1703 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1704 if (d.SpaceQuery(m_targetSpace, prim_geom))
1705 d.SpaceRemove(m_targetSpace, prim_geom);
1706 }
1707
1708
1709 if (childrenPrim.Count == 0)
1710 {
1711 collide_geom = prim_geom;
1712 m_targetSpace = _parent_scene.ActiveSpace;
1713 d.SpaceAdd(m_targetSpace, prim_geom);
1714 }
1715 else
1716 {
1717 m_targetSpace = d.HashSpaceCreate(_parent_scene.ActiveSpace);
1718 d.HashSpaceSetLevels(m_targetSpace, -2, 8);
1719 d.SpaceSetSublevel(m_targetSpace, 3);
1720 d.SpaceSetCleanup(m_targetSpace, false);
1721 d.SpaceAdd(m_targetSpace, prim_geom);
1722
1723 d.GeomSetCategoryBits(m_targetSpace, (uint)(CollisionCategories.Space |
1724 CollisionCategories.Geom |
1725 CollisionCategories.Phantom |
1726 CollisionCategories.VolumeDtc
1727 ));
1728 d.GeomSetCollideBits(m_targetSpace, 0);
1729 collide_geom = m_targetSpace;
1730 }
1731
1732 if (m_delaySelect)
1733 {
1734 m_isSelected = true;
1735 m_delaySelect = false;
1736 }
1737
1738 lock (childrenPrim)
1739 {
1740 foreach (OdePrim prm in childrenPrim)
1741 {
1742 if (prm.prim_geom == IntPtr.Zero)
1743 continue;
1744
1745 Vector3 ppos = prm._position;
1746 d.GeomSetOffsetWorldPosition(prm.prim_geom, ppos.X, ppos.Y, ppos.Z); // set relative position
1747
1748 if (prm.m_targetSpace != m_targetSpace)
1749 {
1750 if (prm.m_targetSpace != IntPtr.Zero)
1751 {
1752 _parent_scene.waitForSpaceUnlock(prm.m_targetSpace);
1753 if (d.SpaceQuery(prm.m_targetSpace, prm.prim_geom))
1754 d.SpaceRemove(prm.m_targetSpace, prm.prim_geom);
1755 }
1756 prm.m_targetSpace = m_targetSpace;
1757 d.SpaceAdd(m_targetSpace, prm.prim_geom);
1758 }
1759
1760 prm.m_collisionscore = 0;
1761
1762 if(!m_disabled)
1763 prm.m_disabled = false;
1764
1765 _parent_scene.addActivePrim(prm);
1766 }
1767 }
1768
1769 // The body doesn't already have a finite rotation mode set here
1770 if ((!m_angularlock.ApproxEquals(Vector3.One, 0.0f)) && _parent == null)
1771 {
1772 createAMotor(m_angularlock);
1773 }
1774
1775 m_collisionscore = 0;
1776
1777 UpdateCollisionCatFlags();
1778 ApplyCollisionCatFlags();
1779
1780 if (m_isSelected || m_disabled)
1781 {
1782 d.BodyDisable(Body);
1783 }
1784 else
1785 {
1786 d.BodySetAngularVel(Body, m_rotationalVelocity.X, m_rotationalVelocity.Y, m_rotationalVelocity.Z);
1787 d.BodySetLinearVel(Body, _velocity.X, _velocity.Y, _velocity.Z);
1788 }
1789
1790 _parent_scene.addActivePrim(this);
1791 _parent_scene.addActiveGroups(this);
1792 }
1793
1794 private void DestroyBody()
1795 {
1796 if (Body != IntPtr.Zero)
1797 {
1798 _parent_scene.remActivePrim(this);
1799
1800 collide_geom = IntPtr.Zero;
1801
1802 if (m_disabled)
1803 m_collisionCategories = 0;
1804 else if (m_isSelected)
1805 m_collisionCategories = CollisionCategories.Selected;
1806 else if (m_isVolumeDetect)
1807 m_collisionCategories = CollisionCategories.VolumeDtc;
1808 else if (m_isphantom)
1809 m_collisionCategories = CollisionCategories.Phantom;
1810 else
1811 m_collisionCategories = CollisionCategories.Geom;
1812
1813 m_collisionFlags = 0;
1814
1815 if (prim_geom != IntPtr.Zero)
1816 {
1817 if (m_NoColide)
1818 {
1819 d.GeomSetCategoryBits(prim_geom, 0);
1820 d.GeomSetCollideBits(prim_geom, 0);
1821 }
1822 else
1823 {
1824 d.GeomSetCategoryBits(prim_geom, (uint)m_collisionCategories);
1825 d.GeomSetCollideBits(prim_geom, (uint)m_collisionFlags);
1826 }
1827 UpdateDataFromGeom();
1828 d.GeomSetBody(prim_geom, IntPtr.Zero);
1829 SetInStaticSpace(this);
1830 }
1831
1832 if (!childPrim)
1833 {
1834 lock (childrenPrim)
1835 {
1836 foreach (OdePrim prm in childrenPrim)
1837 {
1838 _parent_scene.remActivePrim(prm);
1839
1840 if (prm.m_isSelected)
1841 prm.m_collisionCategories = CollisionCategories.Selected;
1842 else if (prm.m_isVolumeDetect)
1843 prm.m_collisionCategories = CollisionCategories.VolumeDtc;
1844 else if (prm.m_isphantom)
1845 prm.m_collisionCategories = CollisionCategories.Phantom;
1846 else
1847 prm.m_collisionCategories = CollisionCategories.Geom;
1848
1849 prm.m_collisionFlags = 0;
1850
1851 if (prm.prim_geom != IntPtr.Zero)
1852 {
1853 if (prm.m_NoColide)
1854 {
1855 d.GeomSetCategoryBits(prm.prim_geom, 0);
1856 d.GeomSetCollideBits(prm.prim_geom, 0);
1857 }
1858 else
1859 {
1860 d.GeomSetCategoryBits(prm.prim_geom, (uint)prm.m_collisionCategories);
1861 d.GeomSetCollideBits(prm.prim_geom, (uint)prm.m_collisionFlags);
1862 }
1863 prm.UpdateDataFromGeom();
1864 SetInStaticSpace(prm);
1865 }
1866 prm.Body = IntPtr.Zero;
1867 prm._mass = prm.primMass;
1868 prm.m_collisionscore = 0;
1869 }
1870 }
1871 if (Amotor != IntPtr.Zero)
1872 {
1873 d.JointDestroy(Amotor);
1874 Amotor = IntPtr.Zero;
1875 }
1876 _parent_scene.remActiveGroup(this);
1877 d.BodyDestroy(Body);
1878 }
1879 Body = IntPtr.Zero;
1880 }
1881 _mass = primMass;
1882 m_collisionscore = 0;
1883 }
1884
1885 private void FixInertia(Vector3 NewPos,Quaternion newrot)
1886 {
1887 d.Matrix3 mat = new d.Matrix3();
1888 d.Quaternion quat = new d.Quaternion();
1889
1890 d.Mass tmpdmass = new d.Mass { };
1891 d.Mass objdmass = new d.Mass { };
1892
1893 d.BodyGetMass(Body, out tmpdmass);
1894 objdmass = tmpdmass;
1895
1896 d.Vector3 dobjpos;
1897 d.Vector3 thispos;
1898
1899 // get current object position and rotation
1900 dobjpos = d.BodyGetPosition(Body);
1901
1902 // get prim own inertia in its local frame
1903 tmpdmass = primdMass;
1904
1905 // transform to object frame
1906 mat = d.GeomGetOffsetRotation(prim_geom);
1907 d.MassRotate(ref tmpdmass, ref mat);
1908
1909 thispos = d.GeomGetOffsetPosition(prim_geom);
1910 d.MassTranslate(ref tmpdmass,
1911 thispos.X,
1912 thispos.Y,
1913 thispos.Z);
1914
1915 // subtract current prim inertia from object
1916 DMassSubPartFromObj(ref tmpdmass, ref objdmass);
1917
1918 // back prim own inertia
1919 tmpdmass = primdMass;
1920
1921 // update to new position and orientation
1922 _position = NewPos;
1923 d.GeomSetOffsetWorldPosition(prim_geom, NewPos.X, NewPos.Y, NewPos.Z);
1924 _orientation = newrot;
1925 quat.X = newrot.X;
1926 quat.Y = newrot.Y;
1927 quat.Z = newrot.Z;
1928 quat.W = newrot.W;
1929 d.GeomSetOffsetWorldQuaternion(prim_geom, ref quat);
1930
1931 mat = d.GeomGetOffsetRotation(prim_geom);
1932 d.MassRotate(ref tmpdmass, ref mat);
1933
1934 thispos = d.GeomGetOffsetPosition(prim_geom);
1935 d.MassTranslate(ref tmpdmass,
1936 thispos.X,
1937 thispos.Y,
1938 thispos.Z);
1939
1940 d.MassAdd(ref objdmass, ref tmpdmass);
1941
1942 // fix all positions
1943 IntPtr g = d.BodyGetFirstGeom(Body);
1944 while (g != IntPtr.Zero)
1945 {
1946 thispos = d.GeomGetOffsetPosition(g);
1947 thispos.X -= objdmass.c.X;
1948 thispos.Y -= objdmass.c.Y;
1949 thispos.Z -= objdmass.c.Z;
1950 d.GeomSetOffsetPosition(g, thispos.X, thispos.Y, thispos.Z);
1951 g = d.dBodyGetNextGeom(g);
1952 }
1953 d.BodyVectorToWorld(Body,objdmass.c.X, objdmass.c.Y, objdmass.c.Z,out thispos);
1954
1955 d.BodySetPosition(Body, dobjpos.X + thispos.X, dobjpos.Y + thispos.Y, dobjpos.Z + thispos.Z);
1956 d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body
1957 d.BodySetMass(Body, ref objdmass);
1958 _mass = objdmass.mass;
1959 }
1960
1961
1962
1963 private void FixInertia(Vector3 NewPos)
1964 {
1965 d.Matrix3 primmat = new d.Matrix3();
1966 d.Mass tmpdmass = new d.Mass { };
1967 d.Mass objdmass = new d.Mass { };
1968 d.Mass primmass = new d.Mass { };
1969
1970 d.Vector3 dobjpos;
1971 d.Vector3 thispos;
1972
1973 d.BodyGetMass(Body, out objdmass);
1974
1975 // get prim own inertia in its local frame
1976 primmass = primdMass;
1977 // transform to object frame
1978 primmat = d.GeomGetOffsetRotation(prim_geom);
1979 d.MassRotate(ref primmass, ref primmat);
1980
1981 tmpdmass = primmass;
1982
1983 thispos = d.GeomGetOffsetPosition(prim_geom);
1984 d.MassTranslate(ref tmpdmass,
1985 thispos.X,
1986 thispos.Y,
1987 thispos.Z);
1988
1989 // subtract current prim inertia from object
1990 DMassSubPartFromObj(ref tmpdmass, ref objdmass);
1991
1992 // update to new position
1993 _position = NewPos;
1994 d.GeomSetOffsetWorldPosition(prim_geom, NewPos.X, NewPos.Y, NewPos.Z);
1995
1996 thispos = d.GeomGetOffsetPosition(prim_geom);
1997 d.MassTranslate(ref primmass,
1998 thispos.X,
1999 thispos.Y,
2000 thispos.Z);
2001
2002 d.MassAdd(ref objdmass, ref primmass);
2003
2004 // fix all positions
2005 IntPtr g = d.BodyGetFirstGeom(Body);
2006 while (g != IntPtr.Zero)
2007 {
2008 thispos = d.GeomGetOffsetPosition(g);
2009 thispos.X -= objdmass.c.X;
2010 thispos.Y -= objdmass.c.Y;
2011 thispos.Z -= objdmass.c.Z;
2012 d.GeomSetOffsetPosition(g, thispos.X, thispos.Y, thispos.Z);
2013 g = d.dBodyGetNextGeom(g);
2014 }
2015
2016 d.BodyVectorToWorld(Body, objdmass.c.X, objdmass.c.Y, objdmass.c.Z, out thispos);
2017
2018 // get current object position and rotation
2019 dobjpos = d.BodyGetPosition(Body);
2020
2021 d.BodySetPosition(Body, dobjpos.X + thispos.X, dobjpos.Y + thispos.Y, dobjpos.Z + thispos.Z);
2022 d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body
2023 d.BodySetMass(Body, ref objdmass);
2024 _mass = objdmass.mass;
2025 }
2026
2027 private void FixInertia(Quaternion newrot)
2028 {
2029 d.Matrix3 mat = new d.Matrix3();
2030 d.Quaternion quat = new d.Quaternion();
2031
2032 d.Mass tmpdmass = new d.Mass { };
2033 d.Mass objdmass = new d.Mass { };
2034 d.Vector3 dobjpos;
2035 d.Vector3 thispos;
2036
2037 d.BodyGetMass(Body, out objdmass);
2038
2039 // get prim own inertia in its local frame
2040 tmpdmass = primdMass;
2041 mat = d.GeomGetOffsetRotation(prim_geom);
2042 d.MassRotate(ref tmpdmass, ref mat);
2043 // transform to object frame
2044 thispos = d.GeomGetOffsetPosition(prim_geom);
2045 d.MassTranslate(ref tmpdmass,
2046 thispos.X,
2047 thispos.Y,
2048 thispos.Z);
2049
2050 // subtract current prim inertia from object
2051 DMassSubPartFromObj(ref tmpdmass, ref objdmass);
2052
2053 // update to new orientation
2054 _orientation = newrot;
2055 quat.X = newrot.X;
2056 quat.Y = newrot.Y;
2057 quat.Z = newrot.Z;
2058 quat.W = newrot.W;
2059 d.GeomSetOffsetWorldQuaternion(prim_geom, ref quat);
2060
2061 tmpdmass = primdMass;
2062 mat = d.GeomGetOffsetRotation(prim_geom);
2063 d.MassRotate(ref tmpdmass, ref mat);
2064 d.MassTranslate(ref tmpdmass,
2065 thispos.X,
2066 thispos.Y,
2067 thispos.Z);
2068
2069 d.MassAdd(ref objdmass, ref tmpdmass);
2070
2071 // fix all positions
2072 IntPtr g = d.BodyGetFirstGeom(Body);
2073 while (g != IntPtr.Zero)
2074 {
2075 thispos = d.GeomGetOffsetPosition(g);
2076 thispos.X -= objdmass.c.X;
2077 thispos.Y -= objdmass.c.Y;
2078 thispos.Z -= objdmass.c.Z;
2079 d.GeomSetOffsetPosition(g, thispos.X, thispos.Y, thispos.Z);
2080 g = d.dBodyGetNextGeom(g);
2081 }
2082
2083 d.BodyVectorToWorld(Body, objdmass.c.X, objdmass.c.Y, objdmass.c.Z, out thispos);
2084 // get current object position and rotation
2085 dobjpos = d.BodyGetPosition(Body);
2086
2087 d.BodySetPosition(Body, dobjpos.X + thispos.X, dobjpos.Y + thispos.Y, dobjpos.Z + thispos.Z);
2088 d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body
2089 d.BodySetMass(Body, ref objdmass);
2090 _mass = objdmass.mass;
2091 }
2092
2093
2094 #region Mass Calculation
2095
2096 private float CalculatePrimVolume()
2097 {
2098 float volume = _size.X * _size.Y * _size.Z; // default
2099 float tmp;
2100
2101 float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
2102 float hollowVolume = hollowAmount * hollowAmount;
2103
2104 switch (_pbs.ProfileShape)
2105 {
2106 case ProfileShape.Square:
2107 // default box
2108
2109 if (_pbs.PathCurve == (byte)Extrusion.Straight)
2110 {
2111 if (hollowAmount > 0.0)
2112 {
2113 switch (_pbs.HollowShape)
2114 {
2115 case HollowShape.Square:
2116 case HollowShape.Same:
2117 break;
2118
2119 case HollowShape.Circle:
2120
2121 hollowVolume *= 0.78539816339f;
2122 break;
2123
2124 case HollowShape.Triangle:
2125
2126 hollowVolume *= (0.5f * .5f);
2127 break;
2128
2129 default:
2130 hollowVolume = 0;
2131 break;
2132 }
2133 volume *= (1.0f - hollowVolume);
2134 }
2135 }
2136
2137 else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
2138 {
2139 //a tube
2140
2141 volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
2142 tmp = 1.0f - 2.0e-2f * (float)(200 - _pbs.PathScaleY);
2143 volume -= volume * tmp * tmp;
2144
2145 if (hollowAmount > 0.0)
2146 {
2147 hollowVolume *= hollowAmount;
2148
2149 switch (_pbs.HollowShape)
2150 {
2151 case HollowShape.Square:
2152 case HollowShape.Same:
2153 break;
2154
2155 case HollowShape.Circle:
2156 hollowVolume *= 0.78539816339f;
2157 break;
2158
2159 case HollowShape.Triangle:
2160 hollowVolume *= 0.5f * 0.5f;
2161 break;
2162 default:
2163 hollowVolume = 0;
2164 break;
2165 }
2166 volume *= (1.0f - hollowVolume);
2167 }
2168 }
2169
2170 break;
2171
2172 case ProfileShape.Circle:
2173
2174 if (_pbs.PathCurve == (byte)Extrusion.Straight)
2175 {
2176 volume *= 0.78539816339f; // elipse base
2177
2178 if (hollowAmount > 0.0)
2179 {
2180 switch (_pbs.HollowShape)
2181 {
2182 case HollowShape.Same:
2183 case HollowShape.Circle:
2184 break;
2185
2186 case HollowShape.Square:
2187 hollowVolume *= 0.5f * 2.5984480504799f;
2188 break;
2189
2190 case HollowShape.Triangle:
2191 hollowVolume *= .5f * 1.27323954473516f;
2192 break;
2193
2194 default:
2195 hollowVolume = 0;
2196 break;
2197 }
2198 volume *= (1.0f - hollowVolume);
2199 }
2200 }
2201
2202 else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
2203 {
2204 volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);
2205 tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
2206 volume *= (1.0f - tmp * tmp);
2207
2208 if (hollowAmount > 0.0)
2209 {
2210
2211 // calculate the hollow volume by it's shape compared to the prim shape
2212 hollowVolume *= hollowAmount;
2213
2214 switch (_pbs.HollowShape)
2215 {
2216 case HollowShape.Same:
2217 case HollowShape.Circle:
2218 break;
2219
2220 case HollowShape.Square:
2221 hollowVolume *= 0.5f * 2.5984480504799f;
2222 break;
2223
2224 case HollowShape.Triangle:
2225 hollowVolume *= .5f * 1.27323954473516f;
2226 break;
2227
2228 default:
2229 hollowVolume = 0;
2230 break;
2231 }
2232 volume *= (1.0f - hollowVolume);
2233 }
2234 }
2235 break;
2236
2237 case ProfileShape.HalfCircle:
2238 if (_pbs.PathCurve == (byte)Extrusion.Curve1)
2239 {
2240 volume *= 0.52359877559829887307710723054658f;
2241 }
2242 break;
2243
2244 case ProfileShape.EquilateralTriangle:
2245
2246 if (_pbs.PathCurve == (byte)Extrusion.Straight)
2247 {
2248 volume *= 0.32475953f;
2249
2250 if (hollowAmount > 0.0)
2251 {
2252
2253 // calculate the hollow volume by it's shape compared to the prim shape
2254 switch (_pbs.HollowShape)
2255 {
2256 case HollowShape.Same:
2257 case HollowShape.Triangle:
2258 hollowVolume *= .25f;
2259 break;
2260
2261 case HollowShape.Square:
2262 hollowVolume *= 0.499849f * 3.07920140172638f;
2263 break;
2264
2265 case HollowShape.Circle:
2266 // Hollow shape is a perfect cyllinder in respect to the cube's scale
2267 // Cyllinder hollow volume calculation
2268
2269 hollowVolume *= 0.1963495f * 3.07920140172638f;
2270 break;
2271
2272 default:
2273 hollowVolume = 0;
2274 break;
2275 }
2276 volume *= (1.0f - hollowVolume);
2277 }
2278 }
2279 else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
2280 {
2281 volume *= 0.32475953f;
2282 volume *= 0.01f * (float)(200 - _pbs.PathScaleX);
2283 tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
2284 volume *= (1.0f - tmp * tmp);
2285
2286 if (hollowAmount > 0.0)
2287 {
2288
2289 hollowVolume *= hollowAmount;
2290
2291 switch (_pbs.HollowShape)
2292 {
2293 case HollowShape.Same:
2294 case HollowShape.Triangle:
2295 hollowVolume *= .25f;
2296 break;
2297
2298 case HollowShape.Square:
2299 hollowVolume *= 0.499849f * 3.07920140172638f;
2300 break;
2301
2302 case HollowShape.Circle:
2303
2304 hollowVolume *= 0.1963495f * 3.07920140172638f;
2305 break;
2306
2307 default:
2308 hollowVolume = 0;
2309 break;
2310 }
2311 volume *= (1.0f - hollowVolume);
2312 }
2313 }
2314 break;
2315
2316 default:
2317 break;
2318 }
2319
2320 float taperX1;
2321 float taperY1;
2322 float taperX;
2323 float taperY;
2324 float pathBegin;
2325 float pathEnd;
2326 float profileBegin;
2327 float profileEnd;
2328
2329 if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)
2330 {
2331 taperX1 = _pbs.PathScaleX * 0.01f;
2332 if (taperX1 > 1.0f)
2333 taperX1 = 2.0f - taperX1;
2334 taperX = 1.0f - taperX1;
2335
2336 taperY1 = _pbs.PathScaleY * 0.01f;
2337 if (taperY1 > 1.0f)
2338 taperY1 = 2.0f - taperY1;
2339 taperY = 1.0f - taperY1;
2340 }
2341 else
2342 {
2343 taperX = _pbs.PathTaperX * 0.01f;
2344 if (taperX < 0.0f)
2345 taperX = -taperX;
2346 taperX1 = 1.0f - taperX;
2347
2348 taperY = _pbs.PathTaperY * 0.01f;
2349 if (taperY < 0.0f)
2350 taperY = -taperY;
2351 taperY1 = 1.0f - taperY;
2352 }
2353
2354 volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
2355
2356 pathBegin = (float)_pbs.PathBegin * 2.0e-5f;
2357 pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;
2358 volume *= (pathEnd - pathBegin);
2359
2360 // this is crude aproximation
2361 profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
2362 profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
2363 volume *= (profileEnd - profileBegin);
2364
2365 return volume;
2366 }
2367
2368
2369 private void CalcPrimBodyData()
2370 {
2371 float volume;
2372
2373 if (prim_geom == IntPtr.Zero)
2374 {
2375 // Ubit let's have a initial basic OOB
2376 primOOBsize.X = _size.X;
2377 primOOBsize.Y = _size.Y;
2378 primOOBsize.Z = _size.Z;
2379 primOOBoffset = Vector3.Zero;
2380 }
2381 else
2382 {
2383 d.AABB AABB;
2384 d.GeomGetAABB(prim_geom, out AABB); // get the AABB from engine geom
2385
2386 primOOBsize.X = (AABB.MaxX - AABB.MinX);
2387 primOOBsize.Y = (AABB.MaxY - AABB.MinY);
2388 primOOBsize.Z = (AABB.MaxZ - AABB.MinZ);
2389 if (!hasOOBoffsetFromMesh)
2390 {
2391 primOOBoffset.X = (AABB.MaxX + AABB.MinX) * 0.5f;
2392 primOOBoffset.Y = (AABB.MaxY + AABB.MinY) * 0.5f;
2393 primOOBoffset.Z = (AABB.MaxZ + AABB.MinZ) * 0.5f;
2394 }
2395 }
2396
2397 // also its own inertia and mass
2398 // keep using basic shape mass for now
2399 volume = CalculatePrimVolume();
2400
2401 primVolume = volume;
2402 primMass = m_density * volume;
2403
2404 if (primMass <= 0)
2405 primMass = 0.0001f;//ckrinke: Mass must be greater then zero.
2406 if (primMass > _parent_scene.maximumMassObject)
2407 primMass = _parent_scene.maximumMassObject;
2408
2409 _mass = primMass; // just in case
2410
2411 d.MassSetBoxTotal(out primdMass, primMass, primOOBsize.X, primOOBsize.Y, primOOBsize.Z);
2412
2413 d.MassTranslate(ref primdMass,
2414 primOOBoffset.X,
2415 primOOBoffset.Y,
2416 primOOBoffset.Z);
2417
2418 primOOBsize *= 0.5f; // let obb size be a corner coords
2419 primOOBradiusSQ = primOOBsize.LengthSquared();
2420 }
2421
2422
2423 #endregion
2424
2425
2426 /// <summary>
2427 /// Add a child prim to this parent prim.
2428 /// </summary>
2429 /// <param name="prim">Child prim</param>
2430 // I'm the parent
2431 // prim is the child
2432 public void ParentPrim(OdePrim prim)
2433 {
2434 //Console.WriteLine("ParentPrim " + m_primName);
2435 if (this.m_localID != prim.m_localID)
2436 {
2437 DestroyBody(); // for now we need to rebuil entire object on link change
2438
2439 lock (childrenPrim)
2440 {
2441 // adopt the prim
2442 if (!childrenPrim.Contains(prim))
2443 childrenPrim.Add(prim);
2444
2445 // see if this prim has kids and adopt them also
2446 // should not happen for now
2447 foreach (OdePrim prm in prim.childrenPrim)
2448 {
2449 if (!childrenPrim.Contains(prm))
2450 {
2451 if (prm.Body != IntPtr.Zero)
2452 {
2453 if (prm.prim_geom != IntPtr.Zero)
2454 d.GeomSetBody(prm.prim_geom, IntPtr.Zero);
2455 if (prm.Body != prim.Body)
2456 prm.DestroyBody(); // don't loose bodies around
2457 prm.Body = IntPtr.Zero;
2458 }
2459
2460 childrenPrim.Add(prm);
2461 prm._parent = this;
2462 }
2463 }
2464 }
2465 //Remove old children from the prim
2466 prim.childrenPrim.Clear();
2467
2468 if (prim.Body != IntPtr.Zero)
2469 {
2470 if (prim.prim_geom != IntPtr.Zero)
2471 d.GeomSetBody(prim.prim_geom, IntPtr.Zero);
2472 prim.DestroyBody(); // don't loose bodies around
2473 prim.Body = IntPtr.Zero;
2474 }
2475
2476 prim.childPrim = true;
2477 prim._parent = this;
2478
2479 MakeBody(); // full nasty reconstruction
2480 }
2481 }
2482
2483 private void UpdateChildsfromgeom()
2484 {
2485 if (childrenPrim.Count > 0)
2486 {
2487 foreach (OdePrim prm in childrenPrim)
2488 prm.UpdateDataFromGeom();
2489 }
2490 }
2491
2492 private void UpdateDataFromGeom()
2493 {
2494 if (prim_geom != IntPtr.Zero)
2495 {
2496 d.Quaternion qtmp;
2497 d.GeomCopyQuaternion(prim_geom, out qtmp);
2498 _orientation.W = qtmp.W;
2499 _orientation.X = qtmp.X;
2500 _orientation.Y = qtmp.Y;
2501 _orientation.Z = qtmp.Z;
2502
2503 d.Vector3 lpos = d.GeomGetPosition(prim_geom);
2504 _position.X = lpos.X;
2505 _position.Y = lpos.Y;
2506 _position.Z = lpos.Z;
2507 }
2508 }
2509
2510 private void ChildDelink(OdePrim odePrim, bool remakebodies)
2511 {
2512 // Okay, we have a delinked child.. destroy all body and remake
2513 if (odePrim != this && !childrenPrim.Contains(odePrim))
2514 return;
2515
2516 DestroyBody();
2517
2518 if (odePrim == this) // delinking the root prim
2519 {
2520 OdePrim newroot = null;
2521 lock (childrenPrim)
2522 {
2523 if (childrenPrim.Count > 0)
2524 {
2525 newroot = childrenPrim[0];
2526 childrenPrim.RemoveAt(0);
2527 foreach (OdePrim prm in childrenPrim)
2528 {
2529 newroot.childrenPrim.Add(prm);
2530 }
2531 childrenPrim.Clear();
2532 }
2533 if (newroot != null)
2534 {
2535 newroot.childPrim = false;
2536 newroot._parent = null;
2537 if (remakebodies)
2538 newroot.MakeBody();
2539 }
2540 }
2541 }
2542
2543 else
2544 {
2545 lock (childrenPrim)
2546 {
2547 childrenPrim.Remove(odePrim);
2548 odePrim.childPrim = false;
2549 odePrim._parent = null;
2550 // odePrim.UpdateDataFromGeom();
2551 if (remakebodies)
2552 odePrim.MakeBody();
2553 }
2554 }
2555 if (remakebodies)
2556 MakeBody();
2557 }
2558
2559 protected void ChildRemove(OdePrim odePrim, bool reMakeBody)
2560 {
2561 // Okay, we have a delinked child.. destroy all body and remake
2562 if (odePrim != this && !childrenPrim.Contains(odePrim))
2563 return;
2564
2565 DestroyBody();
2566
2567 if (odePrim == this)
2568 {
2569 OdePrim newroot = null;
2570 lock (childrenPrim)
2571 {
2572 if (childrenPrim.Count > 0)
2573 {
2574 newroot = childrenPrim[0];
2575 childrenPrim.RemoveAt(0);
2576 foreach (OdePrim prm in childrenPrim)
2577 {
2578 newroot.childrenPrim.Add(prm);
2579 }
2580 childrenPrim.Clear();
2581 }
2582 if (newroot != null)
2583 {
2584 newroot.childPrim = false;
2585 newroot._parent = null;
2586 newroot.MakeBody();
2587 }
2588 }
2589 if (reMakeBody)
2590 MakeBody();
2591 return;
2592 }
2593 else
2594 {
2595 lock (childrenPrim)
2596 {
2597 childrenPrim.Remove(odePrim);
2598 odePrim.childPrim = false;
2599 odePrim._parent = null;
2600 if (reMakeBody)
2601 odePrim.MakeBody();
2602 }
2603 }
2604 MakeBody();
2605 }
2606
2607 #region changes
2608
2609 private void changeadd()
2610 {
2611 CreateGeom();
2612
2613 if (prim_geom != IntPtr.Zero)
2614 {
2615 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
2616 d.Quaternion myrot = new d.Quaternion();
2617 myrot.X = _orientation.X;
2618 myrot.Y = _orientation.Y;
2619 myrot.Z = _orientation.Z;
2620 myrot.W = _orientation.W;
2621 d.GeomSetQuaternion(prim_geom, ref myrot);
2622
2623 if (!m_isphysical)
2624 {
2625 SetInStaticSpace(this);
2626 UpdateCollisionCatFlags();
2627 ApplyCollisionCatFlags();
2628 }
2629 else
2630 MakeBody();
2631 }
2632 }
2633
2634 private void changeAngularLock(Vector3 newLock)
2635 {
2636 // do we have a Physical object?
2637 if (Body != IntPtr.Zero)
2638 {
2639 //Check that we have a Parent
2640 //If we have a parent then we're not authorative here
2641 if (_parent == null)
2642 {
2643 if (!newLock.ApproxEquals(Vector3.One, 0f))
2644 {
2645 createAMotor(newLock);
2646 }
2647 else
2648 {
2649 if (Amotor != IntPtr.Zero)
2650 {
2651 d.JointDestroy(Amotor);
2652 Amotor = IntPtr.Zero;
2653 }
2654 }
2655 }
2656 }
2657 // Store this for later in case we get turned into a separate body
2658 m_angularlock = newLock;
2659 }
2660
2661 private void changeLink(OdePrim NewParent)
2662 {
2663 if (_parent == null && NewParent != null)
2664 {
2665 NewParent.ParentPrim(this);
2666 }
2667 else if (_parent != null)
2668 {
2669 if (_parent is OdePrim)
2670 {
2671 if (NewParent != _parent)
2672 {
2673 (_parent as OdePrim).ChildDelink(this, false); // for now...
2674 childPrim = false;
2675
2676 if (NewParent != null)
2677 {
2678 NewParent.ParentPrim(this);
2679 }
2680 }
2681 }
2682 }
2683 _parent = NewParent;
2684 }
2685
2686
2687 private void Stop()
2688 {
2689 if (!childPrim)
2690 {
2691 m_force = Vector3.Zero;
2692 m_forceacc = Vector3.Zero;
2693 m_angularForceacc = Vector3.Zero;
2694 _torque = Vector3.Zero;
2695 _velocity = Vector3.Zero;
2696 _acceleration = Vector3.Zero;
2697 m_rotationalVelocity = Vector3.Zero;
2698 _target_velocity = Vector3.Zero;
2699 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
2700 m_vehicle.Stop();
2701 }
2702
2703 if (Body != IntPtr.Zero)
2704 {
2705 d.BodySetForce(Body, 0f, 0f, 0f);
2706 d.BodySetTorque(Body, 0f, 0f, 0f);
2707 d.BodySetLinearVel(Body, 0f, 0f, 0f);
2708 d.BodySetAngularVel(Body, 0f, 0f, 0f);
2709 }
2710 }
2711
2712 private void changePhantomStatus(bool newval)
2713 {
2714 m_isphantom = newval;
2715
2716 UpdateCollisionCatFlags();
2717 ApplyCollisionCatFlags();
2718 }
2719
2720/* not in use
2721 internal void ChildSelectedChange(bool childSelect)
2722 {
2723 if(childPrim)
2724 return;
2725
2726 if (childSelect == m_isSelected)
2727 return;
2728
2729 if (childSelect)
2730 {
2731 DoSelectedStatus(true);
2732 }
2733
2734 else
2735 {
2736 foreach (OdePrim prm in childrenPrim)
2737 {
2738 if (prm.m_isSelected)
2739 return;
2740 }
2741 DoSelectedStatus(false);
2742 }
2743 }
2744*/
2745 private void changeSelectedStatus(bool newval)
2746 {
2747 if (m_lastdoneSelected == newval)
2748 return;
2749
2750 m_lastdoneSelected = newval;
2751 DoSelectedStatus(newval);
2752 }
2753
2754 private void CheckDelaySelect()
2755 {
2756 if (m_delaySelect)
2757 {
2758 DoSelectedStatus(m_isSelected);
2759 }
2760 }
2761
2762 private void DoSelectedStatus(bool newval)
2763 {
2764 m_isSelected = newval;
2765 Stop();
2766
2767 if (newval)
2768 {
2769 if (!childPrim && Body != IntPtr.Zero)
2770 d.BodyDisable(Body);
2771
2772 if (m_delaySelect || m_isphysical)
2773 {
2774 m_collisionCategories = CollisionCategories.Selected;
2775 m_collisionFlags = 0;
2776
2777 if (!childPrim)
2778 {
2779 foreach (OdePrim prm in childrenPrim)
2780 {
2781 prm.m_collisionCategories = m_collisionCategories;
2782 prm.m_collisionFlags = m_collisionFlags;
2783
2784 if (prm.prim_geom != null)
2785 {
2786
2787 if (prm.m_NoColide)
2788 {
2789 d.GeomSetCategoryBits(prm.prim_geom, 0);
2790 d.GeomSetCollideBits(prm.prim_geom, 0);
2791 }
2792 else
2793 {
2794 d.GeomSetCategoryBits(prm.prim_geom, (uint)m_collisionCategories);
2795 d.GeomSetCollideBits(prm.prim_geom, (uint)m_collisionFlags);
2796 }
2797 }
2798 prm.m_delaySelect = false;
2799 }
2800 }
2801// else if (_parent != null)
2802// ((OdePrim)_parent).ChildSelectedChange(true);
2803
2804
2805 if (prim_geom != null)
2806 {
2807 if (m_NoColide)
2808 {
2809 d.GeomSetCategoryBits(prim_geom, 0);
2810 d.GeomSetCollideBits(prim_geom, 0);
2811 if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)
2812 {
2813 d.GeomSetCategoryBits(collide_geom, 0);
2814 d.GeomSetCollideBits(collide_geom, 0);
2815 }
2816
2817 }
2818 else
2819 {
2820 d.GeomSetCategoryBits(prim_geom, (uint)m_collisionCategories);
2821 d.GeomSetCollideBits(prim_geom, (uint)m_collisionFlags);
2822 if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)
2823 {
2824 d.GeomSetCategoryBits(collide_geom, (uint)m_collisionCategories);
2825 d.GeomSetCollideBits(collide_geom, (uint)m_collisionFlags);
2826 }
2827 }
2828 }
2829
2830 m_delaySelect = false;
2831 }
2832 else if(!m_isphysical)
2833 {
2834 m_delaySelect = true;
2835 }
2836 }
2837 else
2838 {
2839 if (!childPrim)
2840 {
2841 if (Body != IntPtr.Zero && !m_disabled)
2842 d.BodyEnable(Body);
2843 }
2844// else if (_parent != null)
2845// ((OdePrim)_parent).ChildSelectedChange(false);
2846
2847 UpdateCollisionCatFlags();
2848 ApplyCollisionCatFlags();
2849
2850 m_delaySelect = false;
2851 }
2852
2853 resetCollisionAccounting();
2854 }
2855
2856 private void changePosition(Vector3 newPos)
2857 {
2858 CheckDelaySelect();
2859 if (m_isphysical)
2860 {
2861 if (childPrim) // inertia is messed, must rebuild
2862 {
2863 if (m_building)
2864 {
2865 _position = newPos;
2866 }
2867
2868 else if (m_forcePosOrRotation && _position != newPos && Body != IntPtr.Zero)
2869 {
2870 FixInertia(newPos);
2871 if (!d.BodyIsEnabled(Body))
2872 d.BodyEnable(Body);
2873 }
2874 }
2875 else
2876 {
2877 if (_position != newPos)
2878 {
2879 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2880 _position = newPos;
2881 }
2882 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2883 d.BodyEnable(Body);
2884 }
2885 }
2886 else
2887 {
2888 if (prim_geom != IntPtr.Zero)
2889 {
2890 if (newPos != _position)
2891 {
2892 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2893 _position = newPos;
2894
2895 m_targetSpace = _parent_scene.MoveGeomToStaticSpace(prim_geom, _position, m_targetSpace);
2896 }
2897 }
2898 }
2899 givefakepos--;
2900 if (givefakepos < 0)
2901 givefakepos = 0;
2902 // changeSelectedStatus();
2903 resetCollisionAccounting();
2904 }
2905
2906 private void changeOrientation(Quaternion newOri)
2907 {
2908 CheckDelaySelect();
2909 if (m_isphysical)
2910 {
2911 if (childPrim) // inertia is messed, must rebuild
2912 {
2913 if (m_building)
2914 {
2915 _orientation = newOri;
2916 }
2917 /*
2918 else if (m_forcePosOrRotation && _orientation != newOri && Body != IntPtr.Zero)
2919 {
2920 FixInertia(_position, newOri);
2921 if (!d.BodyIsEnabled(Body))
2922 d.BodyEnable(Body);
2923 }
2924 */
2925 }
2926 else
2927 {
2928 if (newOri != _orientation)
2929 {
2930 d.Quaternion myrot = new d.Quaternion();
2931 myrot.X = newOri.X;
2932 myrot.Y = newOri.Y;
2933 myrot.Z = newOri.Z;
2934 myrot.W = newOri.W;
2935 d.GeomSetQuaternion(prim_geom, ref myrot);
2936 _orientation = newOri;
2937 if (Body != IntPtr.Zero && !m_angularlock.ApproxEquals(Vector3.One, 0f))
2938 createAMotor(m_angularlock);
2939 }
2940 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2941 d.BodyEnable(Body);
2942 }
2943 }
2944 else
2945 {
2946 if (prim_geom != IntPtr.Zero)
2947 {
2948 if (newOri != _orientation)
2949 {
2950 d.Quaternion myrot = new d.Quaternion();
2951 myrot.X = newOri.X;
2952 myrot.Y = newOri.Y;
2953 myrot.Z = newOri.Z;
2954 myrot.W = newOri.W;
2955 d.GeomSetQuaternion(prim_geom, ref myrot);
2956 _orientation = newOri;
2957 }
2958 }
2959 }
2960 givefakeori--;
2961 if (givefakeori < 0)
2962 givefakeori = 0;
2963 resetCollisionAccounting();
2964 }
2965
2966 private void changePositionAndOrientation(Vector3 newPos, Quaternion newOri)
2967 {
2968 CheckDelaySelect();
2969 if (m_isphysical)
2970 {
2971 if (childPrim && m_building) // inertia is messed, must rebuild
2972 {
2973 _position = newPos;
2974 _orientation = newOri;
2975 }
2976 else
2977 {
2978 if (newOri != _orientation)
2979 {
2980 d.Quaternion myrot = new d.Quaternion();
2981 myrot.X = newOri.X;
2982 myrot.Y = newOri.Y;
2983 myrot.Z = newOri.Z;
2984 myrot.W = newOri.W;
2985 d.GeomSetQuaternion(prim_geom, ref myrot);
2986 _orientation = newOri;
2987 if (Body != IntPtr.Zero && !m_angularlock.ApproxEquals(Vector3.One, 0f))
2988 createAMotor(m_angularlock);
2989 }
2990 if (_position != newPos)
2991 {
2992 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2993 _position = newPos;
2994 }
2995 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2996 d.BodyEnable(Body);
2997 }
2998 }
2999 else
3000 {
3001 // string primScenAvatarIn = _parent_scene.whichspaceamIin(_position);
3002 // int[] arrayitem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
3003
3004 if (prim_geom != IntPtr.Zero)
3005 {
3006 if (newOri != _orientation)
3007 {
3008 d.Quaternion myrot = new d.Quaternion();
3009 myrot.X = newOri.X;
3010 myrot.Y = newOri.Y;
3011 myrot.Z = newOri.Z;
3012 myrot.W = newOri.W;
3013 d.GeomSetQuaternion(prim_geom, ref myrot);
3014 _orientation = newOri;
3015 }
3016
3017 if (newPos != _position)
3018 {
3019 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
3020 _position = newPos;
3021
3022 m_targetSpace = _parent_scene.MoveGeomToStaticSpace(prim_geom, _position, m_targetSpace);
3023 }
3024 }
3025 }
3026 givefakepos--;
3027 if (givefakepos < 0)
3028 givefakepos = 0;
3029 givefakeori--;
3030 if (givefakeori < 0)
3031 givefakeori = 0;
3032 resetCollisionAccounting();
3033 }
3034
3035
3036 private void changeDisable(bool disable)
3037 {
3038 if (disable)
3039 {
3040 if (!m_disabled)
3041 disableBodySoft();
3042 }
3043 else
3044 {
3045 if (m_disabled)
3046 enableBodySoft();
3047 }
3048 }
3049
3050 private void changePhysicsStatus(bool NewStatus)
3051 {
3052 CheckDelaySelect();
3053
3054 m_isphysical = NewStatus;
3055
3056 if (!childPrim)
3057 {
3058 if (NewStatus)
3059 {
3060 if (Body == IntPtr.Zero)
3061 MakeBody();
3062 }
3063 else
3064 {
3065 if (Body != IntPtr.Zero)
3066 {
3067 DestroyBody();
3068 }
3069 Stop();
3070 }
3071 }
3072
3073 resetCollisionAccounting();
3074 }
3075
3076 private void changeprimsizeshape()
3077 {
3078 CheckDelaySelect();
3079
3080 OdePrim parent = (OdePrim)_parent;
3081
3082 bool chp = childPrim;
3083
3084 if (chp)
3085 {
3086 if (parent != null)
3087 {
3088 parent.DestroyBody();
3089 }
3090 }
3091 else
3092 {
3093 DestroyBody();
3094 }
3095
3096 RemoveGeom();
3097
3098 // we don't need to do space calculation because the client sends a position update also.
3099 if (_size.X <= 0)
3100 _size.X = 0.01f;
3101 if (_size.Y <= 0)
3102 _size.Y = 0.01f;
3103 if (_size.Z <= 0)
3104 _size.Z = 0.01f;
3105 // Construction of new prim
3106
3107 CreateGeom();
3108
3109 if (prim_geom != IntPtr.Zero)
3110 {
3111 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
3112 d.Quaternion myrot = new d.Quaternion();
3113 myrot.X = _orientation.X;
3114 myrot.Y = _orientation.Y;
3115 myrot.Z = _orientation.Z;
3116 myrot.W = _orientation.W;
3117 d.GeomSetQuaternion(prim_geom, ref myrot);
3118 }
3119
3120 if (m_isphysical)
3121 {
3122 if (chp)
3123 {
3124 if (parent != null)
3125 {
3126 parent.MakeBody();
3127 }
3128 }
3129 else
3130 MakeBody();
3131 }
3132
3133 else
3134 {
3135 UpdateCollisionCatFlags();
3136 ApplyCollisionCatFlags();
3137 }
3138
3139 resetCollisionAccounting();
3140 }
3141
3142 private void changeSize(Vector3 newSize)
3143 {
3144 _size = newSize;
3145 changeprimsizeshape();
3146 }
3147
3148 private void changeShape(PrimitiveBaseShape newShape)
3149 {
3150 if(newShape != null)
3151 _pbs = newShape;
3152 changeprimsizeshape();
3153 }
3154
3155 private void changeFloatOnWater(bool newval)
3156 {
3157 m_collidesWater = newval;
3158
3159 UpdateCollisionCatFlags();
3160 ApplyCollisionCatFlags();
3161 }
3162
3163 private void changeSetTorque(Vector3 newtorque)
3164 {
3165 if (!m_isSelected)
3166 {
3167 if (m_isphysical && Body != IntPtr.Zero)
3168 {
3169 if (m_disabled)
3170 enableBodySoft();
3171 else if (!d.BodyIsEnabled(Body))
3172 d.BodyEnable(Body);
3173
3174 }
3175 _torque = newtorque;
3176 }
3177 }
3178
3179 private void changeForce(Vector3 force)
3180 {
3181 m_force = force;
3182 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
3183 d.BodyEnable(Body);
3184 }
3185
3186
3187 private void changeAddImpulse(Vector3 impulse)
3188 {
3189 m_forceacc += impulse * m_invTimeStep;
3190 if (!m_isSelected)
3191 {
3192 lock (this)
3193 {
3194 //m_log.Info("[PHYSICS]: dequeing forcelist");
3195 if (m_isphysical && Body != IntPtr.Zero)
3196 {
3197 if (m_disabled)
3198 enableBodySoft();
3199 else if (!d.BodyIsEnabled(Body))
3200 d.BodyEnable(Body);
3201 }
3202 }
3203
3204 m_collisionscore = 0;
3205 }
3206 }
3207
3208 // actually angular impulse
3209 private void changeAddAngularImpulse(Vector3 aimpulse)
3210 {
3211 m_angularForceacc += aimpulse * m_invTimeStep;
3212 if (!m_isSelected)
3213 {
3214 lock (this)
3215 {
3216 if (m_isphysical && Body != IntPtr.Zero)
3217 {
3218 if (m_disabled)
3219 enableBodySoft();
3220 else if (!d.BodyIsEnabled(Body))
3221 d.BodyEnable(Body);
3222 }
3223 }
3224 m_collisionscore = 0;
3225 }
3226 }
3227
3228 private void changevelocity(Vector3 newVel)
3229 {
3230 if (!m_isSelected)
3231 {
3232 if (Body != IntPtr.Zero)
3233 {
3234 if (m_disabled)
3235 enableBodySoft();
3236 else if (!d.BodyIsEnabled(Body))
3237 d.BodyEnable(Body);
3238
3239 d.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);
3240 }
3241 //resetCollisionAccounting();
3242 }
3243 _velocity = newVel;
3244 }
3245
3246 private void changeVolumedetetion(bool newVolDtc)
3247 {
3248 m_isVolumeDetect = newVolDtc;
3249 m_fakeisVolumeDetect = newVolDtc;
3250 UpdateCollisionCatFlags();
3251 ApplyCollisionCatFlags();
3252 }
3253
3254 protected void changeBuilding(bool newbuilding)
3255 {
3256 if ((bool)newbuilding)
3257 {
3258 m_building = true;
3259 if (!childPrim)
3260 DestroyBody();
3261 }
3262 else
3263 {
3264 m_building = false;
3265 CheckDelaySelect();
3266 if (!childPrim)
3267 MakeBody();
3268 }
3269 if (!childPrim && childrenPrim.Count > 0)
3270 {
3271 foreach (OdePrim prm in childrenPrim)
3272 prm.changeBuilding(m_building); // call directly
3273 }
3274 }
3275
3276 public void changeSetVehicle(VehicleData vdata)
3277 {
3278 if (m_vehicle == null)
3279 m_vehicle = new ODEDynamics(this);
3280 m_vehicle.DoSetVehicle(vdata);
3281 }
3282 private void changeVehicleType(int value)
3283 {
3284 if (value == (int)Vehicle.TYPE_NONE)
3285 {
3286 if (m_vehicle != null)
3287 m_vehicle = null;
3288 }
3289 else
3290 {
3291 if (m_vehicle == null)
3292 m_vehicle = new ODEDynamics(this);
3293
3294 m_vehicle.ProcessTypeChange((Vehicle)value);
3295 }
3296 }
3297
3298 private void changeVehicleFloatParam(strVehicleFloatParam fp)
3299 {
3300 if (m_vehicle == null)
3301 return;
3302
3303 m_vehicle.ProcessFloatVehicleParam((Vehicle)fp.param, fp.value);
3304 }
3305
3306 private void changeVehicleVectorParam(strVehicleVectorParam vp)
3307 {
3308 if (m_vehicle == null)
3309 return;
3310 m_vehicle.ProcessVectorVehicleParam((Vehicle)vp.param, vp.value);
3311 }
3312
3313 private void changeVehicleRotationParam(strVehicleQuatParam qp)
3314 {
3315 if (m_vehicle == null)
3316 return;
3317 m_vehicle.ProcessRotationVehicleParam((Vehicle)qp.param, qp.value);
3318 }
3319
3320 private void changeVehicleFlags(strVehicleBoolParam bp)
3321 {
3322 if (m_vehicle == null)
3323 return;
3324 m_vehicle.ProcessVehicleFlags(bp.param, bp.value);
3325 }
3326
3327 #endregion
3328
3329 public void Move()
3330 {
3331 if (!childPrim && m_isphysical && Body != IntPtr.Zero &&
3332 !m_disabled && !m_isSelected && !m_building && !m_outbounds)
3333 {
3334 if (!d.BodyIsEnabled(Body))
3335 {
3336 // let vehicles sleep
3337 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
3338 return;
3339
3340 if (++bodydisablecontrol < 20)
3341 return;
3342
3343 bodydisablecontrol = 0;
3344 d.BodyEnable(Body);
3345 }
3346
3347 // check outside region
3348 d.Vector3 lpos = d.GeomGetPosition(prim_geom); // root position that is seem by rest of simulator
3349
3350 if (lpos.Z < -100 || lpos.Z > 100000f)
3351 {
3352 m_outbounds = true;
3353
3354 lpos.Z = Util.Clip(lpos.Z, -100f, 100000f);
3355 _acceleration.X = 0;
3356 _acceleration.Y = 0;
3357 _acceleration.Z = 0;
3358
3359 _velocity.X = 0;
3360 _velocity.Y = 0;
3361 _velocity.Z = 0;
3362 m_rotationalVelocity.X = 0;
3363 m_rotationalVelocity.Y = 0;
3364 m_rotationalVelocity.Z = 0;
3365
3366 d.BodySetLinearVel(Body, 0, 0, 0); // stop it
3367 d.BodySetAngularVel(Body, 0, 0, 0); // stop it
3368 d.BodySetPosition(Body, lpos.X, lpos.Y, lpos.Z); // put it somewhere
3369 m_lastposition = _position;
3370 m_lastorientation = _orientation;
3371
3372 base.RequestPhysicsterseUpdate();
3373
3374 throttleCounter = 0;
3375 _zeroFlag = true;
3376
3377 disableBodySoft(); // disable it and colisions
3378 base.RaiseOutOfBounds(_position);
3379 return;
3380 }
3381
3382 if (lpos.X < 0f)
3383 {
3384 _position.X = Util.Clip(lpos.X, -2f, -0.1f);
3385 m_outbounds = true;
3386 }
3387 else if (lpos.X > _parent_scene.WorldExtents.X)
3388 {
3389 _position.X = Util.Clip(lpos.X, _parent_scene.WorldExtents.X + 0.1f, _parent_scene.WorldExtents.X + 2f);
3390 m_outbounds = true;
3391 }
3392 if (lpos.Y < 0f)
3393 {
3394 _position.Y = Util.Clip(lpos.Y, -2f, -0.1f);
3395 m_outbounds = true;
3396 }
3397 else if (lpos.Y > _parent_scene.WorldExtents.Y)
3398 {
3399 _position.Y = Util.Clip(lpos.Y, _parent_scene.WorldExtents.Y + 0.1f, _parent_scene.WorldExtents.Y + 2f);
3400 m_outbounds = true;
3401 }
3402
3403 if (m_outbounds)
3404 {
3405 m_lastposition = _position;
3406 m_lastorientation = _orientation;
3407
3408 d.Vector3 dtmp = d.BodyGetAngularVel(Body);
3409 m_rotationalVelocity.X = dtmp.X;
3410 m_rotationalVelocity.Y = dtmp.Y;
3411 m_rotationalVelocity.Z = dtmp.Z;
3412
3413 dtmp = d.BodyGetLinearVel(Body);
3414 _velocity.X = dtmp.X;
3415 _velocity.Y = dtmp.Y;
3416 _velocity.Z = dtmp.Z;
3417
3418 d.BodySetLinearVel(Body, 0, 0, 0); // stop it
3419 d.BodySetAngularVel(Body, 0, 0, 0);
3420 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
3421 disableBodySoft(); // stop collisions
3422 base.RequestPhysicsterseUpdate();
3423 return;
3424 }
3425
3426 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
3427 {
3428 // 'VEHICLES' are dealt with in ODEDynamics.cs
3429 m_vehicle.Step();
3430 return;
3431 }
3432
3433 float fx = 0;
3434 float fy = 0;
3435 float fz = 0;
3436
3437 float m_mass = _mass;
3438
3439 if (m_usePID && m_PIDTau > 0)
3440 {
3441 // for now position error
3442 _target_velocity =
3443 new Vector3(
3444 (m_PIDTarget.X - lpos.X),
3445 (m_PIDTarget.Y - lpos.Y),
3446 (m_PIDTarget.Z - lpos.Z)
3447 );
3448
3449 if (_target_velocity.ApproxEquals(Vector3.Zero, 0.02f))
3450 {
3451 d.BodySetPosition(Body, m_PIDTarget.X, m_PIDTarget.Y, m_PIDTarget.Z);
3452 d.BodySetLinearVel(Body, 0, 0, 0);
3453 return;
3454 }
3455 else
3456 {
3457 _zeroFlag = false;
3458
3459 float tmp = 1 / m_PIDTau;
3460 _target_velocity *= tmp;
3461
3462 // apply limits
3463 tmp = _target_velocity.Length();
3464 if (tmp > 50.0f)
3465 {
3466 tmp = 50 / tmp;
3467 _target_velocity *= tmp;
3468 }
3469 else if (tmp < 0.05f)
3470 {
3471 tmp = 0.05f / tmp;
3472 _target_velocity *= tmp;
3473 }
3474
3475 d.Vector3 vel = d.BodyGetLinearVel(Body);
3476 fx = (_target_velocity.X - vel.X) * m_invTimeStep;
3477 fy = (_target_velocity.Y - vel.Y) * m_invTimeStep;
3478 fz = (_target_velocity.Z - vel.Z) * m_invTimeStep;
3479 }
3480 } // end if (m_usePID)
3481
3482 // Hover PID Controller needs to be mutually exlusive to MoveTo PID controller
3483 else if (m_useHoverPID && m_PIDHoverTau != 0 && m_PIDHoverHeight != 0)
3484 {
3485
3486 // Non-Vehicles have a limited set of Hover options.
3487 // determine what our target height really is based on HoverType
3488
3489 m_groundHeight = _parent_scene.GetTerrainHeightAtXY(lpos.X, lpos.Y);
3490
3491 switch (m_PIDHoverType)
3492 {
3493 case PIDHoverType.Ground:
3494 m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
3495 break;
3496
3497 case PIDHoverType.GroundAndWater:
3498 m_waterHeight = _parent_scene.GetWaterLevel();
3499 if (m_groundHeight > m_waterHeight)
3500 m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
3501 else
3502 m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight;
3503 break;
3504 } // end switch (m_PIDHoverType)
3505
3506 // don't go underground unless volumedetector
3507
3508 if (m_targetHoverHeight > m_groundHeight || m_isVolumeDetect)
3509 {
3510 d.Vector3 vel = d.BodyGetLinearVel(Body);
3511
3512 fz = (m_targetHoverHeight - lpos.Z);
3513
3514 // if error is zero, use position control; otherwise, velocity control
3515 if (Math.Abs(fz) < 0.01f)
3516 {
3517 d.BodySetPosition(Body, lpos.X, lpos.Y, m_targetHoverHeight);
3518 d.BodySetLinearVel(Body, vel.X, vel.Y, 0);
3519 }
3520 else
3521 {
3522 _zeroFlag = false;
3523 fz /= m_PIDHoverTau;
3524
3525 float tmp = Math.Abs(fz);
3526 if (tmp > 50)
3527 fz = 50 * Math.Sign(fz);
3528 else if (tmp < 0.1)
3529 fz = 0.1f * Math.Sign(fz);
3530
3531 fz = ((fz - vel.Z) * m_invTimeStep);
3532 }
3533 }
3534 }
3535 else
3536 {
3537 float b = (1.0f - m_buoyancy);
3538 fx = _parent_scene.gravityx * b;
3539 fy = _parent_scene.gravityy * b;
3540 fz = _parent_scene.gravityz * b;
3541 }
3542
3543 fx *= m_mass;
3544 fy *= m_mass;
3545 fz *= m_mass;
3546
3547 // constant force
3548 fx += m_force.X;
3549 fy += m_force.Y;
3550 fz += m_force.Z;
3551
3552 fx += m_forceacc.X;
3553 fy += m_forceacc.Y;
3554 fz += m_forceacc.Z;
3555
3556 m_forceacc = Vector3.Zero;
3557
3558 //m_log.Info("[OBJPID]: X:" + fx.ToString() + " Y:" + fy.ToString() + " Z:" + fz.ToString());
3559 if (fx != 0 || fy != 0 || fz != 0)
3560 {
3561 d.BodyAddForce(Body, fx, fy, fz);
3562 //Console.WriteLine("AddForce " + fx + "," + fy + "," + fz);
3563 }
3564
3565 Vector3 trq;
3566
3567 trq = _torque;
3568 trq += m_angularForceacc;
3569 m_angularForceacc = Vector3.Zero;
3570 if (trq.X != 0 || trq.Y != 0 || trq.Z != 0)
3571 {
3572 d.BodyAddTorque(Body, trq.X, trq.Y, trq.Z);
3573 }
3574 }
3575 else
3576 { // is not physical, or is not a body or is selected
3577 // _zeroPosition = d.BodyGetPosition(Body);
3578 return;
3579 //Console.WriteLine("Nothing " + Name);
3580
3581 }
3582 }
3583
3584 public void UpdatePositionAndVelocity()
3585 {
3586 if (_parent == null && !m_disabled && !m_building && !m_outbounds && Body != IntPtr.Zero)
3587 {
3588 if (d.BodyIsEnabled(Body) || !_zeroFlag)
3589 {
3590 bool lastZeroFlag = _zeroFlag;
3591
3592 d.Vector3 lpos = d.GeomGetPosition(prim_geom);
3593
3594 d.Quaternion ori;
3595 d.GeomCopyQuaternion(prim_geom, out ori);
3596
3597 // decide if moving
3598 // use positions since this are integrated quantities
3599 // tolerance values depende a lot on simulation noise...
3600 // use simple math.abs since we dont need to be exact
3601
3602 if (
3603 (Math.Abs(_position.X - lpos.X) < 0.001f)
3604 && (Math.Abs(_position.Y - lpos.Y) < 0.001f)
3605 && (Math.Abs(_position.Z - lpos.Z) < 0.001f)
3606 && (Math.Abs(_orientation.X - ori.X) < 0.0001f)
3607 && (Math.Abs(_orientation.Y - ori.Y) < 0.0001f)
3608 && (Math.Abs(_orientation.Z - ori.Z) < 0.0001f) // ignore W
3609 )
3610 {
3611 _zeroFlag = true;
3612 }
3613 else
3614 _zeroFlag = false;
3615
3616 // update velocities and aceleration
3617 if (!(_zeroFlag && lastZeroFlag))
3618 {
3619 d.Vector3 vel = d.BodyGetLinearVel(Body);
3620
3621 _acceleration = _velocity;
3622
3623 if ((Math.Abs(vel.X) < 0.001f) &&
3624 (Math.Abs(vel.Y) < 0.001f) &&
3625 (Math.Abs(vel.Z) < 0.001f))
3626 {
3627 _velocity = Vector3.Zero;
3628 float t = -m_invTimeStep;
3629 _acceleration = _acceleration * t;
3630 }
3631 else
3632 {
3633 _velocity.X = vel.X;
3634 _velocity.Y = vel.Y;
3635 _velocity.Z = vel.Z;
3636 _acceleration = (_velocity - _acceleration) * m_invTimeStep;
3637 }
3638
3639 if ((Math.Abs(_acceleration.X) < 0.01f) &&
3640 (Math.Abs(_acceleration.Y) < 0.01f) &&
3641 (Math.Abs(_acceleration.Z) < 0.01f))
3642 {
3643 _acceleration = Vector3.Zero;
3644 }
3645
3646 if ((Math.Abs(_orientation.X - ori.X) < 0.0001) &&
3647 (Math.Abs(_orientation.Y - ori.Y) < 0.0001) &&
3648 (Math.Abs(_orientation.Z - ori.Z) < 0.0001)
3649 )
3650 {
3651 m_rotationalVelocity = Vector3.Zero;
3652 }
3653 else
3654 {
3655 vel = d.BodyGetAngularVel(Body);
3656 m_rotationalVelocity.X = vel.X;
3657 m_rotationalVelocity.Y = vel.Y;
3658 m_rotationalVelocity.Z = vel.Z;
3659 }
3660 }
3661
3662 if (_zeroFlag)
3663 {
3664 if (lastZeroFlag)
3665 {
3666 _velocity = Vector3.Zero;
3667 _acceleration = Vector3.Zero;
3668 m_rotationalVelocity = Vector3.Zero;
3669 }
3670
3671 if (!m_lastUpdateSent)
3672 {
3673 base.RequestPhysicsterseUpdate();
3674 if (lastZeroFlag)
3675 m_lastUpdateSent = true;
3676 }
3677 return;
3678 }
3679
3680 _position.X = lpos.X;
3681 _position.Y = lpos.Y;
3682 _position.Z = lpos.Z;
3683
3684 _orientation.X = ori.X;
3685 _orientation.Y = ori.Y;
3686 _orientation.Z = ori.Z;
3687 _orientation.W = ori.W;
3688 base.RequestPhysicsterseUpdate();
3689 m_lastUpdateSent = false;
3690 }
3691 }
3692 }
3693
3694 internal static bool QuaternionIsFinite(Quaternion q)
3695 {
3696 if (Single.IsNaN(q.X) || Single.IsInfinity(q.X))
3697 return false;
3698 if (Single.IsNaN(q.Y) || Single.IsInfinity(q.Y))
3699 return false;
3700 if (Single.IsNaN(q.Z) || Single.IsInfinity(q.Z))
3701 return false;
3702 if (Single.IsNaN(q.W) || Single.IsInfinity(q.W))
3703 return false;
3704 return true;
3705 }
3706
3707 internal static void DMassCopy(ref d.Mass src, ref d.Mass dst)
3708 {
3709 dst.c.W = src.c.W;
3710 dst.c.X = src.c.X;
3711 dst.c.Y = src.c.Y;
3712 dst.c.Z = src.c.Z;
3713 dst.mass = src.mass;
3714 dst.I.M00 = src.I.M00;
3715 dst.I.M01 = src.I.M01;
3716 dst.I.M02 = src.I.M02;
3717 dst.I.M10 = src.I.M10;
3718 dst.I.M11 = src.I.M11;
3719 dst.I.M12 = src.I.M12;
3720 dst.I.M20 = src.I.M20;
3721 dst.I.M21 = src.I.M21;
3722 dst.I.M22 = src.I.M22;
3723 }
3724
3725 internal static void DMassSubPartFromObj(ref d.Mass part, ref d.Mass theobj)
3726 {
3727 // assumes object center of mass is zero
3728 float smass = part.mass;
3729 theobj.mass -= smass;
3730
3731 smass *= 1.0f / (theobj.mass); ;
3732
3733 theobj.c.X -= part.c.X * smass;
3734 theobj.c.Y -= part.c.Y * smass;
3735 theobj.c.Z -= part.c.Z * smass;
3736
3737 theobj.I.M00 -= part.I.M00;
3738 theobj.I.M01 -= part.I.M01;
3739 theobj.I.M02 -= part.I.M02;
3740 theobj.I.M10 -= part.I.M10;
3741 theobj.I.M11 -= part.I.M11;
3742 theobj.I.M12 -= part.I.M12;
3743 theobj.I.M20 -= part.I.M20;
3744 theobj.I.M21 -= part.I.M21;
3745 theobj.I.M22 -= part.I.M22;
3746 }
3747
3748 private static void DMassDup(ref d.Mass src, out d.Mass dst)
3749 {
3750 dst = new d.Mass { };
3751
3752 dst.c.W = src.c.W;
3753 dst.c.X = src.c.X;
3754 dst.c.Y = src.c.Y;
3755 dst.c.Z = src.c.Z;
3756 dst.mass = src.mass;
3757 dst.I.M00 = src.I.M00;
3758 dst.I.M01 = src.I.M01;
3759 dst.I.M02 = src.I.M02;
3760 dst.I.M10 = src.I.M10;
3761 dst.I.M11 = src.I.M11;
3762 dst.I.M12 = src.I.M12;
3763 dst.I.M20 = src.I.M20;
3764 dst.I.M21 = src.I.M21;
3765 dst.I.M22 = src.I.M22;
3766 }
3767 private void donullchange()
3768 {
3769 }
3770
3771 public bool DoAChange(changes what, object arg)
3772 {
3773 if (prim_geom == IntPtr.Zero && what != changes.Add && what != changes.Remove)
3774 {
3775 return false;
3776 }
3777
3778 // nasty switch
3779 switch (what)
3780 {
3781 case changes.Add:
3782 changeadd();
3783 break;
3784 case changes.Remove:
3785 //If its being removed, we don't want to rebuild the physical rep at all, so ignore this stuff...
3786 //When we return true, it destroys all of the prims in the linkset anyway
3787 if (_parent != null)
3788 {
3789 OdePrim parent = (OdePrim)_parent;
3790 parent.ChildRemove(this, false);
3791 }
3792 else
3793 ChildRemove(this, false);
3794
3795 m_vehicle = null;
3796 RemoveGeom();
3797 m_targetSpace = IntPtr.Zero;
3798 if (m_eventsubscription > 0)
3799 UnSubscribeEvents();
3800 return true;
3801
3802 case changes.Link:
3803 OdePrim tmp = (OdePrim)arg;
3804 changeLink(tmp);
3805 break;
3806
3807 case changes.DeLink:
3808 changeLink(null);
3809 break;
3810
3811 case changes.Position:
3812 changePosition((Vector3)arg);
3813 break;
3814
3815 case changes.Orientation:
3816 changeOrientation((Quaternion)arg);
3817 break;
3818
3819 case changes.PosOffset:
3820 donullchange();
3821 break;
3822
3823 case changes.OriOffset:
3824 donullchange();
3825 break;
3826
3827 case changes.Velocity:
3828 changevelocity((Vector3)arg);
3829 break;
3830
3831 // case changes.Acceleration:
3832 // changeacceleration((Vector3)arg);
3833 // break;
3834 // case changes.AngVelocity:
3835 // changeangvelocity((Vector3)arg);
3836 // break;
3837
3838 case changes.Force:
3839 changeForce((Vector3)arg);
3840 break;
3841
3842 case changes.Torque:
3843 changeSetTorque((Vector3)arg);
3844 break;
3845
3846 case changes.AddForce:
3847 changeAddImpulse((Vector3)arg);
3848 break;
3849
3850 case changes.AddAngForce:
3851 changeAddAngularImpulse((Vector3)arg);
3852 break;
3853
3854 case changes.AngLock:
3855 changeAngularLock((Vector3)arg);
3856 break;
3857
3858 case changes.Size:
3859 changeSize((Vector3)arg);
3860 break;
3861
3862 case changes.Shape:
3863 changeShape((PrimitiveBaseShape)arg);
3864 break;
3865
3866 case changes.CollidesWater:
3867 changeFloatOnWater((bool)arg);
3868 break;
3869
3870 case changes.VolumeDtc:
3871 changeVolumedetetion((bool)arg);
3872 break;
3873
3874 case changes.Phantom:
3875 changePhantomStatus((bool)arg);
3876 break;
3877
3878 case changes.Physical:
3879 changePhysicsStatus((bool)arg);
3880 break;
3881
3882 case changes.Selected:
3883 changeSelectedStatus((bool)arg);
3884 break;
3885
3886 case changes.disabled:
3887 changeDisable((bool)arg);
3888 break;
3889
3890 case changes.building:
3891 changeBuilding((bool)arg);
3892 break;
3893
3894 case changes.VehicleType:
3895 changeVehicleType((int)arg);
3896 break;
3897
3898 case changes.VehicleFlags:
3899 changeVehicleFlags((strVehicleBoolParam) arg);
3900 break;
3901
3902 case changes.VehicleFloatParam:
3903 changeVehicleFloatParam((strVehicleFloatParam) arg);
3904 break;
3905
3906 case changes.VehicleVectorParam:
3907 changeVehicleVectorParam((strVehicleVectorParam) arg);
3908 break;
3909
3910 case changes.VehicleRotationParam:
3911 changeVehicleRotationParam((strVehicleQuatParam) arg);
3912 break;
3913
3914 case changes.SetVehicle:
3915 changeSetVehicle((VehicleData) arg);
3916 break;
3917 case changes.Null:
3918 donullchange();
3919 break;
3920
3921 default:
3922 donullchange();
3923 break;
3924 }
3925 return false;
3926 }
3927
3928 public void AddChange(changes what, object arg)
3929 {
3930 _parent_scene.AddChange((PhysicsActor) this, what, arg);
3931 }
3932
3933
3934 private struct strVehicleBoolParam
3935 {
3936 public int param;
3937 public bool value;
3938 }
3939
3940 private struct strVehicleFloatParam
3941 {
3942 public int param;
3943 public float value;
3944 }
3945
3946 private struct strVehicleQuatParam
3947 {
3948 public int param;
3949 public Quaternion value;
3950 }
3951
3952 private struct strVehicleVectorParam
3953 {
3954 public int param;
3955 public Vector3 value;
3956 }
3957 }
3958} \ No newline at end of file
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs
new file mode 100644
index 0000000..5122ebf
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs
@@ -0,0 +1,603 @@
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 OpenSim.Framework;
34using OpenSim.Region.Physics.Manager;
35using OdeAPI;
36using log4net;
37using OpenMetaverse;
38
39namespace OpenSim.Region.Physics.OdePlugin
40{
41 /// <summary>
42 /// Processes raycast requests as ODE is in a state to be able to do them.
43 /// This ensures that it's thread safe and there will be no conflicts.
44 /// Requests get returned by a different thread then they were requested by.
45 /// </summary>
46 public class ODERayCastRequestManager
47 {
48 /// <summary>
49 /// Pending ray requests
50 /// </summary>
51 protected OpenSim.Framework.LocklessQueue<ODERayRequest> m_PendingRequests = new OpenSim.Framework.LocklessQueue<ODERayRequest>();
52
53 /// <summary>
54 /// Scene that created this object.
55 /// </summary>
56 private OdeScene m_scene;
57
58 IntPtr ray; // the ray. we only need one for our lifetime
59
60 private const int ColisionContactGeomsPerTest = 5;
61 private const int DefaultMaxCount = 25;
62 private const int MaxTimePerCallMS = 30;
63
64 /// <summary>
65 /// ODE near callback delegate
66 /// </summary>
67 private d.NearCallback nearCallback;
68 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
69 private List<ContactResult> m_contactResults = new List<ContactResult>();
70 private RayFilterFlags CurrentRayFilter;
71 private int CurrentMaxCount;
72
73 public ODERayCastRequestManager(OdeScene pScene)
74 {
75 m_scene = pScene;
76 nearCallback = near;
77 ray = d.CreateRay(IntPtr.Zero, 1.0f);
78 d.GeomSetCategoryBits(ray,0);
79 }
80
81 /// <summary>
82 /// Queues request for a raycast to all world
83 /// </summary>
84 /// <param name="position">Origin of Ray</param>
85 /// <param name="direction">Ray direction</param>
86 /// <param name="length">Ray length</param>
87 /// <param name="retMethod">Return method to send the results</param>
88 public void QueueRequest(Vector3 position, Vector3 direction, float length, RayCallback retMethod)
89 {
90 ODERayRequest req = new ODERayRequest();
91 req.geom = IntPtr.Zero;
92 req.callbackMethod = retMethod;
93 req.Count = DefaultMaxCount;
94 req.length = length;
95 req.Normal = direction;
96 req.Origin = position;
97 req.filter = RayFilterFlags.AllPrims;
98
99 m_PendingRequests.Enqueue(req);
100 }
101
102 /// <summary>
103 /// Queues request for a raycast to particular part
104 /// </summary>
105 /// <param name="position">Origin of Ray</param>
106 /// <param name="direction">Ray direction</param>
107 /// <param name="length">Ray length</param>
108 /// <param name="retMethod">Return method to send the results</param>
109 public void QueueRequest(IntPtr geom, Vector3 position, Vector3 direction, float length, RayCallback retMethod)
110 {
111 ODERayRequest req = new ODERayRequest();
112 req.geom = geom;
113 req.callbackMethod = retMethod;
114 req.length = length;
115 req.Normal = direction;
116 req.Origin = position;
117 req.Count = DefaultMaxCount;
118 req.filter = RayFilterFlags.AllPrims;
119
120 m_PendingRequests.Enqueue(req);
121 }
122
123 public void QueueRequest(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
124 {
125 ODERayRequest req = new ODERayRequest();
126 req.geom = IntPtr.Zero;
127 req.callbackMethod = retMethod;
128 req.Count = DefaultMaxCount;
129 req.length = length;
130 req.Normal = direction;
131 req.Origin = position;
132 req.filter = RayFilterFlags.AllPrims;
133
134 m_PendingRequests.Enqueue(req);
135 }
136
137 public void QueueRequest(IntPtr geom, Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
138 {
139 ODERayRequest req = new ODERayRequest();
140 req.geom = geom;
141 req.callbackMethod = retMethod;
142 req.length = length;
143 req.Normal = direction;
144 req.Origin = position;
145 req.Count = DefaultMaxCount;
146 req.filter = RayFilterFlags.AllPrims;
147
148 m_PendingRequests.Enqueue(req);
149 }
150
151 /// <summary>
152 /// Queues a raycast
153 /// </summary>
154 /// <param name="position">Origin of Ray</param>
155 /// <param name="direction">Ray normal</param>
156 /// <param name="length">Ray length</param>
157 /// <param name="count"></param>
158 /// <param name="retMethod">Return method to send the results</param>
159 public void QueueRequest(Vector3 position, Vector3 direction, float length, int count, RayCallback retMethod)
160 {
161 ODERayRequest req = new ODERayRequest();
162 req.geom = IntPtr.Zero;
163 req.callbackMethod = retMethod;
164 req.length = length;
165 req.Normal = direction;
166 req.Origin = position;
167 req.Count = count;
168 req.filter = RayFilterFlags.AllPrims;
169
170 m_PendingRequests.Enqueue(req);
171 }
172
173
174 public void QueueRequest(Vector3 position, Vector3 direction, float length, int count,RayFilterFlags filter , RayCallback retMethod)
175 {
176 ODERayRequest req = new ODERayRequest();
177 req.geom = IntPtr.Zero;
178 req.callbackMethod = retMethod;
179 req.length = length;
180 req.Normal = direction;
181 req.Origin = position;
182 req.Count = count;
183 req.filter = filter;
184
185 m_PendingRequests.Enqueue(req);
186 }
187
188 public void QueueRequest(IntPtr geom, Vector3 position, Vector3 direction, float length, int count, RayCallback retMethod)
189 {
190 ODERayRequest req = new ODERayRequest();
191 req.geom = geom;
192 req.callbackMethod = retMethod;
193 req.length = length;
194 req.Normal = direction;
195 req.Origin = position;
196 req.Count = count;
197 req.filter = RayFilterFlags.AllPrims;
198
199 m_PendingRequests.Enqueue(req);
200 }
201
202 public void QueueRequest(Vector3 position, Vector3 direction, float length, int count, RaycastCallback retMethod)
203 {
204 ODERayRequest req = new ODERayRequest();
205 req.geom = IntPtr.Zero;
206 req.callbackMethod = retMethod;
207 req.length = length;
208 req.Normal = direction;
209 req.Origin = position;
210 req.Count = count;
211 req.filter = RayFilterFlags.AllPrims;
212
213 m_PendingRequests.Enqueue(req);
214 }
215
216 public void QueueRequest(IntPtr geom, Vector3 position, Vector3 direction, float length, int count, RaycastCallback retMethod)
217 {
218 ODERayRequest req = new ODERayRequest();
219 req.geom = geom;
220 req.callbackMethod = retMethod;
221 req.length = length;
222 req.Normal = direction;
223 req.Origin = position;
224 req.Count = count;
225 req.filter = RayFilterFlags.AllPrims;
226
227 m_PendingRequests.Enqueue(req);
228 }
229
230 /// <summary>
231 /// Process all queued raycast requests
232 /// </summary>
233 /// <returns>Time in MS the raycasts took to process.</returns>
234 public int ProcessQueuedRequests()
235 {
236
237 if (m_PendingRequests.Count <= 0)
238 return 0;
239
240 if (m_scene.ContactgeomsArray == IntPtr.Zero || ray == IntPtr.Zero)
241 // oops something got wrong or scene isn't ready still
242 {
243 m_PendingRequests.Clear();
244 return 0;
245 }
246
247 int time = Util.EnvironmentTickCount();
248
249 ODERayRequest req;
250 int closestHit;
251 int backfacecull;
252 CollisionCategories catflags;
253
254 while (m_PendingRequests.Dequeue(out req))
255 {
256 if (req.callbackMethod != null)
257 {
258 CurrentRayFilter = req.filter;
259 CurrentMaxCount = req.Count;
260
261 closestHit = ((CurrentRayFilter & RayFilterFlags.ClosestHit) == 0 ? 0 : 1);
262 backfacecull = ((CurrentRayFilter & RayFilterFlags.BackFaceCull) == 0 ? 0 : 1);
263
264 d.GeomRaySetLength(ray, req.length);
265 d.GeomRaySet(ray, req.Origin.X, req.Origin.Y, req.Origin.Z, req.Normal.X, req.Normal.Y, req.Normal.Z);
266 d.GeomRaySetParams(ray, 0, backfacecull);
267 d.GeomRaySetClosestHit(ray, closestHit);
268
269 if (req.callbackMethod is RaycastCallback)
270 // if we only want one get only one per colision pair saving memory
271 CurrentRayFilter |= RayFilterFlags.ClosestHit;
272
273 if (req.geom == IntPtr.Zero)
274 {
275 // translate ray filter to colision flags
276 catflags = 0;
277 if ((CurrentRayFilter & RayFilterFlags.volumedtc) != 0)
278 catflags |= CollisionCategories.VolumeDtc;
279 if ((CurrentRayFilter & RayFilterFlags.phantom) != 0)
280 catflags |= CollisionCategories.Phantom;
281 if ((CurrentRayFilter & RayFilterFlags.agent) != 0)
282 catflags |= CollisionCategories.Character;
283 if ((CurrentRayFilter & RayFilterFlags.PrimsNonPhantom) != 0)
284 catflags |= CollisionCategories.Geom;
285 if ((CurrentRayFilter & RayFilterFlags.land) != 0)
286 catflags |= CollisionCategories.Land;
287 if ((CurrentRayFilter & RayFilterFlags.water) != 0)
288 catflags |= CollisionCategories.Water;
289
290 if (catflags != 0)
291 doSpaceRay(req);
292 }
293 else
294 {
295 // if we select a geom don't use filters
296 d.GeomSetCollideBits(ray, (uint)CollisionCategories.All);
297 doGeomRay(req);
298 }
299 }
300
301 if (Util.EnvironmentTickCountSubtract(time) > MaxTimePerCallMS)
302 break;
303 }
304
305 lock (m_contactResults)
306 m_contactResults.Clear();
307
308 return Util.EnvironmentTickCountSubtract(time);
309 }
310 /// <summary>
311 /// Method that actually initiates the raycast with spaces
312 /// </summary>
313 /// <param name="req"></param>
314 ///
315
316 private const RayFilterFlags FilterActiveSpace = RayFilterFlags.agent | RayFilterFlags.physical | RayFilterFlags.LSLPhanton;
317 private const RayFilterFlags FilterStaticSpace = RayFilterFlags.water | RayFilterFlags.land | RayFilterFlags.nonphysical | RayFilterFlags.LSLPhanton;
318
319 private void doSpaceRay(ODERayRequest req)
320 {
321 // Collide tests
322 if ((CurrentRayFilter & FilterActiveSpace) != 0)
323 d.SpaceCollide2(ray, m_scene.ActiveSpace, IntPtr.Zero, nearCallback);
324 if ((CurrentRayFilter & FilterStaticSpace) != 0 && (m_contactResults.Count < CurrentMaxCount))
325 d.SpaceCollide2(ray, m_scene.StaticSpace, IntPtr.Zero, nearCallback);
326
327 if (req.callbackMethod is RaycastCallback)
328 {
329 // Define default results
330 bool hitYN = false;
331 uint hitConsumerID = 0;
332 float distance = float.MaxValue;
333 Vector3 closestcontact = Vector3.Zero;
334 Vector3 snormal = Vector3.Zero;
335
336 // Find closest contact and object.
337 lock (m_contactResults)
338 {
339 foreach (ContactResult cResult in m_contactResults)
340 {
341 if(cResult.Depth < distance)
342 {
343 closestcontact = cResult.Pos;
344 hitConsumerID = cResult.ConsumerID;
345 distance = cResult.Depth;
346 snormal = cResult.Normal;
347 }
348 }
349 m_contactResults.Clear();
350 }
351
352 if (distance > 0 && distance < float.MaxValue)
353 hitYN = true;
354 ((RaycastCallback)req.callbackMethod)(hitYN, closestcontact, hitConsumerID, distance, snormal);
355 }
356 else
357 {
358 List<ContactResult> cresult = new List<ContactResult>(m_contactResults.Count);
359 lock (m_PendingRequests)
360 {
361 cresult.AddRange(m_contactResults);
362 m_contactResults.Clear();
363 }
364 ((RayCallback)req.callbackMethod)(cresult);
365 }
366 }
367
368 /// <summary>
369 /// Method that actually initiates the raycast with a geom
370 /// </summary>
371 /// <param name="req"></param>
372 private void doGeomRay(ODERayRequest req)
373 {
374 // Collide test
375 d.SpaceCollide2(ray, req.geom, IntPtr.Zero, nearCallback); // still do this to have full AABB pre test
376
377 if (req.callbackMethod is RaycastCallback)
378 {
379 // Define default results
380 bool hitYN = false;
381 uint hitConsumerID = 0;
382 float distance = float.MaxValue;
383 Vector3 closestcontact = Vector3.Zero;
384 Vector3 snormal = Vector3.Zero;
385
386 // Find closest contact and object.
387 lock (m_contactResults)
388 {
389 foreach (ContactResult cResult in m_contactResults)
390 {
391 if(cResult.Depth < distance )
392 {
393 closestcontact = cResult.Pos;
394 hitConsumerID = cResult.ConsumerID;
395 distance = cResult.Depth;
396 snormal = cResult.Normal;
397 }
398 }
399 m_contactResults.Clear();
400 }
401
402 if (distance > 0 && distance < float.MaxValue)
403 hitYN = true;
404
405 ((RaycastCallback)req.callbackMethod)(hitYN, closestcontact, hitConsumerID, distance, snormal);
406 }
407 else
408 {
409 List<ContactResult> cresult = new List<ContactResult>(m_contactResults.Count);
410 lock (m_PendingRequests)
411 {
412 cresult.AddRange(m_contactResults);
413 m_contactResults.Clear();
414 }
415 ((RayCallback)req.callbackMethod)(cresult);
416 }
417 }
418
419 private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
420 {
421 IntPtr ContactgeomsArray = m_scene.ContactgeomsArray;
422 if (ContactgeomsArray == IntPtr.Zero || index >= ColisionContactGeomsPerTest)
423 return false;
424
425 IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
426 newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
427 return true;
428 }
429
430 // This is the standard Near. g1 is the ray
431 private void near(IntPtr space, IntPtr g1, IntPtr g2)
432 {
433 if (g2 == IntPtr.Zero || g1 == g2)
434 return;
435
436 if (m_contactResults.Count >= CurrentMaxCount)
437 return;
438
439 if (d.GeomIsSpace(g2))
440 {
441 try
442 {
443 d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
444 }
445 catch (Exception e)
446 {
447 m_log.WarnFormat("[PHYSICS Ray]: Unable to Space collide test an object: {0}", e.Message);
448 }
449 return;
450 }
451
452 int count = 0;
453 try
454 {
455 count = d.CollidePtr(g1, g2, ColisionContactGeomsPerTest, m_scene.ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
456 }
457 catch (Exception e)
458 {
459 m_log.WarnFormat("[PHYSICS Ray]: Unable to collide test an object: {0}", e.Message);
460 return;
461 }
462
463 if (count == 0)
464 return;
465
466 uint ID = 0;
467 PhysicsActor p2 = null;
468
469 m_scene.actor_name_map.TryGetValue(g2, out p2);
470
471 if (p2 == null)
472 {
473 string name;
474
475 if (!m_scene.geom_name_map.TryGetValue(g2, out name))
476 return;
477
478 if (name == "Terrain")
479 {
480 // land colision
481 if ((CurrentRayFilter & RayFilterFlags.land) == 0)
482 return;
483 }
484 else if (name == "Water")
485 {
486 if ((CurrentRayFilter & RayFilterFlags.water) == 0)
487 return;
488 }
489 else
490 return;
491 }
492 else
493 {
494 if (p2 is OdePrim)
495 {
496 RayFilterFlags thisFlags;
497
498 if (p2.IsPhysical)
499 thisFlags = RayFilterFlags.physical;
500 else
501 thisFlags = RayFilterFlags.nonphysical;
502
503 if (p2.Phantom)
504 thisFlags |= RayFilterFlags.phantom;
505
506 if (p2.IsVolumeDtc)
507 thisFlags |= RayFilterFlags.volumedtc;
508
509 if ((thisFlags & CurrentRayFilter) == 0)
510 return;
511
512 ID = ((OdePrim)p2).m_localID;
513 }
514 else if (p2 is OdeCharacter)
515 {
516 if ((CurrentRayFilter & RayFilterFlags.agent) == 0)
517 return;
518 else
519 ID = ((OdeCharacter)p2).m_localID;
520 }
521 else //??
522 return;
523 }
524
525 d.ContactGeom curcontact = new d.ContactGeom();
526
527 // closestHit for now only works for meshs, so must do it for others
528 if ((CurrentRayFilter & RayFilterFlags.ClosestHit) == 0)
529 {
530 // Loop all contacts, build results.
531 for (int i = 0; i < count; i++)
532 {
533 if (!GetCurContactGeom(i, ref curcontact))
534 break;
535
536 ContactResult collisionresult = new ContactResult();
537 collisionresult.ConsumerID = ID;
538 collisionresult.Pos = new Vector3(curcontact.pos.X, curcontact.pos.Y, curcontact.pos.Z);
539 collisionresult.Depth = curcontact.depth;
540 collisionresult.Normal = new Vector3(curcontact.normal.X, curcontact.normal.Y,
541 curcontact.normal.Z);
542 lock (m_contactResults)
543 {
544 m_contactResults.Add(collisionresult);
545 if (m_contactResults.Count >= CurrentMaxCount)
546 return;
547 }
548 }
549 }
550 else
551 {
552 // keep only closest contact
553 ContactResult collisionresult = new ContactResult();
554 collisionresult.ConsumerID = ID;
555 collisionresult.Depth = float.MaxValue;
556
557 for (int i = 0; i < count; i++)
558 {
559 if (!GetCurContactGeom(i, ref curcontact))
560 break;
561
562 if (curcontact.depth < collisionresult.Depth)
563 {
564 collisionresult.Pos = new Vector3(curcontact.pos.X, curcontact.pos.Y, curcontact.pos.Z);
565 collisionresult.Depth = curcontact.depth;
566 collisionresult.Normal = new Vector3(curcontact.normal.X, curcontact.normal.Y,
567 curcontact.normal.Z);
568 }
569 }
570
571 if (collisionresult.Depth != float.MaxValue)
572 {
573 lock (m_contactResults)
574 m_contactResults.Add(collisionresult);
575 }
576 }
577 }
578
579 /// <summary>
580 /// Dereference the creator scene so that it can be garbage collected if needed.
581 /// </summary>
582 internal void Dispose()
583 {
584 m_scene = null;
585 if (ray != IntPtr.Zero)
586 {
587 d.GeomDestroy(ray);
588 ray = IntPtr.Zero;
589 }
590 }
591 }
592
593 public struct ODERayRequest
594 {
595 public IntPtr geom;
596 public Vector3 Origin;
597 public Vector3 Normal;
598 public int Count;
599 public float length;
600 public object callbackMethod;
601 public RayFilterFlags filter;
602 }
603} \ No newline at end of file
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/OdeApi.cs b/OpenSim/Region/Physics/UbitOdePlugin/OdeApi.cs
new file mode 100644
index 0000000..0e4961b
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdeApi.cs
@@ -0,0 +1,2005 @@
1/*
2 * based on:
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 * changes by opensim team;
39 * changes by Aurora team http://www.aurora-sim.org/
40
41 * Revision/fixs by Ubit Umarov
42 */
43
44using System;
45using System.Runtime.InteropServices;
46using System.Security;
47
48namespace OdeAPI
49{
50//#if dDOUBLE
51// don't see much use in double precision with time steps of 20ms and 10 iterations used on opensim
52// at least we save same memory and memory access time, FPU performance on intel usually is similar
53// using dReal = System.Double;
54//#else
55 using dReal = System.Single;
56//#endif
57
58 public static class d
59 {
60 public static dReal Infinity = dReal.MaxValue;
61 public static int NTotalBodies = 0;
62 public static int NTotalGeoms = 0;
63
64 #region Flags and Enumerations
65
66 [Flags]
67 public enum AllocateODEDataFlags : uint
68 {
69 BasicData = 0,
70 CollisionData = 0x00000001,
71 All = ~0u
72 }
73
74 [Flags]
75 public enum IniteODEFlags : uint
76 {
77 dInitFlagManualThreadCleanup = 0x00000001
78 }
79
80 [Flags]
81 public enum ContactFlags : int
82 {
83 Mu2 = 0x001,
84 FDir1 = 0x002,
85 Bounce = 0x004,
86 SoftERP = 0x008,
87 SoftCFM = 0x010,
88 Motion1 = 0x020,
89 Motion2 = 0x040,
90 MotionN = 0x080,
91 Slip1 = 0x100,
92 Slip2 = 0x200,
93 Approx0 = 0x0000,
94 Approx1_1 = 0x1000,
95 Approx1_2 = 0x2000,
96 Approx1 = 0x3000
97 }
98
99 public enum GeomClassID : int
100 {
101 SphereClass,
102 BoxClass,
103 CapsuleClass,
104 CylinderClass,
105 PlaneClass,
106 RayClass,
107 ConvexClass,
108 GeomTransformClass,
109 TriMeshClass,
110 HeightfieldClass,
111 FirstSpaceClass,
112 SimpleSpaceClass = FirstSpaceClass,
113 HashSpaceClass,
114 QuadTreeSpaceClass,
115 LastSpaceClass = QuadTreeSpaceClass,
116 UbitTerrainClass,
117 FirstUserClass,
118 LastUserClass = FirstUserClass + MaxUserClasses - 1,
119 NumClasses,
120 MaxUserClasses = 5
121 }
122
123 public enum JointType : int
124 {
125 None,
126 Ball,
127 Hinge,
128 Slider,
129 Contact,
130 Universal,
131 Hinge2,
132 Fixed,
133 Null,
134 AMotor,
135 LMotor,
136 Plane2D
137 }
138
139 public enum JointParam : int
140 {
141 LoStop,
142 HiStop,
143 Vel,
144 FMax,
145 FudgeFactor,
146 Bounce,
147 CFM,
148 StopERP,
149 StopCFM,
150 SuspensionERP,
151 SuspensionCFM,
152 LoStop2 = 256,
153 HiStop2,
154 Vel2,
155 FMax2,
156 FudgeFactor2,
157 Bounce2,
158 CFM2,
159 StopERP2,
160 StopCFM2,
161 SuspensionERP2,
162 SuspensionCFM2,
163 LoStop3 = 512,
164 HiStop3,
165 Vel3,
166 FMax3,
167 FudgeFactor3,
168 Bounce3,
169 CFM3,
170 StopERP3,
171 StopCFM3,
172 SuspensionERP3,
173 SuspensionCFM3
174 }
175
176 public enum dSweepAndPruneAxis : int
177 {
178 XYZ = ((0)|(1<<2)|(2<<4)),
179 XZY = ((0)|(2<<2)|(1<<4)),
180 YXZ = ((1)|(0<<2)|(2<<4)),
181 YZX = ((1)|(2<<2)|(0<<4)),
182 ZXY = ((2)|(0<<2)|(1<<4)),
183 ZYX = ((2)|(1<<2)|(0<<4))
184 }
185
186 #endregion
187
188 #region Callbacks
189
190 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
191 public delegate int AABBTestFn(IntPtr o1, IntPtr o2, ref AABB aabb);
192
193 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
194 public delegate int ColliderFn(IntPtr o1, IntPtr o2, int flags, out ContactGeom contact, int skip);
195
196 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
197 public delegate void GetAABBFn(IntPtr geom, out AABB aabb);
198
199 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
200 public delegate ColliderFn GetColliderFnFn(int num);
201
202 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
203 public delegate void GeomDtorFn(IntPtr o);
204
205 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
206 public delegate dReal HeightfieldGetHeight(IntPtr p_user_data, int x, int z);
207
208 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
209 public delegate dReal UbitTerrainGetHeight(IntPtr p_user_data, int x, int z);
210
211 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
212 public delegate void NearCallback(IntPtr data, IntPtr geom1, IntPtr geom2);
213
214 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
215 public delegate int TriCallback(IntPtr trimesh, IntPtr refObject, int triangleIndex);
216
217 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
218 public delegate int TriArrayCallback(IntPtr trimesh, IntPtr refObject, int[] triangleIndex, int triCount);
219
220 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
221 public delegate int TriRayCallback(IntPtr trimesh, IntPtr ray, int triangleIndex, dReal u, dReal v);
222
223 #endregion
224
225 #region Structs
226
227 [StructLayout(LayoutKind.Sequential)]
228 public struct AABB
229 {
230 public dReal MinX, MaxX;
231 public dReal MinY, MaxY;
232 public dReal MinZ, MaxZ;
233 }
234
235
236 [StructLayout(LayoutKind.Sequential)]
237 public struct Contact
238 {
239 public SurfaceParameters surface;
240 public ContactGeom geom;
241 public Vector3 fdir1;
242 public static readonly int unmanagedSizeOf = Marshal.SizeOf(typeof(Contact));
243 }
244
245
246 [StructLayout(LayoutKind.Sequential)]
247 public struct ContactGeom
248 {
249
250 public Vector3 pos;
251 public Vector3 normal;
252 public dReal depth;
253 public IntPtr g1;
254 public IntPtr g2;
255 public int side1;
256 public int side2;
257 public static readonly int unmanagedSizeOf = Marshal.SizeOf(typeof(ContactGeom));
258 }
259
260 [StructLayout(LayoutKind.Sequential)]
261 public struct GeomClass
262 {
263 public int bytes;
264 public GetColliderFnFn collider;
265 public GetAABBFn aabb;
266 public AABBTestFn aabb_test;
267 public GeomDtorFn dtor;
268 }
269
270
271 [StructLayout(LayoutKind.Sequential)]
272 public struct JointFeedback
273 {
274 public Vector3 f1;
275 public Vector3 t1;
276 public Vector3 f2;
277 public Vector3 t2;
278 }
279
280
281 [StructLayout(LayoutKind.Sequential)]
282 public struct Mass
283 {
284 public dReal mass;
285 public Vector4 c;
286 public Matrix3 I;
287 }
288
289
290 [StructLayout(LayoutKind.Sequential)]
291 public struct Matrix3
292 {
293 public Matrix3(dReal m00, dReal m10, dReal m20, dReal m01, dReal m11, dReal m21, dReal m02, dReal m12, dReal m22)
294 {
295 M00 = m00; M10 = m10; M20 = m20; _m30 = 0.0f;
296 M01 = m01; M11 = m11; M21 = m21; _m31 = 0.0f;
297 M02 = m02; M12 = m12; M22 = m22; _m32 = 0.0f;
298 }
299 public dReal M00, M10, M20;
300 private dReal _m30;
301 public dReal M01, M11, M21;
302 private dReal _m31;
303 public dReal M02, M12, M22;
304 private dReal _m32;
305 }
306
307 [StructLayout(LayoutKind.Sequential)]
308 public struct Matrix4
309 {
310 public Matrix4(dReal m00, dReal m10, dReal m20, dReal m30,
311 dReal m01, dReal m11, dReal m21, dReal m31,
312 dReal m02, dReal m12, dReal m22, dReal m32,
313 dReal m03, dReal m13, dReal m23, dReal m33)
314 {
315 M00 = m00; M10 = m10; M20 = m20; M30 = m30;
316 M01 = m01; M11 = m11; M21 = m21; M31 = m31;
317 M02 = m02; M12 = m12; M22 = m22; M32 = m32;
318 M03 = m03; M13 = m13; M23 = m23; M33 = m33;
319 }
320 public dReal M00, M10, M20, M30;
321 public dReal M01, M11, M21, M31;
322 public dReal M02, M12, M22, M32;
323 public dReal M03, M13, M23, M33;
324 }
325
326 [StructLayout(LayoutKind.Sequential)]
327 public struct Quaternion
328 {
329 public dReal W, X, Y, Z;
330 }
331
332
333 [StructLayout(LayoutKind.Sequential)]
334 public struct SurfaceParameters
335 {
336 public ContactFlags mode;
337 public dReal mu;
338 public dReal mu2;
339 public dReal bounce;
340 public dReal bounce_vel;
341 public dReal soft_erp;
342 public dReal soft_cfm;
343 public dReal motion1;
344 public dReal motion2;
345 public dReal motionN;
346 public dReal slip1;
347 public dReal slip2;
348 }
349
350
351 [StructLayout(LayoutKind.Sequential)]
352 public struct Vector3
353 {
354 public Vector3(dReal x, dReal y, dReal z)
355 {
356 X = x; Y = y; Z = z; _w = 0.0f;
357 }
358 public dReal X, Y, Z;
359 private dReal _w;
360 }
361
362
363 [StructLayout(LayoutKind.Sequential)]
364 public struct Vector4
365 {
366 public Vector4(dReal x, dReal y, dReal z, dReal w)
367 {
368 X = x; Y = y; Z = z; W = w;
369 }
370 public dReal X, Y, Z, W;
371 }
372
373 #endregion
374
375 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dAllocateODEDataForThread"), SuppressUnmanagedCodeSecurity]
376 public static extern int AllocateODEDataForThread(uint ODEInitFlags);
377
378 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dAreConnected"), SuppressUnmanagedCodeSecurity]
379 public static extern bool AreConnected(IntPtr b1, IntPtr b2);
380
381 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dAreConnectedExcluding"), SuppressUnmanagedCodeSecurity]
382 public static extern bool AreConnectedExcluding(IntPtr b1, IntPtr b2, JointType joint_type);
383
384 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddForce"), SuppressUnmanagedCodeSecurity]
385 public static extern void BodyAddForce(IntPtr body, dReal fx, dReal fy, dReal fz);
386
387 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddForceAtPos"), SuppressUnmanagedCodeSecurity]
388 public static extern void BodyAddForceAtPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
389
390 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddForceAtRelPos"), SuppressUnmanagedCodeSecurity]
391 public static extern void BodyAddForceAtRelPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
392
393 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelForce"), SuppressUnmanagedCodeSecurity]
394 public static extern void BodyAddRelForce(IntPtr body, dReal fx, dReal fy, dReal fz);
395
396 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelForceAtPos"), SuppressUnmanagedCodeSecurity]
397 public static extern void BodyAddRelForceAtPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
398
399 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelForceAtRelPos"), SuppressUnmanagedCodeSecurity]
400 public static extern void BodyAddRelForceAtRelPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
401
402 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelTorque"), SuppressUnmanagedCodeSecurity]
403 public static extern void BodyAddRelTorque(IntPtr body, dReal fx, dReal fy, dReal fz);
404
405 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddTorque"), SuppressUnmanagedCodeSecurity]
406 public static extern void BodyAddTorque(IntPtr body, dReal fx, dReal fy, dReal fz);
407
408 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyPosition"), SuppressUnmanagedCodeSecurity]
409 public static extern void BodyCopyPosition(IntPtr body, out Vector3 pos);
410
411 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyPosition"), SuppressUnmanagedCodeSecurity]
412 public static extern void BodyCopyPosition(IntPtr body, out dReal X);
413
414 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyQuaternion"), SuppressUnmanagedCodeSecurity]
415 public static extern void BodyCopyQuaternion(IntPtr body, out Quaternion quat);
416
417 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyQuaternion"), SuppressUnmanagedCodeSecurity]
418 public static extern void BodyCopyQuaternion(IntPtr body, out dReal X);
419
420 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyRotation"), SuppressUnmanagedCodeSecurity]
421 public static extern void BodyCopyRotation(IntPtr body, out Matrix3 R);
422
423 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyRotation"), SuppressUnmanagedCodeSecurity]
424 public static extern void BodyCopyRotation(IntPtr body, out dReal M00);
425
426 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCreate"), SuppressUnmanagedCodeSecurity]
427 public static extern IntPtr BodyiCreate(IntPtr world);
428 public static IntPtr BodyCreate(IntPtr world)
429 {
430 NTotalBodies++;
431 return BodyiCreate(world);
432 }
433
434 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDestroy"), SuppressUnmanagedCodeSecurity]
435 public static extern void BodyiDestroy(IntPtr body);
436 public static void BodyDestroy(IntPtr body)
437 {
438 NTotalBodies--;
439 BodyiDestroy(body);
440 }
441
442 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDisable"), SuppressUnmanagedCodeSecurity]
443 public static extern void BodyDisable(IntPtr body);
444
445 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyEnable"), SuppressUnmanagedCodeSecurity]
446 public static extern void BodyEnable(IntPtr body);
447
448 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
449 public static extern dReal BodyGetAutoDisableAngularThreshold(IntPtr body);
450
451 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
452 public static extern bool BodyGetAutoDisableFlag(IntPtr body);
453
454 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableDefaults"), SuppressUnmanagedCodeSecurity]
455 public static extern void BodyGetAutoDisableDefaults(IntPtr body);
456
457 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
458 public static extern dReal BodyGetAutoDisableLinearThreshold(IntPtr body);
459
460 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
461 public static extern int BodyGetAutoDisableSteps(IntPtr body);
462
463 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
464 public static extern dReal BodyGetAutoDisableTime(IntPtr body);
465
466 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAngularVel"), SuppressUnmanagedCodeSecurity]
467 public extern unsafe static Vector3* BodyGetAngularVelUnsafe(IntPtr body);
468 public static Vector3 BodyGetAngularVel(IntPtr body)
469 {
470 unsafe { return *(BodyGetAngularVelUnsafe(body)); }
471 }
472
473 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetData"), SuppressUnmanagedCodeSecurity]
474 public static extern IntPtr BodyGetData(IntPtr body);
475
476 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetFiniteRotationMode"), SuppressUnmanagedCodeSecurity]
477 public static extern int BodyGetFiniteRotationMode(IntPtr body);
478
479 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetFiniteRotationAxis"), SuppressUnmanagedCodeSecurity]
480 public static extern void BodyGetFiniteRotationAxis(IntPtr body, out Vector3 result);
481
482 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetForce"), SuppressUnmanagedCodeSecurity]
483 public extern unsafe static Vector3* BodyGetForceUnsafe(IntPtr body);
484 public static Vector3 BodyGetForce(IntPtr body)
485 {
486 unsafe { return *(BodyGetForceUnsafe(body)); }
487 }
488
489 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetGravityMode"), SuppressUnmanagedCodeSecurity]
490 public static extern bool BodyGetGravityMode(IntPtr body);
491
492 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetGyroscopicMode"), SuppressUnmanagedCodeSecurity]
493 public static extern int BodyGetGyroscopicMode(IntPtr body);
494
495 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetJoint"), SuppressUnmanagedCodeSecurity]
496 public static extern IntPtr BodyGetJoint(IntPtr body, int index);
497
498 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetLinearVel"), SuppressUnmanagedCodeSecurity]
499 public extern unsafe static Vector3* BodyGetLinearVelUnsafe(IntPtr body);
500 public static Vector3 BodyGetLinearVel(IntPtr body)
501 {
502 unsafe { return *(BodyGetLinearVelUnsafe(body)); }
503 }
504
505 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetMass"), SuppressUnmanagedCodeSecurity]
506 public static extern void BodyGetMass(IntPtr body, out Mass mass);
507
508 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetNumJoints"), SuppressUnmanagedCodeSecurity]
509 public static extern int BodyGetNumJoints(IntPtr body);
510
511 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetPointVel"), SuppressUnmanagedCodeSecurity]
512 public static extern void BodyGetPointVel(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
513
514 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetPosition"), SuppressUnmanagedCodeSecurity]
515 public extern unsafe static Vector3* BodyGetPositionUnsafe(IntPtr body);
516 public static Vector3 BodyGetPosition(IntPtr body)
517 {
518 unsafe { return *(BodyGetPositionUnsafe(body)); }
519 }
520
521 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetPosRelPoint"), SuppressUnmanagedCodeSecurity]
522 public static extern void BodyGetPosRelPoint(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
523
524 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetQuaternion"), SuppressUnmanagedCodeSecurity]
525 public extern unsafe static Quaternion* BodyGetQuaternionUnsafe(IntPtr body);
526 public static Quaternion BodyGetQuaternion(IntPtr body)
527 {
528 unsafe { return *(BodyGetQuaternionUnsafe(body)); }
529 }
530
531 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetRelPointPos"), SuppressUnmanagedCodeSecurity]
532 public static extern void BodyGetRelPointPos(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
533
534 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetRelPointVel"), SuppressUnmanagedCodeSecurity]
535 public static extern void BodyGetRelPointVel(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
536
537 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetRotation"), SuppressUnmanagedCodeSecurity]
538 public extern unsafe static Matrix3* BodyGetRotationUnsafe(IntPtr body);
539 public static Matrix3 BodyGetRotation(IntPtr body)
540 {
541 unsafe { return *(BodyGetRotationUnsafe(body)); }
542 }
543
544 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetTorque"), SuppressUnmanagedCodeSecurity]
545 public extern unsafe static Vector3* BodyGetTorqueUnsafe(IntPtr body);
546 public static Vector3 BodyGetTorque(IntPtr body)
547 {
548 unsafe { return *(BodyGetTorqueUnsafe(body)); }
549 }
550
551 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetWorld"), SuppressUnmanagedCodeSecurity]
552 public static extern IntPtr BodyGetWorld(IntPtr body);
553
554 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetFirstGeom"), SuppressUnmanagedCodeSecurity]
555 public static extern IntPtr BodyGetFirstGeom(IntPtr body);
556
557 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetNextGeom"), SuppressUnmanagedCodeSecurity]
558 public static extern IntPtr dBodyGetNextGeom(IntPtr Geom);
559
560
561 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyIsEnabled"), SuppressUnmanagedCodeSecurity]
562 public static extern bool BodyIsEnabled(IntPtr body);
563
564 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularVel"), SuppressUnmanagedCodeSecurity]
565 public static extern void BodySetAngularVel(IntPtr body, dReal x, dReal y, dReal z);
566
567 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
568 public static extern void BodySetAutoDisableAngularThreshold(IntPtr body, dReal angular_threshold);
569
570 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableDefaults"), SuppressUnmanagedCodeSecurity]
571 public static extern void BodySetAutoDisableDefaults(IntPtr body);
572
573 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
574 public static extern void BodySetAutoDisableFlag(IntPtr body, bool do_auto_disable);
575
576 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
577 public static extern void BodySetAutoDisableLinearThreshold(IntPtr body, dReal linear_threshold);
578
579 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
580 public static extern void BodySetAutoDisableSteps(IntPtr body, int steps);
581
582 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
583 public static extern void BodySetAutoDisableTime(IntPtr body, dReal time);
584
585 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetData"), SuppressUnmanagedCodeSecurity]
586 public static extern void BodySetData(IntPtr body, IntPtr data);
587
588 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetFiniteRotationMode"), SuppressUnmanagedCodeSecurity]
589 public static extern void BodySetFiniteRotationMode(IntPtr body, int mode);
590
591 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetFiniteRotationAxis"), SuppressUnmanagedCodeSecurity]
592 public static extern void BodySetFiniteRotationAxis(IntPtr body, dReal x, dReal y, dReal z);
593
594 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetLinearDamping"), SuppressUnmanagedCodeSecurity]
595 public static extern void BodySetLinearDamping(IntPtr body, dReal scale);
596
597 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularDamping"), SuppressUnmanagedCodeSecurity]
598 public static extern void BodySetAngularDamping(IntPtr body, dReal scale);
599
600 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetLinearDamping"), SuppressUnmanagedCodeSecurity]
601 public static extern dReal BodyGetLinearDamping(IntPtr body);
602
603 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAngularDamping"), SuppressUnmanagedCodeSecurity]
604 public static extern dReal BodyGetAngularDamping(IntPtr body);
605
606 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularDamping"), SuppressUnmanagedCodeSecurity]
607 public static extern void BodySetDamping(IntPtr body, dReal linear_scale, dReal angular_scale);
608
609 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
610 public static extern void BodySetAngularDampingThreshold(IntPtr body, dReal threshold);
611
612 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
613 public static extern void BodySetLinearDampingThreshold(IntPtr body, dReal threshold);
614
615 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
616 public static extern dReal BodyGetLinearDampingThreshold(IntPtr body);
617
618 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
619 public static extern dReal BodyGetAngularDampingThreshold(IntPtr body);
620
621 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetForce"), SuppressUnmanagedCodeSecurity]
622 public static extern void BodySetForce(IntPtr body, dReal x, dReal y, dReal z);
623
624 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetGravityMode"), SuppressUnmanagedCodeSecurity]
625 public static extern void BodySetGravityMode(IntPtr body, bool mode);
626
627 /// <summary>
628 /// Sets the Gyroscopic term status on the body specified.
629 /// </summary>
630 /// <param name="body">Pointer to body</param>
631 /// <param name="enabled">NonZero enabled, Zero disabled</param>
632 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetGyroscopicMode"), SuppressUnmanagedCodeSecurity]
633 public static extern void dBodySetGyroscopicMode(IntPtr body, int enabled);
634
635 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetLinearVel"), SuppressUnmanagedCodeSecurity]
636 public static extern void BodySetLinearVel(IntPtr body, dReal x, dReal y, dReal z);
637
638 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetMass"), SuppressUnmanagedCodeSecurity]
639 public static extern void BodySetMass(IntPtr body, ref Mass mass);
640
641 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetPosition"), SuppressUnmanagedCodeSecurity]
642 public static extern void BodySetPosition(IntPtr body, dReal x, dReal y, dReal z);
643
644 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetQuaternion"), SuppressUnmanagedCodeSecurity]
645 public static extern void BodySetQuaternion(IntPtr body, ref Quaternion q);
646
647 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetQuaternion"), SuppressUnmanagedCodeSecurity]
648 public static extern void BodySetQuaternion(IntPtr body, ref dReal w);
649
650 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetRotation"), SuppressUnmanagedCodeSecurity]
651 public static extern void BodySetRotation(IntPtr body, ref Matrix3 R);
652
653 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetRotation"), SuppressUnmanagedCodeSecurity]
654 public static extern void BodySetRotation(IntPtr body, ref dReal M00);
655
656 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetTorque"), SuppressUnmanagedCodeSecurity]
657 public static extern void BodySetTorque(IntPtr body, dReal x, dReal y, dReal z);
658
659 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyVectorFromWorld"), SuppressUnmanagedCodeSecurity]
660 public static extern void BodyVectorFromWorld(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
661
662 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyVectorToWorld"), SuppressUnmanagedCodeSecurity]
663 public static extern void BodyVectorToWorld(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
664
665 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBoxBox"), SuppressUnmanagedCodeSecurity]
666 public static extern void BoxBox(ref Vector3 p1, ref Matrix3 R1,
667 ref Vector3 side1, ref Vector3 p2,
668 ref Matrix3 R2, ref Vector3 side2,
669 ref Vector3 normal, out dReal depth, out int return_code,
670 int maxc, out ContactGeom contact, int skip);
671
672 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBoxTouchesBox"), SuppressUnmanagedCodeSecurity]
673 public static extern void BoxTouchesBox(ref Vector3 _p1, ref Matrix3 R1,
674 ref Vector3 side1, ref Vector3 _p2,
675 ref Matrix3 R2, ref Vector3 side2);
676
677 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCleanupODEAllDataForThread"), SuppressUnmanagedCodeSecurity]
678 public static extern void CleanupODEAllDataForThread();
679
680 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dClosestLineSegmentPoints"), SuppressUnmanagedCodeSecurity]
681 public static extern void ClosestLineSegmentPoints(ref Vector3 a1, ref Vector3 a2,
682 ref Vector3 b1, ref Vector3 b2,
683 ref Vector3 cp1, ref Vector3 cp2);
684
685 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCloseODE"), SuppressUnmanagedCodeSecurity]
686 public static extern void CloseODE();
687
688 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCollide"), SuppressUnmanagedCodeSecurity]
689 public static extern int Collide(IntPtr o1, IntPtr o2, int flags, [In, Out] ContactGeom[] contact, int skip);
690 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCollide"), SuppressUnmanagedCodeSecurity]
691 public static extern int CollidePtr(IntPtr o1, IntPtr o2, int flags, IntPtr contactgeomarray, int skip);
692
693 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dConnectingJoint"), SuppressUnmanagedCodeSecurity]
694 public static extern IntPtr ConnectingJoint(IntPtr j1, IntPtr j2);
695
696 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateBox"), SuppressUnmanagedCodeSecurity]
697 public static extern IntPtr CreateiBox(IntPtr space, dReal lx, dReal ly, dReal lz);
698 public static IntPtr CreateBox(IntPtr space, dReal lx, dReal ly, dReal lz)
699 {
700 NTotalGeoms++;
701 return CreateiBox(space, lx, ly, lz);
702 }
703
704 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateCapsule"), SuppressUnmanagedCodeSecurity]
705 public static extern IntPtr CreateiCapsule(IntPtr space, dReal radius, dReal length);
706 public static IntPtr CreateCapsule(IntPtr space, dReal radius, dReal length)
707 {
708 NTotalGeoms++;
709 return CreateiCapsule(space, radius, length);
710 }
711
712 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateConvex"), SuppressUnmanagedCodeSecurity]
713 public static extern IntPtr CreateiConvex(IntPtr space, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons);
714 public static IntPtr CreateConvex(IntPtr space, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons)
715 {
716 NTotalGeoms++;
717 return CreateiConvex(space, planes, planeCount, points, pointCount, polygons);
718 }
719
720 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateCylinder"), SuppressUnmanagedCodeSecurity]
721 public static extern IntPtr CreateiCylinder(IntPtr space, dReal radius, dReal length);
722 public static IntPtr CreateCylinder(IntPtr space, dReal radius, dReal length)
723 {
724 NTotalGeoms++;
725 return CreateiCylinder(space, radius, length);
726 }
727
728 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateHeightfield"), SuppressUnmanagedCodeSecurity]
729 public static extern IntPtr CreateiHeightfield(IntPtr space, IntPtr data, int bPlaceable);
730 public static IntPtr CreateHeightfield(IntPtr space, IntPtr data, int bPlaceable)
731 {
732 NTotalGeoms++;
733 return CreateiHeightfield(space, data, bPlaceable);
734 }
735
736 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateUbitTerrain"), SuppressUnmanagedCodeSecurity]
737 public static extern IntPtr CreateiUbitTerrain(IntPtr space, IntPtr data, int bPlaceable);
738 public static IntPtr CreateUbitTerrain(IntPtr space, IntPtr data, int bPlaceable)
739 {
740 NTotalGeoms++;
741 return CreateiUbitTerrain(space, data, bPlaceable);
742 }
743
744
745
746
747
748 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeom"), SuppressUnmanagedCodeSecurity]
749 public static extern IntPtr CreateiGeom(int classnum);
750 public static IntPtr CreateGeom(int classnum)
751 {
752 NTotalGeoms++;
753 return CreateiGeom(classnum);
754 }
755
756 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeomClass"), SuppressUnmanagedCodeSecurity]
757 public static extern int CreateGeomClass(ref GeomClass classptr);
758
759 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeomTransform"), SuppressUnmanagedCodeSecurity]
760 public static extern IntPtr CreateGeomTransform(IntPtr space);
761
762 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreatePlane"), SuppressUnmanagedCodeSecurity]
763 public static extern IntPtr CreateiPlane(IntPtr space, dReal a, dReal b, dReal c, dReal d);
764 public static IntPtr CreatePlane(IntPtr space, dReal a, dReal b, dReal c, dReal d)
765 {
766 NTotalGeoms++;
767 return CreateiPlane(space, a, b, c, d);
768 }
769
770 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateRay"), SuppressUnmanagedCodeSecurity]
771 public static extern IntPtr CreateiRay(IntPtr space, dReal length);
772 public static IntPtr CreateRay(IntPtr space, dReal length)
773 {
774 NTotalGeoms++;
775 return CreateiRay(space, length);
776 }
777
778 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateSphere"), SuppressUnmanagedCodeSecurity]
779 public static extern IntPtr CreateiSphere(IntPtr space, dReal radius);
780 public static IntPtr CreateSphere(IntPtr space, dReal radius)
781 {
782 NTotalGeoms++;
783 return CreateiSphere(space, radius);
784 }
785
786 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateTriMesh"), SuppressUnmanagedCodeSecurity]
787 public static extern IntPtr CreateiTriMesh(IntPtr space, IntPtr data,
788 TriCallback callback, TriArrayCallback arrayCallback, TriRayCallback rayCallback);
789 public static IntPtr CreateTriMesh(IntPtr space, IntPtr data,
790 TriCallback callback, TriArrayCallback arrayCallback, TriRayCallback rayCallback)
791 {
792 NTotalGeoms++;
793 return CreateiTriMesh(space, data, callback, arrayCallback, rayCallback);
794 }
795 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dDot"), SuppressUnmanagedCodeSecurity]
796 public static extern dReal Dot(ref dReal X0, ref dReal X1, int n);
797
798 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dDQfromW"), SuppressUnmanagedCodeSecurity]
799 public static extern void DQfromW(dReal[] dq, ref Vector3 w, ref Quaternion q);
800
801 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dFactorCholesky"), SuppressUnmanagedCodeSecurity]
802 public static extern int FactorCholesky(ref dReal A00, int n);
803
804 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dFactorLDLT"), SuppressUnmanagedCodeSecurity]
805 public static extern void FactorLDLT(ref dReal A, out dReal d, int n, int nskip);
806
807 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxGetLengths"), SuppressUnmanagedCodeSecurity]
808 public static extern void GeomBoxGetLengths(IntPtr geom, out Vector3 len);
809
810 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxGetLengths"), SuppressUnmanagedCodeSecurity]
811 public static extern void GeomBoxGetLengths(IntPtr geom, out dReal x);
812
813 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxPointDepth"), SuppressUnmanagedCodeSecurity]
814 public static extern dReal GeomBoxPointDepth(IntPtr geom, dReal x, dReal y, dReal z);
815
816 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxSetLengths"), SuppressUnmanagedCodeSecurity]
817 public static extern void GeomBoxSetLengths(IntPtr geom, dReal x, dReal y, dReal z);
818
819 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCapsuleGetParams"), SuppressUnmanagedCodeSecurity]
820 public static extern void GeomCapsuleGetParams(IntPtr geom, out dReal radius, out dReal length);
821
822 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCapsulePointDepth"), SuppressUnmanagedCodeSecurity]
823 public static extern dReal GeomCapsulePointDepth(IntPtr geom, dReal x, dReal y, dReal z);
824
825 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCapsuleSetParams"), SuppressUnmanagedCodeSecurity]
826 public static extern void GeomCapsuleSetParams(IntPtr geom, dReal radius, dReal length);
827
828 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomClearOffset"), SuppressUnmanagedCodeSecurity]
829 public static extern void GeomClearOffset(IntPtr geom);
830
831 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetPosition"), SuppressUnmanagedCodeSecurity]
832 public static extern IntPtr GeomCopyOffsetPosition(IntPtr geom, ref Vector3 pos);
833
834 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetPosition"), SuppressUnmanagedCodeSecurity]
835 public static extern IntPtr GeomCopyOffsetPosition(IntPtr geom, ref dReal X);
836
837 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
838 public static extern void GeomCopyOffsetQuaternion(IntPtr geom, ref Quaternion Q);
839
840 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
841 public static extern void GeomCopyOffsetQuaternion(IntPtr geom, ref dReal X);
842
843 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetRotation"), SuppressUnmanagedCodeSecurity]
844 public static extern IntPtr GeomCopyOffsetRotation(IntPtr geom, ref Matrix3 R);
845
846 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetRotation"), SuppressUnmanagedCodeSecurity]
847 public static extern IntPtr GeomCopyOffsetRotation(IntPtr geom, ref dReal M00);
848
849 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyPosition"), SuppressUnmanagedCodeSecurity]
850 public static extern void GeomCopyPosition(IntPtr geom, out Vector3 pos);
851
852 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyPosition"), SuppressUnmanagedCodeSecurity]
853 public static extern void GeomCopyPosition(IntPtr geom, out dReal X);
854
855 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyRotation"), SuppressUnmanagedCodeSecurity]
856 public static extern void GeomCopyRotation(IntPtr geom, out Matrix3 R);
857
858 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyRotation"), SuppressUnmanagedCodeSecurity]
859 public static extern void GeomCopyRotation(IntPtr geom, out dReal M00);
860
861 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCylinderGetParams"), SuppressUnmanagedCodeSecurity]
862 public static extern void GeomCylinderGetParams(IntPtr geom, out dReal radius, out dReal length);
863
864 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCylinderSetParams"), SuppressUnmanagedCodeSecurity]
865 public static extern void GeomCylinderSetParams(IntPtr geom, dReal radius, dReal length);
866
867 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDestroy"), SuppressUnmanagedCodeSecurity]
868 public static extern void GeomiDestroy(IntPtr geom);
869 public static void GeomDestroy(IntPtr geom)
870 {
871 NTotalGeoms--;
872 GeomiDestroy(geom);
873 }
874
875
876 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDisable"), SuppressUnmanagedCodeSecurity]
877 public static extern void GeomDisable(IntPtr geom);
878
879 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomEnable"), SuppressUnmanagedCodeSecurity]
880 public static extern void GeomEnable(IntPtr geom);
881
882 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetAABB"), SuppressUnmanagedCodeSecurity]
883 public static extern void GeomGetAABB(IntPtr geom, out AABB aabb);
884
885 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetAABB"), SuppressUnmanagedCodeSecurity]
886 public static extern void GeomGetAABB(IntPtr geom, out dReal minX);
887
888 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetBody"), SuppressUnmanagedCodeSecurity]
889 public static extern IntPtr GeomGetBody(IntPtr geom);
890
891 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetCategoryBits"), SuppressUnmanagedCodeSecurity]
892 public static extern uint GeomGetCategoryBits(IntPtr geom);
893
894 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetClassData"), SuppressUnmanagedCodeSecurity]
895 public static extern IntPtr GeomGetClassData(IntPtr geom);
896
897 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetCollideBits"), SuppressUnmanagedCodeSecurity]
898 public static extern uint GeomGetCollideBits(IntPtr geom);
899
900 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetClass"), SuppressUnmanagedCodeSecurity]
901 public static extern GeomClassID GeomGetClass(IntPtr geom);
902
903 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetData"), SuppressUnmanagedCodeSecurity]
904 public static extern IntPtr GeomGetData(IntPtr geom);
905
906 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetPosition"), SuppressUnmanagedCodeSecurity]
907 public extern unsafe static Vector3* GeomGetOffsetPositionUnsafe(IntPtr geom);
908 public static Vector3 GeomGetOffsetPosition(IntPtr geom)
909 {
910 unsafe { return *(GeomGetOffsetPositionUnsafe(geom)); }
911 }
912
913 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetRotation"), SuppressUnmanagedCodeSecurity]
914 public extern unsafe static Matrix3* GeomGetOffsetRotationUnsafe(IntPtr geom);
915 public static Matrix3 GeomGetOffsetRotation(IntPtr geom)
916 {
917 unsafe { return *(GeomGetOffsetRotationUnsafe(geom)); }
918 }
919
920 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetPosition"), SuppressUnmanagedCodeSecurity]
921 public extern unsafe static Vector3* GeomGetPositionUnsafe(IntPtr geom);
922 public static Vector3 GeomGetPosition(IntPtr geom)
923 {
924 unsafe { return *(GeomGetPositionUnsafe(geom)); }
925 }
926
927 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetQuaternion"), SuppressUnmanagedCodeSecurity]
928 public static extern void GeomCopyQuaternion(IntPtr geom, out Quaternion q);
929
930 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetQuaternion"), SuppressUnmanagedCodeSecurity]
931 public static extern void GeomCopyQuaternion(IntPtr geom, out dReal X);
932
933 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetRotation"), SuppressUnmanagedCodeSecurity]
934 public extern unsafe static Matrix3* GeomGetRotationUnsafe(IntPtr geom);
935 public static Matrix3 GeomGetRotation(IntPtr geom)
936 {
937 unsafe { return *(GeomGetRotationUnsafe(geom)); }
938 }
939
940 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetSpace"), SuppressUnmanagedCodeSecurity]
941 public static extern IntPtr GeomGetSpace(IntPtr geom);
942
943 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildByte"), SuppressUnmanagedCodeSecurity]
944 public static extern void GeomHeightfieldDataBuildByte(IntPtr d, byte[] pHeightData, int bCopyHeightData,
945 dReal width, dReal depth, int widthSamples, int depthSamples,
946 dReal scale, dReal offset, dReal thickness, int bWrap);
947
948 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildByte"), SuppressUnmanagedCodeSecurity]
949 public static extern void GeomHeightfieldDataBuildByte(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
950 dReal width, dReal depth, int widthSamples, int depthSamples,
951 dReal scale, dReal offset, dReal thickness, int bWrap);
952
953 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildCallback"), SuppressUnmanagedCodeSecurity]
954 public static extern void GeomHeightfieldDataBuildCallback(IntPtr d, IntPtr pUserData, HeightfieldGetHeight pCallback,
955 dReal width, dReal depth, int widthSamples, int depthSamples,
956 dReal scale, dReal offset, dReal thickness, int bWrap);
957
958 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildShort"), SuppressUnmanagedCodeSecurity]
959 public static extern void GeomHeightfieldDataBuildShort(IntPtr d, ushort[] pHeightData, int bCopyHeightData,
960 dReal width, dReal depth, int widthSamples, int depthSamples,
961 dReal scale, dReal offset, dReal thickness, int bWrap);
962
963 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildShort"), SuppressUnmanagedCodeSecurity]
964 public static extern void GeomHeightfieldDataBuildShort(IntPtr d, short[] pHeightData, int bCopyHeightData,
965 dReal width, dReal depth, int widthSamples, int depthSamples,
966 dReal scale, dReal offset, dReal thickness, int bWrap);
967
968 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildShort"), SuppressUnmanagedCodeSecurity]
969 public static extern void GeomHeightfieldDataBuildShort(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
970 dReal width, dReal depth, int widthSamples, int depthSamples,
971 dReal scale, dReal offset, dReal thickness, int bWrap);
972
973 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildSingle"), SuppressUnmanagedCodeSecurity]
974 public static extern void GeomHeightfieldDataBuildSingle(IntPtr d, float[] pHeightData, int bCopyHeightData,
975 dReal width, dReal depth, int widthSamples, int depthSamples,
976 dReal scale, dReal offset, dReal thickness, int bWrap);
977
978 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildSingle"), SuppressUnmanagedCodeSecurity]
979 public static extern void GeomHeightfieldDataBuildSingle(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
980 dReal width, dReal depth, int widthSamples, int depthSamples,
981 dReal scale, dReal offset, dReal thickness, int bWrap);
982
983
984
985 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildDouble"), SuppressUnmanagedCodeSecurity]
986 public static extern void GeomHeightfieldDataBuildDouble(IntPtr d, double[] pHeightData, int bCopyHeightData,
987 dReal width, dReal depth, int widthSamples, int depthSamples,
988 dReal scale, dReal offset, dReal thickness, int bWrap);
989
990 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildDouble"), SuppressUnmanagedCodeSecurity]
991 public static extern void GeomHeightfieldDataBuildDouble(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
992 dReal width, dReal depth, int widthSamples, int depthSamples,
993 dReal scale, dReal offset, dReal thickness, int bWrap);
994
995 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataCreate"), SuppressUnmanagedCodeSecurity]
996 public static extern IntPtr GeomHeightfieldDataCreate();
997
998 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataDestroy"), SuppressUnmanagedCodeSecurity]
999 public static extern void GeomHeightfieldDataDestroy(IntPtr d);
1000
1001 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataSetBounds"), SuppressUnmanagedCodeSecurity]
1002 public static extern void GeomHeightfieldDataSetBounds(IntPtr d, dReal minHeight, dReal maxHeight);
1003
1004 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldGetHeightfieldData"), SuppressUnmanagedCodeSecurity]
1005 public static extern IntPtr GeomHeightfieldGetHeightfieldData(IntPtr g);
1006
1007 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldSetHeightfieldData"), SuppressUnmanagedCodeSecurity]
1008 public static extern void GeomHeightfieldSetHeightfieldData(IntPtr g, IntPtr d);
1009
1010
1011 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataBuild"), SuppressUnmanagedCodeSecurity]
1012 public static extern void GeomUbitTerrainDataBuild(IntPtr d, float[] pHeightData, int bCopyHeightData,
1013 dReal sampleSize, int widthSamples, int depthSamples,
1014 dReal offset, dReal thickness, int bWrap);
1015
1016 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataBuild"), SuppressUnmanagedCodeSecurity]
1017 public static extern void GeomUbitTerrainDataBuild(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
1018 dReal sampleSize, int widthSamples, int depthSamples,
1019 dReal thickness, int bWrap);
1020
1021 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataCreate"), SuppressUnmanagedCodeSecurity]
1022 public static extern IntPtr GeomUbitTerrainDataCreate();
1023
1024 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataDestroy"), SuppressUnmanagedCodeSecurity]
1025 public static extern void GeomUbitTerrainDataDestroy(IntPtr d);
1026
1027 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataSetBounds"), SuppressUnmanagedCodeSecurity]
1028 public static extern void GeomUbitTerrainDataSetBounds(IntPtr d, dReal minHeight, dReal maxHeight);
1029
1030 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainGetHeightfieldData"), SuppressUnmanagedCodeSecurity]
1031 public static extern IntPtr GeomUbitTerrainGetHeightfieldData(IntPtr g);
1032
1033 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainSetHeightfieldData"), SuppressUnmanagedCodeSecurity]
1034 public static extern void GeomUbitTerrainSetHeightfieldData(IntPtr g, IntPtr d);
1035
1036
1037 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomIsEnabled"), SuppressUnmanagedCodeSecurity]
1038 public static extern bool GeomIsEnabled(IntPtr geom);
1039
1040 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomIsOffset"), SuppressUnmanagedCodeSecurity]
1041 public static extern bool GeomIsOffset(IntPtr geom);
1042
1043 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomIsSpace"), SuppressUnmanagedCodeSecurity]
1044 public static extern bool GeomIsSpace(IntPtr geom);
1045
1046 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlaneGetParams"), SuppressUnmanagedCodeSecurity]
1047 public static extern void GeomPlaneGetParams(IntPtr geom, ref Vector4 result);
1048
1049 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlaneGetParams"), SuppressUnmanagedCodeSecurity]
1050 public static extern void GeomPlaneGetParams(IntPtr geom, ref dReal A);
1051
1052 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlanePointDepth"), SuppressUnmanagedCodeSecurity]
1053 public static extern dReal GeomPlanePointDepth(IntPtr geom, dReal x, dReal y, dReal z);
1054
1055 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlaneSetParams"), SuppressUnmanagedCodeSecurity]
1056 public static extern void GeomPlaneSetParams(IntPtr plane, dReal a, dReal b, dReal c, dReal d);
1057
1058 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGet"), SuppressUnmanagedCodeSecurity]
1059 public static extern void GeomRayGet(IntPtr ray, ref Vector3 start, ref Vector3 dir);
1060
1061 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGet"), SuppressUnmanagedCodeSecurity]
1062 public static extern void GeomRayGet(IntPtr ray, ref dReal startX, ref dReal dirX);
1063
1064 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGetClosestHit"), SuppressUnmanagedCodeSecurity]
1065 public static extern int GeomRayGetClosestHit(IntPtr ray);
1066
1067 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGetLength"), SuppressUnmanagedCodeSecurity]
1068 public static extern dReal GeomRayGetLength(IntPtr ray);
1069
1070 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGetParams"), SuppressUnmanagedCodeSecurity]
1071 public static extern dReal GeomRayGetParams(IntPtr g, out int firstContact, out int backfaceCull);
1072
1073 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySet"), SuppressUnmanagedCodeSecurity]
1074 public static extern void GeomRaySet(IntPtr ray, dReal px, dReal py, dReal pz, dReal dx, dReal dy, dReal dz);
1075
1076 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySetClosestHit"), SuppressUnmanagedCodeSecurity]
1077 public static extern void GeomRaySetClosestHit(IntPtr ray, int closestHit);
1078
1079 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySetLength"), SuppressUnmanagedCodeSecurity]
1080 public static extern void GeomRaySetLength(IntPtr ray, dReal length);
1081
1082 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySetParams"), SuppressUnmanagedCodeSecurity]
1083 public static extern void GeomRaySetParams(IntPtr ray, int firstContact, int backfaceCull);
1084
1085 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetBody"), SuppressUnmanagedCodeSecurity]
1086 public static extern void GeomSetBody(IntPtr geom, IntPtr body);
1087
1088 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetCategoryBits"), SuppressUnmanagedCodeSecurity]
1089 public static extern void GeomSetCategoryBits(IntPtr geom, uint bits);
1090
1091 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetCollideBits"), SuppressUnmanagedCodeSecurity]
1092 public static extern void GeomSetCollideBits(IntPtr geom, uint bits);
1093
1094 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetConvex"), SuppressUnmanagedCodeSecurity]
1095 public static extern IntPtr GeomSetConvex(IntPtr geom, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons);
1096
1097 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetData"), SuppressUnmanagedCodeSecurity]
1098 public static extern void GeomSetData(IntPtr geom, IntPtr data);
1099
1100 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetPosition"), SuppressUnmanagedCodeSecurity]
1101 public static extern void GeomSetOffsetPosition(IntPtr geom, dReal x, dReal y, dReal z);
1102
1103 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
1104 public static extern void GeomSetOffsetQuaternion(IntPtr geom, ref Quaternion Q);
1105
1106 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
1107 public static extern void GeomSetOffsetQuaternion(IntPtr geom, ref dReal X);
1108
1109 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetRotation"), SuppressUnmanagedCodeSecurity]
1110 public static extern void GeomSetOffsetRotation(IntPtr geom, ref Matrix3 R);
1111
1112 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetRotation"), SuppressUnmanagedCodeSecurity]
1113 public static extern void GeomSetOffsetRotation(IntPtr geom, ref dReal M00);
1114
1115 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldPosition"), SuppressUnmanagedCodeSecurity]
1116 public static extern void GeomSetOffsetWorldPosition(IntPtr geom, dReal x, dReal y, dReal z);
1117
1118 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
1119 public static extern void GeomSetOffsetWorldQuaternion(IntPtr geom, ref Quaternion Q);
1120
1121 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
1122 public static extern void GeomSetOffsetWorldQuaternion(IntPtr geom, ref dReal X);
1123
1124 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
1125 public static extern void GeomSetOffsetWorldRotation(IntPtr geom, ref Matrix3 R);
1126
1127 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
1128 public static extern void GeomSetOffsetWorldRotation(IntPtr geom, ref dReal M00);
1129
1130 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetPosition"), SuppressUnmanagedCodeSecurity]
1131 public static extern void GeomSetPosition(IntPtr geom, dReal x, dReal y, dReal z);
1132
1133 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
1134 public static extern void GeomSetQuaternion(IntPtr geom, ref Quaternion quat);
1135
1136 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
1137 public static extern void GeomSetQuaternion(IntPtr geom, ref dReal w);
1138
1139 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
1140 public static extern void GeomSetRotation(IntPtr geom, ref Matrix3 R);
1141
1142 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
1143 public static extern void GeomSetRotation(IntPtr geom, ref dReal M00);
1144
1145 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereGetRadius"), SuppressUnmanagedCodeSecurity]
1146 public static extern dReal GeomSphereGetRadius(IntPtr geom);
1147
1148 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSpherePointDepth"), SuppressUnmanagedCodeSecurity]
1149 public static extern dReal GeomSpherePointDepth(IntPtr geom, dReal x, dReal y, dReal z);
1150
1151 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereSetRadius"), SuppressUnmanagedCodeSecurity]
1152 public static extern void GeomSphereSetRadius(IntPtr geom, dReal radius);
1153
1154 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetCleanup"), SuppressUnmanagedCodeSecurity]
1155 public static extern int GeomTransformGetCleanup(IntPtr geom);
1156
1157 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetGeom"), SuppressUnmanagedCodeSecurity]
1158 public static extern IntPtr GeomTransformGetGeom(IntPtr geom);
1159
1160 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetInfo"), SuppressUnmanagedCodeSecurity]
1161 public static extern int GeomTransformGetInfo(IntPtr geom);
1162
1163 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetCleanup"), SuppressUnmanagedCodeSecurity]
1164 public static extern void GeomTransformSetCleanup(IntPtr geom, int mode);
1165
1166 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetGeom"), SuppressUnmanagedCodeSecurity]
1167 public static extern void GeomTransformSetGeom(IntPtr geom, IntPtr obj);
1168
1169 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetInfo"), SuppressUnmanagedCodeSecurity]
1170 public static extern void GeomTransformSetInfo(IntPtr geom, int info);
1171
1172 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble"), SuppressUnmanagedCodeSecurity]
1173 public static extern void GeomTriMeshDataBuildDouble(IntPtr d,
1174 double[] vertices, int vertexStride, int vertexCount,
1175 int[] indices, int indexCount, int triStride);
1176
1177 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble"), SuppressUnmanagedCodeSecurity]
1178 public static extern void GeomTriMeshDataBuildDouble(IntPtr d,
1179 IntPtr vertices, int vertexStride, int vertexCount,
1180 IntPtr indices, int indexCount, int triStride);
1181
1182 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble1"), SuppressUnmanagedCodeSecurity]
1183 public static extern void GeomTriMeshDataBuildDouble1(IntPtr d,
1184 double[] vertices, int vertexStride, int vertexCount,
1185 int[] indices, int indexCount, int triStride,
1186 double[] normals);
1187
1188 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble1"), SuppressUnmanagedCodeSecurity]
1189 public static extern void GeomTriMeshDataBuildDouble(IntPtr d,
1190 IntPtr vertices, int vertexStride, int vertexCount,
1191 IntPtr indices, int indexCount, int triStride,
1192 IntPtr normals);
1193
1194 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple"), SuppressUnmanagedCodeSecurity]
1195 public static extern void GeomTriMeshDataBuildSingle(IntPtr d,
1196 dReal[] vertices, int vertexStride, int vertexCount,
1197 int[] indices, int indexCount, int triStride);
1198
1199 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple"), SuppressUnmanagedCodeSecurity]
1200 public static extern void GeomTriMeshDataBuildSingle(IntPtr d,
1201 IntPtr vertices, int vertexStride, int vertexCount,
1202 IntPtr indices, int indexCount, int triStride);
1203
1204 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple1"), SuppressUnmanagedCodeSecurity]
1205 public static extern void GeomTriMeshDataBuildSingle1(IntPtr d,
1206 dReal[] vertices, int vertexStride, int vertexCount,
1207 int[] indices, int indexCount, int triStride,
1208 dReal[] normals);
1209
1210 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple1"), SuppressUnmanagedCodeSecurity]
1211 public static extern void GeomTriMeshDataBuildSingle1(IntPtr d,
1212 IntPtr vertices, int vertexStride, int vertexCount,
1213 IntPtr indices, int indexCount, int triStride,
1214 IntPtr normals);
1215
1216 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle"), SuppressUnmanagedCodeSecurity]
1217 public static extern void GeomTriMeshDataBuildSimple(IntPtr d,
1218 float[] vertices, int vertexStride, int vertexCount,
1219 int[] indices, int indexCount, int triStride);
1220
1221 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle"), SuppressUnmanagedCodeSecurity]
1222 public static extern void GeomTriMeshDataBuildSimple(IntPtr d,
1223 IntPtr vertices, int vertexStride, int vertexCount,
1224 IntPtr indices, int indexCount, int triStride);
1225
1226 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle1"), SuppressUnmanagedCodeSecurity]
1227 public static extern void GeomTriMeshDataBuildSimple1(IntPtr d,
1228 float[] vertices, int vertexStride, int vertexCount,
1229 int[] indices, int indexCount, int triStride,
1230 float[] normals);
1231
1232 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle1"), SuppressUnmanagedCodeSecurity]
1233 public static extern void GeomTriMeshDataBuildSimple1(IntPtr d,
1234 IntPtr vertices, int vertexStride, int vertexCount,
1235 IntPtr indices, int indexCount, int triStride,
1236 IntPtr normals);
1237
1238 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshClearTCCache"), SuppressUnmanagedCodeSecurity]
1239 public static extern void GeomTriMeshClearTCCache(IntPtr g);
1240
1241 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataCreate"), SuppressUnmanagedCodeSecurity]
1242 public static extern IntPtr GeomTriMeshDataCreate();
1243
1244 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataDestroy"), SuppressUnmanagedCodeSecurity]
1245 public static extern void GeomTriMeshDataDestroy(IntPtr d);
1246
1247 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataGet"), SuppressUnmanagedCodeSecurity]
1248 public static extern IntPtr GeomTriMeshDataGet(IntPtr d, int data_id);
1249
1250 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataPreprocess"), SuppressUnmanagedCodeSecurity]
1251 public static extern void GeomTriMeshDataPreprocess(IntPtr d);
1252
1253 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataSet"), SuppressUnmanagedCodeSecurity]
1254 public static extern void GeomTriMeshDataSet(IntPtr d, int data_id, IntPtr in_data);
1255
1256 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataUpdate"), SuppressUnmanagedCodeSecurity]
1257 public static extern void GeomTriMeshDataUpdate(IntPtr d);
1258
1259 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshEnableTC"), SuppressUnmanagedCodeSecurity]
1260 public static extern void GeomTriMeshEnableTC(IntPtr g, int geomClass, bool enable);
1261
1262 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetArrayCallback"), SuppressUnmanagedCodeSecurity]
1263 public static extern TriArrayCallback GeomTriMeshGetArrayCallback(IntPtr g);
1264
1265 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetCallback"), SuppressUnmanagedCodeSecurity]
1266 public static extern TriCallback GeomTriMeshGetCallback(IntPtr g);
1267
1268 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetData"), SuppressUnmanagedCodeSecurity]
1269 public static extern IntPtr GeomTriMeshGetData(IntPtr g);
1270
1271 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetLastTransform"), SuppressUnmanagedCodeSecurity]
1272 public extern unsafe static Matrix4* GeomTriMeshGetLastTransformUnsafe(IntPtr geom);
1273 public static Matrix4 GeomTriMeshGetLastTransform(IntPtr geom)
1274 {
1275 unsafe { return *(GeomTriMeshGetLastTransformUnsafe(geom)); }
1276 }
1277
1278 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetPoint"), SuppressUnmanagedCodeSecurity]
1279 public extern static void GeomTriMeshGetPoint(IntPtr g, int index, dReal u, dReal v, ref Vector3 outVec);
1280
1281 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetRayCallback"), SuppressUnmanagedCodeSecurity]
1282 public static extern TriRayCallback GeomTriMeshGetRayCallback(IntPtr g);
1283
1284 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetTriangle"), SuppressUnmanagedCodeSecurity]
1285 public extern static void GeomTriMeshGetTriangle(IntPtr g, int index, ref Vector3 v0, ref Vector3 v1, ref Vector3 v2);
1286
1287 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetTriangleCount"), SuppressUnmanagedCodeSecurity]
1288 public extern static int GeomTriMeshGetTriangleCount(IntPtr g);
1289
1290 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetTriMeshDataID"), SuppressUnmanagedCodeSecurity]
1291 public static extern IntPtr GeomTriMeshGetTriMeshDataID(IntPtr g);
1292
1293 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshIsTCEnabled"), SuppressUnmanagedCodeSecurity]
1294 public static extern bool GeomTriMeshIsTCEnabled(IntPtr g, int geomClass);
1295
1296 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetArrayCallback"), SuppressUnmanagedCodeSecurity]
1297 public static extern void GeomTriMeshSetArrayCallback(IntPtr g, TriArrayCallback arrayCallback);
1298
1299 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetCallback"), SuppressUnmanagedCodeSecurity]
1300 public static extern void GeomTriMeshSetCallback(IntPtr g, TriCallback callback);
1301
1302 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetData"), SuppressUnmanagedCodeSecurity]
1303 public static extern void GeomTriMeshSetData(IntPtr g, IntPtr data);
1304
1305 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetLastTransform"), SuppressUnmanagedCodeSecurity]
1306 public static extern void GeomTriMeshSetLastTransform(IntPtr g, ref Matrix4 last_trans);
1307
1308 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetLastTransform"), SuppressUnmanagedCodeSecurity]
1309 public static extern void GeomTriMeshSetLastTransform(IntPtr g, ref dReal M00);
1310
1311 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetRayCallback"), SuppressUnmanagedCodeSecurity]
1312 public static extern void GeomTriMeshSetRayCallback(IntPtr g, TriRayCallback callback);
1313
1314 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGetConfiguration"), SuppressUnmanagedCodeSecurity]
1315 public static extern string GetConfiguration(string str);
1316
1317 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceCreate"), SuppressUnmanagedCodeSecurity]
1318 public static extern IntPtr HashSpaceCreate(IntPtr space);
1319
1320 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceGetLevels"), SuppressUnmanagedCodeSecurity]
1321 public static extern void HashSpaceGetLevels(IntPtr space, out int minlevel, out int maxlevel);
1322
1323 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceSetLevels"), SuppressUnmanagedCodeSecurity]
1324 public static extern void HashSpaceSetLevels(IntPtr space, int minlevel, int maxlevel);
1325
1326 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInfiniteAABB"), SuppressUnmanagedCodeSecurity]
1327 public static extern void InfiniteAABB(IntPtr geom, out AABB aabb);
1328
1329 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInitODE"), SuppressUnmanagedCodeSecurity]
1330 public static extern void InitODE();
1331
1332 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInitODE2"), SuppressUnmanagedCodeSecurity]
1333 public static extern int InitODE2(uint ODEInitFlags);
1334
1335 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dIsPositiveDefinite"), SuppressUnmanagedCodeSecurity]
1336 public static extern int IsPositiveDefinite(ref dReal A, int n);
1337
1338 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInvertPDMatrix"), SuppressUnmanagedCodeSecurity]
1339 public static extern int InvertPDMatrix(ref dReal A, out dReal Ainv, int n);
1340
1341 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddAMotorTorques"), SuppressUnmanagedCodeSecurity]
1342 public static extern void JointAddAMotorTorques(IntPtr joint, dReal torque1, dReal torque2, dReal torque3);
1343
1344 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddHingeTorque"), SuppressUnmanagedCodeSecurity]
1345 public static extern void JointAddHingeTorque(IntPtr joint, dReal torque);
1346
1347 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddHinge2Torque"), SuppressUnmanagedCodeSecurity]
1348 public static extern void JointAddHinge2Torques(IntPtr joint, dReal torque1, dReal torque2);
1349
1350 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddPRTorque"), SuppressUnmanagedCodeSecurity]
1351 public static extern void JointAddPRTorque(IntPtr joint, dReal torque);
1352
1353 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddUniversalTorque"), SuppressUnmanagedCodeSecurity]
1354 public static extern void JointAddUniversalTorques(IntPtr joint, dReal torque1, dReal torque2);
1355
1356 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddSliderForce"), SuppressUnmanagedCodeSecurity]
1357 public static extern void JointAddSliderForce(IntPtr joint, dReal force);
1358
1359 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAttach"), SuppressUnmanagedCodeSecurity]
1360 public static extern void JointAttach(IntPtr joint, IntPtr body1, IntPtr body2);
1361
1362 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateAMotor"), SuppressUnmanagedCodeSecurity]
1363 public static extern IntPtr JointCreateAMotor(IntPtr world, IntPtr group);
1364
1365 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateBall"), SuppressUnmanagedCodeSecurity]
1366 public static extern IntPtr JointCreateBall(IntPtr world, IntPtr group);
1367
1368 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateContact"), SuppressUnmanagedCodeSecurity]
1369 public static extern IntPtr JointCreateContact(IntPtr world, IntPtr group, ref Contact contact);
1370 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateContact"), SuppressUnmanagedCodeSecurity]
1371 public static extern IntPtr JointCreateContactPtr(IntPtr world, IntPtr group, IntPtr contact);
1372
1373 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateFixed"), SuppressUnmanagedCodeSecurity]
1374 public static extern IntPtr JointCreateFixed(IntPtr world, IntPtr group);
1375
1376 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateHinge"), SuppressUnmanagedCodeSecurity]
1377 public static extern IntPtr JointCreateHinge(IntPtr world, IntPtr group);
1378
1379 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateHinge2"), SuppressUnmanagedCodeSecurity]
1380 public static extern IntPtr JointCreateHinge2(IntPtr world, IntPtr group);
1381
1382 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateLMotor"), SuppressUnmanagedCodeSecurity]
1383 public static extern IntPtr JointCreateLMotor(IntPtr world, IntPtr group);
1384
1385 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateNull"), SuppressUnmanagedCodeSecurity]
1386 public static extern IntPtr JointCreateNull(IntPtr world, IntPtr group);
1387
1388 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreatePR"), SuppressUnmanagedCodeSecurity]
1389 public static extern IntPtr JointCreatePR(IntPtr world, IntPtr group);
1390
1391 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreatePlane2D"), SuppressUnmanagedCodeSecurity]
1392 public static extern IntPtr JointCreatePlane2D(IntPtr world, IntPtr group);
1393
1394 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateSlider"), SuppressUnmanagedCodeSecurity]
1395 public static extern IntPtr JointCreateSlider(IntPtr world, IntPtr group);
1396
1397 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateUniversal"), SuppressUnmanagedCodeSecurity]
1398 public static extern IntPtr JointCreateUniversal(IntPtr world, IntPtr group);
1399
1400 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointDestroy"), SuppressUnmanagedCodeSecurity]
1401 public static extern void JointDestroy(IntPtr j);
1402
1403 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAngle"), SuppressUnmanagedCodeSecurity]
1404 public static extern dReal JointGetAMotorAngle(IntPtr j, int anum);
1405
1406 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAngleRate"), SuppressUnmanagedCodeSecurity]
1407 public static extern dReal JointGetAMotorAngleRate(IntPtr j, int anum);
1408
1409 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAxis"), SuppressUnmanagedCodeSecurity]
1410 public static extern void JointGetAMotorAxis(IntPtr j, int anum, out Vector3 result);
1411
1412 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAxisRel"), SuppressUnmanagedCodeSecurity]
1413 public static extern int JointGetAMotorAxisRel(IntPtr j, int anum);
1414
1415 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorMode"), SuppressUnmanagedCodeSecurity]
1416 public static extern int JointGetAMotorMode(IntPtr j);
1417
1418 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorNumAxes"), SuppressUnmanagedCodeSecurity]
1419 public static extern int JointGetAMotorNumAxes(IntPtr j);
1420
1421 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorParam"), SuppressUnmanagedCodeSecurity]
1422 public static extern dReal JointGetAMotorParam(IntPtr j, int parameter);
1423
1424 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetBallAnchor"), SuppressUnmanagedCodeSecurity]
1425 public static extern void JointGetBallAnchor(IntPtr j, out Vector3 result);
1426
1427 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetBallAnchor2"), SuppressUnmanagedCodeSecurity]
1428 public static extern void JointGetBallAnchor2(IntPtr j, out Vector3 result);
1429
1430 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetBody"), SuppressUnmanagedCodeSecurity]
1431 public static extern IntPtr JointGetBody(IntPtr j);
1432
1433 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetData"), SuppressUnmanagedCodeSecurity]
1434 public static extern IntPtr JointGetData(IntPtr j);
1435
1436 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetFeedback"), SuppressUnmanagedCodeSecurity]
1437 public extern unsafe static JointFeedback* JointGetFeedbackUnsafe(IntPtr j);
1438 public static JointFeedback JointGetFeedback(IntPtr j)
1439 {
1440 unsafe { return *(JointGetFeedbackUnsafe(j)); }
1441 }
1442
1443 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAnchor"), SuppressUnmanagedCodeSecurity]
1444 public static extern void JointGetHingeAnchor(IntPtr j, out Vector3 result);
1445
1446 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAngle"), SuppressUnmanagedCodeSecurity]
1447 public static extern dReal JointGetHingeAngle(IntPtr j);
1448
1449 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAngleRate"), SuppressUnmanagedCodeSecurity]
1450 public static extern dReal JointGetHingeAngleRate(IntPtr j);
1451
1452 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAxis"), SuppressUnmanagedCodeSecurity]
1453 public static extern void JointGetHingeAxis(IntPtr j, out Vector3 result);
1454
1455 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeParam"), SuppressUnmanagedCodeSecurity]
1456 public static extern dReal JointGetHingeParam(IntPtr j, int parameter);
1457
1458 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Angle1"), SuppressUnmanagedCodeSecurity]
1459 public static extern dReal JointGetHinge2Angle1(IntPtr j);
1460
1461 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Angle1Rate"), SuppressUnmanagedCodeSecurity]
1462 public static extern dReal JointGetHinge2Angle1Rate(IntPtr j);
1463
1464 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Angle2Rate"), SuppressUnmanagedCodeSecurity]
1465 public static extern dReal JointGetHinge2Angle2Rate(IntPtr j);
1466
1467 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAnchor2"), SuppressUnmanagedCodeSecurity]
1468 public static extern void JointGetHingeAnchor2(IntPtr j, out Vector3 result);
1469
1470 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Anchor"), SuppressUnmanagedCodeSecurity]
1471 public static extern void JointGetHinge2Anchor(IntPtr j, out Vector3 result);
1472
1473 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Anchor2"), SuppressUnmanagedCodeSecurity]
1474 public static extern void JointGetHinge2Anchor2(IntPtr j, out Vector3 result);
1475
1476 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Axis1"), SuppressUnmanagedCodeSecurity]
1477 public static extern void JointGetHinge2Axis1(IntPtr j, out Vector3 result);
1478
1479 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Axis2"), SuppressUnmanagedCodeSecurity]
1480 public static extern void JointGetHinge2Axis2(IntPtr j, out Vector3 result);
1481
1482 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Param"), SuppressUnmanagedCodeSecurity]
1483 public static extern dReal JointGetHinge2Param(IntPtr j, int parameter);
1484
1485 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetLMotorAxis"), SuppressUnmanagedCodeSecurity]
1486 public static extern void JointGetLMotorAxis(IntPtr j, int anum, out Vector3 result);
1487
1488 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetLMotorNumAxes"), SuppressUnmanagedCodeSecurity]
1489 public static extern int JointGetLMotorNumAxes(IntPtr j);
1490
1491 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetLMotorParam"), SuppressUnmanagedCodeSecurity]
1492 public static extern dReal JointGetLMotorParam(IntPtr j, int parameter);
1493
1494 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRAnchor"), SuppressUnmanagedCodeSecurity]
1495 public static extern void JointGetPRAnchor(IntPtr j, out Vector3 result);
1496
1497 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRAxis1"), SuppressUnmanagedCodeSecurity]
1498 public static extern void JointGetPRAxis1(IntPtr j, out Vector3 result);
1499
1500 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRAxis2"), SuppressUnmanagedCodeSecurity]
1501 public static extern void JointGetPRAxis2(IntPtr j, out Vector3 result);
1502
1503 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRParam"), SuppressUnmanagedCodeSecurity]
1504 public static extern dReal JointGetPRParam(IntPtr j, int parameter);
1505
1506 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRPosition"), SuppressUnmanagedCodeSecurity]
1507 public static extern dReal JointGetPRPosition(IntPtr j);
1508
1509 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRPositionRate"), SuppressUnmanagedCodeSecurity]
1510 public static extern dReal JointGetPRPositionRate(IntPtr j);
1511
1512 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderAxis"), SuppressUnmanagedCodeSecurity]
1513 public static extern void JointGetSliderAxis(IntPtr j, out Vector3 result);
1514
1515 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderParam"), SuppressUnmanagedCodeSecurity]
1516 public static extern dReal JointGetSliderParam(IntPtr j, int parameter);
1517
1518 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderPosition"), SuppressUnmanagedCodeSecurity]
1519 public static extern dReal JointGetSliderPosition(IntPtr j);
1520
1521 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderPositionRate"), SuppressUnmanagedCodeSecurity]
1522 public static extern dReal JointGetSliderPositionRate(IntPtr j);
1523
1524 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetType"), SuppressUnmanagedCodeSecurity]
1525 public static extern JointType JointGetType(IntPtr j);
1526
1527 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAnchor"), SuppressUnmanagedCodeSecurity]
1528 public static extern void JointGetUniversalAnchor(IntPtr j, out Vector3 result);
1529
1530 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAnchor2"), SuppressUnmanagedCodeSecurity]
1531 public static extern void JointGetUniversalAnchor2(IntPtr j, out Vector3 result);
1532
1533 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle1"), SuppressUnmanagedCodeSecurity]
1534 public static extern dReal JointGetUniversalAngle1(IntPtr j);
1535
1536 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle1Rate"), SuppressUnmanagedCodeSecurity]
1537 public static extern dReal JointGetUniversalAngle1Rate(IntPtr j);
1538
1539 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle2"), SuppressUnmanagedCodeSecurity]
1540 public static extern dReal JointGetUniversalAngle2(IntPtr j);
1541
1542 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle2Rate"), SuppressUnmanagedCodeSecurity]
1543 public static extern dReal JointGetUniversalAngle2Rate(IntPtr j);
1544
1545 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngles"), SuppressUnmanagedCodeSecurity]
1546 public static extern void JointGetUniversalAngles(IntPtr j, out dReal angle1, out dReal angle2);
1547
1548 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAxis1"), SuppressUnmanagedCodeSecurity]
1549 public static extern void JointGetUniversalAxis1(IntPtr j, out Vector3 result);
1550
1551 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAxis2"), SuppressUnmanagedCodeSecurity]
1552 public static extern void JointGetUniversalAxis2(IntPtr j, out Vector3 result);
1553
1554 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalParam"), SuppressUnmanagedCodeSecurity]
1555 public static extern dReal JointGetUniversalParam(IntPtr j, int parameter);
1556
1557 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGroupCreate"), SuppressUnmanagedCodeSecurity]
1558 public static extern IntPtr JointGroupCreate(int max_size);
1559
1560 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGroupDestroy"), SuppressUnmanagedCodeSecurity]
1561 public static extern void JointGroupDestroy(IntPtr group);
1562
1563 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGroupEmpty"), SuppressUnmanagedCodeSecurity]
1564 public static extern void JointGroupEmpty(IntPtr group);
1565
1566 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorAngle"), SuppressUnmanagedCodeSecurity]
1567 public static extern void JointSetAMotorAngle(IntPtr j, int anum, dReal angle);
1568
1569 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorAxis"), SuppressUnmanagedCodeSecurity]
1570 public static extern void JointSetAMotorAxis(IntPtr j, int anum, int rel, dReal x, dReal y, dReal z);
1571
1572 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorMode"), SuppressUnmanagedCodeSecurity]
1573 public static extern void JointSetAMotorMode(IntPtr j, int mode);
1574
1575 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorNumAxes"), SuppressUnmanagedCodeSecurity]
1576 public static extern void JointSetAMotorNumAxes(IntPtr group, int num);
1577
1578 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorParam"), SuppressUnmanagedCodeSecurity]
1579 public static extern void JointSetAMotorParam(IntPtr group, int parameter, dReal value);
1580
1581 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetBallAnchor"), SuppressUnmanagedCodeSecurity]
1582 public static extern void JointSetBallAnchor(IntPtr j, dReal x, dReal y, dReal z);
1583
1584 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetBallAnchor2"), SuppressUnmanagedCodeSecurity]
1585 public static extern void JointSetBallAnchor2(IntPtr j, dReal x, dReal y, dReal z);
1586
1587 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetData"), SuppressUnmanagedCodeSecurity]
1588 public static extern void JointSetData(IntPtr j, IntPtr data);
1589
1590 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetFeedback"), SuppressUnmanagedCodeSecurity]
1591 public static extern void JointSetFeedback(IntPtr j, out JointFeedback feedback);
1592
1593 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetFixed"), SuppressUnmanagedCodeSecurity]
1594 public static extern void JointSetFixed(IntPtr j);
1595
1596 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeAnchor"), SuppressUnmanagedCodeSecurity]
1597 public static extern void JointSetHingeAnchor(IntPtr j, dReal x, dReal y, dReal z);
1598
1599 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeAnchorDelta"), SuppressUnmanagedCodeSecurity]
1600 public static extern void JointSetHingeAnchorDelta(IntPtr j, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az);
1601
1602 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeAxis"), SuppressUnmanagedCodeSecurity]
1603 public static extern void JointSetHingeAxis(IntPtr j, dReal x, dReal y, dReal z);
1604
1605 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeParam"), SuppressUnmanagedCodeSecurity]
1606 public static extern void JointSetHingeParam(IntPtr j, int parameter, dReal value);
1607
1608 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Anchor"), SuppressUnmanagedCodeSecurity]
1609 public static extern void JointSetHinge2Anchor(IntPtr j, dReal x, dReal y, dReal z);
1610
1611 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Axis1"), SuppressUnmanagedCodeSecurity]
1612 public static extern void JointSetHinge2Axis1(IntPtr j, dReal x, dReal y, dReal z);
1613
1614 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Axis2"), SuppressUnmanagedCodeSecurity]
1615 public static extern void JointSetHinge2Axis2(IntPtr j, dReal x, dReal y, dReal z);
1616
1617 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Param"), SuppressUnmanagedCodeSecurity]
1618 public static extern void JointSetHinge2Param(IntPtr j, int parameter, dReal value);
1619
1620 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetLMotorAxis"), SuppressUnmanagedCodeSecurity]
1621 public static extern void JointSetLMotorAxis(IntPtr j, int anum, int rel, dReal x, dReal y, dReal z);
1622
1623 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetLMotorNumAxes"), SuppressUnmanagedCodeSecurity]
1624 public static extern void JointSetLMotorNumAxes(IntPtr j, int num);
1625
1626 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetLMotorParam"), SuppressUnmanagedCodeSecurity]
1627 public static extern void JointSetLMotorParam(IntPtr j, int parameter, dReal value);
1628
1629 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPlane2DAngleParam"), SuppressUnmanagedCodeSecurity]
1630 public static extern void JointSetPlane2DAngleParam(IntPtr j, int parameter, dReal value);
1631
1632 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPlane2DXParam"), SuppressUnmanagedCodeSecurity]
1633 public static extern void JointSetPlane2DXParam(IntPtr j, int parameter, dReal value);
1634
1635 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPlane2DYParam"), SuppressUnmanagedCodeSecurity]
1636 public static extern void JointSetPlane2DYParam(IntPtr j, int parameter, dReal value);
1637
1638 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRAnchor"), SuppressUnmanagedCodeSecurity]
1639 public static extern void JointSetPRAnchor(IntPtr j, dReal x, dReal y, dReal z);
1640
1641 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRAxis1"), SuppressUnmanagedCodeSecurity]
1642 public static extern void JointSetPRAxis1(IntPtr j, dReal x, dReal y, dReal z);
1643
1644 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRAxis2"), SuppressUnmanagedCodeSecurity]
1645 public static extern void JointSetPRAxis2(IntPtr j, dReal x, dReal y, dReal z);
1646
1647 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRParam"), SuppressUnmanagedCodeSecurity]
1648 public static extern void JointSetPRParam(IntPtr j, int parameter, dReal value);
1649
1650 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetSliderAxis"), SuppressUnmanagedCodeSecurity]
1651 public static extern void JointSetSliderAxis(IntPtr j, dReal x, dReal y, dReal z);
1652
1653 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetSliderAxisDelta"), SuppressUnmanagedCodeSecurity]
1654 public static extern void JointSetSliderAxisDelta(IntPtr j, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az);
1655
1656 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetSliderParam"), SuppressUnmanagedCodeSecurity]
1657 public static extern void JointSetSliderParam(IntPtr j, int parameter, dReal value);
1658
1659 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalAnchor"), SuppressUnmanagedCodeSecurity]
1660 public static extern void JointSetUniversalAnchor(IntPtr j, dReal x, dReal y, dReal z);
1661
1662 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalAxis1"), SuppressUnmanagedCodeSecurity]
1663 public static extern void JointSetUniversalAxis1(IntPtr j, dReal x, dReal y, dReal z);
1664
1665 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalAxis2"), SuppressUnmanagedCodeSecurity]
1666 public static extern void JointSetUniversalAxis2(IntPtr j, dReal x, dReal y, dReal z);
1667
1668 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalParam"), SuppressUnmanagedCodeSecurity]
1669 public static extern void JointSetUniversalParam(IntPtr j, int parameter, dReal value);
1670
1671 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dLDLTAddTL"), SuppressUnmanagedCodeSecurity]
1672 public static extern void LDLTAddTL(ref dReal L, ref dReal d, ref dReal a, int n, int nskip);
1673
1674 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassAdd"), SuppressUnmanagedCodeSecurity]
1675 public static extern void MassAdd(ref Mass a, ref Mass b);
1676
1677 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassAdjust"), SuppressUnmanagedCodeSecurity]
1678 public static extern void MassAdjust(ref Mass m, dReal newmass);
1679
1680 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassCheck"), SuppressUnmanagedCodeSecurity]
1681 public static extern bool MassCheck(ref Mass m);
1682
1683 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassRotate"), SuppressUnmanagedCodeSecurity]
1684 public static extern void MassRotate(ref Mass mass, ref Matrix3 R);
1685
1686 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassRotate"), SuppressUnmanagedCodeSecurity]
1687 public static extern void MassRotate(ref Mass mass, ref dReal M00);
1688
1689 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetBox"), SuppressUnmanagedCodeSecurity]
1690 public static extern void MassSetBox(out Mass mass, dReal density, dReal lx, dReal ly, dReal lz);
1691
1692 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetBoxTotal"), SuppressUnmanagedCodeSecurity]
1693 public static extern void MassSetBoxTotal(out Mass mass, dReal total_mass, dReal lx, dReal ly, dReal lz);
1694
1695 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCapsule"), SuppressUnmanagedCodeSecurity]
1696 public static extern void MassSetCapsule(out Mass mass, dReal density, int direction, dReal radius, dReal length);
1697
1698 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCapsuleTotal"), SuppressUnmanagedCodeSecurity]
1699 public static extern void MassSetCapsuleTotal(out Mass mass, dReal total_mass, int direction, dReal radius, dReal length);
1700
1701 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCylinder"), SuppressUnmanagedCodeSecurity]
1702 public static extern void MassSetCylinder(out Mass mass, dReal density, int direction, dReal radius, dReal length);
1703
1704 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCylinderTotal"), SuppressUnmanagedCodeSecurity]
1705 public static extern void MassSetCylinderTotal(out Mass mass, dReal total_mass, int direction, dReal radius, dReal length);
1706
1707 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetParameters"), SuppressUnmanagedCodeSecurity]
1708 public static extern void MassSetParameters(out Mass mass, dReal themass,
1709 dReal cgx, dReal cgy, dReal cgz,
1710 dReal i11, dReal i22, dReal i33,
1711 dReal i12, dReal i13, dReal i23);
1712
1713 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetSphere"), SuppressUnmanagedCodeSecurity]
1714 public static extern void MassSetSphere(out Mass mass, dReal density, dReal radius);
1715
1716 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetSphereTotal"), SuppressUnmanagedCodeSecurity]
1717 public static extern void dMassSetSphereTotal(out Mass mass, dReal total_mass, dReal radius);
1718
1719 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetTrimesh"), SuppressUnmanagedCodeSecurity]
1720 public static extern void MassSetTrimesh(out Mass mass, dReal density, IntPtr g);
1721
1722 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetZero"), SuppressUnmanagedCodeSecurity]
1723 public static extern void MassSetZero(out Mass mass);
1724
1725 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassTranslate"), SuppressUnmanagedCodeSecurity]
1726 public static extern void MassTranslate(ref Mass mass, dReal x, dReal y, dReal z);
1727
1728 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply0"), SuppressUnmanagedCodeSecurity]
1729 public static extern void Multiply0(out dReal A00, ref dReal B00, ref dReal C00, int p, int q, int r);
1730
1731 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply0"), SuppressUnmanagedCodeSecurity]
1732 private static extern void MultiplyiM3V3(out Vector3 vout, ref Matrix3 matrix, ref Vector3 vect,int p, int q, int r);
1733 public static void MultiplyM3V3(out Vector3 outvector, ref Matrix3 matrix, ref Vector3 invector)
1734 {
1735 MultiplyiM3V3(out outvector, ref matrix, ref invector, 3, 3, 1);
1736 }
1737
1738 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply1"), SuppressUnmanagedCodeSecurity]
1739 public static extern void Multiply1(out dReal A00, ref dReal B00, ref dReal C00, int p, int q, int r);
1740
1741 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply2"), SuppressUnmanagedCodeSecurity]
1742 public static extern void Multiply2(out dReal A00, ref dReal B00, ref dReal C00, int p, int q, int r);
1743
1744 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQFromAxisAndAngle"), SuppressUnmanagedCodeSecurity]
1745 public static extern void QFromAxisAndAngle(out Quaternion q, dReal ax, dReal ay, dReal az, dReal angle);
1746
1747 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQfromR"), SuppressUnmanagedCodeSecurity]
1748 public static extern void QfromR(out Quaternion q, ref Matrix3 R);
1749
1750 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply0"), SuppressUnmanagedCodeSecurity]
1751 public static extern void QMultiply0(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
1752
1753 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply1"), SuppressUnmanagedCodeSecurity]
1754 public static extern void QMultiply1(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
1755
1756 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply2"), SuppressUnmanagedCodeSecurity]
1757 public static extern void QMultiply2(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
1758
1759 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply3"), SuppressUnmanagedCodeSecurity]
1760 public static extern void QMultiply3(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
1761
1762 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQSetIdentity"), SuppressUnmanagedCodeSecurity]
1763 public static extern void QSetIdentity(out Quaternion q);
1764
1765 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQuadTreeSpaceCreate"), SuppressUnmanagedCodeSecurity]
1766 public static extern IntPtr QuadTreeSpaceCreate(IntPtr space, ref Vector3 center, ref Vector3 extents, int depth);
1767
1768 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQuadTreeSpaceCreate"), SuppressUnmanagedCodeSecurity]
1769 public static extern IntPtr QuadTreeSpaceCreate(IntPtr space, ref dReal centerX, ref dReal extentsX, int depth);
1770
1771 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRandReal"), SuppressUnmanagedCodeSecurity]
1772 public static extern dReal RandReal();
1773
1774 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFrom2Axes"), SuppressUnmanagedCodeSecurity]
1775 public static extern void RFrom2Axes(out Matrix3 R, dReal ax, dReal ay, dReal az, dReal bx, dReal by, dReal bz);
1776
1777 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFromAxisAndAngle"), SuppressUnmanagedCodeSecurity]
1778 public static extern void RFromAxisAndAngle(out Matrix3 R, dReal x, dReal y, dReal z, dReal angle);
1779
1780 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFromEulerAngles"), SuppressUnmanagedCodeSecurity]
1781 public static extern void RFromEulerAngles(out Matrix3 R, dReal phi, dReal theta, dReal psi);
1782
1783 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRfromQ"), SuppressUnmanagedCodeSecurity]
1784 public static extern void RfromQ(out Matrix3 R, ref Quaternion q);
1785
1786 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFromZAxis"), SuppressUnmanagedCodeSecurity]
1787 public static extern void RFromZAxis(out Matrix3 R, dReal ax, dReal ay, dReal az);
1788
1789 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRSetIdentity"), SuppressUnmanagedCodeSecurity]
1790 public static extern void RSetIdentity(out Matrix3 R);
1791
1792 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSetValue"), SuppressUnmanagedCodeSecurity]
1793 public static extern void SetValue(out dReal a, int n);
1794
1795 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSetZero"), SuppressUnmanagedCodeSecurity]
1796 public static extern void SetZero(out dReal a, int n);
1797
1798 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSimpleSpaceCreate"), SuppressUnmanagedCodeSecurity]
1799 public static extern IntPtr SimpleSpaceCreate(IntPtr space);
1800
1801 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveCholesky"), SuppressUnmanagedCodeSecurity]
1802 public static extern void SolveCholesky(ref dReal L, out dReal b, int n);
1803
1804 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveL1"), SuppressUnmanagedCodeSecurity]
1805 public static extern void SolveL1(ref dReal L, out dReal b, int n, int nskip);
1806
1807 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveL1T"), SuppressUnmanagedCodeSecurity]
1808 public static extern void SolveL1T(ref dReal L, out dReal b, int n, int nskip);
1809
1810 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveLDLT"), SuppressUnmanagedCodeSecurity]
1811 public static extern void SolveLDLT(ref dReal L, ref dReal d, out dReal b, int n, int nskip);
1812
1813 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceAdd"), SuppressUnmanagedCodeSecurity]
1814 public static extern void SpaceAdd(IntPtr space, IntPtr geom);
1815
1816 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceLockQuery"), SuppressUnmanagedCodeSecurity]
1817 public static extern bool SpaceLockQuery(IntPtr space);
1818
1819 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceClean"), SuppressUnmanagedCodeSecurity]
1820 public static extern void SpaceClean(IntPtr space);
1821
1822 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceCollide"), SuppressUnmanagedCodeSecurity]
1823 public static extern void SpaceCollide(IntPtr space, IntPtr data, NearCallback callback);
1824
1825 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceCollide2"), SuppressUnmanagedCodeSecurity]
1826 public static extern void SpaceCollide2(IntPtr space1, IntPtr space2, IntPtr data, NearCallback callback);
1827
1828 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceDestroy"), SuppressUnmanagedCodeSecurity]
1829 public static extern void SpaceDestroy(IntPtr space);
1830
1831 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetCleanup"), SuppressUnmanagedCodeSecurity]
1832 public static extern bool SpaceGetCleanup(IntPtr space);
1833
1834 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetNumGeoms"), SuppressUnmanagedCodeSecurity]
1835 public static extern int SpaceGetNumGeoms(IntPtr space);
1836
1837 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetGeom"), SuppressUnmanagedCodeSecurity]
1838 public static extern IntPtr SpaceGetGeom(IntPtr space, int i);
1839
1840 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetSublevel"), SuppressUnmanagedCodeSecurity]
1841 public static extern int SpaceGetSublevel(IntPtr space);
1842
1843 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceQuery"), SuppressUnmanagedCodeSecurity]
1844 public static extern bool SpaceQuery(IntPtr space, IntPtr geom);
1845
1846 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceRemove"), SuppressUnmanagedCodeSecurity]
1847 public static extern void SpaceRemove(IntPtr space, IntPtr geom);
1848
1849 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceSetCleanup"), SuppressUnmanagedCodeSecurity]
1850 public static extern void SpaceSetCleanup(IntPtr space, bool mode);
1851
1852 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceSetSublevel"), SuppressUnmanagedCodeSecurity]
1853 public static extern void SpaceSetSublevel(IntPtr space, int sublevel);
1854
1855 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSweepAndPruneSpaceCreate"), SuppressUnmanagedCodeSecurity]
1856 public static extern IntPtr SweepAndPruneSpaceCreate(IntPtr space, int AxisOrder);
1857
1858 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dVectorScale"), SuppressUnmanagedCodeSecurity]
1859 public static extern void VectorScale(out dReal a, ref dReal d, int n);
1860
1861 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldCreate"), SuppressUnmanagedCodeSecurity]
1862 public static extern IntPtr WorldCreate();
1863
1864 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldDestroy"), SuppressUnmanagedCodeSecurity]
1865 public static extern void WorldDestroy(IntPtr world);
1866
1867 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableAverageSamplesCount"), SuppressUnmanagedCodeSecurity]
1868 public static extern int WorldGetAutoDisableAverageSamplesCount(IntPtr world);
1869
1870 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
1871 public static extern dReal WorldGetAutoDisableAngularThreshold(IntPtr world);
1872
1873 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
1874 public static extern bool WorldGetAutoDisableFlag(IntPtr world);
1875
1876 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
1877 public static extern dReal WorldGetAutoDisableLinearThreshold(IntPtr world);
1878
1879 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
1880 public static extern int WorldGetAutoDisableSteps(IntPtr world);
1881
1882 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
1883 public static extern dReal WorldGetAutoDisableTime(IntPtr world);
1884
1885 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoEnableDepthSF1"), SuppressUnmanagedCodeSecurity]
1886 public static extern int WorldGetAutoEnableDepthSF1(IntPtr world);
1887
1888 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetCFM"), SuppressUnmanagedCodeSecurity]
1889 public static extern dReal WorldGetCFM(IntPtr world);
1890
1891 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetERP"), SuppressUnmanagedCodeSecurity]
1892 public static extern dReal WorldGetERP(IntPtr world);
1893
1894 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetGravity"), SuppressUnmanagedCodeSecurity]
1895 public static extern void WorldGetGravity(IntPtr world, out Vector3 gravity);
1896
1897 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetGravity"), SuppressUnmanagedCodeSecurity]
1898 public static extern void WorldGetGravity(IntPtr world, out dReal X);
1899
1900 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetContactMaxCorrectingVel"), SuppressUnmanagedCodeSecurity]
1901 public static extern dReal WorldGetContactMaxCorrectingVel(IntPtr world);
1902
1903 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetContactSurfaceLayer"), SuppressUnmanagedCodeSecurity]
1904 public static extern dReal WorldGetContactSurfaceLayer(IntPtr world);
1905
1906 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAngularDamping"), SuppressUnmanagedCodeSecurity]
1907 public static extern dReal WorldGetAngularDamping(IntPtr world);
1908
1909 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
1910 public static extern dReal WorldGetAngularDampingThreshold(IntPtr world);
1911
1912 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetLinearDamping"), SuppressUnmanagedCodeSecurity]
1913 public static extern dReal WorldGetLinearDamping(IntPtr world);
1914
1915 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
1916 public static extern dReal WorldGetLinearDampingThreshold(IntPtr world);
1917
1918 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetQuickStepNumIterations"), SuppressUnmanagedCodeSecurity]
1919 public static extern int WorldGetQuickStepNumIterations(IntPtr world);
1920
1921 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetQuickStepW"), SuppressUnmanagedCodeSecurity]
1922 public static extern dReal WorldGetQuickStepW(IntPtr world);
1923
1924 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetMaxAngularSpeed"), SuppressUnmanagedCodeSecurity]
1925 public static extern dReal WorldGetMaxAngularSpeed(IntPtr world);
1926
1927 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldImpulseToForce"), SuppressUnmanagedCodeSecurity]
1928 public static extern void WorldImpulseToForce(IntPtr world, dReal stepsize, dReal ix, dReal iy, dReal iz, out Vector3 force);
1929
1930 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldImpulseToForce"), SuppressUnmanagedCodeSecurity]
1931 public static extern void WorldImpulseToForce(IntPtr world, dReal stepsize, dReal ix, dReal iy, dReal iz, out dReal forceX);
1932
1933 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldQuickStep"), SuppressUnmanagedCodeSecurity]
1934 public static extern void WorldQuickStep(IntPtr world, dReal stepsize);
1935
1936 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAngularDamping"), SuppressUnmanagedCodeSecurity]
1937 public static extern void WorldSetAngularDamping(IntPtr world, dReal scale);
1938
1939 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
1940 public static extern void WorldSetAngularDampingThreshold(IntPtr world, dReal threshold);
1941
1942 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
1943 public static extern void WorldSetAutoDisableAngularThreshold(IntPtr world, dReal angular_threshold);
1944
1945 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableAverageSamplesCount"), SuppressUnmanagedCodeSecurity]
1946 public static extern void WorldSetAutoDisableAverageSamplesCount(IntPtr world, int average_samples_count);
1947
1948 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
1949 public static extern void WorldSetAutoDisableFlag(IntPtr world, bool do_auto_disable);
1950
1951 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
1952 public static extern void WorldSetAutoDisableLinearThreshold(IntPtr world, dReal linear_threshold);
1953
1954 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
1955 public static extern void WorldSetAutoDisableSteps(IntPtr world, int steps);
1956
1957 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
1958 public static extern void WorldSetAutoDisableTime(IntPtr world, dReal time);
1959
1960 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoEnableDepthSF1"), SuppressUnmanagedCodeSecurity]
1961 public static extern void WorldSetAutoEnableDepthSF1(IntPtr world, int autoEnableDepth);
1962
1963 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetCFM"), SuppressUnmanagedCodeSecurity]
1964 public static extern void WorldSetCFM(IntPtr world, dReal cfm);
1965
1966 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetContactMaxCorrectingVel"), SuppressUnmanagedCodeSecurity]
1967 public static extern void WorldSetContactMaxCorrectingVel(IntPtr world, dReal vel);
1968
1969 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetContactSurfaceLayer"), SuppressUnmanagedCodeSecurity]
1970 public static extern void WorldSetContactSurfaceLayer(IntPtr world, dReal depth);
1971
1972 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetDamping"), SuppressUnmanagedCodeSecurity]
1973 public static extern void WorldSetDamping(IntPtr world, dReal linear_scale, dReal angular_scale);
1974
1975 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetERP"), SuppressUnmanagedCodeSecurity]
1976 public static extern void WorldSetERP(IntPtr world, dReal erp);
1977
1978 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetGravity"), SuppressUnmanagedCodeSecurity]
1979 public static extern void WorldSetGravity(IntPtr world, dReal x, dReal y, dReal z);
1980
1981 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetLinearDamping"), SuppressUnmanagedCodeSecurity]
1982 public static extern void WorldSetLinearDamping(IntPtr world, dReal scale);
1983
1984 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
1985 public static extern void WorldSetLinearDampingThreshold(IntPtr world, dReal threshold);
1986
1987 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetQuickStepNumIterations"), SuppressUnmanagedCodeSecurity]
1988 public static extern void WorldSetQuickStepNumIterations(IntPtr world, int num);
1989
1990 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetQuickStepW"), SuppressUnmanagedCodeSecurity]
1991 public static extern void WorldSetQuickStepW(IntPtr world, dReal over_relaxation);
1992
1993 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetMaxAngularSpeed"), SuppressUnmanagedCodeSecurity]
1994 public static extern void WorldSetMaxAngularSpeed(IntPtr world, dReal max_speed);
1995
1996 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldStep"), SuppressUnmanagedCodeSecurity]
1997 public static extern void WorldStep(IntPtr world, dReal stepsize);
1998
1999 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldStepFast1"), SuppressUnmanagedCodeSecurity]
2000 public static extern void WorldStepFast1(IntPtr world, dReal stepsize, int maxiterations);
2001
2002 [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldExportDIF"), SuppressUnmanagedCodeSecurity]
2003 public static extern void WorldExportDIF(IntPtr world, string filename, bool append, string prefix);
2004 }
2005}
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/UbitOdePlugin/OdePlugin.cs
new file mode 100644
index 0000000..d32188e
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdePlugin.cs
@@ -0,0 +1,90 @@
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.Threading;
33using System.IO;
34using System.Diagnostics;
35using log4net;
36using Nini.Config;
37using OdeAPI;
38using OpenSim.Framework;
39using OpenSim.Region.Physics.Manager;
40using OpenMetaverse;
41
42namespace OpenSim.Region.Physics.OdePlugin
43{
44 /// <summary>
45 /// ODE plugin
46 /// </summary>
47 public class OdePlugin : IPhysicsPlugin
48 {
49 //private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
50
51 private OdeScene m_scene;
52
53 public bool Init()
54 {
55 if (Util.IsWindows())
56 Util.LoadArchSpecificWindowsDll("ode.dll");
57
58 if (d.InitODE2(0) != 0)
59 {
60 if (d.AllocateODEDataForThread(~0U) == 0)
61 {
62 d.CloseODE();
63 return false;
64 }
65 return true;
66 }
67 return false;
68 }
69
70 public PhysicsScene GetScene(String sceneIdentifier)
71 {
72 if (m_scene == null)
73 {
74
75 m_scene = new OdeScene(sceneIdentifier);
76 }
77 return (m_scene);
78 }
79
80 public string GetName()
81 {
82 return ("UbitODE");
83 }
84
85 public void Dispose()
86 {
87 d.CloseODE();
88 }
89 }
90} \ No newline at end of file
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
new file mode 100644
index 0000000..fa3d33e
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
@@ -0,0 +1,2696 @@
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 SPAM
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 OdeAPI;
40using OpenSim.Framework;
41using OpenSim.Region.Physics.Manager;
42using OpenMetaverse;
43
44namespace OpenSim.Region.Physics.OdePlugin
45{
46 public enum StatusIndicators : int
47 {
48 Generic = 0,
49 Start = 1,
50 End = 2
51 }
52
53 public struct sCollisionData
54 {
55 public uint ColliderLocalId;
56 public uint CollidedWithLocalId;
57 public int NumberOfCollisions;
58 public int CollisionType;
59 public int StatusIndicator;
60 public int lastframe;
61 }
62
63 // colision flags of things others can colide with
64 // rays, sensors, probes removed since can't be colided with
65 // The top space where things are placed provided further selection
66 // ie physical are in active space nonphysical in static
67 // this should be exclusive as possible
68
69 [Flags]
70 public enum CollisionCategories : uint
71 {
72 Disabled = 0,
73 //by 'things' types
74 Space = 0x01,
75 Geom = 0x02, // aka prim/part
76 Character = 0x04,
77 Land = 0x08,
78 Water = 0x010,
79
80 // by state
81 Phantom = 0x01000,
82 VolumeDtc = 0x02000,
83 Selected = 0x04000,
84 NoShape = 0x08000,
85
86
87 All = 0xffffffff
88 }
89
90 /// <summary>
91 /// Material type for a primitive
92 /// </summary>
93 public enum Material : int
94 {
95 /// <summary></summary>
96 Stone = 0,
97 /// <summary></summary>
98 Metal = 1,
99 /// <summary></summary>
100 Glass = 2,
101 /// <summary></summary>
102 Wood = 3,
103 /// <summary></summary>
104 Flesh = 4,
105 /// <summary></summary>
106 Plastic = 5,
107 /// <summary></summary>
108 Rubber = 6,
109
110 light = 7 // compatibility with old viewers
111 }
112
113 public enum changes : int
114 {
115 Add = 0, // arg null. finishs the prim creation. should be used internally only ( to remove later ?)
116 Remove,
117 Link, // arg AuroraODEPrim new parent prim or null to delink. Makes the prim part of a object with prim parent as root
118 // or removes from a object if arg is null
119 DeLink,
120 Position, // arg Vector3 new position in world coords. Changes prim position. Prim must know if it is root or child
121 Orientation, // arg Quaternion new orientation in world coords. Changes prim position. Prim must know it it is root or child
122 PosOffset, // not in use
123 // arg Vector3 new position in local coords. Changes prim position in object
124 OriOffset, // not in use
125 // arg Vector3 new position in local coords. Changes prim position in object
126 Velocity,
127 AngVelocity,
128 Acceleration,
129 Force,
130 Torque,
131 Momentum,
132
133 AddForce,
134 AddAngForce,
135 AngLock,
136
137 Size,
138 Shape,
139
140 CollidesWater,
141 VolumeDtc,
142
143 Physical,
144 Phantom,
145 Selected,
146 disabled,
147 building,
148
149 VehicleType,
150 VehicleFloatParam,
151 VehicleVectorParam,
152 VehicleRotationParam,
153 VehicleFlags,
154 SetVehicle,
155
156 Null //keep this last used do dim the methods array. does nothing but pulsing the prim
157 }
158
159 public struct ODEchangeitem
160 {
161 public PhysicsActor actor;
162 public OdeCharacter character;
163 public changes what;
164 public Object arg;
165 }
166
167 public class OdeScene : PhysicsScene
168 {
169 private readonly ILog m_log;
170 // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
171
172 public bool OdeUbitLib = false;
173// private int threadid = 0;
174 private Random fluidRandomizer = new Random(Environment.TickCount);
175
176 const d.ContactFlags comumContactFlags = d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM |d.ContactFlags.Approx1 | d.ContactFlags.Bounce;
177 const float MaxERP = 0.8f;
178 const float minERP = 0.1f;
179 const float comumContactCFM = 0.0001f;
180
181 float frictionMovementMult = 0.3f;
182
183 float TerrainBounce = 0.1f;
184 float TerrainFriction = 0.3f;
185
186 public float AvatarFriction = 0;// 0.9f * 0.5f;
187
188 private const uint m_regionWidth = Constants.RegionSize;
189 private const uint m_regionHeight = Constants.RegionSize;
190
191 public float ODE_STEPSIZE = 0.020f;
192 public float HalfOdeStep = 0.01f;
193 private float metersInSpace = 25.6f;
194 private float m_timeDilation = 1.0f;
195
196 DateTime m_lastframe;
197
198 public float gravityx = 0f;
199 public float gravityy = 0f;
200 public float gravityz = -9.8f;
201
202 private float waterlevel = 0f;
203 private int framecount = 0;
204
205 private IntPtr WaterGeom = IntPtr.Zero;
206 private IntPtr WaterHeightmapData = IntPtr.Zero;
207 private GCHandle WaterMapHandler = new GCHandle();
208
209 public float avPIDD = 2200f; // make it visible
210 public float avPIDP = 900f; // make it visible
211 private float avCapRadius = 0.37f;
212 private float avDensity = 3f;
213 private float avMovementDivisorWalk = 1.3f;
214 private float avMovementDivisorRun = 0.8f;
215 private float minimumGroundFlightOffset = 3f;
216 public float maximumMassObject = 10000.01f;
217
218 public bool meshSculptedPrim = true;
219 public bool forceSimplePrimMeshing = false;
220
221 public float meshSculptLOD = 32;
222 public float MeshSculptphysicalLOD = 32;
223
224 public float geomDefaultDensity = 10.000006836f;
225
226 public int geomContactPointsStartthrottle = 3;
227 public int geomUpdatesPerThrottledUpdate = 15;
228
229 public float bodyPIDD = 35f;
230 public float bodyPIDG = 25;
231
232// public int geomCrossingFailuresBeforeOutofbounds = 6;
233
234 public int bodyFramesAutoDisable = 5;
235
236
237 private d.NearCallback nearCallback;
238
239 private readonly HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
240 private readonly HashSet<OdePrim> _prims = new HashSet<OdePrim>();
241 private readonly HashSet<OdePrim> _activeprims = new HashSet<OdePrim>();
242 private readonly HashSet<OdePrim> _activegroups = new HashSet<OdePrim>();
243
244 public OpenSim.Framework.LocklessQueue<ODEchangeitem> ChangesQueue = new OpenSim.Framework.LocklessQueue<ODEchangeitem>();
245
246 /// <summary>
247 /// A list of actors that should receive collision events.
248 /// </summary>
249 private readonly List<PhysicsActor> _collisionEventPrim = new List<PhysicsActor>();
250
251 private readonly HashSet<OdeCharacter> _badCharacter = new HashSet<OdeCharacter>();
252 public Dictionary<IntPtr, String> geom_name_map = new Dictionary<IntPtr, String>();
253 public Dictionary<IntPtr, PhysicsActor> actor_name_map = new Dictionary<IntPtr, PhysicsActor>();
254
255 private float contactsurfacelayer = 0.002f;
256
257 private int contactsPerCollision = 80;
258 internal IntPtr ContactgeomsArray = IntPtr.Zero;
259 private IntPtr GlobalContactsArray = IntPtr.Zero;
260
261 const int maxContactsbeforedeath = 4000;
262 private volatile int m_global_contactcount = 0;
263
264
265 private readonly IntPtr contactgroup;
266
267 public ContactData[] m_materialContactsData = new ContactData[8];
268
269 private readonly DoubleDictionary<Vector3, IntPtr, IntPtr> RegionTerrain = new DoubleDictionary<Vector3, IntPtr, IntPtr>();
270 private readonly Dictionary<IntPtr, float[]> TerrainHeightFieldHeights = new Dictionary<IntPtr, float[]>();
271 private readonly Dictionary<IntPtr, GCHandle> TerrainHeightFieldHeightsHandlers = new Dictionary<IntPtr, GCHandle>();
272
273 private int m_physicsiterations = 10;
274 private const float m_SkipFramesAtms = 0.40f; // Drop frames gracefully at a 400 ms lag
275 private readonly PhysicsActor PANull = new NullPhysicsActor();
276 private float step_time = 0.0f;
277
278 public IntPtr world;
279
280 private uint obj2LocalID = 0;
281 private OdeCharacter cc1;
282 private OdePrim cp1;
283 private OdeCharacter cc2;
284 private OdePrim cp2;
285
286 // split the spaces acording to contents type
287 // ActiveSpace contains characters and active prims
288 // StaticSpace contains land and other that is mostly static in enviroment
289 // this can contain subspaces, like the grid in staticspace
290 // as now space only contains this 2 top spaces
291
292 public IntPtr TopSpace; // the global space
293 public IntPtr ActiveSpace; // space for active prims
294 public IntPtr StaticSpace; // space for the static things around
295
296 // some speedup variables
297 private int spaceGridMaxX;
298 private int spaceGridMaxY;
299 private float spacesPerMeter;
300
301 // split static geometry collision into a grid as before
302 private IntPtr[,] staticPrimspace;
303
304 private Object OdeLock;
305 private static Object SimulationLock;
306
307 public IMesher mesher;
308
309 private IConfigSource m_config;
310
311 public bool physics_logging = false;
312 public int physics_logging_interval = 0;
313 public bool physics_logging_append_existing_logfile = false;
314
315 private Vector3 m_worldOffset = Vector3.Zero;
316 public Vector2 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
317 private PhysicsScene m_parentScene = null;
318
319 private ODERayCastRequestManager m_rayCastManager;
320
321
322/* maybe needed if ode uses tls
323 private void checkThread()
324 {
325
326 int th = Thread.CurrentThread.ManagedThreadId;
327 if(th != threadid)
328 {
329 threadid = th;
330 d.AllocateODEDataForThread(~0U);
331 }
332 }
333 */
334 /// <summary>
335 /// Initiailizes the scene
336 /// Sets many properties that ODE requires to be stable
337 /// These settings need to be tweaked 'exactly' right or weird stuff happens.
338 /// </summary>
339 public OdeScene(string sceneIdentifier)
340 {
341 m_log
342 = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + sceneIdentifier);
343
344// checkThread();
345 Name = sceneIdentifier;
346
347 OdeLock = new Object();
348 SimulationLock = new Object();
349
350 nearCallback = near;
351
352 m_rayCastManager = new ODERayCastRequestManager(this);
353 lock (OdeLock)
354 {
355 // Create the world and the first space
356 try
357 {
358 world = d.WorldCreate();
359 TopSpace = d.HashSpaceCreate(IntPtr.Zero);
360
361 // now the major subspaces
362 ActiveSpace = d.HashSpaceCreate(TopSpace);
363 StaticSpace = d.HashSpaceCreate(TopSpace);
364 }
365 catch
366 {
367 // i must RtC#FM
368 }
369
370 d.HashSpaceSetLevels(TopSpace, -2, 8);
371 d.HashSpaceSetLevels(ActiveSpace, -2, 8);
372 d.HashSpaceSetLevels(StaticSpace, -2, 8);
373
374 // demote to second level
375 d.SpaceSetSublevel(ActiveSpace, 1);
376 d.SpaceSetSublevel(StaticSpace, 1);
377
378 d.GeomSetCategoryBits(ActiveSpace, (uint)(CollisionCategories.Space |
379 CollisionCategories.Geom |
380 CollisionCategories.Character |
381 CollisionCategories.Phantom |
382 CollisionCategories.VolumeDtc
383 ));
384 d.GeomSetCollideBits(ActiveSpace, 0);
385 d.GeomSetCategoryBits(StaticSpace, (uint)(CollisionCategories.Space |
386 CollisionCategories.Geom |
387 CollisionCategories.Land |
388 CollisionCategories.Water |
389 CollisionCategories.Phantom |
390 CollisionCategories.VolumeDtc
391 ));
392 d.GeomSetCollideBits(StaticSpace, 0);
393
394 contactgroup = d.JointGroupCreate(0);
395 //contactgroup
396
397 d.WorldSetAutoDisableFlag(world, false);
398 }
399 }
400
401 // Initialize the mesh plugin
402// public override void Initialise(IMesher meshmerizer, IConfigSource config, RegionInfo region )
403 public override void Initialise(IMesher meshmerizer, IConfigSource config)
404 {
405// checkThread();
406 mesher = meshmerizer;
407 m_config = config;
408/*
409 string ode_config = d.GetConfiguration("ODE");
410 if (ode_config != null && ode_config != "")
411 {
412 m_log.WarnFormat("ODE configuration: {0}", ode_config);
413
414 if (ode_config.Contains("ODE_Ubit"))
415 {
416 OdeUbitLib = true;
417 }
418 }
419*/
420 /*
421 if (region != null)
422 {
423 WorldExtents.X = region.RegionSizeX;
424 WorldExtents.Y = region.RegionSizeY;
425 }
426 */
427
428 // Defaults
429
430 int contactsPerCollision = 80;
431
432 if (m_config != null)
433 {
434 IConfig physicsconfig = m_config.Configs["ODEPhysicsSettings"];
435 if (physicsconfig != null)
436 {
437 gravityx = physicsconfig.GetFloat("world_gravityx", gravityx);
438 gravityy = physicsconfig.GetFloat("world_gravityy", gravityy);
439 gravityz = physicsconfig.GetFloat("world_gravityz", gravityz);
440
441 metersInSpace = physicsconfig.GetFloat("meters_in_small_space", metersInSpace);
442
443 contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", contactsurfacelayer);
444
445 ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", ODE_STEPSIZE);
446 m_physicsiterations = physicsconfig.GetInt("world_internal_steps_without_collisions", m_physicsiterations);
447
448 avDensity = physicsconfig.GetFloat("av_density", avDensity);
449 avMovementDivisorWalk = physicsconfig.GetFloat("av_movement_divisor_walk", avMovementDivisorWalk);
450 avMovementDivisorRun = physicsconfig.GetFloat("av_movement_divisor_run", avMovementDivisorRun);
451 avCapRadius = physicsconfig.GetFloat("av_capsule_radius", avCapRadius);
452
453 contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", contactsPerCollision);
454
455 geomContactPointsStartthrottle = physicsconfig.GetInt("geom_contactpoints_start_throttling", 3);
456 geomUpdatesPerThrottledUpdate = physicsconfig.GetInt("geom_updates_before_throttled_update", 15);
457// geomCrossingFailuresBeforeOutofbounds = physicsconfig.GetInt("geom_crossing_failures_before_outofbounds", 5);
458
459 geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", geomDefaultDensity);
460 bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", bodyFramesAutoDisable);
461/*
462 bodyPIDD = physicsconfig.GetFloat("body_pid_derivative", bodyPIDD);
463 bodyPIDG = physicsconfig.GetFloat("body_pid_gain", bodyPIDG);
464*/
465 forceSimplePrimMeshing = physicsconfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
466 meshSculptedPrim = physicsconfig.GetBoolean("mesh_sculpted_prim", meshSculptedPrim);
467 meshSculptLOD = physicsconfig.GetFloat("mesh_lod", meshSculptLOD);
468 MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", MeshSculptphysicalLOD);
469/*
470 if (Environment.OSVersion.Platform == PlatformID.Unix)
471 {
472 avPIDD = physicsconfig.GetFloat("av_pid_derivative_linux", avPIDD);
473 avPIDP = physicsconfig.GetFloat("av_pid_proportional_linux", avPIDP);
474 }
475 else
476 {
477
478 avPIDD = physicsconfig.GetFloat("av_pid_derivative_win", avPIDD);
479 avPIDP = physicsconfig.GetFloat("av_pid_proportional_win", avPIDP);
480 }
481*/
482 physics_logging = physicsconfig.GetBoolean("physics_logging", false);
483 physics_logging_interval = physicsconfig.GetInt("physics_logging_interval", 0);
484 physics_logging_append_existing_logfile = physicsconfig.GetBoolean("physics_logging_append_existing_logfile", false);
485
486 minimumGroundFlightOffset = physicsconfig.GetFloat("minimum_ground_flight_offset", minimumGroundFlightOffset);
487 maximumMassObject = physicsconfig.GetFloat("maximum_mass_object", maximumMassObject);
488 }
489 }
490
491 HalfOdeStep = ODE_STEPSIZE * 0.5f;
492
493 ContactgeomsArray = Marshal.AllocHGlobal(contactsPerCollision * d.ContactGeom.unmanagedSizeOf);
494 GlobalContactsArray = GlobalContactsArray = Marshal.AllocHGlobal(maxContactsbeforedeath * d.Contact.unmanagedSizeOf);
495
496 m_materialContactsData[(int)Material.Stone].mu = 0.8f;
497 m_materialContactsData[(int)Material.Stone].bounce = 0.4f;
498
499 m_materialContactsData[(int)Material.Metal].mu = 0.3f;
500 m_materialContactsData[(int)Material.Metal].bounce = 0.4f;
501
502 m_materialContactsData[(int)Material.Glass].mu = 0.2f;
503 m_materialContactsData[(int)Material.Glass].bounce = 0.7f;
504
505 m_materialContactsData[(int)Material.Wood].mu = 0.6f;
506 m_materialContactsData[(int)Material.Wood].bounce = 0.5f;
507
508 m_materialContactsData[(int)Material.Flesh].mu = 0.9f;
509 m_materialContactsData[(int)Material.Flesh].bounce = 0.3f;
510
511 m_materialContactsData[(int)Material.Plastic].mu = 0.4f;
512 m_materialContactsData[(int)Material.Plastic].bounce = 0.7f;
513
514 m_materialContactsData[(int)Material.Rubber].mu = 0.9f;
515 m_materialContactsData[(int)Material.Rubber].bounce = 0.95f;
516
517 m_materialContactsData[(int)Material.light].mu = 0.0f;
518 m_materialContactsData[(int)Material.light].bounce = 0.0f;
519
520 // Set the gravity,, don't disable things automatically (we set it explicitly on some things)
521
522 d.WorldSetGravity(world, gravityx, gravityy, gravityz);
523 d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
524
525 d.WorldSetLinearDamping(world, 0.001f);
526 d.WorldSetAngularDamping(world, 0.001f);
527 d.WorldSetAngularDampingThreshold(world, 0f);
528 d.WorldSetLinearDampingThreshold(world, 0f);
529 d.WorldSetMaxAngularSpeed(world, 100f);
530
531 d.WorldSetCFM(world,1e-6f); // a bit harder than default
532 //d.WorldSetCFM(world, 1e-4f); // a bit harder than default
533 d.WorldSetERP(world, 0.6f); // higher than original
534
535 // Set how many steps we go without running collision testing
536 // This is in addition to the step size.
537 // Essentially Steps * m_physicsiterations
538 d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
539 d.WorldSetContactMaxCorrectingVel(world, 100.0f);
540
541 spacesPerMeter = 1 / metersInSpace;
542 spaceGridMaxX = (int)(WorldExtents.X * spacesPerMeter);
543 spaceGridMaxY = (int)(WorldExtents.Y * spacesPerMeter);
544
545 staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY];
546
547 // create all spaces now
548 int i, j;
549 IntPtr newspace;
550 for (i = 0; i < spaceGridMaxX; i++)
551 for (j = 0; j < spaceGridMaxY; j++)
552 {
553 newspace = d.HashSpaceCreate(StaticSpace);
554 d.GeomSetCategoryBits(newspace, (int)CollisionCategories.Space);
555 waitForSpaceUnlock(newspace);
556 d.SpaceSetSublevel(newspace, 2);
557 d.HashSpaceSetLevels(newspace, -2, 8);
558 d.GeomSetCategoryBits(newspace, (uint)(CollisionCategories.Space |
559 CollisionCategories.Geom |
560 CollisionCategories.Land |
561 CollisionCategories.Water |
562 CollisionCategories.Phantom |
563 CollisionCategories.VolumeDtc
564 ));
565 d.GeomSetCollideBits(newspace, 0);
566
567 staticPrimspace[i, j] = newspace;
568 }
569 // let this now be real maximum values
570 spaceGridMaxX--;
571 spaceGridMaxY--;
572 m_lastframe = DateTime.UtcNow;
573 }
574
575 internal void waitForSpaceUnlock(IntPtr space)
576 {
577 //if (space != IntPtr.Zero)
578 //while (d.SpaceLockQuery(space)) { } // Wait and do nothing
579 }
580
581 #region Collision Detection
582
583 // sets a global contact for a joint for contactgeom , and base contact description)
584
585 private IntPtr CreateContacJoint(ref d.ContactGeom contactGeom, float mu, float bounce, float cfm, float erpscale, float dscale)
586 {
587 if (GlobalContactsArray == IntPtr.Zero || m_global_contactcount >= maxContactsbeforedeath)
588 return IntPtr.Zero;
589
590 float erp = contactGeom.depth;
591 erp *= erpscale;
592 if (erp < minERP)
593 erp = minERP;
594 else if (erp > MaxERP)
595 erp = MaxERP;
596
597 float depth = contactGeom.depth * dscale;
598 if (depth > 0.5f)
599 depth = 0.5f;
600
601 d.Contact newcontact = new d.Contact();
602 newcontact.geom.depth = depth;
603 newcontact.geom.g1 = contactGeom.g1;
604 newcontact.geom.g2 = contactGeom.g2;
605 newcontact.geom.pos = contactGeom.pos;
606 newcontact.geom.normal = contactGeom.normal;
607 newcontact.geom.side1 = contactGeom.side1;
608 newcontact.geom.side2 = contactGeom.side2;
609
610 // this needs bounce also
611 newcontact.surface.mode = comumContactFlags;
612 newcontact.surface.mu = mu;
613 newcontact.surface.bounce = bounce;
614 newcontact.surface.soft_cfm = cfm;
615 newcontact.surface.soft_erp = erp;
616
617 IntPtr contact = new IntPtr(GlobalContactsArray.ToInt64() + (Int64)(m_global_contactcount * d.Contact.unmanagedSizeOf));
618 Marshal.StructureToPtr(newcontact, contact, true);
619 return d.JointCreateContactPtr(world, contactgroup, contact);
620 }
621
622
623
624 private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
625 {
626 if (ContactgeomsArray == IntPtr.Zero || index >= contactsPerCollision)
627 return false;
628
629 IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
630 newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
631 return true;
632 }
633
634 /// <summary>
635 /// This is our near callback. A geometry is near a body
636 /// </summary>
637 /// <param name="space">The space that contains the geoms. Remember, spaces are also geoms</param>
638 /// <param name="g1">a geometry or space</param>
639 /// <param name="g2">another geometry or space</param>
640 ///
641
642 private void near(IntPtr space, IntPtr g1, IntPtr g2)
643 {
644 // no lock here! It's invoked from within Simulate(), which is thread-locked
645
646 if (m_global_contactcount >= maxContactsbeforedeath)
647 return;
648
649 // Test if we're colliding a geom with a space.
650 // If so we have to drill down into the space recursively
651
652 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
653 return;
654
655 if (d.GeomIsSpace(g1) || d.GeomIsSpace(g2))
656 {
657 // We'll be calling near recursivly if one
658 // of them is a space to find all of the
659 // contact points in the space
660 try
661 {
662 d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
663 }
664 catch (AccessViolationException)
665 {
666 m_log.Warn("[PHYSICS]: Unable to collide test a space");
667 return;
668 }
669 //here one should check collisions of geoms inside a space
670 // but on each space we only should have geoms that not colide amoung each other
671 // so we don't dig inside spaces
672 return;
673 }
674
675 // get geom bodies to check if we already a joint contact
676 // guess this shouldn't happen now
677 IntPtr b1 = d.GeomGetBody(g1);
678 IntPtr b2 = d.GeomGetBody(g2);
679
680 // d.GeomClassID id = d.GeomGetClass(g1);
681
682 // Figure out how many contact points we have
683 int count = 0;
684 try
685 {
686 // Colliding Geom To Geom
687 // This portion of the function 'was' blatantly ripped off from BoxStack.cs
688
689 if (g1 == g2)
690 return; // Can't collide with yourself
691
692 if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
693 return;
694
695 count = d.CollidePtr(g1, g2, (contactsPerCollision & 0xffff), ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
696 }
697 catch (SEHException)
698 {
699 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.");
700// ode.drelease(world);
701 base.TriggerPhysicsBasedRestart();
702 }
703 catch (Exception e)
704 {
705 m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
706 return;
707 }
708
709 // id contacts done
710 if (count == 0)
711 return;
712
713 // try get physical actors
714 PhysicsActor p1;
715 PhysicsActor p2;
716
717 if (!actor_name_map.TryGetValue(g1, out p1))
718 {
719 p1 = PANull;
720 }
721
722 if (!actor_name_map.TryGetValue(g2, out p2))
723 {
724 p2 = PANull;
725 }
726
727 // update actors collision score
728 if (p1.CollisionScore >= float.MaxValue - count)
729 p1.CollisionScore = 0;
730 p1.CollisionScore += count;
731
732 if (p2.CollisionScore >= float.MaxValue - count)
733 p2.CollisionScore = 0;
734 p2.CollisionScore += count;
735
736
737 // get first contact
738 d.ContactGeom curContact = new d.ContactGeom();
739 if (!GetCurContactGeom(0, ref curContact))
740 return;
741 // for now it's the one with max depth
742 ContactPoint maxDepthContact = new ContactPoint(
743 new Vector3(curContact.pos.X, curContact.pos.Y, curContact.pos.Z),
744 new Vector3(curContact.normal.X, curContact.normal.Y, curContact.normal.Z),
745 curContact.depth
746 );
747 // do volume detection case
748 if (
749 (p1 is OdePrim) && (((OdePrim)p1).m_isVolumeDetect) ||
750 (p2 is OdePrim) && (((OdePrim)p2).m_isVolumeDetect))
751 {
752 collision_accounting_events(p1, p2, maxDepthContact);
753 return;
754 }
755
756 // big messy collision analises
757 float mu = 0;
758 float bounce = 0;
759 float cfm = 0.0001f;
760 float erp = 0.1f;
761 float erpscale = 1.0f;
762 float dscale = 1.0f;
763 bool IgnoreNegSides = false;
764
765
766 ContactData contactdata1 = new ContactData(0, 0, false);
767 ContactData contactdata2 = new ContactData(0, 0, false);
768
769 String name = null;
770 bool dop1foot = false;
771 bool dop2foot = false;
772 bool ignore = false;
773
774 switch (p1.PhysicsActorType)
775 {
776 case (int)ActorTypes.Agent:
777 {
778 bounce = 0;
779 mu = 0;
780 cfm = 0.0001f;
781
782 switch (p2.PhysicsActorType)
783 {
784 case (int)ActorTypes.Agent:
785/*
786 p1.getContactData(ref contactdata1);
787 p2.getContactData(ref contactdata2);
788
789 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
790
791 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
792 mu *= frictionMovementMult;
793*/
794 p1.CollidingObj = true;
795 p2.CollidingObj = true;
796 break;
797 case (int)ActorTypes.Prim:
798/*
799 p1.getContactData(ref contactdata1);
800 p2.getContactData(ref contactdata2);
801
802
803 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
804
805 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
806 mu *= frictionMovementMult;
807 */
808 if (p2.Velocity.LengthSquared() > 0.0f)
809 p2.CollidingObj = true;
810
811 dop1foot = true;
812 break;
813 default:
814 ignore = true; // avatar to terrain and water ignored
815 break;
816 }
817 break;
818 }
819
820 case (int)ActorTypes.Prim:
821 switch (p2.PhysicsActorType)
822 {
823 case (int)ActorTypes.Agent:
824// p1.getContactData(ref contactdata1);
825// p2.getContactData(ref contactdata2);
826
827 bounce = 0;
828 mu = 0;
829 cfm = 0.0001f;
830/*
831 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
832
833 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
834 mu *= frictionMovementMult;
835*/
836 dop2foot = true;
837 if (p1.Velocity.LengthSquared() > 0.0f)
838 p1.CollidingObj = true;
839 break;
840 case (int)ActorTypes.Prim:
841 if ((p1.Velocity - p2.Velocity).LengthSquared() > 0.0f)
842 {
843 p1.CollidingObj = true;
844 p2.CollidingObj = true;
845 }
846 p1.getContactData(ref contactdata1);
847 p2.getContactData(ref contactdata2);
848 bounce = contactdata1.bounce * contactdata2.bounce;
849 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
850
851 cfm = p1.Mass;
852 if (cfm > p2.Mass)
853 cfm = p2.Mass;
854 dscale = 10 / cfm;
855 dscale = (float)Math.Sqrt(dscale);
856 if (dscale > 1.0f)
857 dscale = 1.0f;
858 erpscale = cfm * 0.01f;
859 cfm = 0.0001f / cfm;
860 if (cfm > 0.01f)
861 cfm = 0.01f;
862
863 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
864 mu *= frictionMovementMult;
865
866 break;
867 default:
868 if (geom_name_map.TryGetValue(g2, out name))
869 {
870 if (name == "Terrain")
871 {
872 p1.getContactData(ref contactdata1);
873 bounce = contactdata1.bounce * TerrainBounce;
874 mu = (float)Math.Sqrt(contactdata1.mu * TerrainFriction);
875 if (Math.Abs(p1.Velocity.X) > 0.1f || Math.Abs(p1.Velocity.Y) > 0.1f)
876 mu *= frictionMovementMult;
877 p1.CollidingGround = true;
878
879 cfm = p1.Mass;
880 dscale = 10 / cfm;
881 dscale = (float)Math.Sqrt(dscale);
882 if (dscale > 1.0f)
883 dscale = 1.0f;
884 erpscale = cfm * 0.01f;
885 cfm = 0.0001f / cfm;
886 if (cfm > 0.01f)
887 cfm = 0.01f;
888
889 if (d.GeomGetClass(g1) == d.GeomClassID.TriMeshClass)
890 {
891 if (curContact.side1 > 0)
892 IgnoreNegSides = true;
893 }
894
895 }
896 else if (name == "Water")
897 {
898 ignore = true;
899 }
900 }
901 else
902 ignore=true;
903 break;
904 }
905 break;
906
907 default:
908 if (geom_name_map.TryGetValue(g1, out name))
909 {
910 if (name == "Terrain")
911 {
912 if (p2.PhysicsActorType == (int)ActorTypes.Prim)
913 {
914 p2.CollidingGround = true;
915 p2.getContactData(ref contactdata2);
916 bounce = contactdata2.bounce * TerrainBounce;
917 mu = (float)Math.Sqrt(contactdata2.mu * TerrainFriction);
918
919 cfm = p2.Mass;
920 dscale = 10 / cfm;
921 dscale = (float)Math.Sqrt(dscale);
922
923 if (dscale > 1.0f)
924 dscale = 1.0f;
925
926 erpscale = cfm * 0.01f;
927 cfm = 0.0001f / cfm;
928 if (cfm > 0.01f)
929 cfm = 0.01f;
930
931 if (curContact.side1 > 0) // should be 2 ?
932 IgnoreNegSides = true;
933
934 if (Math.Abs(p2.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y) > 0.1f)
935 mu *= frictionMovementMult;
936 }
937 else
938 ignore = true;
939
940 }
941 else if (name == "Water" &&
942 (p2.PhysicsActorType == (int)ActorTypes.Prim || p2.PhysicsActorType == (int)ActorTypes.Agent))
943 {
944 ignore = true;
945 }
946 }
947 else
948 ignore = true;
949 break;
950 }
951
952 if (ignore)
953 return;
954
955 IntPtr Joint;
956
957 int i = 0;
958 while(true)
959 {
960
961 if (IgnoreNegSides && curContact.side1 < 0)
962 {
963 if (++i >= count)
964 break;
965
966 if (!GetCurContactGeom(i, ref curContact))
967 break;
968 }
969 else
970
971 {
972 if (dop1foot && (p1.Position.Z - curContact.pos.Z) > (p1.Size.Z - avCapRadius) * 0.5f)
973 p1.IsColliding = true;
974 if (dop2foot && (p2.Position.Z - curContact.pos.Z) > (p2.Size.Z - avCapRadius) * 0.5f)
975 p2.IsColliding = true;
976
977 Joint = CreateContacJoint(ref curContact, mu, bounce, cfm, erpscale, dscale);
978 d.JointAttach(Joint, b1, b2);
979
980 if (++m_global_contactcount >= maxContactsbeforedeath)
981 break;
982
983 if (++i >= count)
984 break;
985
986 if (!GetCurContactGeom(i, ref curContact))
987 break;
988
989 if (curContact.depth > maxDepthContact.PenetrationDepth)
990 {
991 maxDepthContact.Position.X = curContact.pos.X;
992 maxDepthContact.Position.Y = curContact.pos.Y;
993 maxDepthContact.Position.Z = curContact.pos.Z;
994 maxDepthContact.SurfaceNormal.X = curContact.normal.X;
995 maxDepthContact.SurfaceNormal.Y = curContact.normal.Y;
996 maxDepthContact.SurfaceNormal.Z = curContact.normal.Z;
997 maxDepthContact.PenetrationDepth = curContact.depth;
998 }
999 }
1000 }
1001
1002 collision_accounting_events(p1, p2, maxDepthContact);
1003
1004/*
1005 if (notskipedcount > geomContactPointsStartthrottle)
1006 {
1007 // If there are more then 3 contact points, it's likely
1008 // that we've got a pile of objects, so ...
1009 // We don't want to send out hundreds of terse updates over and over again
1010 // so lets throttle them and send them again after it's somewhat sorted out.
1011 this needs checking so out for now
1012 if (b1 != IntPtr.Zero)
1013 p1.ThrottleUpdates = true;
1014 if (b2 != IntPtr.Zero)
1015 p2.ThrottleUpdates = true;
1016
1017 }
1018 */
1019 }
1020
1021 private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
1022 {
1023 obj2LocalID = 0;
1024 bool p1events = p1.SubscribedEvents();
1025 bool p2events = p2.SubscribedEvents();
1026
1027 if (p1 is OdePrim && p1.IsVolumeDtc)
1028 p2events = false;
1029 if (p2 is OdePrim && p2.IsVolumeDtc)
1030 p1events = false;
1031
1032 if (!(p2events || p1events))
1033 return;
1034
1035 switch ((ActorTypes)p1.PhysicsActorType)
1036 {
1037 case ActorTypes.Agent:
1038 cc1 = (OdeCharacter)p1;
1039 switch ((ActorTypes)p2.PhysicsActorType)
1040 {
1041 case ActorTypes.Agent:
1042 cc2 = (OdeCharacter)p2;
1043 obj2LocalID = cc2.m_localID;
1044 if (p2events)
1045 cc2.AddCollisionEvent(cc1.m_localID, contact);
1046 break;
1047
1048 case ActorTypes.Prim:
1049 if (p2 is OdePrim)
1050 {
1051 cp2 = (OdePrim)p2;
1052 obj2LocalID = cp2.m_localID;
1053 if (p2events)
1054 cp2.AddCollisionEvent(cc1.m_localID, contact);
1055 }
1056 break;
1057
1058 case ActorTypes.Ground:
1059 case ActorTypes.Unknown:
1060 default:
1061 obj2LocalID = 0;
1062 break;
1063 }
1064 if (p1events)
1065 {
1066 contact.SurfaceNormal = -contact.SurfaceNormal;
1067 cc1.AddCollisionEvent(obj2LocalID, contact);
1068 }
1069 break;
1070
1071 case ActorTypes.Prim:
1072
1073 if (p1 is OdePrim)
1074 {
1075 cp1 = (OdePrim)p1;
1076
1077 // obj1LocalID = cp2.m_localID;
1078 switch ((ActorTypes)p2.PhysicsActorType)
1079 {
1080 case ActorTypes.Agent:
1081 if (p2 is OdeCharacter)
1082 {
1083 cc2 = (OdeCharacter)p2;
1084 obj2LocalID = cc2.m_localID;
1085 if (p2events)
1086 cc2.AddCollisionEvent(cp1.m_localID, contact);
1087 }
1088 break;
1089 case ActorTypes.Prim:
1090
1091 if (p2 is OdePrim)
1092 {
1093 cp2 = (OdePrim)p2;
1094 obj2LocalID = cp2.m_localID;
1095 if (p2events)
1096 cp2.AddCollisionEvent(cp1.m_localID, contact);
1097 }
1098 break;
1099
1100 case ActorTypes.Ground:
1101 case ActorTypes.Unknown:
1102 default:
1103 obj2LocalID = 0;
1104 break;
1105 }
1106 if (p1events)
1107 {
1108 contact.SurfaceNormal = -contact.SurfaceNormal;
1109 cp1.AddCollisionEvent(obj2LocalID, contact);
1110 }
1111 }
1112 break;
1113 }
1114 }
1115
1116 /// <summary>
1117 /// This is our collision testing routine in ODE
1118 /// </summary>
1119 /// <param name="timeStep"></param>
1120 private void collision_optimized()
1121 {
1122 lock (_characters)
1123 {
1124 try
1125 {
1126 foreach (OdeCharacter chr in _characters)
1127 {
1128 if (chr == null || chr.Shell == IntPtr.Zero || chr.Body == IntPtr.Zero)
1129 continue;
1130
1131 chr.IsColliding = false;
1132 // chr.CollidingGround = false; not done here
1133 chr.CollidingObj = false;
1134 // do colisions with static space
1135 d.SpaceCollide2(StaticSpace, chr.Shell, IntPtr.Zero, nearCallback);
1136 }
1137 }
1138 catch (AccessViolationException)
1139 {
1140 m_log.Warn("[PHYSICS]: Unable to collide Character to static space");
1141 }
1142
1143 }
1144
1145 lock (_activeprims)
1146 {
1147 foreach (OdePrim aprim in _activeprims)
1148 {
1149 aprim.CollisionScore = 0;
1150 aprim.IsColliding = false;
1151 }
1152 }
1153
1154 // collide active prims with static enviroment
1155 lock (_activegroups)
1156 {
1157 try
1158 {
1159 foreach (OdePrim prm in _activegroups)
1160 {
1161 if (d.BodyIsEnabled(prm.Body) && !prm.m_outbounds)
1162 d.SpaceCollide2(StaticSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
1163 }
1164 }
1165 catch (AccessViolationException)
1166 {
1167 m_log.Warn("[PHYSICS]: Unable to collide Active prim to static space");
1168 }
1169 }
1170 // finally colide active things amoung them
1171 try
1172 {
1173 d.SpaceCollide(ActiveSpace, IntPtr.Zero, nearCallback);
1174 }
1175 catch (AccessViolationException)
1176 {
1177 m_log.Warn("[PHYSICS]: Unable to collide in Active space");
1178 }
1179// _perloopContact.Clear();
1180 }
1181
1182 #endregion
1183
1184
1185
1186 /// <summary>
1187 /// Add actor to the list that should receive collision events in the simulate loop.
1188 /// </summary>
1189 /// <param name="obj"></param>
1190 public void AddCollisionEventReporting(PhysicsActor obj)
1191 {
1192 lock (_collisionEventPrim)
1193 {
1194 if (!_collisionEventPrim.Contains(obj))
1195 _collisionEventPrim.Add(obj);
1196 }
1197 }
1198
1199 /// <summary>
1200 /// Remove actor from the list that should receive collision events in the simulate loop.
1201 /// </summary>
1202 /// <param name="obj"></param>
1203 public void RemoveCollisionEventReporting(PhysicsActor obj)
1204 {
1205 lock (_collisionEventPrim)
1206 {
1207 if (_collisionEventPrim.Contains(obj))
1208 _collisionEventPrim.Remove(obj);
1209 }
1210 }
1211
1212 #region Add/Remove Entities
1213
1214 public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
1215 {
1216 Vector3 pos;
1217 pos.X = position.X;
1218 pos.Y = position.Y;
1219 pos.Z = position.Z;
1220 OdeCharacter newAv = new OdeCharacter(avName, this, pos, size, avPIDD, avPIDP, avCapRadius, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
1221 newAv.Flying = isFlying;
1222 newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
1223
1224 return newAv;
1225 }
1226
1227 public void AddCharacter(OdeCharacter chr)
1228 {
1229 lock (_characters)
1230 {
1231 if (!_characters.Contains(chr))
1232 {
1233 _characters.Add(chr);
1234 if (chr.bad)
1235 m_log.DebugFormat("[PHYSICS] Added BAD actor {0} to characters list", chr.m_uuid);
1236 }
1237 }
1238 }
1239
1240 public void RemoveCharacter(OdeCharacter chr)
1241 {
1242 lock (_characters)
1243 {
1244 if (_characters.Contains(chr))
1245 {
1246 _characters.Remove(chr);
1247 }
1248 }
1249 }
1250
1251 public void BadCharacter(OdeCharacter chr)
1252 {
1253 lock (_badCharacter)
1254 {
1255 if (!_badCharacter.Contains(chr))
1256 _badCharacter.Add(chr);
1257 }
1258 }
1259
1260 public override void RemoveAvatar(PhysicsActor actor)
1261 {
1262 //m_log.Debug("[PHYSICS]:ODELOCK");
1263 ((OdeCharacter) actor).Destroy();
1264 }
1265
1266 private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
1267 PrimitiveBaseShape pbs, bool isphysical, uint localID)
1268 {
1269 Vector3 pos = position;
1270 Vector3 siz = size;
1271 Quaternion rot = rotation;
1272
1273 OdePrim newPrim;
1274 lock (OdeLock)
1275 {
1276 newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical,false,0,localID);
1277
1278 lock (_prims)
1279 _prims.Add(newPrim);
1280 }
1281 return newPrim;
1282 }
1283
1284 private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
1285 PrimitiveBaseShape pbs, bool isphysical, bool isPhantom, uint localID)
1286 {
1287 Vector3 pos = position;
1288 Vector3 siz = size;
1289 Quaternion rot = rotation;
1290
1291 OdePrim newPrim;
1292 lock (OdeLock)
1293 {
1294 newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical, isPhantom, 0, localID);
1295
1296 lock (_prims)
1297 _prims.Add(newPrim);
1298 }
1299 return newPrim;
1300 }
1301
1302 private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
1303 PrimitiveBaseShape pbs, bool isphysical, bool isPhantom, byte shapeType, uint localID)
1304 {
1305 Vector3 pos = position;
1306 Vector3 siz = size;
1307 Quaternion rot = rotation;
1308
1309 OdePrim newPrim;
1310 lock (OdeLock)
1311 {
1312 newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical, isPhantom, shapeType, localID);
1313
1314 lock (_prims)
1315 _prims.Add(newPrim);
1316 }
1317 return newPrim;
1318 }
1319
1320 public void addActivePrim(OdePrim activatePrim)
1321 {
1322 // adds active prim..
1323 lock (_activeprims)
1324 {
1325 if (!_activeprims.Contains(activatePrim))
1326 _activeprims.Add(activatePrim);
1327 }
1328 }
1329
1330 public void addActiveGroups(OdePrim activatePrim)
1331 {
1332 lock (_activegroups)
1333 {
1334 if (!_activegroups.Contains(activatePrim))
1335 _activegroups.Add(activatePrim);
1336 }
1337 }
1338
1339 public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
1340 Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, uint localid)
1341 {
1342 return AddPrim(primName, position, size, rotation, pbs, isPhysical, isPhantom, localid);
1343 }
1344
1345
1346 public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
1347 Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
1348 {
1349#if SPAM
1350 m_log.DebugFormat("[PHYSICS]: Adding physics actor to {0}", primName);
1351#endif
1352
1353 return AddPrim(primName, position, size, rotation, pbs, isPhysical, localid);
1354 }
1355
1356 public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
1357 Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, byte shapeType, uint localid)
1358 {
1359#if SPAM
1360 m_log.DebugFormat("[PHYSICS]: Adding physics actor to {0}", primName);
1361#endif
1362
1363 return AddPrim(primName, position, size, rotation, pbs, isPhysical,isPhantom, shapeType, localid);
1364 }
1365
1366 public override float TimeDilation
1367 {
1368 get { return m_timeDilation; }
1369 }
1370
1371 public override bool SupportsNINJAJoints
1372 {
1373 get { return false; }
1374 }
1375
1376
1377 public void remActivePrim(OdePrim deactivatePrim)
1378 {
1379 lock (_activeprims)
1380 {
1381 _activeprims.Remove(deactivatePrim);
1382 }
1383 }
1384 public void remActiveGroup(OdePrim deactivatePrim)
1385 {
1386 lock (_activegroups)
1387 {
1388 _activegroups.Remove(deactivatePrim);
1389 }
1390 }
1391
1392 public override void RemovePrim(PhysicsActor prim)
1393 {
1394 // As with all ODE physics operations, we don't remove the prim immediately but signal that it should be
1395 // removed in the next physics simulate pass.
1396 if (prim is OdePrim)
1397 {
1398// lock (OdeLock)
1399 {
1400 OdePrim p = (OdePrim)prim;
1401 p.setPrimForRemoval();
1402 }
1403 }
1404 }
1405 /// <summary>
1406 /// This is called from within simulate but outside the locked portion
1407 /// We need to do our own locking here
1408 /// (Note: As of 20110801 this no longer appears to be true - this is being called within lock (odeLock) in
1409 /// Simulate() -- justincc).
1410 ///
1411 /// Essentially, we need to remove the prim from our space segment, whatever segment it's in.
1412 ///
1413 /// If there are no more prim in the segment, we need to empty (spacedestroy)the segment and reclaim memory
1414 /// that the space was using.
1415 /// </summary>
1416 /// <param name="prim"></param>
1417 public void RemovePrimThreadLocked(OdePrim prim)
1418 {
1419 //Console.WriteLine("RemovePrimThreadLocked " + prim.m_primName);
1420 lock (prim)
1421 {
1422 RemoveCollisionEventReporting(prim);
1423 lock (_prims)
1424 _prims.Remove(prim);
1425 }
1426
1427 }
1428 #endregion
1429
1430 #region Space Separation Calculation
1431
1432 /// <summary>
1433 /// Called when a static prim moves or becomes static
1434 /// Places the prim in a space one the static sub-spaces grid
1435 /// </summary>
1436 /// <param name="geom">the pointer to the geom that moved</param>
1437 /// <param name="pos">the position that the geom moved to</param>
1438 /// <param name="currentspace">a pointer to the space it was in before it was moved.</param>
1439 /// <returns>a pointer to the new space it's in</returns>
1440 public IntPtr MoveGeomToStaticSpace(IntPtr geom, Vector3 pos, IntPtr currentspace)
1441 {
1442 // moves a prim into another static sub-space or from another space into a static sub-space
1443
1444 // Called ODEPrim so
1445 // it's already in locked space.
1446
1447 if (geom == IntPtr.Zero) // shouldn't happen
1448 return IntPtr.Zero;
1449
1450 // get the static sub-space for current position
1451 IntPtr newspace = calculateSpaceForGeom(pos);
1452
1453 if (newspace == currentspace) // if we are there all done
1454 return newspace;
1455
1456 // else remove it from its current space
1457 if (currentspace != IntPtr.Zero && d.SpaceQuery(currentspace, geom))
1458 {
1459 if (d.GeomIsSpace(currentspace))
1460 {
1461 waitForSpaceUnlock(currentspace);
1462 d.SpaceRemove(currentspace, geom);
1463
1464 if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
1465 {
1466 d.SpaceDestroy(currentspace);
1467 }
1468 }
1469 else
1470 {
1471 m_log.Info("[Physics]: Invalid or empty Space passed to 'MoveGeomToStaticSpace':" + currentspace +
1472 " Geom:" + geom);
1473 }
1474 }
1475 else // odd currentspace is null or doesn't contain the geom? lets try the geom ideia of current space
1476 {
1477 currentspace = d.GeomGetSpace(geom);
1478 if (currentspace != IntPtr.Zero)
1479 {
1480 if (d.GeomIsSpace(currentspace))
1481 {
1482 waitForSpaceUnlock(currentspace);
1483 d.SpaceRemove(currentspace, geom);
1484
1485 if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
1486 {
1487 d.SpaceDestroy(currentspace);
1488 }
1489
1490 }
1491 }
1492 }
1493
1494 // put the geom in the newspace
1495 waitForSpaceUnlock(newspace);
1496 d.SpaceAdd(newspace, geom);
1497
1498 // let caller know this newspace
1499 return newspace;
1500 }
1501
1502 /// <summary>
1503 /// Calculates the space the prim should be in by its position
1504 /// </summary>
1505 /// <param name="pos"></param>
1506 /// <returns>a pointer to the space. This could be a new space or reused space.</returns>
1507 public IntPtr calculateSpaceForGeom(Vector3 pos)
1508 {
1509 int x, y;
1510 x = (int)(pos.X * spacesPerMeter);
1511 if (x < 0)
1512 x = 0;
1513 else if (x > spaceGridMaxX)
1514 x = spaceGridMaxX;
1515
1516 y = (int)(pos.Y * spacesPerMeter);
1517 if (y < 0)
1518 y = 0;
1519 else if (y >spaceGridMaxY)
1520 y = spaceGridMaxY;
1521
1522 IntPtr tmpSpace = staticPrimspace[x, y];
1523 return tmpSpace;
1524 }
1525
1526 #endregion
1527
1528 /// <summary>
1529 /// Routine to figure out if we need to mesh this prim with our mesher
1530 /// </summary>
1531 /// <param name="pbs"></param>
1532 /// <returns></returns>
1533 public bool needsMeshing(PrimitiveBaseShape pbs)
1534 {
1535 // most of this is redundant now as the mesher will return null if it cant mesh a prim
1536 // but we still need to check for sculptie meshing being enabled so this is the most
1537 // convenient place to do it for now...
1538
1539 // //if (pbs.PathCurve == (byte)Primitive.PathCurve.Circle && pbs.ProfileCurve == (byte)Primitive.ProfileCurve.Circle && pbs.PathScaleY <= 0.75f)
1540 // //m_log.Debug("needsMeshing: " + " pathCurve: " + pbs.PathCurve.ToString() + " profileCurve: " + pbs.ProfileCurve.ToString() + " pathScaleY: " + Primitive.UnpackPathScale(pbs.PathScaleY).ToString());
1541 int iPropertiesNotSupportedDefault = 0;
1542
1543 if (pbs.SculptEntry)
1544 {
1545 if(!meshSculptedPrim)
1546 return false;
1547 }
1548
1549 // 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
1550 if (!forceSimplePrimMeshing && !pbs.SculptEntry)
1551 {
1552 if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
1553 || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
1554 && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
1555 {
1556
1557 if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
1558 && pbs.ProfileHollow == 0
1559 && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
1560 && pbs.PathBegin == 0 && pbs.PathEnd == 0
1561 && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
1562 && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
1563 && pbs.PathShearX == 0 && pbs.PathShearY == 0)
1564 {
1565#if SPAM
1566 m_log.Warn("NonMesh");
1567#endif
1568 return false;
1569 }
1570 }
1571 }
1572
1573 // following code doesn't give meshs to boxes and spheres ever
1574 // and it's odd.. so for now just return true if asked to force meshs
1575 // hopefully mesher will fail if doesn't suport so things still get basic boxes
1576
1577 if (forceSimplePrimMeshing)
1578 return true;
1579
1580 if (pbs.ProfileHollow != 0)
1581 iPropertiesNotSupportedDefault++;
1582
1583 if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
1584 iPropertiesNotSupportedDefault++;
1585
1586 if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
1587 iPropertiesNotSupportedDefault++;
1588
1589 if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
1590 iPropertiesNotSupportedDefault++;
1591
1592 if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
1593 iPropertiesNotSupportedDefault++;
1594
1595 if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
1596 iPropertiesNotSupportedDefault++;
1597
1598 if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
1599 iPropertiesNotSupportedDefault++;
1600
1601 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))
1602 iPropertiesNotSupportedDefault++;
1603
1604 if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1)
1605 iPropertiesNotSupportedDefault++;
1606
1607 // test for torus
1608 if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
1609 {
1610 if (pbs.PathCurve == (byte)Extrusion.Curve1)
1611 {
1612 iPropertiesNotSupportedDefault++;
1613 }
1614 }
1615 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
1616 {
1617 if (pbs.PathCurve == (byte)Extrusion.Straight)
1618 {
1619 iPropertiesNotSupportedDefault++;
1620 }
1621
1622 // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
1623 else if (pbs.PathCurve == (byte)Extrusion.Curve1)
1624 {
1625 iPropertiesNotSupportedDefault++;
1626 }
1627 }
1628 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
1629 {
1630 if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
1631 {
1632 iPropertiesNotSupportedDefault++;
1633 }
1634 }
1635 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
1636 {
1637 if (pbs.PathCurve == (byte)Extrusion.Straight)
1638 {
1639 iPropertiesNotSupportedDefault++;
1640 }
1641 else if (pbs.PathCurve == (byte)Extrusion.Curve1)
1642 {
1643 iPropertiesNotSupportedDefault++;
1644 }
1645 }
1646
1647 if (pbs.SculptEntry && meshSculptedPrim)
1648 iPropertiesNotSupportedDefault++;
1649
1650 if (iPropertiesNotSupportedDefault == 0)
1651 {
1652#if SPAM
1653 m_log.Warn("NonMesh");
1654#endif
1655 return false;
1656 }
1657#if SPAM
1658 m_log.Debug("Mesh");
1659#endif
1660 return true;
1661 }
1662
1663 /// <summary>
1664 /// Called to queue a change to a actor
1665 /// to use in place of old taint mechanism so changes do have a time sequence
1666 /// </summary>
1667
1668 public void AddChange(PhysicsActor actor, changes what, Object arg)
1669 {
1670 ODEchangeitem item = new ODEchangeitem();
1671 item.actor = actor;
1672 item.what = what;
1673 item.arg = arg;
1674 ChangesQueue.Enqueue(item);
1675 }
1676
1677 /// <summary>
1678 /// Called after our prim properties are set Scale, position etc.
1679 /// We use this event queue like method to keep changes to the physical scene occuring in the threadlocked mutex
1680 /// This assures us that we have no race conditions
1681 /// </summary>
1682 /// <param name="prim"></param>
1683 public override void AddPhysicsActorTaint(PhysicsActor prim)
1684 {
1685 }
1686
1687 /// <summary>
1688 /// This is our main simulate loop
1689 /// It's thread locked by a Mutex in the scene.
1690 /// It holds Collisions, it instructs ODE to step through the physical reactions
1691 /// It moves the objects around in memory
1692 /// It calls the methods that report back to the object owners.. (scenepresence, SceneObjectGroup)
1693 /// </summary>
1694 /// <param name="timeStep"></param>
1695 /// <returns></returns>
1696 public override float Simulate(float timeStep)
1697 {
1698
1699 DateTime now = DateTime.UtcNow;
1700 TimeSpan SinceLastFrame = now - m_lastframe;
1701 m_lastframe = now;
1702 timeStep = (float)SinceLastFrame.TotalSeconds;
1703
1704 // acumulate time so we can reduce error
1705 step_time += timeStep;
1706
1707 if (step_time < HalfOdeStep)
1708 return 0;
1709
1710 if (framecount < 0)
1711 framecount = 0;
1712
1713 framecount++;
1714
1715 int curphysiteractions;
1716
1717 // if in trouble reduce step resolution
1718 if (step_time >= m_SkipFramesAtms)
1719 curphysiteractions = m_physicsiterations / 2;
1720 else
1721 curphysiteractions = m_physicsiterations;
1722
1723 int nodeframes = 0;
1724
1725// checkThread();
1726
1727 lock (SimulationLock)
1728 {
1729 // adjust number of iterations per step
1730 try
1731 {
1732 d.WorldSetQuickStepNumIterations(world, curphysiteractions);
1733 }
1734 catch (StackOverflowException)
1735 {
1736 m_log.Error("[PHYSICS]: The operating system wasn't able to allocate enough memory for the simulation. Restarting the sim.");
1737// ode.drelease(world);
1738 base.TriggerPhysicsBasedRestart();
1739 }
1740
1741 while (step_time > HalfOdeStep && nodeframes < 10) //limit number of steps so we don't say here for ever
1742 {
1743 try
1744 {
1745 // clear pointer/counter to contacts to pass into joints
1746 m_global_contactcount = 0;
1747
1748 ODEchangeitem item;
1749
1750 if(ChangesQueue.Count >0)
1751 {
1752 int ttmpstart = Util.EnvironmentTickCount();
1753 int ttmp;
1754 int ttmp2;
1755
1756 while(ChangesQueue.Dequeue(out item))
1757 {
1758 if (item.actor != null)
1759 {
1760 try
1761 {
1762 if (item.actor is OdeCharacter)
1763 ((OdeCharacter)item.actor).DoAChange(item.what, item.arg);
1764 else if (((OdePrim)item.actor).DoAChange(item.what, item.arg))
1765 RemovePrimThreadLocked((OdePrim)item.actor);
1766 }
1767 catch
1768 {
1769 m_log.Warn("[PHYSICS]: doChange failed for a actor");
1770 };
1771 }
1772 ttmp = Util.EnvironmentTickCountSubtract(ttmpstart);
1773 if (ttmp > 20)
1774 break;
1775 }
1776
1777 ttmp2 = Util.EnvironmentTickCountSubtract(ttmpstart);
1778 if (ttmp2 > 50)
1779 ttmp2 = 0;
1780
1781 }
1782
1783 // Move characters
1784 lock (_characters)
1785 {
1786 List<OdeCharacter> defects = new List<OdeCharacter>();
1787 foreach (OdeCharacter actor in _characters)
1788 {
1789 if (actor != null)
1790 actor.Move(ODE_STEPSIZE, defects);
1791 }
1792 if (defects.Count != 0)
1793 {
1794 foreach (OdeCharacter defect in defects)
1795 {
1796 RemoveCharacter(defect);
1797 }
1798 }
1799 }
1800
1801 // Move other active objects
1802 lock (_activegroups)
1803 {
1804 foreach (OdePrim aprim in _activegroups)
1805 {
1806 aprim.Move();
1807 }
1808 }
1809
1810 //if ((framecount % m_randomizeWater) == 0)
1811 // randomizeWater(waterlevel);
1812
1813 m_rayCastManager.ProcessQueuedRequests();
1814
1815 collision_optimized();
1816
1817 lock (_collisionEventPrim)
1818 {
1819 foreach (PhysicsActor obj in _collisionEventPrim)
1820 {
1821 if (obj == null)
1822 continue;
1823
1824 switch ((ActorTypes)obj.PhysicsActorType)
1825 {
1826 case ActorTypes.Agent:
1827 OdeCharacter cobj = (OdeCharacter)obj;
1828 cobj.AddCollisionFrameTime((int)(ODE_STEPSIZE*1000.0f));
1829 cobj.SendCollisions();
1830 break;
1831
1832 case ActorTypes.Prim:
1833 OdePrim pobj = (OdePrim)obj;
1834 pobj.SendCollisions();
1835 break;
1836 }
1837 }
1838 }
1839
1840 // do a ode simulation step
1841 d.WorldQuickStep(world, ODE_STEPSIZE);
1842 d.JointGroupEmpty(contactgroup);
1843
1844 // update managed ideia of physical data and do updates to core
1845 /*
1846 lock (_characters)
1847 {
1848 foreach (OdeCharacter actor in _characters)
1849 {
1850 if (actor != null)
1851 {
1852 if (actor.bad)
1853 m_log.WarnFormat("[PHYSICS]: BAD Actor {0} in _characters list was not removed?", actor.m_uuid);
1854
1855 actor.UpdatePositionAndVelocity();
1856 }
1857 }
1858 }
1859 */
1860
1861 lock (_activegroups)
1862 {
1863 {
1864 foreach (OdePrim actor in _activegroups)
1865 {
1866 if (actor.IsPhysical)
1867 {
1868 actor.UpdatePositionAndVelocity();
1869 }
1870 }
1871 }
1872 }
1873 }
1874 catch (Exception e)
1875 {
1876 m_log.ErrorFormat("[PHYSICS]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
1877// ode.dunlock(world);
1878 }
1879
1880
1881 step_time -= ODE_STEPSIZE;
1882 nodeframes++;
1883 }
1884
1885 lock (_badCharacter)
1886 {
1887 if (_badCharacter.Count > 0)
1888 {
1889 foreach (OdeCharacter chr in _badCharacter)
1890 {
1891 RemoveCharacter(chr);
1892 }
1893
1894 _badCharacter.Clear();
1895 }
1896 }
1897
1898 int nactivegeoms = d.SpaceGetNumGeoms(ActiveSpace);
1899 int nstaticgeoms = d.SpaceGetNumGeoms(StaticSpace);
1900 int ntopgeoms = d.SpaceGetNumGeoms(TopSpace);
1901 int nbodies = d.NTotalBodies;
1902 int ngeoms = d.NTotalGeoms;
1903
1904 // Finished with all sim stepping. If requested, dump world state to file for debugging.
1905 // TODO: This call to the export function is already inside lock (OdeLock) - but is an extra lock needed?
1906 // TODO: This overwrites all dump files in-place. Should this be a growing logfile, or separate snapshots?
1907 if (physics_logging && (physics_logging_interval > 0) && (framecount % physics_logging_interval == 0))
1908 {
1909 string fname = "state-" + world.ToString() + ".DIF"; // give each physics world a separate filename
1910 string prefix = "world" + world.ToString(); // prefix for variable names in exported .DIF file
1911
1912 if (physics_logging_append_existing_logfile)
1913 {
1914 string header = "-------------- START OF PHYSICS FRAME " + framecount.ToString() + " --------------";
1915 TextWriter fwriter = File.AppendText(fname);
1916 fwriter.WriteLine(header);
1917 fwriter.Close();
1918 }
1919
1920 d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
1921 }
1922
1923 // think time dilation as to do with dinamic step size that we dont' have
1924 // even so tell something to world
1925 if (nodeframes < 10) // we did the requested loops
1926 m_timeDilation = 1.0f;
1927 else if (step_time > 0)
1928 {
1929 m_timeDilation = timeStep / step_time;
1930 if (m_timeDilation > 1)
1931 m_timeDilation = 1;
1932 if (step_time > m_SkipFramesAtms)
1933 step_time = 0;
1934 }
1935 }
1936
1937// return nodeframes * ODE_STEPSIZE; // return real simulated time
1938 return 1000 * nodeframes; // return steps for now * 1000 to keep core happy
1939 }
1940
1941 /// <summary>
1942 public override void GetResults()
1943 {
1944 }
1945
1946 public override bool IsThreaded
1947 {
1948 // for now we won't be multithreaded
1949 get { return (false); }
1950 }
1951
1952 public float GetTerrainHeightAtXY(float x, float y)
1953 {
1954
1955
1956 int offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
1957 int offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
1958
1959
1960 IntPtr heightFieldGeom = IntPtr.Zero;
1961
1962 // get region map
1963 if (!RegionTerrain.TryGetValue(new Vector3(offsetX, offsetY, 0), out heightFieldGeom))
1964 return 0f;
1965
1966 if (heightFieldGeom == IntPtr.Zero)
1967 return 0f;
1968
1969 if (!TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
1970 return 0f;
1971
1972 // TerrainHeightField for ODE as offset 1m
1973 x += 1f - offsetX;
1974 y += 1f - offsetY;
1975
1976 // make position fit into array
1977 if (x < 0)
1978 x = 0;
1979 if (y < 0)
1980 y = 0;
1981
1982 // integer indexs
1983 int ix;
1984 int iy;
1985 // interpolators offset
1986 float dx;
1987 float dy;
1988
1989 int regsize = (int)Constants.RegionSize + 3; // map size see setterrain number of samples
1990
1991 if (OdeUbitLib)
1992 {
1993 if (x < regsize - 1)
1994 {
1995 ix = (int)x;
1996 dx = x - (float)ix;
1997 }
1998 else // out world use external height
1999 {
2000 ix = regsize - 2;
2001 dx = 0;
2002 }
2003 if (y < regsize - 1)
2004 {
2005 iy = (int)y;
2006 dy = y - (float)iy;
2007 }
2008 else
2009 {
2010 iy = regsize - 2;
2011 dy = 0;
2012 }
2013 }
2014
2015 else
2016 {
2017 // we still have square fixed size regions
2018 // also flip x and y because of how map is done for ODE fliped axis
2019 // so ix,iy,dx and dy are inter exchanged
2020 if (x < regsize - 1)
2021 {
2022 iy = (int)x;
2023 dy = x - (float)iy;
2024 }
2025 else // out world use external height
2026 {
2027 iy = regsize - 2;
2028 dy = 0;
2029 }
2030 if (y < regsize - 1)
2031 {
2032 ix = (int)y;
2033 dx = y - (float)ix;
2034 }
2035 else
2036 {
2037 ix = regsize - 2;
2038 dx = 0;
2039 }
2040 }
2041
2042 float h0;
2043 float h1;
2044 float h2;
2045
2046 iy *= regsize;
2047 iy += ix; // all indexes have iy + ix
2048
2049 float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
2050 /*
2051 if ((dx + dy) <= 1.0f)
2052 {
2053 h0 = ((float)heights[iy]); // 0,0 vertice
2054 h1 = (((float)heights[iy + 1]) - h0) * dx; // 1,0 vertice minus 0,0
2055 h2 = (((float)heights[iy + regsize]) - h0) * dy; // 0,1 vertice minus 0,0
2056 }
2057 else
2058 {
2059 h0 = ((float)heights[iy + regsize + 1]); // 1,1 vertice
2060 h1 = (((float)heights[iy + 1]) - h0) * (1 - dy); // 1,1 vertice minus 1,0
2061 h2 = (((float)heights[iy + regsize]) - h0) * (1 - dx); // 1,1 vertice minus 0,1
2062 }
2063 */
2064 h0 = ((float)heights[iy]); // 0,0 vertice
2065
2066 if ((dy > dx))
2067 {
2068 iy += regsize;
2069 h2 = (float)heights[iy]; // 0,1 vertice
2070 h1 = (h2 - h0) * dy; // 0,1 vertice minus 0,0
2071 h2 = ((float)heights[iy + 1] - h2) * dx; // 1,1 vertice minus 0,1
2072 }
2073 else
2074 {
2075 iy++;
2076 h2 = (float)heights[iy]; // vertice 1,0
2077 h1 = (h2 - h0) * dx; // 1,0 vertice minus 0,0
2078 h2 = (((float)heights[iy + regsize]) - h2) * dy; // 1,1 vertice minus 1,0
2079 }
2080
2081 return h0 + h1 + h2;
2082 }
2083
2084
2085 public override void SetTerrain(float[] heightMap)
2086 {
2087 if (m_worldOffset != Vector3.Zero && m_parentScene != null)
2088 {
2089 if (m_parentScene is OdeScene)
2090 {
2091 ((OdeScene)m_parentScene).SetTerrain(heightMap, m_worldOffset);
2092 }
2093 }
2094 else
2095 {
2096 SetTerrain(heightMap, m_worldOffset);
2097 }
2098 }
2099
2100 public override void CombineTerrain(float[] heightMap, Vector3 pOffset)
2101 {
2102 SetTerrain(heightMap, pOffset);
2103 }
2104
2105 public void SetTerrain(float[] heightMap, Vector3 pOffset)
2106 {
2107 if (OdeUbitLib)
2108 UbitSetTerrain(heightMap, pOffset);
2109 else
2110 OriSetTerrain(heightMap, pOffset);
2111 }
2112
2113 public void OriSetTerrain(float[] heightMap, Vector3 pOffset)
2114 {
2115 // assumes 1m size grid and constante size square regions
2116 // needs to know about sims around in future
2117
2118 float[] _heightmap;
2119
2120 uint heightmapWidth = Constants.RegionSize + 2;
2121 uint heightmapHeight = Constants.RegionSize + 2;
2122
2123 uint heightmapWidthSamples = heightmapWidth + 1;
2124 uint heightmapHeightSamples = heightmapHeight + 1;
2125
2126 _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
2127
2128 const float scale = 1.0f;
2129 const float offset = 0.0f;
2130 const float thickness = 10f;
2131 const int wrap = 0;
2132
2133 uint regionsize = Constants.RegionSize;
2134
2135 float hfmin = float.MaxValue;
2136 float hfmax = float.MinValue;
2137 float val;
2138 uint xx;
2139 uint yy;
2140
2141 uint maxXXYY = regionsize - 1;
2142 // flipping map adding one margin all around so things don't fall in edges
2143
2144 uint xt = 0;
2145 xx = 0;
2146
2147 for (uint x = 0; x < heightmapWidthSamples; x++)
2148 {
2149 if (x > 1 && xx < maxXXYY)
2150 xx++;
2151 yy = 0;
2152 for (uint y = 0; y < heightmapHeightSamples; y++)
2153 {
2154 if (y > 1 && y < maxXXYY)
2155 yy += regionsize;
2156
2157 val = heightMap[yy + xx];
2158 if (val < 0.0f)
2159 val = 0.0f; // no neg terrain as in chode
2160 _heightmap[xt + y] = val;
2161
2162 if (hfmin > val)
2163 hfmin = val;
2164 if (hfmax < val)
2165 hfmax = val;
2166 }
2167 xt += heightmapHeightSamples;
2168 }
2169 lock (OdeLock)
2170 {
2171 IntPtr GroundGeom = IntPtr.Zero;
2172 if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
2173 {
2174 RegionTerrain.Remove(pOffset);
2175 if (GroundGeom != IntPtr.Zero)
2176 {
2177 d.GeomDestroy(GroundGeom);
2178
2179 if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
2180 {
2181 TerrainHeightFieldHeightsHandlers[GroundGeom].Free();
2182 TerrainHeightFieldHeightsHandlers.Remove(GroundGeom);
2183 TerrainHeightFieldHeights.Remove(GroundGeom);
2184 }
2185 }
2186 }
2187 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
2188
2189 GCHandle _heightmaphandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
2190
2191 d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmaphandler.AddrOfPinnedObject(), 0, heightmapWidth , heightmapHeight,
2192 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
2193 offset, thickness, wrap);
2194
2195 d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
2196 GroundGeom = d.CreateHeightfield(StaticSpace, HeightmapData, 1);
2197 if (GroundGeom != IntPtr.Zero)
2198 {
2199 d.GeomSetCategoryBits(GroundGeom, (uint)(CollisionCategories.Land));
2200 d.GeomSetCollideBits(GroundGeom, 0);
2201
2202 }
2203 geom_name_map[GroundGeom] = "Terrain";
2204
2205 d.Matrix3 R = new d.Matrix3();
2206
2207 Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
2208 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
2209
2210
2211 q1 = q1 * q2;
2212
2213 Vector3 v3;
2214 float angle;
2215 q1.GetAxisAngle(out v3, out angle);
2216
2217 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
2218 d.GeomSetRotation(GroundGeom, ref R);
2219 d.GeomSetPosition(GroundGeom, pOffset.X + (float)Constants.RegionSize * 0.5f, pOffset.Y + (float)Constants.RegionSize * 0.5f, 0);
2220 RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
2221// TerrainHeightFieldHeights.Add(GroundGeom, ODElandMap);
2222 TerrainHeightFieldHeights.Add(GroundGeom, _heightmap);
2223 TerrainHeightFieldHeightsHandlers.Add(GroundGeom, _heightmaphandler);
2224
2225 }
2226 }
2227
2228 public void UbitSetTerrain(float[] heightMap, Vector3 pOffset)
2229 {
2230 // assumes 1m size grid and constante size square regions
2231 // needs to know about sims around in future
2232
2233 float[] _heightmap;
2234
2235 uint heightmapWidth = Constants.RegionSize + 2;
2236 uint heightmapHeight = Constants.RegionSize + 2;
2237
2238 uint heightmapWidthSamples = heightmapWidth + 1;
2239 uint heightmapHeightSamples = heightmapHeight + 1;
2240
2241 _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
2242
2243
2244 uint regionsize = Constants.RegionSize;
2245
2246 float hfmin = float.MaxValue;
2247// float hfmax = float.MinValue;
2248 float val;
2249
2250
2251 uint maxXXYY = regionsize - 1;
2252 // adding one margin all around so things don't fall in edges
2253
2254 uint xx;
2255 uint yy = 0;
2256 uint yt = 0;
2257
2258 for (uint y = 0; y < heightmapHeightSamples; y++)
2259 {
2260 if (y > 1 && y < maxXXYY)
2261 yy += regionsize;
2262 xx = 0;
2263 for (uint x = 0; x < heightmapWidthSamples; x++)
2264 {
2265 if (x > 1 && x < maxXXYY)
2266 xx++;
2267
2268 val = heightMap[yy + xx];
2269 if (val < 0.0f)
2270 val = 0.0f; // no neg terrain as in chode
2271 _heightmap[yt + x] = val;
2272
2273 if (hfmin > val)
2274 hfmin = val;
2275// if (hfmax < val)
2276// hfmax = val;
2277 }
2278 yt += heightmapWidthSamples;
2279 }
2280 lock (OdeLock)
2281 {
2282 IntPtr GroundGeom = IntPtr.Zero;
2283 if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
2284 {
2285 RegionTerrain.Remove(pOffset);
2286 if (GroundGeom != IntPtr.Zero)
2287 {
2288 d.GeomDestroy(GroundGeom);
2289
2290 if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
2291 {
2292 if (TerrainHeightFieldHeightsHandlers[GroundGeom].IsAllocated)
2293 TerrainHeightFieldHeightsHandlers[GroundGeom].Free();
2294 TerrainHeightFieldHeightsHandlers.Remove(GroundGeom);
2295 TerrainHeightFieldHeights.Remove(GroundGeom);
2296 }
2297 }
2298 }
2299 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
2300
2301 const int wrap = 0;
2302 float thickness = hfmin;
2303 if (thickness < 0)
2304 thickness = 1;
2305
2306 GCHandle _heightmaphandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
2307
2308 d.GeomUbitTerrainDataBuild(HeightmapData, _heightmaphandler.AddrOfPinnedObject(), 0, 1.0f,
2309 (int)heightmapWidthSamples, (int)heightmapHeightSamples,
2310 thickness, wrap);
2311
2312// d.GeomUbitTerrainDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
2313 GroundGeom = d.CreateUbitTerrain(StaticSpace, HeightmapData, 1);
2314 if (GroundGeom != IntPtr.Zero)
2315 {
2316 d.GeomSetCategoryBits(GroundGeom, (uint)(CollisionCategories.Land));
2317 d.GeomSetCollideBits(GroundGeom, 0);
2318
2319 }
2320 geom_name_map[GroundGeom] = "Terrain";
2321
2322 d.GeomSetPosition(GroundGeom, pOffset.X + (float)Constants.RegionSize * 0.5f, pOffset.Y + (float)Constants.RegionSize * 0.5f, 0);
2323 RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
2324 // TerrainHeightFieldHeights.Add(GroundGeom, ODElandMap);
2325 TerrainHeightFieldHeights.Add(GroundGeom, _heightmap);
2326 TerrainHeightFieldHeightsHandlers.Add(GroundGeom, _heightmaphandler);
2327 }
2328 }
2329
2330
2331 public override void DeleteTerrain()
2332 {
2333 }
2334
2335 public float GetWaterLevel()
2336 {
2337 return waterlevel;
2338 }
2339
2340 public override bool SupportsCombining()
2341 {
2342 return true;
2343 }
2344/*
2345 public override void UnCombine(PhysicsScene pScene)
2346 {
2347 IntPtr localGround = IntPtr.Zero;
2348// float[] localHeightfield;
2349 bool proceed = false;
2350 List<IntPtr> geomDestroyList = new List<IntPtr>();
2351
2352 lock (OdeLock)
2353 {
2354 if (RegionTerrain.TryGetValue(Vector3.Zero, out localGround))
2355 {
2356 foreach (IntPtr geom in TerrainHeightFieldHeights.Keys)
2357 {
2358 if (geom == localGround)
2359 {
2360// localHeightfield = TerrainHeightFieldHeights[geom];
2361 proceed = true;
2362 }
2363 else
2364 {
2365 geomDestroyList.Add(geom);
2366 }
2367 }
2368
2369 if (proceed)
2370 {
2371 m_worldOffset = Vector3.Zero;
2372 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
2373 m_parentScene = null;
2374
2375 foreach (IntPtr g in geomDestroyList)
2376 {
2377 // removingHeightField needs to be done or the garbage collector will
2378 // collect the terrain data before we tell ODE to destroy it causing
2379 // memory corruption
2380 if (TerrainHeightFieldHeights.ContainsKey(g))
2381 {
2382// float[] removingHeightField = TerrainHeightFieldHeights[g];
2383 TerrainHeightFieldHeights.Remove(g);
2384
2385 if (RegionTerrain.ContainsKey(g))
2386 {
2387 RegionTerrain.Remove(g);
2388 }
2389
2390 d.GeomDestroy(g);
2391 //removingHeightField = new float[0];
2392 }
2393 }
2394
2395 }
2396 else
2397 {
2398 m_log.Warn("[PHYSICS]: Couldn't proceed with UnCombine. Region has inconsistant data.");
2399 }
2400 }
2401 }
2402 }
2403*/
2404 public override void SetWaterLevel(float baseheight)
2405 {
2406 waterlevel = baseheight;
2407 randomizeWater(waterlevel);
2408 }
2409
2410 public void randomizeWater(float baseheight)
2411 {
2412 const uint heightmapWidth = Constants.RegionSize + 2;
2413 const uint heightmapHeight = Constants.RegionSize + 2;
2414 const uint heightmapWidthSamples = heightmapWidth + 1;
2415 const uint heightmapHeightSamples = heightmapHeight + 1;
2416
2417 const float scale = 1.0f;
2418 const float offset = 0.0f;
2419 const int wrap = 0;
2420
2421 float[] _watermap = new float[heightmapWidthSamples * heightmapWidthSamples];
2422
2423 float maxheigh = float.MinValue;
2424 float minheigh = float.MaxValue;
2425 float val;
2426 for (int i = 0; i < (heightmapWidthSamples * heightmapHeightSamples); i++)
2427 {
2428
2429 val = (baseheight - 0.1f) + ((float)fluidRandomizer.Next(1, 9) / 10f);
2430 _watermap[i] = val;
2431 if (maxheigh < val)
2432 maxheigh = val;
2433 if (minheigh > val)
2434 minheigh = val;
2435 }
2436
2437 float thickness = minheigh;
2438
2439 lock (OdeLock)
2440 {
2441 if (WaterGeom != IntPtr.Zero)
2442 {
2443 d.GeomDestroy(WaterGeom);
2444 d.GeomHeightfieldDataDestroy(WaterHeightmapData);
2445 WaterGeom = IntPtr.Zero;
2446 WaterHeightmapData = IntPtr.Zero;
2447 if(WaterMapHandler.IsAllocated)
2448 WaterMapHandler.Free();
2449 }
2450
2451 WaterHeightmapData = d.GeomHeightfieldDataCreate();
2452
2453 WaterMapHandler = GCHandle.Alloc(_watermap, GCHandleType.Pinned);
2454
2455 d.GeomHeightfieldDataBuildSingle(WaterHeightmapData, WaterMapHandler.AddrOfPinnedObject(), 0, heightmapWidth, heightmapHeight,
2456 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
2457 offset, thickness, wrap);
2458 d.GeomHeightfieldDataSetBounds(WaterHeightmapData, minheigh, maxheigh);
2459 WaterGeom = d.CreateHeightfield(StaticSpace, WaterHeightmapData, 1);
2460 if (WaterGeom != IntPtr.Zero)
2461 {
2462 d.GeomSetCategoryBits(WaterGeom, (uint)(CollisionCategories.Water));
2463 d.GeomSetCollideBits(WaterGeom, 0);
2464
2465 geom_name_map[WaterGeom] = "Water";
2466
2467 d.Matrix3 R = new d.Matrix3();
2468
2469 Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
2470 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
2471
2472 q1 = q1 * q2;
2473 Vector3 v3;
2474 float angle;
2475 q1.GetAxisAngle(out v3, out angle);
2476
2477 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
2478 d.GeomSetRotation(WaterGeom, ref R);
2479 d.GeomSetPosition(WaterGeom, (float)Constants.RegionSize * 0.5f, (float)Constants.RegionSize * 0.5f, 0);
2480 }
2481 }
2482 }
2483
2484 public override void Dispose()
2485 {
2486 m_rayCastManager.Dispose();
2487 m_rayCastManager = null;
2488
2489 lock (OdeLock)
2490 {
2491 lock (_prims)
2492 {
2493 foreach (OdePrim prm in _prims)
2494 {
2495 RemovePrim(prm);
2496 }
2497 }
2498
2499 if (TerrainHeightFieldHeightsHandlers.Count > 0)
2500 {
2501 foreach (GCHandle gch in TerrainHeightFieldHeightsHandlers.Values)
2502 {
2503 if (gch.IsAllocated)
2504 gch.Free();
2505 }
2506 }
2507
2508 if (WaterGeom != IntPtr.Zero)
2509 {
2510 d.GeomDestroy(WaterGeom);
2511 WaterGeom = IntPtr.Zero;
2512 if (WaterHeightmapData != IntPtr.Zero)
2513 d.GeomHeightfieldDataDestroy(WaterHeightmapData);
2514 WaterHeightmapData = IntPtr.Zero;
2515
2516 if (WaterMapHandler.IsAllocated)
2517 WaterMapHandler.Free();
2518 }
2519
2520
2521 if (ContactgeomsArray != IntPtr.Zero)
2522 Marshal.FreeHGlobal(ContactgeomsArray);
2523 if (GlobalContactsArray != IntPtr.Zero)
2524 Marshal.FreeHGlobal(GlobalContactsArray);
2525
2526
2527 d.WorldDestroy(world);
2528 //d.CloseODE();
2529 }
2530 }
2531
2532 public override Dictionary<uint, float> GetTopColliders()
2533 {
2534 Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
2535 int cnt = 0;
2536 lock (_prims)
2537 {
2538 foreach (OdePrim prm in _prims)
2539 {
2540 if (prm.CollisionScore > 0)
2541 {
2542 returncolliders.Add(prm.m_localID, prm.CollisionScore);
2543 cnt++;
2544 prm.CollisionScore = 0f;
2545 if (cnt > 25)
2546 {
2547 break;
2548 }
2549 }
2550 }
2551 }
2552 return returncolliders;
2553 }
2554
2555 public override bool SupportsRayCast()
2556 {
2557 return true;
2558 }
2559
2560 public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
2561 {
2562 if (retMethod != null)
2563 {
2564 m_rayCastManager.QueueRequest(position, direction, length, retMethod);
2565 }
2566 }
2567
2568 public override void RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
2569 {
2570 if (retMethod != null)
2571 {
2572 m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
2573 }
2574 }
2575
2576 // don't like this
2577 public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
2578 {
2579 ContactResult[] ourResults = null;
2580 RayCallback retMethod = delegate(List<ContactResult> results)
2581 {
2582 ourResults = new ContactResult[results.Count];
2583 results.CopyTo(ourResults, 0);
2584 };
2585 int waitTime = 0;
2586 m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
2587 while (ourResults == null && waitTime < 1000)
2588 {
2589 Thread.Sleep(1);
2590 waitTime++;
2591 }
2592 if (ourResults == null)
2593 return new List<ContactResult>();
2594 return new List<ContactResult>(ourResults);
2595 }
2596
2597 public override bool SuportsRaycastWorldFiltered()
2598 {
2599 return true;
2600 }
2601
2602 public override object RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
2603 {
2604 object SyncObject = new object();
2605 List<ContactResult> ourresults = new List<ContactResult>();
2606
2607 RayCallback retMethod = delegate(List<ContactResult> results)
2608 {
2609 lock (SyncObject)
2610 {
2611 ourresults = results;
2612 Monitor.PulseAll(SyncObject);
2613 }
2614 };
2615
2616 lock (SyncObject)
2617 {
2618 m_rayCastManager.QueueRequest(position, direction, length, Count,filter, retMethod);
2619 if (!Monitor.Wait(SyncObject, 500))
2620 return null;
2621 else
2622 return ourresults;
2623 }
2624 }
2625
2626 public override void RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
2627 {
2628 if (retMethod != null && actor !=null)
2629 {
2630 IntPtr geom;
2631 if (actor is OdePrim)
2632 geom = ((OdePrim)actor).prim_geom;
2633 else if (actor is OdeCharacter)
2634 geom = ((OdePrim)actor).prim_geom;
2635 else
2636 return;
2637 if (geom == IntPtr.Zero)
2638 return;
2639 m_rayCastManager.QueueRequest(geom, position, direction, length, retMethod);
2640 }
2641 }
2642
2643 public override void RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
2644 {
2645 if (retMethod != null && actor != null)
2646 {
2647 IntPtr geom;
2648 if (actor is OdePrim)
2649 geom = ((OdePrim)actor).prim_geom;
2650 else if (actor is OdeCharacter)
2651 geom = ((OdePrim)actor).prim_geom;
2652 else
2653 return;
2654 if (geom == IntPtr.Zero)
2655 return;
2656
2657 m_rayCastManager.QueueRequest(geom,position, direction, length, Count, retMethod);
2658 }
2659 }
2660
2661 // don't like this
2662 public override List<ContactResult> RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count)
2663 {
2664 if (actor != null)
2665 {
2666 IntPtr geom;
2667 if (actor is OdePrim)
2668 geom = ((OdePrim)actor).prim_geom;
2669 else if (actor is OdeCharacter)
2670 geom = ((OdePrim)actor).prim_geom;
2671 else
2672 return new List<ContactResult>();
2673 if (geom == IntPtr.Zero)
2674 return new List<ContactResult>();
2675
2676 ContactResult[] ourResults = null;
2677 RayCallback retMethod = delegate(List<ContactResult> results)
2678 {
2679 ourResults = new ContactResult[results.Count];
2680 results.CopyTo(ourResults, 0);
2681 };
2682 int waitTime = 0;
2683 m_rayCastManager.QueueRequest(geom,position, direction, length, Count, retMethod);
2684 while (ourResults == null && waitTime < 1000)
2685 {
2686 Thread.Sleep(1);
2687 waitTime++;
2688 }
2689 if (ourResults == null)
2690 return new List<ContactResult>();
2691 return new List<ContactResult>(ourResults);
2692 }
2693 return new List<ContactResult>();
2694 }
2695 }
2696}
generated by cgit v1.1 at 2024-11-19 17:46:22 +0000