diff options
Diffstat (limited to 'OpenSim/Region/Physics/BulletSPlugin')
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs | 58 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs | 549 | ||||
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs | 43 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs | 618 | ||||
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs | 112 | ||||
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs | 445 | ||||
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs | 218 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs | 4 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs | 1157 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletSPlugin/BSScene.cs | 774 | ||||
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs | 756 | ||||
-rwxr-xr-x | OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs | 492 | ||||
-rw-r--r-- | OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs | 716 |
13 files changed, 3979 insertions, 1963 deletions
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs index 683bc51..3306a97 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs | |||
@@ -34,6 +34,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
34 | 34 | ||
35 | public class BS6DofConstraint : BSConstraint | 35 | public class BS6DofConstraint : BSConstraint |
36 | { | 36 | { |
37 | private static string LogHeader = "[BULLETSIM 6DOF CONSTRAINT]"; | ||
38 | |||
39 | public override ConstraintType Type { get { return ConstraintType.D6_CONSTRAINT_TYPE; } } | ||
40 | |||
37 | // Create a btGeneric6DofConstraint | 41 | // Create a btGeneric6DofConstraint |
38 | public BS6DofConstraint(BulletSim world, BulletBody obj1, BulletBody obj2, | 42 | public BS6DofConstraint(BulletSim world, BulletBody obj1, BulletBody obj2, |
39 | Vector3 frame1, Quaternion frame1rot, | 43 | Vector3 frame1, Quaternion frame1rot, |
@@ -44,11 +48,14 @@ public class BS6DofConstraint : BSConstraint | |||
44 | m_body1 = obj1; | 48 | m_body1 = obj1; |
45 | m_body2 = obj2; | 49 | m_body2 = obj2; |
46 | m_constraint = new BulletConstraint( | 50 | m_constraint = new BulletConstraint( |
47 | BulletSimAPI.Create6DofConstraint2(m_world.Ptr, m_body1.Ptr, m_body2.Ptr, | 51 | BulletSimAPI.Create6DofConstraint2(m_world.ptr, m_body1.ptr, m_body2.ptr, |
48 | frame1, frame1rot, | 52 | frame1, frame1rot, |
49 | frame2, frame2rot, | 53 | frame2, frame2rot, |
50 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); | 54 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); |
51 | m_enabled = true; | 55 | m_enabled = true; |
56 | world.physicsScene.DetailLog("{0},BS6DofConstraint,createFrame,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}", | ||
57 | BSScene.DetailLogZero, world.worldID, | ||
58 | obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X")); | ||
52 | } | 59 | } |
53 | 60 | ||
54 | public BS6DofConstraint(BulletSim world, BulletBody obj1, BulletBody obj2, | 61 | public BS6DofConstraint(BulletSim world, BulletBody obj1, BulletBody obj2, |
@@ -58,11 +65,36 @@ public class BS6DofConstraint : BSConstraint | |||
58 | m_world = world; | 65 | m_world = world; |
59 | m_body1 = obj1; | 66 | m_body1 = obj1; |
60 | m_body2 = obj2; | 67 | m_body2 = obj2; |
61 | m_constraint = new BulletConstraint( | 68 | if (obj1.ptr == IntPtr.Zero || obj2.ptr == IntPtr.Zero) |
62 | BulletSimAPI.Create6DofConstraintToPoint2(m_world.Ptr, m_body1.Ptr, m_body2.Ptr, | 69 | { |
63 | joinPoint, | 70 | world.physicsScene.DetailLog("{0},BS6DOFConstraint,badBodyPtr,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}", |
64 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); | 71 | BSScene.DetailLogZero, world.worldID, |
65 | m_enabled = true; | 72 | obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X")); |
73 | world.physicsScene.Logger.ErrorFormat("{0} Attempt to build 6DOF constraint with missing bodies: wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}", | ||
74 | "[BULLETSIM 6DOF CONSTRAINT]", world.worldID, | ||
75 | obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X")); | ||
76 | m_enabled = false; | ||
77 | } | ||
78 | else | ||
79 | { | ||
80 | m_constraint = new BulletConstraint( | ||
81 | BulletSimAPI.Create6DofConstraintToPoint2(m_world.ptr, m_body1.ptr, m_body2.ptr, | ||
82 | joinPoint, | ||
83 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); | ||
84 | world.physicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}", | ||
85 | BSScene.DetailLogZero, world.worldID, m_constraint.ptr.ToString("X"), | ||
86 | obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X")); | ||
87 | if (m_constraint.ptr == IntPtr.Zero) | ||
88 | { | ||
89 | world.physicsScene.Logger.ErrorFormat("{0} Failed creation of 6Dof constraint. rootID={1}, childID={2}", | ||
90 | LogHeader, obj1.ID, obj2.ID); | ||
91 | m_enabled = false; | ||
92 | } | ||
93 | else | ||
94 | { | ||
95 | m_enabled = true; | ||
96 | } | ||
97 | } | ||
66 | } | 98 | } |
67 | 99 | ||
68 | public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot) | 100 | public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot) |
@@ -70,7 +102,7 @@ public class BS6DofConstraint : BSConstraint | |||
70 | bool ret = false; | 102 | bool ret = false; |
71 | if (m_enabled) | 103 | if (m_enabled) |
72 | { | 104 | { |
73 | BulletSimAPI.SetFrames2(m_constraint.Ptr, frameA, frameArot, frameB, frameBrot); | 105 | BulletSimAPI.SetFrames2(m_constraint.ptr, frameA, frameArot, frameB, frameBrot); |
74 | ret = true; | 106 | ret = true; |
75 | } | 107 | } |
76 | return ret; | 108 | return ret; |
@@ -81,9 +113,9 @@ public class BS6DofConstraint : BSConstraint | |||
81 | bool ret = false; | 113 | bool ret = false; |
82 | if (m_enabled) | 114 | if (m_enabled) |
83 | { | 115 | { |
84 | BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL); | 116 | BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL); |
85 | BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL); | 117 | BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL); |
86 | BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL); | 118 | BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL); |
87 | ret = true; | 119 | ret = true; |
88 | } | 120 | } |
89 | return ret; | 121 | return ret; |
@@ -94,7 +126,7 @@ public class BS6DofConstraint : BSConstraint | |||
94 | bool ret = false; | 126 | bool ret = false; |
95 | float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; | 127 | float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; |
96 | if (m_enabled) | 128 | if (m_enabled) |
97 | ret = BulletSimAPI.UseFrameOffset2(m_constraint.Ptr, onOff); | 129 | ret = BulletSimAPI.UseFrameOffset2(m_constraint.ptr, onOff); |
98 | return ret; | 130 | return ret; |
99 | } | 131 | } |
100 | 132 | ||
@@ -103,7 +135,7 @@ public class BS6DofConstraint : BSConstraint | |||
103 | bool ret = false; | 135 | bool ret = false; |
104 | float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; | 136 | float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; |
105 | if (m_enabled) | 137 | if (m_enabled) |
106 | ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.Ptr, onOff, targetVelocity, maxMotorForce); | 138 | ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.ptr, onOff, targetVelocity, maxMotorForce); |
107 | return ret; | 139 | return ret; |
108 | } | 140 | } |
109 | 141 | ||
@@ -111,7 +143,7 @@ public class BS6DofConstraint : BSConstraint | |||
111 | { | 143 | { |
112 | bool ret = false; | 144 | bool ret = false; |
113 | if (m_enabled) | 145 | if (m_enabled) |
114 | ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.Ptr, threshold); | 146 | ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.ptr, threshold); |
115 | return ret; | 147 | return ret; |
116 | } | 148 | } |
117 | } | 149 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs index e2f7af9..2e6b2da 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs | |||
@@ -28,62 +28,46 @@ using System; | |||
28 | using System.Collections.Generic; | 28 | using System.Collections.Generic; |
29 | using System.Reflection; | 29 | using System.Reflection; |
30 | using log4net; | 30 | using log4net; |
31 | using OpenMetaverse; | 31 | using OMV = OpenMetaverse; |
32 | using OpenSim.Framework; | 32 | using OpenSim.Framework; |
33 | using OpenSim.Region.Physics.Manager; | 33 | using OpenSim.Region.Physics.Manager; |
34 | 34 | ||
35 | namespace OpenSim.Region.Physics.BulletSPlugin | 35 | namespace OpenSim.Region.Physics.BulletSPlugin |
36 | { | 36 | { |
37 | public class BSCharacter : PhysicsActor | 37 | public class BSCharacter : BSPhysObject |
38 | { | 38 | { |
39 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 39 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); |
40 | private static readonly string LogHeader = "[BULLETS CHAR]"; | 40 | private static readonly string LogHeader = "[BULLETS CHAR]"; |
41 | 41 | ||
42 | private BSScene _scene; | ||
43 | public BSScene Scene { get { return _scene; } } | ||
44 | private String _avName; | ||
45 | // private bool _stopped; | 42 | // private bool _stopped; |
46 | private Vector3 _size; | 43 | private OMV.Vector3 _size; |
47 | private Vector3 _scale; | 44 | private OMV.Vector3 _scale; |
48 | private PrimitiveBaseShape _pbs; | 45 | private PrimitiveBaseShape _pbs; |
49 | private uint _localID = 0; | ||
50 | private bool _grabbed; | 46 | private bool _grabbed; |
51 | private bool _selected; | 47 | private bool _selected; |
52 | private Vector3 _position; | 48 | private OMV.Vector3 _position; |
53 | private float _mass; | 49 | private float _mass; |
54 | public float _density; | 50 | private float _avatarDensity; |
55 | public float _avatarVolume; | 51 | private float _avatarVolume; |
56 | private Vector3 _force; | 52 | private OMV.Vector3 _force; |
57 | private Vector3 _velocity; | 53 | private OMV.Vector3 _velocity; |
58 | private Vector3 _torque; | 54 | private OMV.Vector3 _torque; |
59 | private float _collisionScore; | 55 | private float _collisionScore; |
60 | private Vector3 _acceleration; | 56 | private OMV.Vector3 _acceleration; |
61 | private Quaternion _orientation; | 57 | private OMV.Quaternion _orientation; |
62 | private int _physicsActorType; | 58 | private int _physicsActorType; |
63 | private bool _isPhysical; | 59 | private bool _isPhysical; |
64 | private bool _flying; | 60 | private bool _flying; |
65 | private bool _setAlwaysRun; | 61 | private bool _setAlwaysRun; |
66 | private bool _throttleUpdates; | 62 | private bool _throttleUpdates; |
67 | private bool _isColliding; | 63 | private bool _isColliding; |
68 | private long _collidingStep; | ||
69 | private bool _collidingGround; | ||
70 | private long _collidingGroundStep; | ||
71 | private bool _collidingObj; | 64 | private bool _collidingObj; |
72 | private bool _floatOnWater; | 65 | private bool _floatOnWater; |
73 | private Vector3 _rotationalVelocity; | 66 | private OMV.Vector3 _rotationalVelocity; |
74 | private bool _kinematic; | 67 | private bool _kinematic; |
75 | private float _buoyancy; | 68 | private float _buoyancy; |
76 | 69 | ||
77 | private BulletBody m_body; | 70 | private OMV.Vector3 _PIDTarget; |
78 | public BulletBody Body { | ||
79 | get { return m_body; } | ||
80 | set { m_body = value; } | ||
81 | } | ||
82 | |||
83 | private int _subscribedEventsMs = 0; | ||
84 | private int _nextCollisionOkTime = 0; | ||
85 | |||
86 | private Vector3 _PIDTarget; | ||
87 | private bool _usePID; | 71 | private bool _usePID; |
88 | private float _PIDTau; | 72 | private float _PIDTau; |
89 | private bool _useHoverPID; | 73 | private bool _useHoverPID; |
@@ -91,25 +75,26 @@ public class BSCharacter : PhysicsActor | |||
91 | private PIDHoverType _PIDHoverType; | 75 | private PIDHoverType _PIDHoverType; |
92 | private float _PIDHoverTao; | 76 | private float _PIDHoverTao; |
93 | 77 | ||
94 | public BSCharacter(uint localID, String avName, BSScene parent_scene, Vector3 pos, Vector3 size, bool isFlying) | 78 | public BSCharacter(uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, bool isFlying) |
95 | { | 79 | { |
96 | _localID = localID; | 80 | base.BaseInitialize(parent_scene, localID, avName, "BSCharacter"); |
97 | _avName = avName; | 81 | _physicsActorType = (int)ActorTypes.Agent; |
98 | _scene = parent_scene; | ||
99 | _position = pos; | 82 | _position = pos; |
100 | _size = size; | 83 | _size = size; |
101 | _flying = isFlying; | 84 | _flying = isFlying; |
102 | _orientation = Quaternion.Identity; | 85 | _orientation = OMV.Quaternion.Identity; |
103 | _velocity = Vector3.Zero; | 86 | _velocity = OMV.Vector3.Zero; |
104 | _buoyancy = ComputeBuoyancyFromFlying(isFlying); | 87 | _buoyancy = ComputeBuoyancyFromFlying(isFlying); |
88 | |||
105 | // The dimensions of the avatar capsule are kept in the scale. | 89 | // The dimensions of the avatar capsule are kept in the scale. |
106 | // Physics creates a unit capsule which is scaled by the physics engine. | 90 | // Physics creates a unit capsule which is scaled by the physics engine. |
107 | _scale = new Vector3(_scene.Params.avatarCapsuleRadius, _scene.Params.avatarCapsuleRadius, size.Z); | 91 | ComputeAvatarScale(_size); |
108 | _density = _scene.Params.avatarDensity; | 92 | _avatarDensity = PhysicsScene.Params.avatarDensity; |
109 | ComputeAvatarVolumeAndMass(); // set _avatarVolume and _mass based on capsule size, _density and _scale | 93 | // set _avatarVolume and _mass based on capsule size, _density and _scale |
94 | ComputeAvatarVolumeAndMass(); | ||
110 | 95 | ||
111 | ShapeData shapeData = new ShapeData(); | 96 | ShapeData shapeData = new ShapeData(); |
112 | shapeData.ID = _localID; | 97 | shapeData.ID = LocalID; |
113 | shapeData.Type = ShapeData.PhysicsShapeType.SHAPE_AVATAR; | 98 | shapeData.Type = ShapeData.PhysicsShapeType.SHAPE_AVATAR; |
114 | shapeData.Position = _position; | 99 | shapeData.Position = _position; |
115 | shapeData.Rotation = _orientation; | 100 | shapeData.Rotation = _orientation; |
@@ -118,29 +103,35 @@ public class BSCharacter : PhysicsActor | |||
118 | shapeData.Mass = _mass; | 103 | shapeData.Mass = _mass; |
119 | shapeData.Buoyancy = _buoyancy; | 104 | shapeData.Buoyancy = _buoyancy; |
120 | shapeData.Static = ShapeData.numericFalse; | 105 | shapeData.Static = ShapeData.numericFalse; |
121 | shapeData.Friction = _scene.Params.avatarFriction; | 106 | shapeData.Friction = PhysicsScene.Params.avatarFriction; |
122 | shapeData.Restitution = _scene.Params.avatarRestitution; | 107 | shapeData.Restitution = PhysicsScene.Params.avatarRestitution; |
123 | 108 | ||
124 | // do actual create at taint time | 109 | // do actual create at taint time |
125 | _scene.TaintedObject("BSCharacter.create", delegate() | 110 | PhysicsScene.TaintedObject("BSCharacter.create", delegate() |
126 | { | 111 | { |
127 | BulletSimAPI.CreateObject(parent_scene.WorldID, shapeData); | 112 | DetailLog("{0},BSCharacter.create,taint", LocalID); |
113 | BulletSimAPI.CreateObject(PhysicsScene.WorldID, shapeData); | ||
114 | |||
115 | // Set the buoyancy for flying. This will be refactored when all the settings happen in C#. | ||
116 | // If not set at creation, the avatar will stop flying when created after crossing a region boundry. | ||
117 | BulletSimAPI.SetObjectBuoyancy(PhysicsScene.WorldID, LocalID, _buoyancy); | ||
118 | |||
119 | BSBody = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(PhysicsScene.World.ptr, LocalID)); | ||
128 | 120 | ||
129 | m_body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID)); | 121 | // This works here because CreateObject has already put the character into the physical world. |
130 | // avatars get all collisions no matter what | 122 | BulletSimAPI.SetCollisionFilterMask2(BSBody.ptr, |
131 | BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | 123 | (uint)CollisionFilterGroups.AvatarFilter, (uint)CollisionFilterGroups.AvatarMask); |
132 | }); | 124 | }); |
133 | |||
134 | return; | 125 | return; |
135 | } | 126 | } |
136 | 127 | ||
137 | // called when this character is being destroyed and the resources should be released | 128 | // called when this character is being destroyed and the resources should be released |
138 | public void Destroy() | 129 | public override void Destroy() |
139 | { | 130 | { |
140 | // DetailLog("{0},BSCharacter.Destroy", LocalID); | 131 | DetailLog("{0},BSCharacter.Destroy", LocalID); |
141 | _scene.TaintedObject("BSCharacter.destroy", delegate() | 132 | PhysicsScene.TaintedObject("BSCharacter.destroy", delegate() |
142 | { | 133 | { |
143 | BulletSimAPI.DestroyObject(_scene.WorldID, _localID); | 134 | BulletSimAPI.DestroyObject(PhysicsScene.WorldID, LocalID); |
144 | }); | 135 | }); |
145 | } | 136 | } |
146 | 137 | ||
@@ -149,274 +140,368 @@ public class BSCharacter : PhysicsActor | |||
149 | base.RequestPhysicsterseUpdate(); | 140 | base.RequestPhysicsterseUpdate(); |
150 | } | 141 | } |
151 | // No one calls this method so I don't know what it could possibly mean | 142 | // No one calls this method so I don't know what it could possibly mean |
152 | public override bool Stopped { | 143 | public override bool Stopped { |
153 | get { return false; } | 144 | get { return false; } |
154 | } | 145 | } |
155 | public override Vector3 Size { | 146 | public override OMV.Vector3 Size { |
156 | get | 147 | get |
157 | { | 148 | { |
158 | // Avatar capsule size is kept in the scale parameter. | 149 | // Avatar capsule size is kept in the scale parameter. |
159 | return new Vector3(_scale.X * 2, _scale.Y * 2, _scale.Z); | 150 | return new OMV.Vector3(_scale.X * 2, _scale.Y * 2, _scale.Z); |
160 | } | 151 | } |
161 | 152 | ||
162 | set { | 153 | set { |
163 | // When an avatar's size is set, only the height is changed | 154 | // When an avatar's size is set, only the height is changed |
164 | // and that really only depends on the radius. | 155 | // and that really only depends on the radius. |
165 | _size = value; | 156 | _size = value; |
166 | _scale.Z = (_size.Z * 1.15f) - (_scale.X + _scale.Y); | 157 | ComputeAvatarScale(_size); |
167 | 158 | ||
168 | // TODO: something has to be done with the avatar's vertical position | 159 | // TODO: something has to be done with the avatar's vertical position |
169 | 160 | ||
170 | ComputeAvatarVolumeAndMass(); | 161 | ComputeAvatarVolumeAndMass(); |
171 | 162 | ||
172 | _scene.TaintedObject("BSCharacter.setSize", delegate() | 163 | PhysicsScene.TaintedObject("BSCharacter.setSize", delegate() |
173 | { | 164 | { |
174 | BulletSimAPI.SetObjectScaleMass(_scene.WorldID, LocalID, _scale, _mass, true); | 165 | BulletSimAPI.SetObjectScaleMass(PhysicsScene.WorldID, LocalID, _scale, _mass, true); |
175 | }); | 166 | }); |
176 | 167 | ||
177 | } | 168 | } |
178 | } | ||
179 | public override PrimitiveBaseShape Shape { | ||
180 | set { _pbs = value; | ||
181 | } | ||
182 | } | 169 | } |
183 | public override uint LocalID { | 170 | public override PrimitiveBaseShape Shape { |
184 | set { _localID = value; | 171 | set { _pbs = value; |
185 | } | 172 | } |
186 | get { return _localID; } | ||
187 | } | 173 | } |
188 | public override bool Grabbed { | 174 | public override bool Grabbed { |
189 | set { _grabbed = value; | 175 | set { _grabbed = value; |
190 | } | 176 | } |
191 | } | 177 | } |
192 | public override bool Selected { | 178 | public override bool Selected { |
193 | set { _selected = value; | 179 | set { _selected = value; |
194 | } | 180 | } |
195 | } | 181 | } |
196 | public override void CrossingFailure() { return; } | 182 | public override void CrossingFailure() { return; } |
197 | public override void link(PhysicsActor obj) { return; } | 183 | public override void link(PhysicsActor obj) { return; } |
198 | public override void delink() { return; } | 184 | public override void delink() { return; } |
199 | public override void LockAngularMotion(Vector3 axis) { return; } | ||
200 | 185 | ||
201 | public override Vector3 Position { | 186 | // Set motion values to zero. |
187 | // Do it to the properties so the values get set in the physics engine. | ||
188 | // Push the setting of the values to the viewer. | ||
189 | // Called at taint time! | ||
190 | public override void ZeroMotion() | ||
191 | { | ||
192 | _velocity = OMV.Vector3.Zero; | ||
193 | _acceleration = OMV.Vector3.Zero; | ||
194 | _rotationalVelocity = OMV.Vector3.Zero; | ||
195 | |||
196 | // Zero some other properties directly into the physics engine | ||
197 | BulletSimAPI.SetLinearVelocity2(BSBody.ptr, OMV.Vector3.Zero); | ||
198 | BulletSimAPI.SetAngularVelocity2(BSBody.ptr, OMV.Vector3.Zero); | ||
199 | BulletSimAPI.SetInterpolationVelocity2(BSBody.ptr, OMV.Vector3.Zero, OMV.Vector3.Zero); | ||
200 | BulletSimAPI.ClearForces2(BSBody.ptr); | ||
201 | } | ||
202 | |||
203 | public override void LockAngularMotion(OMV.Vector3 axis) { return; } | ||
204 | |||
205 | public override OMV.Vector3 Position { | ||
202 | get { | 206 | get { |
203 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 207 | // _position = BulletSimAPI.GetObjectPosition(Scene.WorldID, _localID); |
204 | return _position; | 208 | return _position; |
205 | } | 209 | } |
206 | set { | 210 | set { |
207 | _position = value; | 211 | _position = value; |
208 | PositionSanityCheck(); | 212 | PositionSanityCheck(); |
209 | 213 | ||
210 | _scene.TaintedObject("BSCharacter.setPosition", delegate() | 214 | PhysicsScene.TaintedObject("BSCharacter.setPosition", delegate() |
211 | { | 215 | { |
212 | DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); | 216 | DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); |
213 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 217 | BulletSimAPI.SetObjectTranslation(PhysicsScene.WorldID, LocalID, _position, _orientation); |
214 | }); | 218 | }); |
215 | } | 219 | } |
220 | } | ||
221 | public override OMV.Vector3 ForcePosition { | ||
222 | get { | ||
223 | _position = BulletSimAPI.GetPosition2(BSBody.ptr); | ||
224 | return _position; | ||
225 | } | ||
226 | set { | ||
227 | _position = value; | ||
228 | PositionSanityCheck(); | ||
229 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); | ||
230 | } | ||
216 | } | 231 | } |
217 | 232 | ||
233 | |||
218 | // Check that the current position is sane and, if not, modify the position to make it so. | 234 | // Check that the current position is sane and, if not, modify the position to make it so. |
219 | // Check for being below terrain and being out of bounds. | 235 | // Check for being below terrain and being out of bounds. |
220 | // Returns 'true' of the position was made sane by some action. | 236 | // Returns 'true' of the position was made sane by some action. |
221 | private bool PositionSanityCheck() | 237 | private bool PositionSanityCheck() |
222 | { | 238 | { |
223 | bool ret = false; | 239 | bool ret = false; |
224 | 240 | ||
225 | // If below the ground, move the avatar up | 241 | // If below the ground, move the avatar up |
226 | float terrainHeight = Scene.GetTerrainHeightAtXYZ(_position); | 242 | float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(_position); |
227 | if (_position.Z < terrainHeight) | 243 | if (Position.Z < terrainHeight) |
228 | { | 244 | { |
229 | DetailLog("{0},BSCharacter.PositionAdjustUnderGround,call,pos={1},orient={2}", LocalID, _position, _orientation); | 245 | DetailLog("{0},BSCharacter.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, _position, terrainHeight); |
230 | _position.Z = terrainHeight + 2.0f; | 246 | _position.Z = terrainHeight + 2.0f; |
231 | ret = true; | 247 | ret = true; |
232 | } | 248 | } |
249 | if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0) | ||
250 | { | ||
251 | float waterHeight = PhysicsScene.GetWaterLevelAtXYZ(_position); | ||
252 | if (Position.Z < waterHeight) | ||
253 | { | ||
254 | _position.Z = waterHeight; | ||
255 | ret = true; | ||
256 | } | ||
257 | } | ||
233 | 258 | ||
234 | // TODO: check for out of bounds | 259 | // TODO: check for out of bounds |
260 | return ret; | ||
261 | } | ||
235 | 262 | ||
263 | // A version of the sanity check that also makes sure a new position value is | ||
264 | // pushed back to the physics engine. This routine would be used by anyone | ||
265 | // who is not already pushing the value. | ||
266 | private bool PositionSanityCheck2(bool inTaintTime) | ||
267 | { | ||
268 | bool ret = false; | ||
269 | if (PositionSanityCheck()) | ||
270 | { | ||
271 | // The new position value must be pushed into the physics engine but we can't | ||
272 | // just assign to "Position" because of potential call loops. | ||
273 | BSScene.TaintCallback sanityOperation = delegate() | ||
274 | { | ||
275 | DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation); | ||
276 | BulletSimAPI.SetObjectTranslation(PhysicsScene.WorldID, LocalID, _position, _orientation); | ||
277 | }; | ||
278 | if (inTaintTime) | ||
279 | sanityOperation(); | ||
280 | else | ||
281 | PhysicsScene.TaintedObject("BSCharacter.PositionSanityCheck", sanityOperation); | ||
282 | ret = true; | ||
283 | } | ||
236 | return ret; | 284 | return ret; |
237 | } | 285 | } |
238 | 286 | ||
239 | public override float Mass { | 287 | public override float Mass { |
240 | get { | 288 | get { |
241 | return _mass; | 289 | return _mass; |
242 | } | 290 | } |
243 | } | 291 | } |
244 | public override Vector3 Force { | 292 | |
245 | get { return _force; } | 293 | // used when we only want this prim's mass and not the linkset thing |
294 | public override float MassRaw { get {return _mass; } } | ||
295 | |||
296 | public override OMV.Vector3 Force { | ||
297 | get { return _force; } | ||
246 | set { | 298 | set { |
247 | _force = value; | 299 | _force = value; |
248 | // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force); | 300 | // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force); |
249 | Scene.TaintedObject("BSCharacter.SetForce", delegate() | 301 | PhysicsScene.TaintedObject("BSCharacter.SetForce", delegate() |
250 | { | 302 | { |
251 | DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, _force); | 303 | DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, _force); |
252 | BulletSimAPI.SetObjectForce(Scene.WorldID, LocalID, _force); | 304 | BulletSimAPI.SetObjectForce(PhysicsScene.WorldID, LocalID, _force); |
253 | }); | 305 | }); |
254 | } | 306 | } |
255 | } | 307 | } |
256 | 308 | ||
257 | public override int VehicleType { | 309 | public override int VehicleType { |
258 | get { return 0; } | 310 | get { return 0; } |
259 | set { return; } | 311 | set { return; } |
260 | } | 312 | } |
261 | public override void VehicleFloatParam(int param, float value) { } | 313 | public override void VehicleFloatParam(int param, float value) { } |
262 | public override void VehicleVectorParam(int param, Vector3 value) {} | 314 | public override void VehicleVectorParam(int param, OMV.Vector3 value) {} |
263 | public override void VehicleRotationParam(int param, Quaternion rotation) { } | 315 | public override void VehicleRotationParam(int param, OMV.Quaternion rotation) { } |
264 | public override void VehicleFlags(int param, bool remove) { } | 316 | public override void VehicleFlags(int param, bool remove) { } |
265 | 317 | ||
266 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more | 318 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more |
267 | public override void SetVolumeDetect(int param) { return; } | 319 | public override void SetVolumeDetect(int param) { return; } |
268 | 320 | ||
269 | public override Vector3 GeometricCenter { get { return Vector3.Zero; } } | 321 | public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } } |
270 | public override Vector3 CenterOfMass { get { return Vector3.Zero; } } | 322 | public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } } |
271 | public override Vector3 Velocity { | 323 | public override OMV.Vector3 Velocity { |
272 | get { return _velocity; } | 324 | get { return _velocity; } |
273 | set { | 325 | set { |
274 | _velocity = value; | 326 | _velocity = value; |
275 | // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, _velocity); | 327 | // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, _velocity); |
276 | _scene.TaintedObject("BSCharacter.setVelocity", delegate() | 328 | PhysicsScene.TaintedObject("BSCharacter.setVelocity", delegate() |
277 | { | 329 | { |
278 | DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, _velocity); | 330 | DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, _velocity); |
279 | BulletSimAPI.SetObjectVelocity(_scene.WorldID, _localID, _velocity); | 331 | BulletSimAPI.SetObjectVelocity(PhysicsScene.WorldID, LocalID, _velocity); |
280 | }); | 332 | }); |
281 | } | 333 | } |
282 | } | 334 | } |
283 | public override Vector3 Torque { | 335 | public override OMV.Vector3 ForceVelocity { |
284 | get { return _torque; } | 336 | get { return _velocity; } |
285 | set { _torque = value; | 337 | set { |
286 | } | 338 | _velocity = value; |
339 | BulletSimAPI.SetObjectVelocity(PhysicsScene.WorldID, LocalID, _velocity); | ||
340 | } | ||
287 | } | 341 | } |
288 | public override float CollisionScore { | 342 | public override OMV.Vector3 Torque { |
289 | get { return _collisionScore; } | 343 | get { return _torque; } |
290 | set { _collisionScore = value; | 344 | set { _torque = value; |
291 | } | 345 | } |
346 | } | ||
347 | public override float CollisionScore { | ||
348 | get { return _collisionScore; } | ||
349 | set { _collisionScore = value; | ||
350 | } | ||
292 | } | 351 | } |
293 | public override Vector3 Acceleration { | 352 | public override OMV.Vector3 Acceleration { |
294 | get { return _acceleration; } | 353 | get { return _acceleration; } |
295 | set { _acceleration = value; } | 354 | set { _acceleration = value; } |
296 | } | 355 | } |
297 | public override Quaternion Orientation { | 356 | public override OMV.Quaternion Orientation { |
298 | get { return _orientation; } | 357 | get { return _orientation; } |
299 | set { | 358 | set { |
300 | _orientation = value; | 359 | _orientation = value; |
301 | // m_log.DebugFormat("{0}: set orientation to {1}", LogHeader, _orientation); | 360 | // m_log.DebugFormat("{0}: set orientation to {1}", LogHeader, _orientation); |
302 | _scene.TaintedObject("BSCharacter.setOrientation", delegate() | 361 | PhysicsScene.TaintedObject("BSCharacter.setOrientation", delegate() |
303 | { | 362 | { |
304 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 363 | // _position = BulletSimAPI.GetObjectPosition(Scene.WorldID, _localID); |
305 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 364 | BulletSimAPI.SetObjectTranslation(PhysicsScene.WorldID, LocalID, _position, _orientation); |
306 | }); | 365 | }); |
307 | } | 366 | } |
367 | } | ||
368 | // Go directly to Bullet to get/set the value. | ||
369 | public override OMV.Quaternion ForceOrientation | ||
370 | { | ||
371 | get | ||
372 | { | ||
373 | _orientation = BulletSimAPI.GetOrientation2(BSBody.ptr); | ||
374 | return _orientation; | ||
375 | } | ||
376 | set | ||
377 | { | ||
378 | _orientation = value; | ||
379 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); | ||
380 | } | ||
308 | } | 381 | } |
309 | public override int PhysicsActorType { | 382 | public override int PhysicsActorType { |
310 | get { return _physicsActorType; } | 383 | get { return _physicsActorType; } |
311 | set { _physicsActorType = value; | 384 | set { _physicsActorType = value; |
312 | } | 385 | } |
313 | } | 386 | } |
314 | public override bool IsPhysical { | 387 | public override bool IsPhysical { |
315 | get { return _isPhysical; } | 388 | get { return _isPhysical; } |
316 | set { _isPhysical = value; | 389 | set { _isPhysical = value; |
317 | } | 390 | } |
318 | } | 391 | } |
319 | public override bool Flying { | 392 | public override bool Flying { |
320 | get { return _flying; } | 393 | get { return _flying; } |
321 | set { | 394 | set { |
322 | if (_flying != value) | 395 | _flying = value; |
323 | { | 396 | // simulate flying by changing the effect of gravity |
324 | _flying = value; | 397 | this.Buoyancy = ComputeBuoyancyFromFlying(_flying); |
325 | // simulate flying by changing the effect of gravity | 398 | } |
326 | this.Buoyancy = ComputeBuoyancyFromFlying(_flying); | ||
327 | } | ||
328 | } | ||
329 | } | 399 | } |
400 | // Flying is implimented by changing the avatar's buoyancy. | ||
401 | // Would this be done better with a vehicle type? | ||
330 | private float ComputeBuoyancyFromFlying(bool ifFlying) { | 402 | private float ComputeBuoyancyFromFlying(bool ifFlying) { |
331 | return ifFlying ? 1f : 0f; | 403 | return ifFlying ? 1f : 0f; |
332 | } | 404 | } |
333 | public override bool | 405 | public override bool |
334 | SetAlwaysRun { | 406 | SetAlwaysRun { |
335 | get { return _setAlwaysRun; } | 407 | get { return _setAlwaysRun; } |
336 | set { _setAlwaysRun = value; } | 408 | set { _setAlwaysRun = value; } |
337 | } | 409 | } |
338 | public override bool ThrottleUpdates { | 410 | public override bool ThrottleUpdates { |
339 | get { return _throttleUpdates; } | 411 | get { return _throttleUpdates; } |
340 | set { _throttleUpdates = value; } | 412 | set { _throttleUpdates = value; } |
341 | } | 413 | } |
342 | public override bool IsColliding { | 414 | public override bool IsColliding { |
343 | get { return (_collidingStep == _scene.SimulationStep); } | 415 | get { return (CollidingStep == PhysicsScene.SimulationStep); } |
344 | set { _isColliding = value; } | 416 | set { _isColliding = value; } |
345 | } | 417 | } |
346 | public override bool CollidingGround { | 418 | public override bool CollidingGround { |
347 | get { return (_collidingGroundStep == _scene.SimulationStep); } | 419 | get { return (CollidingGroundStep == PhysicsScene.SimulationStep); } |
348 | set { _collidingGround = value; } | 420 | set { CollidingGround = value; } |
421 | } | ||
422 | public override bool CollidingObj { | ||
423 | get { return _collidingObj; } | ||
424 | set { _collidingObj = value; } | ||
349 | } | 425 | } |
350 | public override bool CollidingObj { | 426 | public override bool FloatOnWater { |
351 | get { return _collidingObj; } | 427 | set { |
352 | set { _collidingObj = value; } | 428 | _floatOnWater = value; |
429 | PhysicsScene.TaintedObject("BSCharacter.setFloatOnWater", delegate() | ||
430 | { | ||
431 | if (_floatOnWater) | ||
432 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
433 | else | ||
434 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
435 | }); | ||
436 | } | ||
353 | } | 437 | } |
354 | public override bool FloatOnWater { | 438 | public override OMV.Vector3 RotationalVelocity { |
355 | set { _floatOnWater = value; } | 439 | get { return _rotationalVelocity; } |
440 | set { _rotationalVelocity = value; } | ||
356 | } | 441 | } |
357 | public override Vector3 RotationalVelocity { | 442 | public override OMV.Vector3 ForceRotationalVelocity { |
358 | get { return _rotationalVelocity; } | 443 | get { return _rotationalVelocity; } |
359 | set { _rotationalVelocity = value; } | 444 | set { _rotationalVelocity = value; } |
360 | } | 445 | } |
361 | public override bool Kinematic { | 446 | public override bool Kinematic { |
362 | get { return _kinematic; } | 447 | get { return _kinematic; } |
363 | set { _kinematic = value; } | 448 | set { _kinematic = value; } |
364 | } | 449 | } |
365 | // neg=fall quickly, 0=1g, 1=0g, pos=float up | 450 | // neg=fall quickly, 0=1g, 1=0g, pos=float up |
366 | public override float Buoyancy { | 451 | public override float Buoyancy { |
367 | get { return _buoyancy; } | 452 | get { return _buoyancy; } |
368 | set { _buoyancy = value; | 453 | set { _buoyancy = value; |
369 | _scene.TaintedObject("BSCharacter.setBuoyancy", delegate() | 454 | PhysicsScene.TaintedObject("BSCharacter.setBuoyancy", delegate() |
370 | { | 455 | { |
371 | DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy); | 456 | DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy); |
372 | BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, LocalID, _buoyancy); | 457 | BulletSimAPI.SetObjectBuoyancy(PhysicsScene.WorldID, LocalID, _buoyancy); |
373 | }); | 458 | }); |
374 | } | 459 | } |
375 | } | 460 | } |
376 | 461 | ||
377 | // Used for MoveTo | 462 | // Used for MoveTo |
378 | public override Vector3 PIDTarget { | 463 | public override OMV.Vector3 PIDTarget { |
379 | set { _PIDTarget = value; } | 464 | set { _PIDTarget = value; } |
380 | } | 465 | } |
381 | public override bool PIDActive { | 466 | public override bool PIDActive { |
382 | set { _usePID = value; } | 467 | set { _usePID = value; } |
383 | } | 468 | } |
384 | public override float PIDTau { | 469 | public override float PIDTau { |
385 | set { _PIDTau = value; } | 470 | set { _PIDTau = value; } |
386 | } | 471 | } |
387 | 472 | ||
388 | // Used for llSetHoverHeight and maybe vehicle height | 473 | // Used for llSetHoverHeight and maybe vehicle height |
389 | // Hover Height will override MoveTo target's Z | 474 | // Hover Height will override MoveTo target's Z |
390 | public override bool PIDHoverActive { | 475 | public override bool PIDHoverActive { |
391 | set { _useHoverPID = value; } | 476 | set { _useHoverPID = value; } |
392 | } | 477 | } |
393 | public override float PIDHoverHeight { | 478 | public override float PIDHoverHeight { |
394 | set { _PIDHoverHeight = value; } | 479 | set { _PIDHoverHeight = value; } |
395 | } | 480 | } |
396 | public override PIDHoverType PIDHoverType { | 481 | public override PIDHoverType PIDHoverType { |
397 | set { _PIDHoverType = value; } | 482 | set { _PIDHoverType = value; } |
398 | } | 483 | } |
399 | public override float PIDHoverTau { | 484 | public override float PIDHoverTau { |
400 | set { _PIDHoverTao = value; } | 485 | set { _PIDHoverTao = value; } |
401 | } | 486 | } |
402 | 487 | ||
403 | // For RotLookAt | 488 | // For RotLookAt |
404 | public override Quaternion APIDTarget { set { return; } } | 489 | public override OMV.Quaternion APIDTarget { set { return; } } |
405 | public override bool APIDActive { set { return; } } | 490 | public override bool APIDActive { set { return; } } |
406 | public override float APIDStrength { set { return; } } | 491 | public override float APIDStrength { set { return; } } |
407 | public override float APIDDamping { set { return; } } | 492 | public override float APIDDamping { set { return; } } |
408 | 493 | ||
409 | public override void AddForce(Vector3 force, bool pushforce) { | 494 | public override void AddForce(OMV.Vector3 force, bool pushforce) { |
410 | if (force.IsFinite()) | 495 | if (force.IsFinite()) |
411 | { | 496 | { |
412 | _force.X += force.X; | 497 | _force.X += force.X; |
413 | _force.Y += force.Y; | 498 | _force.Y += force.Y; |
414 | _force.Z += force.Z; | 499 | _force.Z += force.Z; |
415 | // m_log.DebugFormat("{0}: AddForce. adding={1}, newForce={2}", LogHeader, force, _force); | 500 | // m_log.DebugFormat("{0}: AddForce. adding={1}, newForce={2}", LogHeader, force, _force); |
416 | _scene.TaintedObject("BSCharacter.AddForce", delegate() | 501 | PhysicsScene.TaintedObject("BSCharacter.AddForce", delegate() |
417 | { | 502 | { |
418 | DetailLog("{0},BSCharacter.setAddForce,taint,addedForce={1}", LocalID, _force); | 503 | DetailLog("{0},BSCharacter.setAddForce,taint,addedForce={1}", LocalID, _force); |
419 | BulletSimAPI.AddObjectForce2(Body.Ptr, _force); | 504 | BulletSimAPI.SetObjectForce2(BSBody.ptr, _force); |
420 | }); | 505 | }); |
421 | } | 506 | } |
422 | else | 507 | else |
@@ -426,37 +511,19 @@ public class BSCharacter : PhysicsActor | |||
426 | //m_lastUpdateSent = false; | 511 | //m_lastUpdateSent = false; |
427 | } | 512 | } |
428 | 513 | ||
429 | public override void AddAngularForce(Vector3 force, bool pushforce) { | 514 | public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { |
430 | } | 515 | } |
431 | public override void SetMomentum(Vector3 momentum) { | 516 | public override void SetMomentum(OMV.Vector3 momentum) { |
432 | } | 517 | } |
433 | 518 | ||
434 | // Turn on collision events at a rate no faster than one every the given milliseconds | 519 | private void ComputeAvatarScale(OMV.Vector3 size) |
435 | public override void SubscribeEvents(int ms) { | 520 | { |
436 | _subscribedEventsMs = ms; | 521 | _scale.X = PhysicsScene.Params.avatarCapsuleRadius; |
437 | if (ms > 0) | 522 | _scale.Y = PhysicsScene.Params.avatarCapsuleRadius; |
438 | { | ||
439 | // make sure first collision happens | ||
440 | _nextCollisionOkTime = Util.EnvironmentTickCount() - _subscribedEventsMs; | ||
441 | 523 | ||
442 | Scene.TaintedObject("BSCharacter.SubscribeEvents", delegate() | 524 | // The 1.15 came from ODE but it seems to cause the avatar to float off the ground |
443 | { | 525 | // _scale.Z = (_size.Z * 1.15f) - (_scale.X + _scale.Y); |
444 | BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | 526 | _scale.Z = (_size.Z) - (_scale.X + _scale.Y); |
445 | }); | ||
446 | } | ||
447 | } | ||
448 | // Stop collision events | ||
449 | public override void UnSubscribeEvents() { | ||
450 | _subscribedEventsMs = 0; | ||
451 | // Avatars get all their collision events | ||
452 | // Scene.TaintedObject("BSCharacter.UnSubscribeEvents", delegate() | ||
453 | // { | ||
454 | // BulletSimAPI.RemoveFromCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
455 | // }); | ||
456 | } | ||
457 | // Return 'true' if someone has subscribed to events | ||
458 | public override bool SubscribedEvents() { | ||
459 | return (_subscribedEventsMs > 0); | ||
460 | } | 527 | } |
461 | 528 | ||
462 | // set _avatarVolume and _mass based on capsule size, _density and _scale | 529 | // set _avatarVolume and _mass based on capsule size, _density and _scale |
@@ -473,82 +540,26 @@ public class BSCharacter : PhysicsActor | |||
473 | * Math.Min(_scale.X, _scale.Y) | 540 | * Math.Min(_scale.X, _scale.Y) |
474 | * _scale.Y // plus the volume of the capsule end caps | 541 | * _scale.Y // plus the volume of the capsule end caps |
475 | ); | 542 | ); |
476 | _mass = _density * _avatarVolume; | 543 | _mass = _avatarDensity * _avatarVolume; |
477 | } | 544 | } |
478 | 545 | ||
479 | // The physics engine says that properties have updated. Update same and inform | 546 | // The physics engine says that properties have updated. Update same and inform |
480 | // the world that things have changed. | 547 | // the world that things have changed. |
481 | public void UpdateProperties(EntityProperties entprop) | 548 | public override void UpdateProperties(EntityProperties entprop) |
482 | { | 549 | { |
483 | _position = entprop.Position; | 550 | _position = entprop.Position; |
484 | _orientation = entprop.Rotation; | 551 | _orientation = entprop.Rotation; |
485 | _velocity = entprop.Velocity; | 552 | _velocity = entprop.Velocity; |
486 | _acceleration = entprop.Acceleration; | 553 | _acceleration = entprop.Acceleration; |
487 | _rotationalVelocity = entprop.RotationalVelocity; | 554 | _rotationalVelocity = entprop.RotationalVelocity; |
555 | // Do some sanity checking for the avatar. Make sure it's above ground and inbounds. | ||
556 | PositionSanityCheck2(true); | ||
557 | |||
488 | // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop. | 558 | // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop. |
489 | // base.RequestPhysicsterseUpdate(); | 559 | // base.RequestPhysicsterseUpdate(); |
490 | 560 | ||
491 | /* | ||
492 | DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | 561 | DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", |
493 | LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, | 562 | LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); |
494 | entprop.Acceleration, entprop.RotationalVelocity); | ||
495 | */ | ||
496 | } | ||
497 | |||
498 | // Called by the scene when a collision with this object is reported | ||
499 | // The collision, if it should be reported to the character, is placed in a collection | ||
500 | // that will later be sent to the simulator when SendCollisions() is called. | ||
501 | CollisionEventUpdate collisionCollection = null; | ||
502 | public void Collide(uint collidingWith, ActorTypes type, Vector3 contactPoint, Vector3 contactNormal, float pentrationDepth) | ||
503 | { | ||
504 | // m_log.DebugFormat("{0}: Collide: ms={1}, id={2}, with={3}", LogHeader, _subscribedEventsMs, LocalID, collidingWith); | ||
505 | |||
506 | // The following makes IsColliding() and IsCollidingGround() work | ||
507 | _collidingStep = _scene.SimulationStep; | ||
508 | if (collidingWith == BSScene.TERRAIN_ID || collidingWith == BSScene.GROUNDPLANE_ID) | ||
509 | { | ||
510 | _collidingGroundStep = _scene.SimulationStep; | ||
511 | } | ||
512 | // DetailLog("{0},BSCharacter.Collison,call,with={1}", LocalID, collidingWith); | ||
513 | |||
514 | // throttle collisions to the rate specified in the subscription | ||
515 | if (_subscribedEventsMs != 0) { | ||
516 | int nowTime = _scene.SimulationNowTime; | ||
517 | if (nowTime >= _nextCollisionOkTime) { | ||
518 | _nextCollisionOkTime = nowTime + _subscribedEventsMs; | ||
519 | |||
520 | if (collisionCollection == null) | ||
521 | collisionCollection = new CollisionEventUpdate(); | ||
522 | collisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth)); | ||
523 | } | ||
524 | } | ||
525 | } | ||
526 | |||
527 | public void SendCollisions() | ||
528 | { | ||
529 | /* | ||
530 | if (collisionCollection != null && collisionCollection.Count > 0) | ||
531 | { | ||
532 | base.SendCollisionUpdate(collisionCollection); | ||
533 | collisionCollection = null; | ||
534 | } | ||
535 | */ | ||
536 | // Kludge to make a collision call even if there are no collisions. | ||
537 | // This causes the avatar animation to get updated. | ||
538 | if (collisionCollection == null) | ||
539 | collisionCollection = new CollisionEventUpdate(); | ||
540 | base.SendCollisionUpdate(collisionCollection); | ||
541 | // If there were any collisions in the collection, make sure we don't use the | ||
542 | // same instance next time. | ||
543 | if (collisionCollection.Count > 0) | ||
544 | collisionCollection = null; | ||
545 | // End kludge | ||
546 | } | ||
547 | |||
548 | // Invoke the detailed logger and output something if it's enabled. | ||
549 | private void DetailLog(string msg, params Object[] args) | ||
550 | { | ||
551 | Scene.PhysicsLogging.Write(msg, args); | ||
552 | } | 563 | } |
553 | } | 564 | } |
554 | } | 565 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs index 25084d8..a20be3a 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs | |||
@@ -48,22 +48,31 @@ public abstract class BSConstraint : IDisposable | |||
48 | { | 48 | { |
49 | if (m_enabled) | 49 | if (m_enabled) |
50 | { | 50 | { |
51 | // BulletSimAPI.RemoveConstraint(m_world.ID, m_body1.ID, m_body2.ID); | ||
52 | bool success = BulletSimAPI.DestroyConstraint2(m_world.Ptr, m_constraint.Ptr); | ||
53 | m_world.scene.DetailLog("{0},BSConstraint.Dispose,taint,body1={1},body2={2},success={3}", BSScene.DetailLogZero, m_body1.ID, m_body2.ID, success); | ||
54 | m_constraint.Ptr = System.IntPtr.Zero; | ||
55 | m_enabled = false; | 51 | m_enabled = false; |
52 | if (m_constraint.ptr != IntPtr.Zero) | ||
53 | { | ||
54 | bool success = BulletSimAPI.DestroyConstraint2(m_world.ptr, m_constraint.ptr); | ||
55 | m_world.physicsScene.DetailLog("{0},BSConstraint.Dispose,taint,id1={1},body1={2},id2={3},body2={4},success={5}", | ||
56 | BSScene.DetailLogZero, | ||
57 | m_body1.ID, m_body1.ptr.ToString("X"), | ||
58 | m_body2.ID, m_body2.ptr.ToString("X"), | ||
59 | success); | ||
60 | m_constraint.ptr = System.IntPtr.Zero; | ||
61 | } | ||
56 | } | 62 | } |
57 | } | 63 | } |
58 | 64 | ||
59 | public BulletBody Body1 { get { return m_body1; } } | 65 | public BulletBody Body1 { get { return m_body1; } } |
60 | public BulletBody Body2 { get { return m_body2; } } | 66 | public BulletBody Body2 { get { return m_body2; } } |
67 | public BulletConstraint Constraint { get { return m_constraint; } } | ||
68 | public abstract ConstraintType Type { get; } | ||
69 | |||
61 | 70 | ||
62 | public virtual bool SetLinearLimits(Vector3 low, Vector3 high) | 71 | public virtual bool SetLinearLimits(Vector3 low, Vector3 high) |
63 | { | 72 | { |
64 | bool ret = false; | 73 | bool ret = false; |
65 | if (m_enabled) | 74 | if (m_enabled) |
66 | ret = BulletSimAPI.SetLinearLimits2(m_constraint.Ptr, low, high); | 75 | ret = BulletSimAPI.SetLinearLimits2(m_constraint.ptr, low, high); |
67 | return ret; | 76 | return ret; |
68 | } | 77 | } |
69 | 78 | ||
@@ -71,7 +80,18 @@ public abstract class BSConstraint : IDisposable | |||
71 | { | 80 | { |
72 | bool ret = false; | 81 | bool ret = false; |
73 | if (m_enabled) | 82 | if (m_enabled) |
74 | ret = BulletSimAPI.SetAngularLimits2(m_constraint.Ptr, low, high); | 83 | ret = BulletSimAPI.SetAngularLimits2(m_constraint.ptr, low, high); |
84 | return ret; | ||
85 | } | ||
86 | |||
87 | public virtual bool SetSolverIterations(float cnt) | ||
88 | { | ||
89 | bool ret = false; | ||
90 | if (m_enabled) | ||
91 | { | ||
92 | BulletSimAPI.SetConstraintNumSolverIterations2(m_constraint.ptr, cnt); | ||
93 | ret = true; | ||
94 | } | ||
75 | return ret; | 95 | return ret; |
76 | } | 96 | } |
77 | 97 | ||
@@ -81,7 +101,7 @@ public abstract class BSConstraint : IDisposable | |||
81 | if (m_enabled) | 101 | if (m_enabled) |
82 | { | 102 | { |
83 | // Recompute the internal transforms | 103 | // Recompute the internal transforms |
84 | BulletSimAPI.CalculateTransforms2(m_constraint.Ptr); | 104 | BulletSimAPI.CalculateTransforms2(m_constraint.ptr); |
85 | ret = true; | 105 | ret = true; |
86 | } | 106 | } |
87 | return ret; | 107 | return ret; |
@@ -97,13 +117,14 @@ public abstract class BSConstraint : IDisposable | |||
97 | ret = CalculateTransforms(); | 117 | ret = CalculateTransforms(); |
98 | if (ret) | 118 | if (ret) |
99 | { | 119 | { |
100 | // m_world.scene.PhysicsLogging.Write("{0},BSConstraint.RecomputeConstraintVariables,taint,enabling,A={1},B={2}", | 120 | // Setting an object's mass to zero (making it static like when it's selected) |
101 | // BSScene.DetailLogZero, Body1.ID, Body2.ID); | 121 | // automatically disables the constraints. |
102 | BulletSimAPI.SetConstraintEnable2(m_constraint.Ptr, m_world.scene.NumericBool(true)); | 122 | // If the link is enabled, be sure to set the constraint itself to enabled. |
123 | BulletSimAPI.SetConstraintEnable2(m_constraint.ptr, m_world.physicsScene.NumericBool(true)); | ||
103 | } | 124 | } |
104 | else | 125 | else |
105 | { | 126 | { |
106 | m_world.scene.Logger.ErrorFormat("[BULLETSIM CONSTRAINT] CalculateTransforms failed. A={0}, B={1}", Body1.ID, Body2.ID); | 127 | m_world.physicsScene.Logger.ErrorFormat("[BULLETSIM CONSTRAINT] CalculateTransforms failed. A={0}, B={1}", Body1.ID, Body2.ID); |
107 | } | 128 | } |
108 | } | 129 | } |
109 | return ret; | 130 | return ret; |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs index 5a9f135..56342b8 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs | |||
@@ -54,17 +54,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
54 | { | 54 | { |
55 | public class BSDynamics | 55 | public class BSDynamics |
56 | { | 56 | { |
57 | private int frcount = 0; // Used to limit dynamics debug output to | 57 | private BSScene PhysicsScene { get; set; } |
58 | // every 100th frame | 58 | // the prim this dynamic controller belongs to |
59 | 59 | private BSPrim Prim { get; set; } | |
60 | private BSPrim m_prim; // the prim this dynamic controller belongs to | ||
61 | 60 | ||
62 | // Vehicle properties | 61 | // Vehicle properties |
63 | private Vehicle m_type = Vehicle.TYPE_NONE; // If a 'VEHICLE', and what kind | 62 | public Vehicle Type { get; set; } |
64 | public Vehicle Type | 63 | |
65 | { | ||
66 | get { return m_type; } | ||
67 | } | ||
68 | // private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier | 64 | // private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier |
69 | private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings: | 65 | private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings: |
70 | // HOVER_TERRAIN_ONLY | 66 | // HOVER_TERRAIN_ONLY |
@@ -74,13 +70,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
74 | // HOVER_UP_ONLY | 70 | // HOVER_UP_ONLY |
75 | // LIMIT_MOTOR_UP | 71 | // LIMIT_MOTOR_UP |
76 | // LIMIT_ROLL_ONLY | 72 | // LIMIT_ROLL_ONLY |
77 | private VehicleFlag m_Hoverflags = (VehicleFlag)0; | ||
78 | private Vector3 m_BlockingEndPoint = Vector3.Zero; | 73 | private Vector3 m_BlockingEndPoint = Vector3.Zero; |
79 | private Quaternion m_RollreferenceFrame = Quaternion.Identity; | 74 | private Quaternion m_RollreferenceFrame = Quaternion.Identity; |
80 | // Linear properties | 75 | // Linear properties |
81 | private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time | 76 | private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time |
82 | private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL | 77 | private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL |
83 | private Vector3 m_dir = Vector3.Zero; // velocity applied to body | 78 | private Vector3 m_newVelocity = Vector3.Zero; // velocity computed to be applied to body |
84 | private Vector3 m_linearFrictionTimescale = Vector3.Zero; | 79 | private Vector3 m_linearFrictionTimescale = Vector3.Zero; |
85 | private float m_linearMotorDecayTimescale = 0; | 80 | private float m_linearMotorDecayTimescale = 0; |
86 | private float m_linearMotorTimescale = 0; | 81 | private float m_linearMotorTimescale = 0; |
@@ -97,7 +92,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
97 | private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate | 92 | private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate |
98 | private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate | 93 | private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate |
99 | private Vector3 m_lastAngularVelocity = Vector3.Zero; // what was last applied to body | 94 | private Vector3 m_lastAngularVelocity = Vector3.Zero; // what was last applied to body |
100 | // private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body | 95 | private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body |
101 | 96 | ||
102 | //Deflection properties | 97 | //Deflection properties |
103 | // private float m_angularDeflectionEfficiency = 0; | 98 | // private float m_angularDeflectionEfficiency = 0; |
@@ -124,86 +119,74 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
124 | private float m_verticalAttractionEfficiency = 1.0f; // damped | 119 | private float m_verticalAttractionEfficiency = 1.0f; // damped |
125 | private float m_verticalAttractionTimescale = 500f; // Timescale > 300 means no vert attractor. | 120 | private float m_verticalAttractionTimescale = 500f; // Timescale > 300 means no vert attractor. |
126 | 121 | ||
127 | public BSDynamics(BSPrim myPrim) | 122 | public BSDynamics(BSScene myScene, BSPrim myPrim) |
123 | { | ||
124 | PhysicsScene = myScene; | ||
125 | Prim = myPrim; | ||
126 | Type = Vehicle.TYPE_NONE; | ||
127 | } | ||
128 | |||
129 | // Return 'true' if this vehicle is doing vehicle things | ||
130 | public bool IsActive | ||
128 | { | 131 | { |
129 | m_prim = myPrim; | 132 | get { return Type != Vehicle.TYPE_NONE; } |
130 | m_type = Vehicle.TYPE_NONE; | ||
131 | } | 133 | } |
132 | 134 | ||
133 | internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue, float timestep) | 135 | internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue) |
134 | { | 136 | { |
135 | DetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue); | 137 | VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); |
136 | switch (pParam) | 138 | switch (pParam) |
137 | { | 139 | { |
138 | case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: | 140 | case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: |
139 | if (pValue < 0.01f) pValue = 0.01f; | 141 | // m_angularDeflectionEfficiency = Math.Max(pValue, 0.01f); |
140 | // m_angularDeflectionEfficiency = pValue; | ||
141 | break; | 142 | break; |
142 | case Vehicle.ANGULAR_DEFLECTION_TIMESCALE: | 143 | case Vehicle.ANGULAR_DEFLECTION_TIMESCALE: |
143 | if (pValue < 0.01f) pValue = 0.01f; | 144 | // m_angularDeflectionTimescale = Math.Max(pValue, 0.01f); |
144 | // m_angularDeflectionTimescale = pValue; | ||
145 | break; | 145 | break; |
146 | case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: | 146 | case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: |
147 | if (pValue < 0.01f) pValue = 0.01f; | 147 | m_angularMotorDecayTimescale = Math.Max(pValue, 0.01f); |
148 | m_angularMotorDecayTimescale = pValue; | ||
149 | break; | 148 | break; |
150 | case Vehicle.ANGULAR_MOTOR_TIMESCALE: | 149 | case Vehicle.ANGULAR_MOTOR_TIMESCALE: |
151 | if (pValue < 0.01f) pValue = 0.01f; | 150 | m_angularMotorTimescale = Math.Max(pValue, 0.01f); |
152 | m_angularMotorTimescale = pValue; | ||
153 | break; | 151 | break; |
154 | case Vehicle.BANKING_EFFICIENCY: | 152 | case Vehicle.BANKING_EFFICIENCY: |
155 | if (pValue < 0.01f) pValue = 0.01f; | 153 | // m_bankingEfficiency = Math.Max(pValue, 0.01f); |
156 | // m_bankingEfficiency = pValue; | ||
157 | break; | 154 | break; |
158 | case Vehicle.BANKING_MIX: | 155 | case Vehicle.BANKING_MIX: |
159 | if (pValue < 0.01f) pValue = 0.01f; | 156 | // m_bankingMix = Math.Max(pValue, 0.01f); |
160 | // m_bankingMix = pValue; | ||
161 | break; | 157 | break; |
162 | case Vehicle.BANKING_TIMESCALE: | 158 | case Vehicle.BANKING_TIMESCALE: |
163 | if (pValue < 0.01f) pValue = 0.01f; | 159 | // m_bankingTimescale = Math.Max(pValue, 0.01f); |
164 | // m_bankingTimescale = pValue; | ||
165 | break; | 160 | break; |
166 | case Vehicle.BUOYANCY: | 161 | case Vehicle.BUOYANCY: |
167 | if (pValue < -1f) pValue = -1f; | 162 | m_VehicleBuoyancy = Math.Max(-1f, Math.Min(pValue, 1f)); |
168 | if (pValue > 1f) pValue = 1f; | ||
169 | m_VehicleBuoyancy = pValue; | ||
170 | break; | 163 | break; |
171 | // case Vehicle.HOVER_EFFICIENCY: | 164 | // case Vehicle.HOVER_EFFICIENCY: |
172 | // if (pValue < 0f) pValue = 0f; | 165 | // m_VhoverEfficiency = Math.Max(0f, Math.Min(pValue, 1f)); |
173 | // if (pValue > 1f) pValue = 1f; | ||
174 | // m_VhoverEfficiency = pValue; | ||
175 | // break; | 166 | // break; |
176 | case Vehicle.HOVER_HEIGHT: | 167 | case Vehicle.HOVER_HEIGHT: |
177 | m_VhoverHeight = pValue; | 168 | m_VhoverHeight = pValue; |
178 | break; | 169 | break; |
179 | case Vehicle.HOVER_TIMESCALE: | 170 | case Vehicle.HOVER_TIMESCALE: |
180 | if (pValue < 0.01f) pValue = 0.01f; | 171 | m_VhoverTimescale = Math.Max(pValue, 0.01f); |
181 | m_VhoverTimescale = pValue; | ||
182 | break; | 172 | break; |
183 | case Vehicle.LINEAR_DEFLECTION_EFFICIENCY: | 173 | case Vehicle.LINEAR_DEFLECTION_EFFICIENCY: |
184 | if (pValue < 0.01f) pValue = 0.01f; | 174 | // m_linearDeflectionEfficiency = Math.Max(pValue, 0.01f); |
185 | // m_linearDeflectionEfficiency = pValue; | ||
186 | break; | 175 | break; |
187 | case Vehicle.LINEAR_DEFLECTION_TIMESCALE: | 176 | case Vehicle.LINEAR_DEFLECTION_TIMESCALE: |
188 | if (pValue < 0.01f) pValue = 0.01f; | 177 | // m_linearDeflectionTimescale = Math.Max(pValue, 0.01f); |
189 | // m_linearDeflectionTimescale = pValue; | ||
190 | break; | 178 | break; |
191 | case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE: | 179 | case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE: |
192 | if (pValue < 0.01f) pValue = 0.01f; | 180 | m_linearMotorDecayTimescale = Math.Max(pValue, 0.01f); |
193 | m_linearMotorDecayTimescale = pValue; | ||
194 | break; | 181 | break; |
195 | case Vehicle.LINEAR_MOTOR_TIMESCALE: | 182 | case Vehicle.LINEAR_MOTOR_TIMESCALE: |
196 | if (pValue < 0.01f) pValue = 0.01f; | 183 | m_linearMotorTimescale = Math.Max(pValue, 0.01f); |
197 | m_linearMotorTimescale = pValue; | ||
198 | break; | 184 | break; |
199 | case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY: | 185 | case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY: |
200 | if (pValue < 0.1f) pValue = 0.1f; // Less goes unstable | 186 | m_verticalAttractionEfficiency = Math.Max(0.1f, Math.Min(pValue, 1f)); |
201 | if (pValue > 1.0f) pValue = 1.0f; | ||
202 | m_verticalAttractionEfficiency = pValue; | ||
203 | break; | 187 | break; |
204 | case Vehicle.VERTICAL_ATTRACTION_TIMESCALE: | 188 | case Vehicle.VERTICAL_ATTRACTION_TIMESCALE: |
205 | if (pValue < 0.01f) pValue = 0.01f; | 189 | m_verticalAttractionTimescale = Math.Max(pValue, 0.01f); |
206 | m_verticalAttractionTimescale = pValue; | ||
207 | break; | 190 | break; |
208 | 191 | ||
209 | // These are vector properties but the engine lets you use a single float value to | 192 | // These are vector properties but the engine lets you use a single float value to |
@@ -229,9 +212,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
229 | } | 212 | } |
230 | }//end ProcessFloatVehicleParam | 213 | }//end ProcessFloatVehicleParam |
231 | 214 | ||
232 | internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue, float timestep) | 215 | internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue) |
233 | { | 216 | { |
234 | DetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue); | 217 | VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); |
235 | switch (pParam) | 218 | switch (pParam) |
236 | { | 219 | { |
237 | case Vehicle.ANGULAR_FRICTION_TIMESCALE: | 220 | case Vehicle.ANGULAR_FRICTION_TIMESCALE: |
@@ -266,7 +249,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
266 | 249 | ||
267 | internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue) | 250 | internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue) |
268 | { | 251 | { |
269 | DetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue); | 252 | VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); |
270 | switch (pParam) | 253 | switch (pParam) |
271 | { | 254 | { |
272 | case Vehicle.REFERENCE_FRAME: | 255 | case Vehicle.REFERENCE_FRAME: |
@@ -280,166 +263,29 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
280 | 263 | ||
281 | internal void ProcessVehicleFlags(int pParam, bool remove) | 264 | internal void ProcessVehicleFlags(int pParam, bool remove) |
282 | { | 265 | { |
283 | DetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", m_prim.LocalID, pParam, remove); | 266 | VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", Prim.LocalID, pParam, remove); |
267 | VehicleFlag parm = (VehicleFlag)pParam; | ||
284 | if (remove) | 268 | if (remove) |
285 | { | 269 | { |
286 | if (pParam == -1) | 270 | if (pParam == -1) |
287 | { | 271 | { |
288 | m_flags = (VehicleFlag)0; | 272 | m_flags = (VehicleFlag)0; |
289 | m_Hoverflags = (VehicleFlag)0; | ||
290 | return; | ||
291 | } | ||
292 | if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) | ||
293 | { | ||
294 | if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != (VehicleFlag)0) | ||
295 | m_Hoverflags &= ~(VehicleFlag.HOVER_GLOBAL_HEIGHT); | ||
296 | } | ||
297 | if ((pParam & (int)VehicleFlag.HOVER_TERRAIN_ONLY) == (int)VehicleFlag.HOVER_TERRAIN_ONLY) | ||
298 | { | ||
299 | if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != (VehicleFlag)0) | ||
300 | m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY); | ||
301 | } | ||
302 | if ((pParam & (int)VehicleFlag.HOVER_UP_ONLY) == (int)VehicleFlag.HOVER_UP_ONLY) | ||
303 | { | ||
304 | if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != (VehicleFlag)0) | ||
305 | m_Hoverflags &= ~(VehicleFlag.HOVER_UP_ONLY); | ||
306 | } | ||
307 | if ((pParam & (int)VehicleFlag.HOVER_WATER_ONLY) == (int)VehicleFlag.HOVER_WATER_ONLY) | ||
308 | { | ||
309 | if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != (VehicleFlag)0) | ||
310 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY); | ||
311 | } | ||
312 | if ((pParam & (int)VehicleFlag.LIMIT_MOTOR_UP) == (int)VehicleFlag.LIMIT_MOTOR_UP) | ||
313 | { | ||
314 | if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != (VehicleFlag)0) | ||
315 | m_flags &= ~(VehicleFlag.LIMIT_MOTOR_UP); | ||
316 | } | ||
317 | if ((pParam & (int)VehicleFlag.LIMIT_ROLL_ONLY) == (int)VehicleFlag.LIMIT_ROLL_ONLY) | ||
318 | { | ||
319 | if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) != (VehicleFlag)0) | ||
320 | m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY); | ||
321 | } | ||
322 | if ((pParam & (int)VehicleFlag.MOUSELOOK_BANK) == (int)VehicleFlag.MOUSELOOK_BANK) | ||
323 | { | ||
324 | if ((m_flags & VehicleFlag.MOUSELOOK_BANK) != (VehicleFlag)0) | ||
325 | m_flags &= ~(VehicleFlag.MOUSELOOK_BANK); | ||
326 | } | ||
327 | if ((pParam & (int)VehicleFlag.MOUSELOOK_STEER) == (int)VehicleFlag.MOUSELOOK_STEER) | ||
328 | { | ||
329 | if ((m_flags & VehicleFlag.MOUSELOOK_STEER) != (VehicleFlag)0) | ||
330 | m_flags &= ~(VehicleFlag.MOUSELOOK_STEER); | ||
331 | } | 273 | } |
332 | if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP) | 274 | else |
333 | { | ||
334 | if ((m_flags & VehicleFlag.NO_DEFLECTION_UP) != (VehicleFlag)0) | ||
335 | m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP); | ||
336 | } | ||
337 | if ((pParam & (int)VehicleFlag.CAMERA_DECOUPLED) == (int)VehicleFlag.CAMERA_DECOUPLED) | ||
338 | { | ||
339 | if ((m_flags & VehicleFlag.CAMERA_DECOUPLED) != (VehicleFlag)0) | ||
340 | m_flags &= ~(VehicleFlag.CAMERA_DECOUPLED); | ||
341 | } | ||
342 | if ((pParam & (int)VehicleFlag.NO_X) == (int)VehicleFlag.NO_X) | ||
343 | { | ||
344 | if ((m_flags & VehicleFlag.NO_X) != (VehicleFlag)0) | ||
345 | m_flags &= ~(VehicleFlag.NO_X); | ||
346 | } | ||
347 | if ((pParam & (int)VehicleFlag.NO_Y) == (int)VehicleFlag.NO_Y) | ||
348 | { | ||
349 | if ((m_flags & VehicleFlag.NO_Y) != (VehicleFlag)0) | ||
350 | m_flags &= ~(VehicleFlag.NO_Y); | ||
351 | } | ||
352 | if ((pParam & (int)VehicleFlag.NO_Z) == (int)VehicleFlag.NO_Z) | ||
353 | { | ||
354 | if ((m_flags & VehicleFlag.NO_Z) != (VehicleFlag)0) | ||
355 | m_flags &= ~(VehicleFlag.NO_Z); | ||
356 | } | ||
357 | if ((pParam & (int)VehicleFlag.LOCK_HOVER_HEIGHT) == (int)VehicleFlag.LOCK_HOVER_HEIGHT) | ||
358 | { | ||
359 | if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != (VehicleFlag)0) | ||
360 | m_Hoverflags &= ~(VehicleFlag.LOCK_HOVER_HEIGHT); | ||
361 | } | ||
362 | if ((pParam & (int)VehicleFlag.NO_DEFLECTION) == (int)VehicleFlag.NO_DEFLECTION) | ||
363 | { | ||
364 | if ((m_flags & VehicleFlag.NO_DEFLECTION) != (VehicleFlag)0) | ||
365 | m_flags &= ~(VehicleFlag.NO_DEFLECTION); | ||
366 | } | ||
367 | if ((pParam & (int)VehicleFlag.LOCK_ROTATION) == (int)VehicleFlag.LOCK_ROTATION) | ||
368 | { | 275 | { |
369 | if ((m_flags & VehicleFlag.LOCK_ROTATION) != (VehicleFlag)0) | 276 | m_flags &= ~parm; |
370 | m_flags &= ~(VehicleFlag.LOCK_ROTATION); | ||
371 | } | 277 | } |
372 | } | 278 | } |
373 | else | 279 | else { |
374 | { | 280 | m_flags |= parm; |
375 | if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) | ||
376 | { | ||
377 | m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT | m_flags); | ||
378 | } | ||
379 | if ((pParam & (int)VehicleFlag.HOVER_TERRAIN_ONLY) == (int)VehicleFlag.HOVER_TERRAIN_ONLY) | ||
380 | { | ||
381 | m_Hoverflags |= (VehicleFlag.HOVER_TERRAIN_ONLY | m_flags); | ||
382 | } | ||
383 | if ((pParam & (int)VehicleFlag.HOVER_UP_ONLY) == (int)VehicleFlag.HOVER_UP_ONLY) | ||
384 | { | ||
385 | m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY | m_flags); | ||
386 | } | ||
387 | if ((pParam & (int)VehicleFlag.HOVER_WATER_ONLY) == (int)VehicleFlag.HOVER_WATER_ONLY) | ||
388 | { | ||
389 | m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY | m_flags); | ||
390 | } | ||
391 | if ((pParam & (int)VehicleFlag.LIMIT_MOTOR_UP) == (int)VehicleFlag.LIMIT_MOTOR_UP) | ||
392 | { | ||
393 | m_flags |= (VehicleFlag.LIMIT_MOTOR_UP | m_flags); | ||
394 | } | ||
395 | if ((pParam & (int)VehicleFlag.MOUSELOOK_BANK) == (int)VehicleFlag.MOUSELOOK_BANK) | ||
396 | { | ||
397 | m_flags |= (VehicleFlag.MOUSELOOK_BANK | m_flags); | ||
398 | } | ||
399 | if ((pParam & (int)VehicleFlag.MOUSELOOK_STEER) == (int)VehicleFlag.MOUSELOOK_STEER) | ||
400 | { | ||
401 | m_flags |= (VehicleFlag.MOUSELOOK_STEER | m_flags); | ||
402 | } | ||
403 | if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP) | ||
404 | { | ||
405 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | m_flags); | ||
406 | } | ||
407 | if ((pParam & (int)VehicleFlag.CAMERA_DECOUPLED) == (int)VehicleFlag.CAMERA_DECOUPLED) | ||
408 | { | ||
409 | m_flags |= (VehicleFlag.CAMERA_DECOUPLED | m_flags); | ||
410 | } | ||
411 | if ((pParam & (int)VehicleFlag.NO_X) == (int)VehicleFlag.NO_X) | ||
412 | { | ||
413 | m_flags |= (VehicleFlag.NO_X); | ||
414 | } | ||
415 | if ((pParam & (int)VehicleFlag.NO_Y) == (int)VehicleFlag.NO_Y) | ||
416 | { | ||
417 | m_flags |= (VehicleFlag.NO_Y); | ||
418 | } | ||
419 | if ((pParam & (int)VehicleFlag.NO_Z) == (int)VehicleFlag.NO_Z) | ||
420 | { | ||
421 | m_flags |= (VehicleFlag.NO_Z); | ||
422 | } | ||
423 | if ((pParam & (int)VehicleFlag.LOCK_HOVER_HEIGHT) == (int)VehicleFlag.LOCK_HOVER_HEIGHT) | ||
424 | { | ||
425 | m_Hoverflags |= (VehicleFlag.LOCK_HOVER_HEIGHT); | ||
426 | } | ||
427 | if ((pParam & (int)VehicleFlag.NO_DEFLECTION) == (int)VehicleFlag.NO_DEFLECTION) | ||
428 | { | ||
429 | m_flags |= (VehicleFlag.NO_DEFLECTION); | ||
430 | } | ||
431 | if ((pParam & (int)VehicleFlag.LOCK_ROTATION) == (int)VehicleFlag.LOCK_ROTATION) | ||
432 | { | ||
433 | m_flags |= (VehicleFlag.LOCK_ROTATION); | ||
434 | } | ||
435 | } | 281 | } |
436 | }//end ProcessVehicleFlags | 282 | }//end ProcessVehicleFlags |
437 | 283 | ||
438 | internal void ProcessTypeChange(Vehicle pType) | 284 | internal void ProcessTypeChange(Vehicle pType) |
439 | { | 285 | { |
440 | DetailLog("{0},ProcessTypeChange,type={1}", m_prim.LocalID, pType); | 286 | VDetailLog("{0},ProcessTypeChange,type={1}", Prim.LocalID, pType); |
441 | // Set Defaults For Type | 287 | // Set Defaults For Type |
442 | m_type = pType; | 288 | Type = pType; |
443 | switch (pType) | 289 | switch (pType) |
444 | { | 290 | { |
445 | case Vehicle.TYPE_NONE: | 291 | case Vehicle.TYPE_NONE: |
@@ -478,10 +324,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
478 | // m_bankingMix = 1; | 324 | // m_bankingMix = 1; |
479 | // m_bankingTimescale = 10; | 325 | // m_bankingTimescale = 10; |
480 | // m_referenceFrame = Quaternion.Identity; | 326 | // m_referenceFrame = Quaternion.Identity; |
481 | m_Hoverflags &= | 327 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP); |
328 | m_flags &= | ||
482 | ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | 329 | ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | |
483 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | 330 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); |
484 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP); | ||
485 | break; | 331 | break; |
486 | case Vehicle.TYPE_CAR: | 332 | case Vehicle.TYPE_CAR: |
487 | m_linearFrictionTimescale = new Vector3(100, 2, 1000); | 333 | m_linearFrictionTimescale = new Vector3(100, 2, 1000); |
@@ -506,10 +352,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
506 | // m_bankingMix = 1; | 352 | // m_bankingMix = 1; |
507 | // m_bankingTimescale = 1; | 353 | // m_bankingTimescale = 1; |
508 | // m_referenceFrame = Quaternion.Identity; | 354 | // m_referenceFrame = Quaternion.Identity; |
509 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT); | 355 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
510 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | | 356 | | VehicleFlag.LIMIT_ROLL_ONLY |
511 | VehicleFlag.LIMIT_MOTOR_UP); | 357 | | VehicleFlag.LIMIT_MOTOR_UP); |
512 | m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY); | 358 | m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT); |
359 | m_flags |= (VehicleFlag.HOVER_UP_ONLY); | ||
513 | break; | 360 | break; |
514 | case Vehicle.TYPE_BOAT: | 361 | case Vehicle.TYPE_BOAT: |
515 | m_linearFrictionTimescale = new Vector3(10, 3, 2); | 362 | m_linearFrictionTimescale = new Vector3(10, 3, 2); |
@@ -534,12 +381,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
534 | // m_bankingMix = 0.8f; | 381 | // m_bankingMix = 0.8f; |
535 | // m_bankingTimescale = 1; | 382 | // m_bankingTimescale = 1; |
536 | // m_referenceFrame = Quaternion.Identity; | 383 | // m_referenceFrame = Quaternion.Identity; |
537 | m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY | | 384 | m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
538 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | 385 | | VehicleFlag.HOVER_GLOBAL_HEIGHT |
539 | m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY); | 386 | | VehicleFlag.LIMIT_ROLL_ONLY |
540 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | | 387 | | VehicleFlag.HOVER_UP_ONLY); |
541 | VehicleFlag.LIMIT_MOTOR_UP); | 388 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
542 | m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY); | 389 | | VehicleFlag.LIMIT_MOTOR_UP |
390 | | VehicleFlag.HOVER_WATER_ONLY); | ||
543 | break; | 391 | break; |
544 | case Vehicle.TYPE_AIRPLANE: | 392 | case Vehicle.TYPE_AIRPLANE: |
545 | m_linearFrictionTimescale = new Vector3(200, 10, 5); | 393 | m_linearFrictionTimescale = new Vector3(200, 10, 5); |
@@ -564,9 +412,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
564 | // m_bankingMix = 0.7f; | 412 | // m_bankingMix = 0.7f; |
565 | // m_bankingTimescale = 2; | 413 | // m_bankingTimescale = 2; |
566 | // m_referenceFrame = Quaternion.Identity; | 414 | // m_referenceFrame = Quaternion.Identity; |
567 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | 415 | m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
568 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | 416 | | VehicleFlag.HOVER_TERRAIN_ONLY |
569 | m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP); | 417 | | VehicleFlag.HOVER_GLOBAL_HEIGHT |
418 | | VehicleFlag.HOVER_UP_ONLY | ||
419 | | VehicleFlag.NO_DEFLECTION_UP | ||
420 | | VehicleFlag.LIMIT_MOTOR_UP); | ||
570 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); | 421 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); |
571 | break; | 422 | break; |
572 | case Vehicle.TYPE_BALLOON: | 423 | case Vehicle.TYPE_BALLOON: |
@@ -592,50 +443,66 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
592 | // m_bankingMix = 0.7f; | 443 | // m_bankingMix = 0.7f; |
593 | // m_bankingTimescale = 5; | 444 | // m_bankingTimescale = 5; |
594 | // m_referenceFrame = Quaternion.Identity; | 445 | // m_referenceFrame = Quaternion.Identity; |
595 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | 446 | m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
596 | VehicleFlag.HOVER_UP_ONLY); | 447 | | VehicleFlag.HOVER_TERRAIN_ONLY |
597 | m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP); | 448 | | VehicleFlag.HOVER_UP_ONLY |
598 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); | 449 | | VehicleFlag.NO_DEFLECTION_UP |
599 | m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT); | 450 | | VehicleFlag.LIMIT_MOTOR_UP); |
451 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY | ||
452 | | VehicleFlag.HOVER_GLOBAL_HEIGHT); | ||
600 | break; | 453 | break; |
601 | } | 454 | } |
602 | }//end SetDefaultsForType | 455 | }//end SetDefaultsForType |
603 | 456 | ||
604 | internal void Step(float pTimestep) | 457 | // Some of the properties of this prim may have changed. |
458 | // Do any updating needed for a vehicle | ||
459 | public void Refresh() | ||
605 | { | 460 | { |
606 | if (m_type == Vehicle.TYPE_NONE) return; | 461 | if (!IsActive) |
462 | return; | ||
463 | |||
464 | // Set the prim's inertia to zero. The vehicle code handles that and this | ||
465 | // removes the motion and torque actions introduced by Bullet. | ||
466 | Vector3 inertia = Vector3.Zero; | ||
467 | BulletSimAPI.SetMassProps2(Prim.BSBody.ptr, Prim.MassRaw, inertia); | ||
468 | BulletSimAPI.UpdateInertiaTensor2(Prim.BSBody.ptr); | ||
469 | } | ||
607 | 470 | ||
608 | frcount++; // used to limit debug comment output | 471 | // One step of the vehicle properties for the next 'pTimestep' seconds. |
609 | if (frcount > 100) | 472 | internal void Step(float pTimestep) |
610 | frcount = 0; | 473 | { |
474 | if (!IsActive) return; | ||
611 | 475 | ||
612 | MoveLinear(pTimestep); | 476 | MoveLinear(pTimestep); |
613 | MoveAngular(pTimestep); | 477 | MoveAngular(pTimestep); |
614 | LimitRotation(pTimestep); | 478 | LimitRotation(pTimestep); |
615 | 479 | ||
616 | DetailLog("{0},BSDynamics.Step,done,pos={1},force={2},velocity={3},angvel={4}", | 480 | // remember the position so next step we can limit absolute movement effects |
617 | m_prim.LocalID, m_prim.Position, m_prim.Force, m_prim.Velocity, m_prim.RotationalVelocity); | 481 | m_lastPositionVector = Prim.ForcePosition; |
482 | |||
483 | VDetailLog("{0},BSDynamics.Step,done,pos={1},force={2},velocity={3},angvel={4}", | ||
484 | Prim.LocalID, Prim.ForcePosition, Prim.Force, Prim.ForceVelocity, Prim.RotationalVelocity); | ||
618 | }// end Step | 485 | }// end Step |
619 | 486 | ||
487 | // Apply the effect of the linear motor. | ||
488 | // Also does hover and float. | ||
620 | private void MoveLinear(float pTimestep) | 489 | private void MoveLinear(float pTimestep) |
621 | { | 490 | { |
622 | // requested m_linearMotorDirection is significant | 491 | // m_linearMotorDirection is the direction we are moving relative to the vehicle coordinates |
623 | // if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f)) | 492 | // m_lastLinearVelocityVector is the speed we are moving in that direction |
624 | if (m_linearMotorDirection.LengthSquared() > 0.0001f) | 493 | if (m_linearMotorDirection.LengthSquared() > 0.001f) |
625 | { | 494 | { |
626 | Vector3 origDir = m_linearMotorDirection; | 495 | Vector3 origDir = m_linearMotorDirection; |
627 | Vector3 origVel = m_lastLinearVelocityVector; | 496 | Vector3 origVel = m_lastLinearVelocityVector; |
628 | 497 | ||
629 | // add drive to body | 498 | // add drive to body |
630 | // Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep); | 499 | // Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale / pTimestep); |
631 | Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale); | 500 | Vector3 addAmount = (m_linearMotorDirection - m_lastLinearVelocityVector)/(m_linearMotorTimescale / pTimestep); |
632 | // lastLinearVelocityVector is the current body velocity vector? | 501 | // lastLinearVelocityVector is the current body velocity vector |
633 | // RA: Not sure what the *10 is for. A correction for pTimestep? | 502 | // RA: Not sure what the *10 is for. A correction for pTimestep? |
634 | // m_lastLinearVelocityVector += (addAmount*10); | 503 | // m_lastLinearVelocityVector += (addAmount*10); |
635 | m_lastLinearVelocityVector += addAmount; | 504 | m_lastLinearVelocityVector += addAmount; |
636 | 505 | ||
637 | // This will work temporarily, but we really need to compare speed on an axis | ||
638 | // KF: Limit body velocity to applied velocity? | ||
639 | // Limit the velocity vector to less than the last set linear motor direction | 506 | // Limit the velocity vector to less than the last set linear motor direction |
640 | if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X)) | 507 | if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X)) |
641 | m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X; | 508 | m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X; |
@@ -644,124 +511,87 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
644 | if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z)) | 511 | if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z)) |
645 | m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z; | 512 | m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z; |
646 | 513 | ||
514 | /* | ||
647 | // decay applied velocity | 515 | // decay applied velocity |
648 | Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep))); | 516 | Vector3 decayfraction = Vector3.One/(m_linearMotorDecayTimescale / pTimestep); |
517 | // (RA: do not know where the 0.5f comes from) | ||
649 | m_linearMotorDirection -= m_linearMotorDirection * decayfraction * 0.5f; | 518 | m_linearMotorDirection -= m_linearMotorDirection * decayfraction * 0.5f; |
650 | |||
651 | /* | ||
652 | Vector3 addAmount = (m_linearMotorDirection - m_lastLinearVelocityVector)/m_linearMotorTimescale; | ||
653 | m_lastLinearVelocityVector += addAmount; | ||
654 | |||
655 | float decayfraction = (1.0f - 1.0f / m_linearMotorDecayTimescale); | ||
656 | m_linearMotorDirection *= decayfraction; | ||
657 | |||
658 | */ | 519 | */ |
520 | float keepfraction = 1.0f - (1.0f / (m_linearMotorDecayTimescale / pTimestep)); | ||
521 | m_linearMotorDirection *= keepfraction; | ||
659 | 522 | ||
660 | DetailLog("{0},MoveLinear,nonZero,origdir={1},origvel={2},add={3},decay={4},dir={5},vel={6}", | 523 | VDetailLog("{0},MoveLinear,nonZero,origdir={1},origvel={2},add={3},notDecay={4},dir={5},vel={6}", |
661 | m_prim.LocalID, origDir, origVel, addAmount, decayfraction, m_linearMotorDirection, m_lastLinearVelocityVector); | 524 | Prim.LocalID, origDir, origVel, addAmount, keepfraction, m_linearMotorDirection, m_lastLinearVelocityVector); |
662 | } | 525 | } |
663 | else | 526 | else |
664 | { | 527 | { |
665 | // if what remains of applied is small, zero it. | 528 | // if what remains of direction is very small, zero it. |
666 | // if (m_lastLinearVelocityVector.ApproxEquals(Vector3.Zero, 0.01f)) | ||
667 | // m_lastLinearVelocityVector = Vector3.Zero; | ||
668 | m_linearMotorDirection = Vector3.Zero; | 529 | m_linearMotorDirection = Vector3.Zero; |
669 | m_lastLinearVelocityVector = Vector3.Zero; | 530 | m_lastLinearVelocityVector = Vector3.Zero; |
531 | VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID); | ||
670 | } | 532 | } |
671 | 533 | ||
672 | // convert requested object velocity to world-referenced vector | 534 | // convert requested object velocity to object relative vector |
673 | Quaternion rotq = m_prim.Orientation; | 535 | Quaternion rotq = Prim.ForceOrientation; |
674 | m_dir = m_lastLinearVelocityVector * rotq; | 536 | m_newVelocity = m_lastLinearVelocityVector * rotq; |
675 | 537 | ||
676 | // Add the various forces into m_dir which will be our new direction vector (velocity) | 538 | // Add the various forces into m_dir which will be our new direction vector (velocity) |
677 | 539 | ||
678 | // add Gravity and Buoyancy | 540 | // add Gravity and Buoyancy |
679 | // KF: So far I have found no good method to combine a script-requested | ||
680 | // .Z velocity and gravity. Therefore only 0g will used script-requested | ||
681 | // .Z velocity. >0g (m_VehicleBuoyancy < 1) will used modified gravity only. | ||
682 | Vector3 grav = Vector3.Zero; | ||
683 | // There is some gravity, make a gravity force vector that is applied after object velocity. | 541 | // There is some gravity, make a gravity force vector that is applied after object velocity. |
684 | // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g; | 542 | // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g; |
685 | grav.Z = m_prim.Scene.DefaultGravity.Z * m_prim.Mass * (1f - m_VehicleBuoyancy); | 543 | Vector3 grav = Prim.PhysicsScene.DefaultGravity * (Prim.Linkset.LinksetMass * (1f - m_VehicleBuoyancy)); |
544 | |||
545 | /* | ||
546 | * RA: Not sure why one would do this | ||
686 | // Preserve the current Z velocity | 547 | // Preserve the current Z velocity |
687 | Vector3 vel_now = m_prim.Velocity; | 548 | Vector3 vel_now = m_prim.Velocity; |
688 | m_dir.Z = vel_now.Z; // Preserve the accumulated falling velocity | 549 | m_dir.Z = vel_now.Z; // Preserve the accumulated falling velocity |
550 | */ | ||
689 | 551 | ||
690 | Vector3 pos = m_prim.Position; | 552 | Vector3 pos = Prim.ForcePosition; |
691 | Vector3 posChange = pos; | ||
692 | // Vector3 accel = new Vector3(-(m_dir.X - m_lastLinearVelocityVector.X / 0.1f), -(m_dir.Y - m_lastLinearVelocityVector.Y / 0.1f), m_dir.Z - m_lastLinearVelocityVector.Z / 0.1f); | 553 | // Vector3 accel = new Vector3(-(m_dir.X - m_lastLinearVelocityVector.X / 0.1f), -(m_dir.Y - m_lastLinearVelocityVector.Y / 0.1f), m_dir.Z - m_lastLinearVelocityVector.Z / 0.1f); |
693 | double Zchange = Math.Abs(posChange.Z); | ||
694 | if (m_BlockingEndPoint != Vector3.Zero) | ||
695 | { | ||
696 | bool changed = false; | ||
697 | if (pos.X >= (m_BlockingEndPoint.X - (float)1)) | ||
698 | { | ||
699 | pos.X -= posChange.X + 1; | ||
700 | changed = true; | ||
701 | } | ||
702 | if (pos.Y >= (m_BlockingEndPoint.Y - (float)1)) | ||
703 | { | ||
704 | pos.Y -= posChange.Y + 1; | ||
705 | changed = true; | ||
706 | } | ||
707 | if (pos.Z >= (m_BlockingEndPoint.Z - (float)1)) | ||
708 | { | ||
709 | pos.Z -= posChange.Z + 1; | ||
710 | changed = true; | ||
711 | } | ||
712 | if (pos.X <= 0) | ||
713 | { | ||
714 | pos.X += posChange.X + 1; | ||
715 | changed = true; | ||
716 | } | ||
717 | if (pos.Y <= 0) | ||
718 | { | ||
719 | pos.Y += posChange.Y + 1; | ||
720 | changed = true; | ||
721 | } | ||
722 | if (changed) | ||
723 | { | ||
724 | m_prim.Position = pos; | ||
725 | DetailLog("{0},MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}", | ||
726 | m_prim.LocalID, m_BlockingEndPoint, posChange, pos); | ||
727 | } | ||
728 | } | ||
729 | 554 | ||
730 | // If below the terrain, move us above the ground a little. | 555 | // If below the terrain, move us above the ground a little. |
731 | if (pos.Z < m_prim.Scene.GetTerrainHeightAtXYZ(pos)) | 556 | float terrainHeight = Prim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos); |
557 | // Taking the rotated size doesn't work here because m_prim.Size is the size of the root prim and not the linkset. | ||
558 | // Need to add a m_prim.LinkSet.Size similar to m_prim.LinkSet.Mass. | ||
559 | // Vector3 rotatedSize = m_prim.Size * m_prim.ForceOrientation; | ||
560 | // if (rotatedSize.Z < terrainHeight) | ||
561 | if (pos.Z < terrainHeight) | ||
732 | { | 562 | { |
733 | pos.Z = m_prim.Scene.GetTerrainHeightAtXYZ(pos) + 2; | 563 | pos.Z = terrainHeight + 2; |
734 | m_prim.Position = pos; | 564 | Prim.ForcePosition = pos; |
735 | DetailLog("{0},MoveLinear,terrainHeight,pos={1}", m_prim.LocalID, pos); | 565 | VDetailLog("{0},MoveLinear,terrainHeight,terrainHeight={1},pos={2}", Prim.LocalID, terrainHeight, pos); |
736 | } | 566 | } |
737 | 567 | ||
738 | // Check if hovering | 568 | // Check if hovering |
739 | if ((m_Hoverflags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0) | 569 | if ((m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0) |
740 | { | 570 | { |
741 | // We should hover, get the target height | 571 | // We should hover, get the target height |
742 | if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != 0) | 572 | if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0) |
743 | { | 573 | { |
744 | m_VhoverTargetHeight = m_prim.Scene.GetWaterLevel() + m_VhoverHeight; | 574 | m_VhoverTargetHeight = Prim.PhysicsScene.GetWaterLevelAtXYZ(pos) + m_VhoverHeight; |
745 | } | 575 | } |
746 | if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0) | 576 | if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0) |
747 | { | 577 | { |
748 | m_VhoverTargetHeight = m_prim.Scene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight; | 578 | m_VhoverTargetHeight = terrainHeight + m_VhoverHeight; |
749 | } | 579 | } |
750 | if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0) | 580 | if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0) |
751 | { | 581 | { |
752 | m_VhoverTargetHeight = m_VhoverHeight; | 582 | m_VhoverTargetHeight = m_VhoverHeight; |
753 | } | 583 | } |
754 | 584 | ||
755 | if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != 0) | 585 | if ((m_flags & VehicleFlag.HOVER_UP_ONLY) != 0) |
756 | { | 586 | { |
757 | // If body is aready heigher, use its height as target height | 587 | // If body is aready heigher, use its height as target height |
758 | if (pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z; | 588 | if (pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z; |
759 | } | 589 | } |
760 | if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0) | 590 | if ((m_flags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0) |
761 | { | 591 | { |
762 | if ((pos.Z - m_VhoverTargetHeight) > .2 || (pos.Z - m_VhoverTargetHeight) < -.2) | 592 | if ((pos.Z - m_VhoverTargetHeight) > .2 || (pos.Z - m_VhoverTargetHeight) < -.2) |
763 | { | 593 | { |
764 | m_prim.Position = pos; | 594 | Prim.ForcePosition = pos; |
765 | } | 595 | } |
766 | } | 596 | } |
767 | else | 597 | else |
@@ -770,85 +600,99 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
770 | // Replace Vertical speed with correction figure if significant | 600 | // Replace Vertical speed with correction figure if significant |
771 | if (Math.Abs(herr0) > 0.01f) | 601 | if (Math.Abs(herr0) > 0.01f) |
772 | { | 602 | { |
773 | m_dir.Z = -((herr0 * pTimestep * 50.0f) / m_VhoverTimescale); | 603 | m_newVelocity.Z = -((herr0 * pTimestep * 50.0f) / m_VhoverTimescale); |
774 | //KF: m_VhoverEfficiency is not yet implemented | 604 | //KF: m_VhoverEfficiency is not yet implemented |
775 | } | 605 | } |
776 | else | 606 | else |
777 | { | 607 | { |
778 | m_dir.Z = 0f; | 608 | m_newVelocity.Z = 0f; |
779 | } | 609 | } |
780 | } | 610 | } |
781 | 611 | ||
782 | DetailLog("{0},MoveLinear,hover,pos={1},dir={2},height={3},target={4}", m_prim.LocalID, pos, m_dir, m_VhoverHeight, m_VhoverTargetHeight); | 612 | VDetailLog("{0},MoveLinear,hover,pos={1},dir={2},height={3},target={4}", Prim.LocalID, pos, m_newVelocity, m_VhoverHeight, m_VhoverTargetHeight); |
613 | } | ||
783 | 614 | ||
784 | // m_VhoverEfficiency = 0f; // 0=boucy, 1=Crit.damped | 615 | Vector3 posChange = pos - m_lastPositionVector; |
785 | // m_VhoverTimescale = 0f; // time to acheive height | 616 | if (m_BlockingEndPoint != Vector3.Zero) |
786 | // pTimestep is time since last frame,in secs | 617 | { |
618 | bool changed = false; | ||
619 | if (pos.X >= (m_BlockingEndPoint.X - (float)1)) | ||
620 | { | ||
621 | pos.X -= posChange.X + 1; | ||
622 | changed = true; | ||
623 | } | ||
624 | if (pos.Y >= (m_BlockingEndPoint.Y - (float)1)) | ||
625 | { | ||
626 | pos.Y -= posChange.Y + 1; | ||
627 | changed = true; | ||
628 | } | ||
629 | if (pos.Z >= (m_BlockingEndPoint.Z - (float)1)) | ||
630 | { | ||
631 | pos.Z -= posChange.Z + 1; | ||
632 | changed = true; | ||
633 | } | ||
634 | if (pos.X <= 0) | ||
635 | { | ||
636 | pos.X += posChange.X + 1; | ||
637 | changed = true; | ||
638 | } | ||
639 | if (pos.Y <= 0) | ||
640 | { | ||
641 | pos.Y += posChange.Y + 1; | ||
642 | changed = true; | ||
643 | } | ||
644 | if (changed) | ||
645 | { | ||
646 | Prim.ForcePosition = pos; | ||
647 | VDetailLog("{0},MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}", | ||
648 | Prim.LocalID, m_BlockingEndPoint, posChange, pos); | ||
649 | } | ||
787 | } | 650 | } |
788 | 651 | ||
652 | // Limit absolute vertical change | ||
653 | float Zchange = Math.Abs(posChange.Z); | ||
789 | if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0) | 654 | if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0) |
790 | { | 655 | { |
791 | //Start Experimental Values | ||
792 | if (Zchange > .3) | 656 | if (Zchange > .3) |
793 | { | ||
794 | grav.Z = (float)(grav.Z * 3); | 657 | grav.Z = (float)(grav.Z * 3); |
795 | } | ||
796 | if (Zchange > .15) | 658 | if (Zchange > .15) |
797 | { | ||
798 | grav.Z = (float)(grav.Z * 2); | 659 | grav.Z = (float)(grav.Z * 2); |
799 | } | ||
800 | if (Zchange > .75) | 660 | if (Zchange > .75) |
801 | { | ||
802 | grav.Z = (float)(grav.Z * 1.5); | 661 | grav.Z = (float)(grav.Z * 1.5); |
803 | } | ||
804 | if (Zchange > .05) | 662 | if (Zchange > .05) |
805 | { | ||
806 | grav.Z = (float)(grav.Z * 1.25); | 663 | grav.Z = (float)(grav.Z * 1.25); |
807 | } | ||
808 | if (Zchange > .025) | 664 | if (Zchange > .025) |
809 | { | ||
810 | grav.Z = (float)(grav.Z * 1.125); | 665 | grav.Z = (float)(grav.Z * 1.125); |
811 | } | 666 | float postemp = (pos.Z - terrainHeight); |
812 | float terraintemp = m_prim.Scene.GetTerrainHeightAtXYZ(pos); | ||
813 | float postemp = (pos.Z - terraintemp); | ||
814 | if (postemp > 2.5f) | 667 | if (postemp > 2.5f) |
815 | { | ||
816 | grav.Z = (float)(grav.Z * 1.037125); | 668 | grav.Z = (float)(grav.Z * 1.037125); |
817 | } | 669 | VDetailLog("{0},MoveLinear,limitMotorUp,grav={1}", Prim.LocalID, grav); |
818 | DetailLog("{0},MoveLinear,limitMotorUp,grav={1}", m_prim.LocalID, grav); | ||
819 | //End Experimental Values | ||
820 | } | 670 | } |
671 | |||
672 | // If not changing some axis, reduce out velocity | ||
821 | if ((m_flags & (VehicleFlag.NO_X)) != 0) | 673 | if ((m_flags & (VehicleFlag.NO_X)) != 0) |
822 | { | 674 | m_newVelocity.X = 0; |
823 | m_dir.X = 0; | ||
824 | } | ||
825 | if ((m_flags & (VehicleFlag.NO_Y)) != 0) | 675 | if ((m_flags & (VehicleFlag.NO_Y)) != 0) |
826 | { | 676 | m_newVelocity.Y = 0; |
827 | m_dir.Y = 0; | ||
828 | } | ||
829 | if ((m_flags & (VehicleFlag.NO_Z)) != 0) | 677 | if ((m_flags & (VehicleFlag.NO_Z)) != 0) |
830 | { | 678 | m_newVelocity.Z = 0; |
831 | m_dir.Z = 0; | ||
832 | } | ||
833 | |||
834 | m_lastPositionVector = m_prim.Position; | ||
835 | 679 | ||
836 | // Apply velocity | 680 | // Apply velocity |
837 | m_prim.Velocity = m_dir; | 681 | Prim.ForceVelocity = m_newVelocity; |
838 | // apply gravity force | 682 | // apply gravity force |
839 | // Why is this set here? The physics engine already does gravity. | 683 | // Why is this set here? The physics engine already does gravity. |
840 | // m_prim.AddForce(grav, false); | 684 | Prim.AddForce(grav, false, true); |
841 | // m_prim.Force = grav; | ||
842 | 685 | ||
843 | // Apply friction | 686 | // Apply friction |
844 | Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep); | 687 | Vector3 keepFraction = Vector3.One - (Vector3.One / (m_linearFrictionTimescale / pTimestep)); |
845 | m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount; | 688 | m_lastLinearVelocityVector *= keepFraction; |
846 | 689 | ||
847 | DetailLog("{0},MoveLinear,done,pos={1},vel={2},force={3},decay={4}", | 690 | VDetailLog("{0},MoveLinear,done,lmDir={1},lmVel={2},newVel={3},grav={4},1Mdecay={5}", |
848 | m_prim.LocalID, m_lastPositionVector, m_dir, grav, decayamount); | 691 | Prim.LocalID, m_linearMotorDirection, m_lastLinearVelocityVector, m_newVelocity, grav, keepFraction); |
849 | 692 | ||
850 | } // end MoveLinear() | 693 | } // end MoveLinear() |
851 | 694 | ||
695 | // Apply the effect of the angular motor. | ||
852 | private void MoveAngular(float pTimestep) | 696 | private void MoveAngular(float pTimestep) |
853 | { | 697 | { |
854 | // m_angularMotorDirection // angular velocity requested by LSL motor | 698 | // m_angularMotorDirection // angular velocity requested by LSL motor |
@@ -860,7 +704,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
860 | // m_lastAngularVelocity // what was last applied to body | 704 | // m_lastAngularVelocity // what was last applied to body |
861 | 705 | ||
862 | // Get what the body is doing, this includes 'external' influences | 706 | // Get what the body is doing, this includes 'external' influences |
863 | Vector3 angularVelocity = m_prim.RotationalVelocity; | 707 | Vector3 angularVelocity = Prim.ForceRotationalVelocity; |
864 | 708 | ||
865 | if (m_angularMotorApply > 0) | 709 | if (m_angularMotorApply > 0) |
866 | { | 710 | { |
@@ -868,48 +712,58 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
868 | // a newly set velocity, this routine steps the value from the previous | 712 | // a newly set velocity, this routine steps the value from the previous |
869 | // value (m_angularMotorVelocity) to the requested value (m_angularMotorDirection). | 713 | // value (m_angularMotorVelocity) to the requested value (m_angularMotorDirection). |
870 | // There are m_angularMotorApply steps. | 714 | // There are m_angularMotorApply steps. |
871 | Vector3 origAngularVelocity = m_angularMotorVelocity; | 715 | Vector3 origVel = m_angularMotorVelocity; |
716 | Vector3 origDir = m_angularMotorDirection; | ||
717 | |||
872 | // ramp up to new value | 718 | // ramp up to new value |
873 | // current velocity += error / (time to get there / step interval) | 719 | // new velocity += error / ( time to get there / step interval) |
874 | // requested speed - last motor speed | 720 | // requested speed - last motor speed |
875 | m_angularMotorVelocity.X += (m_angularMotorDirection.X - m_angularMotorVelocity.X) / (m_angularMotorTimescale / pTimestep); | 721 | m_angularMotorVelocity.X += (m_angularMotorDirection.X - m_angularMotorVelocity.X) / (m_angularMotorTimescale / pTimestep); |
876 | m_angularMotorVelocity.Y += (m_angularMotorDirection.Y - m_angularMotorVelocity.Y) / (m_angularMotorTimescale / pTimestep); | 722 | m_angularMotorVelocity.Y += (m_angularMotorDirection.Y - m_angularMotorVelocity.Y) / (m_angularMotorTimescale / pTimestep); |
877 | m_angularMotorVelocity.Z += (m_angularMotorDirection.Z - m_angularMotorVelocity.Z) / (m_angularMotorTimescale / pTimestep); | 723 | m_angularMotorVelocity.Z += (m_angularMotorDirection.Z - m_angularMotorVelocity.Z) / (m_angularMotorTimescale / pTimestep); |
878 | 724 | ||
879 | DetailLog("{0},MoveAngular,angularMotorApply,apply={1},origvel={2},dir={3},vel={4}", | 725 | VDetailLog("{0},MoveAngular,angularMotorApply,apply={1},angTScale={2},timeStep={3},origvel={4},origDir={5},vel={6}", |
880 | m_prim.LocalID,m_angularMotorApply,origAngularVelocity, m_angularMotorDirection, m_angularMotorVelocity); | 726 | Prim.LocalID, m_angularMotorApply, m_angularMotorTimescale, pTimestep, origVel, origDir, m_angularMotorVelocity); |
881 | 727 | ||
882 | m_angularMotorApply--; // This is done so that if script request rate is less than phys frame rate the expected | 728 | m_angularMotorApply--; |
883 | // velocity may still be acheived. | ||
884 | } | 729 | } |
885 | else | 730 | else |
886 | { | 731 | { |
887 | // No motor recently applied, keep the body velocity | 732 | // No motor recently applied, keep the body velocity |
888 | // and decay the velocity | 733 | // and decay the velocity |
889 | m_angularMotorVelocity -= m_angularMotorVelocity / (m_angularMotorDecayTimescale / pTimestep); | 734 | m_angularMotorVelocity -= m_angularMotorVelocity / (m_angularMotorDecayTimescale / pTimestep); |
735 | if (m_angularMotorVelocity.LengthSquared() < 0.00001) | ||
736 | m_angularMotorVelocity = Vector3.Zero; | ||
890 | } // end motor section | 737 | } // end motor section |
891 | 738 | ||
892 | // Vertical attractor section | 739 | // Vertical attractor section |
893 | Vector3 vertattr = Vector3.Zero; | 740 | Vector3 vertattr = Vector3.Zero; |
894 | if (m_verticalAttractionTimescale < 300) | 741 | Vector3 deflection = Vector3.Zero; |
742 | Vector3 banking = Vector3.Zero; | ||
743 | |||
744 | if (m_verticalAttractionTimescale < 300 && m_lastAngularVelocity != Vector3.Zero) | ||
895 | { | 745 | { |
896 | float VAservo = 0.2f / (m_verticalAttractionTimescale * pTimestep); | 746 | float VAservo = 0.2f / (m_verticalAttractionTimescale / pTimestep); |
747 | VAservo *= (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency); | ||
748 | |||
897 | // get present body rotation | 749 | // get present body rotation |
898 | Quaternion rotq = m_prim.Orientation; | 750 | Quaternion rotq = Prim.ForceOrientation; |
899 | // make a vector pointing up | 751 | // vector pointing up |
900 | Vector3 verterr = Vector3.Zero; | 752 | Vector3 verterr = Vector3.Zero; |
901 | verterr.Z = 1.0f; | 753 | verterr.Z = 1.0f; |
754 | |||
902 | // rotate it to Body Angle | 755 | // rotate it to Body Angle |
903 | verterr = verterr * rotq; | 756 | verterr = verterr * rotq; |
904 | // verterr.X and .Y are the World error ammounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1. | 757 | // verterr.X and .Y are the World error amounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1. |
905 | // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go | 758 | // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go |
906 | // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body. | 759 | // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body. |
760 | |||
761 | // Error is 0 (no error) to +/- 2 (max error) | ||
907 | if (verterr.Z < 0.0f) | 762 | if (verterr.Z < 0.0f) |
908 | { | 763 | { |
909 | verterr.X = 2.0f - verterr.X; | 764 | verterr.X = 2.0f - verterr.X; |
910 | verterr.Y = 2.0f - verterr.Y; | 765 | verterr.Y = 2.0f - verterr.Y; |
911 | } | 766 | } |
912 | // Error is 0 (no error) to +/- 2 (max error) | ||
913 | // scale it by VAservo | 767 | // scale it by VAservo |
914 | verterr = verterr * VAservo; | 768 | verterr = verterr * VAservo; |
915 | 769 | ||
@@ -924,12 +778,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
924 | vertattr.X += bounce * angularVelocity.X; | 778 | vertattr.X += bounce * angularVelocity.X; |
925 | vertattr.Y += bounce * angularVelocity.Y; | 779 | vertattr.Y += bounce * angularVelocity.Y; |
926 | 780 | ||
927 | DetailLog("{0},MoveAngular,verticalAttraction,verterr={1},bounce={2},vertattr={3}", | 781 | VDetailLog("{0},MoveAngular,verticalAttraction,verterr={1},bounce={2},vertattr={3}", |
928 | m_prim.LocalID, verterr, bounce, vertattr); | 782 | Prim.LocalID, verterr, bounce, vertattr); |
929 | 783 | ||
930 | } // else vertical attractor is off | 784 | } // else vertical attractor is off |
931 | 785 | ||
932 | // m_lastVertAttractor = vertattr; | 786 | m_lastVertAttractor = vertattr; |
933 | 787 | ||
934 | // Bank section tba | 788 | // Bank section tba |
935 | 789 | ||
@@ -937,18 +791,18 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
937 | 791 | ||
938 | // Sum velocities | 792 | // Sum velocities |
939 | m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // + bank + deflection | 793 | m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // + bank + deflection |
940 | 794 | ||
941 | if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0) | 795 | if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0) |
942 | { | 796 | { |
943 | m_lastAngularVelocity.X = 0; | 797 | m_lastAngularVelocity.X = 0; |
944 | m_lastAngularVelocity.Y = 0; | 798 | m_lastAngularVelocity.Y = 0; |
945 | DetailLog("{0},MoveAngular,noDeflectionUp,lastAngular={1}", m_prim.LocalID, m_lastAngularVelocity); | 799 | VDetailLog("{0},MoveAngular,noDeflectionUp,lastAngular={1}", Prim.LocalID, m_lastAngularVelocity); |
946 | } | 800 | } |
947 | 801 | ||
948 | if (m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f)) | 802 | if (m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f)) |
949 | { | 803 | { |
950 | m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero. | 804 | m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero. |
951 | DetailLog("{0},MoveAngular,zeroSmallValues,lastAngular={1}", m_prim.LocalID, m_lastAngularVelocity); | 805 | VDetailLog("{0},MoveAngular,zeroSmallValues,lastAngular={1}", Prim.LocalID, m_lastAngularVelocity); |
952 | } | 806 | } |
953 | 807 | ||
954 | // apply friction | 808 | // apply friction |
@@ -956,14 +810,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
956 | m_lastAngularVelocity -= m_lastAngularVelocity * decayamount; | 810 | m_lastAngularVelocity -= m_lastAngularVelocity * decayamount; |
957 | 811 | ||
958 | // Apply to the body | 812 | // Apply to the body |
959 | m_prim.RotationalVelocity = m_lastAngularVelocity; | 813 | Prim.ForceRotationalVelocity = m_lastAngularVelocity; |
960 | 814 | ||
961 | DetailLog("{0},MoveAngular,done,decay={1},lastAngular={2}", m_prim.LocalID, decayamount, m_lastAngularVelocity); | 815 | VDetailLog("{0},MoveAngular,done,decay={1},lastAngular={2}", Prim.LocalID, decayamount, m_lastAngularVelocity); |
962 | } //end MoveAngular | 816 | } //end MoveAngular |
963 | 817 | ||
964 | internal void LimitRotation(float timestep) | 818 | internal void LimitRotation(float timestep) |
965 | { | 819 | { |
966 | Quaternion rotq = m_prim.Orientation; | 820 | Quaternion rotq = Prim.ForceOrientation; |
967 | Quaternion m_rot = rotq; | 821 | Quaternion m_rot = rotq; |
968 | bool changed = false; | 822 | bool changed = false; |
969 | if (m_RollreferenceFrame != Quaternion.Identity) | 823 | if (m_RollreferenceFrame != Quaternion.Identity) |
@@ -996,23 +850,19 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
996 | m_rot.Y = 0; | 850 | m_rot.Y = 0; |
997 | changed = true; | 851 | changed = true; |
998 | } | 852 | } |
999 | if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0) | 853 | if (changed) |
1000 | { | 854 | { |
1001 | m_rot.X = 0; | 855 | Prim.ForceOrientation = m_rot; |
1002 | m_rot.Y = 0; | 856 | VDetailLog("{0},LimitRotation,done,orig={1},new={2}", Prim.LocalID, rotq, m_rot); |
1003 | changed = true; | ||
1004 | } | 857 | } |
1005 | if (changed) | ||
1006 | m_prim.Orientation = m_rot; | ||
1007 | 858 | ||
1008 | DetailLog("{0},LimitRotation,done,changed={1},orig={2},new={3}", m_prim.LocalID, changed, rotq, m_rot); | ||
1009 | } | 859 | } |
1010 | 860 | ||
1011 | // Invoke the detailed logger and output something if it's enabled. | 861 | // Invoke the detailed logger and output something if it's enabled. |
1012 | private void DetailLog(string msg, params Object[] args) | 862 | private void VDetailLog(string msg, params Object[] args) |
1013 | { | 863 | { |
1014 | if (m_prim.Scene.VehicleLoggingEnabled) | 864 | if (Prim.PhysicsScene.VehicleLoggingEnabled) |
1015 | m_prim.Scene.PhysicsLogging.Write(msg, args); | 865 | Prim.PhysicsScene.DetailLog(msg, args); |
1016 | } | 866 | } |
1017 | } | 867 | } |
1018 | } | 868 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs index d68048b..7c8a215 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs | |||
@@ -1,55 +1,57 @@ | |||
1 | /* | 1 | /* |
2 | * Copyright (c) Contributors, http://opensimulator.org/ | 2 | * Copyright (c) Contributors, http://opensimulator.org/ |
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | 3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. |
4 | * | 4 | * |
5 | * Redistribution and use in source and binary forms, with or without | 5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions are met: | 6 | * modification, are permitted provided that the following conditions are met: |
7 | * * Redistributions of source code must retain the above copyright | 7 | * * Redistributions of source code must retain the above copyright |
8 | * notice, this list of conditions and the following disclaimer. | 8 | * notice, this list of conditions and the following disclaimer. |
9 | * * Redistributions in binary form must reproduce the above copyrightD | 9 | * * Redistributions in binary form must reproduce the above copyrightD |
10 | * notice, this list of conditions and the following disclaimer in the | 10 | * notice, this list of conditions and the following disclaimer in the |
11 | * documentation and/or other materials provided with the distribution. | 11 | * documentation and/or other materials provided with the distribution. |
12 | * * Neither the name of the OpenSimulator Project nor the | 12 | * * Neither the name of the OpenSimulator Project nor the |
13 | * names of its contributors may be used to endorse or promote products | 13 | * names of its contributors may be used to endorse or promote products |
14 | * derived from this software without specific prior written permission. | 14 | * derived from this software without specific prior written permission. |
15 | * | 15 | * |
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | 16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY |
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | 17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | 18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | 19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY |
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | 20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | 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 | 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 | 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 | 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. | 25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 | */ | 26 | */ |
27 | using System; | 27 | using System; |
28 | using System.Collections.Generic; | 28 | using System.Collections.Generic; |
29 | using System.Text; | 29 | using System.Text; |
30 | using OpenMetaverse; | 30 | using OpenMetaverse; |
31 | 31 | ||
32 | namespace OpenSim.Region.Physics.BulletSPlugin | 32 | namespace OpenSim.Region.Physics.BulletSPlugin |
33 | { | 33 | { |
34 | 34 | ||
35 | class BSHingeConstraint : BSConstraint | 35 | class BSHingeConstraint : BSConstraint |
36 | { | 36 | { |
37 | public BSHingeConstraint(BulletSim world, BulletBody obj1, BulletBody obj2, | 37 | public override ConstraintType Type { get { return ConstraintType.HINGE_CONSTRAINT_TYPE; } } |
38 | Vector3 pivotInA, Vector3 pivotInB, | 38 | |
39 | Vector3 axisInA, Vector3 axisInB, | 39 | public BSHingeConstraint(BulletSim world, BulletBody obj1, BulletBody obj2, |
40 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies) | 40 | Vector3 pivotInA, Vector3 pivotInB, |
41 | { | 41 | Vector3 axisInA, Vector3 axisInB, |
42 | m_world = world; | 42 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies) |
43 | m_body1 = obj1; | 43 | { |
44 | m_body2 = obj2; | 44 | m_world = world; |
45 | m_constraint = new BulletConstraint( | 45 | m_body1 = obj1; |
46 | BulletSimAPI.CreateHingeConstraint2(m_world.Ptr, m_body1.Ptr, m_body2.Ptr, | 46 | m_body2 = obj2; |
47 | pivotInA, pivotInB, | 47 | m_constraint = new BulletConstraint( |
48 | axisInA, axisInB, | 48 | BulletSimAPI.CreateHingeConstraint2(m_world.ptr, m_body1.ptr, m_body2.ptr, |
49 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); | 49 | pivotInA, pivotInB, |
50 | m_enabled = true; | 50 | axisInA, axisInB, |
51 | } | 51 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); |
52 | 52 | m_enabled = true; | |
53 | } | 53 | } |
54 | 54 | ||
55 | } | 55 | } |
56 | |||
57 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs index 087b9bb..43b1262 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs | |||
@@ -34,16 +34,26 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
34 | { | 34 | { |
35 | public class BSLinkset | 35 | public class BSLinkset |
36 | { | 36 | { |
37 | private static string LogHeader = "[BULLETSIM LINKSET]"; | 37 | // private static string LogHeader = "[BULLETSIM LINKSET]"; |
38 | 38 | ||
39 | private BSPrim m_linksetRoot; | 39 | public BSPhysObject LinksetRoot { get; protected set; } |
40 | public BSPrim LinksetRoot { get { return m_linksetRoot; } } | ||
41 | 40 | ||
42 | private BSScene m_physicsScene; | 41 | public BSScene PhysicsScene { get; private set; } |
43 | public BSScene PhysicsScene { get { return m_physicsScene; } } | ||
44 | 42 | ||
45 | // The children under the root in this linkset | 43 | static int m_nextLinksetID = 1; |
46 | private List<BSPrim> m_children; | 44 | public int LinksetID { get; private set; } |
45 | |||
46 | // The children under the root in this linkset. | ||
47 | // There are two lists of children: the current children at runtime | ||
48 | // and the children at taint-time. For instance, if you delink a | ||
49 | // child from the linkset, the child is removed from m_children | ||
50 | // but the constraint won't be removed until taint time. | ||
51 | // Two lists lets this track the 'current' children and | ||
52 | // the physical 'taint' children separately. | ||
53 | // After taint processing and before the simulation step, these | ||
54 | // two lists must be the same. | ||
55 | private HashSet<BSPhysObject> m_children; | ||
56 | private HashSet<BSPhysObject> m_taintChildren; | ||
47 | 57 | ||
48 | // We lock the diddling of linkset classes to prevent any badness. | 58 | // We lock the diddling of linkset classes to prevent any badness. |
49 | // This locks the modification of the instances of this class. Changes | 59 | // This locks the modification of the instances of this class. Changes |
@@ -52,9 +62,9 @@ public class BSLinkset | |||
52 | 62 | ||
53 | // We keep the prim's mass in the linkset structure since it could be dependent on other prims | 63 | // We keep the prim's mass in the linkset structure since it could be dependent on other prims |
54 | private float m_mass; | 64 | private float m_mass; |
55 | public float LinksetMass | 65 | public float LinksetMass |
56 | { | 66 | { |
57 | get | 67 | get |
58 | { | 68 | { |
59 | m_mass = ComputeLinksetMass(); | 69 | m_mass = ComputeLinksetMass(); |
60 | return m_mass; | 70 | return m_mass; |
@@ -71,23 +81,31 @@ public class BSLinkset | |||
71 | get { return ComputeLinksetGeometricCenter(); } | 81 | get { return ComputeLinksetGeometricCenter(); } |
72 | } | 82 | } |
73 | 83 | ||
74 | public BSLinkset(BSScene scene, BSPrim parent) | 84 | public BSLinkset(BSScene scene, BSPhysObject parent) |
75 | { | 85 | { |
76 | // A simple linkset of one (no children) | 86 | // A simple linkset of one (no children) |
77 | m_physicsScene = scene; | 87 | LinksetID = m_nextLinksetID++; |
78 | m_linksetRoot = parent; | 88 | // We create LOTS of linksets. |
79 | m_children = new List<BSPrim>(); | 89 | if (m_nextLinksetID <= 0) |
90 | m_nextLinksetID = 1; | ||
91 | PhysicsScene = scene; | ||
92 | LinksetRoot = parent; | ||
93 | m_children = new HashSet<BSPhysObject>(); | ||
94 | m_taintChildren = new HashSet<BSPhysObject>(); | ||
80 | m_mass = parent.MassRaw; | 95 | m_mass = parent.MassRaw; |
81 | } | 96 | } |
82 | 97 | ||
83 | // Link to a linkset where the child knows the parent. | 98 | // Link to a linkset where the child knows the parent. |
84 | // Parent changing should not happen so do some sanity checking. | 99 | // Parent changing should not happen so do some sanity checking. |
85 | // We return the parent's linkset so the child can track its membership. | 100 | // We return the parent's linkset so the child can track its membership. |
86 | public BSLinkset AddMeToLinkset(BSPrim child) | 101 | // Called at runtime. |
102 | public BSLinkset AddMeToLinkset(BSPhysObject child) | ||
87 | { | 103 | { |
88 | lock (m_linksetActivityLock) | 104 | lock (m_linksetActivityLock) |
89 | { | 105 | { |
90 | AddChildToLinkset(child); | 106 | // Don't add the root to its own linkset |
107 | if (!IsRoot(child)) | ||
108 | AddChildToLinkset(child); | ||
91 | } | 109 | } |
92 | return this; | 110 | return this; |
93 | } | 111 | } |
@@ -95,26 +113,18 @@ public class BSLinkset | |||
95 | // Remove a child from a linkset. | 113 | // Remove a child from a linkset. |
96 | // Returns a new linkset for the child which is a linkset of one (just the | 114 | // Returns a new linkset for the child which is a linkset of one (just the |
97 | // orphened child). | 115 | // orphened child). |
98 | public BSLinkset RemoveMeFromLinkset(BSPrim child) | 116 | // Called at runtime. |
117 | public BSLinkset RemoveMeFromLinkset(BSPhysObject child) | ||
99 | { | 118 | { |
100 | lock (m_linksetActivityLock) | 119 | lock (m_linksetActivityLock) |
101 | { | 120 | { |
102 | if (IsRoot(child)) | 121 | if (IsRoot(child)) |
103 | { | 122 | { |
104 | // if root of linkset, take the linkset apart | 123 | // Cannot remove the root from a linkset. |
105 | while (m_children.Count > 0) | 124 | return this; |
106 | { | ||
107 | // Note that we don't do a foreach because the remove routine | ||
108 | // takes it out of the list. | ||
109 | RemoveChildFromOtherLinkset(m_children[0]); | ||
110 | } | ||
111 | m_children.Clear(); // just to make sure | ||
112 | } | ||
113 | else | ||
114 | { | ||
115 | // Just removing a child from an existing linkset | ||
116 | RemoveChildFromLinkset(child); | ||
117 | } | 125 | } |
126 | |||
127 | RemoveChildFromLinkset(child); | ||
118 | } | 128 | } |
119 | 129 | ||
120 | // The child is down to a linkset of just itself | 130 | // The child is down to a linkset of just itself |
@@ -122,9 +132,9 @@ public class BSLinkset | |||
122 | } | 132 | } |
123 | 133 | ||
124 | // Return 'true' if the passed object is the root object of this linkset | 134 | // Return 'true' if the passed object is the root object of this linkset |
125 | public bool IsRoot(BSPrim requestor) | 135 | public bool IsRoot(BSPhysObject requestor) |
126 | { | 136 | { |
127 | return (requestor.LocalID == m_linksetRoot.LocalID); | 137 | return (requestor.LocalID == LinksetRoot.LocalID); |
128 | } | 138 | } |
129 | 139 | ||
130 | public int NumberOfChildren { get { return m_children.Count; } } | 140 | public int NumberOfChildren { get { return m_children.Count; } } |
@@ -133,12 +143,12 @@ public class BSLinkset | |||
133 | public bool HasAnyChildren { get { return (m_children.Count > 0); } } | 143 | public bool HasAnyChildren { get { return (m_children.Count > 0); } } |
134 | 144 | ||
135 | // Return 'true' if this child is in this linkset | 145 | // Return 'true' if this child is in this linkset |
136 | public bool HasChild(BSPrim child) | 146 | public bool HasChild(BSPhysObject child) |
137 | { | 147 | { |
138 | bool ret = false; | 148 | bool ret = false; |
139 | lock (m_linksetActivityLock) | 149 | lock (m_linksetActivityLock) |
140 | { | 150 | { |
141 | foreach (BSPrim bp in m_children) | 151 | foreach (BSPhysObject bp in m_children) |
142 | { | 152 | { |
143 | if (child.LocalID == bp.LocalID) | 153 | if (child.LocalID == bp.LocalID) |
144 | { | 154 | { |
@@ -150,117 +160,204 @@ public class BSLinkset | |||
150 | return ret; | 160 | return ret; |
151 | } | 161 | } |
152 | 162 | ||
153 | private float ComputeLinksetMass() | 163 | // When physical properties are changed the linkset needs to recalculate |
164 | // its internal properties. | ||
165 | // May be called at runtime or taint-time (just pass the appropriate flag). | ||
166 | public void Refresh(BSPhysObject requestor, bool inTaintTime) | ||
167 | { | ||
168 | // If there are no children, not physical or not root, I am not the one that recomputes the constraints | ||
169 | // (For the moment, static linksets do create constraints so remove the test for physical.) | ||
170 | if (!HasAnyChildren || /*!requestor.IsPhysical ||*/ !IsRoot(requestor)) | ||
171 | return; | ||
172 | |||
173 | BSScene.TaintCallback refreshOperation = delegate() | ||
174 | { | ||
175 | RecomputeLinksetConstraintVariables(); | ||
176 | DetailLog("{0},BSLinkset.Refresh,complete,rBody={1}", | ||
177 | LinksetRoot.LocalID, LinksetRoot.BSBody.ptr.ToString("X")); | ||
178 | }; | ||
179 | if (inTaintTime) | ||
180 | refreshOperation(); | ||
181 | else | ||
182 | PhysicsScene.TaintedObject("BSLinkSet.Refresh", refreshOperation); | ||
183 | } | ||
184 | |||
185 | // The object is going dynamic (physical). Do any setup necessary | ||
186 | // for a dynamic linkset. | ||
187 | // Only the state of the passed object can be modified. The rest of the linkset | ||
188 | // has not yet been fully constructed. | ||
189 | // Return 'true' if any properties updated on the passed object. | ||
190 | // Called at taint-time! | ||
191 | public bool MakeDynamic(BSPhysObject child) | ||
192 | { | ||
193 | // What is done for each object in BSPrim is what we want. | ||
194 | return false; | ||
195 | } | ||
196 | |||
197 | // The object is going static (non-physical). Do any setup necessary | ||
198 | // for a static linkset. | ||
199 | // Return 'true' if any properties updated on the passed object. | ||
200 | // Called at taint-time! | ||
201 | public bool MakeStatic(BSPhysObject child) | ||
202 | { | ||
203 | // What is done for each object in BSPrim is what we want. | ||
204 | return false; | ||
205 | } | ||
206 | |||
207 | // If the software is handling the movement of all the objects in a linkset | ||
208 | // (like if one doesn't use constraints for static linksets), this is called | ||
209 | // when an update for the root of the linkset is received. | ||
210 | // Called at taint-time!! | ||
211 | public void UpdateProperties(BSPhysObject physObject) | ||
154 | { | 212 | { |
155 | float mass = m_linksetRoot.MassRaw; | 213 | // The root local properties have been updated. Apply to the children if appropriate. |
156 | foreach (BSPrim bp in m_children) | 214 | if (IsRoot(physObject) && HasAnyChildren) |
157 | { | 215 | { |
158 | mass += bp.MassRaw; | 216 | if (!physObject.IsPhysical) |
217 | { | ||
218 | // TODO: implement software linkset update for static object linksets | ||
219 | } | ||
159 | } | 220 | } |
160 | return mass; | ||
161 | } | 221 | } |
162 | 222 | ||
163 | private OMV.Vector3 ComputeLinksetCenterOfMass() | 223 | // Routine used when rebuilding the body of the root of the linkset |
224 | // Destroy all the constraints have have been made to root. | ||
225 | // This is called when the root body is changing. | ||
226 | // Returns 'true' of something eas actually removed and would need restoring | ||
227 | // Called at taint-time!! | ||
228 | public bool RemoveBodyDependencies(BSPrim child) | ||
164 | { | 229 | { |
165 | OMV.Vector3 com = m_linksetRoot.Position * m_linksetRoot.MassRaw; | 230 | bool ret = false; |
166 | float totalMass = m_linksetRoot.MassRaw; | ||
167 | 231 | ||
168 | lock (m_linksetActivityLock) | 232 | lock (m_linksetActivityLock) |
169 | { | 233 | { |
170 | foreach (BSPrim bp in m_children) | 234 | if (IsRoot(child)) |
171 | { | 235 | { |
172 | com += bp.Position * bp.MassRaw; | 236 | // If the one with the dependency is root, must undo all children |
173 | totalMass += bp.MassRaw; | 237 | DetailLog("{0},BSLinkset.RemoveBodyDependencies,removeChildrenForRoot,rID={1},rBody={2}", |
238 | child.LocalID, LinksetRoot.LocalID, LinksetRoot.BSBody.ptr.ToString("X")); | ||
239 | |||
240 | ret = PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot); | ||
241 | } | ||
242 | else | ||
243 | { | ||
244 | DetailLog("{0},BSLinkset.RemoveBodyDependencies,removeSingleChild,rID={1},rBody={2},cID={3},cBody={4}", | ||
245 | child.LocalID, | ||
246 | LinksetRoot.LocalID, LinksetRoot.BSBody.ptr.ToString("X"), | ||
247 | child.LocalID, child.BSBody.ptr.ToString("X")); | ||
248 | // ret = PhysicallyUnlinkAChildFromRoot(LinksetRoot, child); | ||
249 | // Despite the function name, this removes any link to the specified object. | ||
250 | ret = PhysicallyUnlinkAllChildrenFromRoot(child); | ||
174 | } | 251 | } |
175 | if (totalMass != 0f) | ||
176 | com /= totalMass; | ||
177 | } | 252 | } |
178 | 253 | return ret; | |
179 | return com; | ||
180 | } | 254 | } |
181 | 255 | ||
182 | private OMV.Vector3 ComputeLinksetGeometricCenter() | 256 | // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true', |
257 | // this routine will restore the removed constraints. | ||
258 | // Called at taint-time!! | ||
259 | public void RestoreBodyDependencies(BSPrim child) | ||
183 | { | 260 | { |
184 | OMV.Vector3 com = m_linksetRoot.Position; | ||
185 | |||
186 | lock (m_linksetActivityLock) | 261 | lock (m_linksetActivityLock) |
187 | { | 262 | { |
188 | foreach (BSPrim bp in m_children) | 263 | if (IsRoot(child)) |
189 | { | 264 | { |
190 | com += bp.Position * bp.MassRaw; | 265 | DetailLog("{0},BSLinkset.RestoreBodyDependencies,restoreChildrenForRoot,rID={1},numChild={2}", |
266 | child.LocalID, LinksetRoot.LocalID, m_taintChildren.Count); | ||
267 | foreach (BSPhysObject bpo in m_taintChildren) | ||
268 | { | ||
269 | PhysicallyLinkAChildToRoot(LinksetRoot, bpo); | ||
270 | } | ||
271 | } | ||
272 | else | ||
273 | { | ||
274 | DetailLog("{0},BSLinkset.RestoreBodyDependencies,restoreSingleChild,rID={1},rBody={2},cID={3},cBody={4}", | ||
275 | LinksetRoot.LocalID, | ||
276 | LinksetRoot.LocalID, LinksetRoot.BSBody.ptr.ToString("X"), | ||
277 | child.LocalID, child.BSBody.ptr.ToString("X")); | ||
278 | PhysicallyLinkAChildToRoot(LinksetRoot, child); | ||
191 | } | 279 | } |
192 | com /= (m_children.Count + 1); | ||
193 | } | 280 | } |
194 | |||
195 | return com; | ||
196 | } | 281 | } |
197 | 282 | ||
198 | // When physical properties are changed the linkset needs to recalculate | 283 | // ================================================================ |
199 | // its internal properties. | 284 | // Below this point is internal magic |
200 | public void Refresh(BSPrim requestor) | 285 | |
286 | private float ComputeLinksetMass() | ||
201 | { | 287 | { |
202 | // If there are no children, there aren't any constraints to recompute | 288 | float mass; |
203 | if (!HasAnyChildren) | 289 | lock (m_linksetActivityLock) |
204 | return; | 290 | { |
291 | mass = LinksetRoot.MassRaw; | ||
292 | foreach (BSPhysObject bp in m_taintChildren) | ||
293 | { | ||
294 | mass += bp.MassRaw; | ||
295 | } | ||
296 | } | ||
297 | return mass; | ||
298 | } | ||
205 | 299 | ||
206 | // Only the root does the recomputation | 300 | private OMV.Vector3 ComputeLinksetCenterOfMass() |
207 | if (IsRoot(requestor)) | 301 | { |
302 | OMV.Vector3 com; | ||
303 | lock (m_linksetActivityLock) | ||
208 | { | 304 | { |
209 | PhysicsScene.TaintedObject("BSLinkSet.Refresh", delegate() | 305 | com = LinksetRoot.Position * LinksetRoot.MassRaw; |
306 | float totalMass = LinksetRoot.MassRaw; | ||
307 | |||
308 | foreach (BSPhysObject bp in m_taintChildren) | ||
210 | { | 309 | { |
211 | RecomputeLinksetConstraintVariables(); | 310 | com += bp.Position * bp.MassRaw; |
212 | }); | 311 | totalMass += bp.MassRaw; |
312 | } | ||
313 | if (totalMass != 0f) | ||
314 | com /= totalMass; | ||
213 | } | 315 | } |
316 | |||
317 | return com; | ||
214 | } | 318 | } |
215 | 319 | ||
216 | // Call each of the constraints that make up this linkset and recompute the | 320 | private OMV.Vector3 ComputeLinksetGeometricCenter() |
217 | // various transforms and variables. Used when objects are added or removed | ||
218 | // from a linkset to make sure the constraints know about the new mass and | ||
219 | // geometry. | ||
220 | // Must only be called at taint time!! | ||
221 | private bool RecomputeLinksetConstraintVariables() | ||
222 | { | 321 | { |
223 | float linksetMass = LinksetMass; | 322 | OMV.Vector3 com; |
224 | lock (m_linksetActivityLock) | 323 | lock (m_linksetActivityLock) |
225 | { | 324 | { |
226 | foreach (BSPrim child in m_children) | 325 | com = LinksetRoot.Position; |
326 | |||
327 | foreach (BSPhysObject bp in m_taintChildren) | ||
227 | { | 328 | { |
228 | BSConstraint constrain; | 329 | com += bp.Position * bp.MassRaw; |
229 | if (m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.Body, child.Body, out constrain)) | ||
230 | { | ||
231 | // DetailLog("{0},BSLinkset.RecomputeLinksetConstraintVariables,taint,child={1},mass={2},A={3},B={4}", | ||
232 | // LinksetRoot.LocalID, child.LocalID, linksetMass, constrain.Body1.ID, constrain.Body2.ID); | ||
233 | constrain.RecomputeConstraintVariables(linksetMass); | ||
234 | } | ||
235 | else | ||
236 | { | ||
237 | // Non-fatal error that can happen when children are being added to the linkset but | ||
238 | // their constraints have not been created yet. | ||
239 | // Caused by the fact that m_children is built at run time but building constraints | ||
240 | // happens at taint time. | ||
241 | // m_physicsScene.Logger.ErrorFormat("[BULLETSIM LINKSET] RecomputeLinksetConstraintVariables: constraint not found for root={0}, child={1}", | ||
242 | // m_linksetRoot.Body.ID, child.Body.ID); | ||
243 | } | ||
244 | } | 330 | } |
331 | com /= (m_taintChildren.Count + 1); | ||
245 | } | 332 | } |
246 | return false; | 333 | |
334 | return com; | ||
247 | } | 335 | } |
248 | 336 | ||
249 | // I am the root of a linkset and a new child is being added | 337 | // I am the root of a linkset and a new child is being added |
250 | // Called while LinkActivity is locked. | 338 | // Called while LinkActivity is locked. |
251 | private void AddChildToLinkset(BSPrim child) | 339 | private void AddChildToLinkset(BSPhysObject child) |
252 | { | 340 | { |
253 | if (!HasChild(child)) | 341 | if (!HasChild(child)) |
254 | { | 342 | { |
255 | m_children.Add(child); | 343 | m_children.Add(child); |
256 | 344 | ||
257 | BSPrim rootx = LinksetRoot; // capture the root as of now | 345 | BSPhysObject rootx = LinksetRoot; // capture the root as of now |
258 | BSPrim childx = child; | 346 | BSPhysObject childx = child; |
259 | m_physicsScene.TaintedObject("AddChildToLinkset", delegate() | 347 | |
348 | DetailLog("{0},AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID); | ||
349 | |||
350 | PhysicsScene.TaintedObject("AddChildToLinkset", delegate() | ||
260 | { | 351 | { |
261 | // DebugLog("{0}: AddChildToLinkset: adding child {1} to {2}", LogHeader, child.LocalID, m_linksetRoot.LocalID); | 352 | DetailLog("{0},AddChildToLinkset,taint,rID={1},rBody={2},cID={3},cBody={4}", |
262 | // DetailLog("{0},AddChildToLinkset,taint,child={1}", m_linksetRoot.LocalID, child.LocalID); | 353 | rootx.LocalID, |
263 | PhysicallyLinkAChildToRoot(rootx, childx); // build the physical binding between me and the child | 354 | rootx.LocalID, rootx.BSBody.ptr.ToString("X"), |
355 | childx.LocalID, childx.BSBody.ptr.ToString("X")); | ||
356 | // Since this is taint-time, the body and shape could have changed for the child | ||
357 | rootx.ForcePosition = rootx.Position; // DEBUG | ||
358 | childx.ForcePosition = childx.Position; // DEBUG | ||
359 | PhysicallyLinkAChildToRoot(rootx, childx); | ||
360 | m_taintChildren.Add(child); | ||
264 | }); | 361 | }); |
265 | } | 362 | } |
266 | return; | 363 | return; |
@@ -270,30 +367,34 @@ public class BSLinkset | |||
270 | // This is not being called by the child so we have to make sure the child doesn't think | 367 | // This is not being called by the child so we have to make sure the child doesn't think |
271 | // it's still connected to the linkset. | 368 | // it's still connected to the linkset. |
272 | // Normal OpenSimulator operation will never do this because other SceneObjectPart information | 369 | // Normal OpenSimulator operation will never do this because other SceneObjectPart information |
273 | // has to be updated also (like pointer to prim's parent). | 370 | // also has to be updated (like pointer to prim's parent). |
274 | private void RemoveChildFromOtherLinkset(BSPrim pchild) | 371 | private void RemoveChildFromOtherLinkset(BSPhysObject pchild) |
275 | { | 372 | { |
276 | pchild.Linkset = new BSLinkset(m_physicsScene, pchild); | 373 | pchild.Linkset = new BSLinkset(PhysicsScene, pchild); |
277 | RemoveChildFromLinkset(pchild); | 374 | RemoveChildFromLinkset(pchild); |
278 | } | 375 | } |
279 | 376 | ||
280 | // I am the root of a linkset and one of my children is being removed. | 377 | // I am the root of a linkset and one of my children is being removed. |
281 | // Safe to call even if the child is not really in my linkset. | 378 | // Safe to call even if the child is not really in my linkset. |
282 | private void RemoveChildFromLinkset(BSPrim child) | 379 | private void RemoveChildFromLinkset(BSPhysObject child) |
283 | { | 380 | { |
284 | if (m_children.Remove(child)) | 381 | if (m_children.Remove(child)) |
285 | { | 382 | { |
286 | BSPrim rootx = LinksetRoot; // capture the root as of now | 383 | BSPhysObject rootx = LinksetRoot; // capture the root and body as of now |
287 | BSPrim childx = child; | 384 | BSPhysObject childx = child; |
288 | m_physicsScene.TaintedObject("RemoveChildFromLinkset", delegate() | 385 | |
289 | { | 386 | DetailLog("{0},RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}", |
290 | // DebugLog("{0}: RemoveChildFromLinkset: Removing constraint to {1}", LogHeader, child.LocalID); | 387 | childx.LocalID, |
291 | // DetailLog("{0},RemoveChildFromLinkset,taint,child={1}", m_linksetRoot.LocalID, child.LocalID); | 388 | rootx.LocalID, rootx.BSBody.ptr.ToString("X"), |
389 | childx.LocalID, childx.BSBody.ptr.ToString("X")); | ||
292 | 390 | ||
391 | PhysicsScene.TaintedObject("RemoveChildFromLinkset", delegate() | ||
392 | { | ||
393 | m_taintChildren.Remove(child); | ||
293 | PhysicallyUnlinkAChildFromRoot(rootx, childx); | 394 | PhysicallyUnlinkAChildFromRoot(rootx, childx); |
395 | RecomputeLinksetConstraintVariables(); | ||
294 | }); | 396 | }); |
295 | 397 | ||
296 | RecomputeLinksetConstraintVariables(); | ||
297 | } | 398 | } |
298 | else | 399 | else |
299 | { | 400 | { |
@@ -305,7 +406,7 @@ public class BSLinkset | |||
305 | 406 | ||
306 | // Create a constraint between me (root of linkset) and the passed prim (the child). | 407 | // Create a constraint between me (root of linkset) and the passed prim (the child). |
307 | // Called at taint time! | 408 | // Called at taint time! |
308 | private void PhysicallyLinkAChildToRoot(BSPrim rootPrim, BSPrim childPrim) | 409 | private void PhysicallyLinkAChildToRoot(BSPhysObject rootPrim, BSPhysObject childPrim) |
309 | { | 410 | { |
310 | // Zero motion for children so they don't interpolate | 411 | // Zero motion for children so they don't interpolate |
311 | childPrim.ZeroMotion(); | 412 | childPrim.ZeroMotion(); |
@@ -317,21 +418,22 @@ public class BSLinkset | |||
317 | // real world coordinate of midpoint between the two objects | 418 | // real world coordinate of midpoint between the two objects |
318 | OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2); | 419 | OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2); |
319 | 420 | ||
421 | DetailLog("{0},BSLinkset.PhysicallyLinkAChildToRoot,taint,root={1},rBody={2},child={3},cBody={4},rLoc={5},cLoc={6},midLoc={7}", | ||
422 | rootPrim.LocalID, | ||
423 | rootPrim.LocalID, rootPrim.BSBody.ptr.ToString("X"), | ||
424 | childPrim.LocalID, childPrim.BSBody.ptr.ToString("X"), | ||
425 | rootPrim.Position, childPrim.Position, midPoint); | ||
426 | |||
320 | // create a constraint that allows no freedom of movement between the two objects | 427 | // create a constraint that allows no freedom of movement between the two objects |
321 | // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818 | 428 | // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818 |
322 | // DebugLog("{0}: CreateLinkset: Adding a constraint between root prim {1} and child prim {2}", LogHeader, LocalID, childPrim.LocalID); | 429 | |
323 | DetailLog("{0},PhysicallyLinkAChildToRoot,taint,root={1},child={2},rLoc={3},cLoc={4},midLoc={5}", | ||
324 | rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID, rootPrim.Position, childPrim.Position, midPoint); | ||
325 | BS6DofConstraint constrain = new BS6DofConstraint( | 430 | BS6DofConstraint constrain = new BS6DofConstraint( |
326 | m_physicsScene.World, rootPrim.Body, childPrim.Body, | 431 | PhysicsScene.World, rootPrim.BSBody, childPrim.BSBody, midPoint, true, true ); |
327 | midPoint, | 432 | |
328 | true, | 433 | /* NOTE: below is an attempt to build constraint with full frame computation, etc. |
329 | true | 434 | * Using the midpoint is easier since it lets the Bullet code manipulate the transforms |
330 | ); | ||
331 | /* NOTE: attempt to build constraint with full frame computation, etc. | ||
332 | * Using the midpoint is easier since it lets the Bullet code use the transforms | ||
333 | * of the objects. | 435 | * of the objects. |
334 | * Code left here as an example. | 436 | * Code left as a warning to future programmers. |
335 | // ================================================================================== | 437 | // ================================================================================== |
336 | // relative position normalized to the root prim | 438 | // relative position normalized to the root prim |
337 | OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation); | 439 | OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation); |
@@ -343,8 +445,7 @@ public class BSLinkset | |||
343 | 445 | ||
344 | // create a constraint that allows no freedom of movement between the two objects | 446 | // create a constraint that allows no freedom of movement between the two objects |
345 | // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818 | 447 | // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818 |
346 | // DebugLog("{0}: CreateLinkset: Adding a constraint between root prim {1} and child prim {2}", LogHeader, LocalID, childPrim.LocalID); | 448 | DetailLog("{0},BSLinkset.PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID); |
347 | DetailLog("{0},PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID); | ||
348 | BS6DofConstraint constrain = new BS6DofConstraint( | 449 | BS6DofConstraint constrain = new BS6DofConstraint( |
349 | PhysicsScene.World, rootPrim.Body, childPrim.Body, | 450 | PhysicsScene.World, rootPrim.Body, childPrim.Body, |
350 | OMV.Vector3.Zero, | 451 | OMV.Vector3.Zero, |
@@ -362,7 +463,7 @@ public class BSLinkset | |||
362 | // ================================================================================== | 463 | // ================================================================================== |
363 | */ | 464 | */ |
364 | 465 | ||
365 | m_physicsScene.Constraints.AddConstraint(constrain); | 466 | PhysicsScene.Constraints.AddConstraint(constrain); |
366 | 467 | ||
367 | // zero linear and angular limits makes the objects unable to move in relation to each other | 468 | // zero linear and angular limits makes the objects unable to move in relation to each other |
368 | constrain.SetLinearLimits(OMV.Vector3.Zero, OMV.Vector3.Zero); | 469 | constrain.SetLinearLimits(OMV.Vector3.Zero, OMV.Vector3.Zero); |
@@ -374,46 +475,100 @@ public class BSLinkset | |||
374 | PhysicsScene.Params.linkConstraintTransMotorMaxVel, | 475 | PhysicsScene.Params.linkConstraintTransMotorMaxVel, |
375 | PhysicsScene.Params.linkConstraintTransMotorMaxForce); | 476 | PhysicsScene.Params.linkConstraintTransMotorMaxForce); |
376 | constrain.SetCFMAndERP(PhysicsScene.Params.linkConstraintCFM, PhysicsScene.Params.linkConstraintERP); | 477 | constrain.SetCFMAndERP(PhysicsScene.Params.linkConstraintCFM, PhysicsScene.Params.linkConstraintERP); |
377 | 478 | if (PhysicsScene.Params.linkConstraintSolverIterations != 0f) | |
378 | RecomputeLinksetConstraintVariables(); | 479 | { |
480 | constrain.SetSolverIterations(PhysicsScene.Params.linkConstraintSolverIterations); | ||
481 | } | ||
379 | } | 482 | } |
380 | 483 | ||
381 | // Remove linkage between myself and a particular child | 484 | // Remove linkage between myself and a particular child |
485 | // The root and child bodies are passed in because we need to remove the constraint between | ||
486 | // the bodies that were at unlink time. | ||
382 | // Called at taint time! | 487 | // Called at taint time! |
383 | private void PhysicallyUnlinkAChildFromRoot(BSPrim rootPrim, BSPrim childPrim) | 488 | private bool PhysicallyUnlinkAChildFromRoot(BSPhysObject rootPrim, BSPhysObject childPrim) |
384 | { | 489 | { |
385 | // DebugLog("{0}: PhysicallyUnlinkAChildFromRoot: RemoveConstraint between root prim {1} and child prim {2}", | 490 | bool ret = false; |
386 | // LogHeader, rootPrim.LocalID, childPrim.LocalID); | 491 | DetailLog("{0},BSLinkset.PhysicallyUnlinkAChildFromRoot,taint,root={1},rBody={2},child={3},cBody={4}", |
387 | DetailLog("{0},PhysicallyUnlinkAChildFromRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID); | 492 | rootPrim.LocalID, |
493 | rootPrim.LocalID, rootPrim.BSBody.ptr.ToString("X"), | ||
494 | childPrim.LocalID, childPrim.BSBody.ptr.ToString("X")); | ||
388 | 495 | ||
389 | // Find the constraint for this link and get rid of it from the overall collection and from my list | 496 | // Find the constraint for this link and get rid of it from the overall collection and from my list |
390 | m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body, childPrim.Body); | 497 | if (PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.BSBody, childPrim.BSBody)) |
498 | { | ||
499 | // Make the child refresh its location | ||
500 | BulletSimAPI.PushUpdate2(childPrim.BSBody.ptr); | ||
501 | ret = true; | ||
502 | } | ||
391 | 503 | ||
392 | // Make the child refresh its location | 504 | return ret; |
393 | BulletSimAPI.PushUpdate2(childPrim.Body.Ptr); | ||
394 | } | 505 | } |
395 | 506 | ||
396 | // Remove linkage between myself and any possible children I might have | 507 | // Remove linkage between myself and any possible children I might have. |
397 | // Called at taint time! | 508 | // Called at taint time! |
398 | private void PhysicallyUnlinkAllChildrenFromRoot(BSPrim rootPrim) | 509 | private bool PhysicallyUnlinkAllChildrenFromRoot(BSPhysObject rootPrim) |
399 | { | 510 | { |
400 | // DebugLog("{0}: PhysicallyUnlinkAllChildren:", LogHeader); | 511 | DetailLog("{0},BSLinkset.PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID); |
401 | DetailLog("{0},PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID); | 512 | bool ret = false; |
402 | 513 | ||
403 | m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body); | 514 | if (PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.BSBody)) |
515 | { | ||
516 | ret = true; | ||
517 | } | ||
518 | return ret; | ||
404 | } | 519 | } |
405 | 520 | ||
406 | // Invoke the detailed logger and output something if it's enabled. | 521 | // Call each of the constraints that make up this linkset and recompute the |
407 | private void DebugLog(string msg, params Object[] args) | 522 | // various transforms and variables. Used when objects are added or removed |
523 | // from a linkset to make sure the constraints know about the new mass and | ||
524 | // geometry. | ||
525 | // Must only be called at taint time!! | ||
526 | private void RecomputeLinksetConstraintVariables() | ||
408 | { | 527 | { |
409 | if (m_physicsScene.ShouldDebugLog) | 528 | float linksetMass = LinksetMass; |
410 | m_physicsScene.Logger.DebugFormat(msg, args); | 529 | foreach (BSPhysObject child in m_taintChildren) |
530 | { | ||
531 | BSConstraint constrain; | ||
532 | if (PhysicsScene.Constraints.TryGetConstraint(LinksetRoot.BSBody, child.BSBody, out constrain)) | ||
533 | { | ||
534 | // DetailLog("{0},BSLinkset.RecomputeLinksetConstraintVariables,taint,child={1},mass={2},A={3},B={4}", | ||
535 | // LinksetRoot.LocalID, child.LocalID, linksetMass, constrain.Body1.ID, constrain.Body2.ID); | ||
536 | constrain.RecomputeConstraintVariables(linksetMass); | ||
537 | } | ||
538 | else | ||
539 | { | ||
540 | // Non-fatal error that happens when children are being added to the linkset but | ||
541 | // their constraints have not been created yet. | ||
542 | break; | ||
543 | } | ||
544 | } | ||
545 | |||
546 | // If the whole linkset is not here, doesn't make sense to recompute linkset wide values | ||
547 | if (m_children.Count == m_taintChildren.Count) | ||
548 | { | ||
549 | // If this is a multiple object linkset, set everybody's center of mass to the set's center of mass | ||
550 | OMV.Vector3 centerOfMass = ComputeLinksetCenterOfMass(); | ||
551 | BulletSimAPI.SetCenterOfMassByPosRot2(LinksetRoot.BSBody.ptr, | ||
552 | centerOfMass, OMV.Quaternion.Identity); | ||
553 | DetailLog("{0},BSLinkset.RecomputeLinksetConstraintVariables,setCenterOfMass,COM={1},rBody={2}", | ||
554 | LinksetRoot.LocalID, centerOfMass, LinksetRoot.BSBody.ptr.ToString("X")); | ||
555 | foreach (BSPhysObject child in m_taintChildren) | ||
556 | { | ||
557 | BulletSimAPI.SetCenterOfMassByPosRot2(child.BSBody.ptr, | ||
558 | centerOfMass, OMV.Quaternion.Identity); | ||
559 | } | ||
560 | |||
561 | // BulletSimAPI.DumpAllInfo2(PhysicsScene.World.ptr); // DEBUG DEBUG DEBUG | ||
562 | } | ||
563 | return; | ||
411 | } | 564 | } |
412 | 565 | ||
566 | |||
413 | // Invoke the detailed logger and output something if it's enabled. | 567 | // Invoke the detailed logger and output something if it's enabled. |
414 | private void DetailLog(string msg, params Object[] args) | 568 | private void DetailLog(string msg, params Object[] args) |
415 | { | 569 | { |
416 | m_physicsScene.PhysicsLogging.Write(msg, args); | 570 | if (PhysicsScene.PhysicsLogging.Enabled) |
571 | PhysicsScene.DetailLog(msg, args); | ||
417 | } | 572 | } |
418 | 573 | ||
419 | } | 574 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs new file mode 100755 index 0000000..cae599c --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs | |||
@@ -0,0 +1,218 @@ | |||
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 copyrightD | ||
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 | using System; | ||
28 | using System.Collections.Generic; | ||
29 | using System.Text; | ||
30 | |||
31 | using OMV = OpenMetaverse; | ||
32 | using OpenSim.Framework; | ||
33 | using OpenSim.Region.Physics.Manager; | ||
34 | |||
35 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
36 | { | ||
37 | // Class to wrap all objects. | ||
38 | // The rest of BulletSim doesn't need to keep checking for avatars or prims | ||
39 | // unless the difference is significant. | ||
40 | public abstract class BSPhysObject : PhysicsActor | ||
41 | { | ||
42 | protected void BaseInitialize(BSScene parentScene, uint localID, string name, string typeName) | ||
43 | { | ||
44 | PhysicsScene = parentScene; | ||
45 | LocalID = localID; | ||
46 | PhysObjectName = name; | ||
47 | TypeName = typeName; | ||
48 | |||
49 | Linkset = new BSLinkset(PhysicsScene, this); | ||
50 | |||
51 | CollisionCollection = new CollisionEventUpdate(); | ||
52 | SubscribedEventsMs = 0; | ||
53 | CollidingStep = 0; | ||
54 | CollidingGroundStep = 0; | ||
55 | } | ||
56 | |||
57 | public BSScene PhysicsScene { get; protected set; } | ||
58 | // public override uint LocalID { get; set; } // Use the LocalID definition in PhysicsActor | ||
59 | public string PhysObjectName { get; protected set; } | ||
60 | public string TypeName { get; protected set; } | ||
61 | |||
62 | public BSLinkset Linkset { get; set; } | ||
63 | |||
64 | // Return the object mass without calculating it or having side effects | ||
65 | public abstract float MassRaw { get; } | ||
66 | |||
67 | // Reference to the physical body (btCollisionObject) of this object | ||
68 | public BulletBody BSBody; | ||
69 | // Reference to the physical shape (btCollisionShape) of this object | ||
70 | public BulletShape BSShape; | ||
71 | |||
72 | // Stop all physical motion. | ||
73 | public abstract void ZeroMotion(); | ||
74 | |||
75 | // Step the vehicle simulation for this object. A NOOP if the vehicle was not configured. | ||
76 | public virtual void StepVehicle(float timeStep) { } | ||
77 | |||
78 | // Update the physical location and motion of the object. Called with data from Bullet. | ||
79 | public abstract void UpdateProperties(EntityProperties entprop); | ||
80 | |||
81 | // Tell the object to clean up. | ||
82 | public abstract void Destroy(); | ||
83 | |||
84 | public abstract OMV.Vector3 ForcePosition { get; set; } | ||
85 | |||
86 | public abstract OMV.Quaternion ForceOrientation { get; set; } | ||
87 | |||
88 | public abstract OMV.Vector3 ForceVelocity { get; set; } | ||
89 | |||
90 | public abstract OMV.Vector3 ForceRotationalVelocity { get; set; } | ||
91 | |||
92 | #region Collisions | ||
93 | |||
94 | // Requested number of milliseconds between collision events. Zero means disabled. | ||
95 | protected int SubscribedEventsMs { get; set; } | ||
96 | // Given subscription, the time that a collision may be passed up | ||
97 | protected int NextCollisionOkTime { get; set; } | ||
98 | // The simulation step that last had a collision | ||
99 | protected long CollidingStep { get; set; } | ||
100 | // The simulation step that last had a collision with the ground | ||
101 | protected long CollidingGroundStep { get; set; } | ||
102 | // The collision flags we think are set in Bullet | ||
103 | protected CollisionFlags CurrentCollisionFlags { get; set; } | ||
104 | |||
105 | // The collisions that have been collected this tick | ||
106 | protected CollisionEventUpdate CollisionCollection; | ||
107 | |||
108 | // The simulation step is telling this object about a collision. | ||
109 | // Return 'true' if a collision was processed and should be sent up. | ||
110 | // Called at taint time from within the Step() function | ||
111 | public virtual bool Collide(uint collidingWith, BSPhysObject collidee, | ||
112 | OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth) | ||
113 | { | ||
114 | bool ret = false; | ||
115 | |||
116 | // The following lines make IsColliding() and IsCollidingGround() work | ||
117 | CollidingStep = PhysicsScene.SimulationStep; | ||
118 | if (collidingWith <= PhysicsScene.TerrainManager.HighestTerrainID) | ||
119 | { | ||
120 | CollidingGroundStep = PhysicsScene.SimulationStep; | ||
121 | } | ||
122 | |||
123 | // prims in the same linkset cannot collide with each other | ||
124 | if (collidee != null && (this.Linkset.LinksetID == collidee.Linkset.LinksetID)) | ||
125 | { | ||
126 | return ret; | ||
127 | } | ||
128 | |||
129 | // if someone has subscribed for collision events.... | ||
130 | if (SubscribedEvents()) { | ||
131 | CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth)); | ||
132 | // DetailLog("{0},{1}.Collison.AddCollider,call,with={2},point={3},normal={4},depth={5}", | ||
133 | // LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth); | ||
134 | |||
135 | ret = true; | ||
136 | } | ||
137 | return ret; | ||
138 | } | ||
139 | |||
140 | // Routine to send the collected collisions into the simulator. | ||
141 | // Also handles removal of this from the collection of objects with collisions if | ||
142 | // there are no collisions from this object. Mechanism is create one last | ||
143 | // collision event to make collision_end work. | ||
144 | // Called at taint time from within the Step() function thus no locking problems | ||
145 | // with CollisionCollection and ObjectsWithNoMoreCollisions. | ||
146 | // Return 'true' if there were some actual collisions passed up | ||
147 | public virtual bool SendCollisions() | ||
148 | { | ||
149 | bool ret = true; | ||
150 | |||
151 | // throttle the collisions to the number of milliseconds specified in the subscription | ||
152 | int nowTime = PhysicsScene.SimulationNowTime; | ||
153 | if (nowTime >= NextCollisionOkTime) | ||
154 | { | ||
155 | NextCollisionOkTime = nowTime + SubscribedEventsMs; | ||
156 | |||
157 | // We are called if we previously had collisions. If there are no collisions | ||
158 | // this time, send up one last empty event so OpenSim can sense collision end. | ||
159 | if (CollisionCollection.Count == 0) | ||
160 | { | ||
161 | // If I have no collisions this time, remove me from the list of objects with collisions. | ||
162 | ret = false; | ||
163 | } | ||
164 | |||
165 | // DetailLog("{0},{1}.SendCollisionUpdate,call,numCollisions={2}", LocalID, TypeName, CollisionCollection.Count); | ||
166 | base.SendCollisionUpdate(CollisionCollection); | ||
167 | |||
168 | // The collisionCollection structure is passed around in the simulator. | ||
169 | // Make sure we don't have a handle to that one and that a new one is used for next time. | ||
170 | CollisionCollection = new CollisionEventUpdate(); | ||
171 | } | ||
172 | return ret; | ||
173 | } | ||
174 | |||
175 | // Subscribe for collision events. | ||
176 | // Parameter is the millisecond rate the caller wishes collision events to occur. | ||
177 | public override void SubscribeEvents(int ms) { | ||
178 | // DetailLog("{0},{1}.SubscribeEvents,subscribing,ms={2}", LocalID, TypeName, ms); | ||
179 | SubscribedEventsMs = ms; | ||
180 | if (ms > 0) | ||
181 | { | ||
182 | // make sure first collision happens | ||
183 | NextCollisionOkTime = Util.EnvironmentTickCountSubtract(SubscribedEventsMs); | ||
184 | |||
185 | PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate() | ||
186 | { | ||
187 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
188 | }); | ||
189 | } | ||
190 | else | ||
191 | { | ||
192 | // Subscribing for zero or less is the same as unsubscribing | ||
193 | UnSubscribeEvents(); | ||
194 | } | ||
195 | } | ||
196 | public override void UnSubscribeEvents() { | ||
197 | // DetailLog("{0},{1}.UnSubscribeEvents,unsubscribing", LocalID, TypeName); | ||
198 | SubscribedEventsMs = 0; | ||
199 | PhysicsScene.TaintedObject(TypeName+".UnSubscribeEvents", delegate() | ||
200 | { | ||
201 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
202 | }); | ||
203 | } | ||
204 | // Return 'true' if the simulator wants collision events | ||
205 | public override bool SubscribedEvents() { | ||
206 | return (SubscribedEventsMs > 0); | ||
207 | } | ||
208 | |||
209 | #endregion // Collisions | ||
210 | |||
211 | // High performance detailed logging routine used by the physical objects. | ||
212 | protected void DetailLog(string msg, params Object[] args) | ||
213 | { | ||
214 | if (PhysicsScene.PhysicsLogging.Enabled) | ||
215 | PhysicsScene.DetailLog(msg, args); | ||
216 | } | ||
217 | } | ||
218 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs index 0f027b8..20f5180 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs | |||
@@ -33,7 +33,7 @@ using OpenMetaverse; | |||
33 | namespace OpenSim.Region.Physics.BulletSPlugin | 33 | namespace OpenSim.Region.Physics.BulletSPlugin |
34 | { | 34 | { |
35 | /// <summary> | 35 | /// <summary> |
36 | /// Entry for a port of Bullet (http://bulletphysics.org/) to OpenSim. | 36 | /// Entry for a port of Bullet (http://bulletphysics.org/) to OpenSim. |
37 | /// This module interfaces to an unmanaged C++ library which makes the | 37 | /// This module interfaces to an unmanaged C++ library which makes the |
38 | /// actual calls into the Bullet physics engine. | 38 | /// actual calls into the Bullet physics engine. |
39 | /// The unmanaged library is found in opensim-libs::trunk/unmanaged/BulletSim/. | 39 | /// The unmanaged library is found in opensim-libs::trunk/unmanaged/BulletSim/. |
@@ -62,7 +62,7 @@ public class BSPlugin : IPhysicsPlugin | |||
62 | if (Util.IsWindows()) | 62 | if (Util.IsWindows()) |
63 | Util.LoadArchSpecificWindowsDll("BulletSim.dll"); | 63 | Util.LoadArchSpecificWindowsDll("BulletSim.dll"); |
64 | // If not Windows, loading is performed by the | 64 | // If not Windows, loading is performed by the |
65 | // Mono loader as specified in | 65 | // Mono loader as specified in |
66 | // "bin/Physics/OpenSim.Region.Physics.BulletSPlugin.dll.config". | 66 | // "bin/Physics/OpenSim.Region.Physics.BulletSPlugin.dll.config". |
67 | 67 | ||
68 | _mScene = new BSScene(sceneIdentifier); | 68 | _mScene = new BSScene(sceneIdentifier); |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs index 9c20004..6a4365c 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs | |||
@@ -24,6 +24,9 @@ | |||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | 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. | 25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 | */ | 26 | */ |
27 | |||
28 | // Uncomment this it enable code to do all shape an body memory management | ||
29 | // in the C# code. | ||
27 | using System; | 30 | using System; |
28 | using System.Reflection; | 31 | using System.Reflection; |
29 | using System.Collections.Generic; | 32 | using System.Collections.Generic; |
@@ -36,32 +39,20 @@ using OpenSim.Region.Physics.ConvexDecompositionDotNet; | |||
36 | 39 | ||
37 | namespace OpenSim.Region.Physics.BulletSPlugin | 40 | namespace OpenSim.Region.Physics.BulletSPlugin |
38 | { | 41 | { |
42 | |||
39 | [Serializable] | 43 | [Serializable] |
40 | public sealed class BSPrim : PhysicsActor | 44 | public sealed class BSPrim : BSPhysObject |
41 | { | 45 | { |
42 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 46 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); |
43 | private static readonly string LogHeader = "[BULLETS PRIM]"; | 47 | private static readonly string LogHeader = "[BULLETS PRIM]"; |
44 | 48 | ||
45 | private void DebugLog(string mm, params Object[] xx) { if (_scene.ShouldDebugLog) m_log.DebugFormat(mm, xx); } | ||
46 | |||
47 | private IMesh _mesh; | ||
48 | private PrimitiveBaseShape _pbs; | 49 | private PrimitiveBaseShape _pbs; |
49 | private ShapeData.PhysicsShapeType _shapeType; | ||
50 | private ulong _meshKey; | ||
51 | private ulong _hullKey; | ||
52 | private List<ConvexResult> _hulls; | ||
53 | |||
54 | private BSScene _scene; | ||
55 | public BSScene Scene { get { return _scene; } } | ||
56 | private String _avName; | ||
57 | private uint _localID = 0; | ||
58 | 50 | ||
59 | // _size is what the user passed. _scale is what we pass to the physics engine with the mesh. | 51 | // _size is what the user passed. _scale is what we pass to the physics engine with the mesh. |
60 | // Often _scale is unity because the meshmerizer will apply _size when creating the mesh. | 52 | // Often _scale is unity because the meshmerizer will apply _size when creating the mesh. |
61 | private OMV.Vector3 _size; // the multiplier for each mesh dimension as passed by the user | 53 | private OMV.Vector3 _size; // the multiplier for each mesh dimension as passed by the user |
62 | private OMV.Vector3 _scale; // the multiplier for each mesh dimension for the mesh as created by the meshmerizer | 54 | private OMV.Vector3 _scale; // the multiplier for each mesh dimension for the mesh as created by the meshmerizer |
63 | 55 | ||
64 | private bool _stopped; | ||
65 | private bool _grabbed; | 56 | private bool _grabbed; |
66 | private bool _isSelected; | 57 | private bool _isSelected; |
67 | private bool _isVolumeDetect; | 58 | private bool _isVolumeDetect; |
@@ -89,25 +80,6 @@ public sealed class BSPrim : PhysicsActor | |||
89 | private bool _kinematic; | 80 | private bool _kinematic; |
90 | private float _buoyancy; | 81 | private float _buoyancy; |
91 | 82 | ||
92 | // Membership in a linkset is controlled by this class. | ||
93 | private BSLinkset _linkset; | ||
94 | public BSLinkset Linkset | ||
95 | { | ||
96 | get { return _linkset; } | ||
97 | set { _linkset = value; } | ||
98 | } | ||
99 | |||
100 | private int _subscribedEventsMs = 0; | ||
101 | private int _nextCollisionOkTime = 0; | ||
102 | long _collidingStep; | ||
103 | long _collidingGroundStep; | ||
104 | |||
105 | private BulletBody m_body; | ||
106 | public BulletBody Body { | ||
107 | get { return m_body; } | ||
108 | set { m_body = value; } | ||
109 | } | ||
110 | |||
111 | private BSDynamics _vehicle; | 83 | private BSDynamics _vehicle; |
112 | 84 | ||
113 | private OMV.Vector3 _PIDTarget; | 85 | private OMV.Vector3 _PIDTarget; |
@@ -122,9 +94,8 @@ public sealed class BSPrim : PhysicsActor | |||
122 | OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical) | 94 | OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical) |
123 | { | 95 | { |
124 | // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID); | 96 | // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID); |
125 | _localID = localID; | 97 | base.BaseInitialize(parent_scene, localID, primName, "BSPrim"); |
126 | _avName = primName; | 98 | _physicsActorType = (int)ActorTypes.Prim; |
127 | _scene = parent_scene; | ||
128 | _position = pos; | 99 | _position = pos; |
129 | _size = size; | 100 | _size = size; |
130 | _scale = new OMV.Vector3(1f, 1f, 1f); // the scale will be set by CreateGeom depending on object type | 101 | _scale = new OMV.Vector3(1f, 1f, 1f); // the scale will be set by CreateGeom depending on object type |
@@ -132,98 +103,103 @@ public sealed class BSPrim : PhysicsActor | |||
132 | _buoyancy = 1f; | 103 | _buoyancy = 1f; |
133 | _velocity = OMV.Vector3.Zero; | 104 | _velocity = OMV.Vector3.Zero; |
134 | _rotationalVelocity = OMV.Vector3.Zero; | 105 | _rotationalVelocity = OMV.Vector3.Zero; |
135 | _hullKey = 0; | ||
136 | _meshKey = 0; | ||
137 | _pbs = pbs; | 106 | _pbs = pbs; |
138 | _isPhysical = pisPhysical; | 107 | _isPhysical = pisPhysical; |
139 | _isVolumeDetect = false; | 108 | _isVolumeDetect = false; |
140 | _subscribedEventsMs = 0; | 109 | _friction = PhysicsScene.Params.defaultFriction; // TODO: compute based on object material |
141 | _friction = _scene.Params.defaultFriction; // TODO: compute based on object material | 110 | _density = PhysicsScene.Params.defaultDensity; // TODO: compute based on object material |
142 | _density = _scene.Params.defaultDensity; // TODO: compute based on object material | 111 | _restitution = PhysicsScene.Params.defaultRestitution; |
143 | _restitution = _scene.Params.defaultRestitution; | 112 | _vehicle = new BSDynamics(PhysicsScene, this); // add vehicleness |
144 | _linkset = new BSLinkset(_scene, this); // a linkset of one | ||
145 | _vehicle = new BSDynamics(this); // add vehicleness | ||
146 | _mass = CalculateMass(); | 113 | _mass = CalculateMass(); |
147 | // do the actual object creation at taint time | 114 | |
115 | // No body or shape yet | ||
116 | BSBody = new BulletBody(LocalID, IntPtr.Zero); | ||
117 | BSShape = new BulletShape(IntPtr.Zero); | ||
118 | |||
148 | DetailLog("{0},BSPrim.constructor,call", LocalID); | 119 | DetailLog("{0},BSPrim.constructor,call", LocalID); |
149 | _scene.TaintedObject("BSPrim.create", delegate() | 120 | // do the actual object creation at taint time |
121 | PhysicsScene.TaintedObject("BSPrim.create", delegate() | ||
150 | { | 122 | { |
151 | RecreateGeomAndObject(); | 123 | CreateGeomAndObject(true); |
152 | 124 | ||
153 | // Get the pointer to the physical body for this object. | 125 | CurrentCollisionFlags = BulletSimAPI.GetCollisionFlags2(BSBody.ptr); |
154 | // At the moment, we're still letting BulletSim manage the creation and destruction | ||
155 | // of the object. Someday we'll move that into the C# code. | ||
156 | m_body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID)); | ||
157 | }); | 126 | }); |
158 | } | 127 | } |
159 | 128 | ||
160 | // called when this prim is being destroyed and we should free all the resources | 129 | // called when this prim is being destroyed and we should free all the resources |
161 | public void Destroy() | 130 | public override void Destroy() |
162 | { | 131 | { |
163 | // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID); | 132 | // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID); |
164 | 133 | ||
165 | // Undo any links between me and any other object | 134 | // Undo any links between me and any other object |
166 | BSPrim parentBefore = _linkset.LinksetRoot; | 135 | BSPhysObject parentBefore = Linkset.LinksetRoot; |
167 | int childrenBefore = _linkset.NumberOfChildren; | 136 | int childrenBefore = Linkset.NumberOfChildren; |
168 | 137 | ||
169 | _linkset = _linkset.RemoveMeFromLinkset(this); | 138 | Linkset = Linkset.RemoveMeFromLinkset(this); |
170 | 139 | ||
171 | DetailLog("{0},BSPrim.Destroy,call,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}", | 140 | DetailLog("{0},BSPrim.Destroy,call,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}", |
172 | LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren); | 141 | LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren); |
173 | 142 | ||
174 | // Undo any vehicle properties | 143 | // Undo any vehicle properties |
175 | this.VehicleType = (int)Vehicle.TYPE_NONE; | 144 | this.VehicleType = (int)Vehicle.TYPE_NONE; |
176 | 145 | ||
177 | _scene.TaintedObject("BSPrim.destroy", delegate() | 146 | PhysicsScene.TaintedObject("BSPrim.destroy", delegate() |
178 | { | 147 | { |
179 | DetailLog("{0},BSPrim.Destroy,taint,", LocalID); | 148 | DetailLog("{0},BSPrim.Destroy,taint,", LocalID); |
180 | // everything in the C# world will get garbage collected. Tell the C++ world to free stuff. | 149 | // If there are physical body and shape, release my use of same. |
181 | BulletSimAPI.DestroyObject(_scene.WorldID, LocalID); | 150 | PhysicsScene.Shapes.DereferenceBody(BSBody, true, null); |
151 | PhysicsScene.Shapes.DereferenceShape(BSShape, true, null); | ||
182 | }); | 152 | }); |
183 | } | 153 | } |
184 | 154 | ||
185 | public override bool Stopped { | 155 | // No one uses this property. |
186 | get { return _stopped; } | 156 | public override bool Stopped { |
157 | get { return false; } | ||
187 | } | 158 | } |
188 | public override OMV.Vector3 Size { | 159 | public override OMV.Vector3 Size { |
189 | get { return _size; } | 160 | get { return _size; } |
190 | set { | 161 | set { |
191 | _size = value; | 162 | _size = value; |
192 | _scene.TaintedObject("BSPrim.setSize", delegate() | 163 | PhysicsScene.TaintedObject("BSPrim.setSize", delegate() |
193 | { | 164 | { |
194 | _mass = CalculateMass(); // changing size changes the mass | 165 | _mass = CalculateMass(); // changing size changes the mass |
195 | BulletSimAPI.SetObjectScaleMass(_scene.WorldID, _localID, _scale, (IsPhysical ? _mass : 0f), IsPhysical); | 166 | // Since _size changed, the mesh needs to be rebuilt. If rebuilt, all the correct |
196 | // DetailLog("{0}: BSPrim.setSize: size={1}, mass={2}, physical={3}", LocalID, _size, _mass, IsPhysical); | 167 | // scale and margins are set. |
197 | RecreateGeomAndObject(); | 168 | CreateGeomAndObject(true); |
169 | // DetailLog("{0},BSPrim.setSize,size={1},scale={2},mass={3},physical={4}", LocalID, _size, _scale, _mass, IsPhysical); | ||
198 | }); | 170 | }); |
199 | } | 171 | } |
172 | } | ||
173 | // Scale is what we set in the physics engine. It is different than 'size' in that | ||
174 | // 'size' can be encorporated into the mesh. In that case, the scale is <1,1,1>. | ||
175 | public OMV.Vector3 Scale | ||
176 | { | ||
177 | get { return _scale; } | ||
178 | set { _scale = value; } | ||
200 | } | 179 | } |
201 | public override PrimitiveBaseShape Shape { | 180 | public override PrimitiveBaseShape Shape { |
202 | set { | 181 | set { |
203 | _pbs = value; | 182 | _pbs = value; |
204 | _scene.TaintedObject("BSPrim.setShape", delegate() | 183 | PhysicsScene.TaintedObject("BSPrim.setShape", delegate() |
205 | { | 184 | { |
206 | _mass = CalculateMass(); // changing the shape changes the mass | 185 | _mass = CalculateMass(); // changing the shape changes the mass |
207 | RecreateGeomAndObject(); | 186 | CreateGeomAndObject(true); |
208 | }); | 187 | }); |
209 | } | 188 | } |
210 | } | ||
211 | public override uint LocalID { | ||
212 | set { _localID = value; } | ||
213 | get { return _localID; } | ||
214 | } | 189 | } |
215 | public override bool Grabbed { | 190 | public override bool Grabbed { |
216 | set { _grabbed = value; | 191 | set { _grabbed = value; |
217 | } | 192 | } |
218 | } | 193 | } |
219 | public override bool Selected { | 194 | public override bool Selected { |
220 | set { | 195 | set { |
221 | _isSelected = value; | 196 | _isSelected = value; |
222 | _scene.TaintedObject("BSPrim.setSelected", delegate() | 197 | PhysicsScene.TaintedObject("BSPrim.setSelected", delegate() |
223 | { | 198 | { |
224 | SetObjectDynamic(); | 199 | DetailLog("{0},BSPrim.selected,taint,selected={1}", LocalID, _isSelected); |
200 | SetObjectDynamic(false); | ||
225 | }); | 201 | }); |
226 | } | 202 | } |
227 | } | 203 | } |
228 | public override void CrossingFailure() { return; } | 204 | public override void CrossingFailure() { return; } |
229 | 205 | ||
@@ -232,158 +208,227 @@ public sealed class BSPrim : PhysicsActor | |||
232 | BSPrim parent = obj as BSPrim; | 208 | BSPrim parent = obj as BSPrim; |
233 | if (parent != null) | 209 | if (parent != null) |
234 | { | 210 | { |
235 | DebugLog("{0}: link {1}/{2} to {3}", LogHeader, _avName, _localID, parent.LocalID); | 211 | BSPhysObject parentBefore = Linkset.LinksetRoot; |
236 | BSPrim parentBefore = _linkset.LinksetRoot; | 212 | int childrenBefore = Linkset.NumberOfChildren; |
237 | int childrenBefore = _linkset.NumberOfChildren; | ||
238 | 213 | ||
239 | _linkset = parent.Linkset.AddMeToLinkset(this); | 214 | Linkset = parent.Linkset.AddMeToLinkset(this); |
240 | 215 | ||
241 | DetailLog("{0},BSPrim.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}", | 216 | DetailLog("{0},BSPrim.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}", |
242 | LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren); | 217 | LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren); |
243 | } | 218 | } |
244 | return; | 219 | return; |
245 | } | 220 | } |
246 | 221 | ||
247 | // delink me from my linkset | 222 | // delink me from my linkset |
248 | public override void delink() { | 223 | public override void delink() { |
249 | // TODO: decide if this parent checking needs to happen at taint time | 224 | // TODO: decide if this parent checking needs to happen at taint time |
250 | // Race condition here: if link() and delink() in same simulation tick, the delink will not happen | 225 | // Race condition here: if link() and delink() in same simulation tick, the delink will not happen |
251 | DebugLog("{0}: delink {1}/{2}. Parent={3}", LogHeader, _avName, _localID, | ||
252 | _linkset.LinksetRoot._avName+"/"+_linkset.LinksetRoot.LocalID.ToString()); | ||
253 | 226 | ||
254 | BSPrim parentBefore = _linkset.LinksetRoot; | 227 | BSPhysObject parentBefore = Linkset.LinksetRoot; |
255 | int childrenBefore = _linkset.NumberOfChildren; | 228 | int childrenBefore = Linkset.NumberOfChildren; |
256 | 229 | ||
257 | _linkset = _linkset.RemoveMeFromLinkset(this); | 230 | Linkset = Linkset.RemoveMeFromLinkset(this); |
258 | 231 | ||
259 | DetailLog("{0},BSPrim.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ", | 232 | DetailLog("{0},BSPrim.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ", |
260 | LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren); | 233 | LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren); |
261 | return; | 234 | return; |
262 | } | 235 | } |
263 | 236 | ||
264 | // Set motion values to zero. | 237 | // Set motion values to zero. |
265 | // Do it to the properties so the values get set in the physics engine. | 238 | // Do it to the properties so the values get set in the physics engine. |
266 | // Push the setting of the values to the viewer. | 239 | // Push the setting of the values to the viewer. |
267 | // Called at taint time! | 240 | // Called at taint time! |
268 | public void ZeroMotion() | 241 | public override void ZeroMotion() |
269 | { | 242 | { |
270 | _velocity = OMV.Vector3.Zero; | 243 | _velocity = OMV.Vector3.Zero; |
271 | _acceleration = OMV.Vector3.Zero; | 244 | _acceleration = OMV.Vector3.Zero; |
272 | _rotationalVelocity = OMV.Vector3.Zero; | 245 | _rotationalVelocity = OMV.Vector3.Zero; |
273 | 246 | ||
274 | // Zero some other properties directly into the physics engine | 247 | // Zero some other properties directly into the physics engine |
275 | BulletSimAPI.SetVelocity2(Body.Ptr, OMV.Vector3.Zero); | 248 | BulletSimAPI.ClearForces2(BSBody.ptr); |
276 | BulletSimAPI.SetAngularVelocity2(Body.Ptr, OMV.Vector3.Zero); | ||
277 | BulletSimAPI.SetInterpolation2(Body.Ptr, OMV.Vector3.Zero, OMV.Vector3.Zero); | ||
278 | BulletSimAPI.ClearForces2(Body.Ptr); | ||
279 | } | 249 | } |
280 | 250 | ||
281 | public override void LockAngularMotion(OMV.Vector3 axis) | 251 | public override void LockAngularMotion(OMV.Vector3 axis) |
282 | { | 252 | { |
283 | // DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis); | 253 | DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis); |
284 | return; | 254 | return; |
285 | } | 255 | } |
286 | 256 | ||
287 | public override OMV.Vector3 Position { | 257 | public override OMV.Vector3 Position { |
288 | get { | 258 | get { |
289 | if (!_linkset.IsRoot(this)) | 259 | if (!Linkset.IsRoot(this)) |
290 | // child prims move around based on their parent. Need to get the latest location | 260 | // child prims move around based on their parent. Need to get the latest location |
291 | _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 261 | _position = BulletSimAPI.GetPosition2(BSBody.ptr); |
292 | 262 | ||
293 | // don't do the GetObjectPosition for root elements because this function is called a zillion times | 263 | // don't do the GetObjectPosition for root elements because this function is called a zillion times |
294 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 264 | // _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr); |
295 | return _position; | 265 | return _position; |
296 | } | 266 | } |
297 | set { | 267 | set { |
268 | // If you must push the position into the physics engine, use ForcePosition. | ||
269 | if (_position == value) | ||
270 | { | ||
271 | return; | ||
272 | } | ||
298 | _position = value; | 273 | _position = value; |
299 | // TODO: what does it mean to set the position of a child prim?? Rebuild the constraint? | 274 | // TODO: what does it mean to set the position of a child prim?? Rebuild the constraint? |
300 | _scene.TaintedObject("BSPrim.setPosition", delegate() | 275 | PositionSanityCheck(); |
276 | PhysicsScene.TaintedObject("BSPrim.setPosition", delegate() | ||
301 | { | 277 | { |
302 | // DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); | 278 | // DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); |
303 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 279 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); |
304 | }); | 280 | }); |
305 | } | 281 | } |
282 | } | ||
283 | public override OMV.Vector3 ForcePosition { | ||
284 | get { | ||
285 | _position = BulletSimAPI.GetPosition2(BSBody.ptr); | ||
286 | return _position; | ||
287 | } | ||
288 | set { | ||
289 | _position = value; | ||
290 | PositionSanityCheck(); | ||
291 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); | ||
292 | } | ||
293 | } | ||
294 | |||
295 | // Check that the current position is sane and, if not, modify the position to make it so. | ||
296 | // Check for being below terrain and being out of bounds. | ||
297 | // Returns 'true' of the position was made sane by some action. | ||
298 | private bool PositionSanityCheck() | ||
299 | { | ||
300 | bool ret = false; | ||
301 | |||
302 | // If totally below the ground, move the prim up | ||
303 | // TODO: figure out the right solution for this... only for dynamic objects? | ||
304 | /* | ||
305 | float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(_position); | ||
306 | if (Position.Z < terrainHeight) | ||
307 | { | ||
308 | DetailLog("{0},BSPrim.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, _position, terrainHeight); | ||
309 | _position.Z = terrainHeight + 2.0f; | ||
310 | ret = true; | ||
311 | } | ||
312 | */ | ||
313 | if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0) | ||
314 | { | ||
315 | float waterHeight = PhysicsScene.GetWaterLevelAtXYZ(_position); | ||
316 | if (Position.Z < waterHeight) | ||
317 | { | ||
318 | _position.Z = waterHeight; | ||
319 | ret = true; | ||
320 | } | ||
321 | } | ||
322 | |||
323 | // TODO: check for out of bounds | ||
324 | return ret; | ||
325 | } | ||
326 | |||
327 | // A version of the sanity check that also makes sure a new position value is | ||
328 | // pushed back to the physics engine. This routine would be used by anyone | ||
329 | // who is not already pushing the value. | ||
330 | private bool PositionSanityCheck2(bool inTaintTime) | ||
331 | { | ||
332 | bool ret = false; | ||
333 | if (PositionSanityCheck()) | ||
334 | { | ||
335 | // The new position value must be pushed into the physics engine but we can't | ||
336 | // just assign to "Position" because of potential call loops. | ||
337 | BSScene.TaintCallback sanityOperation = delegate() | ||
338 | { | ||
339 | DetailLog("{0},BSPrim.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation); | ||
340 | BulletSimAPI.SetObjectTranslation(PhysicsScene.WorldID, LocalID, _position, _orientation); | ||
341 | }; | ||
342 | if (inTaintTime) | ||
343 | sanityOperation(); | ||
344 | else | ||
345 | PhysicsScene.TaintedObject("BSPrim.PositionSanityCheck", sanityOperation); | ||
346 | |||
347 | ret = true; | ||
348 | } | ||
349 | return ret; | ||
306 | } | 350 | } |
307 | 351 | ||
308 | // Return the effective mass of the object. | 352 | // Return the effective mass of the object. |
309 | // If there are multiple items in the linkset, add them together for the root | 353 | // If there are multiple items in the linkset, add them together for the root |
310 | public override float Mass | 354 | public override float Mass |
311 | { | 355 | { |
312 | get | 356 | get |
313 | { | 357 | { |
314 | return _linkset.LinksetMass; | 358 | // return Linkset.LinksetMass; |
359 | return _mass; | ||
315 | } | 360 | } |
316 | } | 361 | } |
317 | 362 | ||
318 | // used when we only want this prim's mass and not the linkset thing | 363 | // used when we only want this prim's mass and not the linkset thing |
319 | public float MassRaw { get { return _mass; } } | 364 | public override float MassRaw { get { return _mass; } } |
320 | 365 | ||
321 | // Is this used? | 366 | // Is this used? |
322 | public override OMV.Vector3 CenterOfMass | 367 | public override OMV.Vector3 CenterOfMass |
323 | { | 368 | { |
324 | get { return _linkset.CenterOfMass; } | 369 | get { return Linkset.CenterOfMass; } |
325 | } | 370 | } |
326 | 371 | ||
327 | // Is this used? | 372 | // Is this used? |
328 | public override OMV.Vector3 GeometricCenter | 373 | public override OMV.Vector3 GeometricCenter |
329 | { | 374 | { |
330 | get { return _linkset.GeometricCenter; } | 375 | get { return Linkset.GeometricCenter; } |
331 | } | 376 | } |
332 | 377 | ||
333 | public override OMV.Vector3 Force { | 378 | public override OMV.Vector3 Force { |
334 | get { return _force; } | 379 | get { return _force; } |
335 | set { | 380 | set { |
336 | _force = value; | 381 | _force = value; |
337 | _scene.TaintedObject("BSPrim.setForce", delegate() | 382 | PhysicsScene.TaintedObject("BSPrim.setForce", delegate() |
338 | { | 383 | { |
339 | // DetailLog("{0},BSPrim.setForce,taint,force={1}", LocalID, _force); | 384 | // DetailLog("{0},BSPrim.setForce,taint,force={1}", LocalID, _force); |
340 | // BulletSimAPI.SetObjectForce(_scene.WorldID, _localID, _force); | 385 | BulletSimAPI.SetObjectForce2(BSBody.ptr, _force); |
341 | BulletSimAPI.SetObjectForce2(Body.Ptr, _force); | ||
342 | }); | 386 | }); |
343 | } | 387 | } |
344 | } | 388 | } |
345 | 389 | ||
346 | public override int VehicleType { | 390 | public override int VehicleType { |
347 | get { | 391 | get { |
348 | return (int)_vehicle.Type; // if we are a vehicle, return that type | 392 | return (int)_vehicle.Type; // if we are a vehicle, return that type |
349 | } | 393 | } |
350 | set { | 394 | set { |
351 | Vehicle type = (Vehicle)value; | 395 | Vehicle type = (Vehicle)value; |
352 | BSPrim vehiclePrim = this; | 396 | |
353 | _scene.TaintedObject("setVehicleType", delegate() | 397 | // Tell the scene about the vehicle so it will get processing each frame. |
398 | PhysicsScene.VehicleInSceneTypeChanged(this, type); | ||
399 | |||
400 | PhysicsScene.TaintedObject("setVehicleType", delegate() | ||
354 | { | 401 | { |
355 | // Done at taint time so we're sure the physics engine is not using the variables | 402 | // Done at taint time so we're sure the physics engine is not using the variables |
356 | // Vehicle code changes the parameters for this vehicle type. | 403 | // Vehicle code changes the parameters for this vehicle type. |
357 | _vehicle.ProcessTypeChange(type); | 404 | this._vehicle.ProcessTypeChange(type); |
358 | // Tell the scene about the vehicle so it will get processing each frame. | ||
359 | _scene.VehicleInSceneTypeChanged(this, type); | ||
360 | }); | 405 | }); |
361 | } | 406 | } |
362 | } | 407 | } |
363 | public override void VehicleFloatParam(int param, float value) | 408 | public override void VehicleFloatParam(int param, float value) |
364 | { | 409 | { |
365 | _scene.TaintedObject("BSPrim.VehicleFloatParam", delegate() | 410 | PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate() |
366 | { | 411 | { |
367 | _vehicle.ProcessFloatVehicleParam((Vehicle)param, value, _scene.LastSimulatedTimestep); | 412 | _vehicle.ProcessFloatVehicleParam((Vehicle)param, value); |
368 | }); | 413 | }); |
369 | } | 414 | } |
370 | public override void VehicleVectorParam(int param, OMV.Vector3 value) | 415 | public override void VehicleVectorParam(int param, OMV.Vector3 value) |
371 | { | 416 | { |
372 | _scene.TaintedObject("BSPrim.VehicleVectorParam", delegate() | 417 | PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate() |
373 | { | 418 | { |
374 | _vehicle.ProcessVectorVehicleParam((Vehicle)param, value, _scene.LastSimulatedTimestep); | 419 | _vehicle.ProcessVectorVehicleParam((Vehicle)param, value); |
375 | }); | 420 | }); |
376 | } | 421 | } |
377 | public override void VehicleRotationParam(int param, OMV.Quaternion rotation) | 422 | public override void VehicleRotationParam(int param, OMV.Quaternion rotation) |
378 | { | 423 | { |
379 | _scene.TaintedObject("BSPrim.VehicleRotationParam", delegate() | 424 | PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate() |
380 | { | 425 | { |
381 | _vehicle.ProcessRotationVehicleParam((Vehicle)param, rotation); | 426 | _vehicle.ProcessRotationVehicleParam((Vehicle)param, rotation); |
382 | }); | 427 | }); |
383 | } | 428 | } |
384 | public override void VehicleFlags(int param, bool remove) | 429 | public override void VehicleFlags(int param, bool remove) |
385 | { | 430 | { |
386 | _scene.TaintedObject("BSPrim.VehicleFlags", delegate() | 431 | PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate() |
387 | { | 432 | { |
388 | _vehicle.ProcessVehicleFlags(param, remove); | 433 | _vehicle.ProcessVehicleFlags(param, remove); |
389 | }); | 434 | }); |
@@ -391,83 +436,114 @@ public sealed class BSPrim : PhysicsActor | |||
391 | 436 | ||
392 | // Called each simulation step to advance vehicle characteristics. | 437 | // Called each simulation step to advance vehicle characteristics. |
393 | // Called from Scene when doing simulation step so we're in taint processing time. | 438 | // Called from Scene when doing simulation step so we're in taint processing time. |
394 | public void StepVehicle(float timeStep) | 439 | public override void StepVehicle(float timeStep) |
395 | { | 440 | { |
396 | if (IsPhysical) | 441 | if (IsPhysical) |
442 | { | ||
397 | _vehicle.Step(timeStep); | 443 | _vehicle.Step(timeStep); |
444 | } | ||
398 | } | 445 | } |
399 | 446 | ||
400 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more | 447 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more |
401 | public override void SetVolumeDetect(int param) { | 448 | public override void SetVolumeDetect(int param) { |
402 | bool newValue = (param != 0); | 449 | bool newValue = (param != 0); |
403 | _isVolumeDetect = newValue; | 450 | if (_isVolumeDetect != newValue) |
404 | _scene.TaintedObject("BSPrim.SetVolumeDetect", delegate() | ||
405 | { | 451 | { |
406 | SetObjectDynamic(); | 452 | _isVolumeDetect = newValue; |
407 | }); | 453 | PhysicsScene.TaintedObject("BSPrim.SetVolumeDetect", delegate() |
408 | return; | 454 | { |
455 | // DetailLog("{0},setVolumeDetect,taint,volDetect={1}", LocalID, _isVolumeDetect); | ||
456 | SetObjectDynamic(true); | ||
457 | }); | ||
458 | } | ||
459 | return; | ||
409 | } | 460 | } |
410 | 461 | public override OMV.Vector3 Velocity { | |
411 | public override OMV.Vector3 Velocity { | 462 | get { return _velocity; } |
412 | get { return _velocity; } | ||
413 | set { | 463 | set { |
414 | _velocity = value; | 464 | _velocity = value; |
415 | _scene.TaintedObject("BSPrim.setVelocity", delegate() | 465 | PhysicsScene.TaintedObject("BSPrim.setVelocity", delegate() |
416 | { | 466 | { |
417 | // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, _velocity); | 467 | // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, _velocity); |
418 | BulletSimAPI.SetObjectVelocity(_scene.WorldID, LocalID, _velocity); | 468 | BulletSimAPI.SetLinearVelocity2(BSBody.ptr, _velocity); |
419 | }); | 469 | }); |
420 | } | 470 | } |
421 | } | 471 | } |
422 | public override OMV.Vector3 Torque { | 472 | public override OMV.Vector3 ForceVelocity { |
423 | get { return _torque; } | 473 | get { return _velocity; } |
424 | set { _torque = value; | 474 | set { |
475 | _velocity = value; | ||
476 | BulletSimAPI.SetLinearVelocity2(BSBody.ptr, _velocity); | ||
477 | } | ||
478 | } | ||
479 | public override OMV.Vector3 Torque { | ||
480 | get { return _torque; } | ||
481 | set { _torque = value; | ||
425 | // DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, _torque); | 482 | // DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, _torque); |
426 | } | 483 | } |
427 | } | 484 | } |
428 | public override float CollisionScore { | 485 | public override float CollisionScore { |
429 | get { return _collisionScore; } | 486 | get { return _collisionScore; } |
430 | set { _collisionScore = value; | 487 | set { _collisionScore = value; |
431 | } | 488 | } |
432 | } | 489 | } |
433 | public override OMV.Vector3 Acceleration { | 490 | public override OMV.Vector3 Acceleration { |
434 | get { return _acceleration; } | 491 | get { return _acceleration; } |
435 | set { _acceleration = value; } | 492 | set { _acceleration = value; } |
436 | } | 493 | } |
437 | public override OMV.Quaternion Orientation { | 494 | public override OMV.Quaternion Orientation { |
438 | get { | 495 | get { |
439 | if (!_linkset.IsRoot(this)) | 496 | if (!Linkset.IsRoot(this)) |
440 | { | 497 | { |
441 | // Children move around because tied to parent. Get a fresh value. | 498 | // Children move around because tied to parent. Get a fresh value. |
442 | _orientation = BulletSimAPI.GetObjectOrientation(_scene.WorldID, LocalID); | 499 | _orientation = BulletSimAPI.GetOrientation2(BSBody.ptr); |
443 | } | 500 | } |
444 | return _orientation; | 501 | return _orientation; |
445 | } | 502 | } |
446 | set { | 503 | set { |
504 | if (_orientation == value) | ||
505 | return; | ||
447 | _orientation = value; | 506 | _orientation = value; |
448 | // TODO: what does it mean if a child in a linkset changes its orientation? Rebuild the constraint? | 507 | // TODO: what does it mean if a child in a linkset changes its orientation? Rebuild the constraint? |
449 | _scene.TaintedObject("BSPrim.setOrientation", delegate() | 508 | PhysicsScene.TaintedObject("BSPrim.setOrientation", delegate() |
450 | { | 509 | { |
451 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 510 | // _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr); |
452 | // DetailLog("{0},BSPrim.setOrientation,taint,pos={1},orient={2}", LocalID, _position, _orientation); | 511 | // DetailLog("{0},BSPrim.setOrientation,taint,pos={1},orient={2}", LocalID, _position, _orientation); |
453 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 512 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); |
454 | }); | 513 | }); |
455 | } | 514 | } |
515 | } | ||
516 | // Go directly to Bullet to get/set the value. | ||
517 | public override OMV.Quaternion ForceOrientation | ||
518 | { | ||
519 | get | ||
520 | { | ||
521 | _orientation = BulletSimAPI.GetOrientation2(BSBody.ptr); | ||
522 | return _orientation; | ||
523 | } | ||
524 | set | ||
525 | { | ||
526 | _orientation = value; | ||
527 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); | ||
528 | } | ||
456 | } | 529 | } |
457 | public override int PhysicsActorType { | 530 | public override int PhysicsActorType { |
458 | get { return _physicsActorType; } | 531 | get { return _physicsActorType; } |
459 | set { _physicsActorType = value; | 532 | set { _physicsActorType = value; } |
460 | } | ||
461 | } | 533 | } |
462 | public override bool IsPhysical { | 534 | public override bool IsPhysical { |
463 | get { return _isPhysical; } | 535 | get { return _isPhysical; } |
464 | set { | 536 | set { |
465 | _isPhysical = value; | 537 | if (_isPhysical != value) |
466 | _scene.TaintedObject("BSPrim.setIsPhysical", delegate() | ||
467 | { | 538 | { |
468 | SetObjectDynamic(); | 539 | _isPhysical = value; |
469 | }); | 540 | PhysicsScene.TaintedObject("BSPrim.setIsPhysical", delegate() |
470 | } | 541 | { |
542 | // DetailLog("{0},setIsPhysical,taint,isPhys={1}", LocalID, _isPhysical); | ||
543 | SetObjectDynamic(true); | ||
544 | }); | ||
545 | } | ||
546 | } | ||
471 | } | 547 | } |
472 | 548 | ||
473 | // An object is static (does not move) if selected or not physical | 549 | // An object is static (does not move) if selected or not physical |
@@ -477,57 +553,201 @@ public sealed class BSPrim : PhysicsActor | |||
477 | } | 553 | } |
478 | 554 | ||
479 | // An object is solid if it's not phantom and if it's not doing VolumeDetect | 555 | // An object is solid if it's not phantom and if it's not doing VolumeDetect |
480 | private bool IsSolid | 556 | public bool IsSolid |
481 | { | 557 | { |
482 | get { return !IsPhantom && !_isVolumeDetect; } | 558 | get { return !IsPhantom && !_isVolumeDetect; } |
483 | } | 559 | } |
484 | 560 | ||
485 | // Make gravity work if the object is physical and not selected | 561 | // Make gravity work if the object is physical and not selected |
486 | // No locking here because only called when it is safe | 562 | // Called at taint-time!! |
487 | private void SetObjectDynamic() | 563 | private void SetObjectDynamic(bool forceRebuild) |
564 | { | ||
565 | // Recreate the physical object if necessary | ||
566 | CreateGeomAndObject(forceRebuild); | ||
567 | } | ||
568 | |||
569 | // Convert the simulator's physical properties into settings on BulletSim objects. | ||
570 | // There are four flags we're interested in: | ||
571 | // IsStatic: Object does not move, otherwise the object has mass and moves | ||
572 | // isSolid: other objects bounce off of this object | ||
573 | // isVolumeDetect: other objects pass through but can generate collisions | ||
574 | // collisionEvents: whether this object returns collision events | ||
575 | private void UpdatePhysicalParameters() | ||
576 | { | ||
577 | // DetailLog("{0},BSPrim.UpdatePhysicalParameters,entry,body={1},shape={2}", LocalID, BSBody, BSShape); | ||
578 | |||
579 | // Mangling all the physical properties requires the object not be in the physical world. | ||
580 | // This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found). | ||
581 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, BSBody.ptr); | ||
582 | |||
583 | // Set up the object physicalness (does gravity and collisions move this object) | ||
584 | MakeDynamic(IsStatic); | ||
585 | |||
586 | // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters) | ||
587 | _vehicle.Refresh(); | ||
588 | |||
589 | // Arrange for collision events if the simulator wants them | ||
590 | EnableCollisions(SubscribedEvents()); | ||
591 | |||
592 | // Make solid or not (do things bounce off or pass through this object). | ||
593 | MakeSolid(IsSolid); | ||
594 | |||
595 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, BSBody.ptr); | ||
596 | |||
597 | // Rebuild its shape | ||
598 | BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, BSBody.ptr); | ||
599 | |||
600 | // Collision filter can be set only when the object is in the world | ||
601 | if (BSBody.collisionFilter != 0 || BSBody.collisionMask != 0) | ||
602 | { | ||
603 | BulletSimAPI.SetCollisionFilterMask2(BSBody.ptr, (uint)BSBody.collisionFilter, (uint)BSBody.collisionMask); | ||
604 | } | ||
605 | |||
606 | // Recompute any linkset parameters. | ||
607 | // When going from non-physical to physical, this re-enables the constraints that | ||
608 | // had been automatically disabled when the mass was set to zero. | ||
609 | Linkset.Refresh(this, true); | ||
610 | |||
611 | DetailLog("{0},BSPrim.UpdatePhysicalParameters,exit,static={1},solid={2},mass={3},collide={4},cf={5:X},body={6},shape={7}", | ||
612 | LocalID, IsStatic, IsSolid, _mass, SubscribedEvents(), CurrentCollisionFlags, BSBody, BSShape); | ||
613 | } | ||
614 | |||
615 | // "Making dynamic" means changing to and from static. | ||
616 | // When static, gravity does not effect the object and it is fixed in space. | ||
617 | // When dynamic, the object can fall and be pushed by others. | ||
618 | // This is independent of its 'solidness' which controls what passes through | ||
619 | // this object and what interacts with it. | ||
620 | private void MakeDynamic(bool makeStatic) | ||
488 | { | 621 | { |
489 | // RA: remove this for the moment. | 622 | if (makeStatic) |
490 | // The problem is that dynamic objects are hulls so if we are becoming physical | 623 | { |
491 | // the shape has to be checked and possibly built. | 624 | // Become a Bullet 'static' object type |
492 | // Maybe a VerifyCorrectPhysicalShape() routine? | 625 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.CF_STATIC_OBJECT); |
493 | // RecreateGeomAndObject(); | 626 | // Stop all movement |
627 | BulletSimAPI.ClearAllForces2(BSBody.ptr); | ||
628 | // Center of mass is at the center of the object | ||
629 | BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.BSBody.ptr, _position, _orientation); | ||
630 | // Mass is zero which disables a bunch of physics stuff in Bullet | ||
631 | BulletSimAPI.SetMassProps2(BSBody.ptr, 0f, OMV.Vector3.Zero); | ||
632 | // There is no inertia in a static object | ||
633 | BulletSimAPI.UpdateInertiaTensor2(BSBody.ptr); | ||
634 | // There can be special things needed for implementing linksets | ||
635 | Linkset.MakeStatic(this); | ||
636 | // The activation state is 'disabled' so Bullet will not try to act on it. | ||
637 | BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.DISABLE_SIMULATION); | ||
638 | // Start it out sleeping and physical actions could wake it up. | ||
639 | // BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ISLAND_SLEEPING); | ||
640 | |||
641 | BSBody.collisionFilter = CollisionFilterGroups.StaticObjectFilter; | ||
642 | BSBody.collisionMask = CollisionFilterGroups.StaticObjectMask; | ||
643 | } | ||
644 | else | ||
645 | { | ||
646 | // Not a Bullet static object | ||
647 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.CF_STATIC_OBJECT); | ||
648 | |||
649 | // Set various physical properties so internal dynamic properties will get computed correctly as they are set | ||
650 | BulletSimAPI.SetFriction2(BSBody.ptr, PhysicsScene.Params.defaultFriction); | ||
651 | BulletSimAPI.SetRestitution2(BSBody.ptr, PhysicsScene.Params.defaultRestitution); | ||
652 | |||
653 | // per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382 | ||
654 | BulletSimAPI.ClearAllForces2(BSBody.ptr); | ||
655 | |||
656 | // For good measure, make sure the transform is set through to the motion state | ||
657 | BulletSimAPI.SetTranslation2(BSBody.ptr, _position, _orientation); | ||
658 | |||
659 | // A dynamic object has mass | ||
660 | IntPtr collisionShapePtr = BulletSimAPI.GetCollisionShape2(BSBody.ptr); | ||
661 | OMV.Vector3 inertia = BulletSimAPI.CalculateLocalInertia2(collisionShapePtr, Mass); | ||
662 | BulletSimAPI.SetMassProps2(BSBody.ptr, _mass, inertia); | ||
663 | BulletSimAPI.UpdateInertiaTensor2(BSBody.ptr); | ||
494 | 664 | ||
495 | // Bullet wants static objects to have a mass of zero | 665 | // Various values for simulation limits |
496 | float mass = IsStatic ? 0f : _mass; | 666 | BulletSimAPI.SetDamping2(BSBody.ptr, PhysicsScene.Params.linearDamping, PhysicsScene.Params.angularDamping); |
667 | BulletSimAPI.SetDeactivationTime2(BSBody.ptr, PhysicsScene.Params.deactivationTime); | ||
668 | BulletSimAPI.SetSleepingThresholds2(BSBody.ptr, PhysicsScene.Params.linearSleepingThreshold, PhysicsScene.Params.angularSleepingThreshold); | ||
669 | BulletSimAPI.SetContactProcessingThreshold2(BSBody.ptr, PhysicsScene.Params.contactProcessingThreshold); | ||
497 | 670 | ||
498 | BulletSimAPI.SetObjectProperties(_scene.WorldID, LocalID, IsStatic, IsSolid, SubscribedEvents(), mass); | 671 | // There might be special things needed for implementing linksets. |
672 | Linkset.MakeDynamic(this); | ||
673 | |||
674 | // Force activation of the object so Bullet will act on it. | ||
675 | // Must do the ForceActivationState2() to overcome the DISABLE_SIMULATION from static objects. | ||
676 | BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ACTIVE_TAG); | ||
677 | // BulletSimAPI.Activate2(BSBody.ptr, true); | ||
678 | |||
679 | BSBody.collisionFilter = CollisionFilterGroups.ObjectFilter; | ||
680 | BSBody.collisionMask = CollisionFilterGroups.ObjectMask; | ||
681 | } | ||
682 | } | ||
499 | 683 | ||
500 | // recompute any linkset parameters | 684 | // "Making solid" means that other object will not pass through this object. |
501 | _linkset.Refresh(this); | 685 | // To make transparent, we create a Bullet ghost object. |
686 | // Note: This expects to be called from the UpdatePhysicalParameters() routine as | ||
687 | // the functions after this one set up the state of a possibly newly created collision body. | ||
688 | private void MakeSolid(bool makeSolid) | ||
689 | { | ||
690 | CollisionObjectTypes bodyType = (CollisionObjectTypes)BulletSimAPI.GetBodyType2(BSBody.ptr); | ||
691 | if (makeSolid) | ||
692 | { | ||
693 | // Verify the previous code created the correct shape for this type of thing. | ||
694 | if ((bodyType & CollisionObjectTypes.CO_RIGID_BODY) == 0) | ||
695 | { | ||
696 | m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType); | ||
697 | } | ||
698 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE); | ||
699 | } | ||
700 | else | ||
701 | { | ||
702 | if ((bodyType & CollisionObjectTypes.CO_GHOST_OBJECT) == 0) | ||
703 | { | ||
704 | m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType); | ||
705 | } | ||
706 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE); | ||
707 | BSBody.collisionFilter = CollisionFilterGroups.VolumeDetectFilter; | ||
708 | BSBody.collisionMask = CollisionFilterGroups.VolumeDetectMask; | ||
709 | } | ||
710 | } | ||
502 | 711 | ||
503 | CollisionFlags cf = BulletSimAPI.GetCollisionFlags2(Body.Ptr); | 712 | // Turn on or off the flag controlling whether collision events are returned to the simulator. |
504 | // DetailLog("{0},BSPrim.SetObjectDynamic,taint,static={1},solid={2},mass={3}, cf={4}", LocalID, IsStatic, IsSolid, mass, cf); | 713 | private void EnableCollisions(bool wantsCollisionEvents) |
714 | { | ||
715 | if (wantsCollisionEvents) | ||
716 | { | ||
717 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
718 | } | ||
719 | else | ||
720 | { | ||
721 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
722 | } | ||
505 | } | 723 | } |
506 | 724 | ||
507 | // prims don't fly | 725 | // prims don't fly |
508 | public override bool Flying { | 726 | public override bool Flying { |
509 | get { return _flying; } | 727 | get { return _flying; } |
510 | set { _flying = value; } | 728 | set { |
729 | _flying = value; | ||
730 | } | ||
511 | } | 731 | } |
512 | public override bool SetAlwaysRun { | 732 | public override bool SetAlwaysRun { |
513 | get { return _setAlwaysRun; } | 733 | get { return _setAlwaysRun; } |
514 | set { _setAlwaysRun = value; } | 734 | set { _setAlwaysRun = value; } |
515 | } | 735 | } |
516 | public override bool ThrottleUpdates { | 736 | public override bool ThrottleUpdates { |
517 | get { return _throttleUpdates; } | 737 | get { return _throttleUpdates; } |
518 | set { _throttleUpdates = value; } | 738 | set { _throttleUpdates = value; } |
519 | } | 739 | } |
520 | public override bool IsColliding { | 740 | public override bool IsColliding { |
521 | get { return (_collidingStep == _scene.SimulationStep); } | 741 | get { return (CollidingStep == PhysicsScene.SimulationStep); } |
522 | set { _isColliding = value; } | 742 | set { _isColliding = value; } |
523 | } | 743 | } |
524 | public override bool CollidingGround { | 744 | public override bool CollidingGround { |
525 | get { return (_collidingGroundStep == _scene.SimulationStep); } | 745 | get { return (CollidingGroundStep == PhysicsScene.SimulationStep); } |
526 | set { _collidingGround = value; } | 746 | set { _collidingGround = value; } |
527 | } | 747 | } |
528 | public override bool CollidingObj { | 748 | public override bool CollidingObj { |
529 | get { return _collidingObj; } | 749 | get { return _collidingObj; } |
530 | set { _collidingObj = value; } | 750 | set { _collidingObj = value; } |
531 | } | 751 | } |
532 | public bool IsPhantom { | 752 | public bool IsPhantom { |
533 | get { | 753 | get { |
@@ -537,10 +757,19 @@ public sealed class BSPrim : PhysicsActor | |||
537 | return false; | 757 | return false; |
538 | } | 758 | } |
539 | } | 759 | } |
540 | public override bool FloatOnWater { | 760 | public override bool FloatOnWater { |
541 | set { _floatOnWater = value; } | 761 | set { |
762 | _floatOnWater = value; | ||
763 | PhysicsScene.TaintedObject("BSPrim.setFloatOnWater", delegate() | ||
764 | { | ||
765 | if (_floatOnWater) | ||
766 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
767 | else | ||
768 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
769 | }); | ||
770 | } | ||
542 | } | 771 | } |
543 | public override OMV.Vector3 RotationalVelocity { | 772 | public override OMV.Vector3 RotationalVelocity { |
544 | get { | 773 | get { |
545 | /* | 774 | /* |
546 | OMV.Vector3 pv = OMV.Vector3.Zero; | 775 | OMV.Vector3 pv = OMV.Vector3.Zero; |
@@ -552,58 +781,69 @@ public sealed class BSPrim : PhysicsActor | |||
552 | */ | 781 | */ |
553 | 782 | ||
554 | return _rotationalVelocity; | 783 | return _rotationalVelocity; |
555 | } | 784 | } |
556 | set { | 785 | set { |
557 | _rotationalVelocity = value; | 786 | _rotationalVelocity = value; |
558 | // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity); | 787 | // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity); |
559 | _scene.TaintedObject("BSPrim.setRotationalVelocity", delegate() | 788 | PhysicsScene.TaintedObject("BSPrim.setRotationalVelocity", delegate() |
560 | { | 789 | { |
561 | // DetailLog("{0},BSPrim.SetRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity); | 790 | // DetailLog("{0},BSPrim.SetRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity); |
562 | BulletSimAPI.SetObjectAngularVelocity(_scene.WorldID, LocalID, _rotationalVelocity); | 791 | BulletSimAPI.SetAngularVelocity2(BSBody.ptr, _rotationalVelocity); |
563 | }); | 792 | }); |
564 | } | 793 | } |
794 | } | ||
795 | public override OMV.Vector3 ForceRotationalVelocity { | ||
796 | get { | ||
797 | return _rotationalVelocity; | ||
798 | } | ||
799 | set { | ||
800 | _rotationalVelocity = value; | ||
801 | BulletSimAPI.SetAngularVelocity2(BSBody.ptr, _rotationalVelocity); | ||
802 | } | ||
565 | } | 803 | } |
566 | public override bool Kinematic { | 804 | public override bool Kinematic { |
567 | get { return _kinematic; } | 805 | get { return _kinematic; } |
568 | set { _kinematic = value; | 806 | set { _kinematic = value; |
569 | // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic); | 807 | // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic); |
570 | } | 808 | } |
571 | } | 809 | } |
572 | public override float Buoyancy { | 810 | public override float Buoyancy { |
573 | get { return _buoyancy; } | 811 | get { return _buoyancy; } |
574 | set { | 812 | set { |
575 | _buoyancy = value; | 813 | _buoyancy = value; |
576 | _scene.TaintedObject("BSPrim.setBuoyancy", delegate() | 814 | PhysicsScene.TaintedObject("BSPrim.setBuoyancy", delegate() |
577 | { | 815 | { |
578 | // DetailLog("{0},BSPrim.SetBuoyancy,taint,buoy={1}", LocalID, _buoyancy); | 816 | // DetailLog("{0},BSPrim.SetBuoyancy,taint,buoy={1}", LocalID, _buoyancy); |
579 | BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, _localID, _buoyancy); | 817 | // Buoyancy is faked by changing the gravity applied to the object |
818 | float grav = PhysicsScene.Params.gravity * (1f - _buoyancy); | ||
819 | BulletSimAPI.SetGravity2(BSBody.ptr, new OMV.Vector3(0f, 0f, grav)); | ||
580 | }); | 820 | }); |
581 | } | 821 | } |
582 | } | 822 | } |
583 | 823 | ||
584 | // Used for MoveTo | 824 | // Used for MoveTo |
585 | public override OMV.Vector3 PIDTarget { | 825 | public override OMV.Vector3 PIDTarget { |
586 | set { _PIDTarget = value; } | 826 | set { _PIDTarget = value; } |
587 | } | 827 | } |
588 | public override bool PIDActive { | 828 | public override bool PIDActive { |
589 | set { _usePID = value; } | 829 | set { _usePID = value; } |
590 | } | 830 | } |
591 | public override float PIDTau { | 831 | public override float PIDTau { |
592 | set { _PIDTau = value; } | 832 | set { _PIDTau = value; } |
593 | } | 833 | } |
594 | 834 | ||
595 | // Used for llSetHoverHeight and maybe vehicle height | 835 | // Used for llSetHoverHeight and maybe vehicle height |
596 | // Hover Height will override MoveTo target's Z | 836 | // Hover Height will override MoveTo target's Z |
597 | public override bool PIDHoverActive { | 837 | public override bool PIDHoverActive { |
598 | set { _useHoverPID = value; } | 838 | set { _useHoverPID = value; } |
599 | } | 839 | } |
600 | public override float PIDHoverHeight { | 840 | public override float PIDHoverHeight { |
601 | set { _PIDHoverHeight = value; } | 841 | set { _PIDHoverHeight = value; } |
602 | } | 842 | } |
603 | public override PIDHoverType PIDHoverType { | 843 | public override PIDHoverType PIDHoverType { |
604 | set { _PIDHoverType = value; } | 844 | set { _PIDHoverType = value; } |
605 | } | 845 | } |
606 | public override float PIDHoverTau { | 846 | public override float PIDHoverTau { |
607 | set { _PIDHoverTao = value; } | 847 | set { _PIDHoverTao = value; } |
608 | } | 848 | } |
609 | 849 | ||
@@ -615,6 +855,9 @@ public sealed class BSPrim : PhysicsActor | |||
615 | 855 | ||
616 | private List<OMV.Vector3> m_accumulatedForces = new List<OMV.Vector3>(); | 856 | private List<OMV.Vector3> m_accumulatedForces = new List<OMV.Vector3>(); |
617 | public override void AddForce(OMV.Vector3 force, bool pushforce) { | 857 | public override void AddForce(OMV.Vector3 force, bool pushforce) { |
858 | AddForce(force, pushforce, false); | ||
859 | } | ||
860 | public void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) { | ||
618 | // for an object, doesn't matter if force is a pushforce or not | 861 | // for an object, doesn't matter if force is a pushforce or not |
619 | if (force.IsFinite()) | 862 | if (force.IsFinite()) |
620 | { | 863 | { |
@@ -624,56 +867,38 @@ public sealed class BSPrim : PhysicsActor | |||
624 | } | 867 | } |
625 | else | 868 | else |
626 | { | 869 | { |
627 | m_log.WarnFormat("{0}: Got a NaN force applied to a Character", LogHeader); | 870 | m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID); |
628 | return; | 871 | return; |
629 | } | 872 | } |
630 | _scene.TaintedObject("BSPrim.AddForce", delegate() | 873 | BSScene.TaintCallback addForceOperation = delegate() |
631 | { | 874 | { |
632 | OMV.Vector3 fSum = OMV.Vector3.Zero; | 875 | OMV.Vector3 fSum = OMV.Vector3.Zero; |
633 | lock (m_accumulatedForces) | 876 | lock (m_accumulatedForces) |
634 | { | 877 | { |
878 | // Sum the accumulated additional forces for one big force to apply once. | ||
635 | foreach (OMV.Vector3 v in m_accumulatedForces) | 879 | foreach (OMV.Vector3 v in m_accumulatedForces) |
636 | { | 880 | { |
637 | fSum += v; | 881 | fSum += v; |
638 | } | 882 | } |
639 | m_accumulatedForces.Clear(); | 883 | m_accumulatedForces.Clear(); |
640 | } | 884 | } |
641 | // DetailLog("{0},BSPrim.AddObjectForce,taint,force={1}", LocalID, _force); | 885 | // DetailLog("{0},BSPrim.AddObjectForce,taint,force={1}", LocalID, fSum); |
642 | BulletSimAPI.AddObjectForce2(Body.Ptr, fSum); | 886 | // For unknown reasons, "ApplyCentralForce" adds this force to the total force on the object. |
643 | }); | 887 | BulletSimAPI.ApplyCentralForce2(BSBody.ptr, fSum); |
888 | }; | ||
889 | if (inTaintTime) | ||
890 | addForceOperation(); | ||
891 | else | ||
892 | PhysicsScene.TaintedObject("BSPrim.AddForce", addForceOperation); | ||
644 | } | 893 | } |
645 | 894 | ||
646 | public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { | 895 | public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { |
647 | // DetailLog("{0},BSPrim.AddAngularForce,call,angForce={1},push={2}", LocalID, force, pushforce); | 896 | // DetailLog("{0},BSPrim.AddAngularForce,call,angForce={1},push={2}", LocalID, force, pushforce); |
648 | // m_log.DebugFormat("{0}: AddAngularForce. f={1}, push={2}", LogHeader, force, pushforce); | 897 | // m_log.DebugFormat("{0}: AddAngularForce. f={1}, push={2}", LogHeader, force, pushforce); |
649 | } | 898 | } |
650 | public override void SetMomentum(OMV.Vector3 momentum) { | 899 | public override void SetMomentum(OMV.Vector3 momentum) { |
651 | // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum); | 900 | // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum); |
652 | } | 901 | } |
653 | public override void SubscribeEvents(int ms) { | ||
654 | _subscribedEventsMs = ms; | ||
655 | if (ms > 0) | ||
656 | { | ||
657 | // make sure first collision happens | ||
658 | _nextCollisionOkTime = Util.EnvironmentTickCount() - _subscribedEventsMs; | ||
659 | |||
660 | Scene.TaintedObject("BSPrim.SubscribeEvents", delegate() | ||
661 | { | ||
662 | BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
663 | }); | ||
664 | } | ||
665 | } | ||
666 | public override void UnSubscribeEvents() { | ||
667 | _subscribedEventsMs = 0; | ||
668 | Scene.TaintedObject("BSPrim.UnSubscribeEvents", delegate() | ||
669 | { | ||
670 | BulletSimAPI.RemoveFromCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
671 | }); | ||
672 | } | ||
673 | public override bool SubscribedEvents() { | ||
674 | return (_subscribedEventsMs > 0); | ||
675 | } | ||
676 | |||
677 | #region Mass Calculation | 902 | #region Mass Calculation |
678 | 903 | ||
679 | private float CalculateMass() | 904 | private float CalculateMass() |
@@ -683,8 +908,8 @@ public sealed class BSPrim : PhysicsActor | |||
683 | 908 | ||
684 | float returnMass = 0; | 909 | float returnMass = 0; |
685 | float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f; | 910 | float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f; |
686 | float hollowVolume = hollowAmount * hollowAmount; | 911 | float hollowVolume = hollowAmount * hollowAmount; |
687 | 912 | ||
688 | switch (_pbs.ProfileShape) | 913 | switch (_pbs.ProfileShape) |
689 | { | 914 | { |
690 | case ProfileShape.Square: | 915 | case ProfileShape.Square: |
@@ -720,16 +945,16 @@ public sealed class BSPrim : PhysicsActor | |||
720 | 945 | ||
721 | else if (_pbs.PathCurve == (byte)Extrusion.Curve1) | 946 | else if (_pbs.PathCurve == (byte)Extrusion.Curve1) |
722 | { | 947 | { |
723 | //a tube | 948 | //a tube |
724 | 949 | ||
725 | volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX); | 950 | volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX); |
726 | tmp= 1.0f -2.0e-2f * (float)(200 - _pbs.PathScaleY); | 951 | tmp= 1.0f -2.0e-2f * (float)(200 - _pbs.PathScaleY); |
727 | volume -= volume*tmp*tmp; | 952 | volume -= volume*tmp*tmp; |
728 | 953 | ||
729 | if (hollowAmount > 0.0) | 954 | if (hollowAmount > 0.0) |
730 | { | 955 | { |
731 | hollowVolume *= hollowAmount; | 956 | hollowVolume *= hollowAmount; |
732 | 957 | ||
733 | switch (_pbs.HollowShape) | 958 | switch (_pbs.HollowShape) |
734 | { | 959 | { |
735 | case HollowShape.Square: | 960 | case HollowShape.Square: |
@@ -788,7 +1013,7 @@ public sealed class BSPrim : PhysicsActor | |||
788 | volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX); | 1013 | volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX); |
789 | tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY); | 1014 | tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY); |
790 | volume *= (1.0f - tmp * tmp); | 1015 | volume *= (1.0f - tmp * tmp); |
791 | 1016 | ||
792 | if (hollowAmount > 0.0) | 1017 | if (hollowAmount > 0.0) |
793 | { | 1018 | { |
794 | 1019 | ||
@@ -967,296 +1192,65 @@ public sealed class BSPrim : PhysicsActor | |||
967 | if (returnMass <= 0) | 1192 | if (returnMass <= 0) |
968 | returnMass = 0.0001f; | 1193 | returnMass = 0.0001f; |
969 | 1194 | ||
970 | if (returnMass > _scene.MaximumObjectMass) | 1195 | if (returnMass > PhysicsScene.MaximumObjectMass) |
971 | returnMass = _scene.MaximumObjectMass; | 1196 | returnMass = PhysicsScene.MaximumObjectMass; |
972 | 1197 | ||
973 | return returnMass; | 1198 | return returnMass; |
974 | }// end CalculateMass | 1199 | }// end CalculateMass |
975 | #endregion Mass Calculation | 1200 | #endregion Mass Calculation |
976 | 1201 | ||
977 | // Create the geometry information in Bullet for later use | ||
978 | // The objects needs a hull if it's physical otherwise a mesh is enough | ||
979 | // No locking here because this is done when we know physics is not simulating | ||
980 | // if 'forceRebuild' is true, the geometry is rebuilt. Otherwise a previously built version is used | ||
981 | // Returns 'true' if the geometry was rebuilt | ||
982 | private bool CreateGeom(bool forceRebuild) | ||
983 | { | ||
984 | // the mesher thought this was too simple to mesh. Use a native Bullet collision shape. | ||
985 | bool ret = false; | ||
986 | if (!_scene.NeedsMeshing(_pbs)) | ||
987 | { | ||
988 | if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1) | ||
989 | { | ||
990 | // if (_size.X == _size.Y && _size.Y == _size.Z && _size.X == _size.Z) | ||
991 | // { | ||
992 | // m_log.DebugFormat("{0}: CreateGeom: Defaulting to sphere of size {1}", LogHeader, _size); | ||
993 | if (forceRebuild || (_shapeType != ShapeData.PhysicsShapeType.SHAPE_SPHERE)) | ||
994 | { | ||
995 | // DetailLog("{0},BSPrim.CreateGeom,sphere (force={1}", LocalID, forceRebuild); | ||
996 | _shapeType = ShapeData.PhysicsShapeType.SHAPE_SPHERE; | ||
997 | // Bullet native objects are scaled by the Bullet engine so pass the size in | ||
998 | _scale = _size; | ||
999 | // TODO: do we need to check for and destroy a mesh or hull that might have been left from before? | ||
1000 | ret = true; | ||
1001 | } | ||
1002 | // } | ||
1003 | } | ||
1004 | else | ||
1005 | { | ||
1006 | // m_log.DebugFormat("{0}: CreateGeom: Defaulting to box. lid={1}, type={2}, size={3}", LogHeader, LocalID, _shapeType, _size); | ||
1007 | if (forceRebuild || (_shapeType != ShapeData.PhysicsShapeType.SHAPE_BOX)) | ||
1008 | { | ||
1009 | // DetailLog("{0},BSPrim.CreateGeom,box (force={1})", LocalID, forceRebuild); | ||
1010 | _shapeType = ShapeData.PhysicsShapeType.SHAPE_BOX; | ||
1011 | _scale = _size; | ||
1012 | // TODO: do we need to check for and destroy a mesh or hull that might have been left from before? | ||
1013 | ret = true; | ||
1014 | } | ||
1015 | } | ||
1016 | } | ||
1017 | else | ||
1018 | { | ||
1019 | if (IsPhysical) | ||
1020 | { | ||
1021 | if (forceRebuild || _hullKey == 0) | ||
1022 | { | ||
1023 | // physical objects require a hull for interaction. | ||
1024 | // This will create the mesh if it doesn't already exist | ||
1025 | CreateGeomHull(); | ||
1026 | ret = true; | ||
1027 | } | ||
1028 | } | ||
1029 | else | ||
1030 | { | ||
1031 | if (forceRebuild || _meshKey == 0) | ||
1032 | { | ||
1033 | // Static (non-physical) objects only need a mesh for bumping into | ||
1034 | CreateGeomMesh(); | ||
1035 | ret = true; | ||
1036 | } | ||
1037 | } | ||
1038 | } | ||
1039 | return ret; | ||
1040 | } | ||
1041 | |||
1042 | // No locking here because this is done when we know physics is not simulating | ||
1043 | private void CreateGeomMesh() | ||
1044 | { | ||
1045 | float lod = _pbs.SculptEntry ? _scene.SculptLOD : _scene.MeshLOD; | ||
1046 | ulong newMeshKey = (ulong)_pbs.GetMeshKey(_size, lod); | ||
1047 | // m_log.DebugFormat("{0}: CreateGeomMesh: lID={1}, oldKey={2}, newKey={3}", LogHeader, _localID, _meshKey, newMeshKey); | ||
1048 | |||
1049 | // if this new shape is the same as last time, don't recreate the mesh | ||
1050 | if (_meshKey == newMeshKey) return; | ||
1051 | |||
1052 | // DetailLog("{0},BSPrim.CreateGeomMesh,create,key={1}", LocalID, newMeshKey); | ||
1053 | // Since we're recreating new, get rid of any previously generated shape | ||
1054 | if (_meshKey != 0) | ||
1055 | { | ||
1056 | // m_log.DebugFormat("{0}: CreateGeom: deleting old mesh. lID={1}, Key={2}", LogHeader, _localID, _meshKey); | ||
1057 | // DetailLog("{0},BSPrim.CreateGeomMesh,deleteOld,key={1}", LocalID, _meshKey); | ||
1058 | BulletSimAPI.DestroyMesh(_scene.WorldID, _meshKey); | ||
1059 | _mesh = null; | ||
1060 | _meshKey = 0; | ||
1061 | } | ||
1062 | |||
1063 | _meshKey = newMeshKey; | ||
1064 | // always pass false for physicalness as this creates some sort of bounding box which we don't need | ||
1065 | _mesh = _scene.mesher.CreateMesh(_avName, _pbs, _size, lod, false); | ||
1066 | |||
1067 | int[] indices = _mesh.getIndexListAsInt(); | ||
1068 | List<OMV.Vector3> vertices = _mesh.getVertexList(); | ||
1069 | |||
1070 | float[] verticesAsFloats = new float[vertices.Count * 3]; | ||
1071 | int vi = 0; | ||
1072 | foreach (OMV.Vector3 vv in vertices) | ||
1073 | { | ||
1074 | verticesAsFloats[vi++] = vv.X; | ||
1075 | verticesAsFloats[vi++] = vv.Y; | ||
1076 | verticesAsFloats[vi++] = vv.Z; | ||
1077 | } | ||
1078 | |||
1079 | // m_log.DebugFormat("{0}: CreateGeomMesh: calling CreateMesh. lid={1}, key={2}, indices={3}, vertices={4}", | ||
1080 | // LogHeader, _localID, _meshKey, indices.Length, vertices.Count); | ||
1081 | BulletSimAPI.CreateMesh(_scene.WorldID, _meshKey, indices.GetLength(0), indices, | ||
1082 | vertices.Count, verticesAsFloats); | ||
1083 | |||
1084 | _shapeType = ShapeData.PhysicsShapeType.SHAPE_MESH; | ||
1085 | // meshes are already scaled by the meshmerizer | ||
1086 | _scale = new OMV.Vector3(1f, 1f, 1f); | ||
1087 | // DetailLog("{0},BSPrim.CreateGeomMesh,done", LocalID); | ||
1088 | return; | ||
1089 | } | ||
1090 | |||
1091 | // No locking here because this is done when we know physics is not simulating | ||
1092 | private void CreateGeomHull() | ||
1093 | { | ||
1094 | float lod = _pbs.SculptEntry ? _scene.SculptLOD : _scene.MeshLOD; | ||
1095 | ulong newHullKey = (ulong)_pbs.GetMeshKey(_size, lod); | ||
1096 | // m_log.DebugFormat("{0}: CreateGeomHull: lID={1}, oldKey={2}, newKey={3}", LogHeader, _localID, _hullKey, newHullKey); | ||
1097 | |||
1098 | // if the hull hasn't changed, don't rebuild it | ||
1099 | if (newHullKey == _hullKey) return; | ||
1100 | |||
1101 | // DetailLog("{0},BSPrim.CreateGeomHull,create,oldKey={1},newKey={2}", LocalID, _hullKey, newHullKey); | ||
1102 | |||
1103 | // Since we're recreating new, get rid of any previously generated shape | ||
1104 | if (_hullKey != 0) | ||
1105 | { | ||
1106 | // m_log.DebugFormat("{0}: CreateGeom: deleting old hull. Key={1}", LogHeader, _hullKey); | ||
1107 | // DetailLog("{0},BSPrim.CreateGeomHull,deleteOldHull,key={1}", LocalID, _hullKey); | ||
1108 | BulletSimAPI.DestroyHull(_scene.WorldID, _hullKey); | ||
1109 | _hullKey = 0; | ||
1110 | } | ||
1111 | |||
1112 | _hullKey = newHullKey; | ||
1113 | |||
1114 | // Make sure the underlying mesh exists and is correct | ||
1115 | CreateGeomMesh(); | ||
1116 | |||
1117 | int[] indices = _mesh.getIndexListAsInt(); | ||
1118 | List<OMV.Vector3> vertices = _mesh.getVertexList(); | ||
1119 | |||
1120 | //format conversion from IMesh format to DecompDesc format | ||
1121 | List<int> convIndices = new List<int>(); | ||
1122 | List<float3> convVertices = new List<float3>(); | ||
1123 | for (int ii = 0; ii < indices.GetLength(0); ii++) | ||
1124 | { | ||
1125 | convIndices.Add(indices[ii]); | ||
1126 | } | ||
1127 | foreach (OMV.Vector3 vv in vertices) | ||
1128 | { | ||
1129 | convVertices.Add(new float3(vv.X, vv.Y, vv.Z)); | ||
1130 | } | ||
1131 | |||
1132 | // setup and do convex hull conversion | ||
1133 | _hulls = new List<ConvexResult>(); | ||
1134 | DecompDesc dcomp = new DecompDesc(); | ||
1135 | dcomp.mIndices = convIndices; | ||
1136 | dcomp.mVertices = convVertices; | ||
1137 | ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn); | ||
1138 | // create the hull into the _hulls variable | ||
1139 | convexBuilder.process(dcomp); | ||
1140 | |||
1141 | // Convert the vertices and indices for passing to unmanaged. | ||
1142 | // The hull information is passed as a large floating point array. | ||
1143 | // The format is: | ||
1144 | // convHulls[0] = number of hulls | ||
1145 | // convHulls[1] = number of vertices in first hull | ||
1146 | // convHulls[2] = hull centroid X coordinate | ||
1147 | // convHulls[3] = hull centroid Y coordinate | ||
1148 | // convHulls[4] = hull centroid Z coordinate | ||
1149 | // convHulls[5] = first hull vertex X | ||
1150 | // convHulls[6] = first hull vertex Y | ||
1151 | // convHulls[7] = first hull vertex Z | ||
1152 | // convHulls[8] = second hull vertex X | ||
1153 | // ... | ||
1154 | // convHulls[n] = number of vertices in second hull | ||
1155 | // convHulls[n+1] = second hull centroid X coordinate | ||
1156 | // ... | ||
1157 | // | ||
1158 | // TODO: is is very inefficient. Someday change the convex hull generator to return | ||
1159 | // data structures that do not need to be converted in order to pass to Bullet. | ||
1160 | // And maybe put the values directly into pinned memory rather than marshaling. | ||
1161 | int hullCount = _hulls.Count; | ||
1162 | int totalVertices = 1; // include one for the count of the hulls | ||
1163 | foreach (ConvexResult cr in _hulls) | ||
1164 | { | ||
1165 | totalVertices += 4; // add four for the vertex count and centroid | ||
1166 | totalVertices += cr.HullIndices.Count * 3; // we pass just triangles | ||
1167 | } | ||
1168 | float[] convHulls = new float[totalVertices]; | ||
1169 | |||
1170 | convHulls[0] = (float)hullCount; | ||
1171 | int jj = 1; | ||
1172 | foreach (ConvexResult cr in _hulls) | ||
1173 | { | ||
1174 | // copy vertices for index access | ||
1175 | float3[] verts = new float3[cr.HullVertices.Count]; | ||
1176 | int kk = 0; | ||
1177 | foreach (float3 ff in cr.HullVertices) | ||
1178 | { | ||
1179 | verts[kk++] = ff; | ||
1180 | } | ||
1181 | |||
1182 | // add to the array one hull's worth of data | ||
1183 | convHulls[jj++] = cr.HullIndices.Count; | ||
1184 | convHulls[jj++] = 0f; // centroid x,y,z | ||
1185 | convHulls[jj++] = 0f; | ||
1186 | convHulls[jj++] = 0f; | ||
1187 | foreach (int ind in cr.HullIndices) | ||
1188 | { | ||
1189 | convHulls[jj++] = verts[ind].x; | ||
1190 | convHulls[jj++] = verts[ind].y; | ||
1191 | convHulls[jj++] = verts[ind].z; | ||
1192 | } | ||
1193 | } | ||
1194 | |||
1195 | // create the hull definition in Bullet | ||
1196 | // m_log.DebugFormat("{0}: CreateGeom: calling CreateHull. lid={1}, key={2}, hulls={3}", LogHeader, _localID, _hullKey, hullCount); | ||
1197 | BulletSimAPI.CreateHull(_scene.WorldID, _hullKey, hullCount, convHulls); | ||
1198 | _shapeType = ShapeData.PhysicsShapeType.SHAPE_HULL; | ||
1199 | // meshes are already scaled by the meshmerizer | ||
1200 | _scale = new OMV.Vector3(1f, 1f, 1f); | ||
1201 | // DetailLog("{0},BSPrim.CreateGeomHull,done", LocalID); | ||
1202 | return; | ||
1203 | } | ||
1204 | |||
1205 | // Callback from convex hull creater with a newly created hull. | ||
1206 | // Just add it to the collection of hulls for this shape. | ||
1207 | private void HullReturn(ConvexResult result) | ||
1208 | { | ||
1209 | _hulls.Add(result); | ||
1210 | return; | ||
1211 | } | ||
1212 | |||
1213 | // Create an object in Bullet if it has not already been created | ||
1214 | // No locking here because this is done when the physics engine is not simulating | ||
1215 | // Returns 'true' if an object was actually created. | ||
1216 | private bool CreateObject() | ||
1217 | { | ||
1218 | // this routine is called when objects are rebuilt. | ||
1219 | |||
1220 | // the mesh or hull must have already been created in Bullet | ||
1221 | ShapeData shape; | ||
1222 | FillShapeInfo(out shape); | ||
1223 | // m_log.DebugFormat("{0}: CreateObject: lID={1}, shape={2}", LogHeader, _localID, shape.Type); | ||
1224 | bool ret = BulletSimAPI.CreateObject(_scene.WorldID, shape); | ||
1225 | |||
1226 | // the CreateObject() may have recreated the rigid body. Make sure we have the latest. | ||
1227 | Body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID)); | ||
1228 | |||
1229 | return ret; | ||
1230 | } | ||
1231 | |||
1232 | // Copy prim's info into the BulletSim shape description structure | 1202 | // Copy prim's info into the BulletSim shape description structure |
1233 | public void FillShapeInfo(out ShapeData shape) | 1203 | public void FillShapeInfo(out ShapeData shape) |
1234 | { | 1204 | { |
1235 | shape.ID = _localID; | 1205 | shape.ID = LocalID; |
1236 | shape.Type = _shapeType; | 1206 | shape.Type = ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; |
1237 | shape.Position = _position; | 1207 | shape.Position = _position; |
1238 | shape.Rotation = _orientation; | 1208 | shape.Rotation = _orientation; |
1239 | shape.Velocity = _velocity; | 1209 | shape.Velocity = _velocity; |
1240 | shape.Scale = _scale; | 1210 | shape.Scale = _scale; |
1241 | shape.Mass = _isPhysical ? _mass : 0f; | 1211 | shape.Mass = _isPhysical ? _mass : 0f; |
1242 | shape.Buoyancy = _buoyancy; | 1212 | shape.Buoyancy = _buoyancy; |
1243 | shape.HullKey = _hullKey; | 1213 | shape.HullKey = 0; |
1244 | shape.MeshKey = _meshKey; | 1214 | shape.MeshKey = 0; |
1245 | shape.Friction = _friction; | 1215 | shape.Friction = _friction; |
1246 | shape.Restitution = _restitution; | 1216 | shape.Restitution = _restitution; |
1247 | shape.Collidable = (!IsPhantom) ? ShapeData.numericTrue : ShapeData.numericFalse; | 1217 | shape.Collidable = (!IsPhantom) ? ShapeData.numericTrue : ShapeData.numericFalse; |
1248 | shape.Static = _isPhysical ? ShapeData.numericFalse : ShapeData.numericTrue; | 1218 | shape.Static = _isPhysical ? ShapeData.numericFalse : ShapeData.numericTrue; |
1219 | shape.Solid = IsSolid ? ShapeData.numericFalse : ShapeData.numericTrue; | ||
1220 | shape.Size = _size; | ||
1249 | } | 1221 | } |
1250 | |||
1251 | |||
1252 | // Rebuild the geometry and object. | 1222 | // Rebuild the geometry and object. |
1253 | // This is called when the shape changes so we need to recreate the mesh/hull. | 1223 | // This is called when the shape changes so we need to recreate the mesh/hull. |
1254 | // No locking here because this is done when the physics engine is not simulating | 1224 | // Called at taint-time!!! |
1255 | private void RecreateGeomAndObject() | 1225 | private void CreateGeomAndObject(bool forceRebuild) |
1256 | { | 1226 | { |
1257 | // m_log.DebugFormat("{0}: RecreateGeomAndObject. lID={1}", LogHeader, _localID); | 1227 | ShapeData shapeData; |
1258 | if (CreateGeom(true)) | 1228 | FillShapeInfo(out shapeData); |
1259 | CreateObject(); | 1229 | |
1230 | // If this prim is part of a linkset, we must remove and restore the physical | ||
1231 | // links of the body is rebuilt. | ||
1232 | bool needToRestoreLinkset = false; | ||
1233 | |||
1234 | // Create the correct physical representation for this type of object. | ||
1235 | // Updates BSBody and BSShape with the new information. | ||
1236 | // Ignore 'forceRebuild'. This routine makes the right choices and changes of necessary. | ||
1237 | PhysicsScene.Shapes.GetBodyAndShape(false, PhysicsScene.World, this, shapeData, _pbs, | ||
1238 | null, delegate(BulletBody dBody) | ||
1239 | { | ||
1240 | // Called if the current prim body is about to be destroyed. | ||
1241 | // Remove all the physical dependencies on the old body. | ||
1242 | // (Maybe someday make the changing of BSShape an event handled by BSLinkset.) | ||
1243 | needToRestoreLinkset = Linkset.RemoveBodyDependencies(this); | ||
1244 | }); | ||
1245 | |||
1246 | if (needToRestoreLinkset) | ||
1247 | { | ||
1248 | // If physical body dependencies were removed, restore them | ||
1249 | Linkset.RestoreBodyDependencies(this); | ||
1250 | } | ||
1251 | |||
1252 | // Make sure the properties are set on the new object | ||
1253 | UpdatePhysicalParameters(); | ||
1260 | return; | 1254 | return; |
1261 | } | 1255 | } |
1262 | 1256 | ||
@@ -1277,7 +1271,7 @@ public sealed class BSPrim : PhysicsActor | |||
1277 | const float ACCELERATION_TOLERANCE = 0.01f; | 1271 | const float ACCELERATION_TOLERANCE = 0.01f; |
1278 | const float ROTATIONAL_VELOCITY_TOLERANCE = 0.01f; | 1272 | const float ROTATIONAL_VELOCITY_TOLERANCE = 0.01f; |
1279 | 1273 | ||
1280 | public void UpdateProperties(EntityProperties entprop) | 1274 | public override void UpdateProperties(EntityProperties entprop) |
1281 | { | 1275 | { |
1282 | /* | 1276 | /* |
1283 | UpdatedProperties changed = 0; | 1277 | UpdatedProperties changed = 0; |
@@ -1325,7 +1319,7 @@ public sealed class BSPrim : PhysicsActor | |||
1325 | // Don't check for damping here -- it's done in BulletSim and SceneObjectPart. | 1319 | // Don't check for damping here -- it's done in BulletSim and SceneObjectPart. |
1326 | 1320 | ||
1327 | // Updates only for individual prims and for the root object of a linkset. | 1321 | // Updates only for individual prims and for the root object of a linkset. |
1328 | if (_linkset.IsRoot(this)) | 1322 | if (Linkset.IsRoot(this)) |
1329 | { | 1323 | { |
1330 | // Assign to the local variables so the normal set action does not happen | 1324 | // Assign to the local variables so the normal set action does not happen |
1331 | _position = entprop.Position; | 1325 | _position = entprop.Position; |
@@ -1334,69 +1328,26 @@ public sealed class BSPrim : PhysicsActor | |||
1334 | _acceleration = entprop.Acceleration; | 1328 | _acceleration = entprop.Acceleration; |
1335 | _rotationalVelocity = entprop.RotationalVelocity; | 1329 | _rotationalVelocity = entprop.RotationalVelocity; |
1336 | 1330 | ||
1337 | // m_log.DebugFormat("{0}: RequestTerseUpdate. id={1}, ch={2}, pos={3}, rot={4}, vel={5}, acc={6}, rvel={7}", | 1331 | PositionSanityCheck2(true); |
1338 | // LogHeader, LocalID, changed, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); | 1332 | |
1339 | // DetailLog("{0},BSPrim.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | 1333 | Linkset.UpdateProperties(this); |
1340 | // LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); | 1334 | |
1335 | DetailLog("{0},BSPrim.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | ||
1336 | LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); | ||
1337 | |||
1338 | // BulletSimAPI.DumpRigidBody2(Scene.World.Ptr, BSBody.Ptr); | ||
1341 | 1339 | ||
1342 | base.RequestPhysicsterseUpdate(); | 1340 | base.RequestPhysicsterseUpdate(); |
1343 | } | 1341 | } |
1344 | /* | 1342 | /* |
1345 | else | 1343 | else |
1346 | { | 1344 | { |
1347 | // For debugging, we also report the movement of children | 1345 | // For debugging, report the movement of children |
1348 | DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | 1346 | DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}", |
1349 | LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, | 1347 | LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, |
1350 | entprop.Acceleration, entprop.RotationalVelocity); | 1348 | entprop.Acceleration, entprop.RotationalVelocity); |
1351 | } | 1349 | } |
1352 | */ | 1350 | */ |
1353 | } | 1351 | } |
1354 | |||
1355 | // I've collided with something | ||
1356 | CollisionEventUpdate collisionCollection; | ||
1357 | public void Collide(uint collidingWith, ActorTypes type, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth) | ||
1358 | { | ||
1359 | // m_log.DebugFormat("{0}: Collide: ms={1}, id={2}, with={3}", LogHeader, _subscribedEventsMs, LocalID, collidingWith); | ||
1360 | |||
1361 | // The following lines make IsColliding() and IsCollidingGround() work | ||
1362 | _collidingStep = _scene.SimulationStep; | ||
1363 | if (collidingWith == BSScene.TERRAIN_ID || collidingWith == BSScene.GROUNDPLANE_ID) | ||
1364 | { | ||
1365 | _collidingGroundStep = _scene.SimulationStep; | ||
1366 | } | ||
1367 | |||
1368 | // DetailLog("{0},BSPrim.Collison,call,with={1}", LocalID, collidingWith); | ||
1369 | |||
1370 | // if someone is subscribed to collision events.... | ||
1371 | if (_subscribedEventsMs != 0) { | ||
1372 | // throttle the collisions to the number of milliseconds specified in the subscription | ||
1373 | int nowTime = _scene.SimulationNowTime; | ||
1374 | if (nowTime >= _nextCollisionOkTime) { | ||
1375 | _nextCollisionOkTime = nowTime + _subscribedEventsMs; | ||
1376 | |||
1377 | if (collisionCollection == null) | ||
1378 | collisionCollection = new CollisionEventUpdate(); | ||
1379 | collisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth)); | ||
1380 | } | ||
1381 | } | ||
1382 | } | ||
1383 | |||
1384 | // The scene is telling us it's time to pass our collected collisions into the simulator | ||
1385 | public void SendCollisions() | ||
1386 | { | ||
1387 | if (collisionCollection != null && collisionCollection.Count > 0) | ||
1388 | { | ||
1389 | base.SendCollisionUpdate(collisionCollection); | ||
1390 | // The collisionCollection structure is passed around in the simulator. | ||
1391 | // Make sure we don't have a handle to that one and that a new one is used next time. | ||
1392 | collisionCollection = null; | ||
1393 | } | ||
1394 | } | ||
1395 | |||
1396 | // Invoke the detailed logger and output something if it's enabled. | ||
1397 | private void DetailLog(string msg, params Object[] args) | ||
1398 | { | ||
1399 | Scene.PhysicsLogging.Write(msg, args); | ||
1400 | } | ||
1401 | } | 1352 | } |
1402 | } | 1353 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs index a31c578..2c3c481 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs | |||
@@ -39,33 +39,27 @@ using log4net; | |||
39 | using OpenMetaverse; | 39 | using OpenMetaverse; |
40 | 40 | ||
41 | // TODOs for BulletSim (for BSScene, BSPrim, BSCharacter and BulletSim) | 41 | // TODOs for BulletSim (for BSScene, BSPrim, BSCharacter and BulletSim) |
42 | // Debug linkset | 42 | // Test sculpties (verified that they don't work) |
43 | // Test with multiple regions in one simulator | ||
44 | // Adjust character capsule size when height is adjusted (ScenePresence.SetHeight) | ||
45 | // Test sculpties | ||
46 | // Compute physics FPS reasonably | 43 | // Compute physics FPS reasonably |
47 | // Based on material, set density and friction | 44 | // Based on material, set density and friction |
48 | // More efficient memory usage when passing hull information from BSPrim to BulletSim | 45 | // Don't use constraints in linksets of non-physical objects. Means having to move children manually. |
49 | // Move all logic out of the C++ code and into the C# code for easier future modifications. | ||
50 | // Four states of prim: Physical, regular, phantom and selected. Are we modeling these correctly? | 46 | // Four states of prim: Physical, regular, phantom and selected. Are we modeling these correctly? |
51 | // In SL one can set both physical and phantom (gravity, does not effect others, makes collisions with ground) | 47 | // In SL one can set both physical and phantom (gravity, does not effect others, makes collisions with ground) |
52 | // At the moment, physical and phantom causes object to drop through the terrain | 48 | // At the moment, physical and phantom causes object to drop through the terrain |
53 | // Physical phantom objects and related typing (collision options ) | 49 | // Physical phantom objects and related typing (collision options ) |
54 | // Use collision masks for collision with terrain and phantom objects | ||
55 | // Check out llVolumeDetect. Must do something for that. | 50 | // Check out llVolumeDetect. Must do something for that. |
51 | // Use collision masks for collision with terrain and phantom objects | ||
52 | // More efficient memory usage when passing hull information from BSPrim to BulletSim | ||
56 | // Should prim.link() and prim.delink() membership checking happen at taint time? | 53 | // Should prim.link() and prim.delink() membership checking happen at taint time? |
57 | // changing the position and orientation of a linked prim must rebuild the constraint with the root. | 54 | // Mesh sharing. Use meshHash to tell if we already have a hull of that shape and only create once. |
58 | // Mesh sharing. Use meshHash to tell if we already have a hull of that shape and only create once | ||
59 | // Do attachments need to be handled separately? Need collision events. Do not collide with VolumeDetect | 55 | // Do attachments need to be handled separately? Need collision events. Do not collide with VolumeDetect |
60 | // Implement the genCollisions feature in BulletSim::SetObjectProperties (don't pass up unneeded collisions) | ||
61 | // Implement LockAngularMotion | 56 | // Implement LockAngularMotion |
62 | // Decide if clearing forces is the right thing to do when setting position (BulletSim::SetObjectTranslation) | 57 | // Decide if clearing forces is the right thing to do when setting position (BulletSim::SetObjectTranslation) |
63 | // Does NeedsMeshing() really need to exclude all the different shapes? | ||
64 | // Remove mesh and Hull stuff. Use mesh passed to bullet and use convexdecom from bullet. | 58 | // Remove mesh and Hull stuff. Use mesh passed to bullet and use convexdecom from bullet. |
65 | // Add PID movement operations. What does ScenePresence.MoveToTarget do? | 59 | // Add PID movement operations. What does ScenePresence.MoveToTarget do? |
66 | // Check terrain size. 128 or 127? | 60 | // Check terrain size. 128 or 127? |
67 | // Raycast | 61 | // Raycast |
68 | // | 62 | // |
69 | namespace OpenSim.Region.Physics.BulletSPlugin | 63 | namespace OpenSim.Region.Physics.BulletSPlugin |
70 | { | 64 | { |
71 | public class BSScene : PhysicsScene, IPhysicsParameters | 65 | public class BSScene : PhysicsScene, IPhysicsParameters |
@@ -73,62 +67,56 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
73 | private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); | 67 | private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); |
74 | private static readonly string LogHeader = "[BULLETS SCENE]"; | 68 | private static readonly string LogHeader = "[BULLETS SCENE]"; |
75 | 69 | ||
76 | public void DebugLog(string mm, params Object[] xx) { if (ShouldDebugLog) m_log.DebugFormat(mm, xx); } | 70 | // The name of the region we're working for. |
71 | public string RegionName { get; private set; } | ||
77 | 72 | ||
78 | public string BulletSimVersion = "?"; | 73 | public string BulletSimVersion = "?"; |
79 | 74 | ||
80 | private Dictionary<uint, BSCharacter> m_avatars = new Dictionary<uint, BSCharacter>(); | 75 | public Dictionary<uint, BSPhysObject> PhysObjects; |
81 | private Dictionary<uint, BSPrim> m_prims = new Dictionary<uint, BSPrim>(); | 76 | public BSShapeCollection Shapes; |
82 | private HashSet<BSCharacter> m_avatarsWithCollisions = new HashSet<BSCharacter>(); | ||
83 | private HashSet<BSPrim> m_primsWithCollisions = new HashSet<BSPrim>(); | ||
84 | private List<BSPrim> m_vehicles = new List<BSPrim>(); | ||
85 | private float[] m_heightMap; | ||
86 | private float m_waterLevel; | ||
87 | private uint m_worldID; | ||
88 | public uint WorldID { get { return m_worldID; } } | ||
89 | 77 | ||
90 | // let my minuions use my logger | 78 | // Keeping track of the objects with collisions so we can report begin and end of a collision |
91 | public ILog Logger { get { return m_log; } } | 79 | public HashSet<BSPhysObject> ObjectsWithCollisions = new HashSet<BSPhysObject>(); |
80 | public HashSet<BSPhysObject> ObjectsWithNoMoreCollisions = new HashSet<BSPhysObject>(); | ||
81 | // Keep track of all the avatars so we can send them a collision event | ||
82 | // every tick so OpenSim will update its animation. | ||
83 | private HashSet<BSPhysObject> m_avatars = new HashSet<BSPhysObject>(); | ||
92 | 84 | ||
93 | private bool m_initialized = false; | 85 | // List of all the objects that have vehicle properties and should be called |
86 | // to update each physics step. | ||
87 | private List<BSPhysObject> m_vehicles = new List<BSPhysObject>(); | ||
94 | 88 | ||
95 | private int m_detailedStatsStep = 0; | 89 | // let my minuions use my logger |
90 | public ILog Logger { get { return m_log; } } | ||
96 | 91 | ||
97 | public IMesher mesher; | 92 | public IMesher mesher; |
98 | private float m_meshLOD; | 93 | // Level of Detail values kept as float because that's what the Meshmerizer wants |
99 | public float MeshLOD | 94 | public float MeshLOD { get; private set; } |
100 | { | 95 | public float MeshMegaPrimLOD { get; private set; } |
101 | get { return m_meshLOD; } | 96 | public float MeshMegaPrimThreshold { get; private set; } |
102 | } | 97 | public float SculptLOD { get; private set; } |
103 | private float m_sculptLOD; | ||
104 | public float SculptLOD | ||
105 | { | ||
106 | get { return m_sculptLOD; } | ||
107 | } | ||
108 | 98 | ||
109 | private BulletSim m_worldSim; | 99 | public uint WorldID { get; private set; } |
110 | public BulletSim World | 100 | public BulletSim World { get; private set; } |
111 | { | ||
112 | get { return m_worldSim; } | ||
113 | } | ||
114 | private BSConstraintCollection m_constraintCollection; | ||
115 | public BSConstraintCollection Constraints | ||
116 | { | ||
117 | get { return m_constraintCollection; } | ||
118 | } | ||
119 | 101 | ||
102 | // All the constraints that have been allocated in this instance. | ||
103 | public BSConstraintCollection Constraints { get; private set; } | ||
104 | |||
105 | // Simulation parameters | ||
120 | private int m_maxSubSteps; | 106 | private int m_maxSubSteps; |
121 | private float m_fixedTimeStep; | 107 | private float m_fixedTimeStep; |
122 | private long m_simulationStep = 0; | 108 | private long m_simulationStep = 0; |
123 | public long SimulationStep { get { return m_simulationStep; } } | 109 | public long SimulationStep { get { return m_simulationStep; } } |
124 | 110 | private int m_taintsToProcessPerStep; | |
125 | public float LastSimulatedTimestep { get; private set; } | ||
126 | 111 | ||
127 | // A value of the time now so all the collision and update routines do not have to get their own | 112 | // A value of the time now so all the collision and update routines do not have to get their own |
128 | // Set to 'now' just before all the prims and actors are called for collisions and updates | 113 | // Set to 'now' just before all the prims and actors are called for collisions and updates |
129 | private int m_simulationNowTime; | 114 | public int SimulationNowTime { get; private set; } |
130 | public int SimulationNowTime { get { return m_simulationNowTime; } } | 115 | |
116 | // True if initialized and ready to do simulation steps | ||
117 | private bool m_initialized = false; | ||
131 | 118 | ||
119 | // Pinned memory used to pass step information between managed and unmanaged | ||
132 | private int m_maxCollisionsPerFrame; | 120 | private int m_maxCollisionsPerFrame; |
133 | private CollisionDesc[] m_collisionArray; | 121 | private CollisionDesc[] m_collisionArray; |
134 | private GCHandle m_collisionArrayPinnedHandle; | 122 | private GCHandle m_collisionArrayPinnedHandle; |
@@ -137,14 +125,19 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
137 | private EntityProperties[] m_updateArray; | 125 | private EntityProperties[] m_updateArray; |
138 | private GCHandle m_updateArrayPinnedHandle; | 126 | private GCHandle m_updateArrayPinnedHandle; |
139 | 127 | ||
140 | private bool _meshSculptedPrim = true; // cause scuplted prims to get meshed | 128 | public bool ShouldMeshSculptedPrim { get; private set; } // cause scuplted prims to get meshed |
141 | private bool _forceSimplePrimMeshing = false; // if a cube or sphere, let Bullet do internal shapes | 129 | public bool ShouldForceSimplePrimMeshing { get; private set; } // if a cube or sphere, let Bullet do internal shapes |
130 | public bool ShouldUseHullsForPhysicalObjects { get; private set; } // 'true' if should create hulls for physical objects | ||
142 | 131 | ||
143 | public float PID_D { get; private set; } // derivative | 132 | public float PID_D { get; private set; } // derivative |
144 | public float PID_P { get; private set; } // proportional | 133 | public float PID_P { get; private set; } // proportional |
145 | 134 | ||
146 | public const uint TERRAIN_ID = 0; // OpenSim senses terrain with a localID of zero | 135 | public const uint TERRAIN_ID = 0; // OpenSim senses terrain with a localID of zero |
147 | public const uint GROUNDPLANE_ID = 1; | 136 | public const uint GROUNDPLANE_ID = 1; |
137 | public const uint CHILDTERRAIN_ID = 2; // Terrain allocated based on our mega-prim childre start here | ||
138 | |||
139 | private float m_waterLevel; | ||
140 | public BSTerrainManager TerrainManager { get; private set; } | ||
148 | 141 | ||
149 | public ConfigurationParameters Params | 142 | public ConfigurationParameters Params |
150 | { | 143 | { |
@@ -154,13 +147,18 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
154 | { | 147 | { |
155 | get { return new Vector3(0f, 0f, Params.gravity); } | 148 | get { return new Vector3(0f, 0f, Params.gravity); } |
156 | } | 149 | } |
157 | 150 | // Just the Z value of the gravity | |
158 | private float m_maximumObjectMass; | 151 | public float DefaultGravityZ |
159 | public float MaximumObjectMass | ||
160 | { | 152 | { |
161 | get { return m_maximumObjectMass; } | 153 | get { return Params.gravity; } |
162 | } | 154 | } |
163 | 155 | ||
156 | public float MaximumObjectMass { get; private set; } | ||
157 | |||
158 | // When functions in the unmanaged code must be called, it is only | ||
159 | // done at a known time just before the simulation step. The taint | ||
160 | // system saves all these function calls and executes them in | ||
161 | // order before the simulation. | ||
164 | public delegate void TaintCallback(); | 162 | public delegate void TaintCallback(); |
165 | private struct TaintCallbackEntry | 163 | private struct TaintCallbackEntry |
166 | { | 164 | { |
@@ -172,15 +170,17 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
172 | callback = c; | 170 | callback = c; |
173 | } | 171 | } |
174 | } | 172 | } |
173 | private Object _taintLock = new Object(); // lock for using the next object | ||
175 | private List<TaintCallbackEntry> _taintedObjects; | 174 | private List<TaintCallbackEntry> _taintedObjects; |
176 | private Object _taintLock = new Object(); | ||
177 | 175 | ||
178 | // A pointer to an instance if this structure is passed to the C++ code | 176 | // A pointer to an instance if this structure is passed to the C++ code |
177 | // Used to pass basic configuration values to the unmanaged code. | ||
179 | ConfigurationParameters[] m_params; | 178 | ConfigurationParameters[] m_params; |
180 | GCHandle m_paramsHandle; | 179 | GCHandle m_paramsHandle; |
181 | 180 | ||
182 | public bool ShouldDebugLog { get; private set; } | 181 | // Handle to the callback used by the unmanaged code to call into the managed code. |
183 | 182 | // Used for debug logging. | |
183 | // Need to store the handle in a persistant variable so it won't be freed. | ||
184 | private BulletSimAPI.DebugLogCallback m_DebugLogCallbackHandle; | 184 | private BulletSimAPI.DebugLogCallback m_DebugLogCallbackHandle; |
185 | 185 | ||
186 | // Sometimes you just have to log everything. | 186 | // Sometimes you just have to log everything. |
@@ -189,17 +189,24 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
189 | private string m_physicsLoggingDir; | 189 | private string m_physicsLoggingDir; |
190 | private string m_physicsLoggingPrefix; | 190 | private string m_physicsLoggingPrefix; |
191 | private int m_physicsLoggingFileMinutes; | 191 | private int m_physicsLoggingFileMinutes; |
192 | // 'true' of the vehicle code is to log lots of details | ||
193 | public bool VehicleLoggingEnabled { get; private set; } | ||
192 | 194 | ||
193 | private bool m_vehicleLoggingEnabled; | 195 | #region Construction and Initialization |
194 | public bool VehicleLoggingEnabled { get { return m_vehicleLoggingEnabled; } } | ||
195 | |||
196 | public BSScene(string identifier) | 196 | public BSScene(string identifier) |
197 | { | 197 | { |
198 | m_initialized = false; | 198 | m_initialized = false; |
199 | // we are passed the name of the region we're working for. | ||
200 | RegionName = identifier; | ||
199 | } | 201 | } |
200 | 202 | ||
201 | public override void Initialise(IMesher meshmerizer, IConfigSource config) | 203 | public override void Initialise(IMesher meshmerizer, IConfigSource config) |
202 | { | 204 | { |
205 | mesher = meshmerizer; | ||
206 | _taintedObjects = new List<TaintCallbackEntry>(); | ||
207 | PhysObjects = new Dictionary<uint, BSPhysObject>(); | ||
208 | Shapes = new BSShapeCollection(this); | ||
209 | |||
203 | // Allocate pinned memory to pass parameters. | 210 | // Allocate pinned memory to pass parameters. |
204 | m_params = new ConfigurationParameters[1]; | 211 | m_params = new ConfigurationParameters[1]; |
205 | m_paramsHandle = GCHandle.Alloc(m_params, GCHandleType.Pinned); | 212 | m_paramsHandle = GCHandle.Alloc(m_params, GCHandleType.Pinned); |
@@ -215,7 +222,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
215 | 222 | ||
216 | // Enable very detailed logging. | 223 | // Enable very detailed logging. |
217 | // By creating an empty logger when not logging, the log message invocation code | 224 | // By creating an empty logger when not logging, the log message invocation code |
218 | // can be left in and every call doesn't have to check for null. | 225 | // can be left in and every call doesn't have to check for null. |
219 | if (m_physicsLoggingEnabled) | 226 | if (m_physicsLoggingEnabled) |
220 | { | 227 | { |
221 | PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes); | 228 | PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes); |
@@ -225,38 +232,43 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
225 | PhysicsLogging = new Logging.LogWriter(); | 232 | PhysicsLogging = new Logging.LogWriter(); |
226 | } | 233 | } |
227 | 234 | ||
228 | // Get the version of the DLL | 235 | // If Debug logging level, enable logging from the unmanaged code |
229 | // TODO: this doesn't work yet. Something wrong with marshaling the returned string. | 236 | m_DebugLogCallbackHandle = null; |
230 | // BulletSimVersion = BulletSimAPI.GetVersion(); | ||
231 | // m_log.WarnFormat("{0}: BulletSim.dll version='{1}'", LogHeader, BulletSimVersion); | ||
232 | |||
233 | // if Debug, enable logging from the unmanaged code | ||
234 | if (m_log.IsDebugEnabled || PhysicsLogging.Enabled) | 237 | if (m_log.IsDebugEnabled || PhysicsLogging.Enabled) |
235 | { | 238 | { |
236 | m_log.DebugFormat("{0}: Initialize: Setting debug callback for unmanaged code", LogHeader); | 239 | m_log.DebugFormat("{0}: Initialize: Setting debug callback for unmanaged code", LogHeader); |
237 | if (PhysicsLogging.Enabled) | 240 | if (PhysicsLogging.Enabled) |
241 | // The handle is saved in a variable to make sure it doesn't get freed after this call | ||
238 | m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLoggerPhysLog); | 242 | m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLoggerPhysLog); |
239 | else | 243 | else |
240 | m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLogger); | 244 | m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLogger); |
241 | // the handle is saved in a variable to make sure it doesn't get freed after this call | ||
242 | BulletSimAPI.SetDebugLogCallback(m_DebugLogCallbackHandle); | ||
243 | } | 245 | } |
244 | 246 | ||
245 | _taintedObjects = new List<TaintCallbackEntry>(); | 247 | // Get the version of the DLL |
248 | // TODO: this doesn't work yet. Something wrong with marshaling the returned string. | ||
249 | // BulletSimVersion = BulletSimAPI.GetVersion(); | ||
250 | // m_log.WarnFormat("{0}: BulletSim.dll version='{1}'", LogHeader, BulletSimVersion); | ||
246 | 251 | ||
247 | mesher = meshmerizer; | 252 | // The bounding box for the simulated world. The origin is 0,0,0 unless we're |
248 | // The bounding box for the simulated world | 253 | // a child in a mega-region. |
249 | Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, 8192f); | 254 | // Bullet actually doesn't care about the extents of the simulated |
255 | // area. It tracks active objects no matter where they are. | ||
256 | Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight); | ||
250 | 257 | ||
251 | // m_log.DebugFormat("{0}: Initialize: Calling BulletSimAPI.Initialize.", LogHeader); | 258 | // m_log.DebugFormat("{0}: Initialize: Calling BulletSimAPI.Initialize.", LogHeader); |
252 | m_worldID = BulletSimAPI.Initialize(worldExtent, m_paramsHandle.AddrOfPinnedObject(), | 259 | WorldID = BulletSimAPI.Initialize(worldExtent, m_paramsHandle.AddrOfPinnedObject(), |
253 | m_maxCollisionsPerFrame, m_collisionArrayPinnedHandle.AddrOfPinnedObject(), | 260 | m_maxCollisionsPerFrame, m_collisionArrayPinnedHandle.AddrOfPinnedObject(), |
254 | m_maxUpdatesPerFrame, m_updateArrayPinnedHandle.AddrOfPinnedObject()); | 261 | m_maxUpdatesPerFrame, m_updateArrayPinnedHandle.AddrOfPinnedObject(), |
262 | m_DebugLogCallbackHandle); | ||
255 | 263 | ||
256 | // Initialization to support the transition to a new API which puts most of the logic | 264 | // Initialization to support the transition to a new API which puts most of the logic |
257 | // into the C# code so it is easier to modify and add to. | 265 | // into the C# code so it is easier to modify and add to. |
258 | m_worldSim = new BulletSim(m_worldID, this, BulletSimAPI.GetSimHandle2(m_worldID)); | 266 | World = new BulletSim(WorldID, this, BulletSimAPI.GetSimHandle2(WorldID)); |
259 | m_constraintCollection = new BSConstraintCollection(World); | 267 | |
268 | Constraints = new BSConstraintCollection(World); | ||
269 | |||
270 | TerrainManager = new BSTerrainManager(this); | ||
271 | TerrainManager.CreateInitialGroundPlaneAndTerrain(); | ||
260 | 272 | ||
261 | m_initialized = true; | 273 | m_initialized = true; |
262 | } | 274 | } |
@@ -281,10 +293,13 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
281 | // Very detailed logging for physics debugging | 293 | // Very detailed logging for physics debugging |
282 | m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false); | 294 | m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false); |
283 | m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", "."); | 295 | m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", "."); |
284 | m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-"); | 296 | m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-%REGIONNAME%-"); |
285 | m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5); | 297 | m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5); |
286 | // Very detailed logging for vehicle debugging | 298 | // Very detailed logging for vehicle debugging |
287 | m_vehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false); | 299 | VehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false); |
300 | |||
301 | // Do any replacements in the parameters | ||
302 | m_physicsLoggingPrefix = m_physicsLoggingPrefix.Replace("%REGIONNAME%", RegionName); | ||
288 | } | 303 | } |
289 | } | 304 | } |
290 | } | 305 | } |
@@ -309,12 +324,50 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
309 | { | 324 | { |
310 | m_log.Debug("[BULLETS UNMANAGED]:" + msg); | 325 | m_log.Debug("[BULLETS UNMANAGED]:" + msg); |
311 | } | 326 | } |
312 | 327 | ||
313 | // Called directly from unmanaged code so don't do much | 328 | // Called directly from unmanaged code so don't do much |
314 | private void BulletLoggerPhysLog(string msg) | 329 | private void BulletLoggerPhysLog(string msg) |
315 | { | 330 | { |
316 | PhysicsLogging.Write("[BULLETS UNMANAGED]:" + msg); | 331 | DetailLog("[BULLETS UNMANAGED]:" + msg); |
332 | } | ||
333 | |||
334 | public override void Dispose() | ||
335 | { | ||
336 | // m_log.DebugFormat("{0}: Dispose()", LogHeader); | ||
337 | |||
338 | // make sure no stepping happens while we're deleting stuff | ||
339 | m_initialized = false; | ||
340 | |||
341 | TerrainManager.ReleaseGroundPlaneAndTerrain(); | ||
342 | |||
343 | foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects) | ||
344 | { | ||
345 | kvp.Value.Destroy(); | ||
346 | } | ||
347 | PhysObjects.Clear(); | ||
348 | |||
349 | // Now that the prims are all cleaned up, there should be no constraints left | ||
350 | if (Constraints != null) | ||
351 | { | ||
352 | Constraints.Dispose(); | ||
353 | Constraints = null; | ||
354 | } | ||
355 | |||
356 | if (Shapes != null) | ||
357 | { | ||
358 | Shapes.Dispose(); | ||
359 | Shapes = null; | ||
360 | } | ||
361 | |||
362 | // Anything left in the unmanaged code should be cleaned out | ||
363 | BulletSimAPI.Shutdown(WorldID); | ||
364 | |||
365 | // Not logging any more | ||
366 | PhysicsLogging.Close(); | ||
317 | } | 367 | } |
368 | #endregion // Construction and Initialization | ||
369 | |||
370 | #region Prim and Avatar addition and removal | ||
318 | 371 | ||
319 | public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying) | 372 | public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying) |
320 | { | 373 | { |
@@ -329,7 +382,13 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
329 | if (!m_initialized) return null; | 382 | if (!m_initialized) return null; |
330 | 383 | ||
331 | BSCharacter actor = new BSCharacter(localID, avName, this, position, size, isFlying); | 384 | BSCharacter actor = new BSCharacter(localID, avName, this, position, size, isFlying); |
332 | lock (m_avatars) m_avatars.Add(localID, actor); | 385 | lock (PhysObjects) PhysObjects.Add(localID, actor); |
386 | |||
387 | // TODO: Remove kludge someday. | ||
388 | // We must generate a collision for avatars whether they collide or not. | ||
389 | // This is required by OpenSim to update avatar animations, etc. | ||
390 | lock (m_avatars) m_avatars.Add(actor); | ||
391 | |||
333 | return actor; | 392 | return actor; |
334 | } | 393 | } |
335 | 394 | ||
@@ -344,7 +403,9 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
344 | { | 403 | { |
345 | try | 404 | try |
346 | { | 405 | { |
347 | lock (m_avatars) m_avatars.Remove(actor.LocalID); | 406 | lock (PhysObjects) PhysObjects.Remove(actor.LocalID); |
407 | // Remove kludge someday | ||
408 | lock (m_avatars) m_avatars.Remove(bsactor); | ||
348 | } | 409 | } |
349 | catch (Exception e) | 410 | catch (Exception e) |
350 | { | 411 | { |
@@ -362,11 +423,11 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
362 | BSPrim bsprim = prim as BSPrim; | 423 | BSPrim bsprim = prim as BSPrim; |
363 | if (bsprim != null) | 424 | if (bsprim != null) |
364 | { | 425 | { |
365 | // DetailLog("{0},RemovePrim,call", bsprim.LocalID); | 426 | DetailLog("{0},RemovePrim,call", bsprim.LocalID); |
366 | // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID); | 427 | // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID); |
367 | try | 428 | try |
368 | { | 429 | { |
369 | lock (m_prims) m_prims.Remove(bsprim.LocalID); | 430 | lock (PhysObjects) PhysObjects.Remove(bsprim.LocalID); |
370 | } | 431 | } |
371 | catch (Exception e) | 432 | catch (Exception e) |
372 | { | 433 | { |
@@ -388,18 +449,21 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
388 | 449 | ||
389 | if (!m_initialized) return null; | 450 | if (!m_initialized) return null; |
390 | 451 | ||
391 | // DetailLog("{0},AddPrimShape,call", localID); | 452 | DetailLog("{0},AddPrimShape,call", localID); |
392 | 453 | ||
393 | BSPrim prim = new BSPrim(localID, primName, this, position, size, rotation, pbs, isPhysical); | 454 | BSPrim prim = new BSPrim(localID, primName, this, position, size, rotation, pbs, isPhysical); |
394 | lock (m_prims) m_prims.Add(localID, prim); | 455 | lock (PhysObjects) PhysObjects.Add(localID, prim); |
395 | return prim; | 456 | return prim; |
396 | } | 457 | } |
397 | 458 | ||
398 | // This is a call from the simulator saying that some physical property has been updated. | 459 | // This is a call from the simulator saying that some physical property has been updated. |
399 | // The BulletSim driver senses the changing of relevant properties so this taint | 460 | // The BulletSim driver senses the changing of relevant properties so this taint |
400 | // information call is not needed. | 461 | // information call is not needed. |
401 | public override void AddPhysicsActorTaint(PhysicsActor prim) { } | 462 | public override void AddPhysicsActorTaint(PhysicsActor prim) { } |
402 | 463 | ||
464 | #endregion // Prim and Avatar addition and removal | ||
465 | |||
466 | #region Simulation | ||
403 | // Simulate one timestep | 467 | // Simulate one timestep |
404 | public override float Simulate(float timeStep) | 468 | public override float Simulate(float timeStep) |
405 | { | 469 | { |
@@ -408,34 +472,46 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
408 | int collidersCount = 0; | 472 | int collidersCount = 0; |
409 | IntPtr collidersPtr; | 473 | IntPtr collidersPtr; |
410 | 474 | ||
411 | LastSimulatedTimestep = timeStep; | 475 | int beforeTime = 0; |
476 | int simTime = 0; | ||
412 | 477 | ||
413 | // prevent simulation until we've been initialized | 478 | // prevent simulation until we've been initialized |
414 | if (!m_initialized) return 10.0f; | 479 | if (!m_initialized) return 5.0f; |
415 | |||
416 | int simulateStartTime = Util.EnvironmentTickCount(); | ||
417 | 480 | ||
418 | // update the prim states while we know the physics engine is not busy | 481 | // update the prim states while we know the physics engine is not busy |
482 | int numTaints = _taintedObjects.Count; | ||
419 | ProcessTaints(); | 483 | ProcessTaints(); |
420 | 484 | ||
421 | // Some of the prims operate with special vehicle properties | 485 | // Some of the prims operate with special vehicle properties |
422 | ProcessVehicles(timeStep); | 486 | ProcessVehicles(timeStep); |
487 | numTaints += _taintedObjects.Count; | ||
423 | ProcessTaints(); // the vehicles might have added taints | 488 | ProcessTaints(); // the vehicles might have added taints |
424 | 489 | ||
425 | // step the physical world one interval | 490 | // step the physical world one interval |
426 | m_simulationStep++; | 491 | m_simulationStep++; |
427 | int numSubSteps = 0; | 492 | int numSubSteps = 0; |
493 | |||
494 | // DEBUG | ||
495 | // DetailLog("{0},BSScene.Simulate,beforeStep,ntaimts={1},step={2}", DetailLogZero, numTaints, m_simulationStep); | ||
496 | |||
428 | try | 497 | try |
429 | { | 498 | { |
430 | numSubSteps = BulletSimAPI.PhysicsStep(m_worldID, timeStep, m_maxSubSteps, m_fixedTimeStep, | 499 | if (PhysicsLogging.Enabled) beforeTime = Util.EnvironmentTickCount(); |
500 | |||
501 | numSubSteps = BulletSimAPI.PhysicsStep(WorldID, timeStep, m_maxSubSteps, m_fixedTimeStep, | ||
431 | out updatedEntityCount, out updatedEntitiesPtr, out collidersCount, out collidersPtr); | 502 | out updatedEntityCount, out updatedEntitiesPtr, out collidersCount, out collidersPtr); |
432 | // DetailLog("{0},Simulate,call, substeps={1}, updates={2}, colliders={3}", DetailLogZero, numSubSteps, updatedEntityCount, collidersCount); | 503 | |
504 | if (PhysicsLogging.Enabled) simTime = Util.EnvironmentTickCountSubtract(beforeTime); | ||
505 | DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}", | ||
506 | DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps, updatedEntityCount, collidersCount); | ||
433 | } | 507 | } |
434 | catch (Exception e) | 508 | catch (Exception e) |
435 | { | 509 | { |
436 | m_log.WarnFormat("{0},PhysicsStep Exception: substeps={1}, updates={2}, colliders={3}, e={4}", LogHeader, numSubSteps, updatedEntityCount, collidersCount, e); | 510 | m_log.WarnFormat("{0},PhysicsStep Exception: nTaints={1}, substeps={2}, updates={3}, colliders={4}, e={5}", |
437 | // DetailLog("{0},PhysicsStepException,call, substeps={1}, updates={2}, colliders={3}", DetailLogZero, numSubSteps, updatedEntityCount, collidersCount); | 511 | LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e); |
438 | // updatedEntityCount = 0; | 512 | DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}", |
513 | DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount); | ||
514 | updatedEntityCount = 0; | ||
439 | collidersCount = 0; | 515 | collidersCount = 0; |
440 | } | 516 | } |
441 | 517 | ||
@@ -443,7 +519,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
443 | // Don't have to use the pointers passed back since we know it is the same pinned memory we passed in | 519 | // Don't have to use the pointers passed back since we know it is the same pinned memory we passed in |
444 | 520 | ||
445 | // Get a value for 'now' so all the collision and update routines don't have to get their own | 521 | // Get a value for 'now' so all the collision and update routines don't have to get their own |
446 | m_simulationNowTime = Util.EnvironmentTickCount(); | 522 | SimulationNowTime = Util.EnvironmentTickCount(); |
447 | 523 | ||
448 | // If there were collisions, process them by sending the event to the prim. | 524 | // If there were collisions, process them by sending the event to the prim. |
449 | // Collisions must be processed before updates. | 525 | // Collisions must be processed before updates. |
@@ -460,21 +536,34 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
460 | } | 536 | } |
461 | } | 537 | } |
462 | 538 | ||
539 | // This is a kludge to get avatar movement updates. | ||
540 | // the simulator expects collisions for avatars even if there are have been no collisions. This updates | ||
541 | // avatar animations and stuff. | ||
542 | // If you fix avatar animation updates, remove this overhead and let normal collision processing happen. | ||
543 | foreach (BSPhysObject bsp in m_avatars) | ||
544 | bsp.SendCollisions(); | ||
545 | |||
463 | // The above SendCollision's batch up the collisions on the objects. | 546 | // The above SendCollision's batch up the collisions on the objects. |
464 | // Now push the collisions into the simulator. | 547 | // Now push the collisions into the simulator. |
465 | foreach (BSPrim bsp in m_primsWithCollisions) | 548 | if (ObjectsWithCollisions.Count > 0) |
466 | bsp.SendCollisions(); | 549 | { |
467 | m_primsWithCollisions.Clear(); | 550 | foreach (BSPhysObject bsp in ObjectsWithCollisions) |
551 | if (!m_avatars.Contains(bsp)) // don't call avatars twice | ||
552 | if (!bsp.SendCollisions()) | ||
553 | { | ||
554 | // If the object is done colliding, see that it's removed from the colliding list | ||
555 | ObjectsWithNoMoreCollisions.Add(bsp); | ||
556 | } | ||
557 | } | ||
468 | 558 | ||
469 | // This is a kludge to get avatar movement updated. | 559 | // Objects that are done colliding are removed from the ObjectsWithCollisions list. |
470 | // Don't send collisions only if there were collisions -- send everytime. | 560 | // Not done above because it is inside an iteration of ObjectWithCollisions. |
471 | // ODE sends collisions even if there are none and this is used to update | 561 | if (ObjectsWithNoMoreCollisions.Count > 0) |
472 | // avatar animations and stuff. | 562 | { |
473 | // foreach (BSCharacter bsc in m_avatarsWithCollisions) | 563 | foreach (BSPhysObject po in ObjectsWithNoMoreCollisions) |
474 | // bsc.SendCollisions(); | 564 | ObjectsWithCollisions.Remove(po); |
475 | foreach (KeyValuePair<uint, BSCharacter> kvp in m_avatars) | 565 | ObjectsWithNoMoreCollisions.Clear(); |
476 | kvp.Value.SendCollisions(); | 566 | } |
477 | m_avatarsWithCollisions.Clear(); | ||
478 | 567 | ||
479 | // If any of the objects had updated properties, tell the object it has been changed by the physics engine | 568 | // If any of the objects had updated properties, tell the object it has been changed by the physics engine |
480 | if (updatedEntityCount > 0) | 569 | if (updatedEntityCount > 0) |
@@ -482,145 +571,98 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
482 | for (int ii = 0; ii < updatedEntityCount; ii++) | 571 | for (int ii = 0; ii < updatedEntityCount; ii++) |
483 | { | 572 | { |
484 | EntityProperties entprop = m_updateArray[ii]; | 573 | EntityProperties entprop = m_updateArray[ii]; |
485 | BSPrim prim; | 574 | BSPhysObject pobj; |
486 | if (m_prims.TryGetValue(entprop.ID, out prim)) | 575 | if (PhysObjects.TryGetValue(entprop.ID, out pobj)) |
487 | { | ||
488 | prim.UpdateProperties(entprop); | ||
489 | continue; | ||
490 | } | ||
491 | BSCharacter actor; | ||
492 | if (m_avatars.TryGetValue(entprop.ID, out actor)) | ||
493 | { | 576 | { |
494 | actor.UpdateProperties(entprop); | 577 | pobj.UpdateProperties(entprop); |
495 | continue; | ||
496 | } | 578 | } |
497 | } | 579 | } |
498 | } | 580 | } |
499 | 581 | ||
500 | // If enabled, call into the physics engine to dump statistics | 582 | // The physics engine returns the number of milliseconds it simulated this call. |
501 | if (m_detailedStatsStep > 0) | 583 | // These are summed and normalized to one second and divided by 1000 to give the reported physics FPS. |
502 | { | 584 | // We multiply by 45 to give a recognizable running rate (45 or less). |
503 | if ((m_simulationStep % m_detailedStatsStep) == 0) | 585 | return numSubSteps * m_fixedTimeStep * 1000 * 45; |
504 | { | 586 | // return timeStep * 1000 * 45; |
505 | BulletSimAPI.DumpBulletStatistics(); | ||
506 | } | ||
507 | } | ||
508 | |||
509 | // this is a waste since the outside routine also calcuates the physics simulation | ||
510 | // period. TODO: There should be a way of computing physics frames from simulator computation. | ||
511 | // long simulateTotalTime = Util.EnvironmentTickCountSubtract(simulateStartTime); | ||
512 | // return (timeStep * (float)simulateTotalTime); | ||
513 | |||
514 | // TODO: FIX THIS: fps calculation possibly wrong. | ||
515 | // This calculation says 1/timeStep is the ideal frame rate. Any time added to | ||
516 | // that by the physics simulation gives a slower frame rate. | ||
517 | long totalSimulationTime = Util.EnvironmentTickCountSubtract(simulateStartTime); | ||
518 | if (totalSimulationTime >= timeStep) | ||
519 | return 0; | ||
520 | return 1f / (timeStep + totalSimulationTime); | ||
521 | } | 587 | } |
522 | 588 | ||
523 | // Something has collided | 589 | // Something has collided |
524 | private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penitration) | 590 | private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penetration) |
525 | { | 591 | { |
526 | if (localID == TERRAIN_ID || localID == GROUNDPLANE_ID) | 592 | if (localID <= TerrainManager.HighestTerrainID) |
527 | { | 593 | { |
528 | return; // don't send collisions to the terrain | 594 | return; // don't send collisions to the terrain |
529 | } | 595 | } |
530 | 596 | ||
531 | ActorTypes type = ActorTypes.Prim; | 597 | BSPhysObject collider; |
532 | if (collidingWith == TERRAIN_ID || collidingWith == GROUNDPLANE_ID) | 598 | if (!PhysObjects.TryGetValue(localID, out collider)) |
533 | type = ActorTypes.Ground; | 599 | { |
534 | else if (m_avatars.ContainsKey(collidingWith)) | 600 | // If the object that is colliding cannot be found, just ignore the collision. |
535 | type = ActorTypes.Agent; | 601 | DetailLog("{0},BSScene.SendCollision,colliderNotInObjectList,id={1},with={2}", DetailLogZero, localID, collidingWith); |
536 | |||
537 | BSPrim prim; | ||
538 | if (m_prims.TryGetValue(localID, out prim)) { | ||
539 | prim.Collide(collidingWith, type, collidePoint, collideNormal, penitration); | ||
540 | m_primsWithCollisions.Add(prim); | ||
541 | return; | 602 | return; |
542 | } | 603 | } |
543 | BSCharacter actor; | 604 | |
544 | if (m_avatars.TryGetValue(localID, out actor)) { | 605 | // The terrain is not in the physical object list so 'collidee' can be null when Collide() is called. |
545 | actor.Collide(collidingWith, type, collidePoint, collideNormal, penitration); | 606 | BSPhysObject collidee = null; |
546 | m_avatarsWithCollisions.Add(actor); | 607 | PhysObjects.TryGetValue(collidingWith, out collidee); |
547 | return; | 608 | |
609 | // DetailLog("{0},BSScene.SendCollision,collide,id={1},with={2}", DetailLogZero, localID, collidingWith); | ||
610 | |||
611 | if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration)) | ||
612 | { | ||
613 | // If a collision was posted, remember to send it to the simulator | ||
614 | ObjectsWithCollisions.Add(collider); | ||
548 | } | 615 | } |
616 | |||
549 | return; | 617 | return; |
550 | } | 618 | } |
551 | 619 | ||
552 | public override void GetResults() { } | 620 | #endregion // Simulation |
553 | 621 | ||
554 | public override void SetTerrain(float[] heightMap) { | 622 | public override void GetResults() { } |
555 | m_heightMap = heightMap; | ||
556 | this.TaintedObject("BSScene.SetTerrain", delegate() | ||
557 | { | ||
558 | BulletSimAPI.SetHeightmap(m_worldID, m_heightMap); | ||
559 | }); | ||
560 | } | ||
561 | 623 | ||
562 | // Someday we will have complex terrain with caves and tunnels | 624 | #region Terrain |
563 | // For the moment, it's flat and convex | ||
564 | public float GetTerrainHeightAtXYZ(Vector3 loc) | ||
565 | { | ||
566 | return GetTerrainHeightAtXY(loc.X, loc.Y); | ||
567 | } | ||
568 | 625 | ||
569 | public float GetTerrainHeightAtXY(float tX, float tY) | 626 | public override void SetTerrain(float[] heightMap) { |
570 | { | 627 | TerrainManager.SetTerrain(heightMap); |
571 | if (tX < 0 || tX >= Constants.RegionSize || tY < 0 || tY >= Constants.RegionSize) | ||
572 | return 30; | ||
573 | return m_heightMap[((int)tX) * Constants.RegionSize + ((int)tY)]; | ||
574 | } | 628 | } |
575 | 629 | ||
576 | public override void SetWaterLevel(float baseheight) | 630 | public override void SetWaterLevel(float baseheight) |
577 | { | 631 | { |
578 | m_waterLevel = baseheight; | 632 | m_waterLevel = baseheight; |
579 | // TODO: pass to physics engine so things will float? | ||
580 | } | 633 | } |
581 | public float GetWaterLevel() | 634 | // Someday.... |
635 | public float GetWaterLevelAtXYZ(Vector3 loc) | ||
582 | { | 636 | { |
583 | return m_waterLevel; | 637 | return m_waterLevel; |
584 | } | 638 | } |
585 | 639 | ||
586 | public override void DeleteTerrain() | 640 | public override void DeleteTerrain() |
587 | { | 641 | { |
588 | // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader); | 642 | // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader); |
589 | } | 643 | } |
590 | 644 | ||
591 | public override void Dispose() | 645 | // Although no one seems to check this, I do support combining. |
646 | public override bool SupportsCombining() | ||
592 | { | 647 | { |
593 | // m_log.DebugFormat("{0}: Dispose()", LogHeader); | 648 | return TerrainManager.SupportsCombining(); |
594 | 649 | } | |
595 | // make sure no stepping happens while we're deleting stuff | 650 | // This call says I am a child to region zero in a mega-region. 'pScene' is that |
596 | m_initialized = false; | 651 | // of region zero, 'offset' is my offset from regions zero's origin, and |
597 | 652 | // 'extents' is the largest XY that is handled in my region. | |
598 | foreach (KeyValuePair<uint, BSCharacter> kvp in m_avatars) | 653 | public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents) |
599 | { | 654 | { |
600 | kvp.Value.Destroy(); | 655 | TerrainManager.Combine(pScene, offset, extents); |
601 | } | 656 | } |
602 | m_avatars.Clear(); | ||
603 | |||
604 | foreach (KeyValuePair<uint, BSPrim> kvp in m_prims) | ||
605 | { | ||
606 | kvp.Value.Destroy(); | ||
607 | } | ||
608 | m_prims.Clear(); | ||
609 | |||
610 | // Now that the prims are all cleaned up, there should be no constraints left | ||
611 | if (m_constraintCollection != null) | ||
612 | { | ||
613 | m_constraintCollection.Dispose(); | ||
614 | m_constraintCollection = null; | ||
615 | } | ||
616 | |||
617 | // Anything left in the unmanaged code should be cleaned out | ||
618 | BulletSimAPI.Shutdown(WorldID); | ||
619 | 657 | ||
620 | // Not logging any more | 658 | // Unhook all the combining that I know about. |
621 | PhysicsLogging.Close(); | 659 | public override void UnCombine(PhysicsScene pScene) |
660 | { | ||
661 | TerrainManager.UnCombine(pScene); | ||
622 | } | 662 | } |
623 | 663 | ||
664 | #endregion // Terrain | ||
665 | |||
624 | public override Dictionary<uint, float> GetTopColliders() | 666 | public override Dictionary<uint, float> GetTopColliders() |
625 | { | 667 | { |
626 | return new Dictionary<uint, float>(); | 668 | return new Dictionary<uint, float>(); |
@@ -628,121 +670,6 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
628 | 670 | ||
629 | public override bool IsThreaded { get { return false; } } | 671 | public override bool IsThreaded { get { return false; } } |
630 | 672 | ||
631 | /// <summary> | ||
632 | /// Routine to figure out if we need to mesh this prim with our mesher | ||
633 | /// </summary> | ||
634 | /// <param name="pbs"></param> | ||
635 | /// <returns>true if the prim needs meshing</returns> | ||
636 | public bool NeedsMeshing(PrimitiveBaseShape pbs) | ||
637 | { | ||
638 | // most of this is redundant now as the mesher will return null if it cant mesh a prim | ||
639 | // but we still need to check for sculptie meshing being enabled so this is the most | ||
640 | // convenient place to do it for now... | ||
641 | |||
642 | // int iPropertiesNotSupportedDefault = 0; | ||
643 | |||
644 | if (pbs.SculptEntry && !_meshSculptedPrim) | ||
645 | { | ||
646 | // Render sculpties as boxes | ||
647 | return false; | ||
648 | } | ||
649 | |||
650 | // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since Bullet | ||
651 | // can use an internal representation for the prim | ||
652 | if (!_forceSimplePrimMeshing) | ||
653 | { | ||
654 | if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight) | ||
655 | || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 | ||
656 | && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z)) | ||
657 | { | ||
658 | |||
659 | if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0 | ||
660 | && pbs.ProfileHollow == 0 | ||
661 | && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0 | ||
662 | && pbs.PathBegin == 0 && pbs.PathEnd == 0 | ||
663 | && pbs.PathTaperX == 0 && pbs.PathTaperY == 0 | ||
664 | && pbs.PathScaleX == 100 && pbs.PathScaleY == 100 | ||
665 | && pbs.PathShearX == 0 && pbs.PathShearY == 0) | ||
666 | { | ||
667 | return false; | ||
668 | } | ||
669 | } | ||
670 | } | ||
671 | |||
672 | /* TODO: verify that the mesher will now do all these shapes | ||
673 | if (pbs.ProfileHollow != 0) | ||
674 | iPropertiesNotSupportedDefault++; | ||
675 | |||
676 | if ((pbs.PathBegin != 0) || pbs.PathEnd != 0) | ||
677 | iPropertiesNotSupportedDefault++; | ||
678 | |||
679 | if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0)) | ||
680 | iPropertiesNotSupportedDefault++; | ||
681 | |||
682 | if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0) | ||
683 | iPropertiesNotSupportedDefault++; | ||
684 | |||
685 | if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100)) | ||
686 | iPropertiesNotSupportedDefault++; | ||
687 | |||
688 | if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0)) | ||
689 | iPropertiesNotSupportedDefault++; | ||
690 | |||
691 | if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight) | ||
692 | iPropertiesNotSupportedDefault++; | ||
693 | |||
694 | 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)) | ||
695 | iPropertiesNotSupportedDefault++; | ||
696 | |||
697 | if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1) | ||
698 | iPropertiesNotSupportedDefault++; | ||
699 | |||
700 | // test for torus | ||
701 | if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square) | ||
702 | { | ||
703 | if (pbs.PathCurve == (byte)Extrusion.Curve1) | ||
704 | { | ||
705 | iPropertiesNotSupportedDefault++; | ||
706 | } | ||
707 | } | ||
708 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle) | ||
709 | { | ||
710 | if (pbs.PathCurve == (byte)Extrusion.Straight) | ||
711 | { | ||
712 | iPropertiesNotSupportedDefault++; | ||
713 | } | ||
714 | // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits | ||
715 | else if (pbs.PathCurve == (byte)Extrusion.Curve1) | ||
716 | { | ||
717 | iPropertiesNotSupportedDefault++; | ||
718 | } | ||
719 | } | ||
720 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle) | ||
721 | { | ||
722 | if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2) | ||
723 | { | ||
724 | iPropertiesNotSupportedDefault++; | ||
725 | } | ||
726 | } | ||
727 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle) | ||
728 | { | ||
729 | if (pbs.PathCurve == (byte)Extrusion.Straight) | ||
730 | { | ||
731 | iPropertiesNotSupportedDefault++; | ||
732 | } | ||
733 | else if (pbs.PathCurve == (byte)Extrusion.Curve1) | ||
734 | { | ||
735 | iPropertiesNotSupportedDefault++; | ||
736 | } | ||
737 | } | ||
738 | if (iPropertiesNotSupportedDefault == 0) | ||
739 | { | ||
740 | return false; | ||
741 | } | ||
742 | */ | ||
743 | return true; | ||
744 | } | ||
745 | |||
746 | // Calls to the PhysicsActors can't directly call into the physics engine | 673 | // Calls to the PhysicsActors can't directly call into the physics engine |
747 | // because it might be busy. We delay changes to a known time. | 674 | // because it might be busy. We delay changes to a known time. |
748 | // We rely on C#'s closure to save and restore the context for the delegate. | 675 | // We rely on C#'s closure to save and restore the context for the delegate. |
@@ -751,7 +678,10 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
751 | if (!m_initialized) return; | 678 | if (!m_initialized) return; |
752 | 679 | ||
753 | lock (_taintLock) | 680 | lock (_taintLock) |
681 | { | ||
754 | _taintedObjects.Add(new TaintCallbackEntry(ident, callback)); | 682 | _taintedObjects.Add(new TaintCallbackEntry(ident, callback)); |
683 | } | ||
684 | |||
755 | return; | 685 | return; |
756 | } | 686 | } |
757 | 687 | ||
@@ -763,6 +693,35 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
763 | if (_taintedObjects.Count > 0) // save allocating new list if there is nothing to process | 693 | if (_taintedObjects.Count > 0) // save allocating new list if there is nothing to process |
764 | { | 694 | { |
765 | // swizzle a new list into the list location so we can process what's there | 695 | // swizzle a new list into the list location so we can process what's there |
696 | int taintCount = m_taintsToProcessPerStep; | ||
697 | TaintCallbackEntry oneCallback = new TaintCallbackEntry(); | ||
698 | while (_taintedObjects.Count > 0 && taintCount-- > 0) | ||
699 | { | ||
700 | bool gotOne = false; | ||
701 | lock (_taintLock) | ||
702 | { | ||
703 | if (_taintedObjects.Count > 0) | ||
704 | { | ||
705 | oneCallback = _taintedObjects[0]; | ||
706 | _taintedObjects.RemoveAt(0); | ||
707 | gotOne = true; | ||
708 | } | ||
709 | } | ||
710 | if (gotOne) | ||
711 | { | ||
712 | try | ||
713 | { | ||
714 | DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, oneCallback.ident); // DEBUG DEBUG DEBUG | ||
715 | oneCallback.callback(); | ||
716 | } | ||
717 | catch (Exception e) | ||
718 | { | ||
719 | m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, oneCallback.ident, e); | ||
720 | } | ||
721 | } | ||
722 | } | ||
723 | /* | ||
724 | // swizzle a new list into the list location so we can process what's there | ||
766 | List<TaintCallbackEntry> oldList; | 725 | List<TaintCallbackEntry> oldList; |
767 | lock (_taintLock) | 726 | lock (_taintLock) |
768 | { | 727 | { |
@@ -774,6 +733,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
774 | { | 733 | { |
775 | try | 734 | try |
776 | { | 735 | { |
736 | DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG | ||
777 | tcbe.callback(); | 737 | tcbe.callback(); |
778 | } | 738 | } |
779 | catch (Exception e) | 739 | catch (Exception e) |
@@ -782,6 +742,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
782 | } | 742 | } |
783 | } | 743 | } |
784 | oldList.Clear(); | 744 | oldList.Clear(); |
745 | */ | ||
785 | } | 746 | } |
786 | } | 747 | } |
787 | 748 | ||
@@ -789,13 +750,10 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
789 | 750 | ||
790 | public void VehicleInSceneTypeChanged(BSPrim vehic, Vehicle newType) | 751 | public void VehicleInSceneTypeChanged(BSPrim vehic, Vehicle newType) |
791 | { | 752 | { |
792 | if (newType == Vehicle.TYPE_NONE) | 753 | RemoveVehiclePrim(vehic); |
793 | { | 754 | if (newType != Vehicle.TYPE_NONE) |
794 | RemoveVehiclePrim(vehic); | ||
795 | } | ||
796 | else | ||
797 | { | 755 | { |
798 | // make it so the scene will call us each tick to do vehicle things | 756 | // make it so the scene will call us each tick to do vehicle things |
799 | AddVehiclePrim(vehic); | 757 | AddVehiclePrim(vehic); |
800 | } | 758 | } |
801 | } | 759 | } |
@@ -827,17 +785,17 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
827 | } | 785 | } |
828 | 786 | ||
829 | // Some prims have extra vehicle actions | 787 | // Some prims have extra vehicle actions |
830 | // no locking because only called when physics engine is not busy | 788 | // Called at taint time! |
831 | private void ProcessVehicles(float timeStep) | 789 | private void ProcessVehicles(float timeStep) |
832 | { | 790 | { |
833 | foreach (BSPrim prim in m_vehicles) | 791 | foreach (BSPhysObject pobj in m_vehicles) |
834 | { | 792 | { |
835 | prim.StepVehicle(timeStep); | 793 | pobj.StepVehicle(timeStep); |
836 | } | 794 | } |
837 | } | 795 | } |
838 | #endregion Vehicles | 796 | #endregion Vehicles |
839 | 797 | ||
840 | #region Parameters | 798 | #region INI and command line parameter processing |
841 | 799 | ||
842 | delegate void ParamUser(BSScene scene, IConfig conf, string paramName, float val); | 800 | delegate void ParamUser(BSScene scene, IConfig conf, string paramName, float val); |
843 | delegate float ParamGet(BSScene scene); | 801 | delegate float ParamGet(BSScene scene); |
@@ -869,7 +827,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
869 | // getters and setters. | 827 | // getters and setters. |
870 | // It is easiest to find an existing definition and copy it. | 828 | // It is easiest to find an existing definition and copy it. |
871 | // Parameter values are floats. Booleans are converted to a floating value. | 829 | // Parameter values are floats. Booleans are converted to a floating value. |
872 | // | 830 | // |
873 | // A ParameterDefn() takes the following parameters: | 831 | // A ParameterDefn() takes the following parameters: |
874 | // -- the text name of the parameter. This is used for console input and ini file. | 832 | // -- the text name of the parameter. This is used for console input and ini file. |
875 | // -- a short text description of the parameter. This shows up in the console listing. | 833 | // -- a short text description of the parameter. This shows up in the console listing. |
@@ -888,25 +846,40 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
888 | { | 846 | { |
889 | new ParameterDefn("MeshSculptedPrim", "Whether to create meshes for sculpties", | 847 | new ParameterDefn("MeshSculptedPrim", "Whether to create meshes for sculpties", |
890 | ConfigurationParameters.numericTrue, | 848 | ConfigurationParameters.numericTrue, |
891 | (s,cf,p,v) => { s._meshSculptedPrim = cf.GetBoolean(p, s.BoolNumeric(v)); }, | 849 | (s,cf,p,v) => { s.ShouldMeshSculptedPrim = cf.GetBoolean(p, s.BoolNumeric(v)); }, |
892 | (s) => { return s.NumericBool(s._meshSculptedPrim); }, | 850 | (s) => { return s.NumericBool(s.ShouldMeshSculptedPrim); }, |
893 | (s,p,l,v) => { s._meshSculptedPrim = s.BoolNumeric(v); } ), | 851 | (s,p,l,v) => { s.ShouldMeshSculptedPrim = s.BoolNumeric(v); } ), |
894 | new ParameterDefn("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects", | 852 | new ParameterDefn("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects", |
895 | ConfigurationParameters.numericFalse, | 853 | ConfigurationParameters.numericFalse, |
896 | (s,cf,p,v) => { s._forceSimplePrimMeshing = cf.GetBoolean(p, s.BoolNumeric(v)); }, | 854 | (s,cf,p,v) => { s.ShouldForceSimplePrimMeshing = cf.GetBoolean(p, s.BoolNumeric(v)); }, |
897 | (s) => { return s.NumericBool(s._forceSimplePrimMeshing); }, | 855 | (s) => { return s.NumericBool(s.ShouldForceSimplePrimMeshing); }, |
898 | (s,p,l,v) => { s._forceSimplePrimMeshing = s.BoolNumeric(v); } ), | 856 | (s,p,l,v) => { s.ShouldForceSimplePrimMeshing = s.BoolNumeric(v); } ), |
857 | new ParameterDefn("UseHullsForPhysicalObjects", "If true, create hulls for physical objects", | ||
858 | ConfigurationParameters.numericTrue, | ||
859 | (s,cf,p,v) => { s.ShouldUseHullsForPhysicalObjects = cf.GetBoolean(p, s.BoolNumeric(v)); }, | ||
860 | (s) => { return s.NumericBool(s.ShouldUseHullsForPhysicalObjects); }, | ||
861 | (s,p,l,v) => { s.ShouldUseHullsForPhysicalObjects = s.BoolNumeric(v); } ), | ||
899 | 862 | ||
900 | new ParameterDefn("MeshLOD", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)", | 863 | new ParameterDefn("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)", |
901 | 8f, | 864 | 8f, |
902 | (s,cf,p,v) => { s.m_meshLOD = cf.GetInt(p, (int)v); }, | 865 | (s,cf,p,v) => { s.MeshLOD = (float)cf.GetInt(p, (int)v); }, |
903 | (s) => { return (float)s.m_meshLOD; }, | 866 | (s) => { return s.MeshLOD; }, |
904 | (s,p,l,v) => { s.m_meshLOD = (int)v; } ), | 867 | (s,p,l,v) => { s.MeshLOD = v; } ), |
905 | new ParameterDefn("SculptLOD", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)", | 868 | new ParameterDefn("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters", |
869 | 16f, | ||
870 | (s,cf,p,v) => { s.MeshMegaPrimLOD = (float)cf.GetInt(p, (int)v); }, | ||
871 | (s) => { return s.MeshMegaPrimLOD; }, | ||
872 | (s,p,l,v) => { s.MeshMegaPrimLOD = v; } ), | ||
873 | new ParameterDefn("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD", | ||
874 | 10f, | ||
875 | (s,cf,p,v) => { s.MeshMegaPrimThreshold = (float)cf.GetInt(p, (int)v); }, | ||
876 | (s) => { return s.MeshMegaPrimThreshold; }, | ||
877 | (s,p,l,v) => { s.MeshMegaPrimThreshold = v; } ), | ||
878 | new ParameterDefn("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)", | ||
906 | 32f, | 879 | 32f, |
907 | (s,cf,p,v) => { s.m_sculptLOD = cf.GetInt(p, (int)v); }, | 880 | (s,cf,p,v) => { s.SculptLOD = (float)cf.GetInt(p, (int)v); }, |
908 | (s) => { return (float)s.m_sculptLOD; }, | 881 | (s) => { return s.SculptLOD; }, |
909 | (s,p,l,v) => { s.m_sculptLOD = (int)v; } ), | 882 | (s,p,l,v) => { s.SculptLOD = v; } ), |
910 | 883 | ||
911 | new ParameterDefn("MaxSubStep", "In simulation step, maximum number of substeps", | 884 | new ParameterDefn("MaxSubStep", "In simulation step, maximum number of substeps", |
912 | 10f, | 885 | 10f, |
@@ -928,11 +901,16 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
928 | (s,cf,p,v) => { s.m_maxUpdatesPerFrame = cf.GetInt(p, (int)v); }, | 901 | (s,cf,p,v) => { s.m_maxUpdatesPerFrame = cf.GetInt(p, (int)v); }, |
929 | (s) => { return (float)s.m_maxUpdatesPerFrame; }, | 902 | (s) => { return (float)s.m_maxUpdatesPerFrame; }, |
930 | (s,p,l,v) => { s.m_maxUpdatesPerFrame = (int)v; } ), | 903 | (s,p,l,v) => { s.m_maxUpdatesPerFrame = (int)v; } ), |
904 | new ParameterDefn("MaxTaintsToProcessPerStep", "Number of update taints to process before each simulation step", | ||
905 | 100f, | ||
906 | (s,cf,p,v) => { s.m_taintsToProcessPerStep = cf.GetInt(p, (int)v); }, | ||
907 | (s) => { return (float)s.m_taintsToProcessPerStep; }, | ||
908 | (s,p,l,v) => { s.m_taintsToProcessPerStep = (int)v; } ), | ||
931 | new ParameterDefn("MaxObjectMass", "Maximum object mass (10000.01)", | 909 | new ParameterDefn("MaxObjectMass", "Maximum object mass (10000.01)", |
932 | 10000.01f, | 910 | 10000.01f, |
933 | (s,cf,p,v) => { s.m_maximumObjectMass = cf.GetFloat(p, v); }, | 911 | (s,cf,p,v) => { s.MaximumObjectMass = cf.GetFloat(p, v); }, |
934 | (s) => { return (float)s.m_maximumObjectMass; }, | 912 | (s) => { return (float)s.MaximumObjectMass; }, |
935 | (s,p,l,v) => { s.m_maximumObjectMass = v; } ), | 913 | (s,p,l,v) => { s.MaximumObjectMass = v; } ), |
936 | 914 | ||
937 | new ParameterDefn("PID_D", "Derivitive factor for motion smoothing", | 915 | new ParameterDefn("PID_D", "Derivitive factor for motion smoothing", |
938 | 2200f, | 916 | 2200f, |
@@ -976,42 +954,42 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
976 | 0f, | 954 | 0f, |
977 | (s,cf,p,v) => { s.m_params[0].linearDamping = cf.GetFloat(p, v); }, | 955 | (s,cf,p,v) => { s.m_params[0].linearDamping = cf.GetFloat(p, v); }, |
978 | (s) => { return s.m_params[0].linearDamping; }, | 956 | (s) => { return s.m_params[0].linearDamping; }, |
979 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].linearDamping, p, l, v); } ), | 957 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].linearDamping, p, l, v); } ), |
980 | new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)", | 958 | new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)", |
981 | 0f, | 959 | 0f, |
982 | (s,cf,p,v) => { s.m_params[0].angularDamping = cf.GetFloat(p, v); }, | 960 | (s,cf,p,v) => { s.m_params[0].angularDamping = cf.GetFloat(p, v); }, |
983 | (s) => { return s.m_params[0].angularDamping; }, | 961 | (s) => { return s.m_params[0].angularDamping; }, |
984 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].angularDamping, p, l, v); } ), | 962 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].angularDamping, p, l, v); } ), |
985 | new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static", | 963 | new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static", |
986 | 0.2f, | 964 | 0.2f, |
987 | (s,cf,p,v) => { s.m_params[0].deactivationTime = cf.GetFloat(p, v); }, | 965 | (s,cf,p,v) => { s.m_params[0].deactivationTime = cf.GetFloat(p, v); }, |
988 | (s) => { return s.m_params[0].deactivationTime; }, | 966 | (s) => { return s.m_params[0].deactivationTime; }, |
989 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].deactivationTime, p, l, v); } ), | 967 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].deactivationTime, p, l, v); } ), |
990 | new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static", | 968 | new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static", |
991 | 0.8f, | 969 | 0.8f, |
992 | (s,cf,p,v) => { s.m_params[0].linearSleepingThreshold = cf.GetFloat(p, v); }, | 970 | (s,cf,p,v) => { s.m_params[0].linearSleepingThreshold = cf.GetFloat(p, v); }, |
993 | (s) => { return s.m_params[0].linearSleepingThreshold; }, | 971 | (s) => { return s.m_params[0].linearSleepingThreshold; }, |
994 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].linearSleepingThreshold, p, l, v); } ), | 972 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].linearSleepingThreshold, p, l, v); } ), |
995 | new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static", | 973 | new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static", |
996 | 1.0f, | 974 | 1.0f, |
997 | (s,cf,p,v) => { s.m_params[0].angularSleepingThreshold = cf.GetFloat(p, v); }, | 975 | (s,cf,p,v) => { s.m_params[0].angularSleepingThreshold = cf.GetFloat(p, v); }, |
998 | (s) => { return s.m_params[0].angularSleepingThreshold; }, | 976 | (s) => { return s.m_params[0].angularSleepingThreshold; }, |
999 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].angularSleepingThreshold, p, l, v); } ), | 977 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].angularSleepingThreshold, p, l, v); } ), |
1000 | new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" , | 978 | new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" , |
1001 | 0f, // set to zero to disable | 979 | 0f, // set to zero to disable |
1002 | (s,cf,p,v) => { s.m_params[0].ccdMotionThreshold = cf.GetFloat(p, v); }, | 980 | (s,cf,p,v) => { s.m_params[0].ccdMotionThreshold = cf.GetFloat(p, v); }, |
1003 | (s) => { return s.m_params[0].ccdMotionThreshold; }, | 981 | (s) => { return s.m_params[0].ccdMotionThreshold; }, |
1004 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].ccdMotionThreshold, p, l, v); } ), | 982 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].ccdMotionThreshold, p, l, v); } ), |
1005 | new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" , | 983 | new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" , |
1006 | 0f, | 984 | 0f, |
1007 | (s,cf,p,v) => { s.m_params[0].ccdSweptSphereRadius = cf.GetFloat(p, v); }, | 985 | (s,cf,p,v) => { s.m_params[0].ccdSweptSphereRadius = cf.GetFloat(p, v); }, |
1008 | (s) => { return s.m_params[0].ccdSweptSphereRadius; }, | 986 | (s) => { return s.m_params[0].ccdSweptSphereRadius; }, |
1009 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].ccdSweptSphereRadius, p, l, v); } ), | 987 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].ccdSweptSphereRadius, p, l, v); } ), |
1010 | new ParameterDefn("ContactProcessingThreshold", "Distance between contacts before doing collision check" , | 988 | new ParameterDefn("ContactProcessingThreshold", "Distance between contacts before doing collision check" , |
1011 | 0.1f, | 989 | 0.1f, |
1012 | (s,cf,p,v) => { s.m_params[0].contactProcessingThreshold = cf.GetFloat(p, v); }, | 990 | (s,cf,p,v) => { s.m_params[0].contactProcessingThreshold = cf.GetFloat(p, v); }, |
1013 | (s) => { return s.m_params[0].contactProcessingThreshold; }, | 991 | (s) => { return s.m_params[0].contactProcessingThreshold; }, |
1014 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].contactProcessingThreshold, p, l, v); } ), | 992 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].contactProcessingThreshold, p, l, v); } ), |
1015 | 993 | ||
1016 | new ParameterDefn("TerrainFriction", "Factor to reduce movement against terrain surface" , | 994 | new ParameterDefn("TerrainFriction", "Factor to reduce movement against terrain surface" , |
1017 | 0.5f, | 995 | 0.5f, |
@@ -1029,44 +1007,44 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1029 | (s) => { return s.m_params[0].terrainRestitution; }, | 1007 | (s) => { return s.m_params[0].terrainRestitution; }, |
1030 | (s,p,l,v) => { s.m_params[0].terrainRestitution = v; s.TaintedUpdateParameter(p,l,v); } ), | 1008 | (s,p,l,v) => { s.m_params[0].terrainRestitution = v; s.TaintedUpdateParameter(p,l,v); } ), |
1031 | new ParameterDefn("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.", | 1009 | new ParameterDefn("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.", |
1032 | 0.5f, | 1010 | 0.2f, |
1033 | (s,cf,p,v) => { s.m_params[0].avatarFriction = cf.GetFloat(p, v); }, | 1011 | (s,cf,p,v) => { s.m_params[0].avatarFriction = cf.GetFloat(p, v); }, |
1034 | (s) => { return s.m_params[0].avatarFriction; }, | 1012 | (s) => { return s.m_params[0].avatarFriction; }, |
1035 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarFriction, p, l, v); } ), | 1013 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarFriction, p, l, v); } ), |
1036 | new ParameterDefn("AvatarDensity", "Density of an avatar. Changed on avatar recreation.", | 1014 | new ParameterDefn("AvatarDensity", "Density of an avatar. Changed on avatar recreation.", |
1037 | 60f, | 1015 | 60f, |
1038 | (s,cf,p,v) => { s.m_params[0].avatarDensity = cf.GetFloat(p, v); }, | 1016 | (s,cf,p,v) => { s.m_params[0].avatarDensity = cf.GetFloat(p, v); }, |
1039 | (s) => { return s.m_params[0].avatarDensity; }, | 1017 | (s) => { return s.m_params[0].avatarDensity; }, |
1040 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarDensity, p, l, v); } ), | 1018 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarDensity, p, l, v); } ), |
1041 | new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", | 1019 | new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", |
1042 | 0f, | 1020 | 0f, |
1043 | (s,cf,p,v) => { s.m_params[0].avatarRestitution = cf.GetFloat(p, v); }, | 1021 | (s,cf,p,v) => { s.m_params[0].avatarRestitution = cf.GetFloat(p, v); }, |
1044 | (s) => { return s.m_params[0].avatarRestitution; }, | 1022 | (s) => { return s.m_params[0].avatarRestitution; }, |
1045 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarRestitution, p, l, v); } ), | 1023 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarRestitution, p, l, v); } ), |
1046 | new ParameterDefn("AvatarCapsuleRadius", "Radius of space around an avatar", | 1024 | new ParameterDefn("AvatarCapsuleRadius", "Radius of space around an avatar", |
1047 | 0.37f, | 1025 | 0.37f, |
1048 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleRadius = cf.GetFloat(p, v); }, | 1026 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleRadius = cf.GetFloat(p, v); }, |
1049 | (s) => { return s.m_params[0].avatarCapsuleRadius; }, | 1027 | (s) => { return s.m_params[0].avatarCapsuleRadius; }, |
1050 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarCapsuleRadius, p, l, v); } ), | 1028 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarCapsuleRadius, p, l, v); } ), |
1051 | new ParameterDefn("AvatarCapsuleHeight", "Default height of space around avatar", | 1029 | new ParameterDefn("AvatarCapsuleHeight", "Default height of space around avatar", |
1052 | 1.5f, | 1030 | 1.5f, |
1053 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleHeight = cf.GetFloat(p, v); }, | 1031 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleHeight = cf.GetFloat(p, v); }, |
1054 | (s) => { return s.m_params[0].avatarCapsuleHeight; }, | 1032 | (s) => { return s.m_params[0].avatarCapsuleHeight; }, |
1055 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarCapsuleHeight, p, l, v); } ), | 1033 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarCapsuleHeight, p, l, v); } ), |
1056 | new ParameterDefn("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", | 1034 | new ParameterDefn("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", |
1057 | 0.1f, | 1035 | 0.1f, |
1058 | (s,cf,p,v) => { s.m_params[0].avatarContactProcessingThreshold = cf.GetFloat(p, v); }, | 1036 | (s,cf,p,v) => { s.m_params[0].avatarContactProcessingThreshold = cf.GetFloat(p, v); }, |
1059 | (s) => { return s.m_params[0].avatarContactProcessingThreshold; }, | 1037 | (s) => { return s.m_params[0].avatarContactProcessingThreshold; }, |
1060 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarContactProcessingThreshold, p, l, v); } ), | 1038 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarContactProcessingThreshold, p, l, v); } ), |
1061 | 1039 | ||
1062 | 1040 | ||
1063 | new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", | 1041 | new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", |
1064 | 0f, // zero to disable | 1042 | 0f, |
1065 | (s,cf,p,v) => { s.m_params[0].maxPersistantManifoldPoolSize = cf.GetFloat(p, v); }, | 1043 | (s,cf,p,v) => { s.m_params[0].maxPersistantManifoldPoolSize = cf.GetFloat(p, v); }, |
1066 | (s) => { return s.m_params[0].maxPersistantManifoldPoolSize; }, | 1044 | (s) => { return s.m_params[0].maxPersistantManifoldPoolSize; }, |
1067 | (s,p,l,v) => { s.m_params[0].maxPersistantManifoldPoolSize = v; } ), | 1045 | (s,p,l,v) => { s.m_params[0].maxPersistantManifoldPoolSize = v; } ), |
1068 | new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", | 1046 | new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", |
1069 | 0f, // zero to disable | 1047 | 0f, |
1070 | (s,cf,p,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); }, | 1048 | (s,cf,p,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); }, |
1071 | (s) => { return s.m_params[0].maxCollisionAlgorithmPoolSize; }, | 1049 | (s) => { return s.m_params[0].maxCollisionAlgorithmPoolSize; }, |
1072 | (s,p,l,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = v; } ), | 1050 | (s,p,l,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = v; } ), |
@@ -1081,12 +1059,12 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1081 | (s) => { return s.m_params[0].shouldForceUpdateAllAabbs; }, | 1059 | (s) => { return s.m_params[0].shouldForceUpdateAllAabbs; }, |
1082 | (s,p,l,v) => { s.m_params[0].shouldForceUpdateAllAabbs = v; } ), | 1060 | (s,p,l,v) => { s.m_params[0].shouldForceUpdateAllAabbs = v; } ), |
1083 | new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", | 1061 | new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", |
1084 | ConfigurationParameters.numericFalse, | 1062 | ConfigurationParameters.numericTrue, |
1085 | (s,cf,p,v) => { s.m_params[0].shouldRandomizeSolverOrder = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, | 1063 | (s,cf,p,v) => { s.m_params[0].shouldRandomizeSolverOrder = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, |
1086 | (s) => { return s.m_params[0].shouldRandomizeSolverOrder; }, | 1064 | (s) => { return s.m_params[0].shouldRandomizeSolverOrder; }, |
1087 | (s,p,l,v) => { s.m_params[0].shouldRandomizeSolverOrder = v; } ), | 1065 | (s,p,l,v) => { s.m_params[0].shouldRandomizeSolverOrder = v; } ), |
1088 | new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", | 1066 | new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", |
1089 | ConfigurationParameters.numericFalse, | 1067 | ConfigurationParameters.numericTrue, |
1090 | (s,cf,p,v) => { s.m_params[0].shouldSplitSimulationIslands = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, | 1068 | (s,cf,p,v) => { s.m_params[0].shouldSplitSimulationIslands = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, |
1091 | (s) => { return s.m_params[0].shouldSplitSimulationIslands; }, | 1069 | (s) => { return s.m_params[0].shouldSplitSimulationIslands; }, |
1092 | (s,p,l,v) => { s.m_params[0].shouldSplitSimulationIslands = v; } ), | 1070 | (s,p,l,v) => { s.m_params[0].shouldSplitSimulationIslands = v; } ), |
@@ -1121,28 +1099,27 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1121 | (s,cf,p,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = cf.GetFloat(p, v); }, | 1099 | (s,cf,p,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = cf.GetFloat(p, v); }, |
1122 | (s) => { return s.m_params[0].linkConstraintTransMotorMaxForce; }, | 1100 | (s) => { return s.m_params[0].linkConstraintTransMotorMaxForce; }, |
1123 | (s,p,l,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = v; } ), | 1101 | (s,p,l,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = v; } ), |
1124 | new ParameterDefn("LinkConstraintCFM", "Amount constraint can be violated. 0=none, 1=all. Default=0", | 1102 | new ParameterDefn("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", |
1125 | 0.0f, | 1103 | 0.001f, |
1126 | (s,cf,p,v) => { s.m_params[0].linkConstraintCFM = cf.GetFloat(p, v); }, | 1104 | (s,cf,p,v) => { s.m_params[0].linkConstraintCFM = cf.GetFloat(p, v); }, |
1127 | (s) => { return s.m_params[0].linkConstraintCFM; }, | 1105 | (s) => { return s.m_params[0].linkConstraintCFM; }, |
1128 | (s,p,l,v) => { s.m_params[0].linkConstraintCFM = v; } ), | 1106 | (s,p,l,v) => { s.m_params[0].linkConstraintCFM = v; } ), |
1129 | new ParameterDefn("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", | 1107 | new ParameterDefn("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", |
1130 | 0.2f, | 1108 | 0.8f, |
1131 | (s,cf,p,v) => { s.m_params[0].linkConstraintERP = cf.GetFloat(p, v); }, | 1109 | (s,cf,p,v) => { s.m_params[0].linkConstraintERP = cf.GetFloat(p, v); }, |
1132 | (s) => { return s.m_params[0].linkConstraintERP; }, | 1110 | (s) => { return s.m_params[0].linkConstraintERP; }, |
1133 | (s,p,l,v) => { s.m_params[0].linkConstraintERP = v; } ), | 1111 | (s,p,l,v) => { s.m_params[0].linkConstraintERP = v; } ), |
1112 | new ParameterDefn("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", | ||
1113 | 40, | ||
1114 | (s,cf,p,v) => { s.m_params[0].linkConstraintSolverIterations = cf.GetFloat(p, v); }, | ||
1115 | (s) => { return s.m_params[0].linkConstraintSolverIterations; }, | ||
1116 | (s,p,l,v) => { s.m_params[0].linkConstraintSolverIterations = v; } ), | ||
1134 | 1117 | ||
1135 | new ParameterDefn("DetailedStats", "Frames between outputting detailed phys stats. (0 is off)", | 1118 | new ParameterDefn("LogPhysicsStatisticsFrames", "Frames between outputting detailed phys stats. (0 is off)", |
1136 | 0f, | 1119 | 0f, |
1137 | (s,cf,p,v) => { s.m_detailedStatsStep = cf.GetInt(p, (int)v); }, | 1120 | (s,cf,p,v) => { s.m_params[0].physicsLoggingFrames = cf.GetInt(p, (int)v); }, |
1138 | (s) => { return (float)s.m_detailedStatsStep; }, | 1121 | (s) => { return (float)s.m_params[0].physicsLoggingFrames; }, |
1139 | (s,p,l,v) => { s.m_detailedStatsStep = (int)v; } ), | 1122 | (s,p,l,v) => { s.m_params[0].physicsLoggingFrames = (int)v; } ), |
1140 | new ParameterDefn("ShouldDebugLog", "Enables detailed DEBUG log statements", | ||
1141 | ConfigurationParameters.numericFalse, | ||
1142 | (s,cf,p,v) => { s.ShouldDebugLog = cf.GetBoolean(p, s.BoolNumeric(v)); }, | ||
1143 | (s) => { return s.NumericBool(s.ShouldDebugLog); }, | ||
1144 | (s,p,l,v) => { s.ShouldDebugLog = s.BoolNumeric(v); } ), | ||
1145 | |||
1146 | }; | 1123 | }; |
1147 | 1124 | ||
1148 | // Convert a boolean to our numeric true and false values | 1125 | // Convert a boolean to our numeric true and false values |
@@ -1200,11 +1177,12 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1200 | 1177 | ||
1201 | private PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1]; | 1178 | private PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1]; |
1202 | 1179 | ||
1180 | // This creates an array in the correct format for returning the list of | ||
1181 | // parameters. This is used by the 'list' option of the 'physics' command. | ||
1203 | private void BuildParameterTable() | 1182 | private void BuildParameterTable() |
1204 | { | 1183 | { |
1205 | if (SettableParameters.Length < ParameterDefinitions.Length) | 1184 | if (SettableParameters.Length < ParameterDefinitions.Length) |
1206 | { | 1185 | { |
1207 | |||
1208 | List<PhysParameterEntry> entries = new List<PhysParameterEntry>(); | 1186 | List<PhysParameterEntry> entries = new List<PhysParameterEntry>(); |
1209 | for (int ii = 0; ii < ParameterDefinitions.Length; ii++) | 1187 | for (int ii = 0; ii < ParameterDefinitions.Length; ii++) |
1210 | { | 1188 | { |
@@ -1250,18 +1228,10 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1250 | } | 1228 | } |
1251 | 1229 | ||
1252 | // check to see if we are updating a parameter for a particular or all of the prims | 1230 | // check to see if we are updating a parameter for a particular or all of the prims |
1253 | protected void UpdateParameterPrims(ref float loc, string parm, uint localID, float val) | 1231 | protected void UpdateParameterObject(ref float loc, string parm, uint localID, float val) |
1254 | { | ||
1255 | List<uint> operateOn; | ||
1256 | lock (m_prims) operateOn = new List<uint>(m_prims.Keys); | ||
1257 | UpdateParameterSet(operateOn, ref loc, parm, localID, val); | ||
1258 | } | ||
1259 | |||
1260 | // check to see if we are updating a parameter for a particular or all of the avatars | ||
1261 | protected void UpdateParameterAvatars(ref float loc, string parm, uint localID, float val) | ||
1262 | { | 1232 | { |
1263 | List<uint> operateOn; | 1233 | List<uint> operateOn; |
1264 | lock (m_avatars) operateOn = new List<uint>(m_avatars.Keys); | 1234 | lock (PhysObjects) operateOn = new List<uint>(PhysObjects.Keys); |
1265 | UpdateParameterSet(operateOn, ref loc, parm, localID, val); | 1235 | UpdateParameterSet(operateOn, ref loc, parm, localID, val); |
1266 | } | 1236 | } |
1267 | 1237 | ||
@@ -1284,11 +1254,11 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1284 | TaintedObject("BSScene.UpdateParameterSet", delegate() { | 1254 | TaintedObject("BSScene.UpdateParameterSet", delegate() { |
1285 | foreach (uint lID in objectIDs) | 1255 | foreach (uint lID in objectIDs) |
1286 | { | 1256 | { |
1287 | BulletSimAPI.UpdateParameter(m_worldID, lID, xparm, xval); | 1257 | BulletSimAPI.UpdateParameter(WorldID, lID, xparm, xval); |
1288 | } | 1258 | } |
1289 | }); | 1259 | }); |
1290 | break; | 1260 | break; |
1291 | default: | 1261 | default: |
1292 | // setting only one localID | 1262 | // setting only one localID |
1293 | TaintedUpdateParameter(parm, localID, val); | 1263 | TaintedUpdateParameter(parm, localID, val); |
1294 | break; | 1264 | break; |
@@ -1302,7 +1272,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1302 | string xparm = parm.ToLower(); | 1272 | string xparm = parm.ToLower(); |
1303 | float xval = val; | 1273 | float xval = val; |
1304 | TaintedObject("BSScene.TaintedUpdateParameter", delegate() { | 1274 | TaintedObject("BSScene.TaintedUpdateParameter", delegate() { |
1305 | BulletSimAPI.UpdateParameter(m_worldID, xlocalID, xparm, xval); | 1275 | BulletSimAPI.UpdateParameter(WorldID, xlocalID, xparm, xval); |
1306 | }); | 1276 | }); |
1307 | } | 1277 | } |
1308 | 1278 | ||
@@ -1330,6 +1300,8 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1330 | public void DetailLog(string msg, params Object[] args) | 1300 | public void DetailLog(string msg, params Object[] args) |
1331 | { | 1301 | { |
1332 | PhysicsLogging.Write(msg, args); | 1302 | PhysicsLogging.Write(msg, args); |
1303 | // Add the Flush() if debugging crashes to get all the messages written out. | ||
1304 | // PhysicsLogging.Flush(); | ||
1333 | } | 1305 | } |
1334 | // used to fill in the LocalID when there isn't one | 1306 | // used to fill in the LocalID when there isn't one |
1335 | public const string DetailLogZero = "0000000000"; | 1307 | public const string DetailLogZero = "0000000000"; |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs new file mode 100755 index 0000000..d189f1d --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs | |||
@@ -0,0 +1,756 @@ | |||
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 copyrightD | ||
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 | using System; | ||
28 | using System.Collections.Generic; | ||
29 | using System.Text; | ||
30 | using OMV = OpenMetaverse; | ||
31 | using OpenSim.Framework; | ||
32 | using OpenSim.Region.Physics.Manager; | ||
33 | using OpenSim.Region.Physics.ConvexDecompositionDotNet; | ||
34 | |||
35 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
36 | { | ||
37 | public class BSShapeCollection : IDisposable | ||
38 | { | ||
39 | // private static string LogHeader = "[BULLETSIM SHAPE COLLECTION]"; | ||
40 | |||
41 | protected BSScene PhysicsScene { get; set; } | ||
42 | |||
43 | private Object m_collectionActivityLock = new Object(); | ||
44 | |||
45 | // Description of a Mesh | ||
46 | private struct MeshDesc | ||
47 | { | ||
48 | public IntPtr ptr; | ||
49 | public int referenceCount; | ||
50 | public DateTime lastReferenced; | ||
51 | } | ||
52 | |||
53 | // Description of a hull. | ||
54 | // Meshes and hulls have the same shape hash key but we only need hulls for efficient physical objects | ||
55 | private struct HullDesc | ||
56 | { | ||
57 | public IntPtr ptr; | ||
58 | public int referenceCount; | ||
59 | public DateTime lastReferenced; | ||
60 | } | ||
61 | |||
62 | private struct BodyDesc | ||
63 | { | ||
64 | public IntPtr ptr; | ||
65 | // Bodies are only used once so reference count is always either one or zero | ||
66 | public int referenceCount; | ||
67 | public DateTime lastReferenced; | ||
68 | } | ||
69 | |||
70 | private Dictionary<System.UInt64, MeshDesc> Meshes = new Dictionary<System.UInt64, MeshDesc>(); | ||
71 | private Dictionary<System.UInt64, HullDesc> Hulls = new Dictionary<System.UInt64, HullDesc>(); | ||
72 | private Dictionary<uint, BodyDesc> Bodies = new Dictionary<uint, BodyDesc>(); | ||
73 | |||
74 | public BSShapeCollection(BSScene physScene) | ||
75 | { | ||
76 | PhysicsScene = physScene; | ||
77 | } | ||
78 | |||
79 | public void Dispose() | ||
80 | { | ||
81 | // TODO!!!!!!!!! | ||
82 | } | ||
83 | |||
84 | // Callbacks called just before either the body or shape is destroyed. | ||
85 | // Mostly used for changing bodies out from under Linksets. | ||
86 | // Useful for other cases where parameters need saving. | ||
87 | // Passing 'null' says no callback. | ||
88 | public delegate void ShapeDestructionCallback(BulletShape shape); | ||
89 | public delegate void BodyDestructionCallback(BulletBody body); | ||
90 | |||
91 | // Called to update/change the body and shape for an object. | ||
92 | // First checks the shape and updates that if necessary then makes | ||
93 | // sure the body is of the right type. | ||
94 | // Return 'true' if either the body or the shape changed. | ||
95 | // Called at taint-time!! | ||
96 | public bool GetBodyAndShape(bool forceRebuild, BulletSim sim, BSPrim prim, | ||
97 | ShapeData shapeData, PrimitiveBaseShape pbs, | ||
98 | ShapeDestructionCallback shapeCallback, BodyDestructionCallback bodyCallback) | ||
99 | { | ||
100 | bool ret = false; | ||
101 | |||
102 | // This lock could probably be pushed down lower but building shouldn't take long | ||
103 | lock (m_collectionActivityLock) | ||
104 | { | ||
105 | // Do we have the correct geometry for this type of object? | ||
106 | // Updates prim.BSShape with information/pointers to requested shape | ||
107 | bool newGeom = CreateGeom(forceRebuild, prim, shapeData, pbs, shapeCallback); | ||
108 | // If we had to select a new shape geometry for the object, | ||
109 | // rebuild the body around it. | ||
110 | // Updates prim.BSBody with information/pointers to requested body | ||
111 | bool newBody = CreateBody((newGeom || forceRebuild), prim, PhysicsScene.World, | ||
112 | prim.BSShape, shapeData, bodyCallback); | ||
113 | ret = newGeom || newBody; | ||
114 | } | ||
115 | DetailLog("{0},BSShapeCollection.GetBodyAndShape,force={1},ret={2},body={3},shape={4}", | ||
116 | prim.LocalID, forceRebuild, ret, prim.BSBody, prim.BSShape); | ||
117 | |||
118 | return ret; | ||
119 | } | ||
120 | |||
121 | // Track another user of a body | ||
122 | // We presume the caller has allocated the body. | ||
123 | // Bodies only have one user so the reference count is either 1 or 0. | ||
124 | public void ReferenceBody(BulletBody body, bool inTaintTime) | ||
125 | { | ||
126 | lock (m_collectionActivityLock) | ||
127 | { | ||
128 | BodyDesc bodyDesc; | ||
129 | if (Bodies.TryGetValue(body.ID, out bodyDesc)) | ||
130 | { | ||
131 | bodyDesc.referenceCount++; | ||
132 | DetailLog("{0},BSShapeCollection.ReferenceBody,existingBody,body={1},ref={2}", body.ID, body, bodyDesc.referenceCount); | ||
133 | } | ||
134 | else | ||
135 | { | ||
136 | // New entry | ||
137 | bodyDesc.ptr = body.ptr; | ||
138 | bodyDesc.referenceCount = 1; | ||
139 | DetailLog("{0},BSShapeCollection.ReferenceBody,newBody,ref={2}", | ||
140 | body.ID, body, bodyDesc.referenceCount); | ||
141 | BSScene.TaintCallback createOperation = delegate() | ||
142 | { | ||
143 | if (!BulletSimAPI.IsInWorld2(body.ptr)) | ||
144 | { | ||
145 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, body.ptr); | ||
146 | DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", | ||
147 | body.ID, body); | ||
148 | } | ||
149 | }; | ||
150 | if (inTaintTime) | ||
151 | createOperation(); | ||
152 | else | ||
153 | PhysicsScene.TaintedObject("BSShapeCollection.ReferenceBody", createOperation); | ||
154 | } | ||
155 | bodyDesc.lastReferenced = System.DateTime.Now; | ||
156 | Bodies[body.ID] = bodyDesc; | ||
157 | } | ||
158 | } | ||
159 | |||
160 | // Release the usage of a body. | ||
161 | // Called when releasing use of a BSBody. BSShape is handled separately. | ||
162 | public void DereferenceBody(BulletBody body, bool inTaintTime, BodyDestructionCallback bodyCallback ) | ||
163 | { | ||
164 | if (body.ptr == IntPtr.Zero) | ||
165 | return; | ||
166 | |||
167 | lock (m_collectionActivityLock) | ||
168 | { | ||
169 | BodyDesc bodyDesc; | ||
170 | if (Bodies.TryGetValue(body.ID, out bodyDesc)) | ||
171 | { | ||
172 | bodyDesc.referenceCount--; | ||
173 | bodyDesc.lastReferenced = System.DateTime.Now; | ||
174 | Bodies[body.ID] = bodyDesc; | ||
175 | DetailLog("{0},BSShapeCollection.DereferenceBody,ref={1}", body.ID, bodyDesc.referenceCount); | ||
176 | |||
177 | // If body is no longer being used, free it -- bodies can never be shared. | ||
178 | if (bodyDesc.referenceCount == 0) | ||
179 | { | ||
180 | Bodies.Remove(body.ID); | ||
181 | BSScene.TaintCallback removeOperation = delegate() | ||
182 | { | ||
183 | DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody. ptr={1}, inTaintTime={2}", | ||
184 | body.ID, body.ptr.ToString("X"), inTaintTime); | ||
185 | // If the caller needs to know the old body is going away, pass the event up. | ||
186 | if (bodyCallback != null) bodyCallback(body); | ||
187 | |||
188 | // It may have already been removed from the world in which case the next is a NOOP. | ||
189 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, body.ptr); | ||
190 | |||
191 | // Zero any reference to the shape so it is not freed when the body is deleted. | ||
192 | BulletSimAPI.SetCollisionShape2(PhysicsScene.World.ptr, body.ptr, IntPtr.Zero); | ||
193 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, body.ptr); | ||
194 | }; | ||
195 | // If already in taint-time, do the operations now. Otherwise queue for later. | ||
196 | if (inTaintTime) | ||
197 | removeOperation(); | ||
198 | else | ||
199 | PhysicsScene.TaintedObject("BSShapeCollection.DereferenceBody", removeOperation); | ||
200 | } | ||
201 | } | ||
202 | else | ||
203 | { | ||
204 | DetailLog("{0},BSShapeCollection.DereferenceBody,DID NOT FIND BODY", body.ID, bodyDesc.referenceCount); | ||
205 | } | ||
206 | } | ||
207 | } | ||
208 | |||
209 | // Track the datastructures and use count for a shape. | ||
210 | // When creating a hull, this is called first to reference the mesh | ||
211 | // and then again to reference the hull. | ||
212 | // Meshes and hulls for the same shape have the same hash key. | ||
213 | // NOTE that native shapes are not added to the mesh list or removed. | ||
214 | // Returns 'true' if this is the initial reference to the shape. Otherwise reused. | ||
215 | private bool ReferenceShape(BulletShape shape) | ||
216 | { | ||
217 | bool ret = false; | ||
218 | switch (shape.type) | ||
219 | { | ||
220 | case ShapeData.PhysicsShapeType.SHAPE_MESH: | ||
221 | MeshDesc meshDesc; | ||
222 | if (Meshes.TryGetValue(shape.shapeKey, out meshDesc)) | ||
223 | { | ||
224 | // There is an existing instance of this mesh. | ||
225 | meshDesc.referenceCount++; | ||
226 | DetailLog("{0},BSShapeCollection.ReferenceShape,existingMesh,key={1},cnt={2}", | ||
227 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount); | ||
228 | } | ||
229 | else | ||
230 | { | ||
231 | // This is a new reference to a mesh | ||
232 | meshDesc.ptr = shape.ptr; | ||
233 | // We keep a reference to the underlying IMesh data so a hull can be built | ||
234 | meshDesc.referenceCount = 1; | ||
235 | DetailLog("{0},BSShapeCollection.ReferenceShape,newMesh,key={1},cnt={2}", | ||
236 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount); | ||
237 | ret = true; | ||
238 | } | ||
239 | meshDesc.lastReferenced = System.DateTime.Now; | ||
240 | Meshes[shape.shapeKey] = meshDesc; | ||
241 | break; | ||
242 | case ShapeData.PhysicsShapeType.SHAPE_HULL: | ||
243 | HullDesc hullDesc; | ||
244 | if (Hulls.TryGetValue(shape.shapeKey, out hullDesc)) | ||
245 | { | ||
246 | // There is an existing instance of this hull. | ||
247 | hullDesc.referenceCount++; | ||
248 | DetailLog("{0},BSShapeCollection.ReferenceShape,existingHull,key={1},cnt={2}", | ||
249 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount); | ||
250 | } | ||
251 | else | ||
252 | { | ||
253 | // This is a new reference to a hull | ||
254 | hullDesc.ptr = shape.ptr; | ||
255 | hullDesc.referenceCount = 1; | ||
256 | DetailLog("{0},BSShapeCollection.ReferenceShape,newHull,key={1},cnt={2}", | ||
257 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount); | ||
258 | ret = true; | ||
259 | |||
260 | } | ||
261 | hullDesc.lastReferenced = System.DateTime.Now; | ||
262 | Hulls[shape.shapeKey] = hullDesc; | ||
263 | break; | ||
264 | case ShapeData.PhysicsShapeType.SHAPE_UNKNOWN: | ||
265 | break; | ||
266 | default: | ||
267 | // Native shapes are not tracked and they don't go into any list | ||
268 | break; | ||
269 | } | ||
270 | return ret; | ||
271 | } | ||
272 | |||
273 | // Release the usage of a shape. | ||
274 | // The collisionObject is released since it is a copy of the real collision shape. | ||
275 | public void DereferenceShape(BulletShape shape, bool inTaintTime, ShapeDestructionCallback shapeCallback) | ||
276 | { | ||
277 | if (shape.ptr == IntPtr.Zero) | ||
278 | return; | ||
279 | |||
280 | BSScene.TaintCallback dereferenceOperation = delegate() | ||
281 | { | ||
282 | switch (shape.type) | ||
283 | { | ||
284 | case ShapeData.PhysicsShapeType.SHAPE_HULL: | ||
285 | DereferenceHull(shape, shapeCallback); | ||
286 | break; | ||
287 | case ShapeData.PhysicsShapeType.SHAPE_MESH: | ||
288 | DereferenceMesh(shape, shapeCallback); | ||
289 | break; | ||
290 | case ShapeData.PhysicsShapeType.SHAPE_UNKNOWN: | ||
291 | break; | ||
292 | default: | ||
293 | // Native shapes are not tracked and are released immediately | ||
294 | if (shape.ptr != IntPtr.Zero & shape.isNativeShape) | ||
295 | { | ||
296 | DetailLog("{0},BSShapeCollection.DereferenceShape,deleteNativeShape,ptr={1},taintTime={2}", | ||
297 | BSScene.DetailLogZero, shape.ptr.ToString("X"), inTaintTime); | ||
298 | if (shapeCallback != null) shapeCallback(shape); | ||
299 | BulletSimAPI.DeleteCollisionShape2(PhysicsScene.World.ptr, shape.ptr); | ||
300 | } | ||
301 | break; | ||
302 | } | ||
303 | }; | ||
304 | if (inTaintTime) | ||
305 | { | ||
306 | lock (m_collectionActivityLock) | ||
307 | { | ||
308 | dereferenceOperation(); | ||
309 | } | ||
310 | } | ||
311 | else | ||
312 | { | ||
313 | PhysicsScene.TaintedObject("BSShapeCollection.DereferenceShape", dereferenceOperation); | ||
314 | } | ||
315 | } | ||
316 | |||
317 | // Count down the reference count for a mesh shape | ||
318 | // Called at taint-time. | ||
319 | private void DereferenceMesh(BulletShape shape, ShapeDestructionCallback shapeCallback) | ||
320 | { | ||
321 | MeshDesc meshDesc; | ||
322 | if (Meshes.TryGetValue(shape.shapeKey, out meshDesc)) | ||
323 | { | ||
324 | meshDesc.referenceCount--; | ||
325 | // TODO: release the Bullet storage | ||
326 | if (shapeCallback != null) shapeCallback(shape); | ||
327 | meshDesc.lastReferenced = System.DateTime.Now; | ||
328 | Meshes[shape.shapeKey] = meshDesc; | ||
329 | DetailLog("{0},BSShapeCollection.DereferenceMesh,key={1},refCnt={2}", | ||
330 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount); | ||
331 | |||
332 | } | ||
333 | } | ||
334 | |||
335 | // Count down the reference count for a hull shape | ||
336 | // Called at taint-time. | ||
337 | private void DereferenceHull(BulletShape shape, ShapeDestructionCallback shapeCallback) | ||
338 | { | ||
339 | HullDesc hullDesc; | ||
340 | if (Hulls.TryGetValue(shape.shapeKey, out hullDesc)) | ||
341 | { | ||
342 | hullDesc.referenceCount--; | ||
343 | // TODO: release the Bullet storage (aging old entries?) | ||
344 | if (shapeCallback != null) shapeCallback(shape); | ||
345 | hullDesc.lastReferenced = System.DateTime.Now; | ||
346 | Hulls[shape.shapeKey] = hullDesc; | ||
347 | DetailLog("{0},BSShapeCollection.DereferenceHull,key={1},refCnt={2}", | ||
348 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount); | ||
349 | } | ||
350 | } | ||
351 | |||
352 | // Create the geometry information in Bullet for later use. | ||
353 | // The objects needs a hull if it's physical otherwise a mesh is enough. | ||
354 | // No locking here because this is done when we know physics is not simulating. | ||
355 | // if 'forceRebuild' is true, the geometry is rebuilt. Otherwise a previously built version is used. | ||
356 | // Returns 'true' if the geometry was rebuilt. | ||
357 | // Called at taint-time! | ||
358 | private bool CreateGeom(bool forceRebuild, BSPrim prim, ShapeData shapeData, | ||
359 | PrimitiveBaseShape pbs, ShapeDestructionCallback shapeCallback) | ||
360 | { | ||
361 | bool ret = false; | ||
362 | bool haveShape = false; | ||
363 | bool nativeShapePossible = true; | ||
364 | |||
365 | // If the prim attributes are simple, this could be a simple Bullet native shape | ||
366 | if (nativeShapePossible | ||
367 | && ((pbs.SculptEntry && !PhysicsScene.ShouldMeshSculptedPrim) | ||
368 | || (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0 | ||
369 | && pbs.ProfileHollow == 0 | ||
370 | && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0 | ||
371 | && pbs.PathBegin == 0 && pbs.PathEnd == 0 | ||
372 | && pbs.PathTaperX == 0 && pbs.PathTaperY == 0 | ||
373 | && pbs.PathScaleX == 100 && pbs.PathScaleY == 100 | ||
374 | && pbs.PathShearX == 0 && pbs.PathShearY == 0) ) ) | ||
375 | { | ||
376 | if ((pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1) | ||
377 | && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z) | ||
378 | { | ||
379 | haveShape = true; | ||
380 | if (forceRebuild | ||
381 | || prim.Scale != shapeData.Size | ||
382 | || prim.BSShape.type != ShapeData.PhysicsShapeType.SHAPE_SPHERE | ||
383 | ) | ||
384 | { | ||
385 | ret = GetReferenceToNativeShape(prim, shapeData, ShapeData.PhysicsShapeType.SHAPE_SPHERE, | ||
386 | ShapeData.FixedShapeKey.KEY_SPHERE, shapeCallback); | ||
387 | DetailLog("{0},BSShapeCollection.CreateGeom,sphere,force={1},shape={2}", | ||
388 | prim.LocalID, forceRebuild, prim.BSShape); | ||
389 | } | ||
390 | } | ||
391 | if (pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight) | ||
392 | { | ||
393 | haveShape = true; | ||
394 | if (forceRebuild | ||
395 | || prim.Scale != shapeData.Size | ||
396 | || prim.BSShape.type != ShapeData.PhysicsShapeType.SHAPE_BOX | ||
397 | ) | ||
398 | { | ||
399 | ret = GetReferenceToNativeShape( prim, shapeData, ShapeData.PhysicsShapeType.SHAPE_BOX, | ||
400 | ShapeData.FixedShapeKey.KEY_BOX, shapeCallback); | ||
401 | DetailLog("{0},BSShapeCollection.CreateGeom,box,force={1},shape={2}", | ||
402 | prim.LocalID, forceRebuild, prim.BSShape); | ||
403 | } | ||
404 | } | ||
405 | } | ||
406 | // If a simple shape is not happening, create a mesh and possibly a hull. | ||
407 | // Note that if it's a native shape, the check for physical/non-physical is not | ||
408 | // made. Native shapes are best used in either case. | ||
409 | if (!haveShape) | ||
410 | { | ||
411 | if (prim.IsPhysical && PhysicsScene.ShouldUseHullsForPhysicalObjects) | ||
412 | { | ||
413 | // Update prim.BSShape to reference a hull of this shape. | ||
414 | ret = GetReferenceToHull(prim, shapeData, pbs, shapeCallback); | ||
415 | DetailLog("{0},BSShapeCollection.CreateGeom,hull,shape={1},key={2}", | ||
416 | shapeData.ID, prim.BSShape, prim.BSShape.shapeKey.ToString("X")); | ||
417 | } | ||
418 | else | ||
419 | { | ||
420 | ret = GetReferenceToMesh(prim, shapeData, pbs, shapeCallback); | ||
421 | DetailLog("{0},BSShapeCollection.CreateGeom,mesh,shape={1},key={2}", | ||
422 | shapeData.ID, prim.BSShape, prim.BSShape.shapeKey.ToString("X")); | ||
423 | } | ||
424 | } | ||
425 | return ret; | ||
426 | } | ||
427 | |||
428 | // Creates a native shape and assignes it to prim.BSShape | ||
429 | private bool GetReferenceToNativeShape( BSPrim prim, ShapeData shapeData, | ||
430 | ShapeData.PhysicsShapeType shapeType, ShapeData.FixedShapeKey shapeKey, | ||
431 | ShapeDestructionCallback shapeCallback) | ||
432 | { | ||
433 | BulletShape newShape; | ||
434 | |||
435 | shapeData.Type = shapeType; | ||
436 | // Bullet native objects are scaled by the Bullet engine so pass the size in | ||
437 | prim.Scale = shapeData.Size; | ||
438 | shapeData.Scale = shapeData.Size; | ||
439 | |||
440 | // release any previous shape | ||
441 | DereferenceShape(prim.BSShape, true, shapeCallback); | ||
442 | |||
443 | // Native shapes are always built independently. | ||
444 | newShape = new BulletShape(BulletSimAPI.BuildNativeShape2(PhysicsScene.World.ptr, shapeData), shapeType); | ||
445 | newShape.shapeKey = (System.UInt64)shapeKey; | ||
446 | newShape.isNativeShape = true; | ||
447 | |||
448 | // Don't need to do a 'ReferenceShape()' here because native shapes are not tracked. | ||
449 | // DetailLog("{0},BSShapeCollection.AddNativeShapeToPrim,create,newshape={1}", shapeData.ID, newShape); | ||
450 | |||
451 | prim.BSShape = newShape; | ||
452 | return true; | ||
453 | } | ||
454 | |||
455 | // Builds a mesh shape in the physical world and updates prim.BSShape. | ||
456 | // Dereferences previous shape in BSShape and adds a reference for this new shape. | ||
457 | // Returns 'true' of a mesh was actually built. Otherwise . | ||
458 | // Called at taint-time! | ||
459 | private bool GetReferenceToMesh(BSPrim prim, ShapeData shapeData, PrimitiveBaseShape pbs, | ||
460 | ShapeDestructionCallback shapeCallback) | ||
461 | { | ||
462 | BulletShape newShape = new BulletShape(IntPtr.Zero); | ||
463 | |||
464 | float lod; | ||
465 | System.UInt64 newMeshKey = ComputeShapeKey(shapeData, pbs, out lod); | ||
466 | |||
467 | // if this new shape is the same as last time, don't recreate the mesh | ||
468 | if (newMeshKey == prim.BSShape.shapeKey && prim.BSShape.type == ShapeData.PhysicsShapeType.SHAPE_MESH) | ||
469 | return false; | ||
470 | |||
471 | DetailLog("{0},BSShapeCollection.CreateGeomMesh,create,oldKey={1},newKey={2}", | ||
472 | prim.LocalID, prim.BSShape.shapeKey.ToString("X"), newMeshKey.ToString("X")); | ||
473 | |||
474 | // Since we're recreating new, get rid of the reference to the previous shape | ||
475 | DereferenceShape(prim.BSShape, true, shapeCallback); | ||
476 | |||
477 | newShape = CreatePhysicalMesh(prim.PhysObjectName, newMeshKey, pbs, shapeData.Size, lod); | ||
478 | |||
479 | ReferenceShape(newShape); | ||
480 | |||
481 | // meshes are already scaled by the meshmerizer | ||
482 | prim.Scale = new OMV.Vector3(1f, 1f, 1f); | ||
483 | prim.BSShape = newShape; | ||
484 | |||
485 | return true; // 'true' means a new shape has been added to this prim | ||
486 | } | ||
487 | |||
488 | private BulletShape CreatePhysicalMesh(string objName, System.UInt64 newMeshKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod) | ||
489 | { | ||
490 | IMesh meshData = null; | ||
491 | IntPtr meshPtr; | ||
492 | MeshDesc meshDesc; | ||
493 | if (Meshes.TryGetValue(newMeshKey, out meshDesc)) | ||
494 | { | ||
495 | // If the mesh has already been built just use it. | ||
496 | meshPtr = meshDesc.ptr; | ||
497 | } | ||
498 | else | ||
499 | { | ||
500 | // Pass false for physicalness as this creates some sort of bounding box which we don't need | ||
501 | meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, false); | ||
502 | |||
503 | int[] indices = meshData.getIndexListAsInt(); | ||
504 | List<OMV.Vector3> vertices = meshData.getVertexList(); | ||
505 | |||
506 | float[] verticesAsFloats = new float[vertices.Count * 3]; | ||
507 | int vi = 0; | ||
508 | foreach (OMV.Vector3 vv in vertices) | ||
509 | { | ||
510 | verticesAsFloats[vi++] = vv.X; | ||
511 | verticesAsFloats[vi++] = vv.Y; | ||
512 | verticesAsFloats[vi++] = vv.Z; | ||
513 | } | ||
514 | |||
515 | // m_log.DebugFormat("{0}: CreateGeomMesh: calling CreateMesh. lid={1}, key={2}, indices={3}, vertices={4}", | ||
516 | // LogHeader, prim.LocalID, newMeshKey, indices.Length, vertices.Count); | ||
517 | |||
518 | meshPtr = BulletSimAPI.CreateMeshShape2(PhysicsScene.World.ptr, | ||
519 | indices.GetLength(0), indices, vertices.Count, verticesAsFloats); | ||
520 | } | ||
521 | BulletShape newShape = new BulletShape(meshPtr, ShapeData.PhysicsShapeType.SHAPE_MESH); | ||
522 | newShape.shapeKey = newMeshKey; | ||
523 | |||
524 | return newShape; | ||
525 | } | ||
526 | |||
527 | // See that hull shape exists in the physical world and update prim.BSShape. | ||
528 | // We could be creating the hull because scale changed or whatever. | ||
529 | private bool GetReferenceToHull(BSPrim prim, ShapeData shapeData, PrimitiveBaseShape pbs, | ||
530 | ShapeDestructionCallback shapeCallback) | ||
531 | { | ||
532 | BulletShape newShape; | ||
533 | |||
534 | float lod; | ||
535 | System.UInt64 newHullKey = ComputeShapeKey(shapeData, pbs, out lod); | ||
536 | |||
537 | // if the hull hasn't changed, don't rebuild it | ||
538 | if (newHullKey == prim.BSShape.shapeKey && prim.BSShape.type == ShapeData.PhysicsShapeType.SHAPE_HULL) | ||
539 | return false; | ||
540 | |||
541 | DetailLog("{0},BSShapeCollection.CreateGeomHull,create,oldKey={1},newKey={2}", | ||
542 | prim.LocalID, prim.BSShape.shapeKey.ToString("X"), newHullKey.ToString("X")); | ||
543 | |||
544 | // Remove usage of the previous shape. | ||
545 | DereferenceShape(prim.BSShape, true, shapeCallback); | ||
546 | |||
547 | newShape = CreatePhysicalHull(prim.PhysObjectName, newHullKey, pbs, shapeData.Size, lod); | ||
548 | |||
549 | ReferenceShape(newShape); | ||
550 | |||
551 | // hulls are already scaled by the meshmerizer | ||
552 | prim.Scale = new OMV.Vector3(1f, 1f, 1f); | ||
553 | prim.BSShape = newShape; | ||
554 | return true; // 'true' means a new shape has been added to this prim | ||
555 | } | ||
556 | |||
557 | List<ConvexResult> m_hulls; | ||
558 | private BulletShape CreatePhysicalHull(string objName, System.UInt64 newHullKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod) | ||
559 | { | ||
560 | |||
561 | IntPtr hullPtr; | ||
562 | HullDesc hullDesc; | ||
563 | if (Hulls.TryGetValue(newHullKey, out hullDesc)) | ||
564 | { | ||
565 | // If the hull shape already is created, just use it. | ||
566 | hullPtr = hullDesc.ptr; | ||
567 | } | ||
568 | else | ||
569 | { | ||
570 | // Build a new hull in the physical world | ||
571 | // Pass false for physicalness as this creates some sort of bounding box which we don't need | ||
572 | IMesh meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, false); | ||
573 | |||
574 | int[] indices = meshData.getIndexListAsInt(); | ||
575 | List<OMV.Vector3> vertices = meshData.getVertexList(); | ||
576 | |||
577 | //format conversion from IMesh format to DecompDesc format | ||
578 | List<int> convIndices = new List<int>(); | ||
579 | List<float3> convVertices = new List<float3>(); | ||
580 | for (int ii = 0; ii < indices.GetLength(0); ii++) | ||
581 | { | ||
582 | convIndices.Add(indices[ii]); | ||
583 | } | ||
584 | foreach (OMV.Vector3 vv in vertices) | ||
585 | { | ||
586 | convVertices.Add(new float3(vv.X, vv.Y, vv.Z)); | ||
587 | } | ||
588 | |||
589 | // setup and do convex hull conversion | ||
590 | m_hulls = new List<ConvexResult>(); | ||
591 | DecompDesc dcomp = new DecompDesc(); | ||
592 | dcomp.mIndices = convIndices; | ||
593 | dcomp.mVertices = convVertices; | ||
594 | ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn); | ||
595 | // create the hull into the _hulls variable | ||
596 | convexBuilder.process(dcomp); | ||
597 | |||
598 | // Convert the vertices and indices for passing to unmanaged. | ||
599 | // The hull information is passed as a large floating point array. | ||
600 | // The format is: | ||
601 | // convHulls[0] = number of hulls | ||
602 | // convHulls[1] = number of vertices in first hull | ||
603 | // convHulls[2] = hull centroid X coordinate | ||
604 | // convHulls[3] = hull centroid Y coordinate | ||
605 | // convHulls[4] = hull centroid Z coordinate | ||
606 | // convHulls[5] = first hull vertex X | ||
607 | // convHulls[6] = first hull vertex Y | ||
608 | // convHulls[7] = first hull vertex Z | ||
609 | // convHulls[8] = second hull vertex X | ||
610 | // ... | ||
611 | // convHulls[n] = number of vertices in second hull | ||
612 | // convHulls[n+1] = second hull centroid X coordinate | ||
613 | // ... | ||
614 | // | ||
615 | // TODO: is is very inefficient. Someday change the convex hull generator to return | ||
616 | // data structures that do not need to be converted in order to pass to Bullet. | ||
617 | // And maybe put the values directly into pinned memory rather than marshaling. | ||
618 | int hullCount = m_hulls.Count; | ||
619 | int totalVertices = 1; // include one for the count of the hulls | ||
620 | foreach (ConvexResult cr in m_hulls) | ||
621 | { | ||
622 | totalVertices += 4; // add four for the vertex count and centroid | ||
623 | totalVertices += cr.HullIndices.Count * 3; // we pass just triangles | ||
624 | } | ||
625 | float[] convHulls = new float[totalVertices]; | ||
626 | |||
627 | convHulls[0] = (float)hullCount; | ||
628 | int jj = 1; | ||
629 | foreach (ConvexResult cr in m_hulls) | ||
630 | { | ||
631 | // copy vertices for index access | ||
632 | float3[] verts = new float3[cr.HullVertices.Count]; | ||
633 | int kk = 0; | ||
634 | foreach (float3 ff in cr.HullVertices) | ||
635 | { | ||
636 | verts[kk++] = ff; | ||
637 | } | ||
638 | |||
639 | // add to the array one hull's worth of data | ||
640 | convHulls[jj++] = cr.HullIndices.Count; | ||
641 | convHulls[jj++] = 0f; // centroid x,y,z | ||
642 | convHulls[jj++] = 0f; | ||
643 | convHulls[jj++] = 0f; | ||
644 | foreach (int ind in cr.HullIndices) | ||
645 | { | ||
646 | convHulls[jj++] = verts[ind].x; | ||
647 | convHulls[jj++] = verts[ind].y; | ||
648 | convHulls[jj++] = verts[ind].z; | ||
649 | } | ||
650 | } | ||
651 | // create the hull data structure in Bullet | ||
652 | hullPtr = BulletSimAPI.CreateHullShape2(PhysicsScene.World.ptr, hullCount, convHulls); | ||
653 | } | ||
654 | |||
655 | BulletShape newShape = new BulletShape(hullPtr, ShapeData.PhysicsShapeType.SHAPE_HULL); | ||
656 | newShape.shapeKey = newHullKey; | ||
657 | |||
658 | return newShape; // 'true' means a new shape has been added to this prim | ||
659 | } | ||
660 | |||
661 | // Callback from convex hull creater with a newly created hull. | ||
662 | // Just add it to our collection of hulls for this shape. | ||
663 | private void HullReturn(ConvexResult result) | ||
664 | { | ||
665 | m_hulls.Add(result); | ||
666 | return; | ||
667 | } | ||
668 | |||
669 | // Create a hash of all the shape parameters to be used as a key | ||
670 | // for this particular shape. | ||
671 | private System.UInt64 ComputeShapeKey(ShapeData shapeData, PrimitiveBaseShape pbs, out float retLod) | ||
672 | { | ||
673 | // level of detail based on size and type of the object | ||
674 | float lod = PhysicsScene.MeshLOD; | ||
675 | if (pbs.SculptEntry) | ||
676 | lod = PhysicsScene.SculptLOD; | ||
677 | |||
678 | // Mega prims usually get more detail because one can interact with shape approximations at this size. | ||
679 | float maxAxis = Math.Max(shapeData.Size.X, Math.Max(shapeData.Size.Y, shapeData.Size.Z)); | ||
680 | if (maxAxis > PhysicsScene.MeshMegaPrimThreshold) | ||
681 | lod = PhysicsScene.MeshMegaPrimLOD; | ||
682 | |||
683 | retLod = lod; | ||
684 | return pbs.GetMeshKey(shapeData.Size, lod); | ||
685 | } | ||
686 | // For those who don't want the LOD | ||
687 | private System.UInt64 ComputeShapeKey(ShapeData shapeData, PrimitiveBaseShape pbs) | ||
688 | { | ||
689 | float lod; | ||
690 | return ComputeShapeKey(shapeData, pbs, out lod); | ||
691 | } | ||
692 | |||
693 | // Create a body object in Bullet. | ||
694 | // Updates prim.BSBody with the information about the new body if one is created. | ||
695 | // Returns 'true' if an object was actually created. | ||
696 | // Called at taint-time. | ||
697 | private bool CreateBody(bool forceRebuild, BSPrim prim, BulletSim sim, BulletShape shape, | ||
698 | ShapeData shapeData, BodyDestructionCallback bodyCallback) | ||
699 | { | ||
700 | bool ret = false; | ||
701 | |||
702 | // the mesh, hull or native shape must have already been created in Bullet | ||
703 | bool mustRebuild = (prim.BSBody.ptr == IntPtr.Zero); | ||
704 | |||
705 | // If there is an existing body, verify it's of an acceptable type. | ||
706 | // If not a solid object, body is a GhostObject. Otherwise a RigidBody. | ||
707 | if (!mustRebuild) | ||
708 | { | ||
709 | CollisionObjectTypes bodyType = (CollisionObjectTypes)BulletSimAPI.GetBodyType2(prim.BSBody.ptr); | ||
710 | if (prim.IsSolid && bodyType != CollisionObjectTypes.CO_RIGID_BODY | ||
711 | || !prim.IsSolid && bodyType != CollisionObjectTypes.CO_GHOST_OBJECT) | ||
712 | { | ||
713 | // If the collisionObject is not the correct type for solidness, rebuild what's there | ||
714 | mustRebuild = true; | ||
715 | } | ||
716 | |||
717 | } | ||
718 | |||
719 | if (mustRebuild || forceRebuild) | ||
720 | { | ||
721 | // Free any old body | ||
722 | DereferenceBody(prim.BSBody, true, bodyCallback); | ||
723 | |||
724 | BulletBody aBody; | ||
725 | IntPtr bodyPtr = IntPtr.Zero; | ||
726 | if (prim.IsSolid) | ||
727 | { | ||
728 | bodyPtr = BulletSimAPI.CreateBodyFromShape2(sim.ptr, shape.ptr, | ||
729 | shapeData.ID, shapeData.Position, shapeData.Rotation); | ||
730 | DetailLog("{0},BSShapeCollection.CreateBody,mesh,ptr={1}", prim.LocalID, bodyPtr.ToString("X")); | ||
731 | } | ||
732 | else | ||
733 | { | ||
734 | bodyPtr = BulletSimAPI.CreateGhostFromShape2(sim.ptr, shape.ptr, | ||
735 | shapeData.ID, shapeData.Position, shapeData.Rotation); | ||
736 | DetailLog("{0},BSShapeCollection.CreateBody,ghost,ptr={1}", prim.LocalID, bodyPtr.ToString("X")); | ||
737 | } | ||
738 | aBody = new BulletBody(shapeData.ID, bodyPtr); | ||
739 | |||
740 | ReferenceBody(aBody, true); | ||
741 | |||
742 | prim.BSBody = aBody; | ||
743 | |||
744 | ret = true; | ||
745 | } | ||
746 | |||
747 | return ret; | ||
748 | } | ||
749 | |||
750 | private void DetailLog(string msg, params Object[] args) | ||
751 | { | ||
752 | if (PhysicsScene.PhysicsLogging.Enabled) | ||
753 | PhysicsScene.DetailLog(msg, args); | ||
754 | } | ||
755 | } | ||
756 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs new file mode 100755 index 0000000..caf411e --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs | |||
@@ -0,0 +1,492 @@ | |||
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 copyrightD | ||
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 | using System; | ||
28 | using System.Collections.Generic; | ||
29 | using System.Text; | ||
30 | |||
31 | using OpenSim.Framework; | ||
32 | using OpenSim.Region.Framework; | ||
33 | using OpenSim.Region.CoreModules; | ||
34 | using OpenSim.Region.Physics.Manager; | ||
35 | |||
36 | using Nini.Config; | ||
37 | using log4net; | ||
38 | |||
39 | using OpenMetaverse; | ||
40 | |||
41 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
42 | { | ||
43 | public class BSTerrainManager | ||
44 | { | ||
45 | static string LogHeader = "[BULLETSIM TERRAIN MANAGER]"; | ||
46 | |||
47 | // These height values are fractional so the odd values will be | ||
48 | // noticable when debugging. | ||
49 | public const float HEIGHT_INITIALIZATION = 24.987f; | ||
50 | public const float HEIGHT_INITIAL_LASTHEIGHT = 24.876f; | ||
51 | public const float HEIGHT_GETHEIGHT_RET = 24.765f; | ||
52 | |||
53 | // If the min and max height are equal, we reduce the min by this | ||
54 | // amount to make sure that a bounding box is built for the terrain. | ||
55 | public const float HEIGHT_EQUAL_FUDGE = 0.2f; | ||
56 | |||
57 | public const float TERRAIN_COLLISION_MARGIN = 0.0f; | ||
58 | |||
59 | // Until the whole simulator is changed to pass us the region size, we rely on constants. | ||
60 | public Vector3 DefaultRegionSize = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight); | ||
61 | |||
62 | // The scene that I am part of | ||
63 | private BSScene PhysicsScene { get; set; } | ||
64 | |||
65 | // The ground plane created to keep thing from falling to infinity. | ||
66 | private BulletBody m_groundPlane; | ||
67 | |||
68 | // If doing mega-regions, if we're region zero we will be managing multiple | ||
69 | // region terrains since region zero does the physics for the whole mega-region. | ||
70 | private Dictionary<Vector2, BulletHeightMapInfo> m_heightMaps; | ||
71 | |||
72 | // True of the terrain has been modified. | ||
73 | // Used to force recalculation of terrain height after terrain has been modified | ||
74 | private bool m_terrainModified; | ||
75 | |||
76 | // If we are doing mega-regions, terrains are added from TERRAIN_ID to m_terrainCount. | ||
77 | // This is incremented before assigning to new region so it is the last ID allocated. | ||
78 | private uint m_terrainCount = BSScene.CHILDTERRAIN_ID - 1; | ||
79 | public uint HighestTerrainID { get {return m_terrainCount; } } | ||
80 | |||
81 | // If doing mega-regions, this holds our offset from region zero of | ||
82 | // the mega-regions. "parentScene" points to the PhysicsScene of region zero. | ||
83 | private Vector3 m_worldOffset; | ||
84 | // If the parent region (region 0), this is the extent of the combined regions | ||
85 | // relative to the origin of region zero | ||
86 | private Vector3 m_worldMax; | ||
87 | private PhysicsScene MegaRegionParentPhysicsScene { get; set; } | ||
88 | |||
89 | public BSTerrainManager(BSScene physicsScene) | ||
90 | { | ||
91 | PhysicsScene = physicsScene; | ||
92 | m_heightMaps = new Dictionary<Vector2,BulletHeightMapInfo>(); | ||
93 | m_terrainModified = false; | ||
94 | |||
95 | // Assume one region of default size | ||
96 | m_worldOffset = Vector3.Zero; | ||
97 | m_worldMax = new Vector3(DefaultRegionSize); | ||
98 | MegaRegionParentPhysicsScene = null; | ||
99 | } | ||
100 | |||
101 | // Create the initial instance of terrain and the underlying ground plane. | ||
102 | // The objects are allocated in the unmanaged space and the pointers are tracked | ||
103 | // by the managed code. | ||
104 | // The terrains and the groundPlane are not added to the list of PhysObjects. | ||
105 | // This is called from the initialization routine so we presume it is | ||
106 | // safe to call Bullet in real time. We hope no one is moving prims around yet. | ||
107 | public void CreateInitialGroundPlaneAndTerrain() | ||
108 | { | ||
109 | // The ground plane is here to catch things that are trying to drop to negative infinity | ||
110 | BulletShape groundPlaneShape = new BulletShape( | ||
111 | BulletSimAPI.CreateGroundPlaneShape2(BSScene.GROUNDPLANE_ID, 1f, TERRAIN_COLLISION_MARGIN), | ||
112 | ShapeData.PhysicsShapeType.SHAPE_GROUNDPLANE); | ||
113 | m_groundPlane = new BulletBody(BSScene.GROUNDPLANE_ID, | ||
114 | BulletSimAPI.CreateBodyWithDefaultMotionState2(groundPlaneShape.ptr, BSScene.GROUNDPLANE_ID, | ||
115 | Vector3.Zero, Quaternion.Identity)); | ||
116 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr); | ||
117 | // Ground plane does not move | ||
118 | BulletSimAPI.ForceActivationState2(m_groundPlane.ptr, ActivationState.DISABLE_SIMULATION); | ||
119 | // Everything collides with the ground plane. | ||
120 | BulletSimAPI.SetCollisionFilterMask2(m_groundPlane.ptr, | ||
121 | (uint)CollisionFilterGroups.GroundPlaneFilter, (uint)CollisionFilterGroups.GroundPlaneMask); | ||
122 | |||
123 | Vector3 minTerrainCoords = new Vector3(0f, 0f, HEIGHT_INITIALIZATION - HEIGHT_EQUAL_FUDGE); | ||
124 | Vector3 maxTerrainCoords = new Vector3(DefaultRegionSize.X, DefaultRegionSize.Y, HEIGHT_INITIALIZATION); | ||
125 | int totalHeights = (int)maxTerrainCoords.X * (int)maxTerrainCoords.Y; | ||
126 | float[] initialMap = new float[totalHeights]; | ||
127 | for (int ii = 0; ii < totalHeights; ii++) | ||
128 | { | ||
129 | initialMap[ii] = HEIGHT_INITIALIZATION; | ||
130 | } | ||
131 | UpdateOrCreateTerrain(BSScene.TERRAIN_ID, initialMap, minTerrainCoords, maxTerrainCoords, true); | ||
132 | } | ||
133 | |||
134 | // Release all the terrain structures we might have allocated | ||
135 | public void ReleaseGroundPlaneAndTerrain() | ||
136 | { | ||
137 | if (m_groundPlane.ptr != IntPtr.Zero) | ||
138 | { | ||
139 | if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr)) | ||
140 | { | ||
141 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, m_groundPlane.ptr); | ||
142 | } | ||
143 | m_groundPlane.ptr = IntPtr.Zero; | ||
144 | } | ||
145 | |||
146 | ReleaseTerrain(); | ||
147 | } | ||
148 | |||
149 | // Release all the terrain we have allocated | ||
150 | public void ReleaseTerrain() | ||
151 | { | ||
152 | foreach (KeyValuePair<Vector2, BulletHeightMapInfo> kvp in m_heightMaps) | ||
153 | { | ||
154 | if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, kvp.Value.terrainBody.ptr)) | ||
155 | { | ||
156 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, kvp.Value.terrainBody.ptr); | ||
157 | BulletSimAPI.ReleaseHeightMapInfo2(kvp.Value.Ptr); | ||
158 | } | ||
159 | } | ||
160 | m_heightMaps.Clear(); | ||
161 | } | ||
162 | |||
163 | // The simulator wants to set a new heightmap for the terrain. | ||
164 | public void SetTerrain(float[] heightMap) { | ||
165 | float[] localHeightMap = heightMap; | ||
166 | PhysicsScene.TaintedObject("TerrainManager.SetTerrain", delegate() | ||
167 | { | ||
168 | if (m_worldOffset != Vector3.Zero && MegaRegionParentPhysicsScene != null) | ||
169 | { | ||
170 | // If a child of a mega-region, we shouldn't have any terrain allocated for us | ||
171 | ReleaseGroundPlaneAndTerrain(); | ||
172 | // If doing the mega-prim stuff and we are the child of the zero region, | ||
173 | // the terrain is added to our parent | ||
174 | if (MegaRegionParentPhysicsScene is BSScene) | ||
175 | { | ||
176 | DetailLog("{0},SetTerrain.ToParent,offset={1},worldMax={2}", | ||
177 | BSScene.DetailLogZero, m_worldOffset, m_worldMax); | ||
178 | ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.UpdateOrCreateTerrain(BSScene.CHILDTERRAIN_ID, | ||
179 | localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize, true); | ||
180 | } | ||
181 | } | ||
182 | else | ||
183 | { | ||
184 | // If not doing the mega-prim thing, just change the terrain | ||
185 | DetailLog("{0},SetTerrain.Existing", BSScene.DetailLogZero); | ||
186 | |||
187 | UpdateOrCreateTerrain(BSScene.TERRAIN_ID, localHeightMap, | ||
188 | m_worldOffset, m_worldOffset + DefaultRegionSize, true); | ||
189 | } | ||
190 | }); | ||
191 | } | ||
192 | |||
193 | // If called with no mapInfo for the terrain, this will create a new mapInfo and terrain | ||
194 | // based on the passed information. The 'id' should be either the terrain id or | ||
195 | // BSScene.CHILDTERRAIN_ID. If the latter, a new child terrain ID will be allocated and used. | ||
196 | // The latter feature is for creating child terrains for mega-regions. | ||
197 | // If called with a mapInfo in m_heightMaps but the terrain has no body yet (mapInfo.terrainBody.Ptr == 0) | ||
198 | // then a new body and shape is created and the mapInfo is filled. | ||
199 | // This call is used for doing the initial terrain creation. | ||
200 | // If called with a mapInfo in m_heightMaps and there is an existing terrain body, a new | ||
201 | // terrain shape is created and added to the body. | ||
202 | // This call is most often used to update the heightMap and parameters of the terrain. | ||
203 | // The 'doNow' boolean says whether to do all the unmanaged activities right now (like when | ||
204 | // calling this routine from initialization or taint-time routines) or whether to delay | ||
205 | // all the unmanaged activities to taint-time. | ||
206 | private void UpdateOrCreateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords, bool inTaintTime) | ||
207 | { | ||
208 | DetailLog("{0},BSTerrainManager.UpdateOrCreateTerrain,call,minC={1},maxC={2},inTaintTime={3}", | ||
209 | BSScene.DetailLogZero, minCoords, maxCoords, inTaintTime); | ||
210 | |||
211 | float minZ = float.MaxValue; | ||
212 | float maxZ = float.MinValue; | ||
213 | Vector2 terrainRegionBase = new Vector2(minCoords.X, minCoords.Y); | ||
214 | |||
215 | int heightMapSize = heightMap.Length; | ||
216 | for (int ii = 0; ii < heightMapSize; ii++) | ||
217 | { | ||
218 | float height = heightMap[ii]; | ||
219 | if (height < minZ) minZ = height; | ||
220 | if (height > maxZ) maxZ = height; | ||
221 | } | ||
222 | |||
223 | // The shape of the terrain is from its base to its extents. | ||
224 | minCoords.Z = minZ; | ||
225 | maxCoords.Z = maxZ; | ||
226 | |||
227 | BulletHeightMapInfo mapInfo; | ||
228 | if (m_heightMaps.TryGetValue(terrainRegionBase, out mapInfo)) | ||
229 | { | ||
230 | // If this is terrain we know about, it's easy to update | ||
231 | |||
232 | mapInfo.heightMap = heightMap; | ||
233 | mapInfo.minCoords = minCoords; | ||
234 | mapInfo.maxCoords = maxCoords; | ||
235 | mapInfo.minZ = minZ; | ||
236 | mapInfo.maxZ = maxZ; | ||
237 | mapInfo.sizeX = maxCoords.X - minCoords.X; | ||
238 | mapInfo.sizeY = maxCoords.Y - minCoords.Y; | ||
239 | DetailLog("{0},UpdateOrCreateTerrain:UpdateExisting,call,terrainBase={1},minC={2}, maxC={3}, szX={4}, szY={5}", | ||
240 | BSScene.DetailLogZero, terrainRegionBase, mapInfo.minCoords, mapInfo.maxCoords, mapInfo.sizeX, mapInfo.sizeY); | ||
241 | |||
242 | BSScene.TaintCallback rebuildOperation = delegate() | ||
243 | { | ||
244 | if (MegaRegionParentPhysicsScene != null) | ||
245 | { | ||
246 | // It's possible that Combine() was called after this code was queued. | ||
247 | // If we are a child of combined regions, we don't create any terrain for us. | ||
248 | DetailLog("{0},UpdateOrCreateTerrain:AmACombineChild,taint", BSScene.DetailLogZero); | ||
249 | |||
250 | // Get rid of any terrain that may have been allocated for us. | ||
251 | ReleaseGroundPlaneAndTerrain(); | ||
252 | |||
253 | // I hate doing this, but just bail | ||
254 | return; | ||
255 | } | ||
256 | |||
257 | if (mapInfo.terrainBody.ptr != IntPtr.Zero) | ||
258 | { | ||
259 | // Updating an existing terrain. | ||
260 | DetailLog("{0},UpdateOrCreateTerrain:UpdateExisting,taint,terrainBase={1},minC={2}, maxC={3}, szX={4}, szY={5}", | ||
261 | BSScene.DetailLogZero, terrainRegionBase, mapInfo.minCoords, mapInfo.maxCoords, mapInfo.sizeX, mapInfo.sizeY); | ||
262 | |||
263 | // Remove from the dynamics world because we're going to mangle this object | ||
264 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
265 | |||
266 | // Get rid of the old terrain | ||
267 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
268 | BulletSimAPI.ReleaseHeightMapInfo2(mapInfo.Ptr); | ||
269 | mapInfo.Ptr = IntPtr.Zero; | ||
270 | |||
271 | /* | ||
272 | // NOTE: This routine is half here because I can't get the terrain shape replacement | ||
273 | // to work. In the short term, the above three lines completely delete the old | ||
274 | // terrain and the code below recreates one from scratch. | ||
275 | // Hopefully the Bullet community will help me out on this one. | ||
276 | |||
277 | // First, release the old collision shape (there is only one terrain) | ||
278 | BulletSimAPI.DeleteCollisionShape2(m_physicsScene.World.Ptr, mapInfo.terrainShape.Ptr); | ||
279 | |||
280 | // Fill the existing height map info with the new location and size information | ||
281 | BulletSimAPI.FillHeightMapInfo2(m_physicsScene.World.Ptr, mapInfo.Ptr, mapInfo.ID, | ||
282 | mapInfo.minCoords, mapInfo.maxCoords, mapInfo.heightMap, TERRAIN_COLLISION_MARGIN); | ||
283 | |||
284 | // Create a terrain shape based on the new info | ||
285 | mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(mapInfo.Ptr)); | ||
286 | |||
287 | // Stuff the shape into the existing terrain body | ||
288 | BulletSimAPI.SetBodyShape2(m_physicsScene.World.Ptr, mapInfo.terrainBody.Ptr, mapInfo.terrainShape.Ptr); | ||
289 | */ | ||
290 | } | ||
291 | // else | ||
292 | { | ||
293 | // Creating a new terrain. | ||
294 | DetailLog("{0},UpdateOrCreateTerrain:CreateNewTerrain,taint,baseX={1},baseY={2},minZ={3},maxZ={4}", | ||
295 | BSScene.DetailLogZero, mapInfo.minCoords.X, mapInfo.minCoords.Y, minZ, maxZ); | ||
296 | |||
297 | mapInfo.ID = id; | ||
298 | mapInfo.Ptr = BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, mapInfo.ID, | ||
299 | mapInfo.minCoords, mapInfo.maxCoords, mapInfo.heightMap, TERRAIN_COLLISION_MARGIN); | ||
300 | |||
301 | // Create the terrain shape from the mapInfo | ||
302 | mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(mapInfo.Ptr), | ||
303 | ShapeData.PhysicsShapeType.SHAPE_TERRAIN); | ||
304 | |||
305 | // The terrain object initial position is at the center of the object | ||
306 | Vector3 centerPos; | ||
307 | centerPos.X = minCoords.X + (mapInfo.sizeX / 2f); | ||
308 | centerPos.Y = minCoords.Y + (mapInfo.sizeY / 2f); | ||
309 | centerPos.Z = minZ + ((maxZ - minZ) / 2f); | ||
310 | |||
311 | mapInfo.terrainBody = new BulletBody(mapInfo.ID, | ||
312 | BulletSimAPI.CreateBodyWithDefaultMotionState2(mapInfo.terrainShape.ptr, | ||
313 | id, centerPos, Quaternion.Identity)); | ||
314 | } | ||
315 | |||
316 | // Make sure the entry is in the heightmap table | ||
317 | m_heightMaps[terrainRegionBase] = mapInfo; | ||
318 | |||
319 | // Set current terrain attributes | ||
320 | BulletSimAPI.SetFriction2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainFriction); | ||
321 | BulletSimAPI.SetHitFraction2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainHitFraction); | ||
322 | BulletSimAPI.SetRestitution2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainRestitution); | ||
323 | BulletSimAPI.SetCollisionFlags2(mapInfo.terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT); | ||
324 | |||
325 | // Return the new terrain to the world of physical objects | ||
326 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
327 | |||
328 | // redo its bounding box now that it is in the world | ||
329 | BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
330 | |||
331 | BulletSimAPI.SetCollisionFilterMask2(mapInfo.terrainBody.ptr, | ||
332 | (uint)CollisionFilterGroups.TerrainFilter, | ||
333 | (uint)CollisionFilterGroups.TerrainMask); | ||
334 | |||
335 | // Make sure the new shape is processed. | ||
336 | // BulletSimAPI.Activate2(mapInfo.terrainBody.ptr, true); | ||
337 | BulletSimAPI.ForceActivationState2(mapInfo.terrainBody.ptr, ActivationState.DISABLE_SIMULATION); | ||
338 | |||
339 | m_terrainModified = true; | ||
340 | }; | ||
341 | |||
342 | // There is the option to do the changes now (we're already in 'taint time'), or | ||
343 | // to do the Bullet operations later. | ||
344 | if (inTaintTime) | ||
345 | rebuildOperation(); | ||
346 | else | ||
347 | PhysicsScene.TaintedObject("BSScene.UpdateOrCreateTerrain:UpdateExisting", rebuildOperation); | ||
348 | } | ||
349 | else | ||
350 | { | ||
351 | // We don't know about this terrain so either we are creating a new terrain or | ||
352 | // our mega-prim child is giving us a new terrain to add to the phys world | ||
353 | |||
354 | // if this is a child terrain, calculate a unique terrain id | ||
355 | uint newTerrainID = id; | ||
356 | if (newTerrainID >= BSScene.CHILDTERRAIN_ID) | ||
357 | newTerrainID = ++m_terrainCount; | ||
358 | |||
359 | float[] heightMapX = heightMap; | ||
360 | Vector3 minCoordsX = minCoords; | ||
361 | Vector3 maxCoordsX = maxCoords; | ||
362 | |||
363 | DetailLog("{0},UpdateOrCreateTerrain:NewTerrain,call,id={1}, minC={2}, maxC={3}", | ||
364 | BSScene.DetailLogZero, newTerrainID, minCoords, minCoords); | ||
365 | |||
366 | // Code that must happen at taint-time | ||
367 | BSScene.TaintCallback createOperation = delegate() | ||
368 | { | ||
369 | DetailLog("{0},UpdateOrCreateTerrain:NewTerrain,taint,baseX={1},baseY={2}", BSScene.DetailLogZero, minCoords.X, minCoords.Y); | ||
370 | // Create a new mapInfo that will be filled with the new info | ||
371 | mapInfo = new BulletHeightMapInfo(id, heightMapX, | ||
372 | BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, newTerrainID, | ||
373 | minCoordsX, maxCoordsX, heightMapX, TERRAIN_COLLISION_MARGIN)); | ||
374 | // Put the unfilled heightmap info into the collection of same | ||
375 | m_heightMaps.Add(terrainRegionBase, mapInfo); | ||
376 | // Build the terrain | ||
377 | UpdateOrCreateTerrain(newTerrainID, heightMap, minCoords, maxCoords, true); | ||
378 | |||
379 | m_terrainModified = true; | ||
380 | }; | ||
381 | |||
382 | // If already in taint-time, just call Bullet. Otherwise queue the operations for the safe time. | ||
383 | if (inTaintTime) | ||
384 | createOperation(); | ||
385 | else | ||
386 | PhysicsScene.TaintedObject("BSScene.UpdateOrCreateTerrain:NewTerrain", createOperation); | ||
387 | } | ||
388 | } | ||
389 | |||
390 | // Someday we will have complex terrain with caves and tunnels | ||
391 | public float GetTerrainHeightAtXYZ(Vector3 loc) | ||
392 | { | ||
393 | // For the moment, it's flat and convex | ||
394 | return GetTerrainHeightAtXY(loc.X, loc.Y); | ||
395 | } | ||
396 | |||
397 | // Given an X and Y, find the height of the terrain. | ||
398 | // Since we could be handling multiple terrains for a mega-region, | ||
399 | // the base of the region is calcuated assuming all regions are | ||
400 | // the same size and that is the default. | ||
401 | // Once the heightMapInfo is found, we have all the information to | ||
402 | // compute the offset into the array. | ||
403 | private float lastHeightTX = 999999f; | ||
404 | private float lastHeightTY = 999999f; | ||
405 | private float lastHeight = HEIGHT_INITIAL_LASTHEIGHT; | ||
406 | private float GetTerrainHeightAtXY(float tX, float tY) | ||
407 | { | ||
408 | // You'd be surprized at the number of times this routine is called | ||
409 | // with the same parameters as last time. | ||
410 | if (!m_terrainModified && lastHeightTX == tX && lastHeightTY == tY) | ||
411 | return lastHeight; | ||
412 | |||
413 | lastHeightTX = tX; | ||
414 | lastHeightTY = tY; | ||
415 | float ret = HEIGHT_GETHEIGHT_RET; | ||
416 | |||
417 | int offsetX = ((int)(tX / (int)DefaultRegionSize.X)) * (int)DefaultRegionSize.X; | ||
418 | int offsetY = ((int)(tY / (int)DefaultRegionSize.Y)) * (int)DefaultRegionSize.Y; | ||
419 | Vector2 terrainBaseXY = new Vector2(offsetX, offsetY); | ||
420 | |||
421 | BulletHeightMapInfo mapInfo; | ||
422 | if (m_heightMaps.TryGetValue(terrainBaseXY, out mapInfo)) | ||
423 | { | ||
424 | float regionX = tX - offsetX; | ||
425 | float regionY = tY - offsetY; | ||
426 | int mapIndex = (int)regionY * (int)mapInfo.sizeY + (int)regionX; | ||
427 | try | ||
428 | { | ||
429 | ret = mapInfo.heightMap[mapIndex]; | ||
430 | } | ||
431 | catch | ||
432 | { | ||
433 | // Sometimes they give us wonky values of X and Y. Give a warning and return something. | ||
434 | PhysicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, x={2}, y={3}", | ||
435 | LogHeader, terrainBaseXY, regionX, regionY); | ||
436 | ret = HEIGHT_GETHEIGHT_RET; | ||
437 | } | ||
438 | // DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXY,bX={1},baseY={2},szX={3},szY={4},regX={5},regY={6},index={7},ht={8}", | ||
439 | // BSScene.DetailLogZero, offsetX, offsetY, mapInfo.sizeX, mapInfo.sizeY, regionX, regionY, mapIndex, ret); | ||
440 | } | ||
441 | else | ||
442 | { | ||
443 | PhysicsScene.Logger.ErrorFormat("{0} GetTerrainHeightAtXY: terrain not found: region={1}, x={2}, y={3}", | ||
444 | LogHeader, PhysicsScene.RegionName, tX, tY); | ||
445 | } | ||
446 | m_terrainModified = false; | ||
447 | lastHeight = ret; | ||
448 | return ret; | ||
449 | } | ||
450 | |||
451 | // Although no one seems to check this, I do support combining. | ||
452 | public bool SupportsCombining() | ||
453 | { | ||
454 | return true; | ||
455 | } | ||
456 | |||
457 | // This routine is called two ways: | ||
458 | // One with 'offset' and 'pScene' zero and null but 'extents' giving the maximum | ||
459 | // extent of the combined regions. This is to inform the parent of the size | ||
460 | // of the combined regions. | ||
461 | // and one with 'offset' as the offset of the child region to the base region, | ||
462 | // 'pScene' pointing to the parent and 'extents' of zero. This informs the | ||
463 | // child of its relative base and new parent. | ||
464 | public void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents) | ||
465 | { | ||
466 | m_worldOffset = offset; | ||
467 | m_worldMax = extents; | ||
468 | MegaRegionParentPhysicsScene = pScene; | ||
469 | if (pScene != null) | ||
470 | { | ||
471 | // We are a child. | ||
472 | // We want m_worldMax to be the highest coordinate of our piece of terrain. | ||
473 | m_worldMax = offset + DefaultRegionSize; | ||
474 | } | ||
475 | DetailLog("{0},BSTerrainManager.Combine,offset={1},extents={2},wOffset={3},wMax={4}", | ||
476 | BSScene.DetailLogZero, offset, extents, m_worldOffset, m_worldMax); | ||
477 | } | ||
478 | |||
479 | // Unhook all the combining that I know about. | ||
480 | public void UnCombine(PhysicsScene pScene) | ||
481 | { | ||
482 | // Just like ODE, for the moment a NOP | ||
483 | DetailLog("{0},BSTerrainManager.UnCombine", BSScene.DetailLogZero); | ||
484 | } | ||
485 | |||
486 | |||
487 | private void DetailLog(string msg, params Object[] args) | ||
488 | { | ||
489 | PhysicsScene.PhysicsLogging.Write(msg, args); | ||
490 | } | ||
491 | } | ||
492 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs index 504bd3c..276111c 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs | |||
@@ -33,38 +33,153 @@ using OpenMetaverse; | |||
33 | namespace OpenSim.Region.Physics.BulletSPlugin { | 33 | namespace OpenSim.Region.Physics.BulletSPlugin { |
34 | 34 | ||
35 | // Classes to allow some type checking for the API | 35 | // Classes to allow some type checking for the API |
36 | // These hold pointers to allocated objects in the unmanaged space. | ||
37 | |||
38 | // The physics engine controller class created at initialization | ||
36 | public struct BulletSim | 39 | public struct BulletSim |
37 | { | 40 | { |
38 | public BulletSim(uint id, BSScene bss, IntPtr xx) { ID = id; scene = bss; Ptr = xx; } | 41 | public BulletSim(uint worldId, BSScene bss, IntPtr xx) |
39 | public uint ID; | 42 | { |
43 | ptr = xx; | ||
44 | worldID = worldId; | ||
45 | physicsScene = bss; | ||
46 | } | ||
47 | public IntPtr ptr; | ||
48 | public uint worldID; | ||
40 | // The scene is only in here so very low level routines have a handle to print debug/error messages | 49 | // The scene is only in here so very low level routines have a handle to print debug/error messages |
41 | public BSScene scene; | 50 | public BSScene physicsScene; |
42 | public IntPtr Ptr; | ||
43 | } | 51 | } |
44 | 52 | ||
53 | // An allocated Bullet btRigidBody | ||
45 | public struct BulletBody | 54 | public struct BulletBody |
46 | { | 55 | { |
47 | public BulletBody(uint id, IntPtr xx) { ID = id; Ptr = xx; } | 56 | public BulletBody(uint id, IntPtr xx) |
48 | public IntPtr Ptr; | 57 | { |
58 | ID = id; | ||
59 | ptr = xx; | ||
60 | collisionFilter = 0; | ||
61 | collisionMask = 0; | ||
62 | } | ||
63 | public IntPtr ptr; | ||
49 | public uint ID; | 64 | public uint ID; |
65 | public CollisionFilterGroups collisionFilter; | ||
66 | public CollisionFilterGroups collisionMask; | ||
67 | public override string ToString() | ||
68 | { | ||
69 | StringBuilder buff = new StringBuilder(); | ||
70 | buff.Append("<id="); | ||
71 | buff.Append(ID.ToString()); | ||
72 | buff.Append(",p="); | ||
73 | buff.Append(ptr.ToString("X")); | ||
74 | if (collisionFilter != 0 || collisionMask != 0) | ||
75 | { | ||
76 | buff.Append(",f="); | ||
77 | buff.Append(collisionFilter.ToString("X")); | ||
78 | buff.Append(",m="); | ||
79 | buff.Append(collisionMask.ToString("X")); | ||
80 | } | ||
81 | buff.Append(">"); | ||
82 | return buff.ToString(); | ||
83 | } | ||
84 | } | ||
85 | |||
86 | public struct BulletShape | ||
87 | { | ||
88 | public BulletShape(IntPtr xx) | ||
89 | { | ||
90 | ptr = xx; | ||
91 | type=ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; | ||
92 | shapeKey = 0; | ||
93 | isNativeShape = false; | ||
94 | } | ||
95 | public BulletShape(IntPtr xx, ShapeData.PhysicsShapeType typ) | ||
96 | { | ||
97 | ptr = xx; | ||
98 | type = typ; | ||
99 | shapeKey = 0; | ||
100 | isNativeShape = false; | ||
101 | } | ||
102 | public IntPtr ptr; | ||
103 | public ShapeData.PhysicsShapeType type; | ||
104 | public System.UInt64 shapeKey; | ||
105 | public bool isNativeShape; | ||
106 | public override string ToString() | ||
107 | { | ||
108 | StringBuilder buff = new StringBuilder(); | ||
109 | buff.Append("<p="); | ||
110 | buff.Append(ptr.ToString("X")); | ||
111 | buff.Append(",s="); | ||
112 | buff.Append(type.ToString()); | ||
113 | buff.Append(",k="); | ||
114 | buff.Append(shapeKey.ToString("X")); | ||
115 | buff.Append(",n="); | ||
116 | buff.Append(isNativeShape.ToString()); | ||
117 | buff.Append(">"); | ||
118 | return buff.ToString(); | ||
119 | } | ||
50 | } | 120 | } |
51 | 121 | ||
122 | // Constraint type values as defined by Bullet | ||
123 | public enum ConstraintType : int | ||
124 | { | ||
125 | POINT2POINT_CONSTRAINT_TYPE = 3, | ||
126 | HINGE_CONSTRAINT_TYPE, | ||
127 | CONETWIST_CONSTRAINT_TYPE, | ||
128 | D6_CONSTRAINT_TYPE, | ||
129 | SLIDER_CONSTRAINT_TYPE, | ||
130 | CONTACT_CONSTRAINT_TYPE, | ||
131 | D6_SPRING_CONSTRAINT_TYPE, | ||
132 | MAX_CONSTRAINT_TYPE | ||
133 | } | ||
134 | |||
135 | // An allocated Bullet btConstraint | ||
52 | public struct BulletConstraint | 136 | public struct BulletConstraint |
53 | { | 137 | { |
54 | public BulletConstraint(IntPtr xx) { Ptr = xx; } | 138 | public BulletConstraint(IntPtr xx) |
139 | { | ||
140 | ptr = xx; | ||
141 | } | ||
142 | public IntPtr ptr; | ||
143 | } | ||
144 | |||
145 | // An allocated HeightMapThing which holds various heightmap info. | ||
146 | // Made a class rather than a struct so there would be only one | ||
147 | // instance of this and C# will pass around pointers rather | ||
148 | // than making copies. | ||
149 | public class BulletHeightMapInfo | ||
150 | { | ||
151 | public BulletHeightMapInfo(uint id, float[] hm, IntPtr xx) { | ||
152 | ID = id; | ||
153 | Ptr = xx; | ||
154 | heightMap = hm; | ||
155 | terrainRegionBase = new Vector2(0f, 0f); | ||
156 | minCoords = new Vector3(100f, 100f, 25f); | ||
157 | maxCoords = new Vector3(101f, 101f, 26f); | ||
158 | minZ = maxZ = 0f; | ||
159 | sizeX = sizeY = 256f; | ||
160 | } | ||
161 | public uint ID; | ||
55 | public IntPtr Ptr; | 162 | public IntPtr Ptr; |
163 | public float[] heightMap; | ||
164 | public Vector2 terrainRegionBase; | ||
165 | public Vector3 minCoords; | ||
166 | public Vector3 maxCoords; | ||
167 | public float sizeX, sizeY; | ||
168 | public float minZ, maxZ; | ||
169 | public BulletShape terrainShape; | ||
170 | public BulletBody terrainBody; | ||
56 | } | 171 | } |
57 | 172 | ||
58 | // =============================================================================== | 173 | // =============================================================================== |
59 | [StructLayout(LayoutKind.Sequential)] | 174 | [StructLayout(LayoutKind.Sequential)] |
60 | public struct ConvexHull | 175 | public struct ConvexHull |
61 | { | 176 | { |
62 | Vector3 Offset; | 177 | Vector3 Offset; |
63 | int VertexCount; | 178 | int VertexCount; |
64 | Vector3[] Vertices; | 179 | Vector3[] Vertices; |
65 | } | 180 | } |
66 | [StructLayout(LayoutKind.Sequential)] | 181 | [StructLayout(LayoutKind.Sequential)] |
67 | public struct ShapeData | 182 | public struct ShapeData |
68 | { | 183 | { |
69 | public enum PhysicsShapeType | 184 | public enum PhysicsShapeType |
70 | { | 185 | { |
@@ -75,7 +190,10 @@ public struct ShapeData | |||
75 | SHAPE_CYLINDER = 4, | 190 | SHAPE_CYLINDER = 4, |
76 | SHAPE_SPHERE = 5, | 191 | SHAPE_SPHERE = 5, |
77 | SHAPE_MESH = 6, | 192 | SHAPE_MESH = 6, |
78 | SHAPE_HULL = 7 | 193 | SHAPE_HULL = 7, |
194 | // following defined by BulletSim | ||
195 | SHAPE_GROUNDPLANE = 20, | ||
196 | SHAPE_TERRAIN = 21, | ||
79 | }; | 197 | }; |
80 | public uint ID; | 198 | public uint ID; |
81 | public PhysicsShapeType Type; | 199 | public PhysicsShapeType Type; |
@@ -91,13 +209,24 @@ public struct ShapeData | |||
91 | public float Restitution; | 209 | public float Restitution; |
92 | public float Collidable; // true of things bump into this | 210 | public float Collidable; // true of things bump into this |
93 | public float Static; // true if a static object. Otherwise gravity, etc. | 211 | public float Static; // true if a static object. Otherwise gravity, etc. |
212 | public float Solid; // true if object cannot be passed through | ||
213 | public Vector3 Size; | ||
94 | 214 | ||
95 | // note that bools are passed as floats since bool size changes by language and architecture | 215 | // note that bools are passed as floats since bool size changes by language and architecture |
96 | public const float numericTrue = 1f; | 216 | public const float numericTrue = 1f; |
97 | public const float numericFalse = 0f; | 217 | public const float numericFalse = 0f; |
218 | |||
219 | // The native shapes have predefined shape hash keys | ||
220 | public enum FixedShapeKey : ulong | ||
221 | { | ||
222 | KEY_BOX = 1, | ||
223 | KEY_SPHERE = 2, | ||
224 | KEY_CONE = 3, | ||
225 | KEY_CYLINDER = 4, | ||
226 | } | ||
98 | } | 227 | } |
99 | [StructLayout(LayoutKind.Sequential)] | 228 | [StructLayout(LayoutKind.Sequential)] |
100 | public struct SweepHit | 229 | public struct SweepHit |
101 | { | 230 | { |
102 | public uint ID; | 231 | public uint ID; |
103 | public float Fraction; | 232 | public float Fraction; |
@@ -174,12 +303,38 @@ public struct ConfigurationParameters | |||
174 | public float linkConstraintTransMotorMaxForce; | 303 | public float linkConstraintTransMotorMaxForce; |
175 | public float linkConstraintERP; | 304 | public float linkConstraintERP; |
176 | public float linkConstraintCFM; | 305 | public float linkConstraintCFM; |
306 | public float linkConstraintSolverIterations; | ||
307 | |||
308 | public float physicsLoggingFrames; | ||
177 | 309 | ||
178 | public const float numericTrue = 1f; | 310 | public const float numericTrue = 1f; |
179 | public const float numericFalse = 0f; | 311 | public const float numericFalse = 0f; |
180 | } | 312 | } |
181 | 313 | ||
182 | // Values used by Bullet and BulletSim to control collisions | 314 | |
315 | // The states a bullet collision object can have | ||
316 | public enum ActivationState : uint | ||
317 | { | ||
318 | ACTIVE_TAG = 1, | ||
319 | ISLAND_SLEEPING, | ||
320 | WANTS_DEACTIVATION, | ||
321 | DISABLE_DEACTIVATION, | ||
322 | DISABLE_SIMULATION, | ||
323 | } | ||
324 | |||
325 | public enum CollisionObjectTypes : int | ||
326 | { | ||
327 | CO_COLLISION_OBJECT = 1 << 0, | ||
328 | CO_RIGID_BODY = 1 << 1, | ||
329 | CO_GHOST_OBJECT = 1 << 2, | ||
330 | CO_SOFT_BODY = 1 << 3, | ||
331 | CO_HF_FLUID = 1 << 4, | ||
332 | CO_USER_TYPE = 1 << 5, | ||
333 | } | ||
334 | |||
335 | // Values used by Bullet and BulletSim to control object properties. | ||
336 | // Bullet's "CollisionFlags" has more to do with operations on the | ||
337 | // object (if collisions happen, if gravity effects it, ...). | ||
183 | public enum CollisionFlags : uint | 338 | public enum CollisionFlags : uint |
184 | { | 339 | { |
185 | CF_STATIC_OBJECT = 1 << 0, | 340 | CF_STATIC_OBJECT = 1 << 0, |
@@ -191,11 +346,55 @@ public enum CollisionFlags : uint | |||
191 | CF_DISABLE_SPU_COLLISION_PROCESS = 1 << 6, | 346 | CF_DISABLE_SPU_COLLISION_PROCESS = 1 << 6, |
192 | // Following used by BulletSim to control collisions | 347 | // Following used by BulletSim to control collisions |
193 | BS_SUBSCRIBE_COLLISION_EVENTS = 1 << 10, | 348 | BS_SUBSCRIBE_COLLISION_EVENTS = 1 << 10, |
194 | BS_VOLUME_DETECT_OBJECT = 1 << 11, | 349 | BS_FLOATS_ON_WATER = 1 << 11, |
195 | BS_PHANTOM_OBJECT = 1 << 12, | 350 | BS_NONE = 0, |
196 | BS_PHYSICAL_OBJECT = 1 << 13, | 351 | BS_ALL = 0xFFFFFFFF, |
352 | |||
353 | // These are the collision flags switched depending on physical state. | ||
354 | // The other flags are used for other things and should not be fooled with. | ||
355 | BS_ACTIVE = CF_STATIC_OBJECT | ||
356 | | CF_KINEMATIC_OBJECT | ||
357 | | CF_NO_CONTACT_RESPONSE | ||
358 | }; | ||
359 | |||
360 | // Values for collisions groups and masks | ||
361 | public enum CollisionFilterGroups : uint | ||
362 | { | ||
363 | // Don't use the bit definitions!! Define the use in a | ||
364 | // filter/mask definition below. This way collision interactions | ||
365 | // are more easily debugged. | ||
366 | BNoneFilter = 0, | ||
367 | BDefaultFilter = 1 << 0, | ||
368 | BStaticFilter = 1 << 1, | ||
369 | BKinematicFilter = 1 << 2, | ||
370 | BDebrisFilter = 1 << 3, | ||
371 | BSensorTrigger = 1 << 4, | ||
372 | BCharacterFilter = 1 << 5, | ||
373 | BAllFilter = 0xFFFFFFFF, | ||
374 | // Filter groups defined by BulletSim | ||
375 | BGroundPlaneFilter = 1 << 10, | ||
376 | BTerrainFilter = 1 << 11, | ||
377 | BRaycastFilter = 1 << 12, | ||
378 | BSolidFilter = 1 << 13, | ||
379 | |||
380 | // The collsion filters and masked are defined in one place -- don't want them scattered | ||
381 | AvatarFilter = BCharacterFilter, | ||
382 | AvatarMask = BAllFilter, | ||
383 | ObjectFilter = BSolidFilter, | ||
384 | ObjectMask = BAllFilter, | ||
385 | StaticObjectFilter = BStaticFilter, | ||
386 | StaticObjectMask = BAllFilter, | ||
387 | VolumeDetectFilter = BSensorTrigger, | ||
388 | VolumeDetectMask = ~BSensorTrigger, | ||
389 | TerrainFilter = BTerrainFilter, | ||
390 | TerrainMask = BAllFilter & ~BStaticFilter, | ||
391 | GroundPlaneFilter = BAllFilter, | ||
392 | GroundPlaneMask = BAllFilter | ||
393 | |||
197 | }; | 394 | }; |
198 | 395 | ||
396 | |||
397 | |||
199 | // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0 | 398 | // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0 |
200 | // ERP controls amount of correction per tick. Usable range=0.1..0.8. Default=0.2. | 399 | // ERP controls amount of correction per tick. Usable range=0.1..0.8. Default=0.2. |
201 | public enum ConstraintParams : int | 400 | public enum ConstraintParams : int |
@@ -221,14 +420,22 @@ public enum ConstraintParamAxis : int | |||
221 | // =============================================================================== | 420 | // =============================================================================== |
222 | static class BulletSimAPI { | 421 | static class BulletSimAPI { |
223 | 422 | ||
423 | // Link back to the managed code for outputting log messages | ||
424 | [UnmanagedFunctionPointer(CallingConvention.Cdecl)] | ||
425 | public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg); | ||
426 | |||
224 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 427 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
225 | [return: MarshalAs(UnmanagedType.LPStr)] | 428 | [return: MarshalAs(UnmanagedType.LPStr)] |
226 | public static extern string GetVersion(); | 429 | public static extern string GetVersion(); |
227 | 430 | ||
228 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 431 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
229 | public static extern uint Initialize(Vector3 maxPosition, IntPtr parms, | 432 | public static extern uint Initialize(Vector3 maxPosition, IntPtr parms, |
230 | int maxCollisions, IntPtr collisionArray, | 433 | int maxCollisions, IntPtr collisionArray, |
231 | int maxUpdates, IntPtr updateArray); | 434 | int maxUpdates, IntPtr updateArray, |
435 | DebugLogCallback logRoutine); | ||
436 | |||
437 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
438 | public static extern void CreateInitialGroundPlaneAndTerrain(uint worldID); | ||
232 | 439 | ||
233 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 440 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
234 | public static extern void SetHeightmap(uint worldID, [MarshalAs(UnmanagedType.LPArray)] float[] heightMap); | 441 | public static extern void SetHeightmap(uint worldID, [MarshalAs(UnmanagedType.LPArray)] float[] heightMap); |
@@ -242,19 +449,19 @@ public static extern bool UpdateParameter(uint worldID, uint localID, | |||
242 | 449 | ||
243 | // =============================================================================== | 450 | // =============================================================================== |
244 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 451 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
245 | public static extern int PhysicsStep(uint worldID, float timeStep, int maxSubSteps, float fixedTimeStep, | 452 | public static extern int PhysicsStep(uint worldID, float timeStep, int maxSubSteps, float fixedTimeStep, |
246 | out int updatedEntityCount, | 453 | out int updatedEntityCount, |
247 | out IntPtr updatedEntitiesPtr, | 454 | out IntPtr updatedEntitiesPtr, |
248 | out int collidersCount, | 455 | out int collidersCount, |
249 | out IntPtr collidersPtr); | 456 | out IntPtr collidersPtr); |
250 | 457 | ||
251 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 458 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
252 | public static extern bool CreateHull(uint worldID, System.UInt64 meshKey, | 459 | public static extern bool CreateHull(uint worldID, System.UInt64 meshKey, |
253 | int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls | 460 | int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls |
254 | ); | 461 | ); |
255 | 462 | ||
256 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 463 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
257 | public static extern bool CreateMesh(uint worldID, System.UInt64 meshKey, | 464 | public static extern bool CreateMesh(uint worldID, System.UInt64 meshKey, |
258 | int indexCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices, | 465 | int indexCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices, |
259 | int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices | 466 | int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices |
260 | ); | 467 | ); |
@@ -268,23 +475,6 @@ public static extern bool DestroyMesh(uint worldID, System.UInt64 meshKey); | |||
268 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 475 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
269 | public static extern bool CreateObject(uint worldID, ShapeData shapeData); | 476 | public static extern bool CreateObject(uint worldID, ShapeData shapeData); |
270 | 477 | ||
271 | /* Remove old functionality | ||
272 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
273 | public static extern void CreateLinkset(uint worldID, int objectCount, ShapeData[] shapeDatas); | ||
274 | |||
275 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
276 | public static extern void AddConstraint(uint worldID, uint id1, uint id2, | ||
277 | Vector3 frame1, Quaternion frame1rot, | ||
278 | Vector3 frame2, Quaternion frame2rot, | ||
279 | Vector3 lowLinear, Vector3 hiLinear, Vector3 lowAngular, Vector3 hiAngular); | ||
280 | |||
281 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
282 | public static extern bool RemoveConstraintByID(uint worldID, uint id1); | ||
283 | |||
284 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
285 | public static extern bool RemoveConstraint(uint worldID, uint id1, uint id2); | ||
286 | */ | ||
287 | |||
288 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 478 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
289 | public static extern Vector3 GetObjectPosition(uint WorldID, uint id); | 479 | public static extern Vector3 GetObjectPosition(uint WorldID, uint id); |
290 | 480 | ||
@@ -300,6 +490,7 @@ public static extern bool SetObjectVelocity(uint worldID, uint id, Vector3 veloc | |||
300 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 490 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
301 | public static extern bool SetObjectAngularVelocity(uint worldID, uint id, Vector3 angularVelocity); | 491 | public static extern bool SetObjectAngularVelocity(uint worldID, uint id, Vector3 angularVelocity); |
302 | 492 | ||
493 | // Set the current force acting on the object | ||
303 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 494 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
304 | public static extern bool SetObjectForce(uint worldID, uint id, Vector3 force); | 495 | public static extern bool SetObjectForce(uint worldID, uint id, Vector3 force); |
305 | 496 | ||
@@ -342,8 +533,6 @@ public static extern Vector3 RecoverFromPenetration(uint worldID, uint id); | |||
342 | public static extern void DumpBulletStatistics(); | 533 | public static extern void DumpBulletStatistics(); |
343 | 534 | ||
344 | // Log a debug message | 535 | // Log a debug message |
345 | [UnmanagedFunctionPointer(CallingConvention.Cdecl)] | ||
346 | public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg); | ||
347 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 536 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
348 | public static extern void SetDebugLogCallback(DebugLogCallback callback); | 537 | public static extern void SetDebugLogCallback(DebugLogCallback callback); |
349 | 538 | ||
@@ -358,6 +547,7 @@ public static extern void SetDebugLogCallback(DebugLogCallback callback); | |||
358 | // The names have a "2" tacked on. This will be removed as the C# code gets rebuilt | 547 | // The names have a "2" tacked on. This will be removed as the C# code gets rebuilt |
359 | // and the old code is removed. | 548 | // and the old code is removed. |
360 | 549 | ||
550 | // Functions use while converting from API1 to API2. Can be removed when totally converted. | ||
361 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 551 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
362 | public static extern IntPtr GetSimHandle2(uint worldID); | 552 | public static extern IntPtr GetSimHandle2(uint worldID); |
363 | 553 | ||
@@ -368,6 +558,7 @@ public static extern IntPtr GetBodyHandleWorldID2(uint worldID, uint id); | |||
368 | public static extern IntPtr GetBodyHandle2(IntPtr world, uint id); | 558 | public static extern IntPtr GetBodyHandle2(IntPtr world, uint id); |
369 | 559 | ||
370 | // =============================================================================== | 560 | // =============================================================================== |
561 | // Initialization and simulation | ||
371 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 562 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
372 | public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms, | 563 | public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms, |
373 | int maxCollisions, IntPtr collisionArray, | 564 | int maxCollisions, IntPtr collisionArray, |
@@ -377,14 +568,14 @@ public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms, | |||
377 | public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value); | 568 | public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value); |
378 | 569 | ||
379 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 570 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
380 | public static extern void SetHeightmap2(IntPtr world, float[] heightmap); | 571 | public static extern void SetHeightMap2(IntPtr world, float[] heightmap); |
381 | 572 | ||
382 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 573 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
383 | public static extern void Shutdown2(IntPtr sim); | 574 | public static extern void Shutdown2(IntPtr sim); |
384 | 575 | ||
385 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 576 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
386 | public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep, | 577 | public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep, |
387 | out int updatedEntityCount, | 578 | out int updatedEntityCount, |
388 | out IntPtr updatedEntitiesPtr, | 579 | out IntPtr updatedEntitiesPtr, |
389 | out int collidersCount, | 580 | out int collidersCount, |
390 | out IntPtr collidersPtr); | 581 | out IntPtr collidersPtr); |
@@ -392,24 +583,87 @@ public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSt | |||
392 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 583 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
393 | public static extern bool PushUpdate2(IntPtr obj); | 584 | public static extern bool PushUpdate2(IntPtr obj); |
394 | 585 | ||
395 | /* | 586 | // ===================================================================================== |
587 | // Mesh, hull, shape and body creation helper routines | ||
588 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
589 | public static extern IntPtr CreateMeshShape2(IntPtr world, | ||
590 | int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices, | ||
591 | int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices ); | ||
592 | |||
593 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
594 | public static extern IntPtr CreateHullShape2(IntPtr world, | ||
595 | int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls); | ||
596 | |||
597 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
598 | public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape); | ||
599 | |||
600 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
601 | public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData); | ||
602 | |||
603 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
604 | public static extern bool IsNativeShape2(IntPtr shape); | ||
605 | |||
606 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
607 | public static extern IntPtr CreateCompoundShape2(IntPtr sim); | ||
608 | |||
609 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
610 | public static extern void AddChildToCompoundShape2(IntPtr cShape, IntPtr addShape, Vector3 pos, Quaternion rot); | ||
611 | |||
612 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
613 | public static extern void RemoveChildFromCompoundShape2(IntPtr cShape, IntPtr removeShape); | ||
614 | |||
615 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
616 | public static extern IntPtr DuplicateCollisionShape2(IntPtr sim, IntPtr srcShape, uint id); | ||
617 | |||
618 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
619 | public static extern IntPtr CreateBodyFromShapeAndInfo2(IntPtr sim, IntPtr shape, uint id, IntPtr constructionInfo); | ||
620 | |||
621 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
622 | public static extern bool DeleteCollisionShape2(IntPtr world, IntPtr shape); | ||
623 | |||
624 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
625 | public static extern int GetBodyType2(IntPtr obj); | ||
626 | |||
396 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 627 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
397 | public static extern IntPtr CreateMesh2(IntPtr world, int indicesCount, int* indices, int verticesCount, float* vertices ); | 628 | public static extern IntPtr CreateBodyFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot); |
398 | 629 | ||
399 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 630 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
400 | public static extern bool BuildHull2(IntPtr world, IntPtr mesh); | 631 | public static extern IntPtr CreateBodyWithDefaultMotionState2(IntPtr shape, uint id, Vector3 pos, Quaternion rot); |
401 | 632 | ||
402 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 633 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
403 | public static extern bool ReleaseHull2(IntPtr world, IntPtr mesh); | 634 | public static extern IntPtr CreateGhostFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot); |
404 | 635 | ||
405 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 636 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
406 | public static extern bool DestroyMesh2(IntPtr world, IntPtr mesh); | 637 | public static extern IntPtr AllocateBodyInfo2(IntPtr obj); |
407 | 638 | ||
408 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 639 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
409 | public static extern IntPtr CreateObject2(IntPtr world, ShapeData shapeData); | 640 | public static extern void ReleaseBodyInfo2(IntPtr obj); |
410 | */ | ||
411 | 641 | ||
412 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 642 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
643 | public static extern void DestroyObject2(IntPtr sim, IntPtr obj); | ||
644 | |||
645 | // ===================================================================================== | ||
646 | // Terrain creation and helper routines | ||
647 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
648 | public static extern IntPtr CreateHeightMapInfo2(IntPtr sim, uint id, Vector3 minCoords, Vector3 maxCoords, | ||
649 | [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin); | ||
650 | |||
651 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
652 | public static extern IntPtr FillHeightMapInfo2(IntPtr sim, IntPtr mapInfo, uint id, Vector3 minCoords, Vector3 maxCoords, | ||
653 | [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin); | ||
654 | |||
655 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
656 | public static extern bool ReleaseHeightMapInfo2(IntPtr heightMapInfo); | ||
657 | |||
658 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
659 | public static extern IntPtr CreateGroundPlaneShape2(uint id, float height, float collisionMargin); | ||
660 | |||
661 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
662 | public static extern IntPtr CreateTerrainShape2(IntPtr mapInfo); | ||
663 | |||
664 | // ===================================================================================== | ||
665 | // Constraint creation and helper routines | ||
666 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
413 | public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2, | 667 | public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2, |
414 | Vector3 frame1loc, Quaternion frame1rot, | 668 | Vector3 frame1loc, Quaternion frame1rot, |
415 | Vector3 frame2loc, Quaternion frame2rot, | 669 | Vector3 frame2loc, Quaternion frame2rot, |
@@ -433,7 +687,7 @@ public static extern void SetConstraintEnable2(IntPtr constrain, float numericTr | |||
433 | public static extern void SetConstraintNumSolverIterations2(IntPtr constrain, float iterations); | 687 | public static extern void SetConstraintNumSolverIterations2(IntPtr constrain, float iterations); |
434 | 688 | ||
435 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 689 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
436 | public static extern bool SetFrames2(IntPtr constrain, | 690 | public static extern bool SetFrames2(IntPtr constrain, |
437 | Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot); | 691 | Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot); |
438 | 692 | ||
439 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 693 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
@@ -460,11 +714,108 @@ public static extern bool SetConstraintParam2(IntPtr constrain, ConstraintParams | |||
460 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 714 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
461 | public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain); | 715 | public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain); |
462 | 716 | ||
717 | // ===================================================================================== | ||
718 | // btCollisionWorld entries | ||
719 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
720 | public static extern void UpdateSingleAabb2(IntPtr world, IntPtr obj); | ||
721 | |||
722 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
723 | public static extern void UpdateAabbs2(IntPtr world); | ||
724 | |||
725 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
726 | public static extern bool GetForceUpdateAllAabbs2(IntPtr world); | ||
727 | |||
728 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
729 | public static extern void SetForceUpdateAllAabbs2(IntPtr world, bool force); | ||
730 | |||
731 | // ===================================================================================== | ||
732 | // btDynamicsWorld entries | ||
733 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
734 | public static extern bool AddObjectToWorld2(IntPtr world, IntPtr obj); | ||
735 | |||
736 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
737 | public static extern bool RemoveObjectFromWorld2(IntPtr world, IntPtr obj); | ||
738 | |||
739 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
740 | public static extern bool AddConstraintToWorld2(IntPtr world, IntPtr constrain, bool disableCollisionsBetweenLinkedObjects); | ||
741 | |||
742 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
743 | public static extern bool RemoveConstraintFromWorld2(IntPtr world, IntPtr constrain); | ||
744 | // ===================================================================================== | ||
745 | // btCollisionObject entries | ||
746 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
747 | public static extern Vector3 GetAnisotripicFriction2(IntPtr constrain); | ||
748 | |||
749 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
750 | public static extern Vector3 SetAnisotripicFriction2(IntPtr constrain, Vector3 frict); | ||
751 | |||
752 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
753 | public static extern bool HasAnisotripicFriction2(IntPtr constrain); | ||
754 | |||
755 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
756 | public static extern void SetContactProcessingThreshold2(IntPtr obj, float val); | ||
757 | |||
758 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
759 | public static extern float GetContactProcessingThreshold2(IntPtr obj); | ||
760 | |||
761 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
762 | public static extern bool IsStaticObject2(IntPtr obj); | ||
763 | |||
764 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
765 | public static extern bool IsKinematicObject2(IntPtr obj); | ||
766 | |||
767 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
768 | public static extern bool IsStaticOrKinematicObject2(IntPtr obj); | ||
769 | |||
770 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
771 | public static extern bool HasContactResponse2(IntPtr obj); | ||
772 | |||
773 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
774 | public static extern void SetCollisionShape2(IntPtr sim, IntPtr obj, IntPtr shape); | ||
775 | |||
776 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
777 | public static extern IntPtr GetCollisionShape2(IntPtr obj); | ||
778 | |||
779 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
780 | public static extern int GetActivationState2(IntPtr obj); | ||
781 | |||
782 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
783 | public static extern void SetActivationState2(IntPtr obj, int state); | ||
784 | |||
785 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
786 | public static extern void SetDeactivationTime2(IntPtr obj, float dtime); | ||
787 | |||
788 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
789 | public static extern float GetDeactivationTime2(IntPtr obj); | ||
790 | |||
791 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
792 | public static extern void ForceActivationState2(IntPtr obj, ActivationState state); | ||
793 | |||
794 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
795 | public static extern void Activate2(IntPtr obj, bool forceActivation); | ||
796 | |||
797 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
798 | public static extern bool IsActive2(IntPtr obj); | ||
799 | |||
800 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
801 | public static extern void SetRestitution2(IntPtr obj, float val); | ||
802 | |||
803 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
804 | public static extern float GetRestitution2(IntPtr obj); | ||
805 | |||
806 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
807 | public static extern void SetFriction2(IntPtr obj, float val); | ||
808 | |||
463 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 809 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
464 | public static extern Vector3 AddObjectToWorld2(IntPtr world, IntPtr obj); | 810 | public static extern float GetFriction2(IntPtr obj); |
465 | 811 | ||
812 | /* Haven't defined the type 'Transform' | ||
466 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 813 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
467 | public static extern Vector3 RemoveObjectFromWorld2(IntPtr world, IntPtr obj); | 814 | public static extern Transform GetWorldTransform2(IntPtr obj); |
815 | |||
816 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
817 | public static extern void setWorldTransform2(IntPtr obj, Transform trans); | ||
818 | */ | ||
468 | 819 | ||
469 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 820 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
470 | public static extern Vector3 GetPosition2(IntPtr obj); | 821 | public static extern Vector3 GetPosition2(IntPtr obj); |
@@ -473,85 +824,290 @@ public static extern Vector3 GetPosition2(IntPtr obj); | |||
473 | public static extern Quaternion GetOrientation2(IntPtr obj); | 824 | public static extern Quaternion GetOrientation2(IntPtr obj); |
474 | 825 | ||
475 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 826 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
476 | public static extern bool SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation); | 827 | public static extern void SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation); |
477 | 828 | ||
478 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 829 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
479 | public static extern bool SetVelocity2(IntPtr obj, Vector3 velocity); | 830 | public static extern IntPtr GetBroadphaseHandle2(IntPtr obj); |
480 | 831 | ||
481 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 832 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
482 | public static extern bool SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity); | 833 | public static extern void SetBroadphaseHandle2(IntPtr obj, IntPtr handle); |
483 | 834 | ||
835 | /* | ||
484 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 836 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
485 | public static extern bool SetObjectForce2(IntPtr obj, Vector3 force); | 837 | public static extern Transform GetInterpolationWorldTransform2(IntPtr obj); |
486 | 838 | ||
487 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 839 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
488 | public static extern bool AddObjectForce2(IntPtr obj, Vector3 force); | 840 | public static extern void SetInterpolationWorldTransform2(IntPtr obj, Transform trans); |
841 | */ | ||
489 | 842 | ||
490 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 843 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
491 | public static extern bool SetCcdMotionThreshold2(IntPtr obj, float val); | 844 | public static extern void SetInterpolationLinearVelocity2(IntPtr obj, Vector3 vel); |
492 | 845 | ||
493 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 846 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
494 | public static extern bool SetCcdSweepSphereRadius2(IntPtr obj, float val); | 847 | public static extern void SetInterpolationAngularVelocity2(IntPtr obj, Vector3 vel); |
495 | 848 | ||
496 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 849 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
497 | public static extern bool SetDamping2(IntPtr obj, float lin_damping, float ang_damping); | 850 | public static extern void SetInterpolationVelocity2(IntPtr obj, Vector3 linearVel, Vector3 angularVel); |
498 | 851 | ||
499 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 852 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
500 | public static extern bool SetDeactivationTime2(IntPtr obj, float val); | 853 | public static extern float GetHitFraction2(IntPtr obj); |
501 | 854 | ||
502 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 855 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
503 | public static extern bool SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold); | 856 | public static extern void SetHitFraction2(IntPtr obj, float val); |
504 | 857 | ||
505 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 858 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
506 | public static extern bool SetContactProcessingThreshold2(IntPtr obj, float val); | 859 | public static extern CollisionFlags GetCollisionFlags2(IntPtr obj); |
507 | 860 | ||
508 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 861 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
509 | public static extern bool SetFriction2(IntPtr obj, float val); | 862 | public static extern CollisionFlags SetCollisionFlags2(IntPtr obj, CollisionFlags flags); |
510 | 863 | ||
511 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 864 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
512 | public static extern bool SetRestitution2(IntPtr obj, float val); | 865 | public static extern CollisionFlags AddToCollisionFlags2(IntPtr obj, CollisionFlags flags); |
513 | 866 | ||
514 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 867 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
515 | public static extern bool SetLinearVelocity2(IntPtr obj, Vector3 val); | 868 | public static extern CollisionFlags RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags); |
516 | 869 | ||
517 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 870 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
518 | public static extern bool SetInterpolation2(IntPtr obj, Vector3 lin, Vector3 ang); | 871 | public static extern float GetCcdMotionThreshold2(IntPtr obj); |
519 | 872 | ||
520 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 873 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
521 | public static extern CollisionFlags GetCollisionFlags2(IntPtr obj); | 874 | public static extern void SetCcdMotionThreshold2(IntPtr obj, float val); |
875 | |||
876 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
877 | public static extern float GetCcdSweepSphereRadius2(IntPtr obj); | ||
878 | |||
879 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
880 | public static extern void SetCcdSweepSphereRadius2(IntPtr obj, float val); | ||
881 | |||
882 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
883 | public static extern IntPtr GetUserPointer2(IntPtr obj); | ||
884 | |||
885 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
886 | public static extern void SetUserPointer2(IntPtr obj, IntPtr val); | ||
887 | |||
888 | // ===================================================================================== | ||
889 | // btRigidBody entries | ||
890 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
891 | public static extern void ApplyGravity2(IntPtr obj); | ||
892 | |||
893 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
894 | public static extern void SetGravity2(IntPtr obj, Vector3 val); | ||
895 | |||
896 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
897 | public static extern Vector3 GetGravity2(IntPtr obj); | ||
898 | |||
899 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
900 | public static extern void SetDamping2(IntPtr obj, float lin_damping, float ang_damping); | ||
901 | |||
902 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
903 | public static extern float GetLinearDamping2(IntPtr obj); | ||
904 | |||
905 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
906 | public static extern float GetAngularDamping2(IntPtr obj); | ||
907 | |||
908 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
909 | public static extern float GetLinearSleepingThreshold2(IntPtr obj); | ||
910 | |||
911 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
912 | public static extern float GetAngularSleepingThreshold2(IntPtr obj); | ||
913 | |||
914 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
915 | public static extern void ApplyDamping2(IntPtr obj, float timeStep); | ||
916 | |||
917 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
918 | public static extern void SetMassProps2(IntPtr obj, float mass, Vector3 inertia); | ||
919 | |||
920 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
921 | public static extern Vector3 GetLinearFactor2(IntPtr obj); | ||
922 | |||
923 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
924 | public static extern void SetLinearFactor2(IntPtr obj, Vector3 factor); | ||
925 | |||
926 | /* | ||
927 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
928 | public static extern void SetCenterOfMassTransform2(IntPtr obj, Transform trans); | ||
929 | */ | ||
930 | |||
931 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
932 | public static extern void SetCenterOfMassByPosRot2(IntPtr obj, Vector3 pos, Quaternion rot); | ||
933 | |||
934 | // Add a force to the object as if its mass is one. | ||
935 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
936 | public static extern void ApplyCentralForce2(IntPtr obj, Vector3 force); | ||
937 | |||
938 | // Set the force being applied to the object as if its mass is one. | ||
939 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
940 | public static extern void SetObjectForce2(IntPtr obj, Vector3 force); | ||
941 | |||
942 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
943 | public static extern Vector3 GetTotalForce2(IntPtr obj); | ||
944 | |||
945 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
946 | public static extern Vector3 GetTotalTorque2(IntPtr obj); | ||
947 | |||
948 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
949 | public static extern Vector3 GetInvInertiaDiagLocal2(IntPtr obj); | ||
950 | |||
951 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
952 | public static extern void SetInvInertiaDiagLocal2(IntPtr obj, Vector3 inert); | ||
953 | |||
954 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
955 | public static extern void SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold); | ||
956 | |||
957 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
958 | public static extern void ApplyTorque2(IntPtr obj, Vector3 torque); | ||
959 | |||
960 | // Apply force at the given point. Will add torque to the object. | ||
961 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
962 | public static extern void ApplyForce2(IntPtr obj, Vector3 force, Vector3 pos); | ||
963 | |||
964 | // Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass. | ||
965 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
966 | public static extern void ApplyCentralImpulse2(IntPtr obj, Vector3 imp); | ||
967 | |||
968 | // Apply impulse to the object's torque. Force is scaled by object's mass. | ||
969 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
970 | public static extern void ApplyTorqueImpulse2(IntPtr obj, Vector3 imp); | ||
971 | |||
972 | // Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces. | ||
973 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
974 | public static extern void ApplyImpulse2(IntPtr obj, Vector3 imp, Vector3 pos); | ||
975 | |||
976 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
977 | public static extern void ClearForces2(IntPtr obj); | ||
978 | |||
979 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
980 | public static extern void ClearAllForces2(IntPtr obj); | ||
981 | |||
982 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
983 | public static extern void UpdateInertiaTensor2(IntPtr obj); | ||
984 | |||
985 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
986 | public static extern Vector3 GetCenterOfMassPosition2(IntPtr obj); | ||
987 | |||
988 | /* | ||
989 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
990 | public static extern Transform GetCenterOfMassTransform2(IntPtr obj); | ||
991 | */ | ||
992 | |||
993 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
994 | public static extern Vector3 GetLinearVelocity2(IntPtr obj); | ||
995 | |||
996 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
997 | public static extern Vector3 GetAngularVelocity2(IntPtr obj); | ||
998 | |||
999 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1000 | public static extern void SetLinearVelocity2(IntPtr obj, Vector3 val); | ||
1001 | |||
1002 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1003 | public static extern void SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity); | ||
1004 | |||
1005 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1006 | public static extern Vector3 GetVelocityInLocalPoint2(IntPtr obj, Vector3 pos); | ||
1007 | |||
1008 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1009 | public static extern void Translate2(IntPtr obj, Vector3 trans); | ||
1010 | |||
1011 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1012 | public static extern void UpdateDeactivation2(IntPtr obj, float timeStep); | ||
1013 | |||
1014 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1015 | public static extern bool WantsSleeping2(IntPtr obj); | ||
1016 | |||
1017 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1018 | public static extern void SetAngularFactor2(IntPtr obj, float factor); | ||
1019 | |||
1020 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1021 | public static extern void SetAngularFactorV2(IntPtr obj, Vector3 factor); | ||
1022 | |||
1023 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1024 | public static extern Vector3 GetAngularFactor2(IntPtr obj); | ||
1025 | |||
1026 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1027 | public static extern bool IsInWorld2(IntPtr obj); | ||
1028 | |||
1029 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1030 | public static extern void AddConstraintRef2(IntPtr obj, IntPtr constrain); | ||
1031 | |||
1032 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1033 | public static extern void RemoveConstraintRef2(IntPtr obj, IntPtr constrain); | ||
1034 | |||
1035 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1036 | public static extern IntPtr GetConstraintRef2(IntPtr obj, int index); | ||
1037 | |||
1038 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1039 | public static extern int GetNumConstraintRefs2(IntPtr obj); | ||
1040 | |||
1041 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1042 | public static extern void SetCollisionFilterMask2(IntPtr body, uint filter, uint mask); | ||
1043 | |||
1044 | // ===================================================================================== | ||
1045 | // btCollisionShape entries | ||
1046 | |||
1047 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1048 | public static extern float GetAngularMotionDisc2(IntPtr shape); | ||
1049 | |||
1050 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1051 | public static extern float GetContactBreakingThreshold2(IntPtr shape, float defaultFactor); | ||
1052 | |||
1053 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1054 | public static extern bool IsPolyhedral2(IntPtr shape); | ||
1055 | |||
1056 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1057 | public static extern bool IsConvex2d2(IntPtr shape); | ||
1058 | |||
1059 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1060 | public static extern bool IsConvex2(IntPtr shape); | ||
1061 | |||
1062 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1063 | public static extern bool IsNonMoving2(IntPtr shape); | ||
1064 | |||
1065 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1066 | public static extern bool IsConcave2(IntPtr shape); | ||
1067 | |||
1068 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1069 | public static extern bool IsCompound2(IntPtr shape); | ||
1070 | |||
1071 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1072 | public static extern bool IsSoftBody2(IntPtr shape); | ||
1073 | |||
1074 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
1075 | public static extern bool IsInfinite2(IntPtr shape); | ||
522 | 1076 | ||
523 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1077 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
524 | public static extern IntPtr SetCollisionFlags2(IntPtr obj, CollisionFlags flags); | 1078 | public static extern void SetLocalScaling2(IntPtr shape, Vector3 scale); |
525 | 1079 | ||
526 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1080 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
527 | public static extern IntPtr AddToCollisionFlags2(IntPtr obj, CollisionFlags flags); | 1081 | public static extern Vector3 GetLocalScaling2(IntPtr shape); |
528 | 1082 | ||
529 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1083 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
530 | public static extern IntPtr RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags); | 1084 | public static extern Vector3 CalculateLocalInertia2(IntPtr shape, float mass); |
531 | 1085 | ||
532 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1086 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
533 | public static extern bool SetMassProps2(IntPtr obj, float mass, Vector3 inertia); | 1087 | public static extern int GetShapeType2(IntPtr shape); |
534 | 1088 | ||
535 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1089 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
536 | public static extern bool UpdateInertiaTensor2(IntPtr obj); | 1090 | public static extern void SetMargin2(IntPtr shape, float val); |
537 | 1091 | ||
538 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1092 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
539 | public static extern bool SetGravity2(IntPtr obj, Vector3 val); | 1093 | public static extern float GetMargin2(IntPtr shape); |
540 | 1094 | ||
1095 | // ===================================================================================== | ||
1096 | // Debugging | ||
541 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1097 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
542 | public static extern IntPtr ClearForces2(IntPtr obj); | 1098 | public static extern void DumpRigidBody2(IntPtr sim, IntPtr collisionObject); |
543 | 1099 | ||
544 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1100 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
545 | public static extern IntPtr ClearAllForces2(IntPtr obj); | 1101 | public static extern void DumpCollisionShape2(IntPtr sim, IntPtr collisionShape); |
546 | 1102 | ||
547 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1103 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
548 | public static extern bool SetMargin2(IntPtr obj, float val); | 1104 | public static extern void DumpConstraint2(IntPtr sim, IntPtr constrain); |
549 | 1105 | ||
550 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1106 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
551 | public static extern bool UpdateSingleAabb2(IntPtr world, IntPtr obj); | 1107 | public static extern void DumpAllInfo2(IntPtr sim); |
552 | 1108 | ||
553 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1109 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
554 | public static extern bool DestroyObject2(IntPtr world, uint id); | 1110 | public static extern void DumpMapInfo2(IntPtr sim, IntPtr manInfo); |
555 | 1111 | ||
556 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1112 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
557 | public static extern void DumpPhysicsStatistics2(IntPtr sim); | 1113 | public static extern void DumpPhysicsStatistics2(IntPtr sim); |