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