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