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.cs1451
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs945
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs3300
-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.cs86
-rw-r--r--OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs2272
8 files changed, 10515 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..793e281
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
@@ -0,0 +1,1451 @@
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 public ContactData AvatarContactData = new ContactData(10f, 0.3f);
140
141 public OdeCharacter(String avName, OdeScene parent_scene, Vector3 pos, Vector3 size, float pid_d, float pid_p, float capsule_radius, float density, float walk_divisor, float rundivisor)
142 {
143 m_uuid = UUID.Random();
144
145 if (pos.IsFinite())
146 {
147 if (pos.Z > 99999f)
148 {
149 pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
150 }
151 if (pos.Z < -100f) // shouldn't this be 0 ?
152 {
153 pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
154 }
155 _position = pos;
156 }
157 else
158 {
159 _position = new Vector3(((float)_parent_scene.WorldExtents.X * 0.5f), ((float)_parent_scene.WorldExtents.Y * 0.5f), parent_scene.GetTerrainHeightAtXY(128f, 128f) + 10f);
160 m_log.Warn("[PHYSICS]: Got NaN Position on Character Create");
161 }
162
163 _parent_scene = parent_scene;
164
165 PID_D = pid_d;
166 PID_P = pid_p;
167 CAPSULE_RADIUS = capsule_radius;
168 m_density = density;
169 m_mass = 80f; // sure we have a default
170
171 AvatarContactData.mu = parent_scene.AvatarFriction;
172 AvatarContactData.bounce = parent_scene.AvatarBounce;
173
174 walkDivisor = walk_divisor;
175 runDivisor = rundivisor;
176
177 CAPSULE_LENGTH = size.Z * 1.15f - CAPSULE_RADIUS * 2.0f;
178 //m_log.Info("[SIZE]: " + CAPSULE_LENGTH.ToString());
179
180 m_isPhysical = false; // current status: no ODE information exists
181
182 m_name = avName;
183
184 AddChange(changes.Add, null);
185 }
186
187 public override int PhysicsActorType
188 {
189 get { return (int)ActorTypes.Agent; }
190 set { return; }
191 }
192
193 public override ContactData ContactData
194 {
195 get { return AvatarContactData; }
196 }
197
198 public override bool Building { get; set; }
199
200 /// <summary>
201 /// If this is set, the avatar will move faster
202 /// </summary>
203 public override bool SetAlwaysRun
204 {
205 get { return m_alwaysRun; }
206 set { m_alwaysRun = value; }
207 }
208
209 public override uint LocalID
210 {
211 set { m_localID = value; }
212 }
213
214 public override bool Grabbed
215 {
216 set { return; }
217 }
218
219 public override bool Selected
220 {
221 set { return; }
222 }
223
224 public override float Buoyancy
225 {
226 get { return m_buoyancy; }
227 set { m_buoyancy = value; }
228 }
229
230 public override bool FloatOnWater
231 {
232 set { return; }
233 }
234
235 public override bool IsPhysical
236 {
237 get { return false; }
238 set { return; }
239 }
240
241 public override bool ThrottleUpdates
242 {
243 get { return false; }
244 set { return; }
245 }
246
247 public override bool Flying
248 {
249 get { return flying; }
250 set
251 {
252 flying = value;
253 // m_log.DebugFormat("[PHYSICS]: Set OdeCharacter Flying to {0}", flying);
254 }
255 }
256
257 /// <summary>
258 /// Returns if the avatar is colliding in general.
259 /// This includes the ground and objects and avatar.
260 /// </summary>
261 public override bool IsColliding
262 {
263 get { return (m_iscolliding || m_iscollidingGround); }
264 set
265 {
266 if (value)
267 {
268 m_colliderfilter += 2;
269 if (m_colliderfilter > 2)
270 m_colliderfilter = 2;
271 }
272 else
273 {
274 m_colliderfilter--;
275 if (m_colliderfilter < 0)
276 m_colliderfilter = 0;
277 }
278
279 if (m_colliderfilter == 0)
280 m_iscolliding = false;
281 else
282 {
283// SetPidStatus(false);
284 m_pidControllerActive = true;
285 m_iscolliding = true;
286 }
287 }
288 }
289
290 /// <summary>
291 /// Returns if an avatar is colliding with the ground
292 /// </summary>
293 public override bool CollidingGround
294 {
295 get { return m_iscollidingGround; }
296 set
297 {
298 /* we now control this
299 if (value)
300 {
301 m_colliderGroundfilter += 2;
302 if (m_colliderGroundfilter > 2)
303 m_colliderGroundfilter = 2;
304 }
305 else
306 {
307 m_colliderGroundfilter--;
308 if (m_colliderGroundfilter < 0)
309 m_colliderGroundfilter = 0;
310 }
311
312 if (m_colliderGroundfilter == 0)
313 m_iscollidingGround = false;
314 else
315 m_iscollidingGround = true;
316 */
317 }
318
319 }
320
321 /// <summary>
322 /// Returns if the avatar is colliding with an object
323 /// </summary>
324 public override bool CollidingObj
325 {
326 get { return m_iscollidingObj; }
327 set
328 {
329 // Ubit filter this also
330 if (value)
331 {
332 m_colliderObjectfilter += 2;
333 if (m_colliderObjectfilter > 2)
334 m_colliderObjectfilter = 2;
335 }
336 else
337 {
338 m_colliderObjectfilter--;
339 if (m_colliderObjectfilter < 0)
340 m_colliderObjectfilter = 0;
341 }
342
343 if (m_colliderObjectfilter == 0)
344 m_iscollidingObj = false;
345 else
346 m_iscollidingObj = true;
347
348 // m_iscollidingObj = value;
349/*
350 if (m_iscollidingObj)
351 m_pidControllerActive = false;
352 else
353 m_pidControllerActive = true;
354 */
355 }
356 }
357
358 /// <summary>
359 /// turn the PID controller on or off.
360 /// The PID Controller will turn on all by itself in many situations
361 /// </summary>
362 /// <param name="status"></param>
363 public void SetPidStatus(bool status)
364 {
365 m_pidControllerActive = status;
366 }
367
368 public override bool Stopped
369 {
370 get { return _zeroFlag; }
371 }
372
373 /// <summary>
374 /// This 'puts' an avatar somewhere in the physics space.
375 /// Not really a good choice unless you 'know' it's a good
376 /// spot otherwise you're likely to orbit the avatar.
377 /// </summary>
378 public override Vector3 Position
379 {
380 get { return _position; }
381 set
382 {
383 if (Body == IntPtr.Zero || Shell == IntPtr.Zero)
384 {
385 if (value.IsFinite())
386 {
387 if (value.Z > 9999999f)
388 {
389 value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
390 }
391 if (value.Z < -100f)
392 {
393 value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
394 }
395 AddChange(changes.Position, value);
396 }
397 else
398 {
399 m_log.Warn("[PHYSICS]: Got a NaN Position from Scene on a Character");
400 }
401 }
402 }
403 }
404
405 public override Vector3 RotationalVelocity
406 {
407 get { return m_rotationalVelocity; }
408 set { m_rotationalVelocity = value; }
409 }
410
411 /// <summary>
412 /// This property sets the height of the avatar only. We use the height to make sure the avatar stands up straight
413 /// and use it to offset landings properly
414 /// </summary>
415 public override Vector3 Size
416 {
417 get {
418 float d = CAPSULE_RADIUS * 2;
419 return new Vector3(d, d, (CAPSULE_LENGTH +d)/1.15f); }
420 set
421 {
422 if (value.IsFinite())
423 {
424 AddChange(changes.Size, value);
425 }
426 else
427 {
428 m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
429 }
430 }
431 }
432
433 /// <summary>
434 /// This creates the Avatar's physical Surrogate at the position supplied
435 /// </summary>
436 /// <param name="npositionX"></param>
437 /// <param name="npositionY"></param>
438 /// <param name="npositionZ"></param>
439
440 //
441 /// <summary>
442 /// Uses the capped cyllinder volume formula to calculate the avatar's mass.
443 /// This may be used in calculations in the scene/scenepresence
444 /// </summary>
445 public override float Mass
446 {
447 get
448 {
449 float AVvolume = (float)(Math.PI * CAPSULE_RADIUS * CAPSULE_RADIUS * (1.3333333333f * CAPSULE_RADIUS + CAPSULE_LENGTH));
450 return m_density * AVvolume;
451 }
452 }
453 public override void link(PhysicsActor obj)
454 {
455
456 }
457
458 public override void delink()
459 {
460
461 }
462
463 public override void LockAngularMotion(Vector3 axis)
464 {
465
466 }
467
468
469 public override Vector3 Force
470 {
471 get { return _target_velocity; }
472 set { return; }
473 }
474
475 public override int VehicleType
476 {
477 get { return 0; }
478 set { return; }
479 }
480
481 public override void VehicleFloatParam(int param, float value)
482 {
483
484 }
485
486 public override void VehicleVectorParam(int param, Vector3 value)
487 {
488
489 }
490
491 public override void VehicleRotationParam(int param, Quaternion rotation)
492 {
493
494 }
495
496 public override void VehicleFlags(int param, bool remove)
497 {
498
499 }
500
501 public override void SetVolumeDetect(int param)
502 {
503
504 }
505
506 public override Vector3 CenterOfMass
507 {
508 get
509 {
510 Vector3 pos = _position;
511 return pos;
512 }
513 }
514
515 public override Vector3 GeometricCenter
516 {
517 get
518 {
519 Vector3 pos = _position;
520 return pos;
521 }
522 }
523
524 //UBit mess
525 /* for later use
526 public override Vector3 PrimOOBsize
527 {
528 get
529 {
530 Vector3 s=Size;
531 s.X *=0.5f;
532 s.Y *=0.5f;
533 s.Z *=0.5f;
534 return s;
535 }
536 }
537
538 public override Vector3 PrimOOBoffset
539 {
540 get
541 {
542 return Vector3.Zero;
543 }
544 }
545 */
546
547 public override PrimitiveBaseShape Shape
548 {
549 set { return; }
550 }
551
552 public override Vector3 Velocity
553 {
554 get
555 {
556 return _velocity;
557 }
558 set
559 {
560 if (value.IsFinite())
561 {
562 AddChange(changes.Velocity, value);
563 }
564 else
565 {
566 m_log.Warn("[PHYSICS]: Got a NaN velocity from Scene in a Character");
567 }
568 }
569 }
570
571 public override Vector3 Torque
572 {
573 get { return Vector3.Zero; }
574 set { return; }
575 }
576
577 public override float CollisionScore
578 {
579 get { return 0f; }
580 set { }
581 }
582
583 public override bool Kinematic
584 {
585 get { return false; }
586 set { }
587 }
588
589 public override Quaternion Orientation
590 {
591 get { return Quaternion.Identity; }
592 set
593 {
594 }
595 }
596
597 public override Vector3 Acceleration
598 {
599 get { return _acceleration; }
600 set { }
601 }
602
603 public void SetAcceleration(Vector3 accel)
604 {
605 m_pidControllerActive = true;
606 _acceleration = accel;
607 }
608
609 /// <summary>
610 /// Adds the force supplied to the Target Velocity
611 /// The PID controller takes this target velocity and tries to make it a reality
612 /// </summary>
613 /// <param name="force"></param>
614 public override void AddForce(Vector3 force, bool pushforce)
615 {
616 if (force.IsFinite())
617 {
618 if (pushforce)
619 {
620 AddChange(changes.Force, force * m_density / _parent_scene.ODE_STEPSIZE / 28f);
621 }
622 else
623 {
624 AddChange(changes.Velocity, force);
625 }
626 }
627 else
628 {
629 m_log.Warn("[PHYSICS]: Got a NaN force applied to a Character");
630 }
631 //m_lastUpdateSent = false;
632 }
633
634 public override void AddAngularForce(Vector3 force, bool pushforce)
635 {
636
637 }
638
639 public override void SetMomentum(Vector3 momentum)
640 {
641 }
642
643
644 // WARNING: This MUST NOT be called outside of ProcessTaints, else we can have unsynchronized access
645 // to ODE internals. ProcessTaints is called from within thread-locked Simulate(), so it is the only
646 // place that is safe to call this routine AvatarGeomAndBodyCreation.
647 private void AvatarGeomAndBodyCreation(float npositionX, float npositionY, float npositionZ)
648 {
649 _parent_scene.waitForSpaceUnlock(_parent_scene.ActiveSpace);
650 if (CAPSULE_LENGTH <= 0)
651 {
652 m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!");
653 CAPSULE_LENGTH = 0.01f;
654
655 }
656
657 if (CAPSULE_RADIUS <= 0)
658 {
659 m_log.Warn("[PHYSICS]: The capsule size you specified in opensim.ini is invalid! Setting it to the smallest possible size!");
660 CAPSULE_RADIUS = 0.01f;
661
662 }
663 Shell = d.CreateCapsule(_parent_scene.ActiveSpace, CAPSULE_RADIUS, CAPSULE_LENGTH);
664
665 d.GeomSetCategoryBits(Shell, (int)m_collisionCategories);
666 d.GeomSetCollideBits(Shell, (int)m_collisionFlags);
667
668 d.MassSetCapsule(out ShellMass, m_density, 3, CAPSULE_RADIUS, CAPSULE_LENGTH);
669
670 m_mass = ShellMass.mass; // update mass
671
672 // rescale PID parameters
673 PID_D = _parent_scene.avPIDD;
674 PID_P = _parent_scene.avPIDP;
675
676 // rescale PID parameters so that this aren't affected by mass
677 // and so don't get unstable for some masses
678 // also scale by ode time step so you don't need to refix them
679
680 PID_D /= 50 * 80; //scale to original mass of around 80 and 50 ODE fps
681 PID_D *= m_mass / _parent_scene.ODE_STEPSIZE;
682 PID_P /= 50 * 80;
683 PID_P *= m_mass / _parent_scene.ODE_STEPSIZE;
684
685 Body = d.BodyCreate(_parent_scene.world);
686
687 d.BodySetAutoDisableFlag(Body, false);
688 d.BodySetPosition(Body, npositionX, npositionY, npositionZ);
689
690 _position.X = npositionX;
691 _position.Y = npositionY;
692 _position.Z = npositionZ;
693
694 d.BodySetMass(Body, ref ShellMass);
695 d.GeomSetBody(Shell, Body);
696
697 // The purpose of the AMotor here is to keep the avatar's physical
698 // surrogate from rotating while moving
699 Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
700 d.JointAttach(Amotor, Body, IntPtr.Zero);
701
702 d.JointSetAMotorMode(Amotor, 0);
703 d.JointSetAMotorNumAxes(Amotor, 3);
704 d.JointSetAMotorAxis(Amotor, 0, 0, 1, 0, 0);
705 d.JointSetAMotorAxis(Amotor, 1, 0, 0, 1, 0);
706 d.JointSetAMotorAxis(Amotor, 2, 0, 0, 0, 1);
707
708 d.JointSetAMotorAngle(Amotor, 0, 0);
709 d.JointSetAMotorAngle(Amotor, 1, 0);
710 d.JointSetAMotorAngle(Amotor, 2, 0);
711
712 d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM, 0f); // make it HARD
713 d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM2, 0f);
714 d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM3, 0f);
715 d.JointSetAMotorParam(Amotor, (int)dParam.StopERP, 0.8f);
716 d.JointSetAMotorParam(Amotor, (int)dParam.StopERP2, 0.8f);
717 d.JointSetAMotorParam(Amotor, (int)dParam.StopERP3, 0.8f);
718
719 // These lowstops and high stops are effectively (no wiggle room)
720 d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -1e-5f);
721 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 1e-5f);
722 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -1e-5f);
723 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 1e-5f);
724 d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -1e-5f);
725 d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 1e-5f);
726
727 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel, 0);
728 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel2, 0);
729 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel3, 0);
730
731 d.JointSetAMotorParam(Amotor, (int)dParam.FMax, 5e6f);
732 d.JointSetAMotorParam(Amotor, (int)dParam.FMax2, 5e6f);
733 d.JointSetAMotorParam(Amotor, (int)dParam.FMax3, 5e6f);
734 }
735
736 /// <summary>
737 /// Destroys the avatar body and geom
738
739 private void AvatarGeomAndBodyDestroy()
740 {
741 // Kill the Amotor
742 if (Amotor != IntPtr.Zero)
743 {
744 d.JointDestroy(Amotor);
745 Amotor = IntPtr.Zero;
746 }
747
748 if (Body != IntPtr.Zero)
749 {
750 //kill the body
751 d.BodyDestroy(Body);
752 Body = IntPtr.Zero;
753 }
754
755 //kill the Geometry
756 if (Shell != IntPtr.Zero)
757 {
758 _parent_scene.geom_name_map.Remove(Shell);
759 _parent_scene.waitForSpaceUnlock(_parent_scene.ActiveSpace);
760 d.GeomDestroy(Shell);
761 _parent_scene.geom_name_map.Remove(Shell);
762 Shell = IntPtr.Zero;
763 }
764 }
765
766 /// <summary>
767 /// Called from Simulate
768 /// This is the avatar's movement control + PID Controller
769 /// </summary>
770 /// <param name="timeStep"></param>
771 public void Move(float timeStep, List<OdeCharacter> defects)
772 {
773 // no lock; for now it's only called from within Simulate()
774
775 // If the PID Controller isn't active then we set our force
776 // calculating base velocity to the current position
777
778 if (Body == IntPtr.Zero)
779 return;
780
781 d.Vector3 dtmp;
782 d.BodyCopyPosition(Body, out dtmp);
783 Vector3 localpos = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
784
785 // the Amotor still lets avatar rotation to drift during colisions
786 // so force it back to identity
787
788 d.Quaternion qtmp;
789 qtmp.W = 1;
790 qtmp.X = 0;
791 qtmp.Y = 0;
792 qtmp.Z = 0;
793 d.BodySetQuaternion(Body, ref qtmp);
794
795 if (m_pidControllerActive == false)
796 {
797 _zeroPosition = localpos;
798 }
799 //PidStatus = true;
800
801
802 if (!localpos.IsFinite())
803 {
804
805 m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
806 defects.Add(this);
807 // _parent_scene.RemoveCharacter(this);
808
809 // destroy avatar capsule and related ODE data
810 AvatarGeomAndBodyDestroy();
811
812 return;
813 }
814
815 Vector3 vec = Vector3.Zero;
816 dtmp = d.BodyGetLinearVel(Body);
817 Vector3 vel = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
818
819 float movementdivisor = 1f;
820 //Ubit change divisions into multiplications below
821 if (!m_alwaysRun)
822 {
823 movementdivisor = 1 / walkDivisor;
824 }
825 else
826 {
827 movementdivisor = 1 / runDivisor;
828 }
829
830 // colide with land
831
832 d.AABB aabb;
833 d.GeomGetAABB(Shell, out aabb);
834 float chrminZ = aabb.MinZ;
835
836 Vector3 posch = localpos;
837
838 float ftmp;
839
840 if (flying)
841 {
842 ftmp = timeStep;
843 posch.X += vel.X * ftmp;
844 posch.Y += vel.Y * ftmp;
845 }
846
847 float terrainheight = _parent_scene.GetTerrainHeightAtXY(posch.X, posch.Y);
848 if (chrminZ < terrainheight)
849 {
850 float depth = terrainheight - chrminZ;
851 if (!flying)
852 {
853 vec.Z = -vel.Z * PID_D * 1.5f + depth * PID_P * 50;
854 }
855 else
856 vec.Z = depth * PID_P * 50;
857
858 /*
859 Vector3 vtmp;
860 vtmp.X = _target_velocity.X * timeStep;
861 vtmp.Y = _target_velocity.Y * timeStep;
862 // fake and avoid squares
863 float k = (Math.Abs(vtmp.X) + Math.Abs(vtmp.Y));
864 if (k > 0)
865 {
866 posch.X += vtmp.X;
867 posch.Y += vtmp.Y;
868 terrainheight -= _parent_scene.GetTerrainHeightAtXY(posch.X, posch.Y);
869 k = 1 + Math.Abs(terrainheight) / k;
870 movementdivisor /= k;
871
872 if (k < 1)
873 k = 1;
874 }
875 */
876
877
878 if (depth < 0.1f)
879 {
880 m_iscolliding = true;
881 m_colliderfilter = 2;
882 m_iscollidingGround = true;
883
884 ContactPoint contact = new ContactPoint();
885 contact.PenetrationDepth = depth;
886 contact.Position.X = localpos.X;
887 contact.Position.Y = localpos.Y;
888 contact.Position.Z = chrminZ;
889 contact.SurfaceNormal.X = 0f;
890 contact.SurfaceNormal.Y = 0f;
891 contact.SurfaceNormal.Z = -1f;
892 AddCollisionEvent(0, contact);
893
894 vec.Z *= 0.5f;
895 }
896
897 else
898 m_iscollidingGround = false;
899 }
900 else
901 m_iscollidingGround = false;
902
903
904 // if velocity is zero, use position control; otherwise, velocity control
905 if (_target_velocity.X == 0.0f && _target_velocity.Y == 0.0f && _target_velocity.Z == 0.0f
906 && m_iscolliding)
907 {
908 // keep track of where we stopped. No more slippin' & slidin'
909 if (!_zeroFlag)
910 {
911 _zeroFlag = true;
912 _zeroPosition = localpos;
913 }
914 if (m_pidControllerActive)
915 {
916 // We only want to deactivate the PID Controller if we think we want to have our surrogate
917 // react to the physics scene by moving it's position.
918 // Avatar to Avatar collisions
919 // Prim to avatar collisions
920
921 vec.X = -vel.X * PID_D + (_zeroPosition.X - localpos.X) * (PID_P * 2);
922 vec.Y = -vel.Y * PID_D + (_zeroPosition.Y - localpos.Y) * (PID_P * 2);
923 if (flying)
924 {
925 vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P;
926 }
927 }
928 //PidStatus = true;
929 }
930 else
931 {
932 m_pidControllerActive = true;
933 _zeroFlag = false;
934
935 if (m_iscolliding)
936 {
937 if (!flying)
938 {
939 if (_target_velocity.Z > 0.0f)
940 {
941 // We're colliding with something and we're not flying but we're moving
942 // This means we're walking or running. JUMPING
943 vec.Z += (_target_velocity.Z - vel.Z) * PID_D * 1.2f;// +(_zeroPosition.Z - localpos.Z) * PID_P;
944 }
945 // We're standing on something
946 vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D);
947 vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D);
948 }
949 else
950 {
951 // We're flying and colliding with something
952 vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D * 0.0625f);
953 vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D * 0.0625f);
954 vec.Z += (_target_velocity.Z - vel.Z) * (PID_D);
955 }
956 }
957 else // ie not colliding
958 {
959 if (flying) //(!m_iscolliding && flying)
960 {
961 // we're in mid air suspended
962 vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D * 1.667f);
963 vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D * 1.667f);
964 vec.Z += (_target_velocity.Z - vel.Z) * (PID_D);
965 }
966
967 else
968 {
969 // we're not colliding and we're not flying so that means we're falling!
970 // m_iscolliding includes collisions with the ground.
971
972 // d.Vector3 pos = d.BodyGetPosition(Body);
973 vec.X = (_target_velocity.X - vel.X) * PID_D * 0.833f;
974 vec.Y = (_target_velocity.Y - vel.Y) * PID_D * 0.833f;
975 }
976 }
977 }
978
979 if (flying)
980 {
981 vec.Z -= _parent_scene.gravityz * m_mass;
982
983 //Added for auto fly height. Kitto Flora
984 float target_altitude = _parent_scene.GetTerrainHeightAtXY(localpos.X, localpos.Y) + MinimumGroundFlightOffset;
985
986 if (localpos.Z < target_altitude)
987 {
988 vec.Z += (target_altitude - localpos.Z) * PID_P * 5.0f;
989 }
990 // end add Kitto Flora
991 }
992
993 if (vec.IsFinite())
994 {
995 if (vec.X != 0 || vec.Y !=0 || vec.Z !=0)
996 d.BodyAddForce(Body, vec.X, vec.Y, vec.Z);
997 }
998 else
999 {
1000 m_log.Warn("[PHYSICS]: Got a NaN force vector in Move()");
1001 m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
1002 defects.Add(this);
1003 // _parent_scene.RemoveCharacter(this);
1004 // destroy avatar capsule and related ODE data
1005 AvatarGeomAndBodyDestroy();
1006 }
1007 }
1008
1009 /// <summary>
1010 /// Updates the reported position and velocity. This essentially sends the data up to ScenePresence.
1011 /// </summary>
1012 public void UpdatePositionAndVelocity()
1013 {
1014 // no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
1015 if (Body == IntPtr.Zero)
1016 return;
1017
1018 d.Vector3 vec;
1019 try
1020 {
1021 d.BodyCopyPosition(Body, out vec);
1022 }
1023 catch (NullReferenceException)
1024 {
1025 bad = true;
1026 _parent_scene.BadCharacter(this);
1027 vec = new d.Vector3(_position.X, _position.Y, _position.Z);
1028 base.RaiseOutOfBounds(_position); // Tells ScenePresence that there's a problem!
1029 m_log.WarnFormat("[ODEPLUGIN]: Avatar Null reference for Avatar {0}, physical actor {1}", m_name, m_uuid);
1030 }
1031
1032 _position.X = vec.X;
1033 _position.Y = vec.Y;
1034 _position.Z = vec.Z;
1035
1036 bool fixbody = false;
1037
1038 if (_position.X < 0.0f)
1039 {
1040 fixbody = true;
1041 _position.X = 0.1f;
1042 }
1043 else if (_position.X > (int)_parent_scene.WorldExtents.X - 0.1f)
1044 {
1045 fixbody = true;
1046 _position.X = (int)_parent_scene.WorldExtents.X - 0.1f;
1047 }
1048
1049 if (_position.Y < 0.0f)
1050 {
1051 fixbody = true;
1052 _position.Y = 0.1f;
1053 }
1054 else if (_position.Y > (int)_parent_scene.WorldExtents.Y - 0.1)
1055 {
1056 fixbody = true;
1057 _position.Y = (int)_parent_scene.WorldExtents.Y - 0.1f;
1058 }
1059
1060 if (fixbody)
1061 d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
1062
1063 // Did we move last? = zeroflag
1064 // This helps keep us from sliding all over
1065/*
1066 if (_zeroFlag)
1067 {
1068 _velocity.X = 0.0f;
1069 _velocity.Y = 0.0f;
1070 _velocity.Z = 0.0f;
1071
1072 // Did we send out the 'stopped' message?
1073 if (!m_lastUpdateSent)
1074 {
1075 m_lastUpdateSent = true;
1076 base.RequestPhysicsterseUpdate();
1077 }
1078 }
1079 else
1080 {
1081 m_lastUpdateSent = false;
1082 */
1083 try
1084 {
1085 vec = d.BodyGetLinearVel(Body);
1086 }
1087 catch (NullReferenceException)
1088 {
1089 vec.X = _velocity.X;
1090 vec.Y = _velocity.Y;
1091 vec.Z = _velocity.Z;
1092 }
1093 _velocity.X = (vec.X);
1094 _velocity.Y = (vec.Y);
1095 _velocity.Z = (vec.Z);
1096 // }
1097 }
1098
1099 /// <summary>
1100 /// Cleanup the things we use in the scene.
1101 /// </summary>
1102 public void Destroy()
1103 {
1104 AddChange(changes.Remove, null);
1105 }
1106
1107 public override void CrossingFailure()
1108 {
1109 }
1110
1111 public override Vector3 PIDTarget { set { return; } }
1112 public override bool PIDActive { set { return; } }
1113 public override float PIDTau { set { return; } }
1114
1115 public override float PIDHoverHeight { set { return; } }
1116 public override bool PIDHoverActive { set { return; } }
1117 public override PIDHoverType PIDHoverType { set { return; } }
1118 public override float PIDHoverTau { set { return; } }
1119
1120 public override Quaternion APIDTarget { set { return; } }
1121
1122 public override bool APIDActive { set { return; } }
1123
1124 public override float APIDStrength { set { return; } }
1125
1126 public override float APIDDamping { set { return; } }
1127
1128
1129 public override void SubscribeEvents(int ms)
1130 {
1131 m_requestedUpdateFrequency = ms;
1132 m_eventsubscription = ms;
1133 _parent_scene.AddCollisionEventReporting(this);
1134 m_haseventsubscription = true;
1135 }
1136
1137 public override void UnSubscribeEvents()
1138 {
1139 m_haseventsubscription = false;
1140 _parent_scene.RemoveCollisionEventReporting(this);
1141 m_requestedUpdateFrequency = 0;
1142 m_eventsubscription = 0;
1143 }
1144
1145 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
1146 {
1147 if (m_haseventsubscription)
1148 {
1149 // m_log.DebugFormat(
1150 // "[PHYSICS]: Adding collision event for {0}, collidedWith {1}, contact {2}", "", CollidedWith, contact);
1151
1152 CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
1153 }
1154 }
1155
1156 public void SendCollisions()
1157 {
1158 if (m_haseventsubscription && m_eventsubscription > m_requestedUpdateFrequency)
1159 {
1160 if (CollisionEventsThisFrame != null)
1161 {
1162 base.SendCollisionUpdate(CollisionEventsThisFrame);
1163 }
1164 CollisionEventsThisFrame = new CollisionEventUpdate();
1165 m_eventsubscription = 0;
1166 }
1167 }
1168
1169 public override bool SubscribedEvents()
1170 {
1171 return m_haseventsubscription;
1172 }
1173
1174 private void changePhysicsStatus(bool NewStatus)
1175 {
1176 if (NewStatus != m_isPhysical)
1177 {
1178 if (NewStatus)
1179 {
1180 // Create avatar capsule and related ODE data
1181 if ((Shell != IntPtr.Zero))
1182 {
1183 // a lost shell ?
1184 m_log.Warn("[PHYSICS]: re-creating the following avatar ODE data, even though it already exists - "
1185 + (Shell != IntPtr.Zero ? "Shell " : "")
1186 + (Body != IntPtr.Zero ? "Body " : "")
1187 + (Amotor != IntPtr.Zero ? "Amotor " : ""));
1188 AvatarGeomAndBodyDestroy();
1189 }
1190
1191 AvatarGeomAndBodyCreation(_position.X, _position.Y, _position.Z);
1192 _parent_scene.geom_name_map[Shell] = m_name;
1193 _parent_scene.actor_name_map[Shell] = (PhysicsActor)this;
1194 _parent_scene.AddCharacter(this);
1195 }
1196 else
1197 {
1198 _parent_scene.RemoveCharacter(this);
1199 // destroy avatar capsule and related ODE data
1200 AvatarGeomAndBodyDestroy();
1201 }
1202
1203 m_isPhysical = NewStatus;
1204 }
1205 }
1206
1207 private void changeAdd()
1208 {
1209 changePhysicsStatus(true);
1210 }
1211
1212 private void changeRemove()
1213 {
1214 changePhysicsStatus(false);
1215 }
1216
1217 private void changeShape(PrimitiveBaseShape arg)
1218 {
1219 }
1220
1221 private void changeSize(Vector3 Size)
1222 {
1223 if (Size.IsFinite())
1224 {
1225 float caplen = Size.Z;
1226
1227 caplen = caplen * 1.15f - CAPSULE_RADIUS * 2.0f;
1228
1229 if (caplen != CAPSULE_LENGTH)
1230 {
1231 if (Shell != IntPtr.Zero && Body != IntPtr.Zero && Amotor != IntPtr.Zero)
1232 {
1233 AvatarGeomAndBodyDestroy();
1234
1235 float prevCapsule = CAPSULE_LENGTH;
1236 CAPSULE_LENGTH = caplen;
1237
1238 AvatarGeomAndBodyCreation(_position.X, _position.Y,
1239 _position.Z + (Math.Abs(CAPSULE_LENGTH - prevCapsule) * 2));
1240
1241 Velocity = Vector3.Zero;
1242
1243 _parent_scene.geom_name_map[Shell] = m_name;
1244 _parent_scene.actor_name_map[Shell] = (PhysicsActor)this;
1245 }
1246 else
1247 {
1248 m_log.Warn("[PHYSICS]: trying to change capsule size, but the following ODE data is missing - "
1249 + (Shell == IntPtr.Zero ? "Shell " : "")
1250 + (Body == IntPtr.Zero ? "Body " : "")
1251 + (Amotor == IntPtr.Zero ? "Amotor " : ""));
1252 }
1253 }
1254
1255 m_pidControllerActive = true;
1256 }
1257 else
1258 {
1259 m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
1260 }
1261 }
1262
1263 private void changePosition( Vector3 newPos)
1264 {
1265 if (Body != IntPtr.Zero)
1266 d.BodySetPosition(Body, newPos.X, newPos.Y, newPos.Z);
1267 _position = newPos;
1268 }
1269
1270 private void changeOrientation(Quaternion newOri)
1271 {
1272 }
1273
1274 private void changeVelocity(Vector3 newVel)
1275 {
1276 m_pidControllerActive = true;
1277 _target_velocity = newVel;
1278 }
1279
1280 private void changeSetTorque(Vector3 newTorque)
1281 {
1282 }
1283
1284 private void changeAddForce(Vector3 newForce)
1285 {
1286 }
1287
1288 private void changeAddAngularForce(Vector3 arg)
1289 {
1290 }
1291
1292 private void changeAngularLock(Vector3 arg)
1293 {
1294 }
1295
1296 private void changeFloatOnWater(bool arg)
1297 {
1298 }
1299
1300 private void changeVolumedetetion(bool arg)
1301 {
1302 }
1303
1304 private void changeSelectedStatus(bool arg)
1305 {
1306 }
1307
1308 private void changeDisable(bool arg)
1309 {
1310 }
1311
1312 private void changeBuilding(bool arg)
1313 {
1314 }
1315
1316 private void changeForce(Vector3 newForce)
1317 {
1318 m_pidControllerActive = false;
1319 if (Body != IntPtr.Zero)
1320 {
1321 if (newForce.X != 0f || newForce.Y != 0f || newForce.Z != 0)
1322 d.BodyAddForce(Body, newForce.X, newForce.Y, newForce.Z);
1323 }
1324 }
1325
1326 private void donullchange()
1327 {
1328 }
1329
1330 public bool DoAChange(changes what, object arg)
1331 {
1332 if (Shell == IntPtr.Zero && what != changes.Add && what != changes.Remove)
1333 {
1334 return false;
1335 }
1336
1337 // nasty switch
1338 switch (what)
1339 {
1340 case changes.Add:
1341 changeAdd();
1342 break;
1343 case changes.Remove:
1344 changeRemove();
1345 break;
1346
1347 case changes.Position:
1348 changePosition((Vector3)arg);
1349 break;
1350
1351 case changes.Orientation:
1352 changeOrientation((Quaternion)arg);
1353 break;
1354
1355 case changes.PosOffset:
1356 donullchange();
1357 break;
1358
1359 case changes.OriOffset:
1360 donullchange();
1361 break;
1362
1363 case changes.Velocity:
1364 changeVelocity((Vector3)arg);
1365 break;
1366
1367 // case changes.Acceleration:
1368 // changeacceleration((Vector3)arg);
1369 // break;
1370 // case changes.AngVelocity:
1371 // changeangvelocity((Vector3)arg);
1372 // break;
1373
1374 case changes.Force:
1375 changeForce((Vector3)arg);
1376 break;
1377
1378 case changes.Torque:
1379 changeSetTorque((Vector3)arg);
1380 break;
1381
1382 case changes.AddForce:
1383 changeAddForce((Vector3)arg);
1384 break;
1385
1386 case changes.AddAngForce:
1387 changeAddAngularForce((Vector3)arg);
1388 break;
1389
1390 case changes.AngLock:
1391 changeAngularLock((Vector3)arg);
1392 break;
1393
1394 case changes.Size:
1395 changeSize((Vector3)arg);
1396 break;
1397/* not in use for now
1398 case changes.Shape:
1399 changeShape((PrimitiveBaseShape)arg);
1400 break;
1401
1402 case changes.CollidesWater:
1403 changeFloatOnWater((bool)arg);
1404 break;
1405
1406 case changes.VolumeDtc:
1407 changeVolumedetetion((bool)arg);
1408 break;
1409
1410 case changes.Physical:
1411 changePhysicsStatus((bool)arg);
1412 break;
1413
1414 case changes.Selected:
1415 changeSelectedStatus((bool)arg);
1416 break;
1417
1418 case changes.disabled:
1419 changeDisable((bool)arg);
1420 break;
1421
1422 case changes.building:
1423 changeBuilding((bool)arg);
1424 break;
1425*/
1426 case changes.Null:
1427 donullchange();
1428 break;
1429
1430 default:
1431 donullchange();
1432 break;
1433 }
1434 return false;
1435 }
1436
1437 public void AddChange(changes what, object arg)
1438 {
1439 _parent_scene.AddChange((PhysicsActor)this, what, arg);
1440 }
1441
1442
1443 internal void AddCollisionFrameTime(int p)
1444 {
1445 // protect it from overflow crashing
1446 if (m_eventsubscription + p >= int.MaxValue)
1447 m_eventsubscription = 0;
1448 m_eventsubscription += p;
1449 }
1450 }
1451}
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs
new file mode 100644
index 0000000..c9d0909
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEDynamics.cs
@@ -0,0 +1,945 @@
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// 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
123
124 public ODEDynamics(OdePrim rootp)
125 {
126 rootPrim = rootp;
127 _pParentScene = rootPrim._parent_scene;
128 }
129
130
131 public void DoSetVehicle(VehicleData vd)
132 {
133
134 float timestep = _pParentScene.ODE_STEPSIZE;
135 float invtimestep = 1.0f / timestep;
136
137 m_type = vd.m_type;
138 m_flags = vd.m_flags;
139
140 // Linear properties
141 m_linearMotorDirection = vd.m_linearMotorDirection;
142
143 m_linearFrictionTimescale = vd.m_linearFrictionTimescale;
144 if (m_linearFrictionTimescale.X < timestep) m_linearFrictionTimescale.X = timestep;
145 if (m_linearFrictionTimescale.Y < timestep) m_linearFrictionTimescale.Y = timestep;
146 if (m_linearFrictionTimescale.Z < timestep) m_linearFrictionTimescale.Z = timestep;
147
148 m_linearMotorDecayTimescale = vd.m_linearMotorDecayTimescale;
149 if (m_linearMotorDecayTimescale < 0.5f) m_linearMotorDecayTimescale = 0.5f;
150 m_linearMotorDecayTimescale *= invtimestep;
151
152 m_linearMotorTimescale = vd.m_linearMotorTimescale;
153 if (m_linearMotorTimescale < timestep) m_linearMotorTimescale = timestep;
154
155 m_linearMotorOffset = vd.m_linearMotorOffset;
156
157 //Angular properties
158 m_angularMotorDirection = vd.m_angularMotorDirection;
159 m_angularMotorTimescale = vd.m_angularMotorTimescale;
160 if (m_angularMotorTimescale < timestep) m_angularMotorTimescale = timestep;
161
162 m_angularMotorDecayTimescale = vd.m_angularMotorDecayTimescale;
163 if (m_angularMotorDecayTimescale < 0.5f) m_angularMotorDecayTimescale = 0.5f;
164 m_angularMotorDecayTimescale *= invtimestep;
165
166 m_angularFrictionTimescale = vd.m_angularFrictionTimescale;
167 if (m_angularFrictionTimescale.X < timestep) m_angularFrictionTimescale.X = timestep;
168 if (m_angularFrictionTimescale.Y < timestep) m_angularFrictionTimescale.Y = timestep;
169 if (m_angularFrictionTimescale.Z < timestep) m_angularFrictionTimescale.Z = timestep;
170
171 //Deflection properties
172 m_angularDeflectionEfficiency = vd.m_angularDeflectionEfficiency;
173 m_angularDeflectionTimescale = vd.m_angularDeflectionTimescale;
174 if (m_angularDeflectionTimescale < timestep) m_angularDeflectionTimescale = timestep;
175
176 m_linearDeflectionEfficiency = vd.m_linearDeflectionEfficiency;
177 m_linearDeflectionTimescale = vd.m_linearDeflectionTimescale;
178 if (m_linearDeflectionTimescale < timestep) m_linearDeflectionTimescale = timestep;
179
180 //Banking properties
181 m_bankingEfficiency = vd.m_bankingEfficiency;
182 m_bankingMix = vd.m_bankingMix;
183 m_bankingTimescale = vd.m_bankingTimescale;
184 if (m_bankingTimescale < timestep) m_bankingTimescale = timestep;
185
186 //Hover and Buoyancy properties
187 m_VhoverHeight = vd.m_VhoverHeight;
188 m_VhoverEfficiency = vd.m_VhoverEfficiency;
189 m_VhoverTimescale = vd.m_VhoverTimescale;
190 if (m_VhoverTimescale < timestep) m_VhoverTimescale = timestep;
191
192 m_VehicleBuoyancy = vd.m_VehicleBuoyancy;
193
194 //Attractor properties
195 m_verticalAttractionEfficiency = vd.m_verticalAttractionEfficiency;
196 m_verticalAttractionTimescale = vd.m_verticalAttractionTimescale;
197 if (m_verticalAttractionTimescale < timestep) m_verticalAttractionTimescale = timestep;
198
199 // Axis
200 m_referenceFrame = vd.m_referenceFrame;
201
202 m_lmEfect = 0;
203 m_amEfect = 0;
204 }
205
206 internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
207 {
208 float len;
209 float invtimestep = 1.0f / _pParentScene.ODE_STEPSIZE;
210 float timestep = _pParentScene.ODE_STEPSIZE;
211
212 switch (pParam)
213 {
214 case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
215 if (pValue < 0f) pValue = 0f;
216 if (pValue > 1f) pValue = 1f;
217 m_angularDeflectionEfficiency = pValue;
218 break;
219 case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
220 if (pValue < timestep) pValue = timestep;
221 m_angularDeflectionTimescale = pValue;
222 break;
223 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
224 // if (pValue < timestep) pValue = timestep;
225 // try to make impulses to work a bit better
226 if (pValue < 0.5f) pValue = 0.5f;
227 else if (pValue > 120) pValue = 120;
228 m_angularMotorDecayTimescale = pValue * invtimestep;
229 break;
230 case Vehicle.ANGULAR_MOTOR_TIMESCALE:
231 if (pValue < timestep) pValue = timestep;
232 m_angularMotorTimescale = pValue;
233 break;
234 case Vehicle.BANKING_EFFICIENCY:
235 if (pValue < -1f) pValue = -1f;
236 if (pValue > 1f) pValue = 1f;
237 m_bankingEfficiency = pValue;
238 break;
239 case Vehicle.BANKING_MIX:
240 if (pValue < 0f) pValue = 0f;
241 if (pValue > 1f) pValue = 1f;
242 m_bankingMix = pValue;
243 break;
244 case Vehicle.BANKING_TIMESCALE:
245 if (pValue < timestep) pValue = timestep;
246 m_bankingTimescale = pValue;
247 break;
248 case Vehicle.BUOYANCY:
249 if (pValue < -1f) pValue = -1f;
250 if (pValue > 1f) pValue = 1f;
251 m_VehicleBuoyancy = pValue;
252 break;
253 case Vehicle.HOVER_EFFICIENCY:
254 if (pValue < 0f) pValue = 0f;
255 if (pValue > 1f) pValue = 1f;
256 m_VhoverEfficiency = pValue;
257 break;
258 case Vehicle.HOVER_HEIGHT:
259 m_VhoverHeight = pValue;
260 break;
261 case Vehicle.HOVER_TIMESCALE:
262 if (pValue < timestep) pValue = timestep;
263 m_VhoverTimescale = pValue;
264 break;
265 case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
266 if (pValue < 0f) pValue = 0f;
267 if (pValue > 1f) pValue = 1f;
268 m_linearDeflectionEfficiency = pValue;
269 break;
270 case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
271 if (pValue < timestep) pValue = timestep;
272 m_linearDeflectionTimescale = pValue;
273 break;
274 case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
275 // if (pValue < timestep) pValue = timestep;
276 // try to make impulses to work a bit better
277 if (pValue < 0.5f) pValue = 0.5f;
278 else if (pValue > 120) pValue = 120;
279 m_linearMotorDecayTimescale = pValue * invtimestep;
280 break;
281 case Vehicle.LINEAR_MOTOR_TIMESCALE:
282 if (pValue < timestep) pValue = timestep;
283 m_linearMotorTimescale = pValue;
284 break;
285 case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
286 if (pValue < 0f) pValue = 0f;
287 if (pValue > 1f) pValue = 1f;
288 m_verticalAttractionEfficiency = pValue;
289 break;
290 case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
291 if (pValue < timestep) pValue = timestep;
292 m_verticalAttractionTimescale = pValue;
293 break;
294
295 // These are vector properties but the engine lets you use a single float value to
296 // set all of the components to the same value
297 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
298 if (pValue < timestep) pValue = timestep;
299 m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
300 break;
301 case Vehicle.ANGULAR_MOTOR_DIRECTION:
302 m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
303 len = m_angularMotorDirection.Length();
304 if (len > 12.566f)
305 m_angularMotorDirection *= (12.566f / len);
306 m_amEfect = 1.0f; // turn it on
307 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
308 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
309 d.BodyEnable(rootPrim.Body);
310 break;
311 case Vehicle.LINEAR_FRICTION_TIMESCALE:
312 if (pValue < timestep) pValue = timestep;
313 m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
314 break;
315 case Vehicle.LINEAR_MOTOR_DIRECTION:
316 m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
317 len = m_linearMotorDirection.Length();
318 if (len > 30.0f)
319 m_linearMotorDirection *= (30.0f / len);
320 m_lmEfect = 1.0f; // turn it on
321 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
322 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
323 d.BodyEnable(rootPrim.Body);
324 break;
325 case Vehicle.LINEAR_MOTOR_OFFSET:
326 m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
327 len = m_linearMotorOffset.Length();
328 if (len > 100.0f)
329 m_linearMotorOffset *= (100.0f / len);
330 break;
331 }
332 }//end ProcessFloatVehicleParam
333
334 internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
335 {
336 float len;
337 float invtimestep = 1.0f / _pParentScene.ODE_STEPSIZE;
338 float timestep = _pParentScene.ODE_STEPSIZE;
339 switch (pParam)
340 {
341 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
342 if (pValue.X < timestep) pValue.X = timestep;
343 if (pValue.Y < timestep) pValue.Y = timestep;
344 if (pValue.Z < timestep) pValue.Z = timestep;
345
346 m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
347 break;
348 case Vehicle.ANGULAR_MOTOR_DIRECTION:
349 m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
350 // Limit requested angular speed to 2 rps= 4 pi rads/sec
351 len = m_angularMotorDirection.Length();
352 if (len > 12.566f)
353 m_angularMotorDirection *= (12.566f / len);
354 m_amEfect = 1.0f; // turn it on
355 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
356 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
357 d.BodyEnable(rootPrim.Body);
358 break;
359 case Vehicle.LINEAR_FRICTION_TIMESCALE:
360 if (pValue.X < timestep) pValue.X = timestep;
361 if (pValue.Y < timestep) pValue.Y = timestep;
362 if (pValue.Z < timestep) pValue.Z = timestep;
363 m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
364 break;
365 case Vehicle.LINEAR_MOTOR_DIRECTION:
366 m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
367 len = m_linearMotorDirection.Length();
368 if (len > 30.0f)
369 m_linearMotorDirection *= (30.0f / len);
370 m_lmEfect = 1.0f; // turn it on
371 if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
372 && !rootPrim.m_isSelected && !rootPrim.m_disabled)
373 d.BodyEnable(rootPrim.Body);
374 break;
375 case Vehicle.LINEAR_MOTOR_OFFSET:
376 m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
377 len = m_linearMotorOffset.Length();
378 if (len > 100.0f)
379 m_linearMotorOffset *= (100.0f / len);
380 break;
381 case Vehicle.BLOCK_EXIT:
382 m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
383 break;
384 }
385 }//end ProcessVectorVehicleParam
386
387 internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
388 {
389 switch (pParam)
390 {
391 case Vehicle.REFERENCE_FRAME:
392 m_referenceFrame = Quaternion.Inverse(pValue);
393 break;
394 case Vehicle.ROLL_FRAME:
395 m_RollreferenceFrame = pValue;
396 break;
397 }
398 }//end ProcessRotationVehicleParam
399
400 internal void ProcessVehicleFlags(int pParam, bool remove)
401 {
402 if (remove)
403 {
404 m_flags &= ~((VehicleFlag)pParam);
405 }
406 else
407 {
408 m_flags |= (VehicleFlag)pParam;
409 }
410 }//end ProcessVehicleFlags
411
412 internal void ProcessTypeChange(Vehicle pType)
413 {
414 float invtimestep = _pParentScene.ODE_STEPSIZE;
415 m_lmEfect = 0;
416 m_amEfect = 0;
417
418 m_linearMotorDirection = Vector3.Zero;
419 m_angularMotorDirection = Vector3.Zero;
420
421 m_BlockingEndPoint = Vector3.Zero;
422 m_RollreferenceFrame = Quaternion.Identity;
423 m_linearMotorOffset = Vector3.Zero;
424
425 m_referenceFrame = Quaternion.Identity;
426
427 // Set Defaults For Type
428 m_type = pType;
429 switch (pType)
430 {
431 case Vehicle.TYPE_NONE:
432 m_linearFrictionTimescale = new Vector3(1000, 1000, 1000);
433 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
434 m_linearMotorTimescale = 1000;
435 m_linearMotorDecayTimescale = 120;
436 m_angularMotorTimescale = 1000;
437 m_angularMotorDecayTimescale = 1000;
438 m_VhoverHeight = 0;
439 m_VhoverEfficiency = 1;
440 m_VhoverTimescale = 1000;
441 m_VehicleBuoyancy = 0;
442 m_linearDeflectionEfficiency = 0;
443 m_linearDeflectionTimescale = 1000;
444 m_angularDeflectionEfficiency = 0;
445 m_angularDeflectionTimescale = 1000;
446 m_bankingEfficiency = 0;
447 m_bankingMix = 1;
448 m_bankingTimescale = 1000;
449 m_verticalAttractionEfficiency = 0;
450 m_verticalAttractionTimescale = 1000;
451
452 m_flags = (VehicleFlag)0;
453 break;
454
455 case Vehicle.TYPE_SLED:
456 m_linearFrictionTimescale = new Vector3(30, 1, 1000);
457 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
458 m_linearMotorTimescale = 1000;
459 m_linearMotorDecayTimescale = 120 * invtimestep;
460 m_angularMotorTimescale = 1000;
461 m_angularMotorDecayTimescale = 120 * invtimestep;
462 m_VhoverHeight = 0;
463 m_VhoverEfficiency = 1;
464 m_VhoverTimescale = 10;
465 m_VehicleBuoyancy = 0;
466 m_linearDeflectionEfficiency = 1;
467 m_linearDeflectionTimescale = 1;
468 m_angularDeflectionEfficiency = 0;
469 m_angularDeflectionTimescale = 1000;
470 m_bankingEfficiency = 0;
471 m_bankingMix = 1;
472 m_bankingTimescale = 10;
473 m_flags &=
474 ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
475 VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
476 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
477 break;
478 case Vehicle.TYPE_CAR:
479 m_linearFrictionTimescale = new Vector3(100, 2, 1000);
480 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
481 m_linearMotorTimescale = 1;
482 m_linearMotorDecayTimescale = 60 * invtimestep;
483 m_angularMotorTimescale = 1;
484 m_angularMotorDecayTimescale = 0.8f * invtimestep;
485 m_VhoverHeight = 0;
486 m_VhoverEfficiency = 0;
487 m_VhoverTimescale = 1000;
488 m_VehicleBuoyancy = 0;
489 m_linearDeflectionEfficiency = 1;
490 m_linearDeflectionTimescale = 2;
491 m_angularDeflectionEfficiency = 0;
492 m_angularDeflectionTimescale = 10;
493 m_verticalAttractionEfficiency = 1f;
494 m_verticalAttractionTimescale = 10f;
495 m_bankingEfficiency = -0.2f;
496 m_bankingMix = 1;
497 m_bankingTimescale = 1;
498 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
499 m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY |
500 VehicleFlag.LIMIT_MOTOR_UP | VehicleFlag.HOVER_UP_ONLY);
501 break;
502 case Vehicle.TYPE_BOAT:
503 m_linearFrictionTimescale = new Vector3(10, 3, 2);
504 m_angularFrictionTimescale = new Vector3(10, 10, 10);
505 m_linearMotorTimescale = 5;
506 m_linearMotorDecayTimescale = 60 * invtimestep;
507 m_angularMotorTimescale = 4;
508 m_angularMotorDecayTimescale = 4 * invtimestep;
509 m_VhoverHeight = 0;
510 m_VhoverEfficiency = 0.5f;
511 m_VhoverTimescale = 2;
512 m_VehicleBuoyancy = 1;
513 m_linearDeflectionEfficiency = 0.5f;
514 m_linearDeflectionTimescale = 3;
515 m_angularDeflectionEfficiency = 0.5f;
516 m_angularDeflectionTimescale = 5;
517 m_verticalAttractionEfficiency = 0.5f;
518 m_verticalAttractionTimescale = 5f;
519 m_bankingEfficiency = -0.3f;
520 m_bankingMix = 0.8f;
521 m_bankingTimescale = 1;
522 m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
523 VehicleFlag.HOVER_GLOBAL_HEIGHT |
524 VehicleFlag.HOVER_UP_ONLY |
525 VehicleFlag.LIMIT_ROLL_ONLY);
526 m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
527 VehicleFlag.LIMIT_MOTOR_UP |
528 VehicleFlag.HOVER_WATER_ONLY);
529 break;
530 case Vehicle.TYPE_AIRPLANE:
531 m_linearFrictionTimescale = new Vector3(200, 10, 5);
532 m_angularFrictionTimescale = new Vector3(20, 20, 20);
533 m_linearMotorTimescale = 2;
534 m_linearMotorDecayTimescale = 60 * invtimestep;
535 m_angularMotorTimescale = 4;
536 m_angularMotorDecayTimescale = 8 * invtimestep;
537 m_VhoverHeight = 0;
538 m_VhoverEfficiency = 0.5f;
539 m_VhoverTimescale = 1000;
540 m_VehicleBuoyancy = 0;
541 m_linearDeflectionEfficiency = 0.5f;
542 m_linearDeflectionTimescale = 0.5f;
543 m_angularDeflectionEfficiency = 1;
544 m_angularDeflectionTimescale = 2;
545 m_verticalAttractionEfficiency = 0.9f;
546 m_verticalAttractionTimescale = 2f;
547 m_bankingEfficiency = 1;
548 m_bankingMix = 0.7f;
549 m_bankingTimescale = 2;
550 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
551 VehicleFlag.HOVER_TERRAIN_ONLY |
552 VehicleFlag.HOVER_GLOBAL_HEIGHT |
553 VehicleFlag.HOVER_UP_ONLY |
554 VehicleFlag.NO_DEFLECTION_UP |
555 VehicleFlag.LIMIT_MOTOR_UP);
556 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
557 break;
558 case Vehicle.TYPE_BALLOON:
559 m_linearFrictionTimescale = new Vector3(5, 5, 5);
560 m_angularFrictionTimescale = new Vector3(10, 10, 10);
561 m_linearMotorTimescale = 5;
562 m_linearMotorDecayTimescale = 60 * invtimestep;
563 m_angularMotorTimescale = 6;
564 m_angularMotorDecayTimescale = 10 * invtimestep;
565 m_VhoverHeight = 5;
566 m_VhoverEfficiency = 0.8f;
567 m_VhoverTimescale = 10;
568 m_VehicleBuoyancy = 1;
569 m_linearDeflectionEfficiency = 0;
570 m_linearDeflectionTimescale = 5 * invtimestep;
571 m_angularDeflectionEfficiency = 0;
572 m_angularDeflectionTimescale = 5;
573 m_verticalAttractionEfficiency = 0f;
574 m_verticalAttractionTimescale = 1000f;
575 m_bankingEfficiency = 0;
576 m_bankingMix = 0.7f;
577 m_bankingTimescale = 5;
578 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
579 VehicleFlag.HOVER_TERRAIN_ONLY |
580 VehicleFlag.HOVER_UP_ONLY |
581 VehicleFlag.NO_DEFLECTION_UP |
582 VehicleFlag.LIMIT_MOTOR_UP);
583 m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY |
584 VehicleFlag.HOVER_GLOBAL_HEIGHT);
585 break;
586 }
587
588 }//end SetDefaultsForType
589
590 internal void Stop()
591 {
592 m_lmEfect = 0;
593 m_amEfect = 0;
594 }
595
596 public static Vector3 Xrot(Quaternion rot)
597 {
598 Vector3 vec;
599 rot.Normalize(); // just in case
600 vec.X = 2 * (rot.X * rot.X + rot.W * rot.W) - 1;
601 vec.Y = 2 * (rot.X * rot.Y + rot.Z * rot.W);
602 vec.Z = 2 * (rot.X * rot.Z - rot.Y * rot.W);
603 return vec;
604 }
605
606 public static Vector3 Zrot(Quaternion rot)
607 {
608 Vector3 vec;
609 rot.Normalize(); // just in case
610 vec.X = 2 * (rot.X * rot.Z + rot.Y * rot.W);
611 vec.Y = 2 * (rot.Y * rot.Z - rot.X * rot.W);
612 vec.Z = 2 * (rot.Z * rot.Z + rot.W * rot.W) - 1;
613
614 return vec;
615 }
616
617 private const float halfpi = 0.5f * (float)Math.PI;
618
619 public static Vector3 ubitRot2Euler(Quaternion rot)
620 {
621 // returns roll in X
622 // pitch in Y
623 // yaw in Z
624 Vector3 vec;
625
626 // assuming rot is normalised
627 // rot.Normalize();
628
629 float zX = rot.X * rot.Z + rot.Y * rot.W;
630
631 if (zX < -0.49999f)
632 {
633 vec.X = 0;
634 vec.Y = -halfpi;
635 vec.Z = (float)(-2d * Math.Atan(rot.X / rot.W));
636 }
637 else if (zX > 0.49999f)
638 {
639 vec.X = 0;
640 vec.Y = halfpi;
641 vec.Z = (float)(2d * Math.Atan(rot.X / rot.W));
642 }
643 else
644 {
645 vec.Y = (float)Math.Asin(2 * zX);
646
647 float sqw = rot.W * rot.W;
648
649 float minuszY = rot.X * rot.W - rot.Y * rot.Z;
650 float zZ = rot.Z * rot.Z + sqw - 0.5f;
651
652 vec.X = (float)Math.Atan2(minuszY, zZ);
653
654 float yX = rot.Z * rot.W - rot.X * rot.Y; //( have negative ?)
655 float yY = rot.X * rot.X + sqw - 0.5f;
656 vec.Z = (float)Math.Atan2(yX, yY);
657 }
658 return vec;
659 }
660
661 public static void GetRollPitch(Quaternion rot, out float roll, out float pitch)
662 {
663 // assuming rot is normalised
664 // rot.Normalize();
665
666 float zX = rot.X * rot.Z + rot.Y * rot.W;
667
668 if (zX < -0.49999f)
669 {
670 roll = 0;
671 pitch = -halfpi;
672 }
673 else if (zX > 0.49999f)
674 {
675 roll = 0;
676 pitch = halfpi;
677 }
678 else
679 {
680 pitch = (float)Math.Asin(2 * zX);
681
682 float minuszY = rot.X * rot.W - rot.Y * rot.Z;
683 float zZ = rot.Z * rot.Z + rot.W * rot.W - 0.5f;
684
685 roll = (float)Math.Atan2(minuszY, zZ);
686 }
687 return ;
688 }
689
690 internal void Step()//float pTimestep)
691 {
692 IntPtr Body = rootPrim.Body;
693
694 d.Quaternion rot = d.BodyGetQuaternion(Body);
695 Quaternion objrotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W); // rotq = rotation of object
696 Quaternion rotq = objrotq; // rotq = rotation of object
697 rotq *= m_referenceFrame; // rotq is now rotation in vehicle reference frame
698 Quaternion irotq = Quaternion.Inverse(rotq);
699
700 d.Vector3 dvtmp;
701 Vector3 tmpV;
702 Vector3 curVel; // velocity in world
703 Vector3 curAngVel; // angular velocity in world
704 Vector3 force = Vector3.Zero; // actually linear aceleration until mult by mass in world frame
705 Vector3 torque = Vector3.Zero;// actually angular aceleration until mult by Inertia in vehicle frame
706 d.Vector3 dtorque = new d.Vector3();
707
708 dvtmp = d.BodyGetLinearVel(Body);
709 curVel.X = dvtmp.X;
710 curVel.Y = dvtmp.Y;
711 curVel.Z = dvtmp.Z;
712 Vector3 curLocalVel = curVel * irotq; // current velocity in local
713
714 dvtmp = d.BodyGetAngularVel(Body);
715 curAngVel.X = dvtmp.X;
716 curAngVel.Y = dvtmp.Y;
717 curAngVel.Z = dvtmp.Z;
718 Vector3 curLocalAngVel = curAngVel * irotq; // current angular velocity in local
719
720 // linear motor
721 if (m_lmEfect > 0.01 && m_linearMotorTimescale < 1000)
722 {
723 tmpV = m_linearMotorDirection - curLocalVel; // velocity error
724 tmpV *= m_lmEfect / m_linearMotorTimescale; // error to correct in this timestep
725 tmpV *= rotq; // to world
726
727 if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != 0)
728 tmpV.Z = 0;
729
730 if (m_linearMotorOffset.X != 0 || m_linearMotorOffset.Y != 0 || m_linearMotorOffset.Z != 0)
731 {
732 // have offset, do it now
733 tmpV *= rootPrim.Mass;
734 d.BodyAddForceAtRelPos(Body, tmpV.X, tmpV.Y, tmpV.Z, m_linearMotorOffset.X, m_linearMotorOffset.Y, m_linearMotorOffset.Z);
735 }
736 else
737 {
738 force.X += tmpV.X;
739 force.Y += tmpV.Y;
740 force.Z += tmpV.Z;
741 }
742 m_lmEfect *= (1.0f - 1.0f / m_linearMotorDecayTimescale);
743 }
744 else
745 m_lmEfect = 0;
746
747 // friction
748 if (curLocalVel.X != 0 || curLocalVel.Y != 0 || curLocalVel.Z != 0)
749 {
750 tmpV.X = -curLocalVel.X / m_linearFrictionTimescale.X;
751 tmpV.Y = -curLocalVel.Y / m_linearFrictionTimescale.Y;
752 tmpV.Z = -curLocalVel.Z / m_linearFrictionTimescale.Z;
753 tmpV *= rotq; // to world
754 force.X += tmpV.X;
755 force.Y += tmpV.Y;
756 force.Z += tmpV.Z;
757 }
758
759 // hover
760 if (m_VhoverTimescale < 300)
761 {
762 d.Vector3 pos = d.BodyGetPosition(Body);
763
764 // default to global
765 float perr = m_VhoverHeight - pos.Z;;
766
767 if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
768 {
769 perr += _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y);
770 }
771 else if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0)
772 {
773 perr += _pParentScene.GetWaterLevel();
774 }
775 else if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) == 0)
776 {
777 float t = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y);
778 float w = _pParentScene.GetWaterLevel();
779 if (t > w)
780 perr += t;
781 else
782 perr += w;
783 }
784
785 if ((m_flags & VehicleFlag.HOVER_UP_ONLY) == 0 || perr > 0)
786 {
787 force.Z += (perr / m_VhoverTimescale / m_VhoverTimescale - curVel.Z * m_VhoverEfficiency) / _pParentScene.ODE_STEPSIZE;
788 force.Z += _pParentScene.gravityz * (1f - m_VehicleBuoyancy);
789 }
790 else // no buoyancy
791 force.Z += _pParentScene.gravityz;
792 }
793 else
794 {
795 // default gravity and buoancy
796 force.Z += _pParentScene.gravityz * (1f - m_VehicleBuoyancy);
797 }
798
799 // linear deflection
800 if (m_linearDeflectionEfficiency > 0)
801 {
802 float len = curVel.Length();
803 Vector3 atAxis;
804 atAxis = Xrot(rotq); // where are we pointing to
805 atAxis *= len; // make it same size as world velocity vector
806 tmpV = -atAxis; // oposite direction
807 atAxis -= curVel; // error to one direction
808 len = atAxis.LengthSquared();
809 tmpV -= curVel; // error to oposite
810 float lens = tmpV.LengthSquared();
811 if (len > 0.01 || lens > 0.01) // do nothing if close enougth
812 {
813 if (len < lens)
814 tmpV = atAxis;
815
816 tmpV *= (m_linearDeflectionEfficiency / m_linearDeflectionTimescale); // error to correct in this timestep
817 force.X += tmpV.X;
818 force.Y += tmpV.Y;
819 if ((m_flags & VehicleFlag.NO_DEFLECTION_UP) == 0)
820 force.Z += tmpV.Z;
821 }
822 }
823
824 // angular motor
825 if (m_amEfect > 0.01 && m_angularMotorTimescale < 1000)
826 {
827 tmpV = m_angularMotorDirection - curLocalAngVel; // velocity error
828 tmpV *= m_amEfect / m_angularMotorTimescale; // error to correct in this timestep
829 torque.X += tmpV.X;
830 torque.Y += tmpV.Y;
831 torque.Z += tmpV.Z;
832 m_amEfect *= (1 - 1.0f / m_angularMotorDecayTimescale);
833 }
834 else
835 m_amEfect = 0;
836
837 // angular friction
838 if (curLocalAngVel.X != 0 || curLocalAngVel.Y != 0 || curLocalAngVel.Z != 0)
839 {
840 torque.X -= curLocalAngVel.X / m_angularFrictionTimescale.X;
841 torque.Y -= curLocalAngVel.Y / m_angularFrictionTimescale.Y;
842 torque.Z -= curLocalAngVel.Z / m_angularFrictionTimescale.Z;
843 }
844
845 // angular deflection
846 if (m_angularDeflectionEfficiency > 0)
847 {
848 Vector3 dirv;
849
850 if (curLocalVel.X > 0.01f)
851 dirv = curLocalVel;
852 else if (curLocalVel.X < -0.01f)
853 // use oposite
854 dirv = -curLocalVel;
855 else
856 {
857 // make it fall into small positive x case
858 dirv.X = 0.01f;
859 dirv.Y = curLocalVel.Y;
860 dirv.Z = curLocalVel.Z;
861 }
862
863 float ftmp = m_angularDeflectionEfficiency / m_angularDeflectionTimescale;
864
865 if (Math.Abs(dirv.Z) > 0.01)
866 {
867 torque.Y += - (float)Math.Atan2(dirv.Z, dirv.X) * ftmp;
868 }
869
870 if (Math.Abs(dirv.Y) > 0.01)
871 {
872 torque.Z += (float)Math.Atan2(dirv.Y, dirv.X) * ftmp;
873 }
874 }
875
876 // vertical atractor
877 if (m_verticalAttractionTimescale < 300)
878 {
879 float roll;
880 float pitch;
881
882 GetRollPitch(irotq, out roll, out pitch);
883
884 float ftmp = 1.0f / m_verticalAttractionTimescale / m_verticalAttractionTimescale / _pParentScene.ODE_STEPSIZE;
885 float ftmp2 = m_verticalAttractionEfficiency / _pParentScene.ODE_STEPSIZE;
886
887 if (Math.Abs(roll) > 0.01) // roll
888 {
889 torque.X -= -roll * ftmp + curLocalAngVel.X * ftmp2;
890 }
891
892 if (Math.Abs(pitch) > 0.01 && ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) == 0)) // pitch
893 {
894 torque.Y -= -pitch * ftmp + curLocalAngVel.Y * ftmp2;
895 }
896
897 if (m_bankingEfficiency != 0 && Math.Abs(roll) > 0.01)
898 {
899 float broll = roll * m_bankingEfficiency; ;
900 if (m_bankingMix != 0)
901 {
902 float vfact = Math.Abs(curLocalVel.X) / 10.0f;
903 if (vfact > 1.0f) vfact = 1.0f;
904 if (curLocalVel.X >= 0)
905 broll *= ((1 - m_bankingMix) + vfact);
906 else
907 broll *= -((1 - m_bankingMix) + vfact);
908 }
909 broll = (broll - curLocalAngVel.Z) / m_bankingTimescale;
910 // torque.Z += broll;
911
912 // make z rot be in world Z not local as seems to be in sl
913 tmpV.X = 0;
914 tmpV.Y = 0;
915 tmpV.Z = broll;
916 tmpV *= irotq;
917
918 torque.X += tmpV.X;
919 torque.Y += tmpV.Y;
920 torque.Z += tmpV.Z;
921 }
922 }
923
924 d.Mass dmass;
925 d.BodyGetMass(Body,out dmass);
926
927 if (force.X != 0 || force.Y != 0 || force.Z != 0)
928 {
929 force *= dmass.mass;
930 d.BodySetForce(Body, force.X, force.Y, force.Z);
931 }
932
933 if (torque.X != 0 || torque.Y != 0 || torque.Z != 0)
934 {
935 torque *= m_referenceFrame; // to object frame
936 dtorque.X = torque.X;
937 dtorque.Y = torque.Y;
938 dtorque.Z = torque.Z;
939
940 d.MultiplyM3V3(out dvtmp, ref dmass.I, ref dtorque);
941 d.BodyAddRelTorque(Body, dvtmp.X, dvtmp.Y, dvtmp.Z); // add torque in object frame
942 }
943 }
944 }
945}
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
new file mode 100644
index 0000000..0ccdbc0
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
@@ -0,0 +1,3300 @@
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
70 protected bool m_building;
71 private Quaternion m_lastorientation = new Quaternion();
72 private Quaternion _orientation;
73
74 private Vector3 _position;
75 private Vector3 _velocity;
76 private Vector3 _torque;
77 private Vector3 m_lastVelocity;
78 private Vector3 m_lastposition;
79 private Vector3 m_rotationalVelocity;
80 private Vector3 _size;
81 private Vector3 _acceleration;
82 private Vector3 m_angularlock = Vector3.One;
83 private IntPtr Amotor = IntPtr.Zero;
84
85 private Vector3 m_force;
86 private Vector3 m_forceacc;
87 private Vector3 m_angularForceacc;
88
89 private Vector3 m_PIDTarget;
90 private float m_PIDTau;
91 private float PID_D = 35f;
92 private float PID_G = 25f;
93 private bool m_usePID;
94
95 // KF: These next 7 params apply to llSetHoverHeight(float height, integer water, float tau),
96 // and are for non-VEHICLES only.
97
98 private float m_PIDHoverHeight;
99 private float m_PIDHoverTau;
100 private bool m_useHoverPID;
101 private PIDHoverType m_PIDHoverType = PIDHoverType.Ground;
102 private float m_targetHoverHeight;
103 private float m_groundHeight;
104 private float m_waterHeight;
105 private float m_buoyancy; //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle.
106
107 private int body_autodisable_frames = 20;
108
109 private const CollisionCategories m_default_collisionFlags = (CollisionCategories.Geom
110 | CollisionCategories.Space
111 | CollisionCategories.Body
112 | CollisionCategories.Character
113 );
114// private bool m_collidesLand = true;
115 private bool m_collidesWater;
116 public bool m_returnCollisions;
117
118 // Default we're a Geometry
119 private CollisionCategories m_collisionCategories = (CollisionCategories.Geom);
120
121 // Default, Collide with Other Geometries, spaces and Bodies
122 private CollisionCategories m_collisionFlags = m_default_collisionFlags;
123
124 public bool m_disabled;
125
126
127 public uint m_localID;
128
129 private PrimitiveBaseShape _pbs;
130 public OdeScene _parent_scene;
131
132 /// <summary>
133 /// The physics space which contains prim geometry
134 /// </summary>
135 public IntPtr m_targetSpace = IntPtr.Zero;
136
137 public IntPtr prim_geom;
138 public IntPtr _triMeshData;
139
140 private PhysicsActor _parent;
141
142 private List<OdePrim> childrenPrim = new List<OdePrim>();
143
144 private bool m_iscolliding;
145
146 public bool m_isSelected;
147 private bool m_delaySelect;
148 private bool m_lastdoneSelected;
149 public bool m_outbounds;
150
151 internal bool m_isVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively
152
153 private bool m_throttleUpdates;
154 private int throttleCounter;
155 public float m_collisionscore;
156 int m_colliderfilter = 0;
157
158 private float m_density = 10.000006836f; // Aluminum g/cm3;
159
160 public bool _zeroFlag;
161 private bool m_lastUpdateSent;
162
163 public IntPtr Body = IntPtr.Zero;
164 public String Name { get; private set; }
165 private Vector3 _target_velocity;
166
167 public Vector3 primOOBsize; // prim real dimensions from mesh
168 public Vector3 primOOBoffset; // its centroid out of mesh or rest aabb
169 public float primOOBradiusSQ;
170 public d.Mass primdMass; // prim inertia information on it's own referencial
171 float primMass; // prim own mass
172 float _mass; // object mass acording to case
173 private bool hasOOBoffsetFromMesh = false; // if true we did compute it form mesh centroid, else from aabb
174
175 public int givefakepos = 0;
176 private Vector3 fakepos;
177 public int givefakeori = 0;
178 private Quaternion fakeori;
179
180 public int m_eventsubscription;
181 private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate();
182
183 public volatile bool childPrim;
184
185 public ODEDynamics m_vehicle;
186
187 internal int m_material = (int)Material.Wood;
188 protected ContactData primContactData = new ContactData { mu = 0f, bounce = 0.1f };
189
190 /// <summary>
191 /// Is this prim subject to physics? Even if not, it's still solid for collision purposes.
192 /// </summary>
193 public override bool IsPhysical // this is not reliable for internal use
194 {
195 get { return m_fakeisphysical; }
196 set
197 {
198 m_fakeisphysical = value; // we show imediatly to outside that we changed physical
199 // and also to stop imediatly some updates
200 // but real change will only happen in taintprocessing
201
202 if (!value) // Zero the remembered last velocity
203 m_lastVelocity = Vector3.Zero;
204 AddChange(changes.Physical, value);
205 }
206 }
207
208 public override bool Building // this is not reliable for internal use
209 {
210 get { return m_building; }
211 set
212 {
213 if (value)
214 m_building = true;
215 AddChange(changes.building, value);
216 }
217 }
218
219 public override ContactData ContactData
220 {
221 get
222 {
223 return primContactData;
224 }
225 }
226
227 public override int PhysicsActorType
228 {
229 get { return (int)ActorTypes.Prim; }
230 set { return; }
231 }
232
233 public override bool SetAlwaysRun
234 {
235 get { return false; }
236 set { return; }
237 }
238
239 public override uint LocalID
240 {
241 get
242 {
243 return m_localID;
244 }
245 set
246 {
247 //m_log.Info("[PHYSICS]: Setting TrackerID: " + value);
248 m_localID = value;
249 }
250 }
251
252 public override bool Grabbed
253 {
254 set { return; }
255 }
256
257 public override bool Selected
258 {
259 set
260 {
261 if (value)
262 m_isSelected = value; // if true set imediatly to stop moves etc
263 AddChange(changes.Selected, value);
264 }
265 }
266
267 public override bool Flying
268 {
269 // no flying prims for you
270 get { return false; }
271 set { }
272 }
273
274 public override bool IsColliding
275 {
276 get { return m_iscolliding; }
277 set
278 {
279 if (value)
280 {
281 m_colliderfilter += 2;
282 if (m_colliderfilter > 2)
283 m_colliderfilter = 2;
284 }
285 else
286 {
287 m_colliderfilter--;
288 if (m_colliderfilter < 0)
289 m_colliderfilter = 0;
290 }
291
292 if (m_colliderfilter == 0)
293 m_iscolliding = false;
294 else
295 m_iscolliding = true;
296 }
297 }
298
299 public override bool CollidingGround
300 {
301 get { return false; }
302 set { return; }
303 }
304
305 public override bool CollidingObj
306 {
307 get { return false; }
308 set { return; }
309 }
310
311 public override bool ThrottleUpdates
312 {
313 get { return m_throttleUpdates; }
314 set { m_throttleUpdates = value; }
315 }
316
317 public override bool Stopped
318 {
319 get { return _zeroFlag; }
320 }
321
322 public override Vector3 Position
323 {
324 get
325 {
326 if (givefakepos > 0)
327 return fakepos;
328 else
329 return _position;
330 }
331
332 set
333 {
334 fakepos = value;
335 givefakepos++;
336 AddChange(changes.Position, value);
337 }
338 }
339
340 public override Vector3 Size
341 {
342 get { return _size; }
343 set
344 {
345 if (value.IsFinite())
346 {
347 AddChange(changes.Size, value);
348 }
349 else
350 {
351 m_log.WarnFormat("[PHYSICS]: Got NaN Size on object {0}", Name);
352 }
353 }
354 }
355
356 public override float Mass
357 {
358 get { return _mass; }
359 }
360
361 public override Vector3 Force
362 {
363 //get { return Vector3.Zero; }
364 get { return m_force; }
365 set
366 {
367 if (value.IsFinite())
368 {
369 AddChange(changes.Force, value);
370 }
371 else
372 {
373 m_log.WarnFormat("[PHYSICS]: NaN in Force Applied to an Object {0}", Name);
374 }
375 }
376 }
377
378 public override void SetVolumeDetect(int param)
379 {
380 AddChange(changes.VolumeDtc, (param != 0));
381 }
382
383 public override Vector3 GeometricCenter
384 {
385 get
386 {
387 return Vector3.Zero;
388 }
389 }
390
391 public override Vector3 CenterOfMass
392 {
393 get
394 {
395 d.Vector3 dtmp;
396 if (IsPhysical && !childPrim && Body != IntPtr.Zero)
397 {
398 dtmp = d.BodyGetPosition(Body);
399 return new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
400 }
401 else if (prim_geom != IntPtr.Zero)
402 {
403 d.Quaternion dq;
404 d.GeomCopyQuaternion(prim_geom, out dq);
405 Quaternion q;
406 q.X = dq.X;
407 q.Y = dq.Y;
408 q.Z = dq.Z;
409 q.W = dq.W;
410
411 Vector3 vtmp = primOOBoffset * q;
412 dtmp = d.GeomGetPosition(prim_geom);
413 return new Vector3(dtmp.X + vtmp.X, dtmp.Y + vtmp.Y, dtmp.Z + vtmp.Z);
414 }
415 else
416 return Vector3.Zero;
417 }
418 }
419 /*
420 public override Vector3 PrimOOBsize
421 {
422 get
423 {
424 return primOOBsize;
425 }
426 }
427
428 public override Vector3 PrimOOBoffset
429 {
430 get
431 {
432 return primOOBoffset;
433 }
434 }
435
436 public override float PrimOOBRadiusSQ
437 {
438 get
439 {
440 return primOOBradiusSQ;
441 }
442 }
443 */
444 public override PrimitiveBaseShape Shape
445 {
446 set
447 {
448 AddChange(changes.Shape, value);
449 }
450 }
451
452 public override Vector3 Velocity
453 {
454 get
455 {
456 // Averate previous velocity with the new one so
457 // client object interpolation works a 'little' better
458 if (_zeroFlag)
459 return Vector3.Zero;
460 return _velocity;
461 }
462 set
463 {
464 if (value.IsFinite())
465 {
466 AddChange(changes.Velocity, value);
467 // _velocity = value;
468
469 }
470 else
471 {
472 m_log.WarnFormat("[PHYSICS]: Got NaN Velocity in Object {0}", Name);
473 }
474
475 }
476 }
477
478 public override Vector3 Torque
479 {
480 get
481 {
482 if (!IsPhysical || Body == IntPtr.Zero)
483 return Vector3.Zero;
484
485 return _torque;
486 }
487
488 set
489 {
490 if (value.IsFinite())
491 {
492 AddChange(changes.Torque, value);
493 }
494 else
495 {
496 m_log.WarnFormat("[PHYSICS]: Got NaN Torque in Object {0}", Name);
497 }
498 }
499 }
500
501 public override float CollisionScore
502 {
503 get { return m_collisionscore; }
504 set { m_collisionscore = value; }
505 }
506
507 public override bool Kinematic
508 {
509 get { return false; }
510 set { }
511 }
512
513 public override Quaternion Orientation
514 {
515 get
516 {
517 if (givefakeori > 0)
518 return fakeori;
519 else
520
521 return _orientation;
522 }
523 set
524 {
525 if (QuaternionIsFinite(value))
526 {
527 fakeori = value;
528 givefakeori++;
529 AddChange(changes.Orientation, value);
530 }
531 else
532 m_log.WarnFormat("[PHYSICS]: Got NaN quaternion Orientation from Scene in Object {0}", Name);
533
534 }
535 }
536
537 public override Vector3 Acceleration
538 {
539 get { return _acceleration; }
540 set { }
541 }
542
543 public override Vector3 RotationalVelocity
544 {
545 get
546 {
547 Vector3 pv = Vector3.Zero;
548 if (_zeroFlag)
549 return pv;
550 m_lastUpdateSent = false;
551
552 if (m_rotationalVelocity.ApproxEquals(pv, 0.0001f))
553 return pv;
554
555 return m_rotationalVelocity;
556 }
557 set
558 {
559 if (value.IsFinite())
560 {
561 m_rotationalVelocity = value;
562 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
563 d.BodyEnable(Body);
564 }
565 else
566 {
567 m_log.WarnFormat("[PHYSICS]: Got NaN RotationalVelocity in Object {0}", Name);
568 }
569 }
570 }
571
572
573 public override float Buoyancy
574 {
575 get { return m_buoyancy; }
576 set
577 {
578 m_buoyancy = value;
579 }
580 }
581
582 public override bool FloatOnWater
583 {
584 set
585 {
586 AddChange(changes.CollidesWater, value);
587 }
588 }
589
590 public override Vector3 PIDTarget
591 {
592 set
593 {
594 if (value.IsFinite())
595 {
596 m_PIDTarget = value;
597 }
598 else
599 m_log.WarnFormat("[PHYSICS]: Got NaN PIDTarget from Scene on Object {0}", Name);
600 }
601 }
602
603 public override bool PIDActive { set { m_usePID = value; } }
604 public override float PIDTau { set { m_PIDTau = value; } }
605
606 public override float PIDHoverHeight { set { m_PIDHoverHeight = value; ; } }
607 public override bool PIDHoverActive { set { m_useHoverPID = value; } }
608 public override PIDHoverType PIDHoverType { set { m_PIDHoverType = value; } }
609 public override float PIDHoverTau { set { m_PIDHoverTau = value; } }
610
611 public override Quaternion APIDTarget { set { return; } }
612
613 public override bool APIDActive { set { return; } }
614
615 public override float APIDStrength { set { return; } }
616
617 public override float APIDDamping { set { return; } }
618
619 public override int VehicleType
620 {
621 // we may need to put a fake on this
622 get
623 {
624 if (m_vehicle == null)
625 return (int)Vehicle.TYPE_NONE;
626 else
627 return (int)m_vehicle.Type;
628 }
629 set
630 {
631 AddChange(changes.VehicleType, value);
632 }
633 }
634
635 public override void VehicleFloatParam(int param, float value)
636 {
637 strVehicleFloatParam fp = new strVehicleFloatParam();
638 fp.param = param;
639 fp.value = value;
640 AddChange(changes.VehicleFloatParam, fp);
641 }
642
643 public override void VehicleVectorParam(int param, Vector3 value)
644 {
645 strVehicleVectorParam fp = new strVehicleVectorParam();
646 fp.param = param;
647 fp.value = value;
648 AddChange(changes.VehicleVectorParam, fp);
649 }
650
651 public override void VehicleRotationParam(int param, Quaternion value)
652 {
653 strVehicleQuatParam fp = new strVehicleQuatParam();
654 fp.param = param;
655 fp.value = value;
656 AddChange(changes.VehicleRotationParam, fp);
657 }
658
659 public override void VehicleFlags(int param, bool value)
660 {
661 strVehicleBoolParam bp = new strVehicleBoolParam();
662 bp.param = param;
663 bp.value = value;
664 AddChange(changes.VehicleFlags, bp);
665 }
666
667 public override void SetVehicle(object vdata)
668 {
669 AddChange(changes.SetVehicle, vdata);
670 }
671 public void SetAcceleration(Vector3 accel)
672 {
673 _acceleration = accel;
674 }
675
676 public override void AddForce(Vector3 force, bool pushforce)
677 {
678 if (force.IsFinite())
679 {
680 AddChange(changes.AddForce, force / _parent_scene.ODE_STEPSIZE);
681 }
682 else
683 {
684 m_log.WarnFormat("[PHYSICS]: Got Invalid linear force vector from Scene in Object {0}", Name);
685 }
686 //m_log.Info("[PHYSICS]: Added Force:" + force.ToString() + " to prim at " + Position.ToString());
687 }
688
689 public override void AddAngularForce(Vector3 force, bool pushforce)
690 {
691 if (force.IsFinite())
692 {
693 AddChange(changes.AddAngForce, force / _parent_scene.ODE_STEPSIZE);
694 }
695 else
696 {
697 m_log.WarnFormat("[PHYSICS]: Got Invalid Angular force vector from Scene in Object {0}", Name);
698 }
699 }
700
701 public override void CrossingFailure()
702 {
703 if (m_outbounds)
704 {
705 _position.X = Util.Clip(_position.X, 0.5f, _parent_scene.WorldExtents.X - 0.5f);
706 _position.Y = Util.Clip(_position.Y, 0.5f, _parent_scene.WorldExtents.Y - 0.5f);
707 _position.Z = Util.Clip(_position.Z + 0.2f, -100f, 50000f);
708
709 m_lastposition = _position;
710 _velocity.X = 0;
711 _velocity.Y = 0;
712 _velocity.Z = 0;
713
714 m_lastVelocity = _velocity;
715 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
716 m_vehicle.Stop();
717
718 if(Body != IntPtr.Zero)
719 d.BodySetLinearVel(Body, 0, 0, 0); // stop it
720 if (prim_geom != IntPtr.Zero)
721 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
722
723 m_outbounds = false;
724 changeDisable(false);
725 base.RequestPhysicsterseUpdate();
726 }
727 }
728
729 public override void SetMomentum(Vector3 momentum)
730 {
731 }
732
733 public override void SetMaterial(int pMaterial)
734 {
735 m_material = pMaterial;
736 primContactData.mu = _parent_scene.m_materialContactsData[pMaterial].mu;
737 primContactData.bounce = _parent_scene.m_materialContactsData[pMaterial].bounce;
738 }
739
740 public void setPrimForRemoval()
741 {
742 AddChange(changes.Remove, null);
743 }
744
745 public override void link(PhysicsActor obj)
746 {
747 AddChange(changes.Link, obj);
748 }
749
750 public override void delink()
751 {
752 AddChange(changes.DeLink, null);
753 }
754
755 public override void LockAngularMotion(Vector3 axis)
756 {
757 // reverse the zero/non zero values for ODE.
758 if (axis.IsFinite())
759 {
760 axis.X = (axis.X > 0) ? 1f : 0f;
761 axis.Y = (axis.Y > 0) ? 1f : 0f;
762 axis.Z = (axis.Z > 0) ? 1f : 0f;
763 m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z);
764 AddChange(changes.AngLock, axis);
765 }
766 else
767 {
768 m_log.WarnFormat("[PHYSICS]: Got NaN locking axis from Scene on Object {0}", Name);
769 }
770 }
771
772 public override void SubscribeEvents(int ms)
773 {
774 m_eventsubscription = ms;
775 _parent_scene.AddCollisionEventReporting(this);
776 }
777
778 public override void UnSubscribeEvents()
779 {
780 _parent_scene.RemoveCollisionEventReporting(this);
781 m_eventsubscription = 0;
782 }
783
784 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
785 {
786 if (CollisionEventsThisFrame == null)
787 CollisionEventsThisFrame = new CollisionEventUpdate();
788
789 CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
790 }
791
792 public void SendCollisions()
793 {
794 if (CollisionEventsThisFrame == null)
795 return;
796
797 base.SendCollisionUpdate(CollisionEventsThisFrame);
798
799 if (CollisionEventsThisFrame.m_objCollisionList.Count == 0)
800 CollisionEventsThisFrame = null;
801 else
802 CollisionEventsThisFrame = new CollisionEventUpdate();
803 }
804
805 public override bool SubscribedEvents()
806 {
807 if (m_eventsubscription > 0)
808 return true;
809 return false;
810 }
811
812
813 public OdePrim(String primName, OdeScene parent_scene, Vector3 pos, Vector3 size,
814 Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
815 {
816 Name = primName;
817
818 m_vehicle = null;
819
820 if (!pos.IsFinite())
821 {
822 pos = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f),
823 parent_scene.GetTerrainHeightAtXY(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f)) + 0.5f);
824 m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Position for {0}", Name);
825 }
826 _position = pos;
827 givefakepos = 0;
828
829 PID_D = parent_scene.bodyPIDD;
830 PID_G = parent_scene.bodyPIDG;
831 m_density = parent_scene.geomDefaultDensity;
832 // m_tensor = parent_scene.bodyMotorJointMaxforceTensor;
833 body_autodisable_frames = parent_scene.bodyFramesAutoDisable;
834
835 prim_geom = IntPtr.Zero;
836 Body = IntPtr.Zero;
837
838 if (!size.IsFinite())
839 {
840 size = new Vector3(0.5f, 0.5f, 0.5f);
841 m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Size for {0}", Name);
842 }
843
844 if (size.X <= 0) size.X = 0.01f;
845 if (size.Y <= 0) size.Y = 0.01f;
846 if (size.Z <= 0) size.Z = 0.01f;
847
848 _size = size;
849
850
851 if (!QuaternionIsFinite(rotation))
852 {
853 rotation = Quaternion.Identity;
854 m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Rotation for {0}", Name);
855 }
856
857 _orientation = rotation;
858 givefakeori = 0;
859
860 _pbs = pbs;
861
862 _parent_scene = parent_scene;
863 m_targetSpace = IntPtr.Zero;
864
865 if (pos.Z < 0)
866 {
867 m_isphysical = false;
868 }
869 else
870 {
871 m_isphysical = pisPhysical;
872 }
873 m_fakeisphysical = m_isphysical;
874
875 m_isVolumeDetect = false;
876
877 m_force = Vector3.Zero;
878
879 m_iscolliding = false;
880 m_colliderfilter = 0;
881
882 hasOOBoffsetFromMesh = false;
883 _triMeshData = IntPtr.Zero;
884
885 m_lastdoneSelected = false;
886 m_isSelected = false;
887 m_delaySelect = false;
888
889 primContactData.mu = parent_scene.m_materialContactsData[(int)Material.Wood].mu;
890 primContactData.bounce = parent_scene.m_materialContactsData[(int)Material.Wood].bounce;
891
892 CalcPrimBodyData();
893
894 m_building = true; // control must set this to false when done
895
896 AddChange(changes.Add, null);
897 }
898
899 private void resetCollisionAccounting()
900 {
901 m_collisionscore = 0;
902 }
903
904 private void createAMotor(Vector3 axis)
905 {
906 if (Body == IntPtr.Zero)
907 return;
908
909 if (Amotor != IntPtr.Zero)
910 {
911 d.JointDestroy(Amotor);
912 Amotor = IntPtr.Zero;
913 }
914
915 int axisnum = 3 - (int)(axis.X + axis.Y + axis.Z);
916
917 if (axisnum <= 0)
918 return;
919
920 // stop it
921 d.BodySetTorque(Body, 0, 0, 0);
922 d.BodySetAngularVel(Body, 0, 0, 0);
923
924 Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
925 d.JointAttach(Amotor, Body, IntPtr.Zero);
926
927 d.JointSetAMotorMode(Amotor, 0);
928
929 d.JointSetAMotorNumAxes(Amotor, axisnum);
930
931 // get current orientation to lock
932
933 d.Quaternion dcur = d.BodyGetQuaternion(Body);
934 Quaternion curr; // crap convertion between identical things
935 curr.X = dcur.X;
936 curr.Y = dcur.Y;
937 curr.Z = dcur.Z;
938 curr.W = dcur.W;
939 Vector3 ax;
940
941 int i = 0;
942 int j = 0;
943 if (axis.X == 0)
944 {
945 ax = (new Vector3(1, 0, 0)) * curr; // rotate world X to current local X
946 // ODE should do this with axis relative to body 1 but seems to fail
947 d.JointSetAMotorAxis(Amotor, 0, 0, ax.X, ax.Y, ax.Z);
948 d.JointSetAMotorAngle(Amotor, 0, 0);
949 d.JointSetAMotorParam(Amotor, (int)d.JointParam.LoStop, -0.000001f);
950 d.JointSetAMotorParam(Amotor, (int)d.JointParam.HiStop, 0.000001f);
951 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel, 0);
952 d.JointSetAMotorParam(Amotor, (int)d.JointParam.FudgeFactor, 0.0001f);
953 d.JointSetAMotorParam(Amotor, (int)d.JointParam.Bounce, 0f);
954 d.JointSetAMotorParam(Amotor, (int)d.JointParam.FMax, 5e8f);
955 d.JointSetAMotorParam(Amotor, (int)d.JointParam.StopCFM, 0f);
956 d.JointSetAMotorParam(Amotor, (int)d.JointParam.StopERP, 0.8f);
957 i++;
958 j = 256; // move to next axis set
959 }
960
961 if (axis.Y == 0)
962 {
963 ax = (new Vector3(0, 1, 0)) * curr;
964 d.JointSetAMotorAxis(Amotor, i, 0, ax.X, ax.Y, ax.Z);
965 d.JointSetAMotorAngle(Amotor, i, 0);
966 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.LoStop, -0.000001f);
967 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.HiStop, 0.000001f);
968 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Vel, 0);
969 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FudgeFactor, 0.0001f);
970 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Bounce, 0f);
971 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FMax, 5e8f);
972 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopCFM, 0f);
973 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopERP, 0.8f);
974 i++;
975 j += 256;
976 }
977
978 if (axis.Z == 0)
979 {
980 ax = (new Vector3(0, 0, 1)) * curr;
981 d.JointSetAMotorAxis(Amotor, i, 0, ax.X, ax.Y, ax.Z);
982 d.JointSetAMotorAngle(Amotor, i, 0);
983 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.LoStop, -0.000001f);
984 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.HiStop, 0.000001f);
985 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Vel, 0);
986 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FudgeFactor, 0.0001f);
987 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Bounce, 0f);
988 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FMax, 5e8f);
989 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopCFM, 0f);
990 d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopERP, 0.8f);
991 }
992 }
993
994 private bool setMesh(OdeScene parent_scene)
995 {
996 if (Body != IntPtr.Zero)
997 {
998 if (childPrim)
999 {
1000 if (_parent != null)
1001 {
1002 OdePrim parent = (OdePrim)_parent;
1003 parent.ChildDelink(this, false);
1004 }
1005 }
1006 else
1007 {
1008 DestroyBody();
1009 }
1010 }
1011
1012 IMesh mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, (int)LevelOfDetail.High, true);
1013 if (mesh == null)
1014 {
1015 m_log.WarnFormat("[PHYSICS]: CreateMesh Failed on prim {0} at <{1},{2},{3}>.", Name, _position.X, _position.Y, _position.Z);
1016 return false;
1017 }
1018
1019 IntPtr vertices, indices;
1020 int vertexCount, indexCount;
1021 int vertexStride, triStride;
1022
1023 mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount); // Note, that vertices are fixed in unmanaged heap
1024 mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount); // Also fixed, needs release after usage
1025
1026 if (vertexCount == 0 || indexCount == 0)
1027 {
1028 m_log.WarnFormat("[PHYSICS]: Got invalid mesh on prim {0} at <{1},{2},{3}>. It can be a sculp with alpha channel in map. Replacing it by a small box.", Name, _position.X, _position.Y, _position.Z);
1029 _size.X = 0.01f;
1030 _size.Y = 0.01f;
1031 _size.Z = 0.01f;
1032 return false;
1033 }
1034
1035 primOOBoffset = mesh.GetCentroid();
1036 hasOOBoffsetFromMesh = true;
1037
1038 _triMeshData = d.GeomTriMeshDataCreate();
1039
1040 d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);
1041 d.GeomTriMeshDataPreprocess(_triMeshData);
1042
1043 mesh.releaseSourceMeshData();
1044
1045 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1046 try
1047 {
1048 SetGeom(d.CreateTriMesh(m_targetSpace, _triMeshData, null, null, null));
1049 }
1050
1051 catch (Exception e)
1052 {
1053 m_log.ErrorFormat("[PHYSICS]: SetGeom Mesh failed for {0} exception: {1}", Name, e);
1054 return false;
1055 }
1056 return true;
1057 }
1058
1059 private void SetGeom(IntPtr geom)
1060 {
1061 prim_geom = geom;
1062 //Console.WriteLine("SetGeom to " + prim_geom + " for " + Name);
1063 if (prim_geom != IntPtr.Zero)
1064 {
1065 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
1066 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
1067
1068 CalcPrimBodyData();
1069
1070 _parent_scene.geom_name_map[prim_geom] = Name;
1071 _parent_scene.actor_name_map[prim_geom] = this;
1072
1073 /*
1074 if (childPrim)
1075 {
1076 if (_parent != null && _parent is OdePrim)
1077 {
1078 OdePrim parent = (OdePrim)_parent;
1079 //Console.WriteLine("SetGeom calls ChildSetGeom");
1080 parent.ChildSetGeom(this);
1081 }
1082 }
1083 */
1084 }
1085 else
1086 m_log.Warn("Setting bad Geom");
1087 }
1088
1089
1090 /// <summary>
1091 /// Create a geometry for the given mesh in the given target space.
1092 /// </summary>
1093 /// <param name="m_targetSpace"></param>
1094 /// <param name="mesh">If null, then a mesh is used that is based on the profile shape data.</param>
1095 private void CreateGeom()
1096 {
1097 if (_triMeshData != IntPtr.Zero)
1098 {
1099 d.GeomTriMeshDataDestroy(_triMeshData);
1100 _triMeshData = IntPtr.Zero;
1101 }
1102
1103 bool haveMesh = false;
1104 hasOOBoffsetFromMesh = false;
1105
1106 if (_parent_scene.needsMeshing(_pbs))
1107 {
1108 haveMesh = setMesh(_parent_scene); // this will give a mesh to non trivial known prims
1109 }
1110
1111 if (!haveMesh)
1112 {
1113 if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1
1114 && _size.X == _size.Y && _size.Y == _size.Z)
1115 { // it's a sphere
1116 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1117 try
1118 {
1119 SetGeom(d.CreateSphere(m_targetSpace, _size.X * 0.5f));
1120 }
1121 catch (Exception e)
1122 {
1123 m_log.WarnFormat("[PHYSICS]: Create sphere failed: {0}", e);
1124 return;
1125 }
1126 }
1127 else
1128 {// do it as a box
1129 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1130 try
1131 {
1132 //Console.WriteLine(" CreateGeom 4");
1133 SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
1134 }
1135 catch (Exception e)
1136 {
1137 m_log.Warn("[PHYSICS]: Create box failed: {0}", e);
1138 return;
1139 }
1140 }
1141 }
1142 }
1143
1144 /// <summary>
1145 /// Set a new geometry for this prim.
1146 /// </summary>
1147 /// <param name="geom"></param>
1148 private void RemoveGeom()
1149 {
1150 if (prim_geom != IntPtr.Zero)
1151 {
1152 _parent_scene.geom_name_map.Remove(prim_geom);
1153 _parent_scene.actor_name_map.Remove(prim_geom);
1154 try
1155 {
1156 d.GeomDestroy(prim_geom);
1157 if (_triMeshData != IntPtr.Zero)
1158 {
1159 d.GeomTriMeshDataDestroy(_triMeshData);
1160 _triMeshData = IntPtr.Zero;
1161 }
1162 }
1163 // catch (System.AccessViolationException)
1164 catch (Exception e)
1165 {
1166 m_log.ErrorFormat("[PHYSICS]: PrimGeom destruction failed for {0} exception {1}", Name, e);
1167 }
1168
1169 prim_geom = IntPtr.Zero;
1170 }
1171 else
1172 {
1173 m_log.ErrorFormat("[PHYSICS]: PrimGeom destruction BAD {0}", Name);
1174 }
1175 Body = IntPtr.Zero;
1176 hasOOBoffsetFromMesh = false;
1177 CalcPrimBodyData();
1178 }
1179
1180 private void ChildSetGeom(OdePrim odePrim)
1181 {
1182 // well..
1183 DestroyBody();
1184 MakeBody();
1185 }
1186
1187 //sets non physical prim m_targetSpace to right space in spaces grid for static prims
1188 // should only be called for non physical prims unless they are becoming non physical
1189 private void SetInStaticSpace(OdePrim prim)
1190 {
1191 IntPtr targetSpace = _parent_scene.MoveGeomToStaticSpace(prim.prim_geom, prim._position, prim.m_targetSpace);
1192 prim.m_targetSpace = targetSpace;
1193 d.GeomEnable(prim_geom);
1194 }
1195
1196 public void enableBodySoft()
1197 {
1198 if (!childPrim && !m_isSelected)
1199 {
1200 if (m_isphysical && Body != IntPtr.Zero && prim_geom != IntPtr.Zero)
1201 {
1202 d.GeomEnable(prim_geom);
1203 foreach (OdePrim prm in childrenPrim)
1204 d.GeomEnable(prm.prim_geom);
1205
1206 d.BodyEnable(Body);
1207 }
1208 }
1209 m_disabled = false;
1210 resetCollisionAccounting(); // this sets m_disable to false
1211 }
1212
1213 private void disableBodySoft()
1214 {
1215 m_disabled = true;
1216 if (!childPrim)
1217 {
1218 if (m_isphysical && Body != IntPtr.Zero && prim_geom != IntPtr.Zero)
1219 {
1220 d.GeomDisable(prim_geom);
1221 foreach (OdePrim prm in childrenPrim)
1222 d.GeomDisable(prm.prim_geom);
1223 d.BodyDisable(Body);
1224 }
1225 }
1226 }
1227
1228 private void MakeBody()
1229 {
1230 if (!m_isphysical) // only physical get bodies
1231 return;
1232
1233 if (childPrim) // child prims don't get bodies;
1234 return;
1235
1236 if (m_building)
1237 return;
1238
1239 if (prim_geom == IntPtr.Zero)
1240 {
1241 m_log.Warn("[PHYSICS]: Unable to link the linkset. Root has no geom yet");
1242 return;
1243 }
1244
1245 if (Body != IntPtr.Zero)
1246 {
1247 d.BodyDestroy(Body);
1248 Body = IntPtr.Zero;
1249 m_log.Warn("[PHYSICS]: MakeBody called having a body");
1250 }
1251
1252
1253 if (d.GeomGetBody(prim_geom) != IntPtr.Zero)
1254 {
1255 d.GeomSetBody(prim_geom, IntPtr.Zero);
1256 m_log.Warn("[PHYSICS]: MakeBody root geom already had a body");
1257 }
1258
1259 d.Matrix3 mymat = new d.Matrix3();
1260 d.Quaternion myrot = new d.Quaternion();
1261 d.Mass objdmass = new d.Mass { };
1262
1263 Body = d.BodyCreate(_parent_scene.world);
1264
1265 DMassDup(ref primdMass, out objdmass);
1266
1267 // rotate inertia
1268 myrot.X = _orientation.X;
1269 myrot.Y = _orientation.Y;
1270 myrot.Z = _orientation.Z;
1271 myrot.W = _orientation.W;
1272
1273 d.RfromQ(out mymat, ref myrot);
1274 d.MassRotate(ref objdmass, ref mymat);
1275
1276 // set the body rotation and position
1277 d.BodySetRotation(Body, ref mymat);
1278
1279 // recompute full object inertia if needed
1280 if (childrenPrim.Count > 0)
1281 {
1282 d.Matrix3 mat = new d.Matrix3();
1283 d.Quaternion quat = new d.Quaternion();
1284 d.Mass tmpdmass = new d.Mass { };
1285 Vector3 rcm;
1286
1287 rcm.X = _position.X + objdmass.c.X;
1288 rcm.Y = _position.Y + objdmass.c.Y;
1289 rcm.Z = _position.Z + objdmass.c.Z;
1290
1291 lock (childrenPrim)
1292 {
1293 foreach (OdePrim prm in childrenPrim)
1294 {
1295 if (prm.prim_geom == IntPtr.Zero)
1296 {
1297 m_log.Warn("[PHYSICS]: Unable to link one of the linkset elements, skipping it. No geom yet");
1298 continue;
1299 }
1300
1301
1302
1303 DMassCopy(ref prm.primdMass, ref tmpdmass);
1304
1305 // apply prim current rotation to inertia
1306 quat.X = prm._orientation.X;
1307 quat.Y = prm._orientation.Y;
1308 quat.Z = prm._orientation.Z;
1309 quat.W = prm._orientation.W;
1310 d.RfromQ(out mat, ref quat);
1311 d.MassRotate(ref tmpdmass, ref mat);
1312
1313 Vector3 ppos = prm._position;
1314 ppos.X += tmpdmass.c.X - rcm.X;
1315 ppos.Y += tmpdmass.c.Y - rcm.Y;
1316 ppos.Z += tmpdmass.c.Z - rcm.Z;
1317
1318 // refer inertia to root prim center of mass position
1319 d.MassTranslate(ref tmpdmass,
1320 ppos.X,
1321 ppos.Y,
1322 ppos.Z);
1323
1324 d.MassAdd(ref objdmass, ref tmpdmass); // add to total object inertia
1325 // fix prim colision cats
1326
1327 if (d.GeomGetBody(prm.prim_geom) != IntPtr.Zero)
1328 {
1329 d.GeomSetBody(prm.prim_geom, IntPtr.Zero);
1330 m_log.Warn("[PHYSICS]: MakeBody child geom already had a body");
1331 }
1332
1333 d.GeomClearOffset(prm.prim_geom);
1334 d.GeomSetBody(prm.prim_geom, Body);
1335 prm.Body = Body;
1336 d.GeomSetOffsetWorldRotation(prm.prim_geom, ref mat); // set relative rotation
1337 }
1338 }
1339 }
1340
1341 d.GeomClearOffset(prim_geom); // make sure we don't have a hidden offset
1342 // associate root geom with body
1343 d.GeomSetBody(prim_geom, Body);
1344
1345 d.BodySetPosition(Body, _position.X + objdmass.c.X, _position.Y + objdmass.c.Y, _position.Z + objdmass.c.Z);
1346 d.GeomSetOffsetWorldPosition(prim_geom, _position.X, _position.Y, _position.Z);
1347
1348 d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body
1349 myrot.W = -myrot.W;
1350 d.RfromQ(out mymat, ref myrot);
1351 d.MassRotate(ref objdmass, ref mymat);
1352 d.BodySetMass(Body, ref objdmass);
1353 _mass = objdmass.mass;
1354
1355 // disconnect from world gravity so we can apply buoyancy
1356 d.BodySetGravityMode(Body, false);
1357
1358 d.BodySetAutoDisableFlag(Body, true);
1359 d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
1360 // d.BodySetLinearDampingThreshold(Body, 0.01f);
1361 // d.BodySetAngularDampingThreshold(Body, 0.001f);
1362 d.BodySetDamping(Body, .002f, .002f);
1363
1364 m_collisionCategories |= CollisionCategories.Body;
1365 m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
1366 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
1367 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
1368 m_collisionscore = 0;
1369
1370 if (m_targetSpace != _parent_scene.ActiveSpace)
1371 {
1372 if (m_targetSpace != IntPtr.Zero)
1373 {
1374 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1375 if (d.SpaceQuery(m_targetSpace, prim_geom))
1376 d.SpaceRemove(m_targetSpace, prim_geom);
1377 }
1378
1379 m_targetSpace = _parent_scene.ActiveSpace;
1380 d.SpaceAdd(m_targetSpace, prim_geom);
1381 }
1382
1383 lock (childrenPrim)
1384 {
1385 foreach (OdePrim prm in childrenPrim)
1386 {
1387 if (prm.prim_geom == IntPtr.Zero)
1388 continue;
1389
1390 Vector3 ppos = prm._position;
1391 d.GeomSetOffsetWorldPosition(prm.prim_geom, ppos.X, ppos.Y, ppos.Z); // set relative position
1392
1393 prm.m_collisionCategories |= CollisionCategories.Body;
1394 prm.m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
1395 d.GeomSetCategoryBits(prm.prim_geom, (int)prm.m_collisionCategories);
1396 d.GeomSetCollideBits(prm.prim_geom, (int)prm.m_collisionFlags);
1397 prm.m_collisionscore = 0;
1398
1399 if (prm.m_targetSpace != _parent_scene.ActiveSpace)
1400 {
1401 if (prm.m_targetSpace != IntPtr.Zero)
1402 {
1403 _parent_scene.waitForSpaceUnlock(m_targetSpace);
1404 if (d.SpaceQuery(prm.m_targetSpace, prm.prim_geom))
1405 d.SpaceRemove(prm.m_targetSpace, prm.prim_geom);
1406 }
1407 prm.m_targetSpace = _parent_scene.ActiveSpace;
1408 d.SpaceAdd(m_targetSpace, prm.prim_geom);
1409 }
1410
1411 if (m_isSelected || m_disabled)
1412 d.GeomDisable(prm.prim_geom);
1413
1414 prm.m_disabled = false;
1415 _parent_scene.addActivePrim(prm);
1416 }
1417 }
1418
1419 // The body doesn't already have a finite rotation mode set here
1420 if ((!m_angularlock.ApproxEquals(Vector3.One, 0.0f)) && _parent == null)
1421 {
1422 createAMotor(m_angularlock);
1423 }
1424
1425 if (m_isSelected || m_disabled)
1426 {
1427 d.GeomDisable(prim_geom);
1428 d.BodyDisable(Body);
1429 }
1430
1431 _parent_scene.addActivePrim(this);
1432 }
1433
1434 private void DestroyBody()
1435 {
1436 if (Body != IntPtr.Zero)
1437 {
1438 _parent_scene.remActivePrim(this);
1439 m_collisionCategories &= ~CollisionCategories.Body;
1440 m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
1441 if (prim_geom != IntPtr.Zero)
1442 {
1443 d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
1444 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
1445 UpdateDataFromGeom();
1446 d.GeomSetBody(prim_geom, IntPtr.Zero);
1447 SetInStaticSpace(this);
1448 }
1449
1450 if (!childPrim)
1451 {
1452 lock (childrenPrim)
1453 {
1454 foreach (OdePrim prm in childrenPrim)
1455 {
1456 _parent_scene.remActivePrim(prm);
1457 prm.m_collisionCategories &= ~CollisionCategories.Body;
1458 prm.m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
1459 if (prm.prim_geom != IntPtr.Zero)
1460 {
1461 d.GeomSetCategoryBits(prm.prim_geom, (int)m_collisionCategories);
1462 d.GeomSetCollideBits(prm.prim_geom, (int)m_collisionFlags);
1463 prm.UpdateDataFromGeom();
1464 SetInStaticSpace(prm);
1465 }
1466 prm.Body = IntPtr.Zero;
1467 prm._mass = prm.primMass;
1468 prm.m_collisionscore = 0;
1469 }
1470 }
1471 if (Amotor != IntPtr.Zero)
1472 {
1473 d.JointDestroy(Amotor);
1474 Amotor = IntPtr.Zero;
1475 }
1476 d.BodyDestroy(Body);
1477 }
1478 Body = IntPtr.Zero;
1479 }
1480 _mass = primMass;
1481 m_collisionscore = 0;
1482 }
1483
1484 #region Mass Calculation
1485
1486 private float CalculatePrimVolume()
1487 {
1488 float volume = _size.X * _size.Y * _size.Z; // default
1489 float tmp;
1490
1491 float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
1492 float hollowVolume = hollowAmount * hollowAmount;
1493
1494 switch (_pbs.ProfileShape)
1495 {
1496 case ProfileShape.Square:
1497 // default box
1498
1499 if (_pbs.PathCurve == (byte)Extrusion.Straight)
1500 {
1501 if (hollowAmount > 0.0)
1502 {
1503 switch (_pbs.HollowShape)
1504 {
1505 case HollowShape.Square:
1506 case HollowShape.Same:
1507 break;
1508
1509 case HollowShape.Circle:
1510
1511 hollowVolume *= 0.78539816339f;
1512 break;
1513
1514 case HollowShape.Triangle:
1515
1516 hollowVolume *= (0.5f * .5f);
1517 break;
1518
1519 default:
1520 hollowVolume = 0;
1521 break;
1522 }
1523 volume *= (1.0f - hollowVolume);
1524 }
1525 }
1526
1527 else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
1528 {
1529 //a tube
1530
1531 volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
1532 tmp = 1.0f - 2.0e-2f * (float)(200 - _pbs.PathScaleY);
1533 volume -= volume * tmp * tmp;
1534
1535 if (hollowAmount > 0.0)
1536 {
1537 hollowVolume *= hollowAmount;
1538
1539 switch (_pbs.HollowShape)
1540 {
1541 case HollowShape.Square:
1542 case HollowShape.Same:
1543 break;
1544
1545 case HollowShape.Circle:
1546 hollowVolume *= 0.78539816339f;
1547 break;
1548
1549 case HollowShape.Triangle:
1550 hollowVolume *= 0.5f * 0.5f;
1551 break;
1552 default:
1553 hollowVolume = 0;
1554 break;
1555 }
1556 volume *= (1.0f - hollowVolume);
1557 }
1558 }
1559
1560 break;
1561
1562 case ProfileShape.Circle:
1563
1564 if (_pbs.PathCurve == (byte)Extrusion.Straight)
1565 {
1566 volume *= 0.78539816339f; // elipse base
1567
1568 if (hollowAmount > 0.0)
1569 {
1570 switch (_pbs.HollowShape)
1571 {
1572 case HollowShape.Same:
1573 case HollowShape.Circle:
1574 break;
1575
1576 case HollowShape.Square:
1577 hollowVolume *= 0.5f * 2.5984480504799f;
1578 break;
1579
1580 case HollowShape.Triangle:
1581 hollowVolume *= .5f * 1.27323954473516f;
1582 break;
1583
1584 default:
1585 hollowVolume = 0;
1586 break;
1587 }
1588 volume *= (1.0f - hollowVolume);
1589 }
1590 }
1591
1592 else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
1593 {
1594 volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);
1595 tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
1596 volume *= (1.0f - tmp * tmp);
1597
1598 if (hollowAmount > 0.0)
1599 {
1600
1601 // calculate the hollow volume by it's shape compared to the prim shape
1602 hollowVolume *= hollowAmount;
1603
1604 switch (_pbs.HollowShape)
1605 {
1606 case HollowShape.Same:
1607 case HollowShape.Circle:
1608 break;
1609
1610 case HollowShape.Square:
1611 hollowVolume *= 0.5f * 2.5984480504799f;
1612 break;
1613
1614 case HollowShape.Triangle:
1615 hollowVolume *= .5f * 1.27323954473516f;
1616 break;
1617
1618 default:
1619 hollowVolume = 0;
1620 break;
1621 }
1622 volume *= (1.0f - hollowVolume);
1623 }
1624 }
1625 break;
1626
1627 case ProfileShape.HalfCircle:
1628 if (_pbs.PathCurve == (byte)Extrusion.Curve1)
1629 {
1630 volume *= 0.52359877559829887307710723054658f;
1631 }
1632 break;
1633
1634 case ProfileShape.EquilateralTriangle:
1635
1636 if (_pbs.PathCurve == (byte)Extrusion.Straight)
1637 {
1638 volume *= 0.32475953f;
1639
1640 if (hollowAmount > 0.0)
1641 {
1642
1643 // calculate the hollow volume by it's shape compared to the prim shape
1644 switch (_pbs.HollowShape)
1645 {
1646 case HollowShape.Same:
1647 case HollowShape.Triangle:
1648 hollowVolume *= .25f;
1649 break;
1650
1651 case HollowShape.Square:
1652 hollowVolume *= 0.499849f * 3.07920140172638f;
1653 break;
1654
1655 case HollowShape.Circle:
1656 // Hollow shape is a perfect cyllinder in respect to the cube's scale
1657 // Cyllinder hollow volume calculation
1658
1659 hollowVolume *= 0.1963495f * 3.07920140172638f;
1660 break;
1661
1662 default:
1663 hollowVolume = 0;
1664 break;
1665 }
1666 volume *= (1.0f - hollowVolume);
1667 }
1668 }
1669 else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
1670 {
1671 volume *= 0.32475953f;
1672 volume *= 0.01f * (float)(200 - _pbs.PathScaleX);
1673 tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
1674 volume *= (1.0f - tmp * tmp);
1675
1676 if (hollowAmount > 0.0)
1677 {
1678
1679 hollowVolume *= hollowAmount;
1680
1681 switch (_pbs.HollowShape)
1682 {
1683 case HollowShape.Same:
1684 case HollowShape.Triangle:
1685 hollowVolume *= .25f;
1686 break;
1687
1688 case HollowShape.Square:
1689 hollowVolume *= 0.499849f * 3.07920140172638f;
1690 break;
1691
1692 case HollowShape.Circle:
1693
1694 hollowVolume *= 0.1963495f * 3.07920140172638f;
1695 break;
1696
1697 default:
1698 hollowVolume = 0;
1699 break;
1700 }
1701 volume *= (1.0f - hollowVolume);
1702 }
1703 }
1704 break;
1705
1706 default:
1707 break;
1708 }
1709
1710 float taperX1;
1711 float taperY1;
1712 float taperX;
1713 float taperY;
1714 float pathBegin;
1715 float pathEnd;
1716 float profileBegin;
1717 float profileEnd;
1718
1719 if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)
1720 {
1721 taperX1 = _pbs.PathScaleX * 0.01f;
1722 if (taperX1 > 1.0f)
1723 taperX1 = 2.0f - taperX1;
1724 taperX = 1.0f - taperX1;
1725
1726 taperY1 = _pbs.PathScaleY * 0.01f;
1727 if (taperY1 > 1.0f)
1728 taperY1 = 2.0f - taperY1;
1729 taperY = 1.0f - taperY1;
1730 }
1731 else
1732 {
1733 taperX = _pbs.PathTaperX * 0.01f;
1734 if (taperX < 0.0f)
1735 taperX = -taperX;
1736 taperX1 = 1.0f - taperX;
1737
1738 taperY = _pbs.PathTaperY * 0.01f;
1739 if (taperY < 0.0f)
1740 taperY = -taperY;
1741 taperY1 = 1.0f - taperY;
1742 }
1743
1744 volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
1745
1746 pathBegin = (float)_pbs.PathBegin * 2.0e-5f;
1747 pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;
1748 volume *= (pathEnd - pathBegin);
1749
1750 // this is crude aproximation
1751 profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
1752 profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
1753 volume *= (profileEnd - profileBegin);
1754
1755 return volume;
1756 }
1757
1758
1759 private void CalcPrimBodyData()
1760 {
1761 float volume;
1762
1763 if (prim_geom == IntPtr.Zero)
1764 {
1765 // Ubit let's have a initial basic OOB
1766 primOOBsize.X = _size.X;
1767 primOOBsize.Y = _size.Y;
1768 primOOBsize.Z = _size.Z;
1769 primOOBoffset = Vector3.Zero;
1770 }
1771 else
1772 {
1773 d.AABB AABB;
1774 d.GeomGetAABB(prim_geom, out AABB); // get the AABB from engine geom
1775
1776 primOOBsize.X = (AABB.MaxX - AABB.MinX);
1777 primOOBsize.Y = (AABB.MaxY - AABB.MinY);
1778 primOOBsize.Z = (AABB.MaxZ - AABB.MinZ);
1779 if (!hasOOBoffsetFromMesh)
1780 {
1781 primOOBoffset.X = (AABB.MaxX + AABB.MinX) * 0.5f;
1782 primOOBoffset.Y = (AABB.MaxY + AABB.MinY) * 0.5f;
1783 primOOBoffset.Z = (AABB.MaxZ + AABB.MinZ) * 0.5f;
1784 }
1785 }
1786
1787 // also its own inertia and mass
1788 // keep using basic shape mass for now
1789 volume = CalculatePrimVolume();
1790
1791 primMass = m_density * volume;
1792
1793 if (primMass <= 0)
1794 primMass = 0.0001f;//ckrinke: Mass must be greater then zero.
1795 if (primMass > _parent_scene.maximumMassObject)
1796 primMass = _parent_scene.maximumMassObject;
1797
1798 _mass = primMass; // just in case
1799
1800 d.MassSetBoxTotal(out primdMass, primMass, primOOBsize.X, primOOBsize.Y, primOOBsize.Z);
1801
1802 d.MassTranslate(ref primdMass,
1803 primOOBoffset.X,
1804 primOOBoffset.Y,
1805 primOOBoffset.Z);
1806
1807 primOOBsize *= 0.5f; // let obb size be a corner coords
1808 primOOBradiusSQ = primOOBsize.LengthSquared();
1809 }
1810
1811
1812 #endregion
1813
1814
1815 /// <summary>
1816 /// Add a child prim to this parent prim.
1817 /// </summary>
1818 /// <param name="prim">Child prim</param>
1819 // I'm the parent
1820 // prim is the child
1821 public void ParentPrim(OdePrim prim)
1822 {
1823 //Console.WriteLine("ParentPrim " + m_primName);
1824 if (this.m_localID != prim.m_localID)
1825 {
1826 DestroyBody(); // for now we need to rebuil entire object on link change
1827
1828 lock (childrenPrim)
1829 {
1830 // adopt the prim
1831 if (!childrenPrim.Contains(prim))
1832 childrenPrim.Add(prim);
1833
1834 // see if this prim has kids and adopt them also
1835 // should not happen for now
1836 foreach (OdePrim prm in prim.childrenPrim)
1837 {
1838 if (!childrenPrim.Contains(prm))
1839 {
1840 if (prm.Body != IntPtr.Zero)
1841 {
1842 if (prm.prim_geom != IntPtr.Zero)
1843 d.GeomSetBody(prm.prim_geom, IntPtr.Zero);
1844 if (prm.Body != prim.Body)
1845 prm.DestroyBody(); // don't loose bodies around
1846 prm.Body = IntPtr.Zero;
1847 }
1848
1849 childrenPrim.Add(prm);
1850 prm._parent = this;
1851 }
1852 }
1853 }
1854 //Remove old children from the prim
1855 prim.childrenPrim.Clear();
1856
1857 if (prim.Body != IntPtr.Zero)
1858 {
1859 if (prim.prim_geom != IntPtr.Zero)
1860 d.GeomSetBody(prim.prim_geom, IntPtr.Zero);
1861 prim.DestroyBody(); // don't loose bodies around
1862 prim.Body = IntPtr.Zero;
1863 }
1864
1865 prim.childPrim = true;
1866 prim._parent = this;
1867
1868 MakeBody(); // full nasty reconstruction
1869 }
1870 }
1871
1872 private void UpdateChildsfromgeom()
1873 {
1874 if (childrenPrim.Count > 0)
1875 {
1876 foreach (OdePrim prm in childrenPrim)
1877 prm.UpdateDataFromGeom();
1878 }
1879 }
1880
1881 private void UpdateDataFromGeom()
1882 {
1883 if (prim_geom != IntPtr.Zero)
1884 {
1885 d.Vector3 lpos;
1886 d.GeomCopyPosition(prim_geom, out lpos);
1887 _position.X = lpos.X;
1888 _position.Y = lpos.Y;
1889 _position.Z = lpos.Z;
1890 d.Quaternion qtmp = new d.Quaternion { };
1891 d.GeomCopyQuaternion(prim_geom, out qtmp);
1892 _orientation.W = qtmp.W;
1893 _orientation.X = qtmp.X;
1894 _orientation.Y = qtmp.Y;
1895 _orientation.Z = qtmp.Z;
1896 }
1897 }
1898
1899 private void ChildDelink(OdePrim odePrim, bool remakebodies)
1900 {
1901 // Okay, we have a delinked child.. destroy all body and remake
1902 if (odePrim != this && !childrenPrim.Contains(odePrim))
1903 return;
1904
1905 DestroyBody();
1906
1907 if (odePrim == this) // delinking the root prim
1908 {
1909 OdePrim newroot = null;
1910 lock (childrenPrim)
1911 {
1912 if (childrenPrim.Count > 0)
1913 {
1914 newroot = childrenPrim[0];
1915 childrenPrim.RemoveAt(0);
1916 foreach (OdePrim prm in childrenPrim)
1917 {
1918 newroot.childrenPrim.Add(prm);
1919 }
1920 childrenPrim.Clear();
1921 }
1922 if (newroot != null)
1923 {
1924 newroot.childPrim = false;
1925 newroot._parent = null;
1926 if (remakebodies)
1927 newroot.MakeBody();
1928 }
1929 }
1930 }
1931
1932 else
1933 {
1934 lock (childrenPrim)
1935 {
1936 childrenPrim.Remove(odePrim);
1937 odePrim.childPrim = false;
1938 odePrim._parent = null;
1939 // odePrim.UpdateDataFromGeom();
1940 if (remakebodies)
1941 odePrim.MakeBody();
1942 }
1943 }
1944 if (remakebodies)
1945 MakeBody();
1946 }
1947
1948 protected void ChildRemove(OdePrim odePrim, bool reMakeBody)
1949 {
1950 // Okay, we have a delinked child.. destroy all body and remake
1951 if (odePrim != this && !childrenPrim.Contains(odePrim))
1952 return;
1953
1954 DestroyBody();
1955
1956 if (odePrim == this)
1957 {
1958 OdePrim newroot = null;
1959 lock (childrenPrim)
1960 {
1961 if (childrenPrim.Count > 0)
1962 {
1963 newroot = childrenPrim[0];
1964 childrenPrim.RemoveAt(0);
1965 foreach (OdePrim prm in childrenPrim)
1966 {
1967 newroot.childrenPrim.Add(prm);
1968 }
1969 childrenPrim.Clear();
1970 }
1971 if (newroot != null)
1972 {
1973 newroot.childPrim = false;
1974 newroot._parent = null;
1975 newroot.MakeBody();
1976 }
1977 }
1978 if (reMakeBody)
1979 MakeBody();
1980 return;
1981 }
1982 else
1983 {
1984 lock (childrenPrim)
1985 {
1986 childrenPrim.Remove(odePrim);
1987 odePrim.childPrim = false;
1988 odePrim._parent = null;
1989 if (reMakeBody)
1990 odePrim.MakeBody();
1991 }
1992 }
1993 MakeBody();
1994 }
1995
1996 #region changes
1997
1998 private void changeadd()
1999 {
2000 CreateGeom();
2001
2002 if (prim_geom != IntPtr.Zero)
2003 {
2004 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
2005 d.Quaternion myrot = new d.Quaternion();
2006 myrot.X = _orientation.X;
2007 myrot.Y = _orientation.Y;
2008 myrot.Z = _orientation.Z;
2009 myrot.W = _orientation.W;
2010 d.GeomSetQuaternion(prim_geom, ref myrot);
2011 // _parent_scene.actor_name_map[prim_geom] = (PhysicsActor)this;
2012 if (!m_isphysical)
2013 SetInStaticSpace(this);
2014 }
2015
2016 if (m_isphysical && Body == IntPtr.Zero)
2017 {
2018 /*
2019 if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
2020 {
2021 changeShape(_pbs);
2022 }
2023 else
2024 {
2025 */
2026 MakeBody();
2027 // }
2028 }
2029 }
2030
2031 private void changeAngularLock(Vector3 newLock)
2032 {
2033 // do we have a Physical object?
2034 if (Body != IntPtr.Zero)
2035 {
2036 //Check that we have a Parent
2037 //If we have a parent then we're not authorative here
2038 if (_parent == null)
2039 {
2040 if (!newLock.ApproxEquals(Vector3.One, 0f))
2041 {
2042 createAMotor(newLock);
2043 }
2044 else
2045 {
2046 if (Amotor != IntPtr.Zero)
2047 {
2048 d.JointDestroy(Amotor);
2049 Amotor = IntPtr.Zero;
2050 }
2051 }
2052 }
2053 }
2054 // Store this for later in case we get turned into a separate body
2055 m_angularlock = newLock;
2056 }
2057
2058 private void changeLink(OdePrim NewParent)
2059 {
2060 if (_parent == null && NewParent != null)
2061 {
2062 NewParent.ParentPrim(this);
2063 }
2064 else if (_parent != null)
2065 {
2066 if (_parent is OdePrim)
2067 {
2068 if (NewParent != _parent)
2069 {
2070 (_parent as OdePrim).ChildDelink(this, false); // for now...
2071 childPrim = false;
2072
2073 if (NewParent != null)
2074 {
2075 NewParent.ParentPrim(this);
2076 }
2077 }
2078 }
2079 }
2080 _parent = NewParent;
2081 }
2082
2083
2084 private void Stop()
2085 {
2086 if (!childPrim)
2087 {
2088 m_force = Vector3.Zero;
2089 m_forceacc = Vector3.Zero;
2090 m_angularForceacc = Vector3.Zero;
2091 _torque = Vector3.Zero;
2092 _velocity = Vector3.Zero;
2093 _acceleration = Vector3.Zero;
2094 m_rotationalVelocity = Vector3.Zero;
2095 _target_velocity = Vector3.Zero;
2096 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
2097 m_vehicle.Stop();
2098 }
2099
2100 if (Body != IntPtr.Zero)
2101 {
2102 d.BodySetForce(Body, 0f, 0f, 0f);
2103 d.BodySetTorque(Body, 0f, 0f, 0f);
2104 d.BodySetLinearVel(Body, 0f, 0f, 0f);
2105 d.BodySetAngularVel(Body, 0f, 0f, 0f);
2106 }
2107 }
2108
2109 private void changeSelectedStatus(bool newval)
2110 {
2111 if (m_lastdoneSelected == newval)
2112 return;
2113
2114 m_lastdoneSelected = newval;
2115 DoSelectedStatus(newval);
2116 }
2117
2118 private void CheckDelaySelect()
2119 {
2120 if (m_delaySelect)
2121 {
2122 DoSelectedStatus(m_isSelected);
2123 }
2124 }
2125
2126 private void DoSelectedStatus(bool newval)
2127 {
2128 m_isSelected = newval;
2129 Stop();
2130
2131 if (newval)
2132 {
2133 if (!childPrim && Body != IntPtr.Zero)
2134 d.BodyDisable(Body);
2135
2136 if (m_delaySelect)
2137 {
2138 if (!childPrim)
2139 {
2140 foreach (OdePrim prm in childrenPrim)
2141 {
2142 d.GeomDisable(prm.prim_geom);
2143 prm.m_delaySelect = false;
2144 }
2145 }
2146 d.GeomDisable(prim_geom);
2147 m_delaySelect = false;
2148 }
2149 else
2150 {
2151 m_delaySelect = true;
2152 }
2153 }
2154 else
2155 {
2156 if (!childPrim && Body != IntPtr.Zero && !m_disabled)
2157 d.BodyEnable(Body);
2158
2159 if (!childPrim)
2160 {
2161 foreach (OdePrim prm in childrenPrim)
2162 {
2163 if(!prm.m_disabled)
2164 d.GeomEnable(prm.prim_geom);
2165 prm.m_delaySelect = false;
2166 }
2167 }
2168 if(!m_disabled)
2169 d.GeomEnable(prim_geom);
2170
2171 m_delaySelect = false;
2172 }
2173
2174 resetCollisionAccounting();
2175 }
2176
2177 private void changePosition(Vector3 newPos)
2178 {
2179 CheckDelaySelect();
2180 if (m_isphysical)
2181 {
2182 if (childPrim) // inertia is messed, must rebuild
2183 {
2184 if (m_building)
2185 {
2186 _position = newPos;
2187 }
2188 }
2189 else
2190 {
2191 if (_position != newPos)
2192 {
2193 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2194 _position = newPos;
2195 }
2196 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2197 d.BodyEnable(Body);
2198 }
2199 }
2200 else
2201 {
2202 if (prim_geom != IntPtr.Zero)
2203 {
2204 if (newPos != _position)
2205 {
2206 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2207 _position = newPos;
2208
2209 m_targetSpace = _parent_scene.MoveGeomToStaticSpace(prim_geom, _position, m_targetSpace);
2210 }
2211 }
2212 }
2213 givefakepos--;
2214 if (givefakepos < 0)
2215 givefakepos = 0;
2216 // changeSelectedStatus();
2217 resetCollisionAccounting();
2218 }
2219
2220 private void changeOrientation(Quaternion newOri)
2221 {
2222 CheckDelaySelect();
2223 if (m_isphysical)
2224 {
2225 if (childPrim) // inertia is messed, must rebuild
2226 {
2227 if (m_building)
2228 {
2229 _orientation = newOri;
2230 }
2231 }
2232 else
2233 {
2234 if (newOri != _orientation)
2235 {
2236 d.Quaternion myrot = new d.Quaternion();
2237 myrot.X = newOri.X;
2238 myrot.Y = newOri.Y;
2239 myrot.Z = newOri.Z;
2240 myrot.W = newOri.W;
2241 d.GeomSetQuaternion(prim_geom, ref myrot);
2242 _orientation = newOri;
2243 if (Body != IntPtr.Zero && !m_angularlock.ApproxEquals(Vector3.One, 0f))
2244 createAMotor(m_angularlock);
2245 }
2246 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2247 d.BodyEnable(Body);
2248 }
2249 }
2250 else
2251 {
2252 if (prim_geom != IntPtr.Zero)
2253 {
2254 if (newOri != _orientation)
2255 {
2256 d.Quaternion myrot = new d.Quaternion();
2257 myrot.X = newOri.X;
2258 myrot.Y = newOri.Y;
2259 myrot.Z = newOri.Z;
2260 myrot.W = newOri.W;
2261 d.GeomSetQuaternion(prim_geom, ref myrot);
2262 _orientation = newOri;
2263 }
2264 }
2265 }
2266 givefakeori--;
2267 if (givefakeori < 0)
2268 givefakeori = 0;
2269 resetCollisionAccounting();
2270 }
2271
2272 private void changePositionAndOrientation(Vector3 newPos, Quaternion newOri)
2273 {
2274 CheckDelaySelect();
2275 if (m_isphysical)
2276 {
2277 if (childPrim && m_building) // inertia is messed, must rebuild
2278 {
2279 _position = newPos;
2280 _orientation = newOri;
2281 }
2282 else
2283 {
2284 if (newOri != _orientation)
2285 {
2286 d.Quaternion myrot = new d.Quaternion();
2287 myrot.X = newOri.X;
2288 myrot.Y = newOri.Y;
2289 myrot.Z = newOri.Z;
2290 myrot.W = newOri.W;
2291 d.GeomSetQuaternion(prim_geom, ref myrot);
2292 _orientation = newOri;
2293 if (Body != IntPtr.Zero && !m_angularlock.ApproxEquals(Vector3.One, 0f))
2294 createAMotor(m_angularlock);
2295 }
2296 if (_position != newPos)
2297 {
2298 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2299 _position = newPos;
2300 }
2301 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2302 d.BodyEnable(Body);
2303 }
2304 }
2305 else
2306 {
2307 // string primScenAvatarIn = _parent_scene.whichspaceamIin(_position);
2308 // int[] arrayitem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
2309
2310 if (prim_geom != IntPtr.Zero)
2311 {
2312 if (newOri != _orientation)
2313 {
2314 d.Quaternion myrot = new d.Quaternion();
2315 myrot.X = newOri.X;
2316 myrot.Y = newOri.Y;
2317 myrot.Z = newOri.Z;
2318 myrot.W = newOri.W;
2319 d.GeomSetQuaternion(prim_geom, ref myrot);
2320 _orientation = newOri;
2321 }
2322
2323 if (newPos != _position)
2324 {
2325 d.GeomSetPosition(prim_geom, newPos.X, newPos.Y, newPos.Z);
2326 _position = newPos;
2327
2328 m_targetSpace = _parent_scene.MoveGeomToStaticSpace(prim_geom, _position, m_targetSpace);
2329 }
2330 }
2331 }
2332 givefakepos--;
2333 if (givefakepos < 0)
2334 givefakepos = 0;
2335 givefakeori--;
2336 if (givefakeori < 0)
2337 givefakeori = 0;
2338
2339 resetCollisionAccounting();
2340 }
2341
2342
2343 private void changeDisable(bool disable)
2344 {
2345 if (disable)
2346 {
2347 if (!m_disabled)
2348 disableBodySoft();
2349 }
2350 else
2351 {
2352 if (m_disabled)
2353 enableBodySoft();
2354 }
2355 }
2356
2357 private void changePhysicsStatus(bool NewStatus)
2358 {
2359 CheckDelaySelect();
2360
2361 m_isphysical = NewStatus;
2362
2363 if (!childPrim)
2364 {
2365 if (NewStatus)
2366 {
2367 if (Body == IntPtr.Zero)
2368 {
2369 /*
2370 if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
2371 {
2372 changeShape(_pbs);
2373 }
2374 else
2375 */
2376 {
2377 MakeBody();
2378 }
2379 }
2380 }
2381 else
2382 {
2383 if (Body != IntPtr.Zero)
2384 {
2385 // UpdateChildsfromgeom();
2386 /* if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
2387 {
2388 changeShape(_pbs);
2389 }
2390 else
2391 */
2392 DestroyBody();
2393 Stop();
2394 }
2395 }
2396 }
2397
2398 resetCollisionAccounting();
2399 }
2400
2401 private void changeprimsizeshape()
2402 {
2403 CheckDelaySelect();
2404
2405 OdePrim parent = (OdePrim)_parent;
2406
2407 bool chp = childPrim;
2408
2409 if (chp)
2410 {
2411 if (parent != null)
2412 {
2413 parent.DestroyBody();
2414 }
2415 }
2416 else
2417 {
2418 DestroyBody();
2419 }
2420
2421 RemoveGeom();
2422
2423 // we don't need to do space calculation because the client sends a position update also.
2424 if (_size.X <= 0)
2425 _size.X = 0.01f;
2426 if (_size.Y <= 0)
2427 _size.Y = 0.01f;
2428 if (_size.Z <= 0)
2429 _size.Z = 0.01f;
2430 // Construction of new prim
2431
2432 CreateGeom();
2433
2434 if (prim_geom != IntPtr.Zero)
2435 {
2436 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
2437 d.Quaternion myrot = new d.Quaternion();
2438 myrot.X = _orientation.X;
2439 myrot.Y = _orientation.Y;
2440 myrot.Z = _orientation.Z;
2441 myrot.W = _orientation.W;
2442 d.GeomSetQuaternion(prim_geom, ref myrot);
2443 }
2444
2445 if (chp)
2446 {
2447 if (parent != null)
2448 {
2449 parent.MakeBody();
2450 }
2451 }
2452 else
2453 MakeBody();
2454
2455 resetCollisionAccounting();
2456 }
2457
2458 private void changeSize(Vector3 newSize)
2459 {
2460 _size = newSize;
2461 changeprimsizeshape();
2462 }
2463
2464 private void changeShape(PrimitiveBaseShape newShape)
2465 {
2466 _pbs = newShape;
2467 changeprimsizeshape();
2468 }
2469
2470 private void changeFloatOnWater(bool newval)
2471 {
2472 m_collidesWater = newval;
2473
2474 if (prim_geom != IntPtr.Zero)
2475 {
2476 if (m_collidesWater)
2477 {
2478 m_collisionFlags |= CollisionCategories.Water;
2479 }
2480 else
2481 {
2482 m_collisionFlags &= ~CollisionCategories.Water;
2483 }
2484 d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
2485 }
2486 }
2487
2488 private void changeSetTorque(Vector3 newtorque)
2489 {
2490 if (!m_isSelected)
2491 {
2492 if (m_isphysical && Body != IntPtr.Zero)
2493 {
2494 if (m_disabled)
2495 enableBodySoft();
2496 else if (!d.BodyIsEnabled(Body))
2497 d.BodyEnable(Body);
2498
2499 }
2500 _torque = newtorque;
2501 }
2502 }
2503
2504 private void changeForce(Vector3 force)
2505 {
2506 m_force = force;
2507 if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))
2508 d.BodyEnable(Body);
2509 }
2510
2511 private void changeAddForce(Vector3 force)
2512 {
2513 m_forceacc += force;
2514 if (!m_isSelected)
2515 {
2516 lock (this)
2517 {
2518 //m_log.Info("[PHYSICS]: dequeing forcelist");
2519 if (m_isphysical && Body != IntPtr.Zero)
2520 {
2521 if (m_disabled)
2522 enableBodySoft();
2523 else if (!d.BodyIsEnabled(Body))
2524 d.BodyEnable(Body);
2525 }
2526 }
2527
2528 m_collisionscore = 0;
2529 }
2530 }
2531
2532 private void changeAddAngularForce(Vector3 aforce)
2533 {
2534 m_angularForceacc += aforce;
2535 if (!m_isSelected)
2536 {
2537 lock (this)
2538 {
2539 if (m_isphysical && Body != IntPtr.Zero)
2540 {
2541 if (m_disabled)
2542 enableBodySoft();
2543 else if (!d.BodyIsEnabled(Body))
2544 d.BodyEnable(Body);
2545 }
2546 }
2547 m_collisionscore = 0;
2548 }
2549 }
2550
2551 private void changevelocity(Vector3 newVel)
2552 {
2553 if (!m_isSelected)
2554 {
2555 if (Body != IntPtr.Zero)
2556 {
2557 if (m_disabled)
2558 enableBodySoft();
2559 else if (!d.BodyIsEnabled(Body))
2560 d.BodyEnable(Body);
2561
2562 d.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);
2563 }
2564 //resetCollisionAccounting();
2565 }
2566 _velocity = newVel;
2567 }
2568
2569 private void changeVolumedetetion(bool newVolDtc)
2570 {
2571 m_isVolumeDetect = newVolDtc;
2572 }
2573
2574 protected void changeBuilding(bool newbuilding)
2575 {
2576 if ((bool)newbuilding)
2577 {
2578 m_building = true;
2579 DestroyBody();
2580 }
2581 else
2582 {
2583 m_building = false;
2584 CheckDelaySelect();
2585 if (!childPrim)
2586 MakeBody();
2587 }
2588 if (!childPrim && childrenPrim.Count > 0)
2589 {
2590 foreach (OdePrim prm in childrenPrim)
2591 prm.changeBuilding(m_building); // call directly
2592 }
2593 }
2594
2595 public void changeSetVehicle(VehicleData vdata)
2596 {
2597 if (m_vehicle == null)
2598 m_vehicle = new ODEDynamics(this);
2599 m_vehicle.DoSetVehicle(vdata);
2600 }
2601 private void changeVehicleType(int value)
2602 {
2603 if (value == (int)Vehicle.TYPE_NONE)
2604 {
2605 if (m_vehicle != null)
2606 m_vehicle = null;
2607 }
2608 else
2609 {
2610 if (m_vehicle == null)
2611 m_vehicle = new ODEDynamics(this);
2612
2613 m_vehicle.ProcessTypeChange((Vehicle)value);
2614 }
2615 }
2616
2617 private void changeVehicleFloatParam(strVehicleFloatParam fp)
2618 {
2619 if (m_vehicle == null)
2620 return;
2621
2622 m_vehicle.ProcessFloatVehicleParam((Vehicle)fp.param, fp.value);
2623 }
2624
2625 private void changeVehicleVectorParam(strVehicleVectorParam vp)
2626 {
2627 if (m_vehicle == null)
2628 return;
2629 m_vehicle.ProcessVectorVehicleParam((Vehicle)vp.param, vp.value);
2630 }
2631
2632 private void changeVehicleRotationParam(strVehicleQuatParam qp)
2633 {
2634 if (m_vehicle == null)
2635 return;
2636 m_vehicle.ProcessRotationVehicleParam((Vehicle)qp.param, qp.value);
2637 }
2638
2639 private void changeVehicleFlags(strVehicleBoolParam bp)
2640 {
2641 if (m_vehicle == null)
2642 return;
2643 m_vehicle.ProcessVehicleFlags(bp.param, bp.value);
2644 }
2645
2646 #endregion
2647
2648 public void Move()
2649 {
2650 if (!childPrim && m_isphysical && Body != IntPtr.Zero &&
2651 !m_disabled && !m_isSelected && d.BodyIsEnabled(Body) && !m_building) // KF: Only move root prims.
2652 {
2653 // if (!d.BodyIsEnabled(Body)) d.BodyEnable(Body); // KF add 161009
2654
2655 float timestep = _parent_scene.ODE_STEPSIZE;
2656
2657 float fx = 0;
2658 float fy = 0;
2659 float fz = 0;
2660
2661 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
2662 {
2663 // 'VEHICLES' are dealt with in ODEDynamics.cs
2664 m_vehicle.Step();
2665 }
2666 else
2667 {
2668 float m_mass = _mass;
2669
2670 // fz = 0f;
2671 //m_log.Info(m_collisionFlags.ToString());
2672 if (m_usePID)
2673 {
2674
2675 // If the PID Controller isn't active then we set our force
2676 // calculating base velocity to the current position
2677
2678 if ((m_PIDTau < 1) && (m_PIDTau != 0))
2679 {
2680 //PID_G = PID_G / m_PIDTau;
2681 m_PIDTau = 1;
2682 }
2683
2684 if ((PID_G - m_PIDTau) <= 0)
2685 {
2686 PID_G = m_PIDTau + 1;
2687 }
2688
2689 d.Vector3 vel = d.BodyGetLinearVel(Body);
2690 d.Vector3 pos = d.BodyGetPosition(Body);
2691 _target_velocity =
2692 new Vector3(
2693 (m_PIDTarget.X - pos.X) * ((PID_G - m_PIDTau) * timestep),
2694 (m_PIDTarget.Y - pos.Y) * ((PID_G - m_PIDTau) * timestep),
2695 (m_PIDTarget.Z - pos.Z) * ((PID_G - m_PIDTau) * timestep)
2696 );
2697
2698 // if velocity is zero, use position control; otherwise, velocity control
2699
2700 if (_target_velocity.ApproxEquals(Vector3.Zero, 0.1f))
2701 {
2702 // keep track of where we stopped. No more slippin' & slidin'
2703
2704 // We only want to deactivate the PID Controller if we think we want to have our surrogate
2705 // react to the physics scene by moving it's position.
2706 // Avatar to Avatar collisions
2707 // Prim to avatar collisions
2708
2709 //fx = (_target_velocity.X - vel.X) * (PID_D) + (_zeroPosition.X - pos.X) * (PID_P * 2);
2710 //fy = (_target_velocity.Y - vel.Y) * (PID_D) + (_zeroPosition.Y - pos.Y) * (PID_P * 2);
2711 //fz = fz + (_target_velocity.Z - vel.Z) * (PID_D) + (_zeroPosition.Z - pos.Z) * PID_P;
2712 d.BodySetPosition(Body, m_PIDTarget.X, m_PIDTarget.Y, m_PIDTarget.Z);
2713 d.BodySetLinearVel(Body, 0, 0, 0);
2714 d.BodyAddForce(Body, 0, 0, fz);
2715 return;
2716 }
2717 else
2718 {
2719 _zeroFlag = false;
2720
2721 // We're flying and colliding with something
2722 fx = ((_target_velocity.X) - vel.X) * (PID_D);
2723 fy = ((_target_velocity.Y) - vel.Y) * (PID_D);
2724
2725 // vec.Z = (_target_velocity.Z - vel.Z) * PID_D + (_zeroPosition.Z - pos.Z) * PID_P;
2726
2727 fz = ((_target_velocity.Z - vel.Z) * (PID_D));
2728 }
2729 } // end if (m_usePID)
2730
2731 // Hover PID Controller needs to be mutually exlusive to MoveTo PID controller
2732 else if (m_useHoverPID)
2733 {
2734 //Console.WriteLine("Hover " + Name);
2735
2736 // If we're using the PID controller, then we have no gravity
2737
2738 // no lock; for now it's only called from within Simulate()
2739
2740 // If the PID Controller isn't active then we set our force
2741 // calculating base velocity to the current position
2742
2743 if ((m_PIDTau < 1))
2744 {
2745 PID_G = PID_G / m_PIDTau;
2746 }
2747
2748 if ((PID_G - m_PIDTau) <= 0)
2749 {
2750 PID_G = m_PIDTau + 1;
2751 }
2752
2753 // Where are we, and where are we headed?
2754 d.Vector3 pos = d.BodyGetPosition(Body);
2755 d.Vector3 vel = d.BodyGetLinearVel(Body);
2756
2757 // Non-Vehicles have a limited set of Hover options.
2758 // determine what our target height really is based on HoverType
2759 switch (m_PIDHoverType)
2760 {
2761 case PIDHoverType.Ground:
2762 m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y);
2763 m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
2764 break;
2765 case PIDHoverType.GroundAndWater:
2766 m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y);
2767 m_waterHeight = _parent_scene.GetWaterLevel();
2768 if (m_groundHeight > m_waterHeight)
2769 {
2770 m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
2771 }
2772 else
2773 {
2774 m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight;
2775 }
2776 break;
2777
2778 } // end switch (m_PIDHoverType)
2779
2780
2781 _target_velocity =
2782 new Vector3(0.0f, 0.0f,
2783 (m_targetHoverHeight - pos.Z) * ((PID_G - m_PIDHoverTau) * timestep)
2784 );
2785
2786 // if velocity is zero, use position control; otherwise, velocity control
2787
2788 if (_target_velocity.ApproxEquals(Vector3.Zero, 0.1f))
2789 {
2790 // keep track of where we stopped. No more slippin' & slidin'
2791
2792 // We only want to deactivate the PID Controller if we think we want to have our surrogate
2793 // react to the physics scene by moving it's position.
2794 // Avatar to Avatar collisions
2795 // Prim to avatar collisions
2796
2797 d.BodySetPosition(Body, pos.X, pos.Y, m_targetHoverHeight);
2798 d.BodySetLinearVel(Body, vel.X, vel.Y, 0);
2799 // ? d.BodyAddForce(Body, 0, 0, fz);
2800 return;
2801 }
2802 else
2803 {
2804 _zeroFlag = false;
2805
2806 // We're flying and colliding with something
2807 fz = ((_target_velocity.Z - vel.Z) * (PID_D));
2808 }
2809 }
2810 else
2811 {
2812 float b = (1.0f - m_buoyancy);
2813 fx = _parent_scene.gravityx * b;
2814 fy = _parent_scene.gravityy * b;
2815 fz = _parent_scene.gravityz * b;
2816 }
2817
2818 fx *= m_mass;
2819 fy *= m_mass;
2820 fz *= m_mass;
2821
2822 // constant force
2823 fx += m_force.X;
2824 fy += m_force.Y;
2825 fz += m_force.Z;
2826
2827 fx += m_forceacc.X;
2828 fy += m_forceacc.Y;
2829 fz += m_forceacc.Z;
2830
2831 m_forceacc = Vector3.Zero;
2832
2833 //m_log.Info("[OBJPID]: X:" + fx.ToString() + " Y:" + fy.ToString() + " Z:" + fz.ToString());
2834 if (fx != 0 || fy != 0 || fz != 0)
2835 {
2836 d.BodyAddForce(Body, fx, fy, fz);
2837 //Console.WriteLine("AddForce " + fx + "," + fy + "," + fz);
2838 }
2839
2840 Vector3 trq;
2841
2842 trq = _torque;
2843 trq += m_angularForceacc;
2844 m_angularForceacc = Vector3.Zero;
2845 if (trq.X != 0 || trq.Y != 0 || trq.Z != 0)
2846 {
2847 d.BodyAddTorque(Body, trq.X, trq.Y, trq.Z);
2848 }
2849
2850 }
2851 }
2852 else
2853 { // is not physical, or is not a body or is selected
2854 // _zeroPosition = d.BodyGetPosition(Body);
2855 return;
2856 //Console.WriteLine("Nothing " + Name);
2857
2858 }
2859 }
2860
2861
2862 public void UpdatePositionAndVelocity(float simulatedtime)
2863 {
2864 // no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
2865 if (_parent == null && !m_disabled && !m_building)
2866 {
2867 if (Body != IntPtr.Zero)
2868 {
2869 Vector3 pv = Vector3.Zero;
2870 bool lastZeroFlag = _zeroFlag;
2871
2872 d.Vector3 lpos;
2873 d.GeomCopyPosition(prim_geom, out lpos); // root position that is seem by rest of simulator
2874
2875 // we need to use root position since that's all the rest of scene uses
2876 if (lpos.X < 0f || lpos.X > _parent_scene.WorldExtents.X
2877 || lpos.Y < 0f || lpos.Y > _parent_scene.WorldExtents.Y
2878 )
2879 {
2880 // we are outside current region
2881 // we can't let it keeping moving and having colisions
2882 // since it can be stucked between something like terrain and edge
2883 // so lets stop and disable it until something else kicks it
2884
2885 _position.X = Util.Clip(lpos.X, -0.2f, _parent_scene.WorldExtents.X + 0.2f);
2886 _position.Y = Util.Clip(lpos.Y, -0.2f, _parent_scene.WorldExtents.Y + 0.2f);
2887 _position.Z = Util.Clip(lpos.Z, -100f, 50000f);
2888
2889 m_lastposition = _position;
2890// m_lastorientation = _orientation;
2891
2892 d.BodySetLinearVel(Body, 0, 0, 0); // stop it
2893// d.BodySetAngularVel(Body, 0, 0, 0);
2894 d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
2895 disableBodySoft(); // stop collisions
2896 m_outbounds = true;
2897 base.RequestPhysicsterseUpdate();
2898 return;
2899 }
2900
2901 if (lpos.Z < -100 || lpos.Z > 100000f)
2902 {
2903 lpos.Z = Util.Clip(lpos.Z, -100f, 50000f);
2904
2905 _acceleration.X = 0;
2906 _acceleration.Y = 0;
2907 _acceleration.Z = 0;
2908
2909 _velocity.X = 0;
2910 _velocity.Y = 0;
2911 _velocity.Z = 0;
2912 m_rotationalVelocity.X = 0;
2913 m_rotationalVelocity.Y = 0;
2914 m_rotationalVelocity.Z = 0;
2915
2916 d.BodySetLinearVel(Body, 0, 0, 0); // stop it
2917 d.BodySetAngularVel(Body, 0, 0, 0); // stop it
2918 d.BodySetPosition(Body, lpos.X, lpos.Y, lpos.Z); // put it somewhere
2919 m_lastposition = _position;
2920 m_lastorientation = _orientation;
2921
2922 base.RequestPhysicsterseUpdate();
2923
2924 m_throttleUpdates = false;
2925 throttleCounter = 0;
2926 _zeroFlag = true;
2927
2928 disableBodySoft(); // disable it and colisions
2929 base.RaiseOutOfBounds(_position);
2930
2931 return;
2932 }
2933
2934 d.Quaternion ori;
2935 d.GeomCopyQuaternion(prim_geom, out ori);
2936 d.Vector3 vel = d.BodyGetLinearVel(Body);
2937 d.Vector3 rotvel = d.BodyGetAngularVel(Body);
2938
2939 if ((Math.Abs(m_lastposition.X - lpos.X) < 0.01)
2940 && (Math.Abs(m_lastposition.Y - lpos.Y) < 0.01)
2941 && (Math.Abs(m_lastposition.Z - lpos.Z) < 0.01)
2942 && (Math.Abs(m_lastorientation.X - ori.X) < 0.0001)
2943 && (Math.Abs(m_lastorientation.Y - ori.Y) < 0.0001)
2944 && (Math.Abs(m_lastorientation.Z - ori.Z) < 0.0001)
2945 )
2946 {
2947 _zeroFlag = true;
2948 //Console.WriteLine("ZFT 2");
2949 m_throttleUpdates = false;
2950 }
2951 else
2952 {
2953 //m_log.Debug(Math.Abs(m_lastposition.X - l_position.X).ToString());
2954 _zeroFlag = false;
2955 m_lastUpdateSent = false;
2956 //m_throttleUpdates = false;
2957 }
2958
2959 if (_zeroFlag)
2960 {
2961 m_lastposition = _position;
2962 m_lastorientation = _orientation;
2963
2964 _velocity.X = 0.0f;
2965 _velocity.Y = 0.0f;
2966 _velocity.Z = 0.0f;
2967
2968 _acceleration.X = 0;
2969 _acceleration.Y = 0;
2970 _acceleration.Z = 0;
2971
2972 m_rotationalVelocity.X = 0;
2973 m_rotationalVelocity.Y = 0;
2974 m_rotationalVelocity.Z = 0;
2975 if (!m_lastUpdateSent)
2976 {
2977 m_throttleUpdates = false;
2978 throttleCounter = 0;
2979 m_rotationalVelocity = pv;
2980
2981 base.RequestPhysicsterseUpdate();
2982
2983 m_lastUpdateSent = true;
2984 }
2985 }
2986 else
2987 {
2988 if (lastZeroFlag != _zeroFlag)
2989 {
2990 base.RequestPhysicsterseUpdate();
2991 }
2992
2993 m_lastVelocity = _velocity;
2994
2995 _position.X = lpos.X;
2996 _position.Y = lpos.Y;
2997 _position.Z = lpos.Z;
2998
2999 _velocity.X = vel.X;
3000 _velocity.Y = vel.Y;
3001 _velocity.Z = vel.Z;
3002
3003 _orientation.X = ori.X;
3004 _orientation.Y = ori.Y;
3005 _orientation.Z = ori.Z;
3006 _orientation.W = ori.W;
3007
3008 _acceleration = ((_velocity - m_lastVelocity) / simulatedtime);
3009
3010 if (m_rotationalVelocity.ApproxEquals(pv, 0.0001f))
3011 {
3012 m_rotationalVelocity = pv;
3013 }
3014 else
3015 {
3016 m_rotationalVelocity.X = rotvel.X;
3017 m_rotationalVelocity.Y = rotvel.Y;
3018 m_rotationalVelocity.Z = rotvel.Z;
3019 }
3020
3021 m_lastUpdateSent = false;
3022 if (!m_throttleUpdates || throttleCounter > _parent_scene.geomUpdatesPerThrottledUpdate)
3023 {
3024 m_lastposition = _position;
3025 m_lastorientation = _orientation;
3026 base.RequestPhysicsterseUpdate();
3027 }
3028 else
3029 {
3030 throttleCounter++;
3031 }
3032 }
3033 }
3034 else if (!m_lastUpdateSent || !_zeroFlag)
3035 {
3036 // Not a body.. so Make sure the client isn't interpolating
3037 _velocity.X = 0;
3038 _velocity.Y = 0;
3039 _velocity.Z = 0;
3040
3041 _acceleration.X = 0;
3042 _acceleration.Y = 0;
3043 _acceleration.Z = 0;
3044
3045 m_rotationalVelocity.X = 0;
3046 m_rotationalVelocity.Y = 0;
3047 m_rotationalVelocity.Z = 0;
3048 _zeroFlag = true;
3049
3050 if (!m_lastUpdateSent)
3051 {
3052 m_throttleUpdates = false;
3053 throttleCounter = 0;
3054
3055 base.RequestPhysicsterseUpdate();
3056
3057 m_lastUpdateSent = true;
3058 }
3059 }
3060 }
3061 }
3062
3063 internal static bool QuaternionIsFinite(Quaternion q)
3064 {
3065 if (Single.IsNaN(q.X) || Single.IsInfinity(q.X))
3066 return false;
3067 if (Single.IsNaN(q.Y) || Single.IsInfinity(q.Y))
3068 return false;
3069 if (Single.IsNaN(q.Z) || Single.IsInfinity(q.Z))
3070 return false;
3071 if (Single.IsNaN(q.W) || Single.IsInfinity(q.W))
3072 return false;
3073 return true;
3074 }
3075
3076 internal static void DMassCopy(ref d.Mass src, ref d.Mass dst)
3077 {
3078 dst.c.W = src.c.W;
3079 dst.c.X = src.c.X;
3080 dst.c.Y = src.c.Y;
3081 dst.c.Z = src.c.Z;
3082 dst.mass = src.mass;
3083 dst.I.M00 = src.I.M00;
3084 dst.I.M01 = src.I.M01;
3085 dst.I.M02 = src.I.M02;
3086 dst.I.M10 = src.I.M10;
3087 dst.I.M11 = src.I.M11;
3088 dst.I.M12 = src.I.M12;
3089 dst.I.M20 = src.I.M20;
3090 dst.I.M21 = src.I.M21;
3091 dst.I.M22 = src.I.M22;
3092 }
3093
3094 private static void DMassDup(ref d.Mass src, out d.Mass dst)
3095 {
3096 dst = new d.Mass { };
3097
3098 dst.c.W = src.c.W;
3099 dst.c.X = src.c.X;
3100 dst.c.Y = src.c.Y;
3101 dst.c.Z = src.c.Z;
3102 dst.mass = src.mass;
3103 dst.I.M00 = src.I.M00;
3104 dst.I.M01 = src.I.M01;
3105 dst.I.M02 = src.I.M02;
3106 dst.I.M10 = src.I.M10;
3107 dst.I.M11 = src.I.M11;
3108 dst.I.M12 = src.I.M12;
3109 dst.I.M20 = src.I.M20;
3110 dst.I.M21 = src.I.M21;
3111 dst.I.M22 = src.I.M22;
3112 }
3113 private void donullchange()
3114 {
3115 }
3116
3117 public bool DoAChange(changes what, object arg)
3118 {
3119 if (prim_geom == IntPtr.Zero && what != changes.Add && what != changes.Remove)
3120 {
3121 return false;
3122 }
3123
3124 // nasty switch
3125 switch (what)
3126 {
3127 case changes.Add:
3128 changeadd();
3129 break;
3130 case changes.Remove:
3131 //If its being removed, we don't want to rebuild the physical rep at all, so ignore this stuff...
3132 //When we return true, it destroys all of the prims in the linkset anyway
3133 if (_parent != null)
3134 {
3135 OdePrim parent = (OdePrim)_parent;
3136 parent.ChildRemove(this, false);
3137 }
3138 else
3139 ChildRemove(this, false);
3140
3141 m_vehicle = null;
3142 RemoveGeom();
3143 m_targetSpace = IntPtr.Zero;
3144 if (m_eventsubscription > 0)
3145 UnSubscribeEvents();
3146 return true;
3147
3148 case changes.Link:
3149 OdePrim tmp = (OdePrim)arg;
3150 changeLink(tmp);
3151 break;
3152
3153 case changes.DeLink:
3154 changeLink(null);
3155 break;
3156
3157 case changes.Position:
3158 changePosition((Vector3)arg);
3159 break;
3160
3161 case changes.Orientation:
3162 changeOrientation((Quaternion)arg);
3163 break;
3164
3165 case changes.PosOffset:
3166 donullchange();
3167 break;
3168
3169 case changes.OriOffset:
3170 donullchange();
3171 break;
3172
3173 case changes.Velocity:
3174 changevelocity((Vector3)arg);
3175 break;
3176
3177 // case changes.Acceleration:
3178 // changeacceleration((Vector3)arg);
3179 // break;
3180 // case changes.AngVelocity:
3181 // changeangvelocity((Vector3)arg);
3182 // break;
3183
3184 case changes.Force:
3185 changeForce((Vector3)arg);
3186 break;
3187
3188 case changes.Torque:
3189 changeSetTorque((Vector3)arg);
3190 break;
3191
3192 case changes.AddForce:
3193 changeAddForce((Vector3)arg);
3194 break;
3195
3196 case changes.AddAngForce:
3197 changeAddAngularForce((Vector3)arg);
3198 break;
3199
3200 case changes.AngLock:
3201 changeAngularLock((Vector3)arg);
3202 break;
3203
3204 case changes.Size:
3205 changeSize((Vector3)arg);
3206 break;
3207
3208 case changes.Shape:
3209 changeShape((PrimitiveBaseShape)arg);
3210 break;
3211
3212 case changes.CollidesWater:
3213 changeFloatOnWater((bool)arg);
3214 break;
3215
3216 case changes.VolumeDtc:
3217 changeVolumedetetion((bool)arg);
3218 break;
3219
3220 case changes.Physical:
3221 changePhysicsStatus((bool)arg);
3222 break;
3223
3224 case changes.Selected:
3225 changeSelectedStatus((bool)arg);
3226 break;
3227
3228 case changes.disabled:
3229 changeDisable((bool)arg);
3230 break;
3231
3232 case changes.building:
3233 changeBuilding((bool)arg);
3234 break;
3235
3236 case changes.VehicleType:
3237 changeVehicleType((int)arg);
3238 break;
3239
3240 case changes.VehicleFlags:
3241 changeVehicleFlags((strVehicleBoolParam) arg);
3242 break;
3243
3244 case changes.VehicleFloatParam:
3245 changeVehicleFloatParam((strVehicleFloatParam) arg);
3246 break;
3247
3248 case changes.VehicleVectorParam:
3249 changeVehicleVectorParam((strVehicleVectorParam) arg);
3250 break;
3251
3252 case changes.VehicleRotationParam:
3253 changeVehicleRotationParam((strVehicleQuatParam) arg);
3254 break;
3255
3256 case changes.SetVehicle:
3257 changeSetVehicle((VehicleData) arg);
3258 break;
3259 case changes.Null:
3260 donullchange();
3261 break;
3262
3263 default:
3264 donullchange();
3265 break;
3266 }
3267 return false;
3268 }
3269
3270 public void AddChange(changes what, object arg)
3271 {
3272 _parent_scene.AddChange((PhysicsActor) this, what, arg);
3273 }
3274
3275
3276 private struct strVehicleBoolParam
3277 {
3278 public int param;
3279 public bool value;
3280 }
3281
3282 private struct strVehicleFloatParam
3283 {
3284 public int param;
3285 public float value;
3286 }
3287
3288 private struct strVehicleQuatParam
3289 {
3290 public int param;
3291 public Quaternion value;
3292 }
3293
3294 private struct strVehicleVectorParam
3295 {
3296 public int param;
3297 public Vector3 value;
3298 }
3299 }
3300} \ 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..215d47a
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdePlugin.cs
@@ -0,0 +1,86 @@
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 (d.InitODE2(0) != 0)
56 {
57 if (d.AllocateODEDataForThread(~0U) == 0)
58 {
59 d.CloseODE();
60 return false;
61 }
62 return true;
63 }
64 return false;
65 }
66
67 public PhysicsScene GetScene(String sceneIdentifier)
68 {
69 if (m_scene == null)
70 {
71 m_scene = new OdeScene(sceneIdentifier);
72 }
73 return (m_scene);
74 }
75
76 public string GetName()
77 {
78 return ("UbitODE");
79 }
80
81 public void Dispose()
82 {
83 d.CloseODE();
84 }
85 }
86} \ 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..6e4c373
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
@@ -0,0 +1,2272 @@
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 Selected,
132 disabled,
133 building,
134
135 VehicleType,
136 VehicleFloatParam,
137 VehicleVectorParam,
138 VehicleRotationParam,
139 VehicleFlags,
140 SetVehicle,
141
142 Null //keep this last used do dim the methods array. does nothing but pulsing the prim
143 }
144
145 public struct ODEchangeitem
146 {
147 public PhysicsActor actor;
148 public OdeCharacter character;
149 public changes what;
150 public Object arg;
151 }
152
153 public class OdeScene : PhysicsScene
154 {
155 private readonly ILog m_log;
156 // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
157
158 private int threadid = 0;
159 private Random fluidRandomizer = new Random(Environment.TickCount);
160
161 const d.ContactFlags comumContactFlags = d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM |d.ContactFlags.Approx1 | d.ContactFlags.Bounce;
162 const float comumContactERP = 0.6f;
163 const float comumSoftContactERP = 0.1f;
164 const float comumContactCFM = 0.0001f;
165
166 float frictionScale = 1.0f;
167
168 float frictionMovementMult = 0.3f;
169
170 float TerrainBounce = 0.1f;
171 float TerrainFriction = 0.1f;
172
173 public float AvatarBounce = 0.3f;
174 public float AvatarFriction = 0;// 0.9f * 0.5f;
175
176 private const uint m_regionWidth = Constants.RegionSize;
177 private const uint m_regionHeight = Constants.RegionSize;
178
179 public float ODE_STEPSIZE = 0.020f;
180 private float metersInSpace = 25.6f;
181 private float m_timeDilation = 1.0f;
182
183 public float gravityx = 0f;
184 public float gravityy = 0f;
185 public float gravityz = -9.8f;
186
187 private float waterlevel = 0f;
188 private int framecount = 0;
189
190 internal IntPtr WaterGeom;
191
192 public float avPIDD = 3200f; // make it visible
193 public float avPIDP = 1400f; // make it visible
194 private float avCapRadius = 0.37f;
195 private float avDensity = 3f;
196 private float avMovementDivisorWalk = 1.3f;
197 private float avMovementDivisorRun = 0.8f;
198 private float minimumGroundFlightOffset = 3f;
199 public float maximumMassObject = 10000.01f;
200
201 public bool meshSculptedPrim = true;
202 public bool forceSimplePrimMeshing = false;
203
204 public float meshSculptLOD = 32;
205 public float MeshSculptphysicalLOD = 16;
206
207 public float geomDefaultDensity = 10.000006836f;
208
209 public int geomContactPointsStartthrottle = 3;
210 public int geomUpdatesPerThrottledUpdate = 15;
211
212 public float bodyPIDD = 35f;
213 public float bodyPIDG = 25;
214
215 public int geomCrossingFailuresBeforeOutofbounds = 6;
216
217 public int bodyFramesAutoDisable = 20;
218
219 private float[] _watermap;
220 private bool m_filterCollisions = true;
221
222 private d.NearCallback nearCallback;
223
224 private readonly HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
225 private readonly HashSet<OdePrim> _prims = new HashSet<OdePrim>();
226 private readonly HashSet<OdePrim> _activeprims = new HashSet<OdePrim>();
227
228 public OpenSim.Framework.LocklessQueue<ODEchangeitem> ChangesQueue = new OpenSim.Framework.LocklessQueue<ODEchangeitem>();
229
230 /// <summary>
231 /// A list of actors that should receive collision events.
232 /// </summary>
233 private readonly List<PhysicsActor> _collisionEventPrim = new List<PhysicsActor>();
234
235 private readonly HashSet<OdeCharacter> _badCharacter = new HashSet<OdeCharacter>();
236 public Dictionary<IntPtr, String> geom_name_map = new Dictionary<IntPtr, String>();
237 public Dictionary<IntPtr, PhysicsActor> actor_name_map = new Dictionary<IntPtr, PhysicsActor>();
238
239 private float contactsurfacelayer = 0.002f;
240
241 private int contactsPerCollision = 80;
242 internal IntPtr ContactgeomsArray = IntPtr.Zero;
243 private IntPtr GlobalContactsArray = IntPtr.Zero;
244
245 const int maxContactsbeforedeath = 4000;
246 private volatile int m_global_contactcount = 0;
247
248
249 private readonly IntPtr contactgroup;
250
251 public ContactData[] m_materialContactsData = new ContactData[8];
252
253 private readonly DoubleDictionary<Vector3, IntPtr, IntPtr> RegionTerrain = new DoubleDictionary<Vector3, IntPtr, IntPtr>();
254 private readonly Dictionary<IntPtr, float[]> TerrainHeightFieldHeights = new Dictionary<IntPtr, float[]>();
255 private readonly Dictionary<IntPtr, GCHandle> TerrainHeightFieldHeightsHandlers = new Dictionary<IntPtr, GCHandle>();
256
257 private int m_physicsiterations = 10;
258 private const float m_SkipFramesAtms = 0.40f; // Drop frames gracefully at a 400 ms lag
259 private readonly PhysicsActor PANull = new NullPhysicsActor();
260 private float step_time = 0.0f;
261
262 public IntPtr world;
263
264 private uint obj2LocalID = 0;
265 private OdeCharacter cc1;
266 private OdePrim cp1;
267 private OdeCharacter cc2;
268 private OdePrim cp2;
269
270 // split the spaces acording to contents type
271 // ActiveSpace contains characters and active prims
272 // StaticSpace contains land and other that is mostly static in enviroment
273 // this can contain subspaces, like the grid in staticspace
274 // as now space only contains this 2 top spaces
275
276 public IntPtr TopSpace; // the global space
277 public IntPtr ActiveSpace; // space for active prims
278 public IntPtr StaticSpace; // space for the static things around
279
280 // some speedup variables
281 private int spaceGridMaxX;
282 private int spaceGridMaxY;
283 private float spacesPerMeter;
284
285 // split static geometry collision into a grid as before
286 private IntPtr[,] staticPrimspace;
287
288 private Object OdeLock;
289 private static Object SimulationLock;
290
291 public IMesher mesher;
292
293 private IConfigSource m_config;
294
295 public bool physics_logging = false;
296 public int physics_logging_interval = 0;
297 public bool physics_logging_append_existing_logfile = false;
298
299 private Vector3 m_worldOffset = Vector3.Zero;
300 public Vector2 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
301 private PhysicsScene m_parentScene = null;
302
303 private ODERayCastRequestManager m_rayCastManager;
304
305
306/* maybe needed if ode uses tls
307 private void checkThread()
308 {
309
310 int th = Thread.CurrentThread.ManagedThreadId;
311 if(th != threadid)
312 {
313 threadid = th;
314 d.AllocateODEDataForThread(~0U);
315 }
316 }
317 */
318 /// <summary>
319 /// Initiailizes the scene
320 /// Sets many properties that ODE requires to be stable
321 /// These settings need to be tweaked 'exactly' right or weird stuff happens.
322 /// </summary>
323 public OdeScene(string sceneIdentifier)
324 {
325 m_log
326 = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + sceneIdentifier);
327
328// checkThread();
329 Name = sceneIdentifier;
330
331 OdeLock = new Object();
332 SimulationLock = new Object();
333
334 nearCallback = near;
335
336 m_rayCastManager = new ODERayCastRequestManager(this);
337 lock (OdeLock)
338 {
339 // Create the world and the first space
340 try
341 {
342 world = d.WorldCreate();
343 TopSpace = d.HashSpaceCreate(IntPtr.Zero);
344
345 // now the major subspaces
346 ActiveSpace = d.HashSpaceCreate(TopSpace);
347 StaticSpace = d.HashSpaceCreate(TopSpace);
348 }
349 catch
350 {
351 // i must RtC#FM
352 }
353
354 d.HashSpaceSetLevels(TopSpace, -2, 8); // cell sizes from .25 to 256 ?? need check what this really does
355 d.HashSpaceSetLevels(ActiveSpace, -2, 8);
356 d.HashSpaceSetLevels(StaticSpace, -2, 8);
357
358 // demote to second level
359 d.SpaceSetSublevel(ActiveSpace, 1);
360 d.SpaceSetSublevel(StaticSpace, 1);
361
362 contactgroup = d.JointGroupCreate(0);
363 //contactgroup
364
365 d.WorldSetAutoDisableFlag(world, false);
366 }
367
368 _watermap = new float[258 * 258];
369 }
370
371 // Initialize the mesh plugin
372// public override void Initialise(IMesher meshmerizer, IConfigSource config, RegionInfo region )
373 public override void Initialise(IMesher meshmerizer, IConfigSource config)
374 {
375// checkThread();
376 mesher = meshmerizer;
377 m_config = config;
378
379// m_log.WarnFormat("ODE configuration: {0}", d.GetConfiguration("ODE"));
380 /*
381 if (region != null)
382 {
383 WorldExtents.X = region.RegionSizeX;
384 WorldExtents.Y = region.RegionSizeY;
385 }
386 */
387
388 // Defaults
389
390 avPIDD = 2200.0f;
391 avPIDP = 900.0f;
392
393 int contactsPerCollision = 80;
394
395 if (m_config != null)
396 {
397 IConfig physicsconfig = m_config.Configs["ODEPhysicsSettings"];
398 if (physicsconfig != null)
399 {
400 gravityx = physicsconfig.GetFloat("world_gravityx", 0f);
401 gravityy = physicsconfig.GetFloat("world_gravityy", 0f);
402 gravityz = physicsconfig.GetFloat("world_gravityz", -9.8f);
403
404 metersInSpace = physicsconfig.GetFloat("meters_in_small_space", 29.9f);
405
406 contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", contactsurfacelayer);
407
408 ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", 0.020f);
409 m_physicsiterations = physicsconfig.GetInt("world_internal_steps_without_collisions", 10);
410
411 avDensity = physicsconfig.GetFloat("av_density", avDensity);
412 avMovementDivisorWalk = physicsconfig.GetFloat("av_movement_divisor_walk", 1.3f);
413 avMovementDivisorRun = physicsconfig.GetFloat("av_movement_divisor_run", 0.8f);
414 avCapRadius = physicsconfig.GetFloat("av_capsule_radius", 0.37f);
415
416 contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", 80);
417
418 geomContactPointsStartthrottle = physicsconfig.GetInt("geom_contactpoints_start_throttling", 3);
419 geomUpdatesPerThrottledUpdate = physicsconfig.GetInt("geom_updates_before_throttled_update", 15);
420 geomCrossingFailuresBeforeOutofbounds = physicsconfig.GetInt("geom_crossing_failures_before_outofbounds", 5);
421
422 geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", 10.000006836f);
423 bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", 20);
424
425 bodyPIDD = physicsconfig.GetFloat("body_pid_derivative", 35f);
426 bodyPIDG = physicsconfig.GetFloat("body_pid_gain", 25f);
427
428 forceSimplePrimMeshing = physicsconfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
429 meshSculptedPrim = physicsconfig.GetBoolean("mesh_sculpted_prim", true);
430 meshSculptLOD = physicsconfig.GetFloat("mesh_lod", 32f);
431 MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", 16f);
432 m_filterCollisions = physicsconfig.GetBoolean("filter_collisions", false);
433
434 if (Environment.OSVersion.Platform == PlatformID.Unix)
435 {
436 avPIDD = physicsconfig.GetFloat("av_pid_derivative_linux", 2200.0f);
437 avPIDP = physicsconfig.GetFloat("av_pid_proportional_linux", 900.0f);
438 }
439 else
440 {
441 avPIDD = physicsconfig.GetFloat("av_pid_derivative_win", 2200.0f);
442 avPIDP = physicsconfig.GetFloat("av_pid_proportional_win", 900.0f);
443 }
444
445 physics_logging = physicsconfig.GetBoolean("physics_logging", false);
446 physics_logging_interval = physicsconfig.GetInt("physics_logging_interval", 0);
447 physics_logging_append_existing_logfile = physicsconfig.GetBoolean("physics_logging_append_existing_logfile", false);
448
449 minimumGroundFlightOffset = physicsconfig.GetFloat("minimum_ground_flight_offset", 3f);
450 maximumMassObject = physicsconfig.GetFloat("maximum_mass_object", 10000.01f);
451 }
452 }
453
454 ContactgeomsArray = Marshal.AllocHGlobal(contactsPerCollision * d.ContactGeom.unmanagedSizeOf);
455 GlobalContactsArray = GlobalContactsArray = Marshal.AllocHGlobal(maxContactsbeforedeath * d.Contact.unmanagedSizeOf);
456
457 m_materialContactsData[(int)Material.Stone].mu = frictionScale * 0.8f;
458 m_materialContactsData[(int)Material.Stone].bounce = 0.4f;
459
460 m_materialContactsData[(int)Material.Metal].mu = frictionScale * 0.3f;
461 m_materialContactsData[(int)Material.Metal].bounce = 0.4f;
462
463 m_materialContactsData[(int)Material.Glass].mu = frictionScale * 0.2f;
464 m_materialContactsData[(int)Material.Glass].bounce = 0.7f;
465
466 m_materialContactsData[(int)Material.Wood].mu = frictionScale * 0.6f;
467 m_materialContactsData[(int)Material.Wood].bounce = 0.5f;
468
469 m_materialContactsData[(int)Material.Flesh].mu = frictionScale * 0.9f;
470 m_materialContactsData[(int)Material.Flesh].bounce = 0.3f;
471
472 m_materialContactsData[(int)Material.Plastic].mu = frictionScale * 0.4f;
473 m_materialContactsData[(int)Material.Plastic].bounce = 0.7f;
474
475 m_materialContactsData[(int)Material.Rubber].mu = frictionScale * 0.9f;
476 m_materialContactsData[(int)Material.Rubber].bounce = 0.95f;
477
478 m_materialContactsData[(int)Material.light].mu = 0.0f;
479 m_materialContactsData[(int)Material.light].bounce = 0.0f;
480
481 TerrainFriction *= frictionScale;
482// AvatarFriction *= frictionScale;
483
484 // Set the gravity,, don't disable things automatically (we set it explicitly on some things)
485
486 d.WorldSetGravity(world, gravityx, gravityy, gravityz);
487 d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
488
489 d.WorldSetLinearDamping(world, 0.001f);
490 d.WorldSetAngularDamping(world, 0.001f);
491 d.WorldSetAngularDampingThreshold(world, 0f);
492 d.WorldSetLinearDampingThreshold(world, 0f);
493 d.WorldSetMaxAngularSpeed(world, 256f);
494
495 d.WorldSetCFM(world,1e-6f); // a bit harder than default
496 //d.WorldSetCFM(world, 1e-4f); // a bit harder than default
497 d.WorldSetERP(world, 0.6f); // higher than original
498
499 // Set how many steps we go without running collision testing
500 // This is in addition to the step size.
501 // Essentially Steps * m_physicsiterations
502 d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
503 d.WorldSetContactMaxCorrectingVel(world, 100.0f);
504
505 spacesPerMeter = 1 / metersInSpace;
506 spaceGridMaxX = (int)(WorldExtents.X * spacesPerMeter);
507 spaceGridMaxY = (int)(WorldExtents.Y * spacesPerMeter);
508
509 staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY];
510
511 // create all spaces now
512 int i, j;
513 IntPtr newspace;
514 for (i = 0; i < spaceGridMaxX; i++)
515 for (j = 0; j < spaceGridMaxY; j++)
516 {
517 newspace = d.HashSpaceCreate(StaticSpace);
518 d.GeomSetCategoryBits(newspace, (int)CollisionCategories.Space);
519 waitForSpaceUnlock(newspace);
520 d.SpaceSetSublevel(newspace, 2);
521 d.HashSpaceSetLevels(newspace, -2, 8);
522 staticPrimspace[i, j] = newspace;
523 }
524 // let this now be real maximum values
525 spaceGridMaxX--;
526 spaceGridMaxY--;
527 }
528
529 internal void waitForSpaceUnlock(IntPtr space)
530 {
531 //if (space != IntPtr.Zero)
532 //while (d.SpaceLockQuery(space)) { } // Wait and do nothing
533 }
534
535 #region Collision Detection
536
537 // sets a global contact for a joint for contactgeom , and base contact description)
538
539 private IntPtr CreateContacJoint(ref d.ContactGeom contactGeom, float mu, float bounce, bool softerp)
540 {
541 if (GlobalContactsArray == IntPtr.Zero || m_global_contactcount >= maxContactsbeforedeath)
542 return IntPtr.Zero;
543
544 d.Contact newcontact = new d.Contact();
545 newcontact.geom.depth = contactGeom.depth;
546 newcontact.geom.g1 = contactGeom.g1;
547 newcontact.geom.g2 = contactGeom.g2;
548 newcontact.geom.pos = contactGeom.pos;
549 newcontact.geom.normal = contactGeom.normal;
550 newcontact.geom.side1 = contactGeom.side1;
551 newcontact.geom.side2 = contactGeom.side2;
552
553 // this needs bounce also
554 newcontact.surface.mode = comumContactFlags;
555 newcontact.surface.mu = mu;
556 newcontact.surface.bounce = bounce;
557 newcontact.surface.soft_cfm = comumContactCFM;
558 if (softerp)
559 newcontact.surface.soft_erp = comumSoftContactERP;
560 else
561 newcontact.surface.soft_erp = comumContactERP;
562
563 IntPtr contact = new IntPtr(GlobalContactsArray.ToInt64() + (Int64)(m_global_contactcount * d.Contact.unmanagedSizeOf));
564 Marshal.StructureToPtr(newcontact, contact, true);
565 return d.JointCreateContactPtr(world, contactgroup, contact);
566 }
567
568
569 /// <summary>
570 /// This is our near callback. A geometry is near a body
571 /// </summary>
572 /// <param name="space">The space that contains the geoms. Remember, spaces are also geoms</param>
573 /// <param name="g1">a geometry or space</param>
574 /// <param name="g2">another geometry or space</param>
575 ///
576
577 private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
578 {
579 if (ContactgeomsArray == IntPtr.Zero || index >= contactsPerCollision)
580 return false;
581
582 IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
583 newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
584 return true;
585 }
586
587
588
589 private void near(IntPtr space, IntPtr g1, IntPtr g2)
590 {
591 // no lock here! It's invoked from within Simulate(), which is thread-locked
592
593 if (m_global_contactcount >= maxContactsbeforedeath)
594 return;
595
596 // Test if we're colliding a geom with a space.
597 // If so we have to drill down into the space recursively
598
599 if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
600 return;
601
602 if (d.GeomIsSpace(g1) || d.GeomIsSpace(g2))
603 {
604 // We'll be calling near recursivly if one
605 // of them is a space to find all of the
606 // contact points in the space
607 try
608 {
609 d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
610 }
611 catch (AccessViolationException)
612 {
613 m_log.Warn("[PHYSICS]: Unable to collide test a space");
614 return;
615 }
616 //here one should check collisions of geoms inside a space
617 // but on each space we only should have geoms that not colide amoung each other
618 // so we don't dig inside spaces
619 return;
620 }
621
622 // get geom bodies to check if we already a joint contact
623 // guess this shouldn't happen now
624 IntPtr b1 = d.GeomGetBody(g1);
625 IntPtr b2 = d.GeomGetBody(g2);
626
627 // d.GeomClassID id = d.GeomGetClass(g1);
628
629 // Figure out how many contact points we have
630 int count = 0;
631 try
632 {
633 // Colliding Geom To Geom
634 // This portion of the function 'was' blatantly ripped off from BoxStack.cs
635
636 if (g1 == g2)
637 return; // Can't collide with yourself
638
639 if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
640 return;
641
642 count = d.CollidePtr(g1, g2, (contactsPerCollision & 0xffff), ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
643 }
644 catch (SEHException)
645 {
646 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.");
647// ode.drelease(world);
648 base.TriggerPhysicsBasedRestart();
649 }
650 catch (Exception e)
651 {
652 m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
653 return;
654 }
655
656 // id contacts done
657 if (count == 0)
658 return;
659
660 // try get physical actors
661 PhysicsActor p1;
662 PhysicsActor p2;
663
664 if (!actor_name_map.TryGetValue(g1, out p1))
665 {
666 p1 = PANull;
667 }
668
669 if (!actor_name_map.TryGetValue(g2, out p2))
670 {
671 p2 = PANull;
672 }
673
674 // update actors collision score
675 if (p1.CollisionScore >= float.MaxValue - count)
676 p1.CollisionScore = 0;
677 p1.CollisionScore += count;
678
679 if (p2.CollisionScore >= float.MaxValue - count)
680 p2.CollisionScore = 0;
681 p2.CollisionScore += count;
682
683
684 // get first contact
685 d.ContactGeom curContact = new d.ContactGeom();
686 if (!GetCurContactGeom(0, ref curContact))
687 return;
688 // for now it's the one with max depth
689 ContactPoint maxDepthContact = new ContactPoint(
690 new Vector3(curContact.pos.X, curContact.pos.Y, curContact.pos.Z),
691 new Vector3(curContact.normal.X, curContact.normal.Y, curContact.normal.Z),
692 curContact.depth
693 );
694 // do volume detection case
695 if (
696 (p1 is OdePrim) && (((OdePrim)p1).m_isVolumeDetect) ||
697 (p2 is OdePrim) && (((OdePrim)p2).m_isVolumeDetect))
698 {
699 collision_accounting_events(p1, p2, maxDepthContact);
700 return;
701 }
702
703 // big messy collision analises
704 float mu = 0;
705 float bounce = 0;
706 ContactData contactdata1;
707 ContactData contactdata2;
708 bool erpSoft = false;
709
710 String name = null;
711 bool dop1foot = false;
712 bool dop2foot = false;
713 bool ignore = false;
714
715 switch (p1.PhysicsActorType)
716 {
717 case (int)ActorTypes.Agent:
718 switch (p2.PhysicsActorType)
719 {
720 case (int)ActorTypes.Agent:
721 contactdata1 = p1.ContactData;
722 contactdata2 = p2.ContactData;
723 bounce = contactdata1.bounce * contactdata2.bounce;
724
725 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
726
727 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
728 mu *= frictionMovementMult;
729
730 p1.CollidingObj = true;
731 p2.CollidingObj = true;
732 break;
733 case (int)ActorTypes.Prim:
734 contactdata1 = p1.ContactData;
735 contactdata2 = p2.ContactData;
736 bounce = contactdata1.bounce * contactdata2.bounce;
737
738 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
739
740 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
741 mu *= frictionMovementMult;
742 if (p2.Velocity.LengthSquared() > 0.0f)
743 p2.CollidingObj = true;
744 dop1foot = true;
745 break;
746 default:
747 ignore=true; // avatar to terrain and water ignored
748 break;
749 }
750 break;
751
752 case (int)ActorTypes.Prim:
753 switch (p2.PhysicsActorType)
754 {
755 case (int)ActorTypes.Agent:
756 contactdata1 = p1.ContactData;
757 contactdata2 = p2.ContactData;
758 bounce = contactdata1.bounce * contactdata2.bounce;
759
760 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
761
762 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
763 mu *= frictionMovementMult;
764
765 dop2foot = true;
766 if (p1.Velocity.LengthSquared() > 0.0f)
767 p1.CollidingObj = true;
768 break;
769 case (int)ActorTypes.Prim:
770 if ((p1.Velocity - p2.Velocity).LengthSquared() > 0.0f)
771 {
772 p1.CollidingObj = true;
773 p2.CollidingObj = true;
774 }
775 contactdata1 = p1.ContactData;
776 contactdata2 = p2.ContactData;
777 bounce = contactdata1.bounce * contactdata2.bounce;
778 erpSoft = true;
779 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
780
781 if ((Math.Abs(p2.Velocity.X - p1.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y - p1.Velocity.Y) > 0.1f))
782 mu *= frictionMovementMult;
783
784 break;
785 default:
786 if (geom_name_map.TryGetValue(g2, out name))
787 {
788 if (name == "Terrain")
789 {
790 erpSoft = true;
791 contactdata1 = p1.ContactData;
792 bounce = contactdata1.bounce * TerrainBounce;
793 mu = (float)Math.Sqrt(contactdata1.mu * TerrainFriction);
794 if (Math.Abs(p1.Velocity.X) > 0.1f || Math.Abs(p1.Velocity.Y) > 0.1f)
795 mu *= frictionMovementMult;
796 p1.CollidingGround = true;
797 }
798 else if (name == "Water")
799 {
800 erpSoft = true;
801 }
802 }
803 else
804 ignore=true;
805 break;
806 }
807 break;
808
809 default:
810 if (geom_name_map.TryGetValue(g1, out name))
811 {
812 if (name == "Terrain")
813 {
814 if (p2.PhysicsActorType == (int)ActorTypes.Prim)
815 {
816 erpSoft = true;
817 p2.CollidingGround = true;
818 contactdata2 = p2.ContactData;
819 bounce = contactdata2.bounce * TerrainBounce;
820 mu = (float)Math.Sqrt(contactdata2.mu * TerrainFriction);
821
822 if (Math.Abs(p2.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y) > 0.1f)
823 mu *= frictionMovementMult;
824 }
825 else
826 ignore = true;
827
828 }
829 else if (name == "Water" &&
830 (p2.PhysicsActorType == (int)ActorTypes.Prim || p2.PhysicsActorType == (int)ActorTypes.Agent))
831 {
832 erpSoft = true;
833 }
834 }
835 else
836 ignore = true;
837 break;
838 }
839
840 if (ignore)
841 return;
842
843 IntPtr Joint;
844
845 int i = 0;
846 while(true)
847 {
848 if (dop1foot && (p1.Position.Z - curContact.pos.Z) > (p1.Size.Z - avCapRadius) * 0.5f)
849 p1.IsColliding = true;
850 if (dop2foot && (p2.Position.Z - curContact.pos.Z) > (p2.Size.Z - avCapRadius) * 0.5f)
851 p2.IsColliding = true;
852
853 Joint = CreateContacJoint(ref curContact, mu, bounce, erpSoft);
854 d.JointAttach(Joint, b1, b2);
855
856 if (++m_global_contactcount >= maxContactsbeforedeath)
857 break;
858
859 if(++i >= count)
860 break;
861
862 if (!GetCurContactGeom(i, ref curContact))
863 break;
864
865 if (curContact.depth > maxDepthContact.PenetrationDepth)
866 {
867 maxDepthContact.Position.X = curContact.pos.X;
868 maxDepthContact.Position.Y = curContact.pos.Y;
869 maxDepthContact.Position.Z = curContact.pos.Z;
870 maxDepthContact.SurfaceNormal.X = curContact.normal.X;
871 maxDepthContact.SurfaceNormal.Y = curContact.normal.Y;
872 maxDepthContact.SurfaceNormal.Z = curContact.normal.Z;
873 maxDepthContact.PenetrationDepth = curContact.depth;
874 }
875 }
876
877 collision_accounting_events(p1, p2, maxDepthContact);
878
879/*
880 if (notskipedcount > geomContactPointsStartthrottle)
881 {
882 // If there are more then 3 contact points, it's likely
883 // that we've got a pile of objects, so ...
884 // We don't want to send out hundreds of terse updates over and over again
885 // so lets throttle them and send them again after it's somewhat sorted out.
886 this needs checking so out for now
887 if (b1 != IntPtr.Zero)
888 p1.ThrottleUpdates = true;
889 if (b2 != IntPtr.Zero)
890 p2.ThrottleUpdates = true;
891
892 }
893 */
894 }
895
896 private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
897 {
898 // obj1LocalID = 0;
899 //returncollisions = false;
900 obj2LocalID = 0;
901 //ctype = 0;
902 //cStartStop = 0;
903 if (!(p2.SubscribedEvents() || p1.SubscribedEvents()))
904 return;
905
906 switch ((ActorTypes)p1.PhysicsActorType)
907 {
908 case ActorTypes.Agent:
909 cc1 = (OdeCharacter)p1;
910 switch ((ActorTypes)p2.PhysicsActorType)
911 {
912 case ActorTypes.Agent:
913 cc2 = (OdeCharacter)p2;
914 obj2LocalID = cc2.m_localID;
915 if (p2.SubscribedEvents())
916 cc2.AddCollisionEvent(cc1.m_localID, contact);
917 break;
918
919 case ActorTypes.Prim:
920 if (p2 is OdePrim)
921 {
922 cp2 = (OdePrim)p2;
923 obj2LocalID = cp2.m_localID;
924 if (p2.SubscribedEvents())
925 cp2.AddCollisionEvent(cc1.m_localID, contact);
926 }
927 break;
928
929 case ActorTypes.Ground:
930 case ActorTypes.Unknown:
931 default:
932 obj2LocalID = 0;
933 break;
934 }
935 if (p1.SubscribedEvents())
936 {
937 contact.SurfaceNormal = -contact.SurfaceNormal;
938 cc1.AddCollisionEvent(obj2LocalID, contact);
939 }
940 break;
941
942 case ActorTypes.Prim:
943
944 if (p1 is OdePrim)
945 {
946 cp1 = (OdePrim)p1;
947
948 // obj1LocalID = cp2.m_localID;
949 switch ((ActorTypes)p2.PhysicsActorType)
950 {
951 case ActorTypes.Agent:
952 if (p2 is OdeCharacter)
953 {
954 cc2 = (OdeCharacter)p2;
955 obj2LocalID = cc2.m_localID;
956 if (p2.SubscribedEvents())
957 cc2.AddCollisionEvent(cp1.m_localID, contact);
958 }
959 break;
960 case ActorTypes.Prim:
961
962 if (p2 is OdePrim)
963 {
964 cp2 = (OdePrim)p2;
965 obj2LocalID = cp2.m_localID;
966 if (p2.SubscribedEvents())
967 cp2.AddCollisionEvent(cp1.m_localID, contact);
968 }
969 break;
970
971 case ActorTypes.Ground:
972 case ActorTypes.Unknown:
973 default:
974 obj2LocalID = 0;
975 break;
976 }
977 if (p1.SubscribedEvents())
978 {
979 contact.SurfaceNormal = -contact.SurfaceNormal;
980 cp1.AddCollisionEvent(obj2LocalID, contact);
981 }
982 }
983 break;
984 }
985 }
986
987 /// <summary>
988 /// This is our collision testing routine in ODE
989 /// </summary>
990 /// <param name="timeStep"></param>
991 private void collision_optimized()
992 {
993 lock (_characters)
994 {
995 try
996 {
997 foreach (OdeCharacter chr in _characters)
998 {
999 if (chr == null || chr.Shell == IntPtr.Zero || chr.Body == IntPtr.Zero)
1000 continue;
1001
1002 chr.IsColliding = false;
1003 // chr.CollidingGround = false; not done here
1004 chr.CollidingObj = false;
1005 // do colisions with static space
1006 d.SpaceCollide2(StaticSpace, chr.Shell, IntPtr.Zero, nearCallback);
1007 }
1008 }
1009 catch (AccessViolationException)
1010 {
1011 m_log.Warn("[PHYSICS]: Unable to collide Character to static space");
1012 }
1013
1014 }
1015
1016 // collide active prims with static enviroment
1017 lock (_activeprims)
1018 {
1019 try
1020 {
1021 foreach (OdePrim prm in _activeprims)
1022 {
1023 if (d.BodyIsEnabled(prm.Body))
1024 d.SpaceCollide2(StaticSpace, prm.prim_geom, IntPtr.Zero, nearCallback);
1025 }
1026 }
1027 catch (AccessViolationException)
1028 {
1029 m_log.Warn("[PHYSICS]: Unable to collide Active prim to static space");
1030 }
1031 }
1032
1033 // finally colide active things amoung them
1034 try
1035 {
1036 d.SpaceCollide(ActiveSpace, IntPtr.Zero, nearCallback);
1037 }
1038 catch (AccessViolationException)
1039 {
1040 m_log.Warn("[PHYSICS]: Unable to collide in Active space");
1041 }
1042
1043// _perloopContact.Clear();
1044 }
1045
1046 #endregion
1047
1048
1049
1050 /// <summary>
1051 /// Add actor to the list that should receive collision events in the simulate loop.
1052 /// </summary>
1053 /// <param name="obj"></param>
1054 public void AddCollisionEventReporting(PhysicsActor obj)
1055 {
1056 lock (_collisionEventPrim)
1057 {
1058 if (!_collisionEventPrim.Contains(obj))
1059 _collisionEventPrim.Add(obj);
1060 }
1061 }
1062
1063 /// <summary>
1064 /// Remove actor from the list that should receive collision events in the simulate loop.
1065 /// </summary>
1066 /// <param name="obj"></param>
1067 public void RemoveCollisionEventReporting(PhysicsActor obj)
1068 {
1069 lock (_collisionEventPrim)
1070 {
1071 if (_collisionEventPrim.Contains(obj))
1072 _collisionEventPrim.Remove(obj);
1073 }
1074 }
1075
1076 #region Add/Remove Entities
1077
1078 public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
1079 {
1080 Vector3 pos;
1081 pos.X = position.X;
1082 pos.Y = position.Y;
1083 pos.Z = position.Z;
1084 OdeCharacter newAv = new OdeCharacter(avName, this, pos, size, avPIDD, avPIDP, avCapRadius, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
1085 newAv.Flying = isFlying;
1086 newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
1087
1088 return newAv;
1089 }
1090
1091 public void AddCharacter(OdeCharacter chr)
1092 {
1093 lock (_characters)
1094 {
1095 if (!_characters.Contains(chr))
1096 {
1097 _characters.Add(chr);
1098 if (chr.bad)
1099 m_log.DebugFormat("[PHYSICS] Added BAD actor {0} to characters list", chr.m_uuid);
1100 }
1101 }
1102 }
1103
1104 public void RemoveCharacter(OdeCharacter chr)
1105 {
1106 lock (_characters)
1107 {
1108 if (_characters.Contains(chr))
1109 {
1110 _characters.Remove(chr);
1111 }
1112 }
1113 }
1114
1115 public void BadCharacter(OdeCharacter chr)
1116 {
1117 lock (_badCharacter)
1118 {
1119 if (!_badCharacter.Contains(chr))
1120 _badCharacter.Add(chr);
1121 }
1122 }
1123
1124 public override void RemoveAvatar(PhysicsActor actor)
1125 {
1126 //m_log.Debug("[PHYSICS]:ODELOCK");
1127 ((OdeCharacter) actor).Destroy();
1128 }
1129
1130 private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
1131 PrimitiveBaseShape pbs, bool isphysical, uint localID)
1132 {
1133 Vector3 pos = position;
1134 Vector3 siz = size;
1135 Quaternion rot = rotation;
1136
1137 OdePrim newPrim;
1138 lock (OdeLock)
1139 {
1140 newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical);
1141
1142 lock (_prims)
1143 _prims.Add(newPrim);
1144 }
1145 newPrim.LocalID = localID;
1146 return newPrim;
1147 }
1148
1149 public void addActivePrim(OdePrim activatePrim)
1150 {
1151 // adds active prim.. (ones that should be iterated over in collisions_optimized
1152 lock (_activeprims)
1153 {
1154 if (!_activeprims.Contains(activatePrim))
1155 _activeprims.Add(activatePrim);
1156 //else
1157 // m_log.Warn("[PHYSICS]: Double Entry in _activeprims detected, potential crash immenent");
1158 }
1159 }
1160
1161 public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
1162 Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
1163 {
1164#if SPAM
1165 m_log.DebugFormat("[PHYSICS]: Adding physics actor to {0}", primName);
1166#endif
1167
1168 return AddPrim(primName, position, size, rotation, pbs, isPhysical, localid);
1169 }
1170
1171 public override float TimeDilation
1172 {
1173 get { return m_timeDilation; }
1174 }
1175
1176 public override bool SupportsNINJAJoints
1177 {
1178 get { return false; }
1179 }
1180
1181
1182 public void remActivePrim(OdePrim deactivatePrim)
1183 {
1184 lock (_activeprims)
1185 {
1186 _activeprims.Remove(deactivatePrim);
1187 }
1188 }
1189
1190 public override void RemovePrim(PhysicsActor prim)
1191 {
1192 // As with all ODE physics operations, we don't remove the prim immediately but signal that it should be
1193 // removed in the next physics simulate pass.
1194 if (prim is OdePrim)
1195 {
1196// lock (OdeLock)
1197 {
1198 OdePrim p = (OdePrim)prim;
1199 p.setPrimForRemoval();
1200 }
1201 }
1202 }
1203 /// <summary>
1204 /// This is called from within simulate but outside the locked portion
1205 /// We need to do our own locking here
1206 /// (Note: As of 20110801 this no longer appears to be true - this is being called within lock (odeLock) in
1207 /// Simulate() -- justincc).
1208 ///
1209 /// Essentially, we need to remove the prim from our space segment, whatever segment it's in.
1210 ///
1211 /// If there are no more prim in the segment, we need to empty (spacedestroy)the segment and reclaim memory
1212 /// that the space was using.
1213 /// </summary>
1214 /// <param name="prim"></param>
1215 public void RemovePrimThreadLocked(OdePrim prim)
1216 {
1217 //Console.WriteLine("RemovePrimThreadLocked " + prim.m_primName);
1218 lock (prim)
1219 {
1220 RemoveCollisionEventReporting(prim);
1221 lock (_prims)
1222 _prims.Remove(prim);
1223 }
1224
1225 }
1226 #endregion
1227
1228 #region Space Separation Calculation
1229
1230 /// <summary>
1231 /// Called when a static prim moves or becomes static
1232 /// Places the prim in a space one the static sub-spaces grid
1233 /// </summary>
1234 /// <param name="geom">the pointer to the geom that moved</param>
1235 /// <param name="pos">the position that the geom moved to</param>
1236 /// <param name="currentspace">a pointer to the space it was in before it was moved.</param>
1237 /// <returns>a pointer to the new space it's in</returns>
1238 public IntPtr MoveGeomToStaticSpace(IntPtr geom, Vector3 pos, IntPtr currentspace)
1239 {
1240 // moves a prim into another static sub-space or from another space into a static sub-space
1241
1242 // Called ODEPrim so
1243 // it's already in locked space.
1244
1245 if (geom == IntPtr.Zero) // shouldn't happen
1246 return IntPtr.Zero;
1247
1248 // get the static sub-space for current position
1249 IntPtr newspace = calculateSpaceForGeom(pos);
1250
1251 if (newspace == currentspace) // if we are there all done
1252 return newspace;
1253
1254 // else remove it from its current space
1255 if (currentspace != IntPtr.Zero && d.SpaceQuery(currentspace, geom))
1256 {
1257 if (d.GeomIsSpace(currentspace))
1258 {
1259 waitForSpaceUnlock(currentspace);
1260 d.SpaceRemove(currentspace, geom);
1261 }
1262 else
1263 {
1264 m_log.Info("[Physics]: Invalid or empty Space passed to 'MoveGeomToStaticSpace':" + currentspace +
1265 " Geom:" + geom);
1266 }
1267 }
1268 else // odd currentspace is null or doesn't contain the geom? lets try the geom ideia of current space
1269 {
1270 currentspace = d.GeomGetSpace(geom);
1271 if (currentspace != IntPtr.Zero)
1272 {
1273 if (d.GeomIsSpace(currentspace))
1274 {
1275 waitForSpaceUnlock(currentspace);
1276 d.SpaceRemove(currentspace, geom);
1277 }
1278 }
1279 }
1280
1281 // put the geom in the newspace
1282 waitForSpaceUnlock(newspace);
1283 d.SpaceAdd(newspace, geom);
1284
1285 // let caller know this newspace
1286 return newspace;
1287 }
1288
1289 /// <summary>
1290 /// Calculates the space the prim should be in by its position
1291 /// </summary>
1292 /// <param name="pos"></param>
1293 /// <returns>a pointer to the space. This could be a new space or reused space.</returns>
1294 public IntPtr calculateSpaceForGeom(Vector3 pos)
1295 {
1296 int x, y;
1297 x = (int)(pos.X * spacesPerMeter);
1298 if (x < 0)
1299 x = 0;
1300 else if (x > spaceGridMaxX)
1301 x = spaceGridMaxX;
1302
1303 y = (int)(pos.Y * spacesPerMeter);
1304 if (y < 0)
1305 y = 0;
1306 else if (y >spaceGridMaxY)
1307 y = spaceGridMaxY;
1308
1309 IntPtr tmpSpace = staticPrimspace[x, y];
1310 return tmpSpace;
1311 }
1312
1313 #endregion
1314
1315 /// <summary>
1316 /// Routine to figure out if we need to mesh this prim with our mesher
1317 /// </summary>
1318 /// <param name="pbs"></param>
1319 /// <returns></returns>
1320 public bool needsMeshing(PrimitiveBaseShape pbs)
1321 {
1322 // most of this is redundant now as the mesher will return null if it cant mesh a prim
1323 // but we still need to check for sculptie meshing being enabled so this is the most
1324 // convenient place to do it for now...
1325
1326 // //if (pbs.PathCurve == (byte)Primitive.PathCurve.Circle && pbs.ProfileCurve == (byte)Primitive.ProfileCurve.Circle && pbs.PathScaleY <= 0.75f)
1327 // //m_log.Debug("needsMeshing: " + " pathCurve: " + pbs.PathCurve.ToString() + " profileCurve: " + pbs.ProfileCurve.ToString() + " pathScaleY: " + Primitive.UnpackPathScale(pbs.PathScaleY).ToString());
1328 int iPropertiesNotSupportedDefault = 0;
1329
1330 if (pbs.SculptEntry)
1331 {
1332 if(!meshSculptedPrim)
1333 return false;
1334 }
1335
1336 // 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
1337 if (!forceSimplePrimMeshing && !pbs.SculptEntry)
1338 {
1339 if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
1340 || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
1341 && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
1342 {
1343
1344 if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
1345 && pbs.ProfileHollow == 0
1346 && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
1347 && pbs.PathBegin == 0 && pbs.PathEnd == 0
1348 && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
1349 && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
1350 && pbs.PathShearX == 0 && pbs.PathShearY == 0)
1351 {
1352#if SPAM
1353 m_log.Warn("NonMesh");
1354#endif
1355 return false;
1356 }
1357 }
1358 }
1359
1360 // following code doesn't give meshs to boxes and spheres ever
1361 // and it's odd.. so for now just return true if asked to force meshs
1362 // hopefully mesher will fail if doesn't suport so things still get basic boxes
1363
1364 if (forceSimplePrimMeshing)
1365 return true;
1366
1367 if (pbs.ProfileHollow != 0)
1368 iPropertiesNotSupportedDefault++;
1369
1370 if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
1371 iPropertiesNotSupportedDefault++;
1372
1373 if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
1374 iPropertiesNotSupportedDefault++;
1375
1376 if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
1377 iPropertiesNotSupportedDefault++;
1378
1379 if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
1380 iPropertiesNotSupportedDefault++;
1381
1382 if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
1383 iPropertiesNotSupportedDefault++;
1384
1385 if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
1386 iPropertiesNotSupportedDefault++;
1387
1388 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))
1389 iPropertiesNotSupportedDefault++;
1390
1391 if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1)
1392 iPropertiesNotSupportedDefault++;
1393
1394 // test for torus
1395 if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
1396 {
1397 if (pbs.PathCurve == (byte)Extrusion.Curve1)
1398 {
1399 iPropertiesNotSupportedDefault++;
1400 }
1401 }
1402 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
1403 {
1404 if (pbs.PathCurve == (byte)Extrusion.Straight)
1405 {
1406 iPropertiesNotSupportedDefault++;
1407 }
1408
1409 // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
1410 else if (pbs.PathCurve == (byte)Extrusion.Curve1)
1411 {
1412 iPropertiesNotSupportedDefault++;
1413 }
1414 }
1415 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
1416 {
1417 if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
1418 {
1419 iPropertiesNotSupportedDefault++;
1420 }
1421 }
1422 else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
1423 {
1424 if (pbs.PathCurve == (byte)Extrusion.Straight)
1425 {
1426 iPropertiesNotSupportedDefault++;
1427 }
1428 else if (pbs.PathCurve == (byte)Extrusion.Curve1)
1429 {
1430 iPropertiesNotSupportedDefault++;
1431 }
1432 }
1433
1434 if (pbs.SculptEntry && meshSculptedPrim)
1435 iPropertiesNotSupportedDefault++;
1436
1437 if (iPropertiesNotSupportedDefault == 0)
1438 {
1439#if SPAM
1440 m_log.Warn("NonMesh");
1441#endif
1442 return false;
1443 }
1444#if SPAM
1445 m_log.Debug("Mesh");
1446#endif
1447 return true;
1448 }
1449
1450 /// <summary>
1451 /// Called to queue a change to a actor
1452 /// to use in place of old taint mechanism so changes do have a time sequence
1453 /// </summary>
1454
1455 public void AddChange(PhysicsActor actor, changes what, Object arg)
1456 {
1457 ODEchangeitem item = new ODEchangeitem();
1458 item.actor = actor;
1459 item.what = what;
1460 item.arg = arg;
1461 ChangesQueue.Enqueue(item);
1462 }
1463
1464 /// <summary>
1465 /// Called after our prim properties are set Scale, position etc.
1466 /// We use this event queue like method to keep changes to the physical scene occuring in the threadlocked mutex
1467 /// This assures us that we have no race conditions
1468 /// </summary>
1469 /// <param name="prim"></param>
1470 public override void AddPhysicsActorTaint(PhysicsActor prim)
1471 {
1472 }
1473
1474 /// <summary>
1475 /// This is our main simulate loop
1476 /// It's thread locked by a Mutex in the scene.
1477 /// It holds Collisions, it instructs ODE to step through the physical reactions
1478 /// It moves the objects around in memory
1479 /// It calls the methods that report back to the object owners.. (scenepresence, SceneObjectGroup)
1480 /// </summary>
1481 /// <param name="timeStep"></param>
1482 /// <returns></returns>
1483 public override float Simulate(float timeStep)
1484 {
1485 int statstart;
1486 int statchanges = 0;
1487 int statchmove = 0;
1488 int statactmove = 0;
1489 int statray = 0;
1490 int statcol = 0;
1491 int statstep = 0;
1492 int statmovchar = 0;
1493 int statmovprim;
1494 int totjcontact = 0;
1495
1496 // acumulate time so we can reduce error
1497 step_time += timeStep;
1498
1499 if (step_time < ODE_STEPSIZE)
1500 return 0;
1501
1502 if (framecount >= int.MaxValue)
1503 framecount = 0;
1504
1505 framecount++;
1506
1507 int curphysiteractions = m_physicsiterations;
1508
1509 if (step_time >= m_SkipFramesAtms)
1510 {
1511 // if in trouble reduce step resolution
1512 curphysiteractions /= 2;
1513 }
1514
1515 int nodeframes = 0;
1516
1517// checkThread();
1518
1519 lock (SimulationLock)
1520 {
1521 // adjust number of iterations per step
1522 try
1523 {
1524 d.WorldSetQuickStepNumIterations(world, curphysiteractions);
1525 }
1526 catch (StackOverflowException)
1527 {
1528 m_log.Error("[PHYSICS]: The operating system wasn't able to allocate enough memory for the simulation. Restarting the sim.");
1529// ode.drelease(world);
1530 base.TriggerPhysicsBasedRestart();
1531 }
1532
1533
1534 while (step_time >= ODE_STEPSIZE && nodeframes < 10) //limit number of steps so we don't say here for ever
1535 {
1536 try
1537 {
1538 statstart = Util.EnvironmentTickCount();
1539
1540 // clear pointer/counter to contacts to pass into joints
1541 m_global_contactcount = 0;
1542
1543 ODEchangeitem item;
1544
1545 if(ChangesQueue.Count >0)
1546 {
1547 int ttmpstart = Util.EnvironmentTickCount();
1548 int ttmp;
1549 int ttmp2;
1550
1551 while(ChangesQueue.Dequeue(out item))
1552 {
1553 if (item.actor != null)
1554 {
1555 try
1556 {
1557 if (item.actor is OdeCharacter)
1558 ((OdeCharacter)item.actor).DoAChange(item.what, item.arg);
1559 else if (((OdePrim)item.actor).DoAChange(item.what, item.arg))
1560 RemovePrimThreadLocked((OdePrim)item.actor);
1561 }
1562 catch
1563 {
1564 m_log.Warn("[PHYSICS]: doChange failed for a actor");
1565 };
1566 }
1567 ttmp = Util.EnvironmentTickCountSubtract(ttmpstart);
1568 if (ttmp > 20)
1569 break;
1570 }
1571
1572 ttmp2 = Util.EnvironmentTickCountSubtract(ttmpstart);
1573 if (ttmp2 > 50)
1574 ttmp2 = 0;
1575
1576 }
1577
1578 statchanges += Util.EnvironmentTickCountSubtract(statstart);
1579
1580 // Move characters
1581 lock (_characters)
1582 {
1583 List<OdeCharacter> defects = new List<OdeCharacter>();
1584 foreach (OdeCharacter actor in _characters)
1585 {
1586 if (actor != null)
1587 actor.Move(ODE_STEPSIZE, defects);
1588 }
1589 if (defects.Count != 0)
1590 {
1591 foreach (OdeCharacter defect in defects)
1592 {
1593 RemoveCharacter(defect);
1594 }
1595 }
1596 }
1597 statchmove += Util.EnvironmentTickCountSubtract(statstart);
1598
1599 // Move other active objects
1600 lock (_activeprims)
1601 {
1602 foreach (OdePrim aprim in _activeprims)
1603 {
1604 aprim.CollisionScore = 0;
1605 aprim.IsColliding = false;
1606 aprim.Move();
1607 }
1608 }
1609
1610 statactmove += Util.EnvironmentTickCountSubtract(statstart);
1611 //if ((framecount % m_randomizeWater) == 0)
1612 // randomizeWater(waterlevel);
1613
1614 m_rayCastManager.ProcessQueuedRequests();
1615
1616 statray += Util.EnvironmentTickCountSubtract(statstart);
1617 collision_optimized();
1618 statcol += Util.EnvironmentTickCountSubtract(statstart);
1619
1620 lock (_collisionEventPrim)
1621 {
1622 foreach (PhysicsActor obj in _collisionEventPrim)
1623 {
1624 if (obj == null)
1625 continue;
1626
1627 switch ((ActorTypes)obj.PhysicsActorType)
1628 {
1629 case ActorTypes.Agent:
1630 OdeCharacter cobj = (OdeCharacter)obj;
1631 cobj.AddCollisionFrameTime((int)(ODE_STEPSIZE*1000.0f));
1632 cobj.SendCollisions();
1633 break;
1634
1635 case ActorTypes.Prim:
1636 OdePrim pobj = (OdePrim)obj;
1637 pobj.SendCollisions();
1638 break;
1639 }
1640 }
1641 }
1642
1643 d.WorldQuickStep(world, ODE_STEPSIZE);
1644 statstep += Util.EnvironmentTickCountSubtract(statstart);
1645 d.JointGroupEmpty(contactgroup);
1646 totjcontact += m_global_contactcount;
1647 //ode.dunlock(world);
1648 }
1649 catch (Exception e)
1650 {
1651 m_log.ErrorFormat("[PHYSICS]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
1652// ode.dunlock(world);
1653 }
1654
1655 step_time -= ODE_STEPSIZE;
1656 nodeframes++;
1657 }
1658
1659 statstart = Util.EnvironmentTickCount();
1660
1661 lock (_characters)
1662 {
1663 foreach (OdeCharacter actor in _characters)
1664 {
1665 if (actor != null)
1666 {
1667 if (actor.bad)
1668 m_log.WarnFormat("[PHYSICS]: BAD Actor {0} in _characters list was not removed?", actor.m_uuid);
1669
1670 actor.UpdatePositionAndVelocity();
1671 }
1672 }
1673 }
1674
1675 lock (_badCharacter)
1676 {
1677 if (_badCharacter.Count > 0)
1678 {
1679 foreach (OdeCharacter chr in _badCharacter)
1680 {
1681 RemoveCharacter(chr);
1682 }
1683
1684 _badCharacter.Clear();
1685 }
1686 }
1687 statmovchar = Util.EnvironmentTickCountSubtract(statstart);
1688
1689 lock (_activeprims)
1690 {
1691 {
1692 foreach (OdePrim actor in _activeprims)
1693 {
1694 if (actor.IsPhysical)
1695 {
1696 actor.UpdatePositionAndVelocity((float)nodeframes * ODE_STEPSIZE);
1697 }
1698 }
1699 }
1700 }
1701
1702 statmovprim = Util.EnvironmentTickCountSubtract(statstart);
1703
1704 int nactivegeoms = d.SpaceGetNumGeoms(ActiveSpace);
1705 int nstaticgeoms = d.SpaceGetNumGeoms(StaticSpace);
1706 int ntopgeoms = d.SpaceGetNumGeoms(TopSpace);
1707 int nbodies = d.NTotalBodies;
1708 int ngeoms = d.NTotalGeoms;
1709
1710 // Finished with all sim stepping. If requested, dump world state to file for debugging.
1711 // TODO: This call to the export function is already inside lock (OdeLock) - but is an extra lock needed?
1712 // TODO: This overwrites all dump files in-place. Should this be a growing logfile, or separate snapshots?
1713 if (physics_logging && (physics_logging_interval > 0) && (framecount % physics_logging_interval == 0))
1714 {
1715 string fname = "state-" + world.ToString() + ".DIF"; // give each physics world a separate filename
1716 string prefix = "world" + world.ToString(); // prefix for variable names in exported .DIF file
1717
1718 if (physics_logging_append_existing_logfile)
1719 {
1720 string header = "-------------- START OF PHYSICS FRAME " + framecount.ToString() + " --------------";
1721 TextWriter fwriter = File.AppendText(fname);
1722 fwriter.WriteLine(header);
1723 fwriter.Close();
1724 }
1725
1726 d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
1727 }
1728
1729 // think time dilation is not a physics issue alone.. but ok let's fake something
1730 if (step_time < ODE_STEPSIZE) // we did the required loops
1731 m_timeDilation = 1.0f;
1732 else
1733 { // we didn't forget the lost ones and let user know something
1734 m_timeDilation = 1 - step_time / timeStep;
1735 if (m_timeDilation < 0)
1736 m_timeDilation = 0;
1737 step_time = 0;
1738 }
1739 }
1740
1741// return nodeframes * ODE_STEPSIZE; // return real simulated time
1742 return 1000 * nodeframes; // return steps for now * 1000 to keep core happy
1743 }
1744
1745 /// <summary>
1746 public override void GetResults()
1747 {
1748 }
1749
1750 public override bool IsThreaded
1751 {
1752 // for now we won't be multithreaded
1753 get { return (false); }
1754 }
1755
1756 public float GetTerrainHeightAtXY(float x, float y)
1757 {
1758 // assumes 1m size grid and constante size square regions
1759 // needs to know about sims around in future
1760 // region offset in mega position
1761
1762 int offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
1763 int offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
1764
1765 IntPtr heightFieldGeom = IntPtr.Zero;
1766
1767 // get region map
1768 if (!RegionTerrain.TryGetValue(new Vector3(offsetX, offsetY, 0), out heightFieldGeom))
1769 return 0f;
1770
1771 if (heightFieldGeom == IntPtr.Zero)
1772 return 0f;
1773
1774 if (!TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
1775 return 0f;
1776
1777 // TerrainHeightField for ODE as offset 1m
1778 x += 1f - offsetX;
1779 y += 1f - offsetY;
1780
1781 // make position fit into array
1782 if (x < 0)
1783 x = 0;
1784 if (y < 0)
1785 y = 0;
1786
1787 // integer indexs
1788 int ix;
1789 int iy;
1790 // interpolators offset
1791 float dx;
1792 float dy;
1793
1794 int regsize = (int)Constants.RegionSize + 3; // map size see setterrain number of samples
1795
1796 // we still have square fixed size regions
1797 // also flip x and y because of how map is done for ODE fliped axis
1798 // so ix,iy,dx and dy are inter exchanged
1799 if (x < regsize - 1)
1800 {
1801 iy = (int)x;
1802 dy = x - (float)iy;
1803 }
1804 else // out world use external height
1805 {
1806 iy = regsize - 1;
1807 dy = 0;
1808 }
1809 if (y < regsize - 1)
1810 {
1811 ix = (int)y;
1812 dx = y - (float)ix;
1813 }
1814 else
1815 {
1816 ix = regsize - 1;
1817 dx = 0;
1818 }
1819
1820 float h0;
1821 float h1;
1822 float h2;
1823
1824 iy *= regsize;
1825 iy += ix; // all indexes have iy + ix
1826
1827 float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
1828
1829 if ((dx + dy) <= 1.0f)
1830 {
1831 h0 = ((float)heights[iy]); // 0,0 vertice
1832 h1 = (((float)heights[iy + 1]) - h0) * dx; // 1,0 vertice minus 0,0
1833 h2 = (((float)heights[iy + regsize]) - h0) * dy; // 0,1 vertice minus 0,0
1834 }
1835 else
1836 {
1837 h0 = ((float)heights[iy + regsize + 1]); // 1,1 vertice
1838 h1 = (((float)heights[iy + 1]) - h0) * (1 - dy); // 1,1 vertice minus 1,0
1839 h2 = (((float)heights[iy + regsize]) - h0) * (1 - dx); // 1,1 vertice minus 0,1
1840 }
1841
1842 return h0 + h1 + h2;
1843 }
1844 public override void SetTerrain(float[] heightMap)
1845 {
1846 if (m_worldOffset != Vector3.Zero && m_parentScene != null)
1847 {
1848 if (m_parentScene is OdeScene)
1849 {
1850 ((OdeScene)m_parentScene).SetTerrain(heightMap, m_worldOffset);
1851 }
1852 }
1853 else
1854 {
1855 SetTerrain(heightMap, m_worldOffset);
1856 }
1857 }
1858
1859 public override void CombineTerrain(float[] heightMap, Vector3 pOffset)
1860 {
1861 SetTerrain(heightMap, pOffset);
1862 }
1863
1864 public void SetTerrain(float[] heightMap, Vector3 pOffset)
1865 {
1866 // assumes 1m size grid and constante size square regions
1867 // needs to know about sims around in future
1868
1869 float[] _heightmap;
1870
1871 uint heightmapWidth = Constants.RegionSize + 2;
1872 uint heightmapHeight = Constants.RegionSize + 2;
1873
1874 uint heightmapWidthSamples = heightmapWidth + 1;
1875 uint heightmapHeightSamples = heightmapHeight + 1;
1876
1877 _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
1878
1879 const float scale = 1.0f;
1880 const float offset = 0.0f;
1881 const float thickness = 10f;
1882 const int wrap = 0;
1883
1884 uint regionsize = Constants.RegionSize;
1885
1886 float hfmin = float.MaxValue;
1887 float hfmax = float.MinValue;
1888 float val;
1889 uint xx;
1890 uint yy;
1891
1892 uint maxXXYY = regionsize - 1;
1893 // flipping map adding one margin all around so things don't fall in edges
1894
1895 uint xt = 0;
1896 xx = 0;
1897
1898 for (uint x = 0; x < heightmapWidthSamples; x++)
1899 {
1900 if (x > 1 && xx < maxXXYY)
1901 xx++;
1902 yy = 0;
1903 for (uint y = 0; y < heightmapHeightSamples; y++)
1904 {
1905 if (y > 1 && y < maxXXYY)
1906 yy += regionsize;
1907
1908 val = heightMap[yy + xx];
1909 _heightmap[xt + y] = val;
1910
1911 if (hfmin > val)
1912 hfmin = val;
1913 if (hfmax < val)
1914 hfmax = val;
1915
1916 }
1917 xt += heightmapHeightSamples;
1918 }
1919 lock (OdeLock)
1920 {
1921 IntPtr GroundGeom = IntPtr.Zero;
1922 if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
1923 {
1924 RegionTerrain.Remove(pOffset);
1925 if (GroundGeom != IntPtr.Zero)
1926 {
1927 if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
1928 {
1929 TerrainHeightFieldHeightsHandlers[GroundGeom].Free();
1930 TerrainHeightFieldHeightsHandlers.Remove(GroundGeom);
1931 TerrainHeightFieldHeights.Remove(GroundGeom);
1932 }
1933 d.SpaceRemove(StaticSpace, GroundGeom);
1934 d.GeomDestroy(GroundGeom);
1935 }
1936 }
1937 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
1938
1939 GCHandle _heightmaphandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
1940
1941 d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmaphandler.AddrOfPinnedObject(), 0, heightmapWidth , heightmapHeight,
1942 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
1943 offset, thickness, wrap);
1944
1945 d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
1946 GroundGeom = d.CreateHeightfield(StaticSpace, HeightmapData, 1);
1947 if (GroundGeom != IntPtr.Zero)
1948 {
1949 d.GeomSetCategoryBits(GroundGeom, (int)(CollisionCategories.Land));
1950 d.GeomSetCollideBits(GroundGeom, (int)(CollisionCategories.Space));
1951
1952 }
1953 geom_name_map[GroundGeom] = "Terrain";
1954
1955 d.Matrix3 R = new d.Matrix3();
1956
1957 Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
1958 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
1959
1960
1961 q1 = q1 * q2;
1962
1963 Vector3 v3;
1964 float angle;
1965 q1.GetAxisAngle(out v3, out angle);
1966
1967 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
1968 d.GeomSetRotation(GroundGeom, ref R);
1969 d.GeomSetPosition(GroundGeom, pOffset.X + (float)Constants.RegionSize * 0.5f - 0.5f, pOffset.Y + (float)Constants.RegionSize * 0.5f - 0.5f, 0);
1970 RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
1971// TerrainHeightFieldHeights.Add(GroundGeom, ODElandMap);
1972 TerrainHeightFieldHeights.Add(GroundGeom, _heightmap);
1973 TerrainHeightFieldHeightsHandlers.Add(GroundGeom, _heightmaphandler);
1974
1975 }
1976 }
1977
1978 public override void DeleteTerrain()
1979 {
1980 }
1981
1982 public float GetWaterLevel()
1983 {
1984 return waterlevel;
1985 }
1986
1987 public override bool SupportsCombining()
1988 {
1989 return true;
1990 }
1991/*
1992 public override void UnCombine(PhysicsScene pScene)
1993 {
1994 IntPtr localGround = IntPtr.Zero;
1995// float[] localHeightfield;
1996 bool proceed = false;
1997 List<IntPtr> geomDestroyList = new List<IntPtr>();
1998
1999 lock (OdeLock)
2000 {
2001 if (RegionTerrain.TryGetValue(Vector3.Zero, out localGround))
2002 {
2003 foreach (IntPtr geom in TerrainHeightFieldHeights.Keys)
2004 {
2005 if (geom == localGround)
2006 {
2007// localHeightfield = TerrainHeightFieldHeights[geom];
2008 proceed = true;
2009 }
2010 else
2011 {
2012 geomDestroyList.Add(geom);
2013 }
2014 }
2015
2016 if (proceed)
2017 {
2018 m_worldOffset = Vector3.Zero;
2019 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
2020 m_parentScene = null;
2021
2022 foreach (IntPtr g in geomDestroyList)
2023 {
2024 // removingHeightField needs to be done or the garbage collector will
2025 // collect the terrain data before we tell ODE to destroy it causing
2026 // memory corruption
2027 if (TerrainHeightFieldHeights.ContainsKey(g))
2028 {
2029// float[] removingHeightField = TerrainHeightFieldHeights[g];
2030 TerrainHeightFieldHeights.Remove(g);
2031
2032 if (RegionTerrain.ContainsKey(g))
2033 {
2034 RegionTerrain.Remove(g);
2035 }
2036
2037 d.GeomDestroy(g);
2038 //removingHeightField = new float[0];
2039 }
2040 }
2041
2042 }
2043 else
2044 {
2045 m_log.Warn("[PHYSICS]: Couldn't proceed with UnCombine. Region has inconsistant data.");
2046 }
2047 }
2048 }
2049 }
2050*/
2051 public override void SetWaterLevel(float baseheight)
2052 {
2053 waterlevel = baseheight;
2054 randomizeWater(waterlevel);
2055 }
2056
2057 public void randomizeWater(float baseheight)
2058 {
2059 const uint heightmapWidth = m_regionWidth + 2;
2060 const uint heightmapHeight = m_regionHeight + 2;
2061 const uint heightmapWidthSamples = m_regionWidth + 2;
2062 const uint heightmapHeightSamples = m_regionHeight + 2;
2063 const float scale = 1.0f;
2064 const float offset = 0.0f;
2065 const float thickness = 2.9f;
2066 const int wrap = 0;
2067
2068 for (int i = 0; i < (258 * 258); i++)
2069 {
2070 _watermap[i] = (baseheight-0.1f) + ((float)fluidRandomizer.Next(1,9) / 10f);
2071 // m_log.Info((baseheight - 0.1f) + ((float)fluidRandomizer.Next(1, 9) / 10f));
2072 }
2073
2074 lock (OdeLock)
2075 {
2076 if (WaterGeom != IntPtr.Zero)
2077 {
2078 d.SpaceRemove(StaticSpace, WaterGeom);
2079 }
2080 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
2081 d.GeomHeightfieldDataBuildSingle(HeightmapData, _watermap, 0, heightmapWidth, heightmapHeight,
2082 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
2083 offset, thickness, wrap);
2084 d.GeomHeightfieldDataSetBounds(HeightmapData, m_regionWidth, m_regionHeight);
2085 WaterGeom = d.CreateHeightfield(StaticSpace, HeightmapData, 1);
2086 if (WaterGeom != IntPtr.Zero)
2087 {
2088 d.GeomSetCategoryBits(WaterGeom, (int)(CollisionCategories.Water));
2089 d.GeomSetCollideBits(WaterGeom, (int)(CollisionCategories.Space));
2090
2091 }
2092 geom_name_map[WaterGeom] = "Water";
2093
2094 d.Matrix3 R = new d.Matrix3();
2095
2096 Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
2097 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
2098
2099 q1 = q1 * q2;
2100 Vector3 v3;
2101 float angle;
2102 q1.GetAxisAngle(out v3, out angle);
2103
2104 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
2105 d.GeomSetRotation(WaterGeom, ref R);
2106 d.GeomSetPosition(WaterGeom, 128, 128, 0);
2107
2108 }
2109
2110 }
2111
2112 public override void Dispose()
2113 {
2114 m_rayCastManager.Dispose();
2115 m_rayCastManager = null;
2116
2117 lock (OdeLock)
2118 {
2119 lock (_prims)
2120 {
2121 foreach (OdePrim prm in _prims)
2122 {
2123 RemovePrim(prm);
2124 }
2125 }
2126
2127 if (ContactgeomsArray != IntPtr.Zero)
2128 Marshal.FreeHGlobal(ContactgeomsArray);
2129 if (GlobalContactsArray != IntPtr.Zero)
2130 Marshal.FreeHGlobal(GlobalContactsArray);
2131
2132 d.WorldDestroy(world);
2133 //d.CloseODE();
2134 }
2135 }
2136
2137 public override Dictionary<uint, float> GetTopColliders()
2138 {
2139 Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
2140 int cnt = 0;
2141 lock (_prims)
2142 {
2143 foreach (OdePrim prm in _prims)
2144 {
2145 if (prm.CollisionScore > 0)
2146 {
2147 returncolliders.Add(prm.m_localID, prm.CollisionScore);
2148 cnt++;
2149 prm.CollisionScore = 0f;
2150 if (cnt > 25)
2151 {
2152 break;
2153 }
2154 }
2155 }
2156 }
2157 return returncolliders;
2158 }
2159
2160 public override bool SupportsRayCast()
2161 {
2162 return true;
2163 }
2164
2165 public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
2166 {
2167 if (retMethod != null)
2168 {
2169 m_rayCastManager.QueueRequest(position, direction, length, retMethod);
2170 }
2171 }
2172
2173 public override void RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
2174 {
2175 if (retMethod != null)
2176 {
2177 m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
2178 }
2179 }
2180
2181 // don't like this
2182 public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
2183 {
2184 ContactResult[] ourResults = null;
2185 RayCallback retMethod = delegate(List<ContactResult> results)
2186 {
2187 ourResults = new ContactResult[results.Count];
2188 results.CopyTo(ourResults, 0);
2189 };
2190 int waitTime = 0;
2191 m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
2192 while (ourResults == null && waitTime < 1000)
2193 {
2194 Thread.Sleep(1);
2195 waitTime++;
2196 }
2197 if (ourResults == null)
2198 return new List<ContactResult>();
2199 return new List<ContactResult>(ourResults);
2200 }
2201
2202 public override void RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
2203 {
2204 if (retMethod != null && actor !=null)
2205 {
2206 IntPtr geom;
2207 if (actor is OdePrim)
2208 geom = ((OdePrim)actor).prim_geom;
2209 else if (actor is OdeCharacter)
2210 geom = ((OdePrim)actor).prim_geom;
2211 else
2212 return;
2213 if (geom == IntPtr.Zero)
2214 return;
2215 m_rayCastManager.QueueRequest(geom, position, direction, length, retMethod);
2216 }
2217 }
2218
2219 public override void RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
2220 {
2221 if (retMethod != null && actor != null)
2222 {
2223 IntPtr geom;
2224 if (actor is OdePrim)
2225 geom = ((OdePrim)actor).prim_geom;
2226 else if (actor is OdeCharacter)
2227 geom = ((OdePrim)actor).prim_geom;
2228 else
2229 return;
2230 if (geom == IntPtr.Zero)
2231 return;
2232
2233 m_rayCastManager.QueueRequest(geom,position, direction, length, Count, retMethod);
2234 }
2235 }
2236
2237 // don't like this
2238 public override List<ContactResult> RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count)
2239 {
2240 if (actor != null)
2241 {
2242 IntPtr geom;
2243 if (actor is OdePrim)
2244 geom = ((OdePrim)actor).prim_geom;
2245 else if (actor is OdeCharacter)
2246 geom = ((OdePrim)actor).prim_geom;
2247 else
2248 return new List<ContactResult>();
2249 if (geom == IntPtr.Zero)
2250 return new List<ContactResult>();
2251
2252 ContactResult[] ourResults = null;
2253 RayCallback retMethod = delegate(List<ContactResult> results)
2254 {
2255 ourResults = new ContactResult[results.Count];
2256 results.CopyTo(ourResults, 0);
2257 };
2258 int waitTime = 0;
2259 m_rayCastManager.QueueRequest(geom,position, direction, length, Count, retMethod);
2260 while (ourResults == null && waitTime < 1000)
2261 {
2262 Thread.Sleep(1);
2263 waitTime++;
2264 }
2265 if (ourResults == null)
2266 return new List<ContactResult>();
2267 return new List<ContactResult>(ourResults);
2268 }
2269 return new List<ContactResult>();
2270 }
2271 }
2272}
generated by cgit v1.1 at 2024-10-20 19:24:53 +0000