diff options
Diffstat (limited to 'OpenSim/Region/Physics/BulletSPlugin')
19 files changed, 5937 insertions, 2431 deletions
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs index e2f7af9..3c48dcc 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs | |||
@@ -28,62 +28,48 @@ 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 sealed 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; | ||
48 | private PrimitiveBaseShape _pbs; | ||
49 | private uint _localID = 0; | ||
50 | private bool _grabbed; | 44 | private bool _grabbed; |
51 | private bool _selected; | 45 | private bool _selected; |
52 | private Vector3 _position; | 46 | private OMV.Vector3 _position; |
53 | private float _mass; | 47 | private float _mass; |
54 | public float _density; | 48 | private float _avatarDensity; |
55 | public float _avatarVolume; | 49 | private float _avatarVolume; |
56 | private Vector3 _force; | 50 | private OMV.Vector3 _force; |
57 | private Vector3 _velocity; | 51 | private OMV.Vector3 _velocity; |
58 | private Vector3 _torque; | 52 | private OMV.Vector3 _torque; |
59 | private float _collisionScore; | 53 | private float _collisionScore; |
60 | private Vector3 _acceleration; | 54 | private OMV.Vector3 _acceleration; |
61 | private Quaternion _orientation; | 55 | private OMV.Quaternion _orientation; |
62 | private int _physicsActorType; | 56 | private int _physicsActorType; |
63 | private bool _isPhysical; | 57 | private bool _isPhysical; |
64 | private bool _flying; | 58 | private bool _flying; |
65 | private bool _setAlwaysRun; | 59 | private bool _setAlwaysRun; |
66 | private bool _throttleUpdates; | 60 | private bool _throttleUpdates; |
67 | private bool _isColliding; | 61 | private bool _isColliding; |
68 | private long _collidingStep; | ||
69 | private bool _collidingGround; | ||
70 | private long _collidingGroundStep; | ||
71 | private bool _collidingObj; | 62 | private bool _collidingObj; |
72 | private bool _floatOnWater; | 63 | private bool _floatOnWater; |
73 | private Vector3 _rotationalVelocity; | 64 | private OMV.Vector3 _rotationalVelocity; |
74 | private bool _kinematic; | 65 | private bool _kinematic; |
75 | private float _buoyancy; | 66 | private float _buoyancy; |
76 | 67 | ||
77 | private BulletBody m_body; | 68 | // The friction and velocity of the avatar is modified depending on whether walking or not. |
78 | public BulletBody Body { | 69 | private OMV.Vector3 _appliedVelocity; // the last velocity applied to the avatar |
79 | get { return m_body; } | 70 | private float _currentFriction; // the friction currently being used (changed by setVelocity). |
80 | set { m_body = value; } | ||
81 | } | ||
82 | |||
83 | private int _subscribedEventsMs = 0; | ||
84 | private int _nextCollisionOkTime = 0; | ||
85 | 71 | ||
86 | private Vector3 _PIDTarget; | 72 | private OMV.Vector3 _PIDTarget; |
87 | private bool _usePID; | 73 | private bool _usePID; |
88 | private float _PIDTau; | 74 | private float _PIDTau; |
89 | private bool _useHoverPID; | 75 | private bool _useHoverPID; |
@@ -91,332 +77,524 @@ public class BSCharacter : PhysicsActor | |||
91 | private PIDHoverType _PIDHoverType; | 77 | private PIDHoverType _PIDHoverType; |
92 | private float _PIDHoverTao; | 78 | private float _PIDHoverTao; |
93 | 79 | ||
94 | public BSCharacter(uint localID, String avName, BSScene parent_scene, Vector3 pos, Vector3 size, bool isFlying) | 80 | public BSCharacter(uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, bool isFlying) |
81 | : base(parent_scene, localID, avName, "BSCharacter") | ||
95 | { | 82 | { |
96 | _localID = localID; | 83 | _physicsActorType = (int)ActorTypes.Agent; |
97 | _avName = avName; | ||
98 | _scene = parent_scene; | ||
99 | _position = pos; | 84 | _position = pos; |
100 | _size = size; | 85 | _size = size; |
101 | _flying = isFlying; | 86 | _flying = isFlying; |
102 | _orientation = Quaternion.Identity; | 87 | _orientation = OMV.Quaternion.Identity; |
103 | _velocity = Vector3.Zero; | 88 | _velocity = OMV.Vector3.Zero; |
89 | _appliedVelocity = OMV.Vector3.Zero; | ||
104 | _buoyancy = ComputeBuoyancyFromFlying(isFlying); | 90 | _buoyancy = ComputeBuoyancyFromFlying(isFlying); |
91 | _currentFriction = PhysicsScene.Params.avatarStandingFriction; | ||
92 | _avatarDensity = PhysicsScene.Params.avatarDensity; | ||
93 | |||
105 | // The dimensions of the avatar capsule are kept in the scale. | 94 | // The dimensions of the avatar capsule are kept in the scale. |
106 | // Physics creates a unit capsule which is scaled by the physics engine. | 95 | // Physics creates a unit capsule which is scaled by the physics engine. |
107 | _scale = new Vector3(_scene.Params.avatarCapsuleRadius, _scene.Params.avatarCapsuleRadius, size.Z); | 96 | ComputeAvatarScale(_size); |
108 | _density = _scene.Params.avatarDensity; | 97 | // set _avatarVolume and _mass based on capsule size, _density and Scale |
109 | ComputeAvatarVolumeAndMass(); // set _avatarVolume and _mass based on capsule size, _density and _scale | 98 | ComputeAvatarVolumeAndMass(); |
110 | 99 | DetailLog("{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5}", | |
111 | ShapeData shapeData = new ShapeData(); | 100 | LocalID, _size, Scale, _avatarDensity, _avatarVolume, RawMass); |
112 | shapeData.ID = _localID; | ||
113 | shapeData.Type = ShapeData.PhysicsShapeType.SHAPE_AVATAR; | ||
114 | shapeData.Position = _position; | ||
115 | shapeData.Rotation = _orientation; | ||
116 | shapeData.Velocity = _velocity; | ||
117 | shapeData.Scale = _scale; | ||
118 | shapeData.Mass = _mass; | ||
119 | shapeData.Buoyancy = _buoyancy; | ||
120 | shapeData.Static = ShapeData.numericFalse; | ||
121 | shapeData.Friction = _scene.Params.avatarFriction; | ||
122 | shapeData.Restitution = _scene.Params.avatarRestitution; | ||
123 | 101 | ||
124 | // do actual create at taint time | 102 | // do actual create at taint time |
125 | _scene.TaintedObject("BSCharacter.create", delegate() | 103 | PhysicsScene.TaintedObject("BSCharacter.create", delegate() |
126 | { | 104 | { |
127 | BulletSimAPI.CreateObject(parent_scene.WorldID, shapeData); | 105 | DetailLog("{0},BSCharacter.create,taint", LocalID); |
106 | // New body and shape into PhysBody and PhysShape | ||
107 | PhysicsScene.Shapes.GetBodyAndShape(true, PhysicsScene.World, this, null, null); | ||
128 | 108 | ||
129 | m_body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID)); | 109 | SetPhysicalProperties(); |
130 | // avatars get all collisions no matter what | ||
131 | BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
132 | }); | 110 | }); |
133 | |||
134 | return; | 111 | return; |
135 | } | 112 | } |
136 | 113 | ||
137 | // called when this character is being destroyed and the resources should be released | 114 | // called when this character is being destroyed and the resources should be released |
138 | public void Destroy() | 115 | public override void Destroy() |
139 | { | 116 | { |
140 | // DetailLog("{0},BSCharacter.Destroy", LocalID); | 117 | DetailLog("{0},BSCharacter.Destroy", LocalID); |
141 | _scene.TaintedObject("BSCharacter.destroy", delegate() | 118 | PhysicsScene.TaintedObject("BSCharacter.destroy", delegate() |
142 | { | 119 | { |
143 | BulletSimAPI.DestroyObject(_scene.WorldID, _localID); | 120 | PhysicsScene.Shapes.DereferenceBody(PhysBody, true, null); |
121 | PhysicsScene.Shapes.DereferenceShape(PhysShape, true, null); | ||
144 | }); | 122 | }); |
145 | } | 123 | } |
146 | 124 | ||
125 | private void SetPhysicalProperties() | ||
126 | { | ||
127 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr); | ||
128 | |||
129 | ZeroMotion(true); | ||
130 | ForcePosition = _position; | ||
131 | // Set the velocity and compute the proper friction | ||
132 | ForceVelocity = _velocity; | ||
133 | |||
134 | // This will enable or disable the flying buoyancy of the avatar. | ||
135 | // Needs to be reset especially when an avatar is recreated after crossing a region boundry. | ||
136 | Flying = _flying; | ||
137 | |||
138 | BulletSimAPI.SetRestitution2(PhysBody.ptr, PhysicsScene.Params.avatarRestitution); | ||
139 | BulletSimAPI.SetMargin2(PhysShape.ptr, PhysicsScene.Params.collisionMargin); | ||
140 | BulletSimAPI.SetLocalScaling2(PhysShape.ptr, Scale); | ||
141 | BulletSimAPI.SetContactProcessingThreshold2(PhysBody.ptr, PhysicsScene.Params.contactProcessingThreshold); | ||
142 | if (PhysicsScene.Params.ccdMotionThreshold > 0f) | ||
143 | { | ||
144 | BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, PhysicsScene.Params.ccdMotionThreshold); | ||
145 | BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, PhysicsScene.Params.ccdSweptSphereRadius); | ||
146 | } | ||
147 | |||
148 | UpdatePhysicalMassProperties(RawMass); | ||
149 | |||
150 | // Make so capsule does not fall over | ||
151 | BulletSimAPI.SetAngularFactorV2(PhysBody.ptr, OMV.Vector3.Zero); | ||
152 | |||
153 | BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_CHARACTER_OBJECT); | ||
154 | |||
155 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, PhysBody.ptr); | ||
156 | |||
157 | // BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ACTIVE_TAG); | ||
158 | BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.DISABLE_DEACTIVATION); | ||
159 | BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, PhysBody.ptr); | ||
160 | |||
161 | // Do this after the object has been added to the world | ||
162 | BulletSimAPI.SetCollisionFilterMask2(PhysBody.ptr, | ||
163 | (uint)CollisionFilterGroups.AvatarFilter, | ||
164 | (uint)CollisionFilterGroups.AvatarMask); | ||
165 | } | ||
166 | |||
147 | public override void RequestPhysicsterseUpdate() | 167 | public override void RequestPhysicsterseUpdate() |
148 | { | 168 | { |
149 | base.RequestPhysicsterseUpdate(); | 169 | base.RequestPhysicsterseUpdate(); |
150 | } | 170 | } |
151 | // No one calls this method so I don't know what it could possibly mean | 171 | // No one calls this method so I don't know what it could possibly mean |
152 | public override bool Stopped { | 172 | public override bool Stopped { get { return false; } } |
153 | get { return false; } | 173 | |
154 | } | 174 | public override OMV.Vector3 Size { |
155 | public override Vector3 Size { | ||
156 | get | 175 | get |
157 | { | 176 | { |
158 | // Avatar capsule size is kept in the scale parameter. | 177 | // Avatar capsule size is kept in the scale parameter. |
159 | return new Vector3(_scale.X * 2, _scale.Y * 2, _scale.Z); | 178 | // return _size; |
179 | return new OMV.Vector3(Scale.X * 2f, Scale.Y * 2f, Scale.Z); | ||
160 | } | 180 | } |
161 | 181 | ||
162 | set { | 182 | set { |
163 | // When an avatar's size is set, only the height is changed | 183 | // When an avatar's size is set, only the height is changed. |
164 | // and that really only depends on the radius. | ||
165 | _size = value; | 184 | _size = value; |
166 | _scale.Z = (_size.Z * 1.15f) - (_scale.X + _scale.Y); | 185 | ComputeAvatarScale(_size); |
167 | |||
168 | // TODO: something has to be done with the avatar's vertical position | ||
169 | |||
170 | ComputeAvatarVolumeAndMass(); | 186 | ComputeAvatarVolumeAndMass(); |
187 | DetailLog("{0},BSCharacter.setSize,call,scale={1},density={2},volume={3},mass={4}", | ||
188 | LocalID, Scale, _avatarDensity, _avatarVolume, RawMass); | ||
171 | 189 | ||
172 | _scene.TaintedObject("BSCharacter.setSize", delegate() | 190 | PhysicsScene.TaintedObject("BSCharacter.setSize", delegate() |
173 | { | 191 | { |
174 | BulletSimAPI.SetObjectScaleMass(_scene.WorldID, LocalID, _scale, _mass, true); | 192 | BulletSimAPI.SetLocalScaling2(PhysShape.ptr, Scale); |
193 | UpdatePhysicalMassProperties(RawMass); | ||
175 | }); | 194 | }); |
176 | 195 | ||
177 | } | 196 | } |
178 | } | 197 | } |
179 | public override PrimitiveBaseShape Shape { | 198 | |
180 | set { _pbs = value; | 199 | public override OMV.Vector3 Scale { get; set; } |
181 | } | 200 | |
201 | public override PrimitiveBaseShape Shape | ||
202 | { | ||
203 | set { BaseShape = value; } | ||
182 | } | 204 | } |
183 | public override uint LocalID { | 205 | // I want the physics engine to make an avatar capsule |
184 | set { _localID = value; | 206 | public override ShapeData.PhysicsShapeType PreferredPhysicalShape |
185 | } | 207 | { |
186 | get { return _localID; } | 208 | get {return ShapeData.PhysicsShapeType.SHAPE_AVATAR; } |
187 | } | 209 | } |
188 | public override bool Grabbed { | 210 | |
189 | set { _grabbed = value; | 211 | public override bool Grabbed { |
190 | } | 212 | set { _grabbed = value; } |
191 | } | 213 | } |
192 | public override bool Selected { | 214 | public override bool Selected { |
193 | set { _selected = value; | 215 | set { _selected = value; } |
194 | } | ||
195 | } | 216 | } |
196 | public override void CrossingFailure() { return; } | 217 | public override void CrossingFailure() { return; } |
197 | public override void link(PhysicsActor obj) { return; } | 218 | public override void link(PhysicsActor obj) { return; } |
198 | public override void delink() { return; } | 219 | public override void delink() { return; } |
199 | public override void LockAngularMotion(Vector3 axis) { return; } | ||
200 | 220 | ||
201 | public override Vector3 Position { | 221 | // Set motion values to zero. |
222 | // Do it to the properties so the values get set in the physics engine. | ||
223 | // Push the setting of the values to the viewer. | ||
224 | // Called at taint time! | ||
225 | public override void ZeroMotion(bool inTaintTime) | ||
226 | { | ||
227 | _velocity = OMV.Vector3.Zero; | ||
228 | _acceleration = OMV.Vector3.Zero; | ||
229 | _rotationalVelocity = OMV.Vector3.Zero; | ||
230 | |||
231 | // Zero some other properties directly into the physics engine | ||
232 | PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.ZeroMotion", delegate() | ||
233 | { | ||
234 | BulletSimAPI.ClearAllForces2(PhysBody.ptr); | ||
235 | }); | ||
236 | } | ||
237 | public override void ZeroAngularMotion(bool inTaintTime) | ||
238 | { | ||
239 | _rotationalVelocity = OMV.Vector3.Zero; | ||
240 | |||
241 | PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.ZeroMotion", delegate() | ||
242 | { | ||
243 | BulletSimAPI.SetInterpolationAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero); | ||
244 | BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero); | ||
245 | // The next also get rid of applied linear force but the linear velocity is untouched. | ||
246 | BulletSimAPI.ClearForces2(PhysBody.ptr); | ||
247 | }); | ||
248 | } | ||
249 | |||
250 | |||
251 | public override void LockAngularMotion(OMV.Vector3 axis) { return; } | ||
252 | |||
253 | public override OMV.Vector3 RawPosition | ||
254 | { | ||
255 | get { return _position; } | ||
256 | set { _position = value; } | ||
257 | } | ||
258 | public override OMV.Vector3 Position { | ||
202 | get { | 259 | get { |
203 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 260 | // Don't refetch the position because this function is called a zillion times |
204 | return _position; | 261 | // _position = BulletSimAPI.GetObjectPosition2(Scene.World.ptr, LocalID); |
205 | } | 262 | return _position; |
263 | } | ||
206 | set { | 264 | set { |
207 | _position = value; | 265 | _position = value; |
208 | PositionSanityCheck(); | 266 | PositionSanityCheck(); |
209 | 267 | ||
210 | _scene.TaintedObject("BSCharacter.setPosition", delegate() | 268 | PhysicsScene.TaintedObject("BSCharacter.setPosition", delegate() |
211 | { | 269 | { |
212 | DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); | 270 | DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); |
213 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 271 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); |
214 | }); | 272 | }); |
215 | } | 273 | } |
216 | } | 274 | } |
275 | public override OMV.Vector3 ForcePosition { | ||
276 | get { | ||
277 | _position = BulletSimAPI.GetPosition2(PhysBody.ptr); | ||
278 | return _position; | ||
279 | } | ||
280 | set { | ||
281 | _position = value; | ||
282 | PositionSanityCheck(); | ||
283 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); | ||
284 | } | ||
285 | } | ||
286 | |||
217 | 287 | ||
218 | // Check that the current position is sane and, if not, modify the position to make it so. | 288 | // 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. | 289 | // Check for being below terrain or on water. |
220 | // Returns 'true' of the position was made sane by some action. | 290 | // Returns 'true' of the position was made sane by some action. |
221 | private bool PositionSanityCheck() | 291 | private bool PositionSanityCheck() |
222 | { | 292 | { |
223 | bool ret = false; | 293 | bool ret = false; |
224 | 294 | ||
225 | // If below the ground, move the avatar up | 295 | // If below the ground, move the avatar up |
226 | float terrainHeight = Scene.GetTerrainHeightAtXYZ(_position); | 296 | float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(_position); |
227 | if (_position.Z < terrainHeight) | 297 | if (Position.Z < terrainHeight) |
228 | { | 298 | { |
229 | DetailLog("{0},BSCharacter.PositionAdjustUnderGround,call,pos={1},orient={2}", LocalID, _position, _orientation); | 299 | DetailLog("{0},BSCharacter.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, _position, terrainHeight); |
230 | _position.Z = terrainHeight + 2.0f; | 300 | _position.Z = terrainHeight + 2.0f; |
231 | ret = true; | 301 | ret = true; |
232 | } | 302 | } |
303 | if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0) | ||
304 | { | ||
305 | float waterHeight = PhysicsScene.GetWaterLevelAtXYZ(_position); | ||
306 | if (Position.Z < waterHeight) | ||
307 | { | ||
308 | _position.Z = waterHeight; | ||
309 | ret = true; | ||
310 | } | ||
311 | } | ||
233 | 312 | ||
234 | // TODO: check for out of bounds | 313 | // TODO: check for out of bounds |
314 | return ret; | ||
315 | } | ||
235 | 316 | ||
317 | // A version of the sanity check that also makes sure a new position value is | ||
318 | // pushed back to the physics engine. This routine would be used by anyone | ||
319 | // who is not already pushing the value. | ||
320 | private bool PositionSanityCheck(bool inTaintTime) | ||
321 | { | ||
322 | bool ret = false; | ||
323 | if (PositionSanityCheck()) | ||
324 | { | ||
325 | // The new position value must be pushed into the physics engine but we can't | ||
326 | // just assign to "Position" because of potential call loops. | ||
327 | PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.PositionSanityCheck", delegate() | ||
328 | { | ||
329 | DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation); | ||
330 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); | ||
331 | }); | ||
332 | ret = true; | ||
333 | } | ||
236 | return ret; | 334 | return ret; |
237 | } | 335 | } |
238 | 336 | ||
239 | public override float Mass { | 337 | public override float Mass { get { return _mass; } } |
240 | get { | 338 | |
241 | return _mass; | 339 | // used when we only want this prim's mass and not the linkset thing |
242 | } | 340 | public override float RawMass { |
341 | get {return _mass; } | ||
243 | } | 342 | } |
244 | public override Vector3 Force { | 343 | public override void UpdatePhysicalMassProperties(float physMass) |
245 | get { return _force; } | 344 | { |
345 | OMV.Vector3 localInertia = BulletSimAPI.CalculateLocalInertia2(PhysShape.ptr, physMass); | ||
346 | BulletSimAPI.SetMassProps2(PhysBody.ptr, physMass, localInertia); | ||
347 | } | ||
348 | |||
349 | public override OMV.Vector3 Force { | ||
350 | get { return _force; } | ||
246 | set { | 351 | set { |
247 | _force = value; | 352 | _force = value; |
248 | // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force); | 353 | // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force); |
249 | Scene.TaintedObject("BSCharacter.SetForce", delegate() | 354 | PhysicsScene.TaintedObject("BSCharacter.SetForce", delegate() |
250 | { | 355 | { |
251 | DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, _force); | 356 | DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, _force); |
252 | BulletSimAPI.SetObjectForce(Scene.WorldID, LocalID, _force); | 357 | BulletSimAPI.SetObjectForce2(PhysBody.ptr, _force); |
253 | }); | 358 | }); |
254 | } | 359 | } |
255 | } | 360 | } |
256 | 361 | ||
257 | public override int VehicleType { | 362 | // Avatars don't do vehicles |
258 | get { return 0; } | 363 | public override int VehicleType { get { return (int)Vehicle.TYPE_NONE; } set { return; } } |
259 | set { return; } | ||
260 | } | ||
261 | public override void VehicleFloatParam(int param, float value) { } | 364 | public override void VehicleFloatParam(int param, float value) { } |
262 | public override void VehicleVectorParam(int param, Vector3 value) {} | 365 | public override void VehicleVectorParam(int param, OMV.Vector3 value) {} |
263 | public override void VehicleRotationParam(int param, Quaternion rotation) { } | 366 | public override void VehicleRotationParam(int param, OMV.Quaternion rotation) { } |
264 | public override void VehicleFlags(int param, bool remove) { } | 367 | public override void VehicleFlags(int param, bool remove) { } |
265 | 368 | ||
266 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more | 369 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more |
267 | public override void SetVolumeDetect(int param) { return; } | 370 | public override void SetVolumeDetect(int param) { return; } |
268 | 371 | ||
269 | public override Vector3 GeometricCenter { get { return Vector3.Zero; } } | 372 | public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } } |
270 | public override Vector3 CenterOfMass { get { return Vector3.Zero; } } | 373 | public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } } |
271 | public override Vector3 Velocity { | 374 | public override OMV.Vector3 Velocity { |
272 | get { return _velocity; } | 375 | get { return _velocity; } |
273 | set { | 376 | set { |
274 | _velocity = value; | 377 | _velocity = value; |
275 | // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, _velocity); | 378 | // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, _velocity); |
276 | _scene.TaintedObject("BSCharacter.setVelocity", delegate() | 379 | PhysicsScene.TaintedObject("BSCharacter.setVelocity", delegate() |
277 | { | 380 | { |
278 | DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, _velocity); | 381 | DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, _velocity); |
279 | BulletSimAPI.SetObjectVelocity(_scene.WorldID, _localID, _velocity); | 382 | ForceVelocity = _velocity; |
280 | }); | 383 | }); |
281 | } | 384 | } |
282 | } | 385 | } |
283 | public override Vector3 Torque { | 386 | public override OMV.Vector3 ForceVelocity { |
284 | get { return _torque; } | 387 | get { return _velocity; } |
285 | set { _torque = value; | 388 | set { |
286 | } | 389 | // Depending on whether the avatar is moving or not, change the friction |
390 | // to keep the avatar from slipping around | ||
391 | if (_velocity.Length() == 0) | ||
392 | { | ||
393 | if (_currentFriction != PhysicsScene.Params.avatarStandingFriction) | ||
394 | { | ||
395 | _currentFriction = PhysicsScene.Params.avatarStandingFriction; | ||
396 | BulletSimAPI.SetFriction2(PhysBody.ptr, _currentFriction); | ||
397 | } | ||
398 | } | ||
399 | else | ||
400 | { | ||
401 | if (_currentFriction != PhysicsScene.Params.avatarFriction) | ||
402 | { | ||
403 | _currentFriction = PhysicsScene.Params.avatarFriction; | ||
404 | BulletSimAPI.SetFriction2(PhysBody.ptr, _currentFriction); | ||
405 | } | ||
406 | } | ||
407 | _velocity = value; | ||
408 | // Remember the set velocity so we can suppress the reduction by friction, ... | ||
409 | _appliedVelocity = value; | ||
410 | |||
411 | BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity); | ||
412 | BulletSimAPI.Activate2(PhysBody.ptr, true); | ||
413 | } | ||
287 | } | 414 | } |
288 | public override float CollisionScore { | 415 | public override OMV.Vector3 Torque { |
289 | get { return _collisionScore; } | 416 | get { return _torque; } |
290 | set { _collisionScore = value; | 417 | set { _torque = value; |
291 | } | 418 | } |
419 | } | ||
420 | public override float CollisionScore { | ||
421 | get { return _collisionScore; } | ||
422 | set { _collisionScore = value; | ||
423 | } | ||
292 | } | 424 | } |
293 | public override Vector3 Acceleration { | 425 | public override OMV.Vector3 Acceleration { |
294 | get { return _acceleration; } | 426 | get { return _acceleration; } |
295 | set { _acceleration = value; } | 427 | set { _acceleration = value; } |
296 | } | 428 | } |
297 | public override Quaternion Orientation { | 429 | public override OMV.Quaternion RawOrientation |
298 | get { return _orientation; } | 430 | { |
431 | get { return _orientation; } | ||
432 | set { _orientation = value; } | ||
433 | } | ||
434 | public override OMV.Quaternion Orientation { | ||
435 | get { return _orientation; } | ||
299 | set { | 436 | set { |
300 | _orientation = value; | 437 | _orientation = value; |
301 | // m_log.DebugFormat("{0}: set orientation to {1}", LogHeader, _orientation); | 438 | // m_log.DebugFormat("{0}: set orientation to {1}", LogHeader, _orientation); |
302 | _scene.TaintedObject("BSCharacter.setOrientation", delegate() | 439 | PhysicsScene.TaintedObject("BSCharacter.setOrientation", delegate() |
303 | { | 440 | { |
304 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 441 | // _position = BulletSimAPI.GetPosition2(BSBody.ptr); |
305 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 442 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); |
306 | }); | 443 | }); |
307 | } | 444 | } |
445 | } | ||
446 | // Go directly to Bullet to get/set the value. | ||
447 | public override OMV.Quaternion ForceOrientation | ||
448 | { | ||
449 | get | ||
450 | { | ||
451 | _orientation = BulletSimAPI.GetOrientation2(PhysBody.ptr); | ||
452 | return _orientation; | ||
453 | } | ||
454 | set | ||
455 | { | ||
456 | _orientation = value; | ||
457 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); | ||
458 | } | ||
308 | } | 459 | } |
309 | public override int PhysicsActorType { | 460 | public override int PhysicsActorType { |
310 | get { return _physicsActorType; } | 461 | get { return _physicsActorType; } |
311 | set { _physicsActorType = value; | 462 | set { _physicsActorType = value; |
312 | } | 463 | } |
313 | } | 464 | } |
314 | public override bool IsPhysical { | 465 | public override bool IsPhysical { |
315 | get { return _isPhysical; } | 466 | get { return _isPhysical; } |
316 | set { _isPhysical = value; | 467 | set { _isPhysical = value; |
317 | } | 468 | } |
318 | } | 469 | } |
319 | public override bool Flying { | 470 | public override bool IsSolid { |
320 | get { return _flying; } | 471 | get { return true; } |
472 | } | ||
473 | public override bool IsStatic { | ||
474 | get { return false; } | ||
475 | } | ||
476 | public override bool Flying { | ||
477 | get { return _flying; } | ||
321 | set { | 478 | set { |
322 | if (_flying != value) | 479 | _flying = value; |
323 | { | 480 | // simulate flying by changing the effect of gravity |
324 | _flying = value; | 481 | Buoyancy = ComputeBuoyancyFromFlying(_flying); |
325 | // simulate flying by changing the effect of gravity | 482 | } |
326 | this.Buoyancy = ComputeBuoyancyFromFlying(_flying); | ||
327 | } | ||
328 | } | ||
329 | } | 483 | } |
484 | // Flying is implimented by changing the avatar's buoyancy. | ||
485 | // Would this be done better with a vehicle type? | ||
330 | private float ComputeBuoyancyFromFlying(bool ifFlying) { | 486 | private float ComputeBuoyancyFromFlying(bool ifFlying) { |
331 | return ifFlying ? 1f : 0f; | 487 | return ifFlying ? 1f : 0f; |
332 | } | 488 | } |
333 | public override bool | 489 | public override bool |
334 | SetAlwaysRun { | 490 | SetAlwaysRun { |
335 | get { return _setAlwaysRun; } | 491 | get { return _setAlwaysRun; } |
336 | set { _setAlwaysRun = value; } | 492 | set { _setAlwaysRun = value; } |
337 | } | 493 | } |
338 | public override bool ThrottleUpdates { | 494 | public override bool ThrottleUpdates { |
339 | get { return _throttleUpdates; } | 495 | get { return _throttleUpdates; } |
340 | set { _throttleUpdates = value; } | 496 | set { _throttleUpdates = value; } |
341 | } | 497 | } |
342 | public override bool IsColliding { | 498 | public override bool IsColliding { |
343 | get { return (_collidingStep == _scene.SimulationStep); } | 499 | get { return (CollidingStep == PhysicsScene.SimulationStep); } |
344 | set { _isColliding = value; } | 500 | set { _isColliding = value; } |
345 | } | 501 | } |
346 | public override bool CollidingGround { | 502 | public override bool CollidingGround { |
347 | get { return (_collidingGroundStep == _scene.SimulationStep); } | 503 | get { return (CollidingGroundStep == PhysicsScene.SimulationStep); } |
348 | set { _collidingGround = value; } | 504 | set { CollidingGround = value; } |
349 | } | 505 | } |
350 | public override bool CollidingObj { | 506 | public override bool CollidingObj { |
351 | get { return _collidingObj; } | 507 | get { return _collidingObj; } |
352 | set { _collidingObj = value; } | 508 | set { _collidingObj = value; } |
353 | } | 509 | } |
354 | public override bool FloatOnWater { | 510 | public override bool FloatOnWater { |
355 | set { _floatOnWater = value; } | 511 | set { |
512 | _floatOnWater = value; | ||
513 | PhysicsScene.TaintedObject("BSCharacter.setFloatOnWater", delegate() | ||
514 | { | ||
515 | if (_floatOnWater) | ||
516 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
517 | else | ||
518 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
519 | }); | ||
520 | } | ||
356 | } | 521 | } |
357 | public override Vector3 RotationalVelocity { | 522 | public override OMV.Vector3 RotationalVelocity { |
358 | get { return _rotationalVelocity; } | 523 | get { return _rotationalVelocity; } |
359 | set { _rotationalVelocity = value; } | 524 | set { _rotationalVelocity = value; } |
360 | } | 525 | } |
361 | public override bool Kinematic { | 526 | public override OMV.Vector3 ForceRotationalVelocity { |
362 | get { return _kinematic; } | 527 | get { return _rotationalVelocity; } |
363 | set { _kinematic = value; } | 528 | set { _rotationalVelocity = value; } |
529 | } | ||
530 | public override bool Kinematic { | ||
531 | get { return _kinematic; } | ||
532 | set { _kinematic = value; } | ||
364 | } | 533 | } |
365 | // neg=fall quickly, 0=1g, 1=0g, pos=float up | 534 | // neg=fall quickly, 0=1g, 1=0g, pos=float up |
366 | public override float Buoyancy { | 535 | public override float Buoyancy { |
367 | get { return _buoyancy; } | 536 | get { return _buoyancy; } |
368 | set { _buoyancy = value; | 537 | set { _buoyancy = value; |
369 | _scene.TaintedObject("BSCharacter.setBuoyancy", delegate() | 538 | PhysicsScene.TaintedObject("BSCharacter.setBuoyancy", delegate() |
370 | { | 539 | { |
371 | DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy); | 540 | DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy); |
372 | BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, LocalID, _buoyancy); | 541 | ForceBuoyancy = _buoyancy; |
373 | }); | 542 | }); |
374 | } | 543 | } |
544 | } | ||
545 | public override float ForceBuoyancy { | ||
546 | get { return _buoyancy; } | ||
547 | set { _buoyancy = value; | ||
548 | DetailLog("{0},BSCharacter.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy); | ||
549 | // Buoyancy is faked by changing the gravity applied to the object | ||
550 | float grav = PhysicsScene.Params.gravity * (1f - _buoyancy); | ||
551 | BulletSimAPI.SetGravity2(PhysBody.ptr, new OMV.Vector3(0f, 0f, grav)); | ||
552 | } | ||
375 | } | 553 | } |
376 | 554 | ||
377 | // Used for MoveTo | 555 | // Used for MoveTo |
378 | public override Vector3 PIDTarget { | 556 | public override OMV.Vector3 PIDTarget { |
379 | set { _PIDTarget = value; } | 557 | set { _PIDTarget = value; } |
380 | } | 558 | } |
381 | public override bool PIDActive { | 559 | public override bool PIDActive { |
382 | set { _usePID = value; } | 560 | set { _usePID = value; } |
383 | } | 561 | } |
384 | public override float PIDTau { | 562 | public override float PIDTau { |
385 | set { _PIDTau = value; } | 563 | set { _PIDTau = value; } |
386 | } | 564 | } |
387 | 565 | ||
388 | // Used for llSetHoverHeight and maybe vehicle height | 566 | // Used for llSetHoverHeight and maybe vehicle height |
389 | // Hover Height will override MoveTo target's Z | 567 | // Hover Height will override MoveTo target's Z |
390 | public override bool PIDHoverActive { | 568 | public override bool PIDHoverActive { |
391 | set { _useHoverPID = value; } | 569 | set { _useHoverPID = value; } |
392 | } | 570 | } |
393 | public override float PIDHoverHeight { | 571 | public override float PIDHoverHeight { |
394 | set { _PIDHoverHeight = value; } | 572 | set { _PIDHoverHeight = value; } |
395 | } | 573 | } |
396 | public override PIDHoverType PIDHoverType { | 574 | public override PIDHoverType PIDHoverType { |
397 | set { _PIDHoverType = value; } | 575 | set { _PIDHoverType = value; } |
398 | } | 576 | } |
399 | public override float PIDHoverTau { | 577 | public override float PIDHoverTau { |
400 | set { _PIDHoverTao = value; } | 578 | set { _PIDHoverTao = value; } |
401 | } | 579 | } |
402 | 580 | ||
403 | // For RotLookAt | 581 | // For RotLookAt |
404 | public override Quaternion APIDTarget { set { return; } } | 582 | public override OMV.Quaternion APIDTarget { set { return; } } |
405 | public override bool APIDActive { set { return; } } | 583 | public override bool APIDActive { set { return; } } |
406 | public override float APIDStrength { set { return; } } | 584 | public override float APIDStrength { set { return; } } |
407 | public override float APIDDamping { set { return; } } | 585 | public override float APIDDamping { set { return; } } |
408 | 586 | ||
409 | public override void AddForce(Vector3 force, bool pushforce) { | 587 | public override void AddForce(OMV.Vector3 force, bool pushforce) { |
410 | if (force.IsFinite()) | 588 | if (force.IsFinite()) |
411 | { | 589 | { |
412 | _force.X += force.X; | 590 | _force.X += force.X; |
413 | _force.Y += force.Y; | 591 | _force.Y += force.Y; |
414 | _force.Z += force.Z; | 592 | _force.Z += force.Z; |
415 | // m_log.DebugFormat("{0}: AddForce. adding={1}, newForce={2}", LogHeader, force, _force); | 593 | // m_log.DebugFormat("{0}: AddForce. adding={1}, newForce={2}", LogHeader, force, _force); |
416 | _scene.TaintedObject("BSCharacter.AddForce", delegate() | 594 | PhysicsScene.TaintedObject("BSCharacter.AddForce", delegate() |
417 | { | 595 | { |
418 | DetailLog("{0},BSCharacter.setAddForce,taint,addedForce={1}", LocalID, _force); | 596 | DetailLog("{0},BSCharacter.setAddForce,taint,addedForce={1}", LocalID, _force); |
419 | BulletSimAPI.AddObjectForce2(Body.Ptr, _force); | 597 | BulletSimAPI.SetObjectForce2(PhysBody.ptr, _force); |
420 | }); | 598 | }); |
421 | } | 599 | } |
422 | else | 600 | else |
@@ -426,129 +604,75 @@ public class BSCharacter : PhysicsActor | |||
426 | //m_lastUpdateSent = false; | 604 | //m_lastUpdateSent = false; |
427 | } | 605 | } |
428 | 606 | ||
429 | public override void AddAngularForce(Vector3 force, bool pushforce) { | 607 | public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { |
430 | } | 608 | } |
431 | public override void SetMomentum(Vector3 momentum) { | 609 | public override void SetMomentum(OMV.Vector3 momentum) { |
432 | } | 610 | } |
433 | 611 | ||
434 | // Turn on collision events at a rate no faster than one every the given milliseconds | 612 | private void ComputeAvatarScale(OMV.Vector3 size) |
435 | public override void SubscribeEvents(int ms) { | 613 | { |
436 | _subscribedEventsMs = ms; | 614 | // The 'size' given by the simulator is the mid-point of the avatar |
437 | if (ms > 0) | 615 | // and X and Y are unspecified. |
438 | { | ||
439 | // make sure first collision happens | ||
440 | _nextCollisionOkTime = Util.EnvironmentTickCount() - _subscribedEventsMs; | ||
441 | 616 | ||
442 | Scene.TaintedObject("BSCharacter.SubscribeEvents", delegate() | 617 | OMV.Vector3 newScale = OMV.Vector3.Zero; |
443 | { | 618 | newScale.X = PhysicsScene.Params.avatarCapsuleRadius; |
444 | BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | 619 | newScale.Y = PhysicsScene.Params.avatarCapsuleRadius; |
445 | }); | 620 | |
446 | } | 621 | // From the total height, remove the capsule half spheres that are at each end |
447 | } | 622 | newScale.Z = size.Z - (newScale.X + newScale.Y); |
448 | // Stop collision events | 623 | Scale = newScale; |
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 | } | 624 | } |
461 | 625 | ||
462 | // set _avatarVolume and _mass based on capsule size, _density and _scale | 626 | // set _avatarVolume and _mass based on capsule size, _density and Scale |
463 | private void ComputeAvatarVolumeAndMass() | 627 | private void ComputeAvatarVolumeAndMass() |
464 | { | 628 | { |
465 | _avatarVolume = (float)( | 629 | _avatarVolume = (float)( |
466 | Math.PI | 630 | Math.PI |
467 | * _scale.X | 631 | * Scale.X |
468 | * _scale.Y // the area of capsule cylinder | 632 | * Scale.Y // the area of capsule cylinder |
469 | * _scale.Z // times height of capsule cylinder | 633 | * Scale.Z // times height of capsule cylinder |
470 | + 1.33333333f | 634 | + 1.33333333f |
471 | * Math.PI | 635 | * Math.PI |
472 | * _scale.X | 636 | * Scale.X |
473 | * Math.Min(_scale.X, _scale.Y) | 637 | * Math.Min(Scale.X, Scale.Y) |
474 | * _scale.Y // plus the volume of the capsule end caps | 638 | * Scale.Y // plus the volume of the capsule end caps |
475 | ); | 639 | ); |
476 | _mass = _density * _avatarVolume; | 640 | _mass = _avatarDensity * _avatarVolume; |
477 | } | 641 | } |
478 | 642 | ||
479 | // The physics engine says that properties have updated. Update same and inform | 643 | // The physics engine says that properties have updated. Update same and inform |
480 | // the world that things have changed. | 644 | // the world that things have changed. |
481 | public void UpdateProperties(EntityProperties entprop) | 645 | public override void UpdateProperties(EntityProperties entprop) |
482 | { | 646 | { |
483 | _position = entprop.Position; | 647 | _position = entprop.Position; |
484 | _orientation = entprop.Rotation; | 648 | _orientation = entprop.Rotation; |
485 | _velocity = entprop.Velocity; | 649 | _velocity = entprop.Velocity; |
486 | _acceleration = entprop.Acceleration; | 650 | _acceleration = entprop.Acceleration; |
487 | _rotationalVelocity = entprop.RotationalVelocity; | 651 | _rotationalVelocity = entprop.RotationalVelocity; |
488 | // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop. | 652 | // Do some sanity checking for the avatar. Make sure it's above ground and inbounds. |
489 | // base.RequestPhysicsterseUpdate(); | 653 | PositionSanityCheck(true); |
490 | |||
491 | /* | ||
492 | DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | ||
493 | LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, | ||
494 | entprop.Acceleration, entprop.RotationalVelocity); | ||
495 | */ | ||
496 | } | ||
497 | 654 | ||
498 | // Called by the scene when a collision with this object is reported | 655 | // remember the current and last set values |
499 | // The collision, if it should be reported to the character, is placed in a collection | 656 | LastEntityProperties = CurrentEntityProperties; |
500 | // that will later be sent to the simulator when SendCollisions() is called. | 657 | CurrentEntityProperties = entprop; |
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 | 658 | ||
506 | // The following makes IsColliding() and IsCollidingGround() work | 659 | if (entprop.Velocity != LastEntityProperties.Velocity) |
507 | _collidingStep = _scene.SimulationStep; | ||
508 | if (collidingWith == BSScene.TERRAIN_ID || collidingWith == BSScene.GROUNDPLANE_ID) | ||
509 | { | 660 | { |
510 | _collidingGroundStep = _scene.SimulationStep; | 661 | // Changes in the velocity are suppressed in avatars. |
662 | // That's just the way they are defined. | ||
663 | OMV.Vector3 avVel = new OMV.Vector3(_appliedVelocity.X, _appliedVelocity.Y, entprop.Velocity.Z); | ||
664 | _velocity = avVel; | ||
665 | BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, avVel); | ||
511 | } | 666 | } |
512 | // DetailLog("{0},BSCharacter.Collison,call,with={1}", LocalID, collidingWith); | ||
513 | 667 | ||
514 | // throttle collisions to the rate specified in the subscription | 668 | // Tell the linkset about value changes |
515 | if (_subscribedEventsMs != 0) { | 669 | Linkset.UpdateProperties(this); |
516 | int nowTime = _scene.SimulationNowTime; | ||
517 | if (nowTime >= _nextCollisionOkTime) { | ||
518 | _nextCollisionOkTime = nowTime + _subscribedEventsMs; | ||
519 | 670 | ||
520 | if (collisionCollection == null) | 671 | // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop. |
521 | collisionCollection = new CollisionEventUpdate(); | 672 | // base.RequestPhysicsterseUpdate(); |
522 | collisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth)); | ||
523 | } | ||
524 | } | ||
525 | } | ||
526 | 673 | ||
527 | public void SendCollisions() | 674 | DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", |
528 | { | 675 | LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); |
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 | } | 676 | } |
553 | } | 677 | } |
554 | } | 678 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs index 25084d8..65fac00 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs | |||
@@ -34,12 +34,20 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
34 | 34 | ||
35 | public abstract class BSConstraint : IDisposable | 35 | public abstract class BSConstraint : IDisposable |
36 | { | 36 | { |
37 | private static string LogHeader = "[BULLETSIM CONSTRAINT]"; | ||
38 | |||
37 | protected BulletSim m_world; | 39 | protected BulletSim m_world; |
38 | protected BulletBody m_body1; | 40 | protected BulletBody m_body1; |
39 | protected BulletBody m_body2; | 41 | protected BulletBody m_body2; |
40 | protected BulletConstraint m_constraint; | 42 | protected BulletConstraint m_constraint; |
41 | protected bool m_enabled = false; | 43 | protected bool m_enabled = false; |
42 | 44 | ||
45 | public BulletBody Body1 { get { return m_body1; } } | ||
46 | public BulletBody Body2 { get { return m_body2; } } | ||
47 | public BulletConstraint Constraint { get { return m_constraint; } } | ||
48 | public abstract ConstraintType Type { get; } | ||
49 | public bool IsEnabled { get { return m_enabled; } } | ||
50 | |||
43 | public BSConstraint() | 51 | public BSConstraint() |
44 | { | 52 | { |
45 | } | 53 | } |
@@ -48,22 +56,25 @@ public abstract class BSConstraint : IDisposable | |||
48 | { | 56 | { |
49 | if (m_enabled) | 57 | if (m_enabled) |
50 | { | 58 | { |
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; | 59 | m_enabled = false; |
60 | if (m_constraint.ptr != IntPtr.Zero) | ||
61 | { | ||
62 | bool success = BulletSimAPI.DestroyConstraint2(m_world.ptr, m_constraint.ptr); | ||
63 | m_world.physicsScene.DetailLog("{0},BSConstraint.Dispose,taint,id1={1},body1={2},id2={3},body2={4},success={5}", | ||
64 | BSScene.DetailLogZero, | ||
65 | m_body1.ID, m_body1.ptr.ToString("X"), | ||
66 | m_body2.ID, m_body2.ptr.ToString("X"), | ||
67 | success); | ||
68 | m_constraint.ptr = System.IntPtr.Zero; | ||
69 | } | ||
56 | } | 70 | } |
57 | } | 71 | } |
58 | 72 | ||
59 | public BulletBody Body1 { get { return m_body1; } } | ||
60 | public BulletBody Body2 { get { return m_body2; } } | ||
61 | |||
62 | public virtual bool SetLinearLimits(Vector3 low, Vector3 high) | 73 | public virtual bool SetLinearLimits(Vector3 low, Vector3 high) |
63 | { | 74 | { |
64 | bool ret = false; | 75 | bool ret = false; |
65 | if (m_enabled) | 76 | if (m_enabled) |
66 | ret = BulletSimAPI.SetLinearLimits2(m_constraint.Ptr, low, high); | 77 | ret = BulletSimAPI.SetLinearLimits2(m_constraint.ptr, low, high); |
67 | return ret; | 78 | return ret; |
68 | } | 79 | } |
69 | 80 | ||
@@ -71,7 +82,18 @@ public abstract class BSConstraint : IDisposable | |||
71 | { | 82 | { |
72 | bool ret = false; | 83 | bool ret = false; |
73 | if (m_enabled) | 84 | if (m_enabled) |
74 | ret = BulletSimAPI.SetAngularLimits2(m_constraint.Ptr, low, high); | 85 | ret = BulletSimAPI.SetAngularLimits2(m_constraint.ptr, low, high); |
86 | return ret; | ||
87 | } | ||
88 | |||
89 | public virtual bool SetSolverIterations(float cnt) | ||
90 | { | ||
91 | bool ret = false; | ||
92 | if (m_enabled) | ||
93 | { | ||
94 | BulletSimAPI.SetConstraintNumSolverIterations2(m_constraint.ptr, cnt); | ||
95 | ret = true; | ||
96 | } | ||
75 | return ret; | 97 | return ret; |
76 | } | 98 | } |
77 | 99 | ||
@@ -81,7 +103,7 @@ public abstract class BSConstraint : IDisposable | |||
81 | if (m_enabled) | 103 | if (m_enabled) |
82 | { | 104 | { |
83 | // Recompute the internal transforms | 105 | // Recompute the internal transforms |
84 | BulletSimAPI.CalculateTransforms2(m_constraint.Ptr); | 106 | BulletSimAPI.CalculateTransforms2(m_constraint.ptr); |
85 | ret = true; | 107 | ret = true; |
86 | } | 108 | } |
87 | return ret; | 109 | return ret; |
@@ -97,13 +119,14 @@ public abstract class BSConstraint : IDisposable | |||
97 | ret = CalculateTransforms(); | 119 | ret = CalculateTransforms(); |
98 | if (ret) | 120 | if (ret) |
99 | { | 121 | { |
100 | // m_world.scene.PhysicsLogging.Write("{0},BSConstraint.RecomputeConstraintVariables,taint,enabling,A={1},B={2}", | 122 | // Setting an object's mass to zero (making it static like when it's selected) |
101 | // BSScene.DetailLogZero, Body1.ID, Body2.ID); | 123 | // automatically disables the constraints. |
102 | BulletSimAPI.SetConstraintEnable2(m_constraint.Ptr, m_world.scene.NumericBool(true)); | 124 | // If the link is enabled, be sure to set the constraint itself to enabled. |
125 | BulletSimAPI.SetConstraintEnable2(m_constraint.ptr, m_world.physicsScene.NumericBool(true)); | ||
103 | } | 126 | } |
104 | else | 127 | else |
105 | { | 128 | { |
106 | m_world.scene.Logger.ErrorFormat("[BULLETSIM CONSTRAINT] CalculateTransforms failed. A={0}, B={1}", Body1.ID, Body2.ID); | 129 | m_world.physicsScene.Logger.ErrorFormat("{0} CalculateTransforms failed. A={1}, B={2}", LogHeader, Body1.ID, Body2.ID); |
107 | } | 130 | } |
108 | } | 131 | } |
109 | return ret; | 132 | return ret; |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs index 683bc51..23ef052 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs | |||
@@ -32,10 +32,14 @@ using OpenMetaverse; | |||
32 | namespace OpenSim.Region.Physics.BulletSPlugin | 32 | namespace OpenSim.Region.Physics.BulletSPlugin |
33 | { | 33 | { |
34 | 34 | ||
35 | public class BS6DofConstraint : BSConstraint | 35 | public sealed class BSConstraint6Dof : 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 BSConstraint6Dof(BulletSim world, BulletBody obj1, BulletBody obj2, |
39 | Vector3 frame1, Quaternion frame1rot, | 43 | Vector3 frame1, Quaternion frame1rot, |
40 | Vector3 frame2, Quaternion frame2rot, | 44 | Vector3 frame2, Quaternion frame2rot, |
41 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies) | 45 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies) |
@@ -44,25 +48,52 @@ 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 BSConstraint6Dof(BulletSim world, BulletBody obj1, BulletBody obj2, |
55 | Vector3 joinPoint, | 62 | Vector3 joinPoint, |
56 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies) | 63 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies) |
57 | { | 64 | { |
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 | LogHeader, world.worldID, obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X")); | ||
75 | m_enabled = false; | ||
76 | } | ||
77 | else | ||
78 | { | ||
79 | m_constraint = new BulletConstraint( | ||
80 | BulletSimAPI.Create6DofConstraintToPoint2(m_world.ptr, m_body1.ptr, m_body2.ptr, | ||
81 | joinPoint, | ||
82 | useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies)); | ||
83 | world.physicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}", | ||
84 | BSScene.DetailLogZero, world.worldID, m_constraint.ptr.ToString("X"), | ||
85 | obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X")); | ||
86 | if (m_constraint.ptr == IntPtr.Zero) | ||
87 | { | ||
88 | world.physicsScene.Logger.ErrorFormat("{0} Failed creation of 6Dof constraint. rootID={1}, childID={2}", | ||
89 | LogHeader, obj1.ID, obj2.ID); | ||
90 | m_enabled = false; | ||
91 | } | ||
92 | else | ||
93 | { | ||
94 | m_enabled = true; | ||
95 | } | ||
96 | } | ||
66 | } | 97 | } |
67 | 98 | ||
68 | public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot) | 99 | public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot) |
@@ -70,7 +101,7 @@ public class BS6DofConstraint : BSConstraint | |||
70 | bool ret = false; | 101 | bool ret = false; |
71 | if (m_enabled) | 102 | if (m_enabled) |
72 | { | 103 | { |
73 | BulletSimAPI.SetFrames2(m_constraint.Ptr, frameA, frameArot, frameB, frameBrot); | 104 | BulletSimAPI.SetFrames2(m_constraint.ptr, frameA, frameArot, frameB, frameBrot); |
74 | ret = true; | 105 | ret = true; |
75 | } | 106 | } |
76 | return ret; | 107 | return ret; |
@@ -81,9 +112,9 @@ public class BS6DofConstraint : BSConstraint | |||
81 | bool ret = false; | 112 | bool ret = false; |
82 | if (m_enabled) | 113 | if (m_enabled) |
83 | { | 114 | { |
84 | BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL); | 115 | 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); | 116 | 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); | 117 | BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL); |
87 | ret = true; | 118 | ret = true; |
88 | } | 119 | } |
89 | return ret; | 120 | return ret; |
@@ -94,7 +125,7 @@ public class BS6DofConstraint : BSConstraint | |||
94 | bool ret = false; | 125 | bool ret = false; |
95 | float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; | 126 | float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; |
96 | if (m_enabled) | 127 | if (m_enabled) |
97 | ret = BulletSimAPI.UseFrameOffset2(m_constraint.Ptr, onOff); | 128 | ret = BulletSimAPI.UseFrameOffset2(m_constraint.ptr, onOff); |
98 | return ret; | 129 | return ret; |
99 | } | 130 | } |
100 | 131 | ||
@@ -103,7 +134,11 @@ public class BS6DofConstraint : BSConstraint | |||
103 | bool ret = false; | 134 | bool ret = false; |
104 | float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; | 135 | float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse; |
105 | if (m_enabled) | 136 | if (m_enabled) |
106 | ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.Ptr, onOff, targetVelocity, maxMotorForce); | 137 | { |
138 | ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.ptr, onOff, targetVelocity, maxMotorForce); | ||
139 | m_world.physicsScene.DetailLog("{0},BS6DOFConstraint,TransLimitMotor,enable={1},vel={2},maxForce={3}", | ||
140 | BSScene.DetailLogZero, enable, targetVelocity, maxMotorForce); | ||
141 | } | ||
107 | return ret; | 142 | return ret; |
108 | } | 143 | } |
109 | 144 | ||
@@ -111,7 +146,7 @@ public class BS6DofConstraint : BSConstraint | |||
111 | { | 146 | { |
112 | bool ret = false; | 147 | bool ret = false; |
113 | if (m_enabled) | 148 | if (m_enabled) |
114 | ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.Ptr, threshold); | 149 | ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.ptr, threshold); |
115 | return ret; | 150 | return ret; |
116 | } | 151 | } |
117 | } | 152 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs index 22ea367..a9fd826 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs | |||
@@ -33,7 +33,7 @@ using OpenMetaverse; | |||
33 | namespace OpenSim.Region.Physics.BulletSPlugin | 33 | namespace OpenSim.Region.Physics.BulletSPlugin |
34 | { | 34 | { |
35 | 35 | ||
36 | public class BSConstraintCollection : IDisposable | 36 | public sealed class BSConstraintCollection : IDisposable |
37 | { | 37 | { |
38 | // private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); | 38 | // private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); |
39 | // private static readonly string LogHeader = "[CONSTRAINT COLLECTION]"; | 39 | // private static readonly string LogHeader = "[CONSTRAINT COLLECTION]"; |
@@ -143,8 +143,6 @@ public class BSConstraintCollection : IDisposable | |||
143 | // Return 'true' if any constraints were destroyed. | 143 | // Return 'true' if any constraints were destroyed. |
144 | public bool RemoveAndDestroyConstraint(BulletBody body1) | 144 | public bool RemoveAndDestroyConstraint(BulletBody body1) |
145 | { | 145 | { |
146 | // return BulletSimAPI.RemoveConstraintByID(m_world.ID, obj.ID); | ||
147 | |||
148 | List<BSConstraint> toRemove = new List<BSConstraint>(); | 146 | List<BSConstraint> toRemove = new List<BSConstraint>(); |
149 | uint lookingID = body1.ID; | 147 | uint lookingID = body1.ID; |
150 | lock (m_constraints) | 148 | lock (m_constraints) |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs index d68048b..ed3ffa7 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.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 | public sealed class BSConstraintHinge : 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 BSConstraintHinge(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/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs index 5a9f135..dbc9039 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs | |||
@@ -23,7 +23,7 @@ | |||
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 | 27 | ||
28 | /* RA: June 14, 2011. Copied from ODEDynamics.cs and converted to | 28 | /* RA: June 14, 2011. Copied from ODEDynamics.cs and converted to |
29 | * call the BulletSim system. | 29 | * call the BulletSim system. |
@@ -52,19 +52,20 @@ using OpenSim.Region.Physics.Manager; | |||
52 | 52 | ||
53 | namespace OpenSim.Region.Physics.BulletSPlugin | 53 | namespace OpenSim.Region.Physics.BulletSPlugin |
54 | { | 54 | { |
55 | public class BSDynamics | 55 | public sealed class BSDynamics |
56 | { | 56 | { |
57 | private int frcount = 0; // Used to limit dynamics debug output to | 57 | private static string LogHeader = "[BULLETSIM VEHICLE]"; |
58 | // every 100th frame | 58 | |
59 | private BSScene PhysicsScene { get; set; } | ||
60 | // the prim this dynamic controller belongs to | ||
61 | private BSPrim Prim { get; set; } | ||
59 | 62 | ||
60 | private BSPrim m_prim; // the prim this dynamic controller belongs to | 63 | // mass of the vehicle fetched each time we're calles |
64 | private float m_vehicleMass; | ||
61 | 65 | ||
62 | // Vehicle properties | 66 | // Vehicle properties |
63 | private Vehicle m_type = Vehicle.TYPE_NONE; // If a 'VEHICLE', and what kind | 67 | public Vehicle Type { get; set; } |
64 | public Vehicle Type | 68 | |
65 | { | ||
66 | get { return m_type; } | ||
67 | } | ||
68 | // private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier | 69 | // private Quaternion m_referenceFrame = Quaternion.Identity; // Axis modifier |
69 | private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings: | 70 | private VehicleFlag m_flags = (VehicleFlag) 0; // Boolean settings: |
70 | // HOVER_TERRAIN_ONLY | 71 | // HOVER_TERRAIN_ONLY |
@@ -74,13 +75,15 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
74 | // HOVER_UP_ONLY | 75 | // HOVER_UP_ONLY |
75 | // LIMIT_MOTOR_UP | 76 | // LIMIT_MOTOR_UP |
76 | // LIMIT_ROLL_ONLY | 77 | // LIMIT_ROLL_ONLY |
77 | private VehicleFlag m_Hoverflags = (VehicleFlag)0; | ||
78 | private Vector3 m_BlockingEndPoint = Vector3.Zero; | 78 | private Vector3 m_BlockingEndPoint = Vector3.Zero; |
79 | private Quaternion m_RollreferenceFrame = Quaternion.Identity; | 79 | private Quaternion m_RollreferenceFrame = Quaternion.Identity; |
80 | private Quaternion m_referenceFrame = Quaternion.Identity; | ||
81 | |||
80 | // Linear properties | 82 | // Linear properties |
81 | private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time | 83 | private Vector3 m_linearMotorDirection = Vector3.Zero; // velocity requested by LSL, decayed by time |
84 | private Vector3 m_linearMotorOffset = Vector3.Zero; // the point of force can be offset from the center | ||
82 | private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL | 85 | private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL |
83 | private Vector3 m_dir = Vector3.Zero; // velocity applied to body | 86 | private Vector3 m_newVelocity = Vector3.Zero; // velocity computed to be applied to body |
84 | private Vector3 m_linearFrictionTimescale = Vector3.Zero; | 87 | private Vector3 m_linearFrictionTimescale = Vector3.Zero; |
85 | private float m_linearMotorDecayTimescale = 0; | 88 | private float m_linearMotorDecayTimescale = 0; |
86 | private float m_linearMotorTimescale = 0; | 89 | private float m_linearMotorTimescale = 0; |
@@ -91,28 +94,28 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
91 | 94 | ||
92 | //Angular properties | 95 | //Angular properties |
93 | private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor | 96 | private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor |
94 | private int m_angularMotorApply = 0; // application frame counter | 97 | // private int m_angularMotorApply = 0; // application frame counter |
95 | private Vector3 m_angularMotorVelocity = Vector3.Zero; // current angular motor velocity | 98 | private Vector3 m_angularMotorVelocity = Vector3.Zero; // current angular motor velocity |
96 | private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate | 99 | private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate |
97 | private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate | 100 | private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate |
98 | private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate | 101 | private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate |
99 | private Vector3 m_lastAngularVelocity = Vector3.Zero; // what was last applied to body | 102 | 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 | 103 | private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body |
101 | 104 | ||
102 | //Deflection properties | 105 | //Deflection properties |
103 | // private float m_angularDeflectionEfficiency = 0; | 106 | private float m_angularDeflectionEfficiency = 0; |
104 | // private float m_angularDeflectionTimescale = 0; | 107 | private float m_angularDeflectionTimescale = 0; |
105 | // private float m_linearDeflectionEfficiency = 0; | 108 | private float m_linearDeflectionEfficiency = 0; |
106 | // private float m_linearDeflectionTimescale = 0; | 109 | private float m_linearDeflectionTimescale = 0; |
107 | 110 | ||
108 | //Banking properties | 111 | //Banking properties |
109 | // private float m_bankingEfficiency = 0; | 112 | private float m_bankingEfficiency = 0; |
110 | // private float m_bankingMix = 0; | 113 | private float m_bankingMix = 0; |
111 | // private float m_bankingTimescale = 0; | 114 | private float m_bankingTimescale = 0; |
112 | 115 | ||
113 | //Hover and Buoyancy properties | 116 | //Hover and Buoyancy properties |
114 | private float m_VhoverHeight = 0f; | 117 | private float m_VhoverHeight = 0f; |
115 | // private float m_VhoverEfficiency = 0f; | 118 | private float m_VhoverEfficiency = 0f; |
116 | private float m_VhoverTimescale = 0f; | 119 | private float m_VhoverTimescale = 0f; |
117 | private float m_VhoverTargetHeight = -1.0f; // if <0 then no hover, else its the current target height | 120 | private float m_VhoverTargetHeight = -1.0f; // if <0 then no hover, else its the current target height |
118 | private float m_VehicleBuoyancy = 0f; //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle. | 121 | private float m_VehicleBuoyancy = 0f; //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle. |
@@ -124,86 +127,74 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
124 | private float m_verticalAttractionEfficiency = 1.0f; // damped | 127 | private float m_verticalAttractionEfficiency = 1.0f; // damped |
125 | private float m_verticalAttractionTimescale = 500f; // Timescale > 300 means no vert attractor. | 128 | private float m_verticalAttractionTimescale = 500f; // Timescale > 300 means no vert attractor. |
126 | 129 | ||
127 | public BSDynamics(BSPrim myPrim) | 130 | public BSDynamics(BSScene myScene, BSPrim myPrim) |
131 | { | ||
132 | PhysicsScene = myScene; | ||
133 | Prim = myPrim; | ||
134 | Type = Vehicle.TYPE_NONE; | ||
135 | } | ||
136 | |||
137 | // Return 'true' if this vehicle is doing vehicle things | ||
138 | public bool IsActive | ||
128 | { | 139 | { |
129 | m_prim = myPrim; | 140 | get { return Type != Vehicle.TYPE_NONE; } |
130 | m_type = Vehicle.TYPE_NONE; | ||
131 | } | 141 | } |
132 | 142 | ||
133 | internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue, float timestep) | 143 | internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue) |
134 | { | 144 | { |
135 | DetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue); | 145 | VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); |
136 | switch (pParam) | 146 | switch (pParam) |
137 | { | 147 | { |
138 | case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: | 148 | case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: |
139 | if (pValue < 0.01f) pValue = 0.01f; | 149 | m_angularDeflectionEfficiency = Math.Max(pValue, 0.01f); |
140 | // m_angularDeflectionEfficiency = pValue; | ||
141 | break; | 150 | break; |
142 | case Vehicle.ANGULAR_DEFLECTION_TIMESCALE: | 151 | case Vehicle.ANGULAR_DEFLECTION_TIMESCALE: |
143 | if (pValue < 0.01f) pValue = 0.01f; | 152 | m_angularDeflectionTimescale = Math.Max(pValue, 0.01f); |
144 | // m_angularDeflectionTimescale = pValue; | ||
145 | break; | 153 | break; |
146 | case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: | 154 | case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: |
147 | if (pValue < 0.01f) pValue = 0.01f; | 155 | m_angularMotorDecayTimescale = Math.Max(pValue, 0.01f); |
148 | m_angularMotorDecayTimescale = pValue; | ||
149 | break; | 156 | break; |
150 | case Vehicle.ANGULAR_MOTOR_TIMESCALE: | 157 | case Vehicle.ANGULAR_MOTOR_TIMESCALE: |
151 | if (pValue < 0.01f) pValue = 0.01f; | 158 | m_angularMotorTimescale = Math.Max(pValue, 0.01f); |
152 | m_angularMotorTimescale = pValue; | ||
153 | break; | 159 | break; |
154 | case Vehicle.BANKING_EFFICIENCY: | 160 | case Vehicle.BANKING_EFFICIENCY: |
155 | if (pValue < 0.01f) pValue = 0.01f; | 161 | m_bankingEfficiency = Math.Max(-1f, Math.Min(pValue, 1f)); |
156 | // m_bankingEfficiency = pValue; | ||
157 | break; | 162 | break; |
158 | case Vehicle.BANKING_MIX: | 163 | case Vehicle.BANKING_MIX: |
159 | if (pValue < 0.01f) pValue = 0.01f; | 164 | m_bankingMix = Math.Max(pValue, 0.01f); |
160 | // m_bankingMix = pValue; | ||
161 | break; | 165 | break; |
162 | case Vehicle.BANKING_TIMESCALE: | 166 | case Vehicle.BANKING_TIMESCALE: |
163 | if (pValue < 0.01f) pValue = 0.01f; | 167 | m_bankingTimescale = Math.Max(pValue, 0.01f); |
164 | // m_bankingTimescale = pValue; | ||
165 | break; | 168 | break; |
166 | case Vehicle.BUOYANCY: | 169 | case Vehicle.BUOYANCY: |
167 | if (pValue < -1f) pValue = -1f; | 170 | m_VehicleBuoyancy = Math.Max(-1f, Math.Min(pValue, 1f)); |
168 | if (pValue > 1f) pValue = 1f; | 171 | break; |
169 | m_VehicleBuoyancy = pValue; | 172 | case Vehicle.HOVER_EFFICIENCY: |
170 | break; | 173 | m_VhoverEfficiency = Math.Max(0f, Math.Min(pValue, 1f)); |
171 | // case Vehicle.HOVER_EFFICIENCY: | 174 | break; |
172 | // if (pValue < 0f) pValue = 0f; | ||
173 | // if (pValue > 1f) pValue = 1f; | ||
174 | // m_VhoverEfficiency = pValue; | ||
175 | // break; | ||
176 | case Vehicle.HOVER_HEIGHT: | 175 | case Vehicle.HOVER_HEIGHT: |
177 | m_VhoverHeight = pValue; | 176 | m_VhoverHeight = pValue; |
178 | break; | 177 | break; |
179 | case Vehicle.HOVER_TIMESCALE: | 178 | case Vehicle.HOVER_TIMESCALE: |
180 | if (pValue < 0.01f) pValue = 0.01f; | 179 | m_VhoverTimescale = Math.Max(pValue, 0.01f); |
181 | m_VhoverTimescale = pValue; | ||
182 | break; | 180 | break; |
183 | case Vehicle.LINEAR_DEFLECTION_EFFICIENCY: | 181 | case Vehicle.LINEAR_DEFLECTION_EFFICIENCY: |
184 | if (pValue < 0.01f) pValue = 0.01f; | 182 | m_linearDeflectionEfficiency = Math.Max(pValue, 0.01f); |
185 | // m_linearDeflectionEfficiency = pValue; | ||
186 | break; | 183 | break; |
187 | case Vehicle.LINEAR_DEFLECTION_TIMESCALE: | 184 | case Vehicle.LINEAR_DEFLECTION_TIMESCALE: |
188 | if (pValue < 0.01f) pValue = 0.01f; | 185 | m_linearDeflectionTimescale = Math.Max(pValue, 0.01f); |
189 | // m_linearDeflectionTimescale = pValue; | ||
190 | break; | 186 | break; |
191 | case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE: | 187 | case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE: |
192 | if (pValue < 0.01f) pValue = 0.01f; | 188 | m_linearMotorDecayTimescale = Math.Max(pValue, 0.01f); |
193 | m_linearMotorDecayTimescale = pValue; | ||
194 | break; | 189 | break; |
195 | case Vehicle.LINEAR_MOTOR_TIMESCALE: | 190 | case Vehicle.LINEAR_MOTOR_TIMESCALE: |
196 | if (pValue < 0.01f) pValue = 0.01f; | 191 | m_linearMotorTimescale = Math.Max(pValue, 0.01f); |
197 | m_linearMotorTimescale = pValue; | ||
198 | break; | 192 | break; |
199 | case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY: | 193 | case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY: |
200 | if (pValue < 0.1f) pValue = 0.1f; // Less goes unstable | 194 | m_verticalAttractionEfficiency = Math.Max(0.1f, Math.Min(pValue, 1f)); |
201 | if (pValue > 1.0f) pValue = 1.0f; | ||
202 | m_verticalAttractionEfficiency = pValue; | ||
203 | break; | 195 | break; |
204 | case Vehicle.VERTICAL_ATTRACTION_TIMESCALE: | 196 | case Vehicle.VERTICAL_ATTRACTION_TIMESCALE: |
205 | if (pValue < 0.01f) pValue = 0.01f; | 197 | m_verticalAttractionTimescale = Math.Max(pValue, 0.01f); |
206 | m_verticalAttractionTimescale = pValue; | ||
207 | break; | 198 | break; |
208 | 199 | ||
209 | // These are vector properties but the engine lets you use a single float value to | 200 | // These are vector properties but the engine lets you use a single float value to |
@@ -213,7 +204,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
213 | break; | 204 | break; |
214 | case Vehicle.ANGULAR_MOTOR_DIRECTION: | 205 | case Vehicle.ANGULAR_MOTOR_DIRECTION: |
215 | m_angularMotorDirection = new Vector3(pValue, pValue, pValue); | 206 | m_angularMotorDirection = new Vector3(pValue, pValue, pValue); |
216 | m_angularMotorApply = 10; | 207 | // m_angularMotorApply = 100; |
217 | break; | 208 | break; |
218 | case Vehicle.LINEAR_FRICTION_TIMESCALE: | 209 | case Vehicle.LINEAR_FRICTION_TIMESCALE: |
219 | m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue); | 210 | m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue); |
@@ -223,30 +214,27 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
223 | m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue); | 214 | m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue); |
224 | break; | 215 | break; |
225 | case Vehicle.LINEAR_MOTOR_OFFSET: | 216 | case Vehicle.LINEAR_MOTOR_OFFSET: |
226 | // m_linearMotorOffset = new Vector3(pValue, pValue, pValue); | 217 | m_linearMotorOffset = new Vector3(pValue, pValue, pValue); |
227 | break; | 218 | break; |
228 | 219 | ||
229 | } | 220 | } |
230 | }//end ProcessFloatVehicleParam | 221 | }//end ProcessFloatVehicleParam |
231 | 222 | ||
232 | internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue, float timestep) | 223 | internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue) |
233 | { | 224 | { |
234 | DetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue); | 225 | VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); |
235 | switch (pParam) | 226 | switch (pParam) |
236 | { | 227 | { |
237 | case Vehicle.ANGULAR_FRICTION_TIMESCALE: | 228 | case Vehicle.ANGULAR_FRICTION_TIMESCALE: |
238 | m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); | 229 | m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); |
239 | break; | 230 | break; |
240 | case Vehicle.ANGULAR_MOTOR_DIRECTION: | 231 | case Vehicle.ANGULAR_MOTOR_DIRECTION: |
241 | m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); | ||
242 | // Limit requested angular speed to 2 rps= 4 pi rads/sec | 232 | // Limit requested angular speed to 2 rps= 4 pi rads/sec |
243 | if (m_angularMotorDirection.X > 12.56f) m_angularMotorDirection.X = 12.56f; | 233 | pValue.X = Math.Max(-12.56f, Math.Min(pValue.X, 12.56f)); |
244 | if (m_angularMotorDirection.X < - 12.56f) m_angularMotorDirection.X = - 12.56f; | 234 | pValue.Y = Math.Max(-12.56f, Math.Min(pValue.Y, 12.56f)); |
245 | if (m_angularMotorDirection.Y > 12.56f) m_angularMotorDirection.Y = 12.56f; | 235 | pValue.Z = Math.Max(-12.56f, Math.Min(pValue.Z, 12.56f)); |
246 | if (m_angularMotorDirection.Y < - 12.56f) m_angularMotorDirection.Y = - 12.56f; | 236 | m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); |
247 | if (m_angularMotorDirection.Z > 12.56f) m_angularMotorDirection.Z = 12.56f; | 237 | // m_angularMotorApply = 100; |
248 | if (m_angularMotorDirection.Z < - 12.56f) m_angularMotorDirection.Z = - 12.56f; | ||
249 | m_angularMotorApply = 10; | ||
250 | break; | 238 | break; |
251 | case Vehicle.LINEAR_FRICTION_TIMESCALE: | 239 | case Vehicle.LINEAR_FRICTION_TIMESCALE: |
252 | m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); | 240 | m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); |
@@ -256,7 +244,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
256 | m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z); | 244 | m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z); |
257 | break; | 245 | break; |
258 | case Vehicle.LINEAR_MOTOR_OFFSET: | 246 | case Vehicle.LINEAR_MOTOR_OFFSET: |
259 | // m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z); | 247 | m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z); |
260 | break; | 248 | break; |
261 | case Vehicle.BLOCK_EXIT: | 249 | case Vehicle.BLOCK_EXIT: |
262 | m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z); | 250 | m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z); |
@@ -266,11 +254,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
266 | 254 | ||
267 | internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue) | 255 | internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue) |
268 | { | 256 | { |
269 | DetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue); | 257 | VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); |
270 | switch (pParam) | 258 | switch (pParam) |
271 | { | 259 | { |
272 | case Vehicle.REFERENCE_FRAME: | 260 | case Vehicle.REFERENCE_FRAME: |
273 | // m_referenceFrame = pValue; | 261 | m_referenceFrame = pValue; |
274 | break; | 262 | break; |
275 | case Vehicle.ROLL_FRAME: | 263 | case Vehicle.ROLL_FRAME: |
276 | m_RollreferenceFrame = pValue; | 264 | m_RollreferenceFrame = pValue; |
@@ -280,575 +268,545 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
280 | 268 | ||
281 | internal void ProcessVehicleFlags(int pParam, bool remove) | 269 | internal void ProcessVehicleFlags(int pParam, bool remove) |
282 | { | 270 | { |
283 | DetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", m_prim.LocalID, pParam, remove); | 271 | VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", Prim.LocalID, pParam, remove); |
284 | if (remove) | 272 | VehicleFlag parm = (VehicleFlag)pParam; |
285 | { | 273 | if (pParam == -1) |
286 | if (pParam == -1) | 274 | m_flags = (VehicleFlag)0; |
287 | { | ||
288 | 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 | } | ||
332 | if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP) | ||
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 | { | ||
369 | if ((m_flags & VehicleFlag.LOCK_ROTATION) != (VehicleFlag)0) | ||
370 | m_flags &= ~(VehicleFlag.LOCK_ROTATION); | ||
371 | } | ||
372 | } | ||
373 | else | 275 | else |
374 | { | 276 | { |
375 | if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) | 277 | if (remove) |
376 | { | 278 | m_flags &= ~parm; |
377 | m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT | m_flags); | 279 | else |
378 | } | 280 | m_flags |= parm; |
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 | } |
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: |
446 | m_linearFrictionTimescale = new Vector3(0, 0, 0); | ||
447 | m_angularFrictionTimescale = new Vector3(0, 0, 0); | ||
448 | m_linearMotorDirection = Vector3.Zero; | 292 | m_linearMotorDirection = Vector3.Zero; |
449 | m_linearMotorTimescale = 0; | 293 | m_linearMotorTimescale = 0; |
450 | m_linearMotorDecayTimescale = 0; | 294 | m_linearMotorDecayTimescale = 0; |
295 | m_linearFrictionTimescale = new Vector3(0, 0, 0); | ||
296 | |||
451 | m_angularMotorDirection = Vector3.Zero; | 297 | m_angularMotorDirection = Vector3.Zero; |
452 | m_angularMotorTimescale = 0; | ||
453 | m_angularMotorDecayTimescale = 0; | 298 | m_angularMotorDecayTimescale = 0; |
299 | m_angularMotorTimescale = 0; | ||
300 | m_angularFrictionTimescale = new Vector3(0, 0, 0); | ||
301 | |||
454 | m_VhoverHeight = 0; | 302 | m_VhoverHeight = 0; |
303 | m_VhoverEfficiency = 0; | ||
455 | m_VhoverTimescale = 0; | 304 | m_VhoverTimescale = 0; |
456 | m_VehicleBuoyancy = 0; | 305 | m_VehicleBuoyancy = 0; |
306 | |||
307 | m_linearDeflectionEfficiency = 1; | ||
308 | m_linearDeflectionTimescale = 1; | ||
309 | |||
310 | m_angularDeflectionEfficiency = 0; | ||
311 | m_angularDeflectionTimescale = 1000; | ||
312 | |||
313 | m_verticalAttractionEfficiency = 0; | ||
314 | m_verticalAttractionTimescale = 0; | ||
315 | |||
316 | m_bankingEfficiency = 0; | ||
317 | m_bankingTimescale = 1000; | ||
318 | m_bankingMix = 1; | ||
319 | |||
320 | m_referenceFrame = Quaternion.Identity; | ||
457 | m_flags = (VehicleFlag)0; | 321 | m_flags = (VehicleFlag)0; |
458 | break; | 322 | break; |
459 | 323 | ||
460 | case Vehicle.TYPE_SLED: | 324 | case Vehicle.TYPE_SLED: |
461 | m_linearFrictionTimescale = new Vector3(30, 1, 1000); | ||
462 | m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
463 | m_linearMotorDirection = Vector3.Zero; | 325 | m_linearMotorDirection = Vector3.Zero; |
464 | m_linearMotorTimescale = 1000; | 326 | m_linearMotorTimescale = 1000; |
465 | m_linearMotorDecayTimescale = 120; | 327 | m_linearMotorDecayTimescale = 120; |
328 | m_linearFrictionTimescale = new Vector3(30, 1, 1000); | ||
329 | |||
466 | m_angularMotorDirection = Vector3.Zero; | 330 | m_angularMotorDirection = Vector3.Zero; |
467 | m_angularMotorTimescale = 1000; | 331 | m_angularMotorTimescale = 1000; |
468 | m_angularMotorDecayTimescale = 120; | 332 | m_angularMotorDecayTimescale = 120; |
333 | m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
334 | |||
469 | m_VhoverHeight = 0; | 335 | m_VhoverHeight = 0; |
470 | // m_VhoverEfficiency = 1; | 336 | m_VhoverEfficiency = 10; // TODO: this looks wrong!! |
471 | m_VhoverTimescale = 10; | 337 | m_VhoverTimescale = 10; |
472 | m_VehicleBuoyancy = 0; | 338 | m_VehicleBuoyancy = 0; |
473 | // m_linearDeflectionEfficiency = 1; | 339 | |
474 | // m_linearDeflectionTimescale = 1; | 340 | m_linearDeflectionEfficiency = 1; |
475 | // m_angularDeflectionEfficiency = 1; | 341 | m_linearDeflectionTimescale = 1; |
476 | // m_angularDeflectionTimescale = 1000; | 342 | |
477 | // m_bankingEfficiency = 0; | 343 | m_angularDeflectionEfficiency = 1; |
478 | // m_bankingMix = 1; | 344 | m_angularDeflectionTimescale = 1000; |
479 | // m_bankingTimescale = 10; | 345 | |
480 | // m_referenceFrame = Quaternion.Identity; | 346 | m_verticalAttractionEfficiency = 0; |
481 | m_Hoverflags &= | 347 | m_verticalAttractionTimescale = 0; |
348 | |||
349 | m_bankingEfficiency = 0; | ||
350 | m_bankingTimescale = 10; | ||
351 | m_bankingMix = 1; | ||
352 | |||
353 | m_referenceFrame = Quaternion.Identity; | ||
354 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP); | ||
355 | m_flags &= | ||
482 | ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | 356 | ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | |
483 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | 357 | 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; | 358 | break; |
486 | case Vehicle.TYPE_CAR: | 359 | case Vehicle.TYPE_CAR: |
487 | m_linearFrictionTimescale = new Vector3(100, 2, 1000); | ||
488 | m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
489 | m_linearMotorDirection = Vector3.Zero; | 360 | m_linearMotorDirection = Vector3.Zero; |
490 | m_linearMotorTimescale = 1; | 361 | m_linearMotorTimescale = 1; |
491 | m_linearMotorDecayTimescale = 60; | 362 | m_linearMotorDecayTimescale = 60; |
363 | m_linearFrictionTimescale = new Vector3(100, 2, 1000); | ||
364 | |||
492 | m_angularMotorDirection = Vector3.Zero; | 365 | m_angularMotorDirection = Vector3.Zero; |
493 | m_angularMotorTimescale = 1; | 366 | m_angularMotorTimescale = 1; |
494 | m_angularMotorDecayTimescale = 0.8f; | 367 | m_angularMotorDecayTimescale = 0.8f; |
368 | m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
369 | |||
495 | m_VhoverHeight = 0; | 370 | m_VhoverHeight = 0; |
496 | // m_VhoverEfficiency = 0; | 371 | m_VhoverEfficiency = 0; |
497 | m_VhoverTimescale = 1000; | 372 | m_VhoverTimescale = 1000; |
498 | m_VehicleBuoyancy = 0; | 373 | m_VehicleBuoyancy = 0; |
499 | // // m_linearDeflectionEfficiency = 1; | 374 | |
500 | // // m_linearDeflectionTimescale = 2; | 375 | m_linearDeflectionEfficiency = 1; |
501 | // // m_angularDeflectionEfficiency = 0; | 376 | m_linearDeflectionTimescale = 2; |
502 | // m_angularDeflectionTimescale = 10; | 377 | |
378 | m_angularDeflectionEfficiency = 0; | ||
379 | m_angularDeflectionTimescale = 10; | ||
380 | |||
503 | m_verticalAttractionEfficiency = 1f; | 381 | m_verticalAttractionEfficiency = 1f; |
504 | m_verticalAttractionTimescale = 10f; | 382 | m_verticalAttractionTimescale = 10f; |
505 | // m_bankingEfficiency = -0.2f; | 383 | |
506 | // m_bankingMix = 1; | 384 | m_bankingEfficiency = -0.2f; |
507 | // m_bankingTimescale = 1; | 385 | m_bankingMix = 1; |
508 | // m_referenceFrame = Quaternion.Identity; | 386 | m_bankingTimescale = 1; |
509 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT); | 387 | |
510 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | | 388 | m_referenceFrame = Quaternion.Identity; |
511 | VehicleFlag.LIMIT_MOTOR_UP); | 389 | m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
512 | m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY); | 390 | | VehicleFlag.HOVER_TERRAIN_ONLY |
391 | | VehicleFlag.HOVER_GLOBAL_HEIGHT); | ||
392 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | ||
393 | | VehicleFlag.LIMIT_ROLL_ONLY | ||
394 | | VehicleFlag.LIMIT_MOTOR_UP | ||
395 | | VehicleFlag.HOVER_UP_ONLY); | ||
513 | break; | 396 | break; |
514 | case Vehicle.TYPE_BOAT: | 397 | case Vehicle.TYPE_BOAT: |
515 | m_linearFrictionTimescale = new Vector3(10, 3, 2); | ||
516 | m_angularFrictionTimescale = new Vector3(10,10,10); | ||
517 | m_linearMotorDirection = Vector3.Zero; | 398 | m_linearMotorDirection = Vector3.Zero; |
518 | m_linearMotorTimescale = 5; | 399 | m_linearMotorTimescale = 5; |
519 | m_linearMotorDecayTimescale = 60; | 400 | m_linearMotorDecayTimescale = 60; |
401 | m_linearFrictionTimescale = new Vector3(10, 3, 2); | ||
402 | |||
520 | m_angularMotorDirection = Vector3.Zero; | 403 | m_angularMotorDirection = Vector3.Zero; |
521 | m_angularMotorTimescale = 4; | 404 | m_angularMotorTimescale = 4; |
522 | m_angularMotorDecayTimescale = 4; | 405 | m_angularMotorDecayTimescale = 4; |
406 | m_angularFrictionTimescale = new Vector3(10,10,10); | ||
407 | |||
523 | m_VhoverHeight = 0; | 408 | m_VhoverHeight = 0; |
524 | // m_VhoverEfficiency = 0.5f; | 409 | m_VhoverEfficiency = 0.5f; |
525 | m_VhoverTimescale = 2; | 410 | m_VhoverTimescale = 2; |
526 | m_VehicleBuoyancy = 1; | 411 | m_VehicleBuoyancy = 1; |
527 | // m_linearDeflectionEfficiency = 0.5f; | 412 | |
528 | // m_linearDeflectionTimescale = 3; | 413 | m_linearDeflectionEfficiency = 0.5f; |
529 | // m_angularDeflectionEfficiency = 0.5f; | 414 | m_linearDeflectionTimescale = 3; |
530 | // m_angularDeflectionTimescale = 5; | 415 | |
416 | m_angularDeflectionEfficiency = 0.5f; | ||
417 | m_angularDeflectionTimescale = 5; | ||
418 | |||
531 | m_verticalAttractionEfficiency = 0.5f; | 419 | m_verticalAttractionEfficiency = 0.5f; |
532 | m_verticalAttractionTimescale = 5f; | 420 | m_verticalAttractionTimescale = 5f; |
533 | // m_bankingEfficiency = -0.3f; | 421 | |
534 | // m_bankingMix = 0.8f; | 422 | m_bankingEfficiency = -0.3f; |
535 | // m_bankingTimescale = 1; | 423 | m_bankingMix = 0.8f; |
536 | // m_referenceFrame = Quaternion.Identity; | 424 | m_bankingTimescale = 1; |
537 | m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY | | 425 | |
538 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | 426 | m_referenceFrame = Quaternion.Identity; |
539 | m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY); | 427 | m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
540 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | | 428 | | VehicleFlag.HOVER_GLOBAL_HEIGHT |
541 | VehicleFlag.LIMIT_MOTOR_UP); | 429 | | VehicleFlag.LIMIT_ROLL_ONLY |
542 | m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY); | 430 | | VehicleFlag.HOVER_UP_ONLY); |
431 | m_flags |= (VehicleFlag.NO_DEFLECTION_UP | ||
432 | | VehicleFlag.LIMIT_MOTOR_UP | ||
433 | | VehicleFlag.HOVER_WATER_ONLY); | ||
543 | break; | 434 | break; |
544 | case Vehicle.TYPE_AIRPLANE: | 435 | case Vehicle.TYPE_AIRPLANE: |
545 | m_linearFrictionTimescale = new Vector3(200, 10, 5); | ||
546 | m_angularFrictionTimescale = new Vector3(20, 20, 20); | ||
547 | m_linearMotorDirection = Vector3.Zero; | 436 | m_linearMotorDirection = Vector3.Zero; |
548 | m_linearMotorTimescale = 2; | 437 | m_linearMotorTimescale = 2; |
549 | m_linearMotorDecayTimescale = 60; | 438 | m_linearMotorDecayTimescale = 60; |
439 | m_linearFrictionTimescale = new Vector3(200, 10, 5); | ||
440 | |||
550 | m_angularMotorDirection = Vector3.Zero; | 441 | m_angularMotorDirection = Vector3.Zero; |
551 | m_angularMotorTimescale = 4; | 442 | m_angularMotorTimescale = 4; |
552 | m_angularMotorDecayTimescale = 4; | 443 | m_angularMotorDecayTimescale = 4; |
444 | m_angularFrictionTimescale = new Vector3(20, 20, 20); | ||
445 | |||
553 | m_VhoverHeight = 0; | 446 | m_VhoverHeight = 0; |
554 | // m_VhoverEfficiency = 0.5f; | 447 | m_VhoverEfficiency = 0.5f; |
555 | m_VhoverTimescale = 1000; | 448 | m_VhoverTimescale = 1000; |
556 | m_VehicleBuoyancy = 0; | 449 | m_VehicleBuoyancy = 0; |
557 | // m_linearDeflectionEfficiency = 0.5f; | 450 | |
558 | // m_linearDeflectionTimescale = 3; | 451 | m_linearDeflectionEfficiency = 0.5f; |
559 | // m_angularDeflectionEfficiency = 1; | 452 | m_linearDeflectionTimescale = 3; |
560 | // m_angularDeflectionTimescale = 2; | 453 | |
454 | m_angularDeflectionEfficiency = 1; | ||
455 | m_angularDeflectionTimescale = 2; | ||
456 | |||
561 | m_verticalAttractionEfficiency = 0.9f; | 457 | m_verticalAttractionEfficiency = 0.9f; |
562 | m_verticalAttractionTimescale = 2f; | 458 | m_verticalAttractionTimescale = 2f; |
563 | // m_bankingEfficiency = 1; | 459 | |
564 | // m_bankingMix = 0.7f; | 460 | m_bankingEfficiency = 1; |
565 | // m_bankingTimescale = 2; | 461 | m_bankingMix = 0.7f; |
566 | // m_referenceFrame = Quaternion.Identity; | 462 | m_bankingTimescale = 2; |
567 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | 463 | |
568 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | 464 | m_referenceFrame = Quaternion.Identity; |
569 | m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP); | 465 | m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
466 | | VehicleFlag.HOVER_TERRAIN_ONLY | ||
467 | | VehicleFlag.HOVER_GLOBAL_HEIGHT | ||
468 | | VehicleFlag.HOVER_UP_ONLY | ||
469 | | VehicleFlag.NO_DEFLECTION_UP | ||
470 | | VehicleFlag.LIMIT_MOTOR_UP); | ||
570 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); | 471 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); |
571 | break; | 472 | break; |
572 | case Vehicle.TYPE_BALLOON: | 473 | case Vehicle.TYPE_BALLOON: |
573 | m_linearFrictionTimescale = new Vector3(5, 5, 5); | ||
574 | m_angularFrictionTimescale = new Vector3(10, 10, 10); | ||
575 | m_linearMotorDirection = Vector3.Zero; | 474 | m_linearMotorDirection = Vector3.Zero; |
576 | m_linearMotorTimescale = 5; | 475 | m_linearMotorTimescale = 5; |
476 | m_linearFrictionTimescale = new Vector3(5, 5, 5); | ||
577 | m_linearMotorDecayTimescale = 60; | 477 | m_linearMotorDecayTimescale = 60; |
478 | |||
578 | m_angularMotorDirection = Vector3.Zero; | 479 | m_angularMotorDirection = Vector3.Zero; |
579 | m_angularMotorTimescale = 6; | 480 | m_angularMotorTimescale = 6; |
481 | m_angularFrictionTimescale = new Vector3(10, 10, 10); | ||
580 | m_angularMotorDecayTimescale = 10; | 482 | m_angularMotorDecayTimescale = 10; |
483 | |||
581 | m_VhoverHeight = 5; | 484 | m_VhoverHeight = 5; |
582 | // m_VhoverEfficiency = 0.8f; | 485 | m_VhoverEfficiency = 0.8f; |
583 | m_VhoverTimescale = 10; | 486 | m_VhoverTimescale = 10; |
584 | m_VehicleBuoyancy = 1; | 487 | m_VehicleBuoyancy = 1; |
585 | // m_linearDeflectionEfficiency = 0; | 488 | |
586 | // m_linearDeflectionTimescale = 5; | 489 | m_linearDeflectionEfficiency = 0; |
587 | // m_angularDeflectionEfficiency = 0; | 490 | m_linearDeflectionTimescale = 5; |
588 | // m_angularDeflectionTimescale = 5; | 491 | |
492 | m_angularDeflectionEfficiency = 0; | ||
493 | m_angularDeflectionTimescale = 5; | ||
494 | |||
589 | m_verticalAttractionEfficiency = 1f; | 495 | m_verticalAttractionEfficiency = 1f; |
590 | m_verticalAttractionTimescale = 100f; | 496 | m_verticalAttractionTimescale = 100f; |
591 | // m_bankingEfficiency = 0; | 497 | |
592 | // m_bankingMix = 0.7f; | 498 | m_bankingEfficiency = 0; |
593 | // m_bankingTimescale = 5; | 499 | m_bankingMix = 0.7f; |
594 | // m_referenceFrame = Quaternion.Identity; | 500 | m_bankingTimescale = 5; |
595 | m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | 501 | m_referenceFrame = Quaternion.Identity; |
596 | VehicleFlag.HOVER_UP_ONLY); | 502 | |
597 | m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP); | 503 | m_referenceFrame = Quaternion.Identity; |
598 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); | 504 | m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
599 | m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT); | 505 | | VehicleFlag.HOVER_TERRAIN_ONLY |
506 | | VehicleFlag.HOVER_UP_ONLY | ||
507 | | VehicleFlag.NO_DEFLECTION_UP | ||
508 | | VehicleFlag.LIMIT_MOTOR_UP); | ||
509 | m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY | ||
510 | | VehicleFlag.HOVER_GLOBAL_HEIGHT); | ||
600 | break; | 511 | break; |
601 | } | 512 | } |
602 | }//end SetDefaultsForType | 513 | } |
514 | |||
515 | // Some of the properties of this prim may have changed. | ||
516 | // Do any updating needed for a vehicle | ||
517 | public void Refresh() | ||
518 | { | ||
519 | if (IsActive) | ||
520 | { | ||
521 | // Friction effects are handled by this vehicle code | ||
522 | BulletSimAPI.SetFriction2(Prim.PhysBody.ptr, 0f); | ||
523 | BulletSimAPI.SetHitFraction2(Prim.PhysBody.ptr, 0f); | ||
524 | |||
525 | // BulletSimAPI.SetAngularDamping2(Prim.PhysBody.ptr, 0.8f); | ||
526 | |||
527 | VDetailLog("{0},BSDynamics.Refresh,zeroingFriction and adding damping", Prim.LocalID); | ||
528 | } | ||
529 | } | ||
530 | |||
531 | public bool RemoveBodyDependencies(BSPhysObject prim) | ||
532 | { | ||
533 | // If active, we need to add our properties back when the body is rebuilt. | ||
534 | return IsActive; | ||
535 | } | ||
536 | |||
537 | public void RestoreBodyDependencies(BSPhysObject prim) | ||
538 | { | ||
539 | if (Prim.LocalID != prim.LocalID) | ||
540 | { | ||
541 | // The call should be on us by our prim. Error if not. | ||
542 | PhysicsScene.Logger.ErrorFormat("{0} RestoreBodyDependencies: called by not my prim. passedLocalID={1}, vehiclePrimLocalID={2}", | ||
543 | LogHeader, prim.LocalID, Prim.LocalID); | ||
544 | return; | ||
545 | } | ||
546 | Refresh(); | ||
547 | } | ||
603 | 548 | ||
549 | // One step of the vehicle properties for the next 'pTimestep' seconds. | ||
604 | internal void Step(float pTimestep) | 550 | internal void Step(float pTimestep) |
605 | { | 551 | { |
606 | if (m_type == Vehicle.TYPE_NONE) return; | 552 | if (!IsActive) return; |
607 | 553 | ||
608 | frcount++; // used to limit debug comment output | 554 | // DEBUG |
609 | if (frcount > 100) | 555 | // Because Bullet does apply forces to the vehicle, our last computed |
610 | frcount = 0; | 556 | // linear and angular velocities are not what is happening now. |
557 | // Vector3 externalAngularVelocity = Prim.ForceRotationalVelocity - m_lastAngularVelocity; | ||
558 | // m_lastAngularVelocity += (externalAngularVelocity * 0.5f) * pTimestep; | ||
559 | // m_lastAngularVelocity = Prim.ForceRotationalVelocity; // DEBUG: account for what Bullet did last time | ||
560 | // m_lastLinearVelocityVector = Prim.ForceVelocity * Quaternion.Inverse(Prim.ForceOrientation); // DEBUG: | ||
561 | // END DEBUG | ||
562 | |||
563 | m_vehicleMass = Prim.Linkset.LinksetMass; | ||
611 | 564 | ||
612 | MoveLinear(pTimestep); | 565 | MoveLinear(pTimestep); |
566 | // Commented out for debug | ||
613 | MoveAngular(pTimestep); | 567 | MoveAngular(pTimestep); |
568 | // Prim.ApplyTorqueImpulse(-Prim.RotationalVelocity * m_vehicleMass, false); // DEBUG DEBUG | ||
569 | // Prim.ForceRotationalVelocity = -Prim.RotationalVelocity; // DEBUG DEBUG | ||
570 | |||
614 | LimitRotation(pTimestep); | 571 | LimitRotation(pTimestep); |
615 | 572 | ||
616 | DetailLog("{0},BSDynamics.Step,done,pos={1},force={2},velocity={3},angvel={4}", | 573 | // 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); | 574 | m_lastPositionVector = Prim.ForcePosition; |
575 | |||
576 | VDetailLog("{0},BSDynamics.Step,frict={1},grav={2},inertia={3},mass={4}", // DEBUG DEBUG | ||
577 | Prim.LocalID, | ||
578 | BulletSimAPI.GetFriction2(Prim.PhysBody.ptr), | ||
579 | BulletSimAPI.GetGravity2(Prim.PhysBody.ptr), | ||
580 | Prim.Inertia, | ||
581 | m_vehicleMass | ||
582 | ); | ||
583 | VDetailLog("{0},BSDynamics.Step,done,pos={1},force={2},velocity={3},angvel={4}", | ||
584 | Prim.LocalID, Prim.ForcePosition, Prim.Force, Prim.ForceVelocity, Prim.RotationalVelocity); | ||
618 | }// end Step | 585 | }// end Step |
619 | 586 | ||
587 | // Apply the effect of the linear motor. | ||
588 | // Also does hover and float. | ||
620 | private void MoveLinear(float pTimestep) | 589 | private void MoveLinear(float pTimestep) |
621 | { | 590 | { |
622 | // requested m_linearMotorDirection is significant | 591 | // m_linearMotorDirection is the target direction we are moving relative to the vehicle coordinates |
623 | // if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f)) | 592 | // m_lastLinearVelocityVector is the current speed we are moving in that direction |
624 | if (m_linearMotorDirection.LengthSquared() > 0.0001f) | 593 | if (m_linearMotorDirection.LengthSquared() > 0.001f) |
625 | { | 594 | { |
626 | Vector3 origDir = m_linearMotorDirection; | 595 | Vector3 origDir = m_linearMotorDirection; // DEBUG |
627 | Vector3 origVel = m_lastLinearVelocityVector; | 596 | Vector3 origVel = m_lastLinearVelocityVector; // DEBUG |
628 | 597 | // DEBUG: the vehicle velocity rotated to be relative to vehicle coordinates for comparison | |
629 | // add drive to body | 598 | Vector3 vehicleVelocity = Prim.ForceVelocity * Quaternion.Inverse(Prim.ForceOrientation); // DEBUG |
630 | // Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep); | 599 | |
631 | Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale); | 600 | // Add (desiredVelocity - lastAppliedVelocity) / howLongItShouldTakeToComplete |
632 | // lastLinearVelocityVector is the current body velocity vector? | 601 | Vector3 addAmount = (m_linearMotorDirection - m_lastLinearVelocityVector)/(m_linearMotorTimescale) * pTimestep; |
633 | // RA: Not sure what the *10 is for. A correction for pTimestep? | ||
634 | // m_lastLinearVelocityVector += (addAmount*10); | ||
635 | m_lastLinearVelocityVector += addAmount; | ||
636 | |||
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 | ||
640 | if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X)) | ||
641 | m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X; | ||
642 | if (Math.Abs(m_lastLinearVelocityVector.Y) > Math.Abs(m_linearMotorDirectionLASTSET.Y)) | ||
643 | m_lastLinearVelocityVector.Y = m_linearMotorDirectionLASTSET.Y; | ||
644 | if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z)) | ||
645 | m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z; | ||
646 | |||
647 | // decay applied velocity | ||
648 | Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep))); | ||
649 | m_linearMotorDirection -= m_linearMotorDirection * decayfraction * 0.5f; | ||
650 | |||
651 | /* | ||
652 | Vector3 addAmount = (m_linearMotorDirection - m_lastLinearVelocityVector)/m_linearMotorTimescale; | ||
653 | m_lastLinearVelocityVector += addAmount; | 602 | m_lastLinearVelocityVector += addAmount; |
654 | 603 | ||
655 | float decayfraction = (1.0f - 1.0f / m_linearMotorDecayTimescale); | 604 | float decayFactor = (1.0f / m_linearMotorDecayTimescale) * pTimestep; |
656 | m_linearMotorDirection *= decayfraction; | 605 | m_linearMotorDirection *= (1f - decayFactor); |
606 | |||
607 | // Rotate new object velocity from vehicle relative to world coordinates | ||
608 | m_newVelocity = m_lastLinearVelocityVector * Prim.ForceOrientation; | ||
657 | 609 | ||
658 | */ | 610 | // Apply friction for next time |
611 | Vector3 frictionFactor = (Vector3.One / m_linearFrictionTimescale) * pTimestep; | ||
612 | m_lastLinearVelocityVector *= (Vector3.One - frictionFactor); | ||
659 | 613 | ||
660 | DetailLog("{0},MoveLinear,nonZero,origdir={1},origvel={2},add={3},decay={4},dir={5},vel={6}", | 614 | VDetailLog("{0},MoveLinear,nonZero,origlmDir={1},origlvVel={2},vehVel={3},add={4},decay={5},frict={6},lmDir={7},lvVec={8},newVel={9}", |
661 | m_prim.LocalID, origDir, origVel, addAmount, decayfraction, m_linearMotorDirection, m_lastLinearVelocityVector); | 615 | Prim.LocalID, origDir, origVel, vehicleVelocity, addAmount, decayFactor, frictionFactor, |
616 | m_linearMotorDirection, m_lastLinearVelocityVector, m_newVelocity); | ||
662 | } | 617 | } |
663 | else | 618 | else |
664 | { | 619 | { |
665 | // if what remains of applied is small, zero it. | 620 | // 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; | 621 | m_linearMotorDirection = Vector3.Zero; |
669 | m_lastLinearVelocityVector = Vector3.Zero; | 622 | m_lastLinearVelocityVector = Vector3.Zero; |
670 | } | 623 | m_newVelocity = Vector3.Zero; |
671 | 624 | ||
672 | // convert requested object velocity to world-referenced vector | 625 | VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID); |
673 | Quaternion rotq = m_prim.Orientation; | 626 | } |
674 | m_dir = m_lastLinearVelocityVector * rotq; | ||
675 | 627 | ||
676 | // Add the various forces into m_dir which will be our new direction vector (velocity) | 628 | // m_newVelocity is velocity computed from linear motor in world coordinates |
677 | 629 | ||
678 | // add Gravity and Buoyancy | 630 | // 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. | 631 | // There is some gravity, make a gravity force vector that is applied after object velocity. |
684 | // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g; | 632 | // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g; |
685 | grav.Z = m_prim.Scene.DefaultGravity.Z * m_prim.Mass * (1f - m_VehicleBuoyancy); | 633 | Vector3 grav = Prim.PhysicsScene.DefaultGravity * (1f - m_VehicleBuoyancy); |
634 | |||
635 | /* | ||
636 | * RA: Not sure why one would do this unless we are hoping external forces are doing gravity, ... | ||
686 | // Preserve the current Z velocity | 637 | // Preserve the current Z velocity |
687 | Vector3 vel_now = m_prim.Velocity; | 638 | Vector3 vel_now = m_prim.Velocity; |
688 | m_dir.Z = vel_now.Z; // Preserve the accumulated falling velocity | 639 | m_dir.Z = vel_now.Z; // Preserve the accumulated falling velocity |
640 | */ | ||
689 | 641 | ||
690 | Vector3 pos = m_prim.Position; | 642 | 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); | 643 | // 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 | 644 | ||
730 | // If below the terrain, move us above the ground a little. | 645 | // If below the terrain, move us above the ground a little. |
731 | if (pos.Z < m_prim.Scene.GetTerrainHeightAtXYZ(pos)) | 646 | float terrainHeight = Prim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos); |
647 | // Taking the rotated size doesn't work here because m_prim.Size is the size of the root prim and not the linkset. | ||
648 | // TODO: Add a m_prim.LinkSet.Size similar to m_prim.LinkSet.Mass. | ||
649 | // Vector3 rotatedSize = m_prim.Size * m_prim.ForceOrientation; | ||
650 | // if (rotatedSize.Z < terrainHeight) | ||
651 | if (pos.Z < terrainHeight) | ||
732 | { | 652 | { |
733 | pos.Z = m_prim.Scene.GetTerrainHeightAtXYZ(pos) + 2; | 653 | pos.Z = terrainHeight + 2; |
734 | m_prim.Position = pos; | 654 | Prim.ForcePosition = pos; |
735 | DetailLog("{0},MoveLinear,terrainHeight,pos={1}", m_prim.LocalID, pos); | 655 | VDetailLog("{0},MoveLinear,terrainHeight,terrainHeight={1},pos={2}", Prim.LocalID, terrainHeight, pos); |
736 | } | 656 | } |
737 | 657 | ||
738 | // Check if hovering | 658 | // Check if hovering |
739 | if ((m_Hoverflags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0) | 659 | // m_VhoverEfficiency: 0=bouncy, 1=totally damped |
660 | // m_VhoverTimescale: time to achieve height | ||
661 | if ((m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0) | ||
740 | { | 662 | { |
741 | // We should hover, get the target height | 663 | // We should hover, get the target height |
742 | if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != 0) | 664 | if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0) |
743 | { | 665 | { |
744 | m_VhoverTargetHeight = m_prim.Scene.GetWaterLevel() + m_VhoverHeight; | 666 | m_VhoverTargetHeight = Prim.PhysicsScene.GetWaterLevelAtXYZ(pos) + m_VhoverHeight; |
745 | } | 667 | } |
746 | if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0) | 668 | if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0) |
747 | { | 669 | { |
748 | m_VhoverTargetHeight = m_prim.Scene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight; | 670 | m_VhoverTargetHeight = terrainHeight + m_VhoverHeight; |
749 | } | 671 | } |
750 | if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0) | 672 | if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0) |
751 | { | 673 | { |
752 | m_VhoverTargetHeight = m_VhoverHeight; | 674 | m_VhoverTargetHeight = m_VhoverHeight; |
753 | } | 675 | } |
754 | 676 | ||
755 | if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != 0) | 677 | if ((m_flags & VehicleFlag.HOVER_UP_ONLY) != 0) |
756 | { | 678 | { |
757 | // If body is aready heigher, use its height as target height | 679 | // If body is already heigher, use its height as target height |
758 | if (pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z; | 680 | if (pos.Z > m_VhoverTargetHeight) |
681 | m_VhoverTargetHeight = pos.Z; | ||
759 | } | 682 | } |
760 | if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0) | 683 | if ((m_flags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0) |
761 | { | 684 | { |
762 | if ((pos.Z - m_VhoverTargetHeight) > .2 || (pos.Z - m_VhoverTargetHeight) < -.2) | 685 | if (Math.Abs(pos.Z - m_VhoverTargetHeight) > 0.2f) |
763 | { | 686 | { |
764 | m_prim.Position = pos; | 687 | pos.Z = m_VhoverTargetHeight; |
688 | Prim.ForcePosition = pos; | ||
765 | } | 689 | } |
766 | } | 690 | } |
767 | else | 691 | else |
768 | { | 692 | { |
769 | float herr0 = pos.Z - m_VhoverTargetHeight; | 693 | float verticalError = pos.Z - m_VhoverTargetHeight; |
694 | // RA: where does the 50 come from? | ||
695 | float verticalCorrectionVelocity = pTimestep * ((verticalError * 50.0f) / m_VhoverTimescale); | ||
770 | // Replace Vertical speed with correction figure if significant | 696 | // Replace Vertical speed with correction figure if significant |
771 | if (Math.Abs(herr0) > 0.01f) | 697 | if (Math.Abs(verticalError) > 0.01f) |
772 | { | 698 | { |
773 | m_dir.Z = -((herr0 * pTimestep * 50.0f) / m_VhoverTimescale); | 699 | m_newVelocity.Z += verticalCorrectionVelocity; |
774 | //KF: m_VhoverEfficiency is not yet implemented | 700 | //KF: m_VhoverEfficiency is not yet implemented |
775 | } | 701 | } |
702 | else if (verticalError < -0.01) | ||
703 | { | ||
704 | m_newVelocity.Z -= verticalCorrectionVelocity; | ||
705 | } | ||
776 | else | 706 | else |
777 | { | 707 | { |
778 | m_dir.Z = 0f; | 708 | m_newVelocity.Z = 0f; |
779 | } | 709 | } |
780 | } | 710 | } |
781 | 711 | ||
782 | DetailLog("{0},MoveLinear,hover,pos={1},dir={2},height={3},target={4}", m_prim.LocalID, pos, m_dir, m_VhoverHeight, m_VhoverTargetHeight); | 712 | VDetailLog("{0},MoveLinear,hover,pos={1},dir={2},height={3},target={4}", Prim.LocalID, pos, m_newVelocity, m_VhoverHeight, m_VhoverTargetHeight); |
783 | |||
784 | // m_VhoverEfficiency = 0f; // 0=boucy, 1=Crit.damped | ||
785 | // m_VhoverTimescale = 0f; // time to acheive height | ||
786 | // pTimestep is time since last frame,in secs | ||
787 | } | 713 | } |
788 | 714 | ||
789 | if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0) | 715 | Vector3 posChange = pos - m_lastPositionVector; |
716 | if (m_BlockingEndPoint != Vector3.Zero) | ||
790 | { | 717 | { |
791 | //Start Experimental Values | 718 | bool changed = false; |
792 | if (Zchange > .3) | 719 | if (pos.X >= (m_BlockingEndPoint.X - (float)1)) |
793 | { | 720 | { |
794 | grav.Z = (float)(grav.Z * 3); | 721 | pos.X -= posChange.X + 1; |
722 | changed = true; | ||
795 | } | 723 | } |
796 | if (Zchange > .15) | 724 | if (pos.Y >= (m_BlockingEndPoint.Y - (float)1)) |
797 | { | 725 | { |
798 | grav.Z = (float)(grav.Z * 2); | 726 | pos.Y -= posChange.Y + 1; |
727 | changed = true; | ||
799 | } | 728 | } |
800 | if (Zchange > .75) | 729 | if (pos.Z >= (m_BlockingEndPoint.Z - (float)1)) |
801 | { | 730 | { |
802 | grav.Z = (float)(grav.Z * 1.5); | 731 | pos.Z -= posChange.Z + 1; |
732 | changed = true; | ||
803 | } | 733 | } |
804 | if (Zchange > .05) | 734 | if (pos.X <= 0) |
805 | { | 735 | { |
806 | grav.Z = (float)(grav.Z * 1.25); | 736 | pos.X += posChange.X + 1; |
737 | changed = true; | ||
807 | } | 738 | } |
808 | if (Zchange > .025) | 739 | if (pos.Y <= 0) |
809 | { | 740 | { |
810 | grav.Z = (float)(grav.Z * 1.125); | 741 | pos.Y += posChange.Y + 1; |
742 | changed = true; | ||
811 | } | 743 | } |
812 | float terraintemp = m_prim.Scene.GetTerrainHeightAtXYZ(pos); | 744 | if (changed) |
813 | float postemp = (pos.Z - terraintemp); | ||
814 | if (postemp > 2.5f) | ||
815 | { | 745 | { |
816 | grav.Z = (float)(grav.Z * 1.037125); | 746 | Prim.ForcePosition = pos; |
747 | VDetailLog("{0},MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}", | ||
748 | Prim.LocalID, m_BlockingEndPoint, posChange, pos); | ||
817 | } | 749 | } |
818 | DetailLog("{0},MoveLinear,limitMotorUp,grav={1}", m_prim.LocalID, grav); | ||
819 | //End Experimental Values | ||
820 | } | 750 | } |
821 | if ((m_flags & (VehicleFlag.NO_X)) != 0) | 751 | |
752 | #region downForce | ||
753 | Vector3 downForce = Vector3.Zero; | ||
754 | |||
755 | if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0) | ||
822 | { | 756 | { |
823 | m_dir.X = 0; | 757 | // If the vehicle is motoring into the sky, get it going back down. |
758 | // Is this an angular force or both linear and angular?? | ||
759 | float distanceAboveGround = pos.Z - terrainHeight; | ||
760 | if (distanceAboveGround > 2f) | ||
761 | { | ||
762 | // downForce = new Vector3(0, 0, (-distanceAboveGround / m_bankingTimescale) * pTimestep); | ||
763 | // downForce = new Vector3(0, 0, -distanceAboveGround / m_bankingTimescale); | ||
764 | downForce = new Vector3(0, 0, -distanceAboveGround); | ||
765 | } | ||
766 | // TODO: this calculation is all wrong. From the description at | ||
767 | // (http://wiki.secondlife.com/wiki/Category:LSL_Vehicle), the downForce | ||
768 | // has a decay factor. This says this force should | ||
769 | // be computed with a motor. | ||
770 | VDetailLog("{0},MoveLinear,limitMotorUp,distAbove={1},downForce={2}", | ||
771 | Prim.LocalID, distanceAboveGround, downForce); | ||
824 | } | 772 | } |
773 | #endregion // downForce | ||
774 | |||
775 | // If not changing some axis, reduce out velocity | ||
776 | if ((m_flags & (VehicleFlag.NO_X)) != 0) | ||
777 | m_newVelocity.X = 0; | ||
825 | if ((m_flags & (VehicleFlag.NO_Y)) != 0) | 778 | if ((m_flags & (VehicleFlag.NO_Y)) != 0) |
826 | { | 779 | m_newVelocity.Y = 0; |
827 | m_dir.Y = 0; | ||
828 | } | ||
829 | if ((m_flags & (VehicleFlag.NO_Z)) != 0) | 780 | if ((m_flags & (VehicleFlag.NO_Z)) != 0) |
781 | m_newVelocity.Z = 0; | ||
782 | |||
783 | // Clamp REALLY high or low velocities | ||
784 | if (m_newVelocity.LengthSquared() > 1e6f) | ||
830 | { | 785 | { |
831 | m_dir.Z = 0; | 786 | m_newVelocity /= m_newVelocity.Length(); |
787 | m_newVelocity *= 1000f; | ||
832 | } | 788 | } |
789 | else if (m_newVelocity.LengthSquared() < 1e-6f) | ||
790 | m_newVelocity = Vector3.Zero; | ||
833 | 791 | ||
834 | m_lastPositionVector = m_prim.Position; | 792 | // Stuff new linear velocity into the vehicle |
793 | Prim.ForceVelocity = m_newVelocity; | ||
794 | // Prim.ApplyForceImpulse((m_newVelocity - Prim.Velocity) * m_vehicleMass, false); // DEBUG DEBUG | ||
835 | 795 | ||
836 | // Apply velocity | 796 | Vector3 totalDownForce = downForce + grav; |
837 | m_prim.Velocity = m_dir; | 797 | if (totalDownForce != Vector3.Zero) |
838 | // apply gravity force | 798 | { |
839 | // Why is this set here? The physics engine already does gravity. | 799 | Prim.AddForce(totalDownForce * m_vehicleMass, false); |
840 | // m_prim.AddForce(grav, false); | 800 | // Prim.ApplyForceImpulse(totalDownForce * m_vehicleMass, false); |
841 | // m_prim.Force = grav; | 801 | } |
842 | |||
843 | // Apply friction | ||
844 | Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep); | ||
845 | m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount; | ||
846 | 802 | ||
847 | DetailLog("{0},MoveLinear,done,pos={1},vel={2},force={3},decay={4}", | 803 | VDetailLog("{0},MoveLinear,done,lmDir={1},lmVel={2},newVel={3},primVel={4},totalDown={5}", |
848 | m_prim.LocalID, m_lastPositionVector, m_dir, grav, decayamount); | 804 | Prim.LocalID, m_linearMotorDirection, m_lastLinearVelocityVector, m_newVelocity, Prim.Velocity, totalDownForce); |
849 | 805 | ||
850 | } // end MoveLinear() | 806 | } // end MoveLinear() |
851 | 807 | ||
808 | // ======================================================================= | ||
809 | // Apply the effect of the angular motor. | ||
852 | private void MoveAngular(float pTimestep) | 810 | private void MoveAngular(float pTimestep) |
853 | { | 811 | { |
854 | // m_angularMotorDirection // angular velocity requested by LSL motor | 812 | // m_angularMotorDirection // angular velocity requested by LSL motor |
@@ -859,160 +817,263 @@ namespace OpenSim.Region.Physics.BulletSPlugin | |||
859 | // m_angularFrictionTimescale // body angular velocity decay rate | 817 | // m_angularFrictionTimescale // body angular velocity decay rate |
860 | // m_lastAngularVelocity // what was last applied to body | 818 | // m_lastAngularVelocity // what was last applied to body |
861 | 819 | ||
862 | // Get what the body is doing, this includes 'external' influences | 820 | if (m_angularMotorDirection.LengthSquared() > 0.0001) |
863 | Vector3 angularVelocity = m_prim.RotationalVelocity; | ||
864 | |||
865 | if (m_angularMotorApply > 0) | ||
866 | { | 821 | { |
867 | // Rather than snapping the angular motor velocity from the old value to | 822 | Vector3 origVel = m_angularMotorVelocity; |
868 | // a newly set velocity, this routine steps the value from the previous | 823 | Vector3 origDir = m_angularMotorDirection; |
869 | // value (m_angularMotorVelocity) to the requested value (m_angularMotorDirection). | 824 | |
870 | // There are m_angularMotorApply steps. | 825 | // new velocity += error / ( time to get there / step interval) |
871 | Vector3 origAngularVelocity = m_angularMotorVelocity; | 826 | // requested direction - current vehicle direction |
872 | // ramp up to new value | 827 | m_angularMotorVelocity += (m_angularMotorDirection - m_angularMotorVelocity) / (m_angularMotorTimescale / pTimestep); |
873 | // current velocity += error / (time to get there / step interval) | 828 | // decay requested direction |
874 | // requested speed - last motor speed | 829 | m_angularMotorDirection *= (1.0f - (pTimestep * 1.0f/m_angularMotorDecayTimescale)); |
875 | m_angularMotorVelocity.X += (m_angularMotorDirection.X - m_angularMotorVelocity.X) / (m_angularMotorTimescale / pTimestep); | 830 | |
876 | m_angularMotorVelocity.Y += (m_angularMotorDirection.Y - m_angularMotorVelocity.Y) / (m_angularMotorTimescale / pTimestep); | 831 | VDetailLog("{0},MoveAngular,angularMotorApply,angTScale={1},timeStep={2},origvel={3},origDir={4},vel={5}", |
877 | m_angularMotorVelocity.Z += (m_angularMotorDirection.Z - m_angularMotorVelocity.Z) / (m_angularMotorTimescale / pTimestep); | 832 | Prim.LocalID, m_angularMotorTimescale, pTimestep, origVel, origDir, m_angularMotorVelocity); |
878 | |||
879 | DetailLog("{0},MoveAngular,angularMotorApply,apply={1},origvel={2},dir={3},vel={4}", | ||
880 | m_prim.LocalID,m_angularMotorApply,origAngularVelocity, m_angularMotorDirection, m_angularMotorVelocity); | ||
881 | |||
882 | m_angularMotorApply--; // This is done so that if script request rate is less than phys frame rate the expected | ||
883 | // velocity may still be acheived. | ||
884 | } | 833 | } |
885 | else | 834 | else |
886 | { | 835 | { |
887 | // No motor recently applied, keep the body velocity | 836 | m_angularMotorVelocity = Vector3.Zero; |
888 | // and decay the velocity | 837 | } |
889 | m_angularMotorVelocity -= m_angularMotorVelocity / (m_angularMotorDecayTimescale / pTimestep); | 838 | |
890 | } // end motor section | 839 | #region Vertical attactor |
891 | 840 | ||
892 | // Vertical attractor section | ||
893 | Vector3 vertattr = Vector3.Zero; | 841 | Vector3 vertattr = Vector3.Zero; |
894 | if (m_verticalAttractionTimescale < 300) | 842 | Vector3 deflection = Vector3.Zero; |
843 | Vector3 banking = Vector3.Zero; | ||
844 | |||
845 | // If vertical attaction timescale is reasonable and we applied an angular force last time... | ||
846 | if (m_verticalAttractionTimescale < 300 && m_lastAngularVelocity != Vector3.Zero) | ||
895 | { | 847 | { |
896 | float VAservo = 0.2f / (m_verticalAttractionTimescale * pTimestep); | 848 | float VAservo = pTimestep * 0.2f / m_verticalAttractionTimescale; |
897 | // get present body rotation | 849 | if (Prim.IsColliding) |
898 | Quaternion rotq = m_prim.Orientation; | 850 | VAservo = pTimestep * 0.05f / (m_verticalAttractionTimescale); |
899 | // make a vector pointing up | 851 | |
900 | Vector3 verterr = Vector3.Zero; | 852 | VAservo *= (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency); |
901 | verterr.Z = 1.0f; | 853 | |
902 | // rotate it to Body Angle | 854 | // Create a vector of the vehicle "up" in world coordinates |
903 | verterr = verterr * rotq; | 855 | Vector3 verticalError = Vector3.UnitZ * Prim.ForceOrientation; |
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. | 856 | // verticalError.X and .Y are the World error amounts. They are 0 when there is no |
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 | 857 | // error (Vehicle Body is 'vertical'), and .Z will be 1. As the body leans to its |
906 | // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body. | 858 | // side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall |
907 | if (verterr.Z < 0.0f) | 859 | // and .Z will go // negative. Similar for tilt and |.Y|. .X and .Y must be |
860 | // modulated to prevent a stable inverted body. | ||
861 | |||
862 | // Error is 0 (no error) to +/- 2 (max error) | ||
863 | if (verticalError.Z < 0.0f) | ||
908 | { | 864 | { |
909 | verterr.X = 2.0f - verterr.X; | 865 | verticalError.X = 2.0f - verticalError.X; |
910 | verterr.Y = 2.0f - verterr.Y; | 866 | verticalError.Y = 2.0f - verticalError.Y; |
911 | } | 867 | } |
912 | // Error is 0 (no error) to +/- 2 (max error) | 868 | // scale it by VAservo (timestep and timescale) |
913 | // scale it by VAservo | 869 | verticalError = verticalError * VAservo; |
914 | verterr = verterr * VAservo; | 870 | |
915 | 871 | // As the body rotates around the X axis, then verticalError.Y increases; Rotated around Y | |
916 | // As the body rotates around the X axis, then verterr.Y increases; Rotated around Y then .X increases, so | 872 | // then .X increases, so change Body angular velocity X based on Y, and Y based on X. |
917 | // Change Body angular velocity X based on Y, and Y based on X. Z is not changed. | 873 | // Z is not changed. |
918 | vertattr.X = verterr.Y; | 874 | vertattr.X = verticalError.Y; |
919 | vertattr.Y = - verterr.X; | 875 | vertattr.Y = - verticalError.X; |
920 | vertattr.Z = 0f; | 876 | vertattr.Z = 0f; |
921 | 877 | ||
922 | // scaling appears better usingsquare-law | 878 | // scaling appears better usingsquare-law |
879 | Vector3 angularVelocity = Prim.ForceRotationalVelocity; | ||
923 | float bounce = 1.0f - (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency); | 880 | float bounce = 1.0f - (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency); |
924 | vertattr.X += bounce * angularVelocity.X; | 881 | vertattr.X += bounce * angularVelocity.X; |
925 | vertattr.Y += bounce * angularVelocity.Y; | 882 | vertattr.Y += bounce * angularVelocity.Y; |
926 | 883 | ||
927 | DetailLog("{0},MoveAngular,verticalAttraction,verterr={1},bounce={2},vertattr={3}", | 884 | VDetailLog("{0},MoveAngular,verticalAttraction,VAservo={1},effic={2},verticalError={3},bounce={4},vertattr={5}", |
928 | m_prim.LocalID, verterr, bounce, vertattr); | 885 | Prim.LocalID, VAservo, m_verticalAttractionEfficiency, verticalError, bounce, vertattr); |
929 | 886 | ||
930 | } // else vertical attractor is off | 887 | } |
888 | #endregion // Vertical attactor | ||
889 | |||
890 | #region Deflection | ||
891 | |||
892 | if (m_angularDeflectionEfficiency != 0) | ||
893 | { | ||
894 | // Compute a scaled vector that points in the preferred axis (X direction) | ||
895 | Vector3 scaledDefaultDirection = | ||
896 | new Vector3((pTimestep * 10 * (m_angularDeflectionEfficiency / m_angularDeflectionTimescale)), 0, 0); | ||
897 | // Adding the current vehicle orientation and reference frame displaces the orientation to the frame. | ||
898 | // Rotate the scaled default axix relative to the actual vehicle direction giving where it should point. | ||
899 | Vector3 preferredAxisOfMotion = scaledDefaultDirection * Quaternion.Add(Prim.ForceOrientation, m_referenceFrame); | ||
900 | |||
901 | // Scale by efficiency and timescale | ||
902 | deflection = (preferredAxisOfMotion * (m_angularDeflectionEfficiency) / m_angularDeflectionTimescale) * pTimestep; | ||
903 | |||
904 | VDetailLog("{0},MoveAngular,Deflection,perfAxis={1},deflection={2}", | ||
905 | Prim.LocalID, preferredAxisOfMotion, deflection); | ||
906 | // This deflection computation is not correct. | ||
907 | deflection = Vector3.Zero; | ||
908 | } | ||
909 | |||
910 | #endregion | ||
911 | |||
912 | #region Banking | ||
913 | |||
914 | if (m_bankingEfficiency != 0) | ||
915 | { | ||
916 | Vector3 dir = Vector3.One * Prim.ForceOrientation; | ||
917 | float mult = (m_bankingMix*m_bankingMix)*-1*(m_bankingMix < 0 ? -1 : 1); | ||
918 | //Changes which way it banks in and out of turns | ||
931 | 919 | ||
932 | // m_lastVertAttractor = vertattr; | 920 | //Use the square of the efficiency, as it looks much more how SL banking works |
921 | float effSquared = (m_bankingEfficiency*m_bankingEfficiency); | ||
922 | if (m_bankingEfficiency < 0) | ||
923 | effSquared *= -1; //Keep the negative! | ||
933 | 924 | ||
934 | // Bank section tba | 925 | float mix = Math.Abs(m_bankingMix); |
926 | if (m_angularMotorVelocity.X == 0) | ||
927 | { | ||
928 | /*if (!parent.Orientation.ApproxEquals(this.m_referenceFrame, 0.25f)) | ||
929 | { | ||
930 | Vector3 axisAngle; | ||
931 | float angle; | ||
932 | parent.Orientation.GetAxisAngle(out axisAngle, out angle); | ||
933 | Vector3 rotatedVel = parent.Velocity * parent.Orientation; | ||
934 | if ((rotatedVel.X < 0 && axisAngle.Y > 0) || (rotatedVel.X > 0 && axisAngle.Y < 0)) | ||
935 | m_angularMotorVelocity.X += (effSquared * (mult * mix)) * (1f) * 10; | ||
936 | else | ||
937 | m_angularMotorVelocity.X += (effSquared * (mult * mix)) * (-1f) * 10; | ||
938 | }*/ | ||
939 | } | ||
940 | else | ||
941 | banking.Z += (effSquared*(mult*mix))*(m_angularMotorVelocity.X) * 4; | ||
942 | if (!Prim.IsColliding && Math.Abs(m_angularMotorVelocity.X) > mix) | ||
943 | //If they are colliding, we probably shouldn't shove the prim around... probably | ||
944 | { | ||
945 | float angVelZ = m_angularMotorVelocity.X*-1; | ||
946 | /*if(angVelZ > mix) | ||
947 | angVelZ = mix; | ||
948 | else if(angVelZ < -mix) | ||
949 | angVelZ = -mix;*/ | ||
950 | //This controls how fast and how far the banking occurs | ||
951 | Vector3 bankingRot = new Vector3(angVelZ*(effSquared*mult), 0, 0); | ||
952 | if (bankingRot.X > 3) | ||
953 | bankingRot.X = 3; | ||
954 | else if (bankingRot.X < -3) | ||
955 | bankingRot.X = -3; | ||
956 | bankingRot *= Prim.ForceOrientation; | ||
957 | banking += bankingRot; | ||
958 | } | ||
959 | m_angularMotorVelocity.X *= m_bankingEfficiency == 1 ? 0.0f : 1 - m_bankingEfficiency; | ||
960 | VDetailLog("{0},MoveAngular,Banking,bEff={1},angMotVel={2},banking={3}", | ||
961 | Prim.LocalID, m_bankingEfficiency, m_angularMotorVelocity, banking); | ||
962 | } | ||
935 | 963 | ||
936 | // Deflection section tba | 964 | #endregion |
965 | |||
966 | m_lastVertAttractor = vertattr; | ||
937 | 967 | ||
938 | // Sum velocities | 968 | // Sum velocities |
939 | m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // + bank + deflection | 969 | m_lastAngularVelocity = m_angularMotorVelocity + vertattr + banking + deflection; |
940 | 970 | ||
971 | #region Linear Motor Offset | ||
972 | |||
973 | //Offset section | ||
974 | if (m_linearMotorOffset != Vector3.Zero) | ||
975 | { | ||
976 | //Offset of linear velocity doesn't change the linear velocity, | ||
977 | // but causes a torque to be applied, for example... | ||
978 | // | ||
979 | // IIIII >>> IIIII | ||
980 | // IIIII >>> IIIII | ||
981 | // IIIII >>> IIIII | ||
982 | // ^ | ||
983 | // | Applying a force at the arrow will cause the object to move forward, but also rotate | ||
984 | // | ||
985 | // | ||
986 | // The torque created is the linear velocity crossed with the offset | ||
987 | |||
988 | // NOTE: this computation does should be in the linear section | ||
989 | // because there we know the impulse being applied. | ||
990 | Vector3 torqueFromOffset = Vector3.Zero; | ||
991 | // torqueFromOffset = Vector3.Cross(m_linearMotorOffset, appliedImpulse); | ||
992 | if (float.IsNaN(torqueFromOffset.X)) | ||
993 | torqueFromOffset.X = 0; | ||
994 | if (float.IsNaN(torqueFromOffset.Y)) | ||
995 | torqueFromOffset.Y = 0; | ||
996 | if (float.IsNaN(torqueFromOffset.Z)) | ||
997 | torqueFromOffset.Z = 0; | ||
998 | torqueFromOffset *= m_vehicleMass; | ||
999 | Prim.ApplyTorqueImpulse(torqueFromOffset, true); | ||
1000 | VDetailLog("{0},BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", Prim.LocalID, torqueFromOffset); | ||
1001 | } | ||
1002 | |||
1003 | #endregion | ||
1004 | |||
941 | if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0) | 1005 | if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0) |
942 | { | 1006 | { |
943 | m_lastAngularVelocity.X = 0; | 1007 | m_lastAngularVelocity.X = 0; |
944 | m_lastAngularVelocity.Y = 0; | 1008 | m_lastAngularVelocity.Y = 0; |
945 | DetailLog("{0},MoveAngular,noDeflectionUp,lastAngular={1}", m_prim.LocalID, m_lastAngularVelocity); | 1009 | VDetailLog("{0},MoveAngular,noDeflectionUp,lastAngular={1}", Prim.LocalID, m_lastAngularVelocity); |
946 | } | 1010 | } |
947 | 1011 | ||
948 | if (m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f)) | 1012 | if (m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f)) |
949 | { | 1013 | { |
950 | m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero. | 1014 | m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero. |
951 | DetailLog("{0},MoveAngular,zeroSmallValues,lastAngular={1}", m_prim.LocalID, m_lastAngularVelocity); | 1015 | Prim.ZeroAngularMotion(true); |
1016 | VDetailLog("{0},MoveAngular,zeroAngularMotion,lastAngular={1}", Prim.LocalID, m_lastAngularVelocity); | ||
1017 | } | ||
1018 | else | ||
1019 | { | ||
1020 | // Apply to the body. | ||
1021 | // The above calculates the absolute angular velocity needed. Angular velocity is massless. | ||
1022 | // Since we are stuffing the angular velocity directly into the object, the computed | ||
1023 | // velocity needs to be scaled by the timestep. | ||
1024 | Vector3 applyAngularForce = ((m_lastAngularVelocity * pTimestep) - Prim.ForceRotationalVelocity); | ||
1025 | Prim.ForceRotationalVelocity = applyAngularForce; | ||
1026 | |||
1027 | // Decay the angular movement for next time | ||
1028 | Vector3 decayamount = (Vector3.One / m_angularFrictionTimescale) * pTimestep; | ||
1029 | m_lastAngularVelocity *= Vector3.One - decayamount; | ||
1030 | |||
1031 | VDetailLog("{0},MoveAngular,done,newRotVel={1},decay={2},lastAngular={3}", | ||
1032 | Prim.LocalID, applyAngularForce, decayamount, m_lastAngularVelocity); | ||
952 | } | 1033 | } |
953 | |||
954 | // apply friction | ||
955 | Vector3 decayamount = Vector3.One / (m_angularFrictionTimescale / pTimestep); | ||
956 | m_lastAngularVelocity -= m_lastAngularVelocity * decayamount; | ||
957 | |||
958 | // Apply to the body | ||
959 | m_prim.RotationalVelocity = m_lastAngularVelocity; | ||
960 | |||
961 | DetailLog("{0},MoveAngular,done,decay={1},lastAngular={2}", m_prim.LocalID, decayamount, m_lastAngularVelocity); | ||
962 | } //end MoveAngular | 1034 | } //end MoveAngular |
963 | 1035 | ||
964 | internal void LimitRotation(float timestep) | 1036 | internal void LimitRotation(float timestep) |
965 | { | 1037 | { |
966 | Quaternion rotq = m_prim.Orientation; | 1038 | Quaternion rotq = Prim.ForceOrientation; |
967 | Quaternion m_rot = rotq; | 1039 | Quaternion m_rot = rotq; |
968 | bool changed = false; | ||
969 | if (m_RollreferenceFrame != Quaternion.Identity) | 1040 | if (m_RollreferenceFrame != Quaternion.Identity) |
970 | { | 1041 | { |
971 | if (rotq.X >= m_RollreferenceFrame.X) | 1042 | if (rotq.X >= m_RollreferenceFrame.X) |
972 | { | 1043 | { |
973 | m_rot.X = rotq.X - (m_RollreferenceFrame.X / 2); | 1044 | m_rot.X = rotq.X - (m_RollreferenceFrame.X / 2); |
974 | changed = true; | ||
975 | } | 1045 | } |
976 | if (rotq.Y >= m_RollreferenceFrame.Y) | 1046 | if (rotq.Y >= m_RollreferenceFrame.Y) |
977 | { | 1047 | { |
978 | m_rot.Y = rotq.Y - (m_RollreferenceFrame.Y / 2); | 1048 | m_rot.Y = rotq.Y - (m_RollreferenceFrame.Y / 2); |
979 | changed = true; | ||
980 | } | 1049 | } |
981 | if (rotq.X <= -m_RollreferenceFrame.X) | 1050 | if (rotq.X <= -m_RollreferenceFrame.X) |
982 | { | 1051 | { |
983 | m_rot.X = rotq.X + (m_RollreferenceFrame.X / 2); | 1052 | m_rot.X = rotq.X + (m_RollreferenceFrame.X / 2); |
984 | changed = true; | ||
985 | } | 1053 | } |
986 | if (rotq.Y <= -m_RollreferenceFrame.Y) | 1054 | if (rotq.Y <= -m_RollreferenceFrame.Y) |
987 | { | 1055 | { |
988 | m_rot.Y = rotq.Y + (m_RollreferenceFrame.Y / 2); | 1056 | m_rot.Y = rotq.Y + (m_RollreferenceFrame.Y / 2); |
989 | changed = true; | ||
990 | } | 1057 | } |
991 | changed = true; | ||
992 | } | 1058 | } |
993 | if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0) | 1059 | if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0) |
994 | { | 1060 | { |
995 | m_rot.X = 0; | 1061 | m_rot.X = 0; |
996 | m_rot.Y = 0; | 1062 | m_rot.Y = 0; |
997 | changed = true; | ||
998 | } | 1063 | } |
999 | if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0) | 1064 | if (rotq != m_rot) |
1000 | { | 1065 | { |
1001 | m_rot.X = 0; | 1066 | Prim.ForceOrientation = m_rot; |
1002 | m_rot.Y = 0; | 1067 | VDetailLog("{0},LimitRotation,done,orig={1},new={2}", Prim.LocalID, rotq, m_rot); |
1003 | changed = true; | ||
1004 | } | 1068 | } |
1005 | if (changed) | ||
1006 | m_prim.Orientation = m_rot; | ||
1007 | 1069 | ||
1008 | DetailLog("{0},LimitRotation,done,changed={1},orig={2},new={3}", m_prim.LocalID, changed, rotq, m_rot); | ||
1009 | } | 1070 | } |
1010 | 1071 | ||
1011 | // Invoke the detailed logger and output something if it's enabled. | 1072 | // Invoke the detailed logger and output something if it's enabled. |
1012 | private void DetailLog(string msg, params Object[] args) | 1073 | private void VDetailLog(string msg, params Object[] args) |
1013 | { | 1074 | { |
1014 | if (m_prim.Scene.VehicleLoggingEnabled) | 1075 | if (Prim.PhysicsScene.VehicleLoggingEnabled) |
1015 | m_prim.Scene.PhysicsLogging.Write(msg, args); | 1076 | Prim.PhysicsScene.DetailLog(msg, args); |
1016 | } | 1077 | } |
1017 | } | 1078 | } |
1018 | } | 1079 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs index 087b9bb..436e043 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs | |||
@@ -32,35 +32,80 @@ using OMV = OpenMetaverse; | |||
32 | 32 | ||
33 | namespace OpenSim.Region.Physics.BulletSPlugin | 33 | namespace OpenSim.Region.Physics.BulletSPlugin |
34 | { | 34 | { |
35 | public class BSLinkset | 35 | public abstract 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 enum LinksetImplementation |
40 | public BSPrim LinksetRoot { get { return m_linksetRoot; } } | 40 | { |
41 | Constraint = 0, // linkset tied together with constraints | ||
42 | Compound = 1, // linkset tied together as a compound object | ||
43 | Manual = 2 // linkset tied together manually (code moves all the pieces) | ||
44 | } | ||
45 | // Create the correct type of linkset for this child | ||
46 | public static BSLinkset Factory(BSScene physScene, BSPhysObject parent) | ||
47 | { | ||
48 | BSLinkset ret = null; | ||
49 | |||
50 | switch ((int)physScene.Params.linksetImplementation) | ||
51 | { | ||
52 | case (int)LinksetImplementation.Constraint: | ||
53 | ret = new BSLinksetConstraints(physScene, parent); | ||
54 | break; | ||
55 | case (int)LinksetImplementation.Compound: | ||
56 | ret = new BSLinksetCompound(physScene, parent); | ||
57 | break; | ||
58 | case (int)LinksetImplementation.Manual: | ||
59 | // ret = new BSLinksetManual(physScene, parent); | ||
60 | break; | ||
61 | default: | ||
62 | ret = new BSLinksetCompound(physScene, parent); | ||
63 | break; | ||
64 | } | ||
65 | return ret; | ||
66 | } | ||
67 | |||
68 | public BSPhysObject LinksetRoot { get; protected set; } | ||
41 | 69 | ||
42 | private BSScene m_physicsScene; | 70 | public BSScene PhysicsScene { get; private set; } |
43 | public BSScene PhysicsScene { get { return m_physicsScene; } } | ||
44 | 71 | ||
45 | // The children under the root in this linkset | 72 | static int m_nextLinksetID = 1; |
46 | private List<BSPrim> m_children; | 73 | public int LinksetID { get; private set; } |
74 | |||
75 | // The children under the root in this linkset. | ||
76 | protected HashSet<BSPhysObject> m_children; | ||
47 | 77 | ||
48 | // We lock the diddling of linkset classes to prevent any badness. | 78 | // We lock the diddling of linkset classes to prevent any badness. |
49 | // This locks the modification of the instances of this class. Changes | 79 | // This locks the modification of the instances of this class. Changes |
50 | // to the physical representation is done via the tainting mechenism. | 80 | // to the physical representation is done via the tainting mechenism. |
51 | private object m_linksetActivityLock = new Object(); | 81 | protected object m_linksetActivityLock = new Object(); |
82 | |||
83 | // Some linksets have a preferred physical shape. | ||
84 | // Returns SHAPE_UNKNOWN if there is no preference. Causes the correct shape to be selected. | ||
85 | public virtual ShapeData.PhysicsShapeType PreferredPhysicalShape(BSPhysObject requestor) | ||
86 | { | ||
87 | return ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; | ||
88 | } | ||
52 | 89 | ||
90 | // Linksets move around the children so the linkset might need to compute the child position | ||
91 | public virtual OMV.Vector3 Position(BSPhysObject member) | ||
92 | { return member.RawPosition; } | ||
93 | public virtual OMV.Quaternion Orientation(BSPhysObject member) | ||
94 | { return member.RawOrientation; } | ||
95 | // TODO: does this need to be done for Velocity and RotationalVelocityy? | ||
96 | |||
53 | // We keep the prim's mass in the linkset structure since it could be dependent on other prims | 97 | // We keep the prim's mass in the linkset structure since it could be dependent on other prims |
54 | private float m_mass; | 98 | protected float m_mass; |
55 | public float LinksetMass | 99 | public float LinksetMass |
56 | { | 100 | { |
57 | get | 101 | get |
58 | { | 102 | { |
59 | m_mass = ComputeLinksetMass(); | ||
60 | return m_mass; | 103 | return m_mass; |
61 | } | 104 | } |
62 | } | 105 | } |
63 | 106 | ||
107 | public virtual bool LinksetIsColliding { get { return false; } } | ||
108 | |||
64 | public OMV.Vector3 CenterOfMass | 109 | public OMV.Vector3 CenterOfMass |
65 | { | 110 | { |
66 | get { return ComputeLinksetCenterOfMass(); } | 111 | get { return ComputeLinksetCenterOfMass(); } |
@@ -71,23 +116,31 @@ public class BSLinkset | |||
71 | get { return ComputeLinksetGeometricCenter(); } | 116 | get { return ComputeLinksetGeometricCenter(); } |
72 | } | 117 | } |
73 | 118 | ||
74 | public BSLinkset(BSScene scene, BSPrim parent) | 119 | protected void Initialize(BSScene scene, BSPhysObject parent) |
75 | { | 120 | { |
76 | // A simple linkset of one (no children) | 121 | // A simple linkset of one (no children) |
77 | m_physicsScene = scene; | 122 | LinksetID = m_nextLinksetID++; |
78 | m_linksetRoot = parent; | 123 | // We create LOTS of linksets. |
79 | m_children = new List<BSPrim>(); | 124 | if (m_nextLinksetID <= 0) |
80 | m_mass = parent.MassRaw; | 125 | m_nextLinksetID = 1; |
126 | PhysicsScene = scene; | ||
127 | LinksetRoot = parent; | ||
128 | m_children = new HashSet<BSPhysObject>(); | ||
129 | m_mass = parent.RawMass; | ||
81 | } | 130 | } |
82 | 131 | ||
83 | // Link to a linkset where the child knows the parent. | 132 | // Link to a linkset where the child knows the parent. |
84 | // Parent changing should not happen so do some sanity checking. | 133 | // Parent changing should not happen so do some sanity checking. |
85 | // We return the parent's linkset so the child can track its membership. | 134 | // We return the parent's linkset so the child can track its membership. |
86 | public BSLinkset AddMeToLinkset(BSPrim child) | 135 | // Called at runtime. |
136 | public BSLinkset AddMeToLinkset(BSPhysObject child) | ||
87 | { | 137 | { |
88 | lock (m_linksetActivityLock) | 138 | lock (m_linksetActivityLock) |
89 | { | 139 | { |
90 | AddChildToLinkset(child); | 140 | // Don't add the root to its own linkset |
141 | if (!IsRoot(child)) | ||
142 | AddChildToLinkset(child); | ||
143 | m_mass = ComputeLinksetMass(); | ||
91 | } | 144 | } |
92 | return this; | 145 | return this; |
93 | } | 146 | } |
@@ -95,36 +148,28 @@ public class BSLinkset | |||
95 | // Remove a child from a linkset. | 148 | // Remove a child from a linkset. |
96 | // Returns a new linkset for the child which is a linkset of one (just the | 149 | // Returns a new linkset for the child which is a linkset of one (just the |
97 | // orphened child). | 150 | // orphened child). |
98 | public BSLinkset RemoveMeFromLinkset(BSPrim child) | 151 | // Called at runtime. |
152 | public BSLinkset RemoveMeFromLinkset(BSPhysObject child) | ||
99 | { | 153 | { |
100 | lock (m_linksetActivityLock) | 154 | lock (m_linksetActivityLock) |
101 | { | 155 | { |
102 | if (IsRoot(child)) | 156 | if (IsRoot(child)) |
103 | { | 157 | { |
104 | // if root of linkset, take the linkset apart | 158 | // Cannot remove the root from a linkset. |
105 | while (m_children.Count > 0) | 159 | 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 | } | 160 | } |
161 | RemoveChildFromLinkset(child); | ||
162 | m_mass = ComputeLinksetMass(); | ||
118 | } | 163 | } |
119 | 164 | ||
120 | // The child is down to a linkset of just itself | 165 | // The child is down to a linkset of just itself |
121 | return new BSLinkset(PhysicsScene, child); | 166 | return BSLinkset.Factory(PhysicsScene, child); |
122 | } | 167 | } |
123 | 168 | ||
124 | // Return 'true' if the passed object is the root object of this linkset | 169 | // Return 'true' if the passed object is the root object of this linkset |
125 | public bool IsRoot(BSPrim requestor) | 170 | public bool IsRoot(BSPhysObject requestor) |
126 | { | 171 | { |
127 | return (requestor.LocalID == m_linksetRoot.LocalID); | 172 | return (requestor.LocalID == LinksetRoot.LocalID); |
128 | } | 173 | } |
129 | 174 | ||
130 | public int NumberOfChildren { get { return m_children.Count; } } | 175 | public int NumberOfChildren { get { return m_children.Count; } } |
@@ -133,12 +178,14 @@ public class BSLinkset | |||
133 | public bool HasAnyChildren { get { return (m_children.Count > 0); } } | 178 | public bool HasAnyChildren { get { return (m_children.Count > 0); } } |
134 | 179 | ||
135 | // Return 'true' if this child is in this linkset | 180 | // Return 'true' if this child is in this linkset |
136 | public bool HasChild(BSPrim child) | 181 | public bool HasChild(BSPhysObject child) |
137 | { | 182 | { |
138 | bool ret = false; | 183 | bool ret = false; |
139 | lock (m_linksetActivityLock) | 184 | lock (m_linksetActivityLock) |
140 | { | 185 | { |
141 | foreach (BSPrim bp in m_children) | 186 | ret = m_children.Contains(child); |
187 | /* Safer version but the above should work | ||
188 | foreach (BSPhysObject bp in m_children) | ||
142 | { | 189 | { |
143 | if (child.LocalID == bp.LocalID) | 190 | if (child.LocalID == bp.LocalID) |
144 | { | 191 | { |
@@ -146,274 +193,132 @@ public class BSLinkset | |||
146 | break; | 193 | break; |
147 | } | 194 | } |
148 | } | 195 | } |
196 | */ | ||
149 | } | 197 | } |
150 | return ret; | 198 | return ret; |
151 | } | 199 | } |
152 | 200 | ||
153 | private float ComputeLinksetMass() | 201 | // Perform an action on each member of the linkset including root prim. |
154 | { | 202 | // Depends on the action on whether this should be done at taint time. |
155 | float mass = m_linksetRoot.MassRaw; | 203 | public delegate bool ForEachMemberAction(BSPhysObject obj); |
156 | foreach (BSPrim bp in m_children) | 204 | public virtual bool ForEachMember(ForEachMemberAction action) |
157 | { | ||
158 | mass += bp.MassRaw; | ||
159 | } | ||
160 | return mass; | ||
161 | } | ||
162 | |||
163 | private OMV.Vector3 ComputeLinksetCenterOfMass() | ||
164 | { | 205 | { |
165 | OMV.Vector3 com = m_linksetRoot.Position * m_linksetRoot.MassRaw; | 206 | bool ret = false; |
166 | float totalMass = m_linksetRoot.MassRaw; | ||
167 | |||
168 | lock (m_linksetActivityLock) | 207 | lock (m_linksetActivityLock) |
169 | { | 208 | { |
170 | foreach (BSPrim bp in m_children) | 209 | action(LinksetRoot); |
210 | foreach (BSPhysObject po in m_children) | ||
171 | { | 211 | { |
172 | com += bp.Position * bp.MassRaw; | 212 | if (action(po)) |
173 | totalMass += bp.MassRaw; | 213 | break; |
174 | } | 214 | } |
175 | if (totalMass != 0f) | ||
176 | com /= totalMass; | ||
177 | } | 215 | } |
178 | 216 | return ret; | |
179 | return com; | ||
180 | } | 217 | } |
181 | 218 | ||
182 | private OMV.Vector3 ComputeLinksetGeometricCenter() | 219 | // I am the root of a linkset and a new child is being added |
183 | { | 220 | // Called while LinkActivity is locked. |
184 | OMV.Vector3 com = m_linksetRoot.Position; | 221 | protected abstract void AddChildToLinkset(BSPhysObject child); |
185 | |||
186 | lock (m_linksetActivityLock) | ||
187 | { | ||
188 | foreach (BSPrim bp in m_children) | ||
189 | { | ||
190 | com += bp.Position * bp.MassRaw; | ||
191 | } | ||
192 | com /= (m_children.Count + 1); | ||
193 | } | ||
194 | 222 | ||
195 | return com; | 223 | // I am the root of a linkset and one of my children is being removed. |
196 | } | 224 | // Safe to call even if the child is not really in my linkset. |
225 | protected abstract void RemoveChildFromLinkset(BSPhysObject child); | ||
197 | 226 | ||
198 | // When physical properties are changed the linkset needs to recalculate | 227 | // When physical properties are changed the linkset needs to recalculate |
199 | // its internal properties. | 228 | // its internal properties. |
200 | public void Refresh(BSPrim requestor) | 229 | // May be called at runtime or taint-time. |
201 | { | 230 | public abstract void Refresh(BSPhysObject requestor); |
202 | // If there are no children, there aren't any constraints to recompute | 231 | |
203 | if (!HasAnyChildren) | 232 | // The object is going dynamic (physical). Do any setup necessary |
204 | return; | 233 | // for a dynamic linkset. |
205 | 234 | // Only the state of the passed object can be modified. The rest of the linkset | |
206 | // Only the root does the recomputation | 235 | // has not yet been fully constructed. |
207 | if (IsRoot(requestor)) | 236 | // Return 'true' if any properties updated on the passed object. |
208 | { | 237 | // Called at taint-time! |
209 | PhysicsScene.TaintedObject("BSLinkSet.Refresh", delegate() | 238 | public abstract bool MakeDynamic(BSPhysObject child); |
210 | { | 239 | |
211 | RecomputeLinksetConstraintVariables(); | 240 | // The object is going static (non-physical). Do any setup necessary |
212 | }); | 241 | // for a static linkset. |
213 | } | 242 | // Return 'true' if any properties updated on the passed object. |
214 | } | 243 | // Called at taint-time! |
215 | 244 | public abstract bool MakeStatic(BSPhysObject child); | |
216 | // Call each of the constraints that make up this linkset and recompute the | 245 | |
217 | // various transforms and variables. Used when objects are added or removed | 246 | // Called when a parameter update comes from the physics engine for any object |
218 | // from a linkset to make sure the constraints know about the new mass and | 247 | // of the linkset is received. |
219 | // geometry. | 248 | // Called at taint-time!! |
220 | // Must only be called at taint time!! | 249 | public abstract void UpdateProperties(BSPhysObject physObject); |
221 | private bool RecomputeLinksetConstraintVariables() | 250 | |
251 | // Routine used when rebuilding the body of the root of the linkset | ||
252 | // Destroy all the constraints have have been made to root. | ||
253 | // This is called when the root body is changing. | ||
254 | // Returns 'true' of something was actually removed and would need restoring | ||
255 | // Called at taint-time!! | ||
256 | public abstract bool RemoveBodyDependencies(BSPrim child); | ||
257 | |||
258 | // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true', | ||
259 | // this routine will restore the removed constraints. | ||
260 | // Called at taint-time!! | ||
261 | public abstract void RestoreBodyDependencies(BSPrim child); | ||
262 | |||
263 | // ================================================================ | ||
264 | protected virtual float ComputeLinksetMass() | ||
222 | { | 265 | { |
223 | float linksetMass = LinksetMass; | 266 | float mass = LinksetRoot.RawMass; |
224 | lock (m_linksetActivityLock) | 267 | if (HasAnyChildren) |
225 | { | 268 | { |
226 | foreach (BSPrim child in m_children) | 269 | lock (m_linksetActivityLock) |
227 | { | 270 | { |
228 | BSConstraint constrain; | 271 | foreach (BSPhysObject bp in m_children) |
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 | { | 272 | { |
237 | // Non-fatal error that can happen when children are being added to the linkset but | 273 | mass += bp.RawMass; |
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 | } | 274 | } |
244 | } | 275 | } |
245 | } | 276 | } |
246 | return false; | 277 | return mass; |
247 | } | 278 | } |
248 | 279 | ||
249 | // I am the root of a linkset and a new child is being added | 280 | protected virtual OMV.Vector3 ComputeLinksetCenterOfMass() |
250 | // Called while LinkActivity is locked. | ||
251 | private void AddChildToLinkset(BSPrim child) | ||
252 | { | 281 | { |
253 | if (!HasChild(child)) | 282 | OMV.Vector3 com; |
283 | lock (m_linksetActivityLock) | ||
254 | { | 284 | { |
255 | m_children.Add(child); | 285 | com = LinksetRoot.Position * LinksetRoot.RawMass; |
286 | float totalMass = LinksetRoot.RawMass; | ||
256 | 287 | ||
257 | BSPrim rootx = LinksetRoot; // capture the root as of now | 288 | foreach (BSPhysObject bp in m_children) |
258 | BSPrim childx = child; | ||
259 | m_physicsScene.TaintedObject("AddChildToLinkset", delegate() | ||
260 | { | 289 | { |
261 | // DebugLog("{0}: AddChildToLinkset: adding child {1} to {2}", LogHeader, child.LocalID, m_linksetRoot.LocalID); | 290 | com += bp.Position * bp.RawMass; |
262 | // DetailLog("{0},AddChildToLinkset,taint,child={1}", m_linksetRoot.LocalID, child.LocalID); | 291 | totalMass += bp.RawMass; |
263 | PhysicallyLinkAChildToRoot(rootx, childx); // build the physical binding between me and the child | 292 | } |
264 | }); | 293 | if (totalMass != 0f) |
294 | com /= totalMass; | ||
265 | } | 295 | } |
266 | return; | ||
267 | } | ||
268 | 296 | ||
269 | // Forcefully removing a child from a linkset. | 297 | return com; |
270 | // 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. | ||
272 | // Normal OpenSimulator operation will never do this because other SceneObjectPart information | ||
273 | // has to be updated also (like pointer to prim's parent). | ||
274 | private void RemoveChildFromOtherLinkset(BSPrim pchild) | ||
275 | { | ||
276 | pchild.Linkset = new BSLinkset(m_physicsScene, pchild); | ||
277 | RemoveChildFromLinkset(pchild); | ||
278 | } | 298 | } |
279 | 299 | ||
280 | // I am the root of a linkset and one of my children is being removed. | 300 | protected virtual OMV.Vector3 ComputeLinksetGeometricCenter() |
281 | // Safe to call even if the child is not really in my linkset. | ||
282 | private void RemoveChildFromLinkset(BSPrim child) | ||
283 | { | 301 | { |
284 | if (m_children.Remove(child)) | 302 | OMV.Vector3 com; |
303 | lock (m_linksetActivityLock) | ||
285 | { | 304 | { |
286 | BSPrim rootx = LinksetRoot; // capture the root as of now | 305 | com = LinksetRoot.Position; |
287 | BSPrim childx = child; | ||
288 | m_physicsScene.TaintedObject("RemoveChildFromLinkset", delegate() | ||
289 | { | ||
290 | // DebugLog("{0}: RemoveChildFromLinkset: Removing constraint to {1}", LogHeader, child.LocalID); | ||
291 | // DetailLog("{0},RemoveChildFromLinkset,taint,child={1}", m_linksetRoot.LocalID, child.LocalID); | ||
292 | |||
293 | PhysicallyUnlinkAChildFromRoot(rootx, childx); | ||
294 | }); | ||
295 | 306 | ||
296 | RecomputeLinksetConstraintVariables(); | 307 | foreach (BSPhysObject bp in m_children) |
297 | } | 308 | { |
298 | else | 309 | com += bp.Position * bp.RawMass; |
299 | { | 310 | } |
300 | // This will happen if we remove the root of the linkset first. Non-fatal occurance. | 311 | com /= (m_children.Count + 1); |
301 | // PhysicsScene.Logger.ErrorFormat("{0}: Asked to remove child from linkset that was not in linkset", LogHeader); | ||
302 | } | 312 | } |
303 | return; | ||
304 | } | ||
305 | |||
306 | // Create a constraint between me (root of linkset) and the passed prim (the child). | ||
307 | // Called at taint time! | ||
308 | private void PhysicallyLinkAChildToRoot(BSPrim rootPrim, BSPrim childPrim) | ||
309 | { | ||
310 | // Zero motion for children so they don't interpolate | ||
311 | childPrim.ZeroMotion(); | ||
312 | |||
313 | // Relative position normalized to the root prim | ||
314 | // Essentually a vector pointing from center of rootPrim to center of childPrim | ||
315 | OMV.Vector3 childRelativePosition = childPrim.Position - rootPrim.Position; | ||
316 | |||
317 | // real world coordinate of midpoint between the two objects | ||
318 | OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2); | ||
319 | |||
320 | // create a constraint that allows no freedom of movement between the two objects | ||
321 | // 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); | ||
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( | ||
326 | m_physicsScene.World, rootPrim.Body, childPrim.Body, | ||
327 | midPoint, | ||
328 | true, | ||
329 | true | ||
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. | ||
334 | * Code left here as an example. | ||
335 | // ================================================================================== | ||
336 | // relative position normalized to the root prim | ||
337 | OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation); | ||
338 | OMV.Vector3 childRelativePosition = (childPrim.Position - rootPrim.Position) * invThisOrientation; | ||
339 | |||
340 | // relative rotation of the child to the parent | ||
341 | OMV.Quaternion childRelativeRotation = invThisOrientation * childPrim.Orientation; | ||
342 | OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation); | ||
343 | |||
344 | // create a constraint that allows no freedom of movement between the two objects | ||
345 | // 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); | ||
347 | DetailLog("{0},PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID); | ||
348 | BS6DofConstraint constrain = new BS6DofConstraint( | ||
349 | PhysicsScene.World, rootPrim.Body, childPrim.Body, | ||
350 | OMV.Vector3.Zero, | ||
351 | OMV.Quaternion.Inverse(rootPrim.Orientation), | ||
352 | OMV.Vector3.Zero, | ||
353 | OMV.Quaternion.Inverse(childPrim.Orientation), | ||
354 | // A point half way between the parent and child | ||
355 | // childRelativePosition/2, | ||
356 | // childRelativeRotation, | ||
357 | // childRelativePosition/2, | ||
358 | // inverseChildRelativeRotation, | ||
359 | true, | ||
360 | true | ||
361 | ); | ||
362 | // ================================================================================== | ||
363 | */ | ||
364 | |||
365 | m_physicsScene.Constraints.AddConstraint(constrain); | ||
366 | |||
367 | // 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); | ||
369 | constrain.SetAngularLimits(OMV.Vector3.Zero, OMV.Vector3.Zero); | ||
370 | |||
371 | // tweek the constraint to increase stability | ||
372 | constrain.UseFrameOffset(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintUseFrameOffset)); | ||
373 | constrain.TranslationalLimitMotor(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintEnableTransMotor), | ||
374 | PhysicsScene.Params.linkConstraintTransMotorMaxVel, | ||
375 | PhysicsScene.Params.linkConstraintTransMotorMaxForce); | ||
376 | constrain.SetCFMAndERP(PhysicsScene.Params.linkConstraintCFM, PhysicsScene.Params.linkConstraintERP); | ||
377 | |||
378 | RecomputeLinksetConstraintVariables(); | ||
379 | } | ||
380 | 313 | ||
381 | // Remove linkage between myself and a particular child | 314 | return com; |
382 | // Called at taint time! | ||
383 | private void PhysicallyUnlinkAChildFromRoot(BSPrim rootPrim, BSPrim childPrim) | ||
384 | { | ||
385 | // DebugLog("{0}: PhysicallyUnlinkAChildFromRoot: RemoveConstraint between root prim {1} and child prim {2}", | ||
386 | // LogHeader, rootPrim.LocalID, childPrim.LocalID); | ||
387 | DetailLog("{0},PhysicallyUnlinkAChildFromRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID); | ||
388 | |||
389 | // 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); | ||
391 | |||
392 | // Make the child refresh its location | ||
393 | BulletSimAPI.PushUpdate2(childPrim.Body.Ptr); | ||
394 | } | ||
395 | |||
396 | // Remove linkage between myself and any possible children I might have | ||
397 | // Called at taint time! | ||
398 | private void PhysicallyUnlinkAllChildrenFromRoot(BSPrim rootPrim) | ||
399 | { | ||
400 | // DebugLog("{0}: PhysicallyUnlinkAllChildren:", LogHeader); | ||
401 | DetailLog("{0},PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID); | ||
402 | |||
403 | m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body); | ||
404 | } | ||
405 | |||
406 | // Invoke the detailed logger and output something if it's enabled. | ||
407 | private void DebugLog(string msg, params Object[] args) | ||
408 | { | ||
409 | if (m_physicsScene.ShouldDebugLog) | ||
410 | m_physicsScene.Logger.DebugFormat(msg, args); | ||
411 | } | 315 | } |
412 | 316 | ||
413 | // Invoke the detailed logger and output something if it's enabled. | 317 | // Invoke the detailed logger and output something if it's enabled. |
414 | private void DetailLog(string msg, params Object[] args) | 318 | protected void DetailLog(string msg, params Object[] args) |
415 | { | 319 | { |
416 | m_physicsScene.PhysicsLogging.Write(msg, args); | 320 | if (PhysicsScene.PhysicsLogging.Enabled) |
321 | PhysicsScene.DetailLog(msg, args); | ||
417 | } | 322 | } |
418 | 323 | ||
419 | } | 324 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs new file mode 100755 index 0000000..3238c85 --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs | |||
@@ -0,0 +1,275 @@ | |||
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 | |||
33 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
34 | { | ||
35 | public sealed class BSLinksetCompound : BSLinkset | ||
36 | { | ||
37 | private static string LogHeader = "[BULLETSIM LINKSET COMPOUND]"; | ||
38 | |||
39 | public BSLinksetCompound(BSScene scene, BSPhysObject parent) | ||
40 | { | ||
41 | base.Initialize(scene, parent); | ||
42 | } | ||
43 | |||
44 | // For compound implimented linksets, if there are children, use compound shape for the root. | ||
45 | public override ShapeData.PhysicsShapeType PreferredPhysicalShape(BSPhysObject requestor) | ||
46 | { | ||
47 | ShapeData.PhysicsShapeType ret = ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; | ||
48 | if (IsRoot(requestor) && HasAnyChildren) | ||
49 | { | ||
50 | ret = ShapeData.PhysicsShapeType.SHAPE_COMPOUND; | ||
51 | } | ||
52 | // DetailLog("{0},BSLinksetCompound.PreferredPhysicalShape,call,shape={1}", LinksetRoot.LocalID, ret); | ||
53 | return ret; | ||
54 | } | ||
55 | |||
56 | // When physical properties are changed the linkset needs to recalculate | ||
57 | // its internal properties. | ||
58 | // This is queued in the 'post taint' queue so the | ||
59 | // refresh will happen once after all the other taints are applied. | ||
60 | public override void Refresh(BSPhysObject requestor) | ||
61 | { | ||
62 | // External request for Refresh (from BSPrim) is not necessary | ||
63 | // InternalRefresh(requestor); | ||
64 | } | ||
65 | |||
66 | private void InternalRefresh(BSPhysObject requestor) | ||
67 | { | ||
68 | DetailLog("{0},BSLinksetCompound.Refresh,schedulingRefresh,requestor={1}", LinksetRoot.LocalID, requestor.LocalID); | ||
69 | // Queue to happen after all the other taint processing | ||
70 | PhysicsScene.PostTaintObject("BSLinksetCompound.Refresh", requestor.LocalID, delegate() | ||
71 | { | ||
72 | if (IsRoot(requestor) && HasAnyChildren) | ||
73 | RecomputeLinksetCompound(); | ||
74 | }); | ||
75 | } | ||
76 | |||
77 | // The object is going dynamic (physical). Do any setup necessary | ||
78 | // for a dynamic linkset. | ||
79 | // Only the state of the passed object can be modified. The rest of the linkset | ||
80 | // has not yet been fully constructed. | ||
81 | // Return 'true' if any properties updated on the passed object. | ||
82 | // Called at taint-time! | ||
83 | public override bool MakeDynamic(BSPhysObject child) | ||
84 | { | ||
85 | bool ret = false; | ||
86 | DetailLog("{0},BSLinksetCompound.MakeDynamic,call,IsRoot={1}", child.LocalID, IsRoot(child)); | ||
87 | if (!IsRoot(child)) | ||
88 | { | ||
89 | // Physical children are removed from the world as the shape ofthe root compound | ||
90 | // shape takes over. | ||
91 | BulletSimAPI.AddToCollisionFlags2(child.PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE); | ||
92 | BulletSimAPI.ForceActivationState2(child.PhysBody.ptr, ActivationState.DISABLE_SIMULATION); | ||
93 | ret = true; | ||
94 | } | ||
95 | return ret; | ||
96 | } | ||
97 | |||
98 | // The object is going static (non-physical). Do any setup necessary for a static linkset. | ||
99 | // Return 'true' if any properties updated on the passed object. | ||
100 | // This doesn't normally happen -- OpenSim removes the objects from the physical | ||
101 | // world if it is a static linkset. | ||
102 | // Called at taint-time! | ||
103 | public override bool MakeStatic(BSPhysObject child) | ||
104 | { | ||
105 | bool ret = false; | ||
106 | DetailLog("{0},BSLinksetCompound.MakeStatic,call,IsRoot={1}", child.LocalID, IsRoot(child)); | ||
107 | if (!IsRoot(child)) | ||
108 | { | ||
109 | // The non-physical children can come back to life. | ||
110 | BulletSimAPI.RemoveFromCollisionFlags2(child.PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE); | ||
111 | // Don't force activation so setting of DISABLE_SIMULATION can stay. | ||
112 | BulletSimAPI.Activate2(child.PhysBody.ptr, false); | ||
113 | ret = true; | ||
114 | } | ||
115 | return ret; | ||
116 | } | ||
117 | |||
118 | // Called at taint-time!! | ||
119 | public override void UpdateProperties(BSPhysObject updated) | ||
120 | { | ||
121 | // Nothing to do for constraints on property updates | ||
122 | } | ||
123 | |||
124 | // The children move around in relationship to the root. | ||
125 | // Just grab the current values of wherever it is right now. | ||
126 | public override OMV.Vector3 Position(BSPhysObject member) | ||
127 | { | ||
128 | return BulletSimAPI.GetPosition2(member.PhysBody.ptr); | ||
129 | } | ||
130 | |||
131 | public override OMV.Quaternion Orientation(BSPhysObject member) | ||
132 | { | ||
133 | return BulletSimAPI.GetOrientation2(member.PhysBody.ptr); | ||
134 | } | ||
135 | |||
136 | // Routine called when rebuilding the body of some member of the linkset. | ||
137 | // Since we don't keep in world relationships, do nothing unless it's a child changing. | ||
138 | // Returns 'true' of something was actually removed and would need restoring | ||
139 | // Called at taint-time!! | ||
140 | public override bool RemoveBodyDependencies(BSPrim child) | ||
141 | { | ||
142 | bool ret = false; | ||
143 | |||
144 | DetailLog("{0},BSLinksetCompound.RemoveBodyDependencies,refreshIfChild,rID={1},rBody={2},isRoot={3}", | ||
145 | child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"), IsRoot(child)); | ||
146 | |||
147 | if (!IsRoot(child)) | ||
148 | { | ||
149 | // Cause the current shape to be freed and the new one to be built. | ||
150 | InternalRefresh(LinksetRoot); | ||
151 | ret = true; | ||
152 | } | ||
153 | |||
154 | return ret; | ||
155 | } | ||
156 | |||
157 | // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true', | ||
158 | // this routine will restore the removed constraints. | ||
159 | // Called at taint-time!! | ||
160 | public override void RestoreBodyDependencies(BSPrim child) | ||
161 | { | ||
162 | // The Refresh operation queued by RemoveBodyDependencies() will build any missing constraints. | ||
163 | } | ||
164 | |||
165 | // ================================================================ | ||
166 | |||
167 | // Add a new child to the linkset. | ||
168 | // Called while LinkActivity is locked. | ||
169 | protected override void AddChildToLinkset(BSPhysObject child) | ||
170 | { | ||
171 | if (!HasChild(child)) | ||
172 | { | ||
173 | m_children.Add(child); | ||
174 | |||
175 | DetailLog("{0},BSLinksetCompound.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID); | ||
176 | |||
177 | // Cause constraints and assorted properties to be recomputed before the next simulation step. | ||
178 | InternalRefresh(LinksetRoot); | ||
179 | } | ||
180 | return; | ||
181 | } | ||
182 | |||
183 | // Remove the specified child from the linkset. | ||
184 | // Safe to call even if the child is not really in my linkset. | ||
185 | protected override void RemoveChildFromLinkset(BSPhysObject child) | ||
186 | { | ||
187 | if (m_children.Remove(child)) | ||
188 | { | ||
189 | DetailLog("{0},BSLinksetCompound.RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}", | ||
190 | child.LocalID, | ||
191 | LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"), | ||
192 | child.LocalID, child.PhysBody.ptr.ToString("X")); | ||
193 | |||
194 | // Cause the child's body to be rebuilt and thus restored to normal operation | ||
195 | child.ForceBodyShapeRebuild(false); | ||
196 | |||
197 | if (!HasAnyChildren) | ||
198 | { | ||
199 | // The linkset is now empty. The root needs rebuilding. | ||
200 | LinksetRoot.ForceBodyShapeRebuild(false); | ||
201 | } | ||
202 | else | ||
203 | { | ||
204 | // Schedule a rebuild of the linkset before the next simulation tick. | ||
205 | InternalRefresh(LinksetRoot); | ||
206 | } | ||
207 | } | ||
208 | return; | ||
209 | } | ||
210 | |||
211 | // Called before the simulation step to make sure the compound based linkset | ||
212 | // is all initialized. | ||
213 | // Constraint linksets are rebuilt every time. | ||
214 | // Note that this works for rebuilding just the root after a linkset is taken apart. | ||
215 | // Called at taint time!! | ||
216 | private void RecomputeLinksetCompound() | ||
217 | { | ||
218 | // Cause the root shape to be rebuilt as a compound object with just the root in it | ||
219 | LinksetRoot.ForceBodyShapeRebuild(true); | ||
220 | |||
221 | DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,start,rBody={1},rShape={2},numChildren={3}", | ||
222 | LinksetRoot.LocalID, LinksetRoot.PhysBody, LinksetRoot.PhysShape, NumberOfChildren); | ||
223 | |||
224 | // Add a shape for each of the other children in the linkset | ||
225 | ForEachMember(delegate(BSPhysObject cPrim) | ||
226 | { | ||
227 | if (!IsRoot(cPrim)) | ||
228 | { | ||
229 | // Each child position and rotation is given relative to the root. | ||
230 | OMV.Quaternion invRootOrientation = OMV.Quaternion.Inverse(LinksetRoot.RawOrientation); | ||
231 | OMV.Vector3 displacementPos = (cPrim.RawPosition - LinksetRoot.RawPosition) * invRootOrientation; | ||
232 | OMV.Quaternion displacementRot = cPrim.RawOrientation * invRootOrientation; | ||
233 | |||
234 | DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addMemberToShape,mID={1},mShape={2},dispPos={3},dispRot={4}", | ||
235 | LinksetRoot.LocalID, cPrim.LocalID, cPrim.PhysShape, displacementPos, displacementRot); | ||
236 | |||
237 | if (cPrim.PhysShape.isNativeShape) | ||
238 | { | ||
239 | // Native shapes are not shared so we need to create a new one. | ||
240 | // A mesh or hull is created because scale is not available on a native shape. | ||
241 | // (TODO: Bullet does have a btScaledCollisionShape. Can that be used?) | ||
242 | BulletShape saveShape = cPrim.PhysShape; | ||
243 | cPrim.PhysShape.ptr = IntPtr.Zero; // Don't let the create free the child's shape | ||
244 | PhysicsScene.Shapes.CreateGeomMeshOrHull(cPrim, null); | ||
245 | BulletShape newShape = cPrim.PhysShape; | ||
246 | cPrim.PhysShape = saveShape; | ||
247 | BulletSimAPI.AddChildShapeToCompoundShape2(LinksetRoot.PhysShape.ptr, newShape.ptr, displacementPos, displacementRot); | ||
248 | } | ||
249 | else | ||
250 | { | ||
251 | // For the shared shapes (meshes and hulls), just use the shape in the child. | ||
252 | if (PhysicsScene.Shapes.ReferenceShape(cPrim.PhysShape)) | ||
253 | { | ||
254 | PhysicsScene.Logger.ErrorFormat("{0} Rebuilt sharable shape when building linkset! Region={1}, primID={2}, shape={3}", | ||
255 | LogHeader, PhysicsScene.RegionName, cPrim.LocalID, cPrim.PhysShape); | ||
256 | } | ||
257 | BulletSimAPI.AddChildShapeToCompoundShape2(LinksetRoot.PhysShape.ptr, cPrim.PhysShape.ptr, displacementPos, displacementRot); | ||
258 | } | ||
259 | } | ||
260 | return false; // 'false' says to move onto the next child in the list | ||
261 | }); | ||
262 | |||
263 | // With all of the linkset packed into the root prim, it has the mass of everyone. | ||
264 | float linksetMass = LinksetMass; | ||
265 | LinksetRoot.UpdatePhysicalMassProperties(linksetMass); | ||
266 | |||
267 | BulletSimAPI.RecalculateCompoundShapeLocalAabb2(LinksetRoot.PhysShape.ptr); | ||
268 | |||
269 | // DEBUG: see of inter-linkset collisions are causing problems for constraint linksets. | ||
270 | // BulletSimAPI.SetCollisionFilterMask2(LinksetRoot.BSBody.ptr, | ||
271 | // (uint)CollisionFilterGroups.LinksetFilter, (uint)CollisionFilterGroups.LinksetMask); | ||
272 | |||
273 | } | ||
274 | } | ||
275 | } \ No newline at end of file | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs new file mode 100755 index 0000000..c855fda --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs | |||
@@ -0,0 +1,327 @@ | |||
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 | |||
33 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
34 | { | ||
35 | public sealed class BSLinksetConstraints : BSLinkset | ||
36 | { | ||
37 | // private static string LogHeader = "[BULLETSIM LINKSET CONSTRAINTS]"; | ||
38 | |||
39 | public BSLinksetConstraints(BSScene scene, BSPhysObject parent) | ||
40 | { | ||
41 | base.Initialize(scene, parent); | ||
42 | } | ||
43 | |||
44 | // When physical properties are changed the linkset needs to recalculate | ||
45 | // its internal properties. | ||
46 | // This is queued in the 'post taint' queue so the | ||
47 | // refresh will happen once after all the other taints are applied. | ||
48 | public override void Refresh(BSPhysObject requestor) | ||
49 | { | ||
50 | // Queue to happen after all the other taint processing | ||
51 | PhysicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate() | ||
52 | { | ||
53 | if (HasAnyChildren && IsRoot(requestor)) | ||
54 | RecomputeLinksetConstraints(); | ||
55 | }); | ||
56 | } | ||
57 | |||
58 | // The object is going dynamic (physical). Do any setup necessary | ||
59 | // for a dynamic linkset. | ||
60 | // Only the state of the passed object can be modified. The rest of the linkset | ||
61 | // has not yet been fully constructed. | ||
62 | // Return 'true' if any properties updated on the passed object. | ||
63 | // Called at taint-time! | ||
64 | public override bool MakeDynamic(BSPhysObject child) | ||
65 | { | ||
66 | // What is done for each object in BSPrim is what we want. | ||
67 | return false; | ||
68 | } | ||
69 | |||
70 | // The object is going static (non-physical). Do any setup necessary for a static linkset. | ||
71 | // Return 'true' if any properties updated on the passed object. | ||
72 | // This doesn't normally happen -- OpenSim removes the objects from the physical | ||
73 | // world if it is a static linkset. | ||
74 | // Called at taint-time! | ||
75 | public override bool MakeStatic(BSPhysObject child) | ||
76 | { | ||
77 | // What is done for each object in BSPrim is what we want. | ||
78 | return false; | ||
79 | } | ||
80 | |||
81 | // Called at taint-time!! | ||
82 | public override void UpdateProperties(BSPhysObject updated) | ||
83 | { | ||
84 | // Nothing to do for constraints on property updates | ||
85 | } | ||
86 | |||
87 | // The children of the linkset are moved around by the constraints. | ||
88 | // Just grab the current values of wherever it is right now. | ||
89 | public override OMV.Vector3 Position(BSPhysObject member) | ||
90 | { | ||
91 | return BulletSimAPI.GetPosition2(member.PhysBody.ptr); | ||
92 | } | ||
93 | |||
94 | public override OMV.Quaternion Orientation(BSPhysObject member) | ||
95 | { | ||
96 | return BulletSimAPI.GetOrientation2(member.PhysBody.ptr); | ||
97 | } | ||
98 | |||
99 | // Routine called when rebuilding the body of some member of the linkset. | ||
100 | // Destroy all the constraints have have been made to root and set | ||
101 | // up to rebuild the constraints before the next simulation step. | ||
102 | // Returns 'true' of something was actually removed and would need restoring | ||
103 | // Called at taint-time!! | ||
104 | public override bool RemoveBodyDependencies(BSPrim child) | ||
105 | { | ||
106 | bool ret = false; | ||
107 | |||
108 | DetailLog("{0},BSLinksetConstraint.RemoveBodyDependencies,removeChildrenForRoot,rID={1},rBody={2}", | ||
109 | child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X")); | ||
110 | |||
111 | lock (m_linksetActivityLock) | ||
112 | { | ||
113 | // Just undo all the constraints for this linkset. Rebuild at the end of the step. | ||
114 | ret = PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot); | ||
115 | // Cause the constraints, et al to be rebuilt before the next simulation step. | ||
116 | Refresh(LinksetRoot); | ||
117 | } | ||
118 | return ret; | ||
119 | } | ||
120 | |||
121 | // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true', | ||
122 | // this routine will restore the removed constraints. | ||
123 | // Called at taint-time!! | ||
124 | public override void RestoreBodyDependencies(BSPrim child) | ||
125 | { | ||
126 | // The Refresh operation queued by RemoveBodyDependencies() will build any missing constraints. | ||
127 | } | ||
128 | |||
129 | // ================================================================ | ||
130 | |||
131 | // Add a new child to the linkset. | ||
132 | // Called while LinkActivity is locked. | ||
133 | protected override void AddChildToLinkset(BSPhysObject child) | ||
134 | { | ||
135 | if (!HasChild(child)) | ||
136 | { | ||
137 | m_children.Add(child); | ||
138 | |||
139 | DetailLog("{0},BSLinksetConstraints.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID); | ||
140 | |||
141 | // Cause constraints and assorted properties to be recomputed before the next simulation step. | ||
142 | Refresh(LinksetRoot); | ||
143 | } | ||
144 | return; | ||
145 | } | ||
146 | |||
147 | // Remove the specified child from the linkset. | ||
148 | // Safe to call even if the child is not really in my linkset. | ||
149 | protected override void RemoveChildFromLinkset(BSPhysObject child) | ||
150 | { | ||
151 | if (m_children.Remove(child)) | ||
152 | { | ||
153 | BSPhysObject rootx = LinksetRoot; // capture the root and body as of now | ||
154 | BSPhysObject childx = child; | ||
155 | |||
156 | DetailLog("{0},BSLinksetConstraints.RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}", | ||
157 | childx.LocalID, | ||
158 | rootx.LocalID, rootx.PhysBody.ptr.ToString("X"), | ||
159 | childx.LocalID, childx.PhysBody.ptr.ToString("X")); | ||
160 | |||
161 | PhysicsScene.TaintedObject("BSLinksetConstraints.RemoveChildFromLinkset", delegate() | ||
162 | { | ||
163 | PhysicallyUnlinkAChildFromRoot(rootx, childx); | ||
164 | }); | ||
165 | // See that the linkset parameters are recomputed at the end of the taint time. | ||
166 | Refresh(LinksetRoot); | ||
167 | } | ||
168 | else | ||
169 | { | ||
170 | // Non-fatal occurance. | ||
171 | // PhysicsScene.Logger.ErrorFormat("{0}: Asked to remove child from linkset that was not in linkset", LogHeader); | ||
172 | } | ||
173 | return; | ||
174 | } | ||
175 | |||
176 | // Create a constraint between me (root of linkset) and the passed prim (the child). | ||
177 | // Called at taint time! | ||
178 | private void PhysicallyLinkAChildToRoot(BSPhysObject rootPrim, BSPhysObject childPrim) | ||
179 | { | ||
180 | // Don't build the constraint when asked. Put it off until just before the simulation step. | ||
181 | Refresh(rootPrim); | ||
182 | } | ||
183 | |||
184 | private BSConstraint BuildConstraint(BSPhysObject rootPrim, BSPhysObject childPrim) | ||
185 | { | ||
186 | // Zero motion for children so they don't interpolate | ||
187 | childPrim.ZeroMotion(true); | ||
188 | |||
189 | // Relative position normalized to the root prim | ||
190 | // Essentually a vector pointing from center of rootPrim to center of childPrim | ||
191 | OMV.Vector3 childRelativePosition = childPrim.Position - rootPrim.Position; | ||
192 | |||
193 | // real world coordinate of midpoint between the two objects | ||
194 | OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2); | ||
195 | |||
196 | DetailLog("{0},BSLinksetConstraint.BuildConstraint,taint,root={1},rBody={2},child={3},cBody={4},rLoc={5},cLoc={6},midLoc={7}", | ||
197 | rootPrim.LocalID, | ||
198 | rootPrim.LocalID, rootPrim.PhysBody.ptr.ToString("X"), | ||
199 | childPrim.LocalID, childPrim.PhysBody.ptr.ToString("X"), | ||
200 | rootPrim.Position, childPrim.Position, midPoint); | ||
201 | |||
202 | // create a constraint that allows no freedom of movement between the two objects | ||
203 | // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818 | ||
204 | |||
205 | BSConstraint6Dof constrain = new BSConstraint6Dof( | ||
206 | PhysicsScene.World, rootPrim.PhysBody, childPrim.PhysBody, midPoint, true, true ); | ||
207 | // PhysicsScene.World, childPrim.BSBody, rootPrim.BSBody, midPoint, true, true ); | ||
208 | |||
209 | /* NOTE: below is an attempt to build constraint with full frame computation, etc. | ||
210 | * Using the midpoint is easier since it lets the Bullet code manipulate the transforms | ||
211 | * of the objects. | ||
212 | * Code left for future programmers. | ||
213 | // ================================================================================== | ||
214 | // relative position normalized to the root prim | ||
215 | OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation); | ||
216 | OMV.Vector3 childRelativePosition = (childPrim.Position - rootPrim.Position) * invThisOrientation; | ||
217 | |||
218 | // relative rotation of the child to the parent | ||
219 | OMV.Quaternion childRelativeRotation = invThisOrientation * childPrim.Orientation; | ||
220 | OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation); | ||
221 | |||
222 | DetailLog("{0},BSLinksetConstraint.PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID); | ||
223 | BS6DofConstraint constrain = new BS6DofConstraint( | ||
224 | PhysicsScene.World, rootPrim.Body, childPrim.Body, | ||
225 | OMV.Vector3.Zero, | ||
226 | OMV.Quaternion.Inverse(rootPrim.Orientation), | ||
227 | OMV.Vector3.Zero, | ||
228 | OMV.Quaternion.Inverse(childPrim.Orientation), | ||
229 | true, | ||
230 | true | ||
231 | ); | ||
232 | // ================================================================================== | ||
233 | */ | ||
234 | |||
235 | PhysicsScene.Constraints.AddConstraint(constrain); | ||
236 | |||
237 | // zero linear and angular limits makes the objects unable to move in relation to each other | ||
238 | constrain.SetLinearLimits(OMV.Vector3.Zero, OMV.Vector3.Zero); | ||
239 | constrain.SetAngularLimits(OMV.Vector3.Zero, OMV.Vector3.Zero); | ||
240 | |||
241 | // tweek the constraint to increase stability | ||
242 | constrain.UseFrameOffset(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintUseFrameOffset)); | ||
243 | constrain.TranslationalLimitMotor(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintEnableTransMotor), | ||
244 | PhysicsScene.Params.linkConstraintTransMotorMaxVel, | ||
245 | PhysicsScene.Params.linkConstraintTransMotorMaxForce); | ||
246 | constrain.SetCFMAndERP(PhysicsScene.Params.linkConstraintCFM, PhysicsScene.Params.linkConstraintERP); | ||
247 | if (PhysicsScene.Params.linkConstraintSolverIterations != 0f) | ||
248 | { | ||
249 | constrain.SetSolverIterations(PhysicsScene.Params.linkConstraintSolverIterations); | ||
250 | } | ||
251 | return constrain; | ||
252 | } | ||
253 | |||
254 | // Remove linkage between the linkset root and a particular child | ||
255 | // The root and child bodies are passed in because we need to remove the constraint between | ||
256 | // the bodies that were present at unlink time. | ||
257 | // Called at taint time! | ||
258 | private bool PhysicallyUnlinkAChildFromRoot(BSPhysObject rootPrim, BSPhysObject childPrim) | ||
259 | { | ||
260 | bool ret = false; | ||
261 | DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAChildFromRoot,taint,root={1},rBody={2},child={3},cBody={4}", | ||
262 | rootPrim.LocalID, | ||
263 | rootPrim.LocalID, rootPrim.PhysBody.ptr.ToString("X"), | ||
264 | childPrim.LocalID, childPrim.PhysBody.ptr.ToString("X")); | ||
265 | |||
266 | // Find the constraint for this link and get rid of it from the overall collection and from my list | ||
267 | if (PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody, childPrim.PhysBody)) | ||
268 | { | ||
269 | // Make the child refresh its location | ||
270 | BulletSimAPI.PushUpdate2(childPrim.PhysBody.ptr); | ||
271 | ret = true; | ||
272 | } | ||
273 | |||
274 | return ret; | ||
275 | } | ||
276 | |||
277 | // Remove linkage between myself and any possible children I might have. | ||
278 | // Returns 'true' of any constraints were destroyed. | ||
279 | // Called at taint time! | ||
280 | private bool PhysicallyUnlinkAllChildrenFromRoot(BSPhysObject rootPrim) | ||
281 | { | ||
282 | DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID); | ||
283 | |||
284 | return PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody); | ||
285 | } | ||
286 | |||
287 | // Call each of the constraints that make up this linkset and recompute the | ||
288 | // various transforms and variables. Create constraints of not created yet. | ||
289 | // Called before the simulation step to make sure the constraint based linkset | ||
290 | // is all initialized. | ||
291 | // Called at taint time!! | ||
292 | private void RecomputeLinksetConstraints() | ||
293 | { | ||
294 | float linksetMass = LinksetMass; | ||
295 | LinksetRoot.UpdatePhysicalMassProperties(linksetMass); | ||
296 | |||
297 | // DEBUG: see of inter-linkset collisions are causing problems | ||
298 | // BulletSimAPI.SetCollisionFilterMask2(LinksetRoot.BSBody.ptr, | ||
299 | // (uint)CollisionFilterGroups.LinksetFilter, (uint)CollisionFilterGroups.LinksetMask); | ||
300 | DetailLog("{0},BSLinksetConstraint.RecomputeLinksetConstraints,set,rBody={1},linksetMass={2}", | ||
301 | LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"), linksetMass); | ||
302 | |||
303 | foreach (BSPhysObject child in m_children) | ||
304 | { | ||
305 | // A child in the linkset physically shows the mass of the whole linkset. | ||
306 | // This allows Bullet to apply enough force on the child to move the whole linkset. | ||
307 | // (Also do the mass stuff before recomputing the constraint so mass is not zero.) | ||
308 | child.UpdatePhysicalMassProperties(linksetMass); | ||
309 | |||
310 | BSConstraint constrain; | ||
311 | if (!PhysicsScene.Constraints.TryGetConstraint(LinksetRoot.PhysBody, child.PhysBody, out constrain)) | ||
312 | { | ||
313 | // If constraint doesn't exist yet, create it. | ||
314 | constrain = BuildConstraint(LinksetRoot, child); | ||
315 | } | ||
316 | constrain.RecomputeConstraintVariables(linksetMass); | ||
317 | |||
318 | // DEBUG: see of inter-linkset collisions are causing problems | ||
319 | // BulletSimAPI.SetCollisionFilterMask2(child.BSBody.ptr, | ||
320 | // (uint)CollisionFilterGroups.LinksetFilter, (uint)CollisionFilterGroups.LinksetMask); | ||
321 | |||
322 | // BulletSimAPI.DumpConstraint2(PhysicsScene.World.ptr, constrain.Constraint.ptr); // DEBUG DEBUG | ||
323 | } | ||
324 | |||
325 | } | ||
326 | } | ||
327 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs new file mode 100755 index 0000000..bc6e4c4 --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs | |||
@@ -0,0 +1,104 @@ | |||
1 | using System; | ||
2 | using System.Collections.Generic; | ||
3 | using System.Text; | ||
4 | using OpenMetaverse; | ||
5 | |||
6 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
7 | { | ||
8 | public abstract class BSMotor | ||
9 | { | ||
10 | public virtual void Reset() { } | ||
11 | public virtual void Zero() { } | ||
12 | } | ||
13 | // Can all the incremental stepping be replaced with motor classes? | ||
14 | public class BSVMotor : BSMotor | ||
15 | { | ||
16 | public Vector3 FrameOfReference { get; set; } | ||
17 | public Vector3 Offset { get; set; } | ||
18 | |||
19 | public float TimeScale { get; set; } | ||
20 | public float TargetValueDecayTimeScale { get; set; } | ||
21 | public Vector3 CurrentValueReductionTimescale { get; set; } | ||
22 | public float Efficiency { get; set; } | ||
23 | |||
24 | public Vector3 TargetValue { get; private set; } | ||
25 | public Vector3 CurrentValue { get; private set; } | ||
26 | |||
27 | |||
28 | |||
29 | BSVMotor(float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency) | ||
30 | { | ||
31 | TimeScale = timeScale; | ||
32 | TargetValueDecayTimeScale = decayTimeScale; | ||
33 | CurrentValueReductionTimescale = frictionTimeScale; | ||
34 | Efficiency = efficiency; | ||
35 | } | ||
36 | public void SetCurrent(Vector3 current) | ||
37 | { | ||
38 | CurrentValue = current; | ||
39 | } | ||
40 | public void SetTarget(Vector3 target) | ||
41 | { | ||
42 | TargetValue = target; | ||
43 | } | ||
44 | public Vector3 Step(float timeStep) | ||
45 | { | ||
46 | if (CurrentValue.LengthSquared() > 0.001f) | ||
47 | { | ||
48 | // Vector3 origDir = Target; // DEBUG | ||
49 | // Vector3 origVel = CurrentValue; // DEBUG | ||
50 | |||
51 | // Add (desiredVelocity - currentAppliedVelocity) / howLongItShouldTakeToComplete | ||
52 | Vector3 addAmount = (TargetValue - CurrentValue)/(TargetValue) * timeStep; | ||
53 | CurrentValue += addAmount; | ||
54 | |||
55 | float decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep; | ||
56 | TargetValue *= (1f - decayFactor); | ||
57 | |||
58 | Vector3 frictionFactor = (Vector3.One / CurrentValueReductionTimescale) * timeStep; | ||
59 | CurrentValue *= (Vector3.One - frictionFactor); | ||
60 | } | ||
61 | else | ||
62 | { | ||
63 | // if what remains of direction is very small, zero it. | ||
64 | TargetValue = Vector3.Zero; | ||
65 | CurrentValue = Vector3.Zero; | ||
66 | |||
67 | // VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID); | ||
68 | } | ||
69 | return CurrentValue; | ||
70 | } | ||
71 | } | ||
72 | |||
73 | public class BSFMotor : BSMotor | ||
74 | { | ||
75 | public float TimeScale { get; set; } | ||
76 | public float DecayTimeScale { get; set; } | ||
77 | public float Friction { get; set; } | ||
78 | public float Efficiency { get; set; } | ||
79 | |||
80 | public float Target { get; private set; } | ||
81 | public float CurrentValue { get; private set; } | ||
82 | |||
83 | BSFMotor(float timeScale, float decayTimescale, float friction, float efficiency) | ||
84 | { | ||
85 | } | ||
86 | public void SetCurrent(float target) | ||
87 | { | ||
88 | } | ||
89 | public void SetTarget(float target) | ||
90 | { | ||
91 | } | ||
92 | public float Step(float timeStep) | ||
93 | { | ||
94 | return 0f; | ||
95 | } | ||
96 | } | ||
97 | public class BSPIDMotor : BSMotor | ||
98 | { | ||
99 | // TODO: write and use this one | ||
100 | BSPIDMotor() | ||
101 | { | ||
102 | } | ||
103 | } | ||
104 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs new file mode 100755 index 0000000..991e5b1 --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs | |||
@@ -0,0 +1,263 @@ | |||
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 | /* | ||
38 | * Class to wrap all objects. | ||
39 | * The rest of BulletSim doesn't need to keep checking for avatars or prims | ||
40 | * unless the difference is significant. | ||
41 | * | ||
42 | * Variables in the physicsl objects are in three forms: | ||
43 | * VariableName: used by the simulator and performs taint operations, etc | ||
44 | * RawVariableName: direct reference to the BulletSim storage for the variable value | ||
45 | * ForceVariableName: direct reference (store and fetch) to the value in the physics engine. | ||
46 | * The last two (and certainly the last one) should be referenced only in taint-time. | ||
47 | */ | ||
48 | public abstract class BSPhysObject : PhysicsActor | ||
49 | { | ||
50 | protected BSPhysObject() | ||
51 | { | ||
52 | } | ||
53 | protected BSPhysObject(BSScene parentScene, uint localID, string name, string typeName) | ||
54 | { | ||
55 | PhysicsScene = parentScene; | ||
56 | LocalID = localID; | ||
57 | PhysObjectName = name; | ||
58 | TypeName = typeName; | ||
59 | |||
60 | Linkset = BSLinkset.Factory(PhysicsScene, this); | ||
61 | LastAssetBuildFailed = false; | ||
62 | |||
63 | CollisionCollection = new CollisionEventUpdate(); | ||
64 | SubscribedEventsMs = 0; | ||
65 | CollidingStep = 0; | ||
66 | CollidingGroundStep = 0; | ||
67 | } | ||
68 | |||
69 | public BSScene PhysicsScene { get; protected set; } | ||
70 | // public override uint LocalID { get; set; } // Use the LocalID definition in PhysicsActor | ||
71 | public string PhysObjectName { get; protected set; } | ||
72 | public string TypeName { get; protected set; } | ||
73 | |||
74 | public BSLinkset Linkset { get; set; } | ||
75 | |||
76 | // Return the object mass without calculating it or having side effects | ||
77 | public abstract float RawMass { get; } | ||
78 | // Set the raw mass but also update physical mass properties (inertia, ...) | ||
79 | public abstract void UpdatePhysicalMassProperties(float mass); | ||
80 | |||
81 | // The last value calculated for the prim's inertia | ||
82 | public OMV.Vector3 Inertia { get; set; } | ||
83 | |||
84 | // Reference to the physical body (btCollisionObject) of this object | ||
85 | public BulletBody PhysBody; | ||
86 | // Reference to the physical shape (btCollisionShape) of this object | ||
87 | public BulletShape PhysShape; | ||
88 | |||
89 | // 'true' if the mesh's underlying asset failed to build. | ||
90 | // This will keep us from looping after the first time the build failed. | ||
91 | public bool LastAssetBuildFailed { get; set; } | ||
92 | |||
93 | // The objects base shape information. Null if not a prim type shape. | ||
94 | public PrimitiveBaseShape BaseShape { get; protected set; } | ||
95 | // Some types of objects have preferred physical representations. | ||
96 | // Returns SHAPE_UNKNOWN if there is no preference. | ||
97 | public virtual ShapeData.PhysicsShapeType PreferredPhysicalShape | ||
98 | { | ||
99 | get { return ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; } | ||
100 | } | ||
101 | |||
102 | // When the physical properties are updated, an EntityProperty holds the update values. | ||
103 | // Keep the current and last EntityProperties to enable computation of differences | ||
104 | // between the current update and the previous values. | ||
105 | public EntityProperties CurrentEntityProperties { get; set; } | ||
106 | public EntityProperties LastEntityProperties { get; set; } | ||
107 | |||
108 | public abstract OMV.Vector3 Scale { get; set; } | ||
109 | public abstract bool IsSolid { get; } | ||
110 | public abstract bool IsStatic { get; } | ||
111 | |||
112 | // Stop all physical motion. | ||
113 | public abstract void ZeroMotion(bool inTaintTime); | ||
114 | public abstract void ZeroAngularMotion(bool inTaintTime); | ||
115 | |||
116 | // Step the vehicle simulation for this object. A NOOP if the vehicle was not configured. | ||
117 | public virtual void StepVehicle(float timeStep) { } | ||
118 | |||
119 | // Update the physical location and motion of the object. Called with data from Bullet. | ||
120 | public abstract void UpdateProperties(EntityProperties entprop); | ||
121 | |||
122 | // Tell the object to clean up. | ||
123 | public abstract void Destroy(); | ||
124 | |||
125 | public abstract OMV.Vector3 RawPosition { get; set; } | ||
126 | public abstract OMV.Vector3 ForcePosition { get; set; } | ||
127 | |||
128 | public abstract OMV.Quaternion RawOrientation { get; set; } | ||
129 | public abstract OMV.Quaternion ForceOrientation { get; set; } | ||
130 | |||
131 | public abstract OMV.Vector3 ForceVelocity { get; set; } | ||
132 | |||
133 | public abstract OMV.Vector3 ForceRotationalVelocity { get; set; } | ||
134 | |||
135 | public abstract float ForceBuoyancy { get; set; } | ||
136 | |||
137 | public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; } | ||
138 | |||
139 | #region Collisions | ||
140 | |||
141 | // Requested number of milliseconds between collision events. Zero means disabled. | ||
142 | protected int SubscribedEventsMs { get; set; } | ||
143 | // Given subscription, the time that a collision may be passed up | ||
144 | protected int NextCollisionOkTime { get; set; } | ||
145 | // The simulation step that last had a collision | ||
146 | protected long CollidingStep { get; set; } | ||
147 | // The simulation step that last had a collision with the ground | ||
148 | protected long CollidingGroundStep { get; set; } | ||
149 | // The collision flags we think are set in Bullet | ||
150 | protected CollisionFlags CurrentCollisionFlags { get; set; } | ||
151 | |||
152 | // The collisions that have been collected this tick | ||
153 | protected CollisionEventUpdate CollisionCollection; | ||
154 | |||
155 | // The simulation step is telling this object about a collision. | ||
156 | // Return 'true' if a collision was processed and should be sent up. | ||
157 | // Called at taint time from within the Step() function | ||
158 | public virtual bool Collide(uint collidingWith, BSPhysObject collidee, | ||
159 | OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth) | ||
160 | { | ||
161 | bool ret = false; | ||
162 | |||
163 | // The following lines make IsColliding() and IsCollidingGround() work | ||
164 | CollidingStep = PhysicsScene.SimulationStep; | ||
165 | if (collidingWith <= PhysicsScene.TerrainManager.HighestTerrainID) | ||
166 | { | ||
167 | CollidingGroundStep = PhysicsScene.SimulationStep; | ||
168 | } | ||
169 | |||
170 | // prims in the same linkset cannot collide with each other | ||
171 | if (collidee != null && (this.Linkset.LinksetID == collidee.Linkset.LinksetID)) | ||
172 | { | ||
173 | return ret; | ||
174 | } | ||
175 | |||
176 | // if someone has subscribed for collision events.... | ||
177 | if (SubscribedEvents()) { | ||
178 | CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth)); | ||
179 | DetailLog("{0},{1}.Collison.AddCollider,call,with={2},point={3},normal={4},depth={5}", | ||
180 | LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth); | ||
181 | |||
182 | ret = true; | ||
183 | } | ||
184 | return ret; | ||
185 | } | ||
186 | |||
187 | // Send the collected collisions into the simulator. | ||
188 | // Called at taint time from within the Step() function thus no locking problems | ||
189 | // with CollisionCollection and ObjectsWithNoMoreCollisions. | ||
190 | // Return 'true' if there were some actual collisions passed up | ||
191 | public virtual bool SendCollisions() | ||
192 | { | ||
193 | bool ret = true; | ||
194 | // If the 'no collision' call, force it to happen right now so quick collision_end | ||
195 | bool force = CollisionCollection.Count == 0; | ||
196 | |||
197 | // throttle the collisions to the number of milliseconds specified in the subscription | ||
198 | if (force || (PhysicsScene.SimulationNowTime >= NextCollisionOkTime)) | ||
199 | { | ||
200 | NextCollisionOkTime = PhysicsScene.SimulationNowTime + SubscribedEventsMs; | ||
201 | |||
202 | // We are called if we previously had collisions. If there are no collisions | ||
203 | // this time, send up one last empty event so OpenSim can sense collision end. | ||
204 | if (CollisionCollection.Count == 0) | ||
205 | { | ||
206 | // If I have no collisions this time, remove me from the list of objects with collisions. | ||
207 | ret = false; | ||
208 | } | ||
209 | |||
210 | // DetailLog("{0},{1}.SendCollisionUpdate,call,numCollisions={2}", LocalID, TypeName, CollisionCollection.Count); | ||
211 | base.SendCollisionUpdate(CollisionCollection); | ||
212 | |||
213 | // The collisionCollection structure is passed around in the simulator. | ||
214 | // Make sure we don't have a handle to that one and that a new one is used for next time. | ||
215 | CollisionCollection = new CollisionEventUpdate(); | ||
216 | } | ||
217 | return ret; | ||
218 | } | ||
219 | |||
220 | // Subscribe for collision events. | ||
221 | // Parameter is the millisecond rate the caller wishes collision events to occur. | ||
222 | public override void SubscribeEvents(int ms) { | ||
223 | // DetailLog("{0},{1}.SubscribeEvents,subscribing,ms={2}", LocalID, TypeName, ms); | ||
224 | SubscribedEventsMs = ms; | ||
225 | if (ms > 0) | ||
226 | { | ||
227 | // make sure first collision happens | ||
228 | NextCollisionOkTime = Util.EnvironmentTickCountSubtract(SubscribedEventsMs); | ||
229 | |||
230 | PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate() | ||
231 | { | ||
232 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
233 | }); | ||
234 | } | ||
235 | else | ||
236 | { | ||
237 | // Subscribing for zero or less is the same as unsubscribing | ||
238 | UnSubscribeEvents(); | ||
239 | } | ||
240 | } | ||
241 | public override void UnSubscribeEvents() { | ||
242 | // DetailLog("{0},{1}.UnSubscribeEvents,unsubscribing", LocalID, TypeName); | ||
243 | SubscribedEventsMs = 0; | ||
244 | PhysicsScene.TaintedObject(TypeName+".UnSubscribeEvents", delegate() | ||
245 | { | ||
246 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
247 | }); | ||
248 | } | ||
249 | // Return 'true' if the simulator wants collision events | ||
250 | public override bool SubscribedEvents() { | ||
251 | return (SubscribedEventsMs > 0); | ||
252 | } | ||
253 | |||
254 | #endregion // Collisions | ||
255 | |||
256 | // High performance detailed logging routine used by the physical objects. | ||
257 | protected void DetailLog(string msg, params Object[] args) | ||
258 | { | ||
259 | if (PhysicsScene.PhysicsLogging.Enabled) | ||
260 | PhysicsScene.DetailLog(msg, args); | ||
261 | } | ||
262 | } | ||
263 | } | ||
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..500c84a 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs | |||
@@ -24,6 +24,7 @@ | |||
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 | |||
27 | using System; | 28 | using System; |
28 | using System.Reflection; | 29 | using System.Reflection; |
29 | using System.Collections.Generic; | 30 | using System.Collections.Generic; |
@@ -36,32 +37,18 @@ using OpenSim.Region.Physics.ConvexDecompositionDotNet; | |||
36 | 37 | ||
37 | namespace OpenSim.Region.Physics.BulletSPlugin | 38 | namespace OpenSim.Region.Physics.BulletSPlugin |
38 | { | 39 | { |
40 | |||
39 | [Serializable] | 41 | [Serializable] |
40 | public sealed class BSPrim : PhysicsActor | 42 | public sealed class BSPrim : BSPhysObject |
41 | { | 43 | { |
42 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 44 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); |
43 | private static readonly string LogHeader = "[BULLETS PRIM]"; | 45 | private static readonly string LogHeader = "[BULLETS PRIM]"; |
44 | 46 | ||
45 | private void DebugLog(string mm, params Object[] xx) { if (_scene.ShouldDebugLog) m_log.DebugFormat(mm, xx); } | 47 | // _size is what the user passed. Scale is what we pass to the physics engine with the mesh. |
46 | 48 | // Often Scale is unity because the meshmerizer will apply _size when creating the mesh. | |
47 | private IMesh _mesh; | ||
48 | 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 | |||
59 | // _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. | ||
61 | private OMV.Vector3 _size; // the multiplier for each mesh dimension as passed by the user | 49 | 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 | 50 | // private OMV.Vector3 _scale; // the multiplier for each mesh dimension for the mesh as created by the meshmerizer |
63 | 51 | ||
64 | private bool _stopped; | ||
65 | private bool _grabbed; | 52 | private bool _grabbed; |
66 | private bool _isSelected; | 53 | private bool _isSelected; |
67 | private bool _isVolumeDetect; | 54 | private bool _isVolumeDetect; |
@@ -89,25 +76,6 @@ public sealed class BSPrim : PhysicsActor | |||
89 | private bool _kinematic; | 76 | private bool _kinematic; |
90 | private float _buoyancy; | 77 | private float _buoyancy; |
91 | 78 | ||
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; | 79 | private BSDynamics _vehicle; |
112 | 80 | ||
113 | private OMV.Vector3 _PIDTarget; | 81 | private OMV.Vector3 _PIDTarget; |
@@ -120,110 +88,114 @@ public sealed class BSPrim : PhysicsActor | |||
120 | 88 | ||
121 | public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, | 89 | public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, |
122 | OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical) | 90 | OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical) |
91 | : base(parent_scene, localID, primName, "BSPrim") | ||
123 | { | 92 | { |
124 | // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID); | 93 | // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID); |
125 | _localID = localID; | 94 | _physicsActorType = (int)ActorTypes.Prim; |
126 | _avName = primName; | ||
127 | _scene = parent_scene; | ||
128 | _position = pos; | 95 | _position = pos; |
129 | _size = size; | 96 | _size = size; |
130 | _scale = new OMV.Vector3(1f, 1f, 1f); // the scale will be set by CreateGeom depending on object type | 97 | Scale = new OMV.Vector3(1f, 1f, 1f); // the scale will be set by CreateGeom depending on object type |
131 | _orientation = rotation; | 98 | _orientation = rotation; |
132 | _buoyancy = 1f; | 99 | _buoyancy = 1f; |
133 | _velocity = OMV.Vector3.Zero; | 100 | _velocity = OMV.Vector3.Zero; |
134 | _rotationalVelocity = OMV.Vector3.Zero; | 101 | _rotationalVelocity = OMV.Vector3.Zero; |
135 | _hullKey = 0; | 102 | BaseShape = pbs; |
136 | _meshKey = 0; | ||
137 | _pbs = pbs; | ||
138 | _isPhysical = pisPhysical; | 103 | _isPhysical = pisPhysical; |
139 | _isVolumeDetect = false; | 104 | _isVolumeDetect = false; |
140 | _subscribedEventsMs = 0; | 105 | _friction = PhysicsScene.Params.defaultFriction; // TODO: compute based on object material |
141 | _friction = _scene.Params.defaultFriction; // TODO: compute based on object material | 106 | _density = PhysicsScene.Params.defaultDensity; // TODO: compute based on object material |
142 | _density = _scene.Params.defaultDensity; // TODO: compute based on object material | 107 | _restitution = PhysicsScene.Params.defaultRestitution; |
143 | _restitution = _scene.Params.defaultRestitution; | 108 | _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(); | 109 | _mass = CalculateMass(); |
147 | // do the actual object creation at taint time | 110 | |
111 | // No body or shape yet | ||
112 | PhysBody = new BulletBody(LocalID, IntPtr.Zero); | ||
113 | PhysShape = new BulletShape(IntPtr.Zero); | ||
114 | |||
148 | DetailLog("{0},BSPrim.constructor,call", LocalID); | 115 | DetailLog("{0},BSPrim.constructor,call", LocalID); |
149 | _scene.TaintedObject("BSPrim.create", delegate() | 116 | // do the actual object creation at taint time |
117 | PhysicsScene.TaintedObject("BSPrim.create", delegate() | ||
150 | { | 118 | { |
151 | RecreateGeomAndObject(); | 119 | CreateGeomAndObject(true); |
152 | 120 | ||
153 | // Get the pointer to the physical body for this object. | 121 | CurrentCollisionFlags = BulletSimAPI.GetCollisionFlags2(PhysBody.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 | }); | 122 | }); |
158 | } | 123 | } |
159 | 124 | ||
160 | // called when this prim is being destroyed and we should free all the resources | 125 | // called when this prim is being destroyed and we should free all the resources |
161 | public void Destroy() | 126 | public override void Destroy() |
162 | { | 127 | { |
163 | // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID); | 128 | // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID); |
164 | 129 | ||
165 | // Undo any links between me and any other object | 130 | // Undo any links between me and any other object |
166 | BSPrim parentBefore = _linkset.LinksetRoot; | 131 | BSPhysObject parentBefore = Linkset.LinksetRoot; |
167 | int childrenBefore = _linkset.NumberOfChildren; | 132 | int childrenBefore = Linkset.NumberOfChildren; |
168 | 133 | ||
169 | _linkset = _linkset.RemoveMeFromLinkset(this); | 134 | Linkset = Linkset.RemoveMeFromLinkset(this); |
170 | 135 | ||
171 | DetailLog("{0},BSPrim.Destroy,call,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}", | 136 | DetailLog("{0},BSPrim.Destroy,call,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}", |
172 | LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren); | 137 | LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren); |
173 | 138 | ||
174 | // Undo any vehicle properties | 139 | // Undo any vehicle properties |
175 | this.VehicleType = (int)Vehicle.TYPE_NONE; | 140 | this.VehicleType = (int)Vehicle.TYPE_NONE; |
176 | 141 | ||
177 | _scene.TaintedObject("BSPrim.destroy", delegate() | 142 | PhysicsScene.TaintedObject("BSPrim.destroy", delegate() |
178 | { | 143 | { |
179 | DetailLog("{0},BSPrim.Destroy,taint,", LocalID); | 144 | DetailLog("{0},BSPrim.Destroy,taint,", LocalID); |
180 | // everything in the C# world will get garbage collected. Tell the C++ world to free stuff. | 145 | // If there are physical body and shape, release my use of same. |
181 | BulletSimAPI.DestroyObject(_scene.WorldID, LocalID); | 146 | PhysicsScene.Shapes.DereferenceBody(PhysBody, true, null); |
147 | PhysicsScene.Shapes.DereferenceShape(PhysShape, true, null); | ||
182 | }); | 148 | }); |
183 | } | 149 | } |
184 | 150 | ||
185 | public override bool Stopped { | 151 | // No one uses this property. |
186 | get { return _stopped; } | 152 | public override bool Stopped { |
153 | get { return false; } | ||
187 | } | 154 | } |
188 | public override OMV.Vector3 Size { | 155 | public override OMV.Vector3 Size { |
189 | get { return _size; } | 156 | get { return _size; } |
190 | set { | 157 | set { |
191 | _size = value; | 158 | _size = value; |
192 | _scene.TaintedObject("BSPrim.setSize", delegate() | 159 | ForceBodyShapeRebuild(false); |
193 | { | 160 | } |
194 | _mass = CalculateMass(); // changing size changes the mass | ||
195 | BulletSimAPI.SetObjectScaleMass(_scene.WorldID, _localID, _scale, (IsPhysical ? _mass : 0f), IsPhysical); | ||
196 | // DetailLog("{0}: BSPrim.setSize: size={1}, mass={2}, physical={3}", LocalID, _size, _mass, IsPhysical); | ||
197 | RecreateGeomAndObject(); | ||
198 | }); | ||
199 | } | ||
200 | } | 161 | } |
201 | public override PrimitiveBaseShape Shape { | 162 | // Scale is what we set in the physics engine. It is different than 'size' in that |
163 | // 'size' can be encorporated into the mesh. In that case, the scale is <1,1,1>. | ||
164 | public override OMV.Vector3 Scale { get; set; } | ||
165 | |||
166 | public override PrimitiveBaseShape Shape { | ||
202 | set { | 167 | set { |
203 | _pbs = value; | 168 | BaseShape = value; |
204 | _scene.TaintedObject("BSPrim.setShape", delegate() | 169 | ForceBodyShapeRebuild(false); |
205 | { | 170 | } |
206 | _mass = CalculateMass(); // changing the shape changes the mass | ||
207 | RecreateGeomAndObject(); | ||
208 | }); | ||
209 | } | ||
210 | } | 171 | } |
211 | public override uint LocalID { | 172 | // Whatever the linkset wants is what I want. |
212 | set { _localID = value; } | 173 | public override ShapeData.PhysicsShapeType PreferredPhysicalShape |
213 | get { return _localID; } | 174 | { get { return Linkset.PreferredPhysicalShape(this); } } |
175 | |||
176 | public override bool ForceBodyShapeRebuild(bool inTaintTime) | ||
177 | { | ||
178 | LastAssetBuildFailed = false; | ||
179 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ForceBodyShapeRebuild", delegate() | ||
180 | { | ||
181 | _mass = CalculateMass(); // changing the shape changes the mass | ||
182 | CreateGeomAndObject(true); | ||
183 | }); | ||
184 | return true; | ||
214 | } | 185 | } |
215 | public override bool Grabbed { | 186 | public override bool Grabbed { |
216 | set { _grabbed = value; | 187 | set { _grabbed = value; |
217 | } | 188 | } |
218 | } | 189 | } |
219 | public override bool Selected { | 190 | public override bool Selected { |
220 | set { | 191 | set { |
221 | _isSelected = value; | 192 | _isSelected = value; |
222 | _scene.TaintedObject("BSPrim.setSelected", delegate() | 193 | PhysicsScene.TaintedObject("BSPrim.setSelected", delegate() |
223 | { | 194 | { |
224 | SetObjectDynamic(); | 195 | DetailLog("{0},BSPrim.selected,taint,selected={1}", LocalID, _isSelected); |
196 | SetObjectDynamic(false); | ||
225 | }); | 197 | }); |
226 | } | 198 | } |
227 | } | 199 | } |
228 | public override void CrossingFailure() { return; } | 200 | public override void CrossingFailure() { return; } |
229 | 201 | ||
@@ -232,158 +204,269 @@ public sealed class BSPrim : PhysicsActor | |||
232 | BSPrim parent = obj as BSPrim; | 204 | BSPrim parent = obj as BSPrim; |
233 | if (parent != null) | 205 | if (parent != null) |
234 | { | 206 | { |
235 | DebugLog("{0}: link {1}/{2} to {3}", LogHeader, _avName, _localID, parent.LocalID); | 207 | BSPhysObject parentBefore = Linkset.LinksetRoot; |
236 | BSPrim parentBefore = _linkset.LinksetRoot; | 208 | int childrenBefore = Linkset.NumberOfChildren; |
237 | int childrenBefore = _linkset.NumberOfChildren; | ||
238 | 209 | ||
239 | _linkset = parent.Linkset.AddMeToLinkset(this); | 210 | Linkset = parent.Linkset.AddMeToLinkset(this); |
240 | 211 | ||
241 | DetailLog("{0},BSPrim.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}", | 212 | DetailLog("{0},BSPrim.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}", |
242 | LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren); | 213 | LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren); |
243 | } | 214 | } |
244 | return; | 215 | return; |
245 | } | 216 | } |
246 | 217 | ||
247 | // delink me from my linkset | 218 | // delink me from my linkset |
248 | public override void delink() { | 219 | public override void delink() { |
249 | // TODO: decide if this parent checking needs to happen at taint time | 220 | // 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 | 221 | // 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 | 222 | ||
254 | BSPrim parentBefore = _linkset.LinksetRoot; | 223 | BSPhysObject parentBefore = Linkset.LinksetRoot; |
255 | int childrenBefore = _linkset.NumberOfChildren; | 224 | int childrenBefore = Linkset.NumberOfChildren; |
256 | 225 | ||
257 | _linkset = _linkset.RemoveMeFromLinkset(this); | 226 | Linkset = Linkset.RemoveMeFromLinkset(this); |
258 | 227 | ||
259 | DetailLog("{0},BSPrim.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ", | 228 | DetailLog("{0},BSPrim.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ", |
260 | LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren); | 229 | LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren); |
261 | return; | 230 | return; |
262 | } | 231 | } |
263 | 232 | ||
264 | // Set motion values to zero. | 233 | // Set motion values to zero. |
265 | // Do it to the properties so the values get set in the physics engine. | 234 | // Do it to the properties so the values get set in the physics engine. |
266 | // Push the setting of the values to the viewer. | 235 | // Push the setting of the values to the viewer. |
267 | // Called at taint time! | 236 | // Called at taint time! |
268 | public void ZeroMotion() | 237 | public override void ZeroMotion(bool inTaintTime) |
269 | { | 238 | { |
270 | _velocity = OMV.Vector3.Zero; | 239 | _velocity = OMV.Vector3.Zero; |
271 | _acceleration = OMV.Vector3.Zero; | 240 | _acceleration = OMV.Vector3.Zero; |
272 | _rotationalVelocity = OMV.Vector3.Zero; | 241 | _rotationalVelocity = OMV.Vector3.Zero; |
273 | 242 | ||
274 | // Zero some other properties directly into the physics engine | 243 | // Zero some other properties in the physics engine |
275 | BulletSimAPI.SetVelocity2(Body.Ptr, OMV.Vector3.Zero); | 244 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ZeroMotion", delegate() |
276 | BulletSimAPI.SetAngularVelocity2(Body.Ptr, OMV.Vector3.Zero); | 245 | { |
277 | BulletSimAPI.SetInterpolation2(Body.Ptr, OMV.Vector3.Zero, OMV.Vector3.Zero); | 246 | BulletSimAPI.ClearAllForces2(PhysBody.ptr); |
278 | BulletSimAPI.ClearForces2(Body.Ptr); | 247 | }); |
248 | } | ||
249 | public override void ZeroAngularMotion(bool inTaintTime) | ||
250 | { | ||
251 | _rotationalVelocity = OMV.Vector3.Zero; | ||
252 | // Zero some other properties in the physics engine | ||
253 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ZeroMotion", delegate() | ||
254 | { | ||
255 | BulletSimAPI.SetInterpolationAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero); | ||
256 | BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero); | ||
257 | }); | ||
279 | } | 258 | } |
280 | 259 | ||
281 | public override void LockAngularMotion(OMV.Vector3 axis) | 260 | public override void LockAngularMotion(OMV.Vector3 axis) |
282 | { | 261 | { |
283 | // DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis); | 262 | DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis); |
284 | return; | 263 | return; |
285 | } | 264 | } |
286 | 265 | ||
287 | public override OMV.Vector3 Position { | 266 | public override OMV.Vector3 RawPosition |
288 | get { | 267 | { |
289 | if (!_linkset.IsRoot(this)) | 268 | get { return _position; } |
290 | // child prims move around based on their parent. Need to get the latest location | 269 | set { _position = value; } |
291 | _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 270 | } |
271 | public override OMV.Vector3 Position { | ||
272 | get { | ||
273 | // child prims move around based on their parent. Need to get the latest location | ||
274 | if (!Linkset.IsRoot(this)) | ||
275 | _position = Linkset.Position(this); | ||
292 | 276 | ||
293 | // don't do the GetObjectPosition for root elements because this function is called a zillion times | 277 | // don't do the GetObjectPosition for root elements because this function is called a zillion times |
294 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 278 | // _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr); |
295 | return _position; | 279 | return _position; |
296 | } | 280 | } |
297 | set { | 281 | set { |
282 | // If you must push the position into the physics engine, use ForcePosition. | ||
283 | if (_position == value) | ||
284 | { | ||
285 | return; | ||
286 | } | ||
298 | _position = value; | 287 | _position = value; |
299 | // TODO: what does it mean to set the position of a child prim?? Rebuild the constraint? | 288 | // TODO: what does it mean to set the position of a child prim?? Rebuild the constraint? |
300 | _scene.TaintedObject("BSPrim.setPosition", delegate() | 289 | PositionSanityCheck(); |
290 | PhysicsScene.TaintedObject("BSPrim.setPosition", delegate() | ||
301 | { | 291 | { |
302 | // DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); | 292 | // DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation); |
303 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 293 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); |
294 | ActivateIfPhysical(false); | ||
304 | }); | 295 | }); |
305 | } | 296 | } |
297 | } | ||
298 | public override OMV.Vector3 ForcePosition { | ||
299 | get { | ||
300 | _position = BulletSimAPI.GetPosition2(PhysBody.ptr); | ||
301 | return _position; | ||
302 | } | ||
303 | set { | ||
304 | _position = value; | ||
305 | PositionSanityCheck(); | ||
306 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); | ||
307 | ActivateIfPhysical(false); | ||
308 | } | ||
309 | } | ||
310 | |||
311 | // Check that the current position is sane and, if not, modify the position to make it so. | ||
312 | // Check for being below terrain and being out of bounds. | ||
313 | // Returns 'true' of the position was made sane by some action. | ||
314 | private bool PositionSanityCheck() | ||
315 | { | ||
316 | bool ret = false; | ||
317 | |||
318 | // If totally below the ground, move the prim up | ||
319 | // TODO: figure out the right solution for this... only for dynamic objects? | ||
320 | /* | ||
321 | float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(_position); | ||
322 | if (Position.Z < terrainHeight) | ||
323 | { | ||
324 | DetailLog("{0},BSPrim.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, _position, terrainHeight); | ||
325 | _position.Z = terrainHeight + 2.0f; | ||
326 | ret = true; | ||
327 | } | ||
328 | */ | ||
329 | if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0) | ||
330 | { | ||
331 | float waterHeight = PhysicsScene.GetWaterLevelAtXYZ(_position); | ||
332 | // TODO: a floating motor so object will bob in the water | ||
333 | if (Position.Z < waterHeight) | ||
334 | { | ||
335 | _position.Z = waterHeight; | ||
336 | ret = true; | ||
337 | } | ||
338 | } | ||
339 | |||
340 | // TODO: check for out of bounds | ||
341 | return ret; | ||
342 | } | ||
343 | |||
344 | // A version of the sanity check that also makes sure a new position value is | ||
345 | // pushed to the physics engine. This routine would be used by anyone | ||
346 | // who is not already pushing the value. | ||
347 | private bool PositionSanityCheck(bool inTaintTime) | ||
348 | { | ||
349 | bool ret = false; | ||
350 | if (PositionSanityCheck()) | ||
351 | { | ||
352 | // The new position value must be pushed into the physics engine but we can't | ||
353 | // just assign to "Position" because of potential call loops. | ||
354 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.PositionSanityCheck", delegate() | ||
355 | { | ||
356 | DetailLog("{0},BSPrim.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation); | ||
357 | ForcePosition = _position; | ||
358 | }); | ||
359 | ret = true; | ||
360 | } | ||
361 | return ret; | ||
306 | } | 362 | } |
307 | 363 | ||
308 | // Return the effective mass of the object. | 364 | // Return the effective mass of the object. |
309 | // If there are multiple items in the linkset, add them together for the root | 365 | // If there are multiple items in the linkset, add them together for the root |
310 | public override float Mass | 366 | public override float Mass |
311 | { | 367 | { |
312 | get | 368 | get |
313 | { | 369 | { |
314 | return _linkset.LinksetMass; | 370 | return Linkset.LinksetMass; |
371 | // return _mass; | ||
315 | } | 372 | } |
316 | } | 373 | } |
317 | 374 | ||
318 | // used when we only want this prim's mass and not the linkset thing | 375 | // used when we only want this prim's mass and not the linkset thing |
319 | public float MassRaw { get { return _mass; } } | 376 | public override float RawMass { |
377 | get { return _mass; } | ||
378 | } | ||
379 | // Set the physical mass to the passed mass. | ||
380 | // Note that this does not change _mass! | ||
381 | public override void UpdatePhysicalMassProperties(float physMass) | ||
382 | { | ||
383 | if (IsStatic) | ||
384 | { | ||
385 | Inertia = OMV.Vector3.Zero; | ||
386 | BulletSimAPI.SetMassProps2(PhysBody.ptr, 0f, Inertia); | ||
387 | BulletSimAPI.UpdateInertiaTensor2(PhysBody.ptr); | ||
388 | } | ||
389 | else | ||
390 | { | ||
391 | Inertia = BulletSimAPI.CalculateLocalInertia2(PhysShape.ptr, physMass); | ||
392 | BulletSimAPI.SetMassProps2(PhysBody.ptr, physMass, Inertia); | ||
393 | BulletSimAPI.UpdateInertiaTensor2(PhysBody.ptr); | ||
394 | // center of mass is at the zero of the object | ||
395 | // DEBUG DEBUG BulletSimAPI.SetCenterOfMassByPosRot2(PhysBody.ptr, ForcePosition, ForceOrientation); | ||
396 | DetailLog("{0},BSPrim.UpdateMassProperties,mass={1},localInertia={2}", LocalID, physMass, Inertia); | ||
397 | } | ||
398 | } | ||
320 | 399 | ||
321 | // Is this used? | 400 | // Is this used? |
322 | public override OMV.Vector3 CenterOfMass | 401 | public override OMV.Vector3 CenterOfMass |
323 | { | 402 | { |
324 | get { return _linkset.CenterOfMass; } | 403 | get { return Linkset.CenterOfMass; } |
325 | } | 404 | } |
326 | 405 | ||
327 | // Is this used? | 406 | // Is this used? |
328 | public override OMV.Vector3 GeometricCenter | 407 | public override OMV.Vector3 GeometricCenter |
329 | { | 408 | { |
330 | get { return _linkset.GeometricCenter; } | 409 | get { return Linkset.GeometricCenter; } |
331 | } | 410 | } |
332 | 411 | ||
333 | public override OMV.Vector3 Force { | 412 | public override OMV.Vector3 Force { |
334 | get { return _force; } | 413 | get { return _force; } |
335 | set { | 414 | set { |
336 | _force = value; | 415 | _force = value; |
337 | _scene.TaintedObject("BSPrim.setForce", delegate() | 416 | PhysicsScene.TaintedObject("BSPrim.setForce", delegate() |
338 | { | 417 | { |
339 | // DetailLog("{0},BSPrim.setForce,taint,force={1}", LocalID, _force); | 418 | // DetailLog("{0},BSPrim.setForce,taint,force={1}", LocalID, _force); |
340 | // BulletSimAPI.SetObjectForce(_scene.WorldID, _localID, _force); | 419 | BulletSimAPI.SetObjectForce2(PhysBody.ptr, _force); |
341 | BulletSimAPI.SetObjectForce2(Body.Ptr, _force); | ||
342 | }); | 420 | }); |
343 | } | 421 | } |
344 | } | 422 | } |
345 | 423 | ||
346 | public override int VehicleType { | 424 | public override int VehicleType { |
347 | get { | 425 | get { |
348 | return (int)_vehicle.Type; // if we are a vehicle, return that type | 426 | return (int)_vehicle.Type; // if we are a vehicle, return that type |
349 | } | 427 | } |
350 | set { | 428 | set { |
351 | Vehicle type = (Vehicle)value; | 429 | Vehicle type = (Vehicle)value; |
352 | BSPrim vehiclePrim = this; | 430 | |
353 | _scene.TaintedObject("setVehicleType", delegate() | 431 | // Tell the scene about the vehicle so it will get processing each frame. |
432 | PhysicsScene.VehicleInSceneTypeChanged(this, type); | ||
433 | |||
434 | PhysicsScene.TaintedObject("setVehicleType", delegate() | ||
354 | { | 435 | { |
355 | // Done at taint time so we're sure the physics engine is not using the variables | 436 | // 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. | 437 | // Vehicle code changes the parameters for this vehicle type. |
357 | _vehicle.ProcessTypeChange(type); | 438 | _vehicle.ProcessTypeChange(type); |
358 | // Tell the scene about the vehicle so it will get processing each frame. | 439 | ActivateIfPhysical(false); |
359 | _scene.VehicleInSceneTypeChanged(this, type); | ||
360 | }); | 440 | }); |
361 | } | 441 | } |
362 | } | 442 | } |
363 | public override void VehicleFloatParam(int param, float value) | 443 | public override void VehicleFloatParam(int param, float value) |
364 | { | 444 | { |
365 | _scene.TaintedObject("BSPrim.VehicleFloatParam", delegate() | 445 | PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate() |
366 | { | 446 | { |
367 | _vehicle.ProcessFloatVehicleParam((Vehicle)param, value, _scene.LastSimulatedTimestep); | 447 | _vehicle.ProcessFloatVehicleParam((Vehicle)param, value); |
448 | ActivateIfPhysical(false); | ||
368 | }); | 449 | }); |
369 | } | 450 | } |
370 | public override void VehicleVectorParam(int param, OMV.Vector3 value) | 451 | public override void VehicleVectorParam(int param, OMV.Vector3 value) |
371 | { | 452 | { |
372 | _scene.TaintedObject("BSPrim.VehicleVectorParam", delegate() | 453 | PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate() |
373 | { | 454 | { |
374 | _vehicle.ProcessVectorVehicleParam((Vehicle)param, value, _scene.LastSimulatedTimestep); | 455 | _vehicle.ProcessVectorVehicleParam((Vehicle)param, value); |
456 | ActivateIfPhysical(false); | ||
375 | }); | 457 | }); |
376 | } | 458 | } |
377 | public override void VehicleRotationParam(int param, OMV.Quaternion rotation) | 459 | public override void VehicleRotationParam(int param, OMV.Quaternion rotation) |
378 | { | 460 | { |
379 | _scene.TaintedObject("BSPrim.VehicleRotationParam", delegate() | 461 | PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate() |
380 | { | 462 | { |
381 | _vehicle.ProcessRotationVehicleParam((Vehicle)param, rotation); | 463 | _vehicle.ProcessRotationVehicleParam((Vehicle)param, rotation); |
464 | ActivateIfPhysical(false); | ||
382 | }); | 465 | }); |
383 | } | 466 | } |
384 | public override void VehicleFlags(int param, bool remove) | 467 | public override void VehicleFlags(int param, bool remove) |
385 | { | 468 | { |
386 | _scene.TaintedObject("BSPrim.VehicleFlags", delegate() | 469 | PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate() |
387 | { | 470 | { |
388 | _vehicle.ProcessVehicleFlags(param, remove); | 471 | _vehicle.ProcessVehicleFlags(param, remove); |
389 | }); | 472 | }); |
@@ -391,143 +474,356 @@ public sealed class BSPrim : PhysicsActor | |||
391 | 474 | ||
392 | // Called each simulation step to advance vehicle characteristics. | 475 | // Called each simulation step to advance vehicle characteristics. |
393 | // Called from Scene when doing simulation step so we're in taint processing time. | 476 | // Called from Scene when doing simulation step so we're in taint processing time. |
394 | public void StepVehicle(float timeStep) | 477 | public override void StepVehicle(float timeStep) |
395 | { | 478 | { |
396 | if (IsPhysical) | 479 | if (IsPhysical && _vehicle.IsActive) |
480 | { | ||
397 | _vehicle.Step(timeStep); | 481 | _vehicle.Step(timeStep); |
482 | /* // TEST TEST DEBUG DEBUG -- trying to reduce the extra action of Bullet simulation step | ||
483 | PhysicsScene.PostTaintObject("BSPrim.StepVehicles", LocalID, delegate() | ||
484 | { | ||
485 | // This resets the interpolation values and recomputes the tensor variables | ||
486 | BulletSimAPI.SetCenterOfMassByPosRot2(BSBody.ptr, ForcePosition, ForceOrientation); | ||
487 | }); | ||
488 | */ | ||
489 | } | ||
398 | } | 490 | } |
399 | 491 | ||
400 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more | 492 | // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more |
401 | public override void SetVolumeDetect(int param) { | 493 | public override void SetVolumeDetect(int param) { |
402 | bool newValue = (param != 0); | 494 | bool newValue = (param != 0); |
403 | _isVolumeDetect = newValue; | 495 | if (_isVolumeDetect != newValue) |
404 | _scene.TaintedObject("BSPrim.SetVolumeDetect", delegate() | ||
405 | { | 496 | { |
406 | SetObjectDynamic(); | 497 | _isVolumeDetect = newValue; |
407 | }); | 498 | PhysicsScene.TaintedObject("BSPrim.SetVolumeDetect", delegate() |
408 | return; | 499 | { |
500 | // DetailLog("{0},setVolumeDetect,taint,volDetect={1}", LocalID, _isVolumeDetect); | ||
501 | SetObjectDynamic(true); | ||
502 | }); | ||
503 | } | ||
504 | return; | ||
409 | } | 505 | } |
410 | 506 | public override OMV.Vector3 Velocity { | |
411 | public override OMV.Vector3 Velocity { | 507 | get { return _velocity; } |
412 | get { return _velocity; } | ||
413 | set { | 508 | set { |
414 | _velocity = value; | 509 | _velocity = value; |
415 | _scene.TaintedObject("BSPrim.setVelocity", delegate() | 510 | PhysicsScene.TaintedObject("BSPrim.setVelocity", delegate() |
416 | { | 511 | { |
417 | // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, _velocity); | 512 | // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, _velocity); |
418 | BulletSimAPI.SetObjectVelocity(_scene.WorldID, LocalID, _velocity); | 513 | BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity); |
419 | }); | 514 | }); |
420 | } | 515 | } |
516 | } | ||
517 | public override OMV.Vector3 ForceVelocity { | ||
518 | get { return _velocity; } | ||
519 | set { | ||
520 | _velocity = value; | ||
521 | BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity); | ||
522 | } | ||
421 | } | 523 | } |
422 | public override OMV.Vector3 Torque { | 524 | public override OMV.Vector3 Torque { |
423 | get { return _torque; } | 525 | get { return _torque; } |
424 | set { _torque = value; | 526 | set { |
527 | _torque = value; | ||
528 | AddAngularForce(_torque, false, false); | ||
425 | // DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, _torque); | 529 | // DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, _torque); |
426 | } | 530 | } |
427 | } | 531 | } |
428 | public override float CollisionScore { | 532 | public override float CollisionScore { |
429 | get { return _collisionScore; } | 533 | get { return _collisionScore; } |
430 | set { _collisionScore = value; | 534 | set { _collisionScore = value; |
431 | } | 535 | } |
432 | } | 536 | } |
433 | public override OMV.Vector3 Acceleration { | 537 | public override OMV.Vector3 Acceleration { |
434 | get { return _acceleration; } | 538 | get { return _acceleration; } |
435 | set { _acceleration = value; } | 539 | set { _acceleration = value; } |
436 | } | 540 | } |
437 | public override OMV.Quaternion Orientation { | 541 | public override OMV.Quaternion RawOrientation |
542 | { | ||
543 | get { return _orientation; } | ||
544 | set { _orientation = value; } | ||
545 | } | ||
546 | public override OMV.Quaternion Orientation { | ||
438 | get { | 547 | get { |
439 | if (!_linkset.IsRoot(this)) | 548 | // Children move around because tied to parent. Get a fresh value. |
549 | if (!Linkset.IsRoot(this)) | ||
440 | { | 550 | { |
441 | // Children move around because tied to parent. Get a fresh value. | 551 | _orientation = Linkset.Orientation(this); |
442 | _orientation = BulletSimAPI.GetObjectOrientation(_scene.WorldID, LocalID); | ||
443 | } | 552 | } |
444 | return _orientation; | 553 | return _orientation; |
445 | } | 554 | } |
446 | set { | 555 | set { |
556 | if (_orientation == value) | ||
557 | return; | ||
447 | _orientation = value; | 558 | _orientation = value; |
448 | // TODO: what does it mean if a child in a linkset changes its orientation? Rebuild the constraint? | 559 | // TODO: what does it mean if a child in a linkset changes its orientation? Rebuild the constraint? |
449 | _scene.TaintedObject("BSPrim.setOrientation", delegate() | 560 | PhysicsScene.TaintedObject("BSPrim.setOrientation", delegate() |
450 | { | 561 | { |
451 | // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID); | 562 | // _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr); |
452 | // DetailLog("{0},BSPrim.setOrientation,taint,pos={1},orient={2}", LocalID, _position, _orientation); | 563 | // DetailLog("{0},BSPrim.setOrientation,taint,pos={1},orient={2}", LocalID, _position, _orientation); |
453 | BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation); | 564 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); |
454 | }); | 565 | }); |
455 | } | 566 | } |
456 | } | 567 | } |
457 | public override int PhysicsActorType { | 568 | // Go directly to Bullet to get/set the value. |
458 | get { return _physicsActorType; } | 569 | public override OMV.Quaternion ForceOrientation |
459 | set { _physicsActorType = value; | 570 | { |
460 | } | 571 | get |
572 | { | ||
573 | _orientation = BulletSimAPI.GetOrientation2(PhysBody.ptr); | ||
574 | return _orientation; | ||
575 | } | ||
576 | set | ||
577 | { | ||
578 | _orientation = value; | ||
579 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); | ||
580 | } | ||
581 | } | ||
582 | public override int PhysicsActorType { | ||
583 | get { return _physicsActorType; } | ||
584 | set { _physicsActorType = value; } | ||
461 | } | 585 | } |
462 | public override bool IsPhysical { | 586 | public override bool IsPhysical { |
463 | get { return _isPhysical; } | 587 | get { return _isPhysical; } |
464 | set { | 588 | set { |
465 | _isPhysical = value; | 589 | if (_isPhysical != value) |
466 | _scene.TaintedObject("BSPrim.setIsPhysical", delegate() | ||
467 | { | 590 | { |
468 | SetObjectDynamic(); | 591 | _isPhysical = value; |
469 | }); | 592 | PhysicsScene.TaintedObject("BSPrim.setIsPhysical", delegate() |
470 | } | 593 | { |
594 | // DetailLog("{0},setIsPhysical,taint,isPhys={1}", LocalID, _isPhysical); | ||
595 | SetObjectDynamic(true); | ||
596 | // whether phys-to-static or static-to-phys, the object is not moving. | ||
597 | ZeroMotion(true); | ||
598 | }); | ||
599 | } | ||
600 | } | ||
471 | } | 601 | } |
472 | 602 | ||
473 | // An object is static (does not move) if selected or not physical | 603 | // An object is static (does not move) if selected or not physical |
474 | private bool IsStatic | 604 | public override bool IsStatic |
475 | { | 605 | { |
476 | get { return _isSelected || !IsPhysical; } | 606 | get { return _isSelected || !IsPhysical; } |
477 | } | 607 | } |
478 | 608 | ||
479 | // An object is solid if it's not phantom and if it's not doing VolumeDetect | 609 | // An object is solid if it's not phantom and if it's not doing VolumeDetect |
480 | private bool IsSolid | 610 | public override bool IsSolid |
481 | { | 611 | { |
482 | get { return !IsPhantom && !_isVolumeDetect; } | 612 | get { return !IsPhantom && !_isVolumeDetect; } |
483 | } | 613 | } |
484 | 614 | ||
485 | // Make gravity work if the object is physical and not selected | 615 | // Make gravity work if the object is physical and not selected |
486 | // No locking here because only called when it is safe | 616 | // Called at taint-time!! |
487 | private void SetObjectDynamic() | 617 | private void SetObjectDynamic(bool forceRebuild) |
618 | { | ||
619 | // Recreate the physical object if necessary | ||
620 | CreateGeomAndObject(forceRebuild); | ||
621 | } | ||
622 | |||
623 | // Convert the simulator's physical properties into settings on BulletSim objects. | ||
624 | // There are four flags we're interested in: | ||
625 | // IsStatic: Object does not move, otherwise the object has mass and moves | ||
626 | // isSolid: other objects bounce off of this object | ||
627 | // isVolumeDetect: other objects pass through but can generate collisions | ||
628 | // collisionEvents: whether this object returns collision events | ||
629 | private void UpdatePhysicalParameters() | ||
488 | { | 630 | { |
489 | // RA: remove this for the moment. | 631 | // DetailLog("{0},BSPrim.UpdatePhysicalParameters,entry,body={1},shape={2}", LocalID, BSBody, BSShape); |
490 | // The problem is that dynamic objects are hulls so if we are becoming physical | 632 | |
491 | // the shape has to be checked and possibly built. | 633 | // Mangling all the physical properties requires the object not be in the physical world. |
492 | // Maybe a VerifyCorrectPhysicalShape() routine? | 634 | // This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found). |
493 | // RecreateGeomAndObject(); | 635 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr); |
636 | |||
637 | // Set up the object physicalness (does gravity and collisions move this object) | ||
638 | MakeDynamic(IsStatic); | ||
639 | |||
640 | // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters) | ||
641 | _vehicle.Refresh(); | ||
642 | |||
643 | // Arrange for collision events if the simulator wants them | ||
644 | EnableCollisions(SubscribedEvents()); | ||
645 | |||
646 | // Make solid or not (do things bounce off or pass through this object). | ||
647 | MakeSolid(IsSolid); | ||
648 | |||
649 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, PhysBody.ptr); | ||
650 | |||
651 | // Rebuild its shape | ||
652 | BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, PhysBody.ptr); | ||
653 | |||
654 | // Collision filter can be set only when the object is in the world | ||
655 | if (PhysBody.collisionFilter != 0 || PhysBody.collisionMask != 0) | ||
656 | { | ||
657 | BulletSimAPI.SetCollisionFilterMask2(PhysBody.ptr, (uint)PhysBody.collisionFilter, (uint)PhysBody.collisionMask); | ||
658 | } | ||
659 | |||
660 | // Recompute any linkset parameters. | ||
661 | // When going from non-physical to physical, this re-enables the constraints that | ||
662 | // had been automatically disabled when the mass was set to zero. | ||
663 | // For compound based linksets, this enables and disables interactions of the children. | ||
664 | Linkset.Refresh(this); | ||
665 | |||
666 | DetailLog("{0},BSPrim.UpdatePhysicalParameters,taintExit,static={1},solid={2},mass={3},collide={4},cf={5:X},body={6},shape={7}", | ||
667 | LocalID, IsStatic, IsSolid, _mass, SubscribedEvents(), CurrentCollisionFlags, PhysBody, PhysShape); | ||
668 | } | ||
494 | 669 | ||
495 | // Bullet wants static objects to have a mass of zero | 670 | // "Making dynamic" means changing to and from static. |
496 | float mass = IsStatic ? 0f : _mass; | 671 | // When static, gravity does not effect the object and it is fixed in space. |
672 | // When dynamic, the object can fall and be pushed by others. | ||
673 | // This is independent of its 'solidness' which controls what passes through | ||
674 | // this object and what interacts with it. | ||
675 | private void MakeDynamic(bool makeStatic) | ||
676 | { | ||
677 | if (makeStatic) | ||
678 | { | ||
679 | // Become a Bullet 'static' object type | ||
680 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_STATIC_OBJECT); | ||
681 | // Stop all movement | ||
682 | ZeroMotion(true); | ||
683 | // Center of mass is at the center of the object | ||
684 | // DEBUG DEBUG BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.PhysBody.ptr, _position, _orientation); | ||
685 | // Mass is zero which disables a bunch of physics stuff in Bullet | ||
686 | UpdatePhysicalMassProperties(0f); | ||
687 | // Set collision detection parameters | ||
688 | if (PhysicsScene.Params.ccdMotionThreshold > 0f) | ||
689 | { | ||
690 | BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, PhysicsScene.Params.ccdMotionThreshold); | ||
691 | BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, PhysicsScene.Params.ccdSweptSphereRadius); | ||
692 | } | ||
693 | // There can be special things needed for implementing linksets | ||
694 | Linkset.MakeStatic(this); | ||
695 | // The activation state is 'disabled' so Bullet will not try to act on it. | ||
696 | BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.DISABLE_SIMULATION); | ||
697 | // Start it out sleeping and physical actions could wake it up. | ||
698 | // BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ISLAND_SLEEPING); | ||
699 | |||
700 | PhysBody.collisionFilter = CollisionFilterGroups.StaticObjectFilter; | ||
701 | PhysBody.collisionMask = CollisionFilterGroups.StaticObjectMask; | ||
702 | } | ||
703 | else | ||
704 | { | ||
705 | // Not a Bullet static object | ||
706 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_STATIC_OBJECT); | ||
497 | 707 | ||
498 | BulletSimAPI.SetObjectProperties(_scene.WorldID, LocalID, IsStatic, IsSolid, SubscribedEvents(), mass); | 708 | // Set various physical properties so internal dynamic properties will get computed correctly as they are set |
709 | BulletSimAPI.SetFriction2(PhysBody.ptr, PhysicsScene.Params.defaultFriction); | ||
710 | BulletSimAPI.SetRestitution2(PhysBody.ptr, PhysicsScene.Params.defaultRestitution); | ||
711 | |||
712 | // per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382 | ||
713 | // Since this can be called multiple times, only zero forces when becoming physical | ||
714 | // BulletSimAPI.ClearAllForces2(BSBody.ptr); | ||
715 | |||
716 | // For good measure, make sure the transform is set through to the motion state | ||
717 | BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation); | ||
718 | |||
719 | // Center of mass is at the center of the object | ||
720 | // DEBUG DEBUG BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.PhysBody.ptr, _position, _orientation); | ||
721 | |||
722 | // A dynamic object has mass | ||
723 | UpdatePhysicalMassProperties(RawMass); | ||
724 | |||
725 | // Set collision detection parameters | ||
726 | if (PhysicsScene.Params.ccdMotionThreshold > 0f) | ||
727 | { | ||
728 | BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, PhysicsScene.Params.ccdMotionThreshold); | ||
729 | BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, PhysicsScene.Params.ccdSweptSphereRadius); | ||
730 | } | ||
731 | |||
732 | // Various values for simulation limits | ||
733 | BulletSimAPI.SetDamping2(PhysBody.ptr, PhysicsScene.Params.linearDamping, PhysicsScene.Params.angularDamping); | ||
734 | BulletSimAPI.SetDeactivationTime2(PhysBody.ptr, PhysicsScene.Params.deactivationTime); | ||
735 | BulletSimAPI.SetSleepingThresholds2(PhysBody.ptr, PhysicsScene.Params.linearSleepingThreshold, PhysicsScene.Params.angularSleepingThreshold); | ||
736 | BulletSimAPI.SetContactProcessingThreshold2(PhysBody.ptr, PhysicsScene.Params.contactProcessingThreshold); | ||
737 | |||
738 | // There might be special things needed for implementing linksets. | ||
739 | Linkset.MakeDynamic(this); | ||
740 | |||
741 | // Force activation of the object so Bullet will act on it. | ||
742 | // Must do the ForceActivationState2() to overcome the DISABLE_SIMULATION from static objects. | ||
743 | BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.ACTIVE_TAG); | ||
744 | // BulletSimAPI.Activate2(BSBody.ptr, true); | ||
745 | |||
746 | PhysBody.collisionFilter = CollisionFilterGroups.ObjectFilter; | ||
747 | PhysBody.collisionMask = CollisionFilterGroups.ObjectMask; | ||
748 | } | ||
749 | } | ||
750 | |||
751 | // "Making solid" means that other object will not pass through this object. | ||
752 | // To make transparent, we create a Bullet ghost object. | ||
753 | // Note: This expects to be called from the UpdatePhysicalParameters() routine as | ||
754 | // the functions after this one set up the state of a possibly newly created collision body. | ||
755 | private void MakeSolid(bool makeSolid) | ||
756 | { | ||
757 | CollisionObjectTypes bodyType = (CollisionObjectTypes)BulletSimAPI.GetBodyType2(PhysBody.ptr); | ||
758 | if (makeSolid) | ||
759 | { | ||
760 | // Verify the previous code created the correct shape for this type of thing. | ||
761 | if ((bodyType & CollisionObjectTypes.CO_RIGID_BODY) == 0) | ||
762 | { | ||
763 | m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType); | ||
764 | } | ||
765 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE); | ||
766 | } | ||
767 | else | ||
768 | { | ||
769 | if ((bodyType & CollisionObjectTypes.CO_GHOST_OBJECT) == 0) | ||
770 | { | ||
771 | m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType); | ||
772 | } | ||
773 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE); | ||
774 | PhysBody.collisionFilter = CollisionFilterGroups.VolumeDetectFilter; | ||
775 | PhysBody.collisionMask = CollisionFilterGroups.VolumeDetectMask; | ||
776 | } | ||
777 | } | ||
499 | 778 | ||
500 | // recompute any linkset parameters | 779 | // Enable physical actions. Bullet will keep sleeping non-moving physical objects so |
501 | _linkset.Refresh(this); | 780 | // they need waking up when parameters are changed. |
781 | // Called in taint-time!! | ||
782 | private void ActivateIfPhysical(bool forceIt) | ||
783 | { | ||
784 | if (IsPhysical) | ||
785 | BulletSimAPI.Activate2(PhysBody.ptr, forceIt); | ||
786 | } | ||
502 | 787 | ||
503 | CollisionFlags cf = BulletSimAPI.GetCollisionFlags2(Body.Ptr); | 788 | // 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); | 789 | private void EnableCollisions(bool wantsCollisionEvents) |
790 | { | ||
791 | if (wantsCollisionEvents) | ||
792 | { | ||
793 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
794 | } | ||
795 | else | ||
796 | { | ||
797 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
798 | } | ||
505 | } | 799 | } |
506 | 800 | ||
507 | // prims don't fly | 801 | // prims don't fly |
508 | public override bool Flying { | 802 | public override bool Flying { |
509 | get { return _flying; } | 803 | get { return _flying; } |
510 | set { _flying = value; } | 804 | set { |
805 | _flying = value; | ||
806 | } | ||
511 | } | 807 | } |
512 | public override bool SetAlwaysRun { | 808 | public override bool SetAlwaysRun { |
513 | get { return _setAlwaysRun; } | 809 | get { return _setAlwaysRun; } |
514 | set { _setAlwaysRun = value; } | 810 | set { _setAlwaysRun = value; } |
515 | } | 811 | } |
516 | public override bool ThrottleUpdates { | 812 | public override bool ThrottleUpdates { |
517 | get { return _throttleUpdates; } | 813 | get { return _throttleUpdates; } |
518 | set { _throttleUpdates = value; } | 814 | set { _throttleUpdates = value; } |
519 | } | 815 | } |
520 | public override bool IsColliding { | 816 | public override bool IsColliding { |
521 | get { return (_collidingStep == _scene.SimulationStep); } | 817 | get { return (CollidingStep == PhysicsScene.SimulationStep); } |
522 | set { _isColliding = value; } | 818 | set { _isColliding = value; } |
523 | } | 819 | } |
524 | public override bool CollidingGround { | 820 | public override bool CollidingGround { |
525 | get { return (_collidingGroundStep == _scene.SimulationStep); } | 821 | get { return (CollidingGroundStep == PhysicsScene.SimulationStep); } |
526 | set { _collidingGround = value; } | 822 | set { _collidingGround = value; } |
527 | } | 823 | } |
528 | public override bool CollidingObj { | 824 | public override bool CollidingObj { |
529 | get { return _collidingObj; } | 825 | get { return _collidingObj; } |
530 | set { _collidingObj = value; } | 826 | set { _collidingObj = value; } |
531 | } | 827 | } |
532 | public bool IsPhantom { | 828 | public bool IsPhantom { |
533 | get { | 829 | get { |
@@ -537,10 +833,19 @@ public sealed class BSPrim : PhysicsActor | |||
537 | return false; | 833 | return false; |
538 | } | 834 | } |
539 | } | 835 | } |
540 | public override bool FloatOnWater { | 836 | public override bool FloatOnWater { |
541 | set { _floatOnWater = value; } | 837 | set { |
838 | _floatOnWater = value; | ||
839 | PhysicsScene.TaintedObject("BSPrim.setFloatOnWater", delegate() | ||
840 | { | ||
841 | if (_floatOnWater) | ||
842 | CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
843 | else | ||
844 | CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER); | ||
845 | }); | ||
846 | } | ||
542 | } | 847 | } |
543 | public override OMV.Vector3 RotationalVelocity { | 848 | public override OMV.Vector3 RotationalVelocity { |
544 | get { | 849 | get { |
545 | /* | 850 | /* |
546 | OMV.Vector3 pv = OMV.Vector3.Zero; | 851 | OMV.Vector3 pv = OMV.Vector3.Zero; |
@@ -552,58 +857,76 @@ public sealed class BSPrim : PhysicsActor | |||
552 | */ | 857 | */ |
553 | 858 | ||
554 | return _rotationalVelocity; | 859 | return _rotationalVelocity; |
555 | } | 860 | } |
556 | set { | 861 | set { |
557 | _rotationalVelocity = value; | 862 | _rotationalVelocity = value; |
558 | // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity); | 863 | // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity); |
559 | _scene.TaintedObject("BSPrim.setRotationalVelocity", delegate() | 864 | PhysicsScene.TaintedObject("BSPrim.setRotationalVelocity", delegate() |
560 | { | 865 | { |
561 | // DetailLog("{0},BSPrim.SetRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity); | 866 | DetailLog("{0},BSPrim.SetRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity); |
562 | BulletSimAPI.SetObjectAngularVelocity(_scene.WorldID, LocalID, _rotationalVelocity); | 867 | BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, _rotationalVelocity); |
563 | }); | 868 | }); |
564 | } | 869 | } |
565 | } | 870 | } |
566 | public override bool Kinematic { | 871 | public override OMV.Vector3 ForceRotationalVelocity { |
567 | get { return _kinematic; } | 872 | get { |
568 | set { _kinematic = value; | 873 | return _rotationalVelocity; |
874 | } | ||
875 | set { | ||
876 | _rotationalVelocity = value; | ||
877 | BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, _rotationalVelocity); | ||
878 | } | ||
879 | } | ||
880 | public override bool Kinematic { | ||
881 | get { return _kinematic; } | ||
882 | set { _kinematic = value; | ||
569 | // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic); | 883 | // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic); |
570 | } | 884 | } |
571 | } | 885 | } |
572 | public override float Buoyancy { | 886 | public override float Buoyancy { |
573 | get { return _buoyancy; } | 887 | get { return _buoyancy; } |
574 | set { | 888 | set { |
575 | _buoyancy = value; | 889 | _buoyancy = value; |
576 | _scene.TaintedObject("BSPrim.setBuoyancy", delegate() | 890 | PhysicsScene.TaintedObject("BSPrim.setBuoyancy", delegate() |
577 | { | 891 | { |
578 | // DetailLog("{0},BSPrim.SetBuoyancy,taint,buoy={1}", LocalID, _buoyancy); | 892 | ForceBuoyancy = _buoyancy; |
579 | BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, _localID, _buoyancy); | ||
580 | }); | 893 | }); |
581 | } | 894 | } |
895 | } | ||
896 | public override float ForceBuoyancy { | ||
897 | get { return _buoyancy; } | ||
898 | set { | ||
899 | _buoyancy = value; | ||
900 | // DetailLog("{0},BSPrim.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy); | ||
901 | // Buoyancy is faked by changing the gravity applied to the object | ||
902 | float grav = PhysicsScene.Params.gravity * (1f - _buoyancy); | ||
903 | BulletSimAPI.SetGravity2(PhysBody.ptr, new OMV.Vector3(0f, 0f, grav)); | ||
904 | } | ||
582 | } | 905 | } |
583 | 906 | ||
584 | // Used for MoveTo | 907 | // Used for MoveTo |
585 | public override OMV.Vector3 PIDTarget { | 908 | public override OMV.Vector3 PIDTarget { |
586 | set { _PIDTarget = value; } | 909 | set { _PIDTarget = value; } |
587 | } | 910 | } |
588 | public override bool PIDActive { | 911 | public override bool PIDActive { |
589 | set { _usePID = value; } | 912 | set { _usePID = value; } |
590 | } | 913 | } |
591 | public override float PIDTau { | 914 | public override float PIDTau { |
592 | set { _PIDTau = value; } | 915 | set { _PIDTau = value; } |
593 | } | 916 | } |
594 | 917 | ||
595 | // Used for llSetHoverHeight and maybe vehicle height | 918 | // Used for llSetHoverHeight and maybe vehicle height |
596 | // Hover Height will override MoveTo target's Z | 919 | // Hover Height will override MoveTo target's Z |
597 | public override bool PIDHoverActive { | 920 | public override bool PIDHoverActive { |
598 | set { _useHoverPID = value; } | 921 | set { _useHoverPID = value; } |
599 | } | 922 | } |
600 | public override float PIDHoverHeight { | 923 | public override float PIDHoverHeight { |
601 | set { _PIDHoverHeight = value; } | 924 | set { _PIDHoverHeight = value; } |
602 | } | 925 | } |
603 | public override PIDHoverType PIDHoverType { | 926 | public override PIDHoverType PIDHoverType { |
604 | set { _PIDHoverType = value; } | 927 | set { _PIDHoverType = value; } |
605 | } | 928 | } |
606 | public override float PIDHoverTau { | 929 | public override float PIDHoverTau { |
607 | set { _PIDHoverTao = value; } | 930 | set { _PIDHoverTao = value; } |
608 | } | 931 | } |
609 | 932 | ||
@@ -615,6 +938,9 @@ public sealed class BSPrim : PhysicsActor | |||
615 | 938 | ||
616 | private List<OMV.Vector3> m_accumulatedForces = new List<OMV.Vector3>(); | 939 | private List<OMV.Vector3> m_accumulatedForces = new List<OMV.Vector3>(); |
617 | public override void AddForce(OMV.Vector3 force, bool pushforce) { | 940 | public override void AddForce(OMV.Vector3 force, bool pushforce) { |
941 | AddForce(force, pushforce, false); | ||
942 | } | ||
943 | public void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) { | ||
618 | // for an object, doesn't matter if force is a pushforce or not | 944 | // for an object, doesn't matter if force is a pushforce or not |
619 | if (force.IsFinite()) | 945 | if (force.IsFinite()) |
620 | { | 946 | { |
@@ -624,56 +950,87 @@ public sealed class BSPrim : PhysicsActor | |||
624 | } | 950 | } |
625 | else | 951 | else |
626 | { | 952 | { |
627 | m_log.WarnFormat("{0}: Got a NaN force applied to a Character", LogHeader); | 953 | m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID); |
628 | return; | 954 | return; |
629 | } | 955 | } |
630 | _scene.TaintedObject("BSPrim.AddForce", delegate() | 956 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddForce", delegate() |
631 | { | 957 | { |
632 | OMV.Vector3 fSum = OMV.Vector3.Zero; | 958 | OMV.Vector3 fSum = OMV.Vector3.Zero; |
633 | lock (m_accumulatedForces) | 959 | lock (m_accumulatedForces) |
634 | { | 960 | { |
961 | // Sum the accumulated additional forces for one big force to apply once. | ||
635 | foreach (OMV.Vector3 v in m_accumulatedForces) | 962 | foreach (OMV.Vector3 v in m_accumulatedForces) |
636 | { | 963 | { |
637 | fSum += v; | 964 | fSum += v; |
638 | } | 965 | } |
639 | m_accumulatedForces.Clear(); | 966 | m_accumulatedForces.Clear(); |
640 | } | 967 | } |
641 | // DetailLog("{0},BSPrim.AddObjectForce,taint,force={1}", LocalID, _force); | 968 | DetailLog("{0},BSPrim.AddForce,taint,force={1}", LocalID, fSum); |
642 | BulletSimAPI.AddObjectForce2(Body.Ptr, fSum); | 969 | if (fSum != OMV.Vector3.Zero) |
970 | BulletSimAPI.ApplyCentralForce2(PhysBody.ptr, fSum); | ||
643 | }); | 971 | }); |
644 | } | 972 | } |
645 | 973 | ||
646 | public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { | 974 | public void ApplyForceImpulse(OMV.Vector3 impulse, bool inTaintTime) |
647 | // DetailLog("{0},BSPrim.AddAngularForce,call,angForce={1},push={2}", LocalID, force, pushforce); | 975 | { |
648 | // m_log.DebugFormat("{0}: AddAngularForce. f={1}, push={2}", LogHeader, force, pushforce); | 976 | OMV.Vector3 applyImpulse = impulse; |
977 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ApplyForceImpulse", delegate() | ||
978 | { | ||
979 | DetailLog("{0},BSPrim.ApplyForceImpulse,taint,tImpulse={1}", LocalID, applyImpulse); | ||
980 | BulletSimAPI.ApplyCentralImpulse2(PhysBody.ptr, applyImpulse); | ||
981 | }); | ||
649 | } | 982 | } |
650 | public override void SetMomentum(OMV.Vector3 momentum) { | 983 | |
651 | // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum); | 984 | private List<OMV.Vector3> m_accumulatedAngularForces = new List<OMV.Vector3>(); |
985 | public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { | ||
986 | AddAngularForce(force, pushforce, false); | ||
652 | } | 987 | } |
653 | public override void SubscribeEvents(int ms) { | 988 | public void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) |
654 | _subscribedEventsMs = ms; | 989 | { |
655 | if (ms > 0) | 990 | if (force.IsFinite()) |
656 | { | 991 | { |
657 | // make sure first collision happens | 992 | // _force += force; |
658 | _nextCollisionOkTime = Util.EnvironmentTickCount() - _subscribedEventsMs; | 993 | lock (m_accumulatedAngularForces) |
659 | 994 | m_accumulatedAngularForces.Add(new OMV.Vector3(force)); | |
660 | Scene.TaintedObject("BSPrim.SubscribeEvents", delegate() | ||
661 | { | ||
662 | BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | ||
663 | }); | ||
664 | } | 995 | } |
665 | } | 996 | else |
666 | public override void UnSubscribeEvents() { | ||
667 | _subscribedEventsMs = 0; | ||
668 | Scene.TaintedObject("BSPrim.UnSubscribeEvents", delegate() | ||
669 | { | 997 | { |
670 | BulletSimAPI.RemoveFromCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS); | 998 | m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID); |
999 | return; | ||
1000 | } | ||
1001 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddAngularForce", delegate() | ||
1002 | { | ||
1003 | OMV.Vector3 fSum = OMV.Vector3.Zero; | ||
1004 | lock (m_accumulatedAngularForces) | ||
1005 | { | ||
1006 | // Sum the accumulated additional forces for one big force to apply once. | ||
1007 | foreach (OMV.Vector3 v in m_accumulatedAngularForces) | ||
1008 | { | ||
1009 | fSum += v; | ||
1010 | } | ||
1011 | m_accumulatedAngularForces.Clear(); | ||
1012 | } | ||
1013 | DetailLog("{0},BSPrim.AddAngularForce,taint,aForce={1}", LocalID, fSum); | ||
1014 | if (fSum != OMV.Vector3.Zero) | ||
1015 | { | ||
1016 | BulletSimAPI.ApplyTorque2(PhysBody.ptr, fSum); | ||
1017 | _torque = fSum; | ||
1018 | } | ||
671 | }); | 1019 | }); |
672 | } | 1020 | } |
673 | public override bool SubscribedEvents() { | 1021 | // A torque impulse. |
674 | return (_subscribedEventsMs > 0); | 1022 | public void ApplyTorqueImpulse(OMV.Vector3 impulse, bool inTaintTime) |
1023 | { | ||
1024 | OMV.Vector3 applyImpulse = impulse; | ||
1025 | PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ApplyTorqueImpulse", delegate() | ||
1026 | { | ||
1027 | BulletSimAPI.ApplyTorqueImpulse2(PhysBody.ptr, applyImpulse); | ||
1028 | }); | ||
675 | } | 1029 | } |
676 | 1030 | ||
1031 | public override void SetMomentum(OMV.Vector3 momentum) { | ||
1032 | // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum); | ||
1033 | } | ||
677 | #region Mass Calculation | 1034 | #region Mass Calculation |
678 | 1035 | ||
679 | private float CalculateMass() | 1036 | private float CalculateMass() |
@@ -682,19 +1039,19 @@ public sealed class BSPrim : PhysicsActor | |||
682 | float tmp; | 1039 | float tmp; |
683 | 1040 | ||
684 | float returnMass = 0; | 1041 | float returnMass = 0; |
685 | float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f; | 1042 | float hollowAmount = (float)BaseShape.ProfileHollow * 2.0e-5f; |
686 | float hollowVolume = hollowAmount * hollowAmount; | 1043 | float hollowVolume = hollowAmount * hollowAmount; |
687 | 1044 | ||
688 | switch (_pbs.ProfileShape) | 1045 | switch (BaseShape.ProfileShape) |
689 | { | 1046 | { |
690 | case ProfileShape.Square: | 1047 | case ProfileShape.Square: |
691 | // default box | 1048 | // default box |
692 | 1049 | ||
693 | if (_pbs.PathCurve == (byte)Extrusion.Straight) | 1050 | if (BaseShape.PathCurve == (byte)Extrusion.Straight) |
694 | { | 1051 | { |
695 | if (hollowAmount > 0.0) | 1052 | if (hollowAmount > 0.0) |
696 | { | 1053 | { |
697 | switch (_pbs.HollowShape) | 1054 | switch (BaseShape.HollowShape) |
698 | { | 1055 | { |
699 | case HollowShape.Square: | 1056 | case HollowShape.Square: |
700 | case HollowShape.Same: | 1057 | case HollowShape.Same: |
@@ -718,19 +1075,19 @@ public sealed class BSPrim : PhysicsActor | |||
718 | } | 1075 | } |
719 | } | 1076 | } |
720 | 1077 | ||
721 | else if (_pbs.PathCurve == (byte)Extrusion.Curve1) | 1078 | else if (BaseShape.PathCurve == (byte)Extrusion.Curve1) |
722 | { | 1079 | { |
723 | //a tube | 1080 | //a tube |
724 | 1081 | ||
725 | volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX); | 1082 | volume *= 0.78539816339e-2f * (float)(200 - BaseShape.PathScaleX); |
726 | tmp= 1.0f -2.0e-2f * (float)(200 - _pbs.PathScaleY); | 1083 | tmp= 1.0f -2.0e-2f * (float)(200 - BaseShape.PathScaleY); |
727 | volume -= volume*tmp*tmp; | 1084 | volume -= volume*tmp*tmp; |
728 | 1085 | ||
729 | if (hollowAmount > 0.0) | 1086 | if (hollowAmount > 0.0) |
730 | { | 1087 | { |
731 | hollowVolume *= hollowAmount; | 1088 | hollowVolume *= hollowAmount; |
732 | 1089 | ||
733 | switch (_pbs.HollowShape) | 1090 | switch (BaseShape.HollowShape) |
734 | { | 1091 | { |
735 | case HollowShape.Square: | 1092 | case HollowShape.Square: |
736 | case HollowShape.Same: | 1093 | case HollowShape.Same: |
@@ -755,13 +1112,13 @@ public sealed class BSPrim : PhysicsActor | |||
755 | 1112 | ||
756 | case ProfileShape.Circle: | 1113 | case ProfileShape.Circle: |
757 | 1114 | ||
758 | if (_pbs.PathCurve == (byte)Extrusion.Straight) | 1115 | if (BaseShape.PathCurve == (byte)Extrusion.Straight) |
759 | { | 1116 | { |
760 | volume *= 0.78539816339f; // elipse base | 1117 | volume *= 0.78539816339f; // elipse base |
761 | 1118 | ||
762 | if (hollowAmount > 0.0) | 1119 | if (hollowAmount > 0.0) |
763 | { | 1120 | { |
764 | switch (_pbs.HollowShape) | 1121 | switch (BaseShape.HollowShape) |
765 | { | 1122 | { |
766 | case HollowShape.Same: | 1123 | case HollowShape.Same: |
767 | case HollowShape.Circle: | 1124 | case HollowShape.Circle: |
@@ -783,19 +1140,19 @@ public sealed class BSPrim : PhysicsActor | |||
783 | } | 1140 | } |
784 | } | 1141 | } |
785 | 1142 | ||
786 | else if (_pbs.PathCurve == (byte)Extrusion.Curve1) | 1143 | else if (BaseShape.PathCurve == (byte)Extrusion.Curve1) |
787 | { | 1144 | { |
788 | volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX); | 1145 | volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - BaseShape.PathScaleX); |
789 | tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY); | 1146 | tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY); |
790 | volume *= (1.0f - tmp * tmp); | 1147 | volume *= (1.0f - tmp * tmp); |
791 | 1148 | ||
792 | if (hollowAmount > 0.0) | 1149 | if (hollowAmount > 0.0) |
793 | { | 1150 | { |
794 | 1151 | ||
795 | // calculate the hollow volume by it's shape compared to the prim shape | 1152 | // calculate the hollow volume by it's shape compared to the prim shape |
796 | hollowVolume *= hollowAmount; | 1153 | hollowVolume *= hollowAmount; |
797 | 1154 | ||
798 | switch (_pbs.HollowShape) | 1155 | switch (BaseShape.HollowShape) |
799 | { | 1156 | { |
800 | case HollowShape.Same: | 1157 | case HollowShape.Same: |
801 | case HollowShape.Circle: | 1158 | case HollowShape.Circle: |
@@ -819,7 +1176,7 @@ public sealed class BSPrim : PhysicsActor | |||
819 | break; | 1176 | break; |
820 | 1177 | ||
821 | case ProfileShape.HalfCircle: | 1178 | case ProfileShape.HalfCircle: |
822 | if (_pbs.PathCurve == (byte)Extrusion.Curve1) | 1179 | if (BaseShape.PathCurve == (byte)Extrusion.Curve1) |
823 | { | 1180 | { |
824 | volume *= 0.52359877559829887307710723054658f; | 1181 | volume *= 0.52359877559829887307710723054658f; |
825 | } | 1182 | } |
@@ -827,7 +1184,7 @@ public sealed class BSPrim : PhysicsActor | |||
827 | 1184 | ||
828 | case ProfileShape.EquilateralTriangle: | 1185 | case ProfileShape.EquilateralTriangle: |
829 | 1186 | ||
830 | if (_pbs.PathCurve == (byte)Extrusion.Straight) | 1187 | if (BaseShape.PathCurve == (byte)Extrusion.Straight) |
831 | { | 1188 | { |
832 | volume *= 0.32475953f; | 1189 | volume *= 0.32475953f; |
833 | 1190 | ||
@@ -835,7 +1192,7 @@ public sealed class BSPrim : PhysicsActor | |||
835 | { | 1192 | { |
836 | 1193 | ||
837 | // calculate the hollow volume by it's shape compared to the prim shape | 1194 | // calculate the hollow volume by it's shape compared to the prim shape |
838 | switch (_pbs.HollowShape) | 1195 | switch (BaseShape.HollowShape) |
839 | { | 1196 | { |
840 | case HollowShape.Same: | 1197 | case HollowShape.Same: |
841 | case HollowShape.Triangle: | 1198 | case HollowShape.Triangle: |
@@ -860,11 +1217,11 @@ public sealed class BSPrim : PhysicsActor | |||
860 | volume *= (1.0f - hollowVolume); | 1217 | volume *= (1.0f - hollowVolume); |
861 | } | 1218 | } |
862 | } | 1219 | } |
863 | else if (_pbs.PathCurve == (byte)Extrusion.Curve1) | 1220 | else if (BaseShape.PathCurve == (byte)Extrusion.Curve1) |
864 | { | 1221 | { |
865 | volume *= 0.32475953f; | 1222 | volume *= 0.32475953f; |
866 | volume *= 0.01f * (float)(200 - _pbs.PathScaleX); | 1223 | volume *= 0.01f * (float)(200 - BaseShape.PathScaleX); |
867 | tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY); | 1224 | tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY); |
868 | volume *= (1.0f - tmp * tmp); | 1225 | volume *= (1.0f - tmp * tmp); |
869 | 1226 | ||
870 | if (hollowAmount > 0.0) | 1227 | if (hollowAmount > 0.0) |
@@ -872,7 +1229,7 @@ public sealed class BSPrim : PhysicsActor | |||
872 | 1229 | ||
873 | hollowVolume *= hollowAmount; | 1230 | hollowVolume *= hollowAmount; |
874 | 1231 | ||
875 | switch (_pbs.HollowShape) | 1232 | switch (BaseShape.HollowShape) |
876 | { | 1233 | { |
877 | case HollowShape.Same: | 1234 | case HollowShape.Same: |
878 | case HollowShape.Triangle: | 1235 | case HollowShape.Triangle: |
@@ -912,26 +1269,26 @@ public sealed class BSPrim : PhysicsActor | |||
912 | float profileBegin; | 1269 | float profileBegin; |
913 | float profileEnd; | 1270 | float profileEnd; |
914 | 1271 | ||
915 | if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible) | 1272 | if (BaseShape.PathCurve == (byte)Extrusion.Straight || BaseShape.PathCurve == (byte)Extrusion.Flexible) |
916 | { | 1273 | { |
917 | taperX1 = _pbs.PathScaleX * 0.01f; | 1274 | taperX1 = BaseShape.PathScaleX * 0.01f; |
918 | if (taperX1 > 1.0f) | 1275 | if (taperX1 > 1.0f) |
919 | taperX1 = 2.0f - taperX1; | 1276 | taperX1 = 2.0f - taperX1; |
920 | taperX = 1.0f - taperX1; | 1277 | taperX = 1.0f - taperX1; |
921 | 1278 | ||
922 | taperY1 = _pbs.PathScaleY * 0.01f; | 1279 | taperY1 = BaseShape.PathScaleY * 0.01f; |
923 | if (taperY1 > 1.0f) | 1280 | if (taperY1 > 1.0f) |
924 | taperY1 = 2.0f - taperY1; | 1281 | taperY1 = 2.0f - taperY1; |
925 | taperY = 1.0f - taperY1; | 1282 | taperY = 1.0f - taperY1; |
926 | } | 1283 | } |
927 | else | 1284 | else |
928 | { | 1285 | { |
929 | taperX = _pbs.PathTaperX * 0.01f; | 1286 | taperX = BaseShape.PathTaperX * 0.01f; |
930 | if (taperX < 0.0f) | 1287 | if (taperX < 0.0f) |
931 | taperX = -taperX; | 1288 | taperX = -taperX; |
932 | taperX1 = 1.0f - taperX; | 1289 | taperX1 = 1.0f - taperX; |
933 | 1290 | ||
934 | taperY = _pbs.PathTaperY * 0.01f; | 1291 | taperY = BaseShape.PathTaperY * 0.01f; |
935 | if (taperY < 0.0f) | 1292 | if (taperY < 0.0f) |
936 | taperY = -taperY; | 1293 | taperY = -taperY; |
937 | taperY1 = 1.0f - taperY; | 1294 | taperY1 = 1.0f - taperY; |
@@ -941,20 +1298,18 @@ public sealed class BSPrim : PhysicsActor | |||
941 | 1298 | ||
942 | volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY); | 1299 | volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY); |
943 | 1300 | ||
944 | pathBegin = (float)_pbs.PathBegin * 2.0e-5f; | 1301 | pathBegin = (float)BaseShape.PathBegin * 2.0e-5f; |
945 | pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f; | 1302 | pathEnd = 1.0f - (float)BaseShape.PathEnd * 2.0e-5f; |
946 | volume *= (pathEnd - pathBegin); | 1303 | volume *= (pathEnd - pathBegin); |
947 | 1304 | ||
948 | // this is crude aproximation | 1305 | // this is crude aproximation |
949 | profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f; | 1306 | profileBegin = (float)BaseShape.ProfileBegin * 2.0e-5f; |
950 | profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f; | 1307 | profileEnd = 1.0f - (float)BaseShape.ProfileEnd * 2.0e-5f; |
951 | volume *= (profileEnd - profileBegin); | 1308 | volume *= (profileEnd - profileBegin); |
952 | 1309 | ||
953 | returnMass = _density * volume; | 1310 | returnMass = _density * volume; |
954 | 1311 | ||
955 | /* | 1312 | /* Comment out code that computes the mass of the linkset. That is done in the Linkset class. |
956 | * This change means each object keeps its own mass and the Mass property | ||
957 | * will return the sum if we're part of a linkset. | ||
958 | if (IsRootOfLinkset) | 1313 | if (IsRootOfLinkset) |
959 | { | 1314 | { |
960 | foreach (BSPrim prim in _childrenPrims) | 1315 | foreach (BSPrim prim in _childrenPrims) |
@@ -967,296 +1322,49 @@ public sealed class BSPrim : PhysicsActor | |||
967 | if (returnMass <= 0) | 1322 | if (returnMass <= 0) |
968 | returnMass = 0.0001f; | 1323 | returnMass = 0.0001f; |
969 | 1324 | ||
970 | if (returnMass > _scene.MaximumObjectMass) | 1325 | if (returnMass > PhysicsScene.MaximumObjectMass) |
971 | returnMass = _scene.MaximumObjectMass; | 1326 | returnMass = PhysicsScene.MaximumObjectMass; |
972 | 1327 | ||
973 | return returnMass; | 1328 | return returnMass; |
974 | }// end CalculateMass | 1329 | }// end CalculateMass |
975 | #endregion Mass Calculation | 1330 | #endregion Mass Calculation |
976 | 1331 | ||
977 | // Create the geometry information in Bullet for later use | 1332 | // Rebuild the geometry and object. |
978 | // The objects needs a hull if it's physical otherwise a mesh is enough | 1333 | // This is called when the shape changes so we need to recreate the mesh/hull. |
979 | // No locking here because this is done when we know physics is not simulating | 1334 | // Called at taint-time!!! |
980 | // if 'forceRebuild' is true, the geometry is rebuilt. Otherwise a previously built version is used | 1335 | private void CreateGeomAndObject(bool forceRebuild) |
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 | { | 1336 | { |
1094 | float lod = _pbs.SculptEntry ? _scene.SculptLOD : _scene.MeshLOD; | 1337 | // If this prim is part of a linkset, we must remove and restore the physical |
1095 | ulong newHullKey = (ulong)_pbs.GetMeshKey(_size, lod); | 1338 | // links if the body is rebuilt. |
1096 | // m_log.DebugFormat("{0}: CreateGeomHull: lID={1}, oldKey={2}, newKey={3}", LogHeader, _localID, _hullKey, newHullKey); | 1339 | bool needToRestoreLinkset = false; |
1097 | 1340 | bool needToRestoreVehicle = false; | |
1098 | // if the hull hasn't changed, don't rebuild it | 1341 | |
1099 | if (newHullKey == _hullKey) return; | 1342 | // Create the correct physical representation for this type of object. |
1100 | 1343 | // Updates PhysBody and PhysShape with the new information. | |
1101 | // DetailLog("{0},BSPrim.CreateGeomHull,create,oldKey={1},newKey={2}", LocalID, _hullKey, newHullKey); | 1344 | // Ignore 'forceRebuild'. This routine makes the right choices and changes of necessary. |
1102 | 1345 | // Returns 'true' if either the body or the shape was changed. | |
1103 | // Since we're recreating new, get rid of any previously generated shape | 1346 | PhysicsScene.Shapes.GetBodyAndShape(false, PhysicsScene.World, this, null, delegate(BulletBody dBody) |
1104 | if (_hullKey != 0) | ||
1105 | { | 1347 | { |
1106 | // m_log.DebugFormat("{0}: CreateGeom: deleting old hull. Key={1}", LogHeader, _hullKey); | 1348 | // Called if the current prim body is about to be destroyed. |
1107 | // DetailLog("{0},BSPrim.CreateGeomHull,deleteOldHull,key={1}", LocalID, _hullKey); | 1349 | // Remove all the physical dependencies on the old body. |
1108 | BulletSimAPI.DestroyHull(_scene.WorldID, _hullKey); | 1350 | // (Maybe someday make the changing of BSShape an event handled by BSLinkset.) |
1109 | _hullKey = 0; | 1351 | needToRestoreLinkset = Linkset.RemoveBodyDependencies(this); |
1110 | } | 1352 | needToRestoreVehicle = _vehicle.RemoveBodyDependencies(this); |
1111 | 1353 | }); | |
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 | 1354 | ||
1132 | // setup and do convex hull conversion | 1355 | if (needToRestoreLinkset) |
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 | { | 1356 | { |
1165 | totalVertices += 4; // add four for the vertex count and centroid | 1357 | // If physical body dependencies were removed, restore them |
1166 | totalVertices += cr.HullIndices.Count * 3; // we pass just triangles | 1358 | Linkset.RestoreBodyDependencies(this); |
1167 | } | 1359 | } |
1168 | float[] convHulls = new float[totalVertices]; | 1360 | if (needToRestoreVehicle) |
1169 | |||
1170 | convHulls[0] = (float)hullCount; | ||
1171 | int jj = 1; | ||
1172 | foreach (ConvexResult cr in _hulls) | ||
1173 | { | 1361 | { |
1174 | // copy vertices for index access | 1362 | // If physical body dependencies were removed, restore them |
1175 | float3[] verts = new float3[cr.HullVertices.Count]; | 1363 | _vehicle.RestoreBodyDependencies(this); |
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 | } | 1364 | } |
1194 | 1365 | ||
1195 | // create the hull definition in Bullet | 1366 | // Make sure the properties are set on the new object |
1196 | // m_log.DebugFormat("{0}: CreateGeom: calling CreateHull. lid={1}, key={2}, hulls={3}", LogHeader, _localID, _hullKey, hullCount); | 1367 | UpdatePhysicalParameters(); |
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 | ||
1233 | public void FillShapeInfo(out ShapeData shape) | ||
1234 | { | ||
1235 | shape.ID = _localID; | ||
1236 | shape.Type = _shapeType; | ||
1237 | shape.Position = _position; | ||
1238 | shape.Rotation = _orientation; | ||
1239 | shape.Velocity = _velocity; | ||
1240 | shape.Scale = _scale; | ||
1241 | shape.Mass = _isPhysical ? _mass : 0f; | ||
1242 | shape.Buoyancy = _buoyancy; | ||
1243 | shape.HullKey = _hullKey; | ||
1244 | shape.MeshKey = _meshKey; | ||
1245 | shape.Friction = _friction; | ||
1246 | shape.Restitution = _restitution; | ||
1247 | shape.Collidable = (!IsPhantom) ? ShapeData.numericTrue : ShapeData.numericFalse; | ||
1248 | shape.Static = _isPhysical ? ShapeData.numericFalse : ShapeData.numericTrue; | ||
1249 | } | ||
1250 | |||
1251 | |||
1252 | // Rebuild the geometry and object. | ||
1253 | // 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 | ||
1255 | private void RecreateGeomAndObject() | ||
1256 | { | ||
1257 | // m_log.DebugFormat("{0}: RecreateGeomAndObject. lID={1}", LogHeader, _localID); | ||
1258 | if (CreateGeom(true)) | ||
1259 | CreateObject(); | ||
1260 | return; | 1368 | return; |
1261 | } | 1369 | } |
1262 | 1370 | ||
@@ -1277,7 +1385,7 @@ public sealed class BSPrim : PhysicsActor | |||
1277 | const float ACCELERATION_TOLERANCE = 0.01f; | 1385 | const float ACCELERATION_TOLERANCE = 0.01f; |
1278 | const float ROTATIONAL_VELOCITY_TOLERANCE = 0.01f; | 1386 | const float ROTATIONAL_VELOCITY_TOLERANCE = 0.01f; |
1279 | 1387 | ||
1280 | public void UpdateProperties(EntityProperties entprop) | 1388 | public override void UpdateProperties(EntityProperties entprop) |
1281 | { | 1389 | { |
1282 | /* | 1390 | /* |
1283 | UpdatedProperties changed = 0; | 1391 | UpdatedProperties changed = 0; |
@@ -1325,7 +1433,7 @@ public sealed class BSPrim : PhysicsActor | |||
1325 | // Don't check for damping here -- it's done in BulletSim and SceneObjectPart. | 1433 | // Don't check for damping here -- it's done in BulletSim and SceneObjectPart. |
1326 | 1434 | ||
1327 | // Updates only for individual prims and for the root object of a linkset. | 1435 | // Updates only for individual prims and for the root object of a linkset. |
1328 | if (_linkset.IsRoot(this)) | 1436 | if (Linkset.IsRoot(this)) |
1329 | { | 1437 | { |
1330 | // Assign to the local variables so the normal set action does not happen | 1438 | // Assign to the local variables so the normal set action does not happen |
1331 | _position = entprop.Position; | 1439 | _position = entprop.Position; |
@@ -1334,69 +1442,32 @@ public sealed class BSPrim : PhysicsActor | |||
1334 | _acceleration = entprop.Acceleration; | 1442 | _acceleration = entprop.Acceleration; |
1335 | _rotationalVelocity = entprop.RotationalVelocity; | 1443 | _rotationalVelocity = entprop.RotationalVelocity; |
1336 | 1444 | ||
1337 | // m_log.DebugFormat("{0}: RequestTerseUpdate. id={1}, ch={2}, pos={3}, rot={4}, vel={5}, acc={6}, rvel={7}", | 1445 | // remember the current and last set values |
1338 | // LogHeader, LocalID, changed, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); | 1446 | LastEntityProperties = CurrentEntityProperties; |
1339 | // DetailLog("{0},BSPrim.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | 1447 | CurrentEntityProperties = entprop; |
1340 | // LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity); | 1448 | |
1449 | PositionSanityCheck(true); | ||
1450 | |||
1451 | OMV.Vector3 direction = OMV.Vector3.UnitX * _orientation; | ||
1452 | DetailLog("{0},BSPrim.UpdateProperties,call,pos={1},orient={2},dir={3},vel={4},rotVel={5}", | ||
1453 | LocalID, _position, _orientation, direction, _velocity, _rotationalVelocity); | ||
1454 | |||
1455 | // BulletSimAPI.DumpRigidBody2(PhysicsScene.World.ptr, BSBody.ptr); // DEBUG DEBUG DEBUG | ||
1341 | 1456 | ||
1342 | base.RequestPhysicsterseUpdate(); | 1457 | base.RequestPhysicsterseUpdate(); |
1343 | } | 1458 | } |
1344 | /* | 1459 | /* |
1345 | else | 1460 | else |
1346 | { | 1461 | { |
1347 | // For debugging, we also report the movement of children | 1462 | // For debugging, report the movement of children |
1348 | DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}", | 1463 | DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}", |
1349 | LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, | 1464 | LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, |
1350 | entprop.Acceleration, entprop.RotationalVelocity); | 1465 | entprop.Acceleration, entprop.RotationalVelocity); |
1351 | } | 1466 | } |
1352 | */ | 1467 | */ |
1353 | } | ||
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 | 1468 | ||
1377 | if (collisionCollection == null) | 1469 | // The linkset implimentation might want to know about this. |
1378 | collisionCollection = new CollisionEventUpdate(); | 1470 | Linkset.UpdateProperties(this); |
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 | } | 1471 | } |
1401 | } | 1472 | } |
1402 | } | 1473 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs index a31c578..2fee95e 100644 --- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs | |||
@@ -39,96 +39,88 @@ 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 sealed class BSScene : PhysicsScene, IPhysicsParameters |
72 | { | 66 | { |
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 | { | 101 | |
112 | get { return m_worldSim; } | 102 | // All the constraints that have been allocated in this instance. |
113 | } | 103 | public BSConstraintCollection Constraints { get; private set; } |
114 | private BSConstraintCollection m_constraintCollection; | ||
115 | public BSConstraintCollection Constraints | ||
116 | { | ||
117 | get { return m_constraintCollection; } | ||
118 | } | ||
119 | 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; | ||
118 | |||
119 | // Flag which is true when processing taints. | ||
120 | // Not guaranteed to be correct all the time (don't depend on this) but good for debugging. | ||
121 | public bool InTaintTime { get; private set; } | ||
131 | 122 | ||
123 | // Pinned memory used to pass step information between managed and unmanaged | ||
132 | private int m_maxCollisionsPerFrame; | 124 | private int m_maxCollisionsPerFrame; |
133 | private CollisionDesc[] m_collisionArray; | 125 | private CollisionDesc[] m_collisionArray; |
134 | private GCHandle m_collisionArrayPinnedHandle; | 126 | private GCHandle m_collisionArrayPinnedHandle; |
@@ -137,14 +129,19 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
137 | private EntityProperties[] m_updateArray; | 129 | private EntityProperties[] m_updateArray; |
138 | private GCHandle m_updateArrayPinnedHandle; | 130 | private GCHandle m_updateArrayPinnedHandle; |
139 | 131 | ||
140 | private bool _meshSculptedPrim = true; // cause scuplted prims to get meshed | 132 | 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 | 133 | public bool ShouldForceSimplePrimMeshing { get; private set; } // if a cube or sphere, let Bullet do internal shapes |
134 | public bool ShouldUseHullsForPhysicalObjects { get; private set; } // 'true' if should create hulls for physical objects | ||
142 | 135 | ||
143 | public float PID_D { get; private set; } // derivative | 136 | public float PID_D { get; private set; } // derivative |
144 | public float PID_P { get; private set; } // proportional | 137 | public float PID_P { get; private set; } // proportional |
145 | 138 | ||
146 | public const uint TERRAIN_ID = 0; // OpenSim senses terrain with a localID of zero | 139 | public const uint TERRAIN_ID = 0; // OpenSim senses terrain with a localID of zero |
147 | public const uint GROUNDPLANE_ID = 1; | 140 | public const uint GROUNDPLANE_ID = 1; |
141 | public const uint CHILDTERRAIN_ID = 2; // Terrain allocated based on our mega-prim childre start here | ||
142 | |||
143 | private float m_waterLevel; | ||
144 | public BSTerrainManager TerrainManager { get; private set; } | ||
148 | 145 | ||
149 | public ConfigurationParameters Params | 146 | public ConfigurationParameters Params |
150 | { | 147 | { |
@@ -154,13 +151,18 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
154 | { | 151 | { |
155 | get { return new Vector3(0f, 0f, Params.gravity); } | 152 | get { return new Vector3(0f, 0f, Params.gravity); } |
156 | } | 153 | } |
157 | 154 | // Just the Z value of the gravity | |
158 | private float m_maximumObjectMass; | 155 | public float DefaultGravityZ |
159 | public float MaximumObjectMass | ||
160 | { | 156 | { |
161 | get { return m_maximumObjectMass; } | 157 | get { return Params.gravity; } |
162 | } | 158 | } |
163 | 159 | ||
160 | public float MaximumObjectMass { get; private set; } | ||
161 | |||
162 | // When functions in the unmanaged code must be called, it is only | ||
163 | // done at a known time just before the simulation step. The taint | ||
164 | // system saves all these function calls and executes them in | ||
165 | // order before the simulation. | ||
164 | public delegate void TaintCallback(); | 166 | public delegate void TaintCallback(); |
165 | private struct TaintCallbackEntry | 167 | private struct TaintCallbackEntry |
166 | { | 168 | { |
@@ -172,15 +174,19 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
172 | callback = c; | 174 | callback = c; |
173 | } | 175 | } |
174 | } | 176 | } |
175 | private List<TaintCallbackEntry> _taintedObjects; | 177 | private Object _taintLock = new Object(); // lock for using the next object |
176 | private Object _taintLock = new Object(); | 178 | private List<TaintCallbackEntry> _taintOperations; |
179 | private Dictionary<string, TaintCallbackEntry> _postTaintOperations; | ||
180 | private List<TaintCallbackEntry> _postStepOperations; | ||
177 | 181 | ||
178 | // A pointer to an instance if this structure is passed to the C++ code | 182 | // A pointer to an instance if this structure is passed to the C++ code |
183 | // Used to pass basic configuration values to the unmanaged code. | ||
179 | ConfigurationParameters[] m_params; | 184 | ConfigurationParameters[] m_params; |
180 | GCHandle m_paramsHandle; | 185 | GCHandle m_paramsHandle; |
181 | 186 | ||
182 | public bool ShouldDebugLog { get; private set; } | 187 | // Handle to the callback used by the unmanaged code to call into the managed code. |
183 | 188 | // Used for debug logging. | |
189 | // Need to store the handle in a persistant variable so it won't be freed. | ||
184 | private BulletSimAPI.DebugLogCallback m_DebugLogCallbackHandle; | 190 | private BulletSimAPI.DebugLogCallback m_DebugLogCallbackHandle; |
185 | 191 | ||
186 | // Sometimes you just have to log everything. | 192 | // Sometimes you just have to log everything. |
@@ -189,17 +195,26 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
189 | private string m_physicsLoggingDir; | 195 | private string m_physicsLoggingDir; |
190 | private string m_physicsLoggingPrefix; | 196 | private string m_physicsLoggingPrefix; |
191 | private int m_physicsLoggingFileMinutes; | 197 | private int m_physicsLoggingFileMinutes; |
198 | // 'true' of the vehicle code is to log lots of details | ||
199 | public bool VehicleLoggingEnabled { get; private set; } | ||
192 | 200 | ||
193 | private bool m_vehicleLoggingEnabled; | 201 | #region Construction and Initialization |
194 | public bool VehicleLoggingEnabled { get { return m_vehicleLoggingEnabled; } } | ||
195 | |||
196 | public BSScene(string identifier) | 202 | public BSScene(string identifier) |
197 | { | 203 | { |
198 | m_initialized = false; | 204 | m_initialized = false; |
205 | // we are passed the name of the region we're working for. | ||
206 | RegionName = identifier; | ||
199 | } | 207 | } |
200 | 208 | ||
201 | public override void Initialise(IMesher meshmerizer, IConfigSource config) | 209 | public override void Initialise(IMesher meshmerizer, IConfigSource config) |
202 | { | 210 | { |
211 | mesher = meshmerizer; | ||
212 | _taintOperations = new List<TaintCallbackEntry>(); | ||
213 | _postTaintOperations = new Dictionary<string, TaintCallbackEntry>(); | ||
214 | _postStepOperations = new List<TaintCallbackEntry>(); | ||
215 | PhysObjects = new Dictionary<uint, BSPhysObject>(); | ||
216 | Shapes = new BSShapeCollection(this); | ||
217 | |||
203 | // Allocate pinned memory to pass parameters. | 218 | // Allocate pinned memory to pass parameters. |
204 | m_params = new ConfigurationParameters[1]; | 219 | m_params = new ConfigurationParameters[1]; |
205 | m_paramsHandle = GCHandle.Alloc(m_params, GCHandleType.Pinned); | 220 | m_paramsHandle = GCHandle.Alloc(m_params, GCHandleType.Pinned); |
@@ -215,7 +230,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
215 | 230 | ||
216 | // Enable very detailed logging. | 231 | // Enable very detailed logging. |
217 | // By creating an empty logger when not logging, the log message invocation code | 232 | // 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. | 233 | // can be left in and every call doesn't have to check for null. |
219 | if (m_physicsLoggingEnabled) | 234 | if (m_physicsLoggingEnabled) |
220 | { | 235 | { |
221 | PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes); | 236 | PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes); |
@@ -225,39 +240,43 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
225 | PhysicsLogging = new Logging.LogWriter(); | 240 | PhysicsLogging = new Logging.LogWriter(); |
226 | } | 241 | } |
227 | 242 | ||
228 | // Get the version of the DLL | 243 | // If Debug logging level, enable logging from the unmanaged code |
229 | // TODO: this doesn't work yet. Something wrong with marshaling the returned string. | 244 | 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) | 245 | if (m_log.IsDebugEnabled || PhysicsLogging.Enabled) |
235 | { | 246 | { |
236 | m_log.DebugFormat("{0}: Initialize: Setting debug callback for unmanaged code", LogHeader); | 247 | m_log.DebugFormat("{0}: Initialize: Setting debug callback for unmanaged code", LogHeader); |
237 | if (PhysicsLogging.Enabled) | 248 | if (PhysicsLogging.Enabled) |
249 | // 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); | 250 | m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLoggerPhysLog); |
239 | else | 251 | else |
240 | m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLogger); | 252 | 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 | } | 253 | } |
244 | 254 | ||
245 | _taintedObjects = new List<TaintCallbackEntry>(); | 255 | // Get the version of the DLL |
256 | // TODO: this doesn't work yet. Something wrong with marshaling the returned string. | ||
257 | // BulletSimVersion = BulletSimAPI.GetVersion(); | ||
258 | // m_log.WarnFormat("{0}: BulletSim.dll version='{1}'", LogHeader, BulletSimVersion); | ||
246 | 259 | ||
247 | mesher = meshmerizer; | 260 | // The bounding box for the simulated world. The origin is 0,0,0 unless we're |
248 | // The bounding box for the simulated world | 261 | // a child in a mega-region. |
249 | Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, 8192f); | 262 | // Bullet actually doesn't care about the extents of the simulated |
263 | // area. It tracks active objects no matter where they are. | ||
264 | Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight); | ||
250 | 265 | ||
251 | // m_log.DebugFormat("{0}: Initialize: Calling BulletSimAPI.Initialize.", LogHeader); | 266 | // m_log.DebugFormat("{0}: Initialize: Calling BulletSimAPI.Initialize.", LogHeader); |
252 | m_worldID = BulletSimAPI.Initialize(worldExtent, m_paramsHandle.AddrOfPinnedObject(), | 267 | World = new BulletSim(0, this, BulletSimAPI.Initialize2(worldExtent, m_paramsHandle.AddrOfPinnedObject(), |
253 | m_maxCollisionsPerFrame, m_collisionArrayPinnedHandle.AddrOfPinnedObject(), | 268 | m_maxCollisionsPerFrame, m_collisionArrayPinnedHandle.AddrOfPinnedObject(), |
254 | m_maxUpdatesPerFrame, m_updateArrayPinnedHandle.AddrOfPinnedObject()); | 269 | m_maxUpdatesPerFrame, m_updateArrayPinnedHandle.AddrOfPinnedObject(), |
270 | m_DebugLogCallbackHandle)); | ||
271 | |||
272 | Constraints = new BSConstraintCollection(World); | ||
255 | 273 | ||
256 | // Initialization to support the transition to a new API which puts most of the logic | 274 | TerrainManager = new BSTerrainManager(this); |
257 | // into the C# code so it is easier to modify and add to. | 275 | TerrainManager.CreateInitialGroundPlaneAndTerrain(); |
258 | m_worldSim = new BulletSim(m_worldID, this, BulletSimAPI.GetSimHandle2(m_worldID)); | ||
259 | m_constraintCollection = new BSConstraintCollection(World); | ||
260 | 276 | ||
277 | m_log.WarnFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)Params.linksetImplementation); | ||
278 | |||
279 | InTaintTime = false; | ||
261 | m_initialized = true; | 280 | m_initialized = true; |
262 | } | 281 | } |
263 | 282 | ||
@@ -281,10 +300,13 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
281 | // Very detailed logging for physics debugging | 300 | // Very detailed logging for physics debugging |
282 | m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false); | 301 | m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false); |
283 | m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", "."); | 302 | m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", "."); |
284 | m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-"); | 303 | m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-%REGIONNAME%-"); |
285 | m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5); | 304 | m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5); |
286 | // Very detailed logging for vehicle debugging | 305 | // Very detailed logging for vehicle debugging |
287 | m_vehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false); | 306 | VehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false); |
307 | |||
308 | // Do any replacements in the parameters | ||
309 | m_physicsLoggingPrefix = m_physicsLoggingPrefix.Replace("%REGIONNAME%", RegionName); | ||
288 | } | 310 | } |
289 | } | 311 | } |
290 | } | 312 | } |
@@ -309,13 +331,51 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
309 | { | 331 | { |
310 | m_log.Debug("[BULLETS UNMANAGED]:" + msg); | 332 | m_log.Debug("[BULLETS UNMANAGED]:" + msg); |
311 | } | 333 | } |
312 | 334 | ||
313 | // Called directly from unmanaged code so don't do much | 335 | // Called directly from unmanaged code so don't do much |
314 | private void BulletLoggerPhysLog(string msg) | 336 | private void BulletLoggerPhysLog(string msg) |
315 | { | 337 | { |
316 | PhysicsLogging.Write("[BULLETS UNMANAGED]:" + msg); | 338 | DetailLog("[BULLETS UNMANAGED]:" + msg); |
317 | } | 339 | } |
318 | 340 | ||
341 | public override void Dispose() | ||
342 | { | ||
343 | // m_log.DebugFormat("{0}: Dispose()", LogHeader); | ||
344 | |||
345 | // make sure no stepping happens while we're deleting stuff | ||
346 | m_initialized = false; | ||
347 | |||
348 | TerrainManager.ReleaseGroundPlaneAndTerrain(); | ||
349 | |||
350 | foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects) | ||
351 | { | ||
352 | kvp.Value.Destroy(); | ||
353 | } | ||
354 | PhysObjects.Clear(); | ||
355 | |||
356 | // Now that the prims are all cleaned up, there should be no constraints left | ||
357 | if (Constraints != null) | ||
358 | { | ||
359 | Constraints.Dispose(); | ||
360 | Constraints = null; | ||
361 | } | ||
362 | |||
363 | if (Shapes != null) | ||
364 | { | ||
365 | Shapes.Dispose(); | ||
366 | Shapes = null; | ||
367 | } | ||
368 | |||
369 | // Anything left in the unmanaged code should be cleaned out | ||
370 | BulletSimAPI.Shutdown2(World.ptr); | ||
371 | |||
372 | // Not logging any more | ||
373 | PhysicsLogging.Close(); | ||
374 | } | ||
375 | #endregion // Construction and Initialization | ||
376 | |||
377 | #region Prim and Avatar addition and removal | ||
378 | |||
319 | public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying) | 379 | public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying) |
320 | { | 380 | { |
321 | m_log.ErrorFormat("{0}: CALL TO AddAvatar in BSScene. NOT IMPLEMENTED", LogHeader); | 381 | m_log.ErrorFormat("{0}: CALL TO AddAvatar in BSScene. NOT IMPLEMENTED", LogHeader); |
@@ -329,7 +389,13 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
329 | if (!m_initialized) return null; | 389 | if (!m_initialized) return null; |
330 | 390 | ||
331 | BSCharacter actor = new BSCharacter(localID, avName, this, position, size, isFlying); | 391 | BSCharacter actor = new BSCharacter(localID, avName, this, position, size, isFlying); |
332 | lock (m_avatars) m_avatars.Add(localID, actor); | 392 | lock (PhysObjects) PhysObjects.Add(localID, actor); |
393 | |||
394 | // TODO: Remove kludge someday. | ||
395 | // We must generate a collision for avatars whether they collide or not. | ||
396 | // This is required by OpenSim to update avatar animations, etc. | ||
397 | lock (m_avatars) m_avatars.Add(actor); | ||
398 | |||
333 | return actor; | 399 | return actor; |
334 | } | 400 | } |
335 | 401 | ||
@@ -344,7 +410,9 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
344 | { | 410 | { |
345 | try | 411 | try |
346 | { | 412 | { |
347 | lock (m_avatars) m_avatars.Remove(actor.LocalID); | 413 | lock (PhysObjects) PhysObjects.Remove(actor.LocalID); |
414 | // Remove kludge someday | ||
415 | lock (m_avatars) m_avatars.Remove(bsactor); | ||
348 | } | 416 | } |
349 | catch (Exception e) | 417 | catch (Exception e) |
350 | { | 418 | { |
@@ -362,11 +430,11 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
362 | BSPrim bsprim = prim as BSPrim; | 430 | BSPrim bsprim = prim as BSPrim; |
363 | if (bsprim != null) | 431 | if (bsprim != null) |
364 | { | 432 | { |
365 | // DetailLog("{0},RemovePrim,call", bsprim.LocalID); | 433 | DetailLog("{0},RemovePrim,call", bsprim.LocalID); |
366 | // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID); | 434 | // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID); |
367 | try | 435 | try |
368 | { | 436 | { |
369 | lock (m_prims) m_prims.Remove(bsprim.LocalID); | 437 | lock (PhysObjects) PhysObjects.Remove(bsprim.LocalID); |
370 | } | 438 | } |
371 | catch (Exception e) | 439 | catch (Exception e) |
372 | { | 440 | { |
@@ -388,18 +456,21 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
388 | 456 | ||
389 | if (!m_initialized) return null; | 457 | if (!m_initialized) return null; |
390 | 458 | ||
391 | // DetailLog("{0},AddPrimShape,call", localID); | 459 | DetailLog("{0},AddPrimShape,call", localID); |
392 | 460 | ||
393 | BSPrim prim = new BSPrim(localID, primName, this, position, size, rotation, pbs, isPhysical); | 461 | BSPrim prim = new BSPrim(localID, primName, this, position, size, rotation, pbs, isPhysical); |
394 | lock (m_prims) m_prims.Add(localID, prim); | 462 | lock (PhysObjects) PhysObjects.Add(localID, prim); |
395 | return prim; | 463 | return prim; |
396 | } | 464 | } |
397 | 465 | ||
398 | // This is a call from the simulator saying that some physical property has been updated. | 466 | // 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 | 467 | // The BulletSim driver senses the changing of relevant properties so this taint |
400 | // information call is not needed. | 468 | // information call is not needed. |
401 | public override void AddPhysicsActorTaint(PhysicsActor prim) { } | 469 | public override void AddPhysicsActorTaint(PhysicsActor prim) { } |
402 | 470 | ||
471 | #endregion // Prim and Avatar addition and removal | ||
472 | |||
473 | #region Simulation | ||
403 | // Simulate one timestep | 474 | // Simulate one timestep |
404 | public override float Simulate(float timeStep) | 475 | public override float Simulate(float timeStep) |
405 | { | 476 | { |
@@ -408,14 +479,14 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
408 | int collidersCount = 0; | 479 | int collidersCount = 0; |
409 | IntPtr collidersPtr; | 480 | IntPtr collidersPtr; |
410 | 481 | ||
411 | LastSimulatedTimestep = timeStep; | 482 | int beforeTime = 0; |
483 | int simTime = 0; | ||
412 | 484 | ||
413 | // prevent simulation until we've been initialized | 485 | // prevent simulation until we've been initialized |
414 | if (!m_initialized) return 10.0f; | 486 | if (!m_initialized) return 5.0f; |
415 | |||
416 | int simulateStartTime = Util.EnvironmentTickCount(); | ||
417 | 487 | ||
418 | // update the prim states while we know the physics engine is not busy | 488 | // update the prim states while we know the physics engine is not busy |
489 | int numTaints = _taintOperations.Count; | ||
419 | ProcessTaints(); | 490 | ProcessTaints(); |
420 | 491 | ||
421 | // Some of the prims operate with special vehicle properties | 492 | // Some of the prims operate with special vehicle properties |
@@ -425,25 +496,34 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
425 | // step the physical world one interval | 496 | // step the physical world one interval |
426 | m_simulationStep++; | 497 | m_simulationStep++; |
427 | int numSubSteps = 0; | 498 | int numSubSteps = 0; |
499 | |||
428 | try | 500 | try |
429 | { | 501 | { |
430 | numSubSteps = BulletSimAPI.PhysicsStep(m_worldID, timeStep, m_maxSubSteps, m_fixedTimeStep, | 502 | if (VehicleLoggingEnabled) DumpVehicles(); // DEBUG |
503 | if (PhysicsLogging.Enabled) beforeTime = Util.EnvironmentTickCount(); | ||
504 | |||
505 | numSubSteps = BulletSimAPI.PhysicsStep2(World.ptr, timeStep, m_maxSubSteps, m_fixedTimeStep, | ||
431 | out updatedEntityCount, out updatedEntitiesPtr, out collidersCount, out collidersPtr); | 506 | out updatedEntityCount, out updatedEntitiesPtr, out collidersCount, out collidersPtr); |
432 | // DetailLog("{0},Simulate,call, substeps={1}, updates={2}, colliders={3}", DetailLogZero, numSubSteps, updatedEntityCount, collidersCount); | 507 | |
508 | if (PhysicsLogging.Enabled) simTime = Util.EnvironmentTickCountSubtract(beforeTime); | ||
509 | DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}", | ||
510 | DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps, updatedEntityCount, collidersCount); | ||
511 | if (VehicleLoggingEnabled) DumpVehicles(); // DEBUG | ||
433 | } | 512 | } |
434 | catch (Exception e) | 513 | catch (Exception e) |
435 | { | 514 | { |
436 | m_log.WarnFormat("{0},PhysicsStep Exception: substeps={1}, updates={2}, colliders={3}, e={4}", LogHeader, numSubSteps, updatedEntityCount, collidersCount, e); | 515 | 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); | 516 | LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e); |
438 | // updatedEntityCount = 0; | 517 | DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}", |
518 | DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount); | ||
519 | updatedEntityCount = 0; | ||
439 | collidersCount = 0; | 520 | collidersCount = 0; |
440 | } | 521 | } |
441 | 522 | ||
442 | |||
443 | // Don't have to use the pointers passed back since we know it is the same pinned memory we passed in | 523 | // Don't have to use the pointers passed back since we know it is the same pinned memory we passed in |
444 | 524 | ||
445 | // Get a value for 'now' so all the collision and update routines don't have to get their own | 525 | // Get a value for 'now' so all the collision and update routines don't have to get their own |
446 | m_simulationNowTime = Util.EnvironmentTickCount(); | 526 | SimulationNowTime = Util.EnvironmentTickCount(); |
447 | 527 | ||
448 | // If there were collisions, process them by sending the event to the prim. | 528 | // If there were collisions, process them by sending the event to the prim. |
449 | // Collisions must be processed before updates. | 529 | // Collisions must be processed before updates. |
@@ -462,19 +542,32 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
462 | 542 | ||
463 | // The above SendCollision's batch up the collisions on the objects. | 543 | // The above SendCollision's batch up the collisions on the objects. |
464 | // Now push the collisions into the simulator. | 544 | // Now push the collisions into the simulator. |
465 | foreach (BSPrim bsp in m_primsWithCollisions) | 545 | if (ObjectsWithCollisions.Count > 0) |
466 | bsp.SendCollisions(); | 546 | { |
467 | m_primsWithCollisions.Clear(); | 547 | foreach (BSPhysObject bsp in ObjectsWithCollisions) |
468 | 548 | if (!bsp.SendCollisions()) | |
469 | // This is a kludge to get avatar movement updated. | 549 | { |
470 | // Don't send collisions only if there were collisions -- send everytime. | 550 | // If the object is done colliding, see that it's removed from the colliding list |
471 | // ODE sends collisions even if there are none and this is used to update | 551 | ObjectsWithNoMoreCollisions.Add(bsp); |
472 | // avatar animations and stuff. | 552 | } |
473 | // foreach (BSCharacter bsc in m_avatarsWithCollisions) | 553 | } |
474 | // bsc.SendCollisions(); | 554 | |
475 | foreach (KeyValuePair<uint, BSCharacter> kvp in m_avatars) | 555 | // This is a kludge to get avatar movement updates. |
476 | kvp.Value.SendCollisions(); | 556 | // The simulator expects collisions for avatars even if there are have been no collisions. |
477 | m_avatarsWithCollisions.Clear(); | 557 | // The event updates avatar animations and stuff. |
558 | // If you fix avatar animation updates, remove this overhead and let normal collision processing happen. | ||
559 | foreach (BSPhysObject bsp in m_avatars) | ||
560 | if (!ObjectsWithCollisions.Contains(bsp)) // don't call avatars twice | ||
561 | bsp.SendCollisions(); | ||
562 | |||
563 | // Objects that are done colliding are removed from the ObjectsWithCollisions list. | ||
564 | // Not done above because it is inside an iteration of ObjectWithCollisions. | ||
565 | if (ObjectsWithNoMoreCollisions.Count > 0) | ||
566 | { | ||
567 | foreach (BSPhysObject po in ObjectsWithNoMoreCollisions) | ||
568 | ObjectsWithCollisions.Remove(po); | ||
569 | ObjectsWithNoMoreCollisions.Clear(); | ||
570 | } | ||
478 | 571 | ||
479 | // If any of the objects had updated properties, tell the object it has been changed by the physics engine | 572 | // If any of the objects had updated properties, tell the object it has been changed by the physics engine |
480 | if (updatedEntityCount > 0) | 573 | if (updatedEntityCount > 0) |
@@ -482,320 +575,316 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
482 | for (int ii = 0; ii < updatedEntityCount; ii++) | 575 | for (int ii = 0; ii < updatedEntityCount; ii++) |
483 | { | 576 | { |
484 | EntityProperties entprop = m_updateArray[ii]; | 577 | EntityProperties entprop = m_updateArray[ii]; |
485 | BSPrim prim; | 578 | BSPhysObject pobj; |
486 | if (m_prims.TryGetValue(entprop.ID, out prim)) | 579 | 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 | { | 580 | { |
494 | actor.UpdateProperties(entprop); | 581 | pobj.UpdateProperties(entprop); |
495 | continue; | ||
496 | } | 582 | } |
497 | } | 583 | } |
498 | } | 584 | } |
499 | 585 | ||
500 | // If enabled, call into the physics engine to dump statistics | 586 | ProcessPostStepTaints(); |
501 | if (m_detailedStatsStep > 0) | ||
502 | { | ||
503 | if ((m_simulationStep % m_detailedStatsStep) == 0) | ||
504 | { | ||
505 | BulletSimAPI.DumpBulletStatistics(); | ||
506 | } | ||
507 | } | ||
508 | 587 | ||
509 | // this is a waste since the outside routine also calcuates the physics simulation | 588 | // This causes the unmanaged code to output ALL the values found in ALL the objects in the world. |
510 | // period. TODO: There should be a way of computing physics frames from simulator computation. | 589 | // Only enable this in a limited test world with few objects. |
511 | // long simulateTotalTime = Util.EnvironmentTickCountSubtract(simulateStartTime); | 590 | // BulletSimAPI.DumpAllInfo2(World.ptr); // DEBUG DEBUG DEBUG |
512 | // return (timeStep * (float)simulateTotalTime); | 591 | |
513 | 592 | // The physics engine returns the number of milliseconds it simulated this call. | |
514 | // TODO: FIX THIS: fps calculation possibly wrong. | 593 | // These are summed and normalized to one second and divided by 1000 to give the reported physics FPS. |
515 | // This calculation says 1/timeStep is the ideal frame rate. Any time added to | 594 | // We multiply by 55 to give a recognizable running rate (55 or less). |
516 | // that by the physics simulation gives a slower frame rate. | 595 | return numSubSteps * m_fixedTimeStep * 1000 * 55; |
517 | long totalSimulationTime = Util.EnvironmentTickCountSubtract(simulateStartTime); | 596 | // return timeStep * 1000 * 55; |
518 | if (totalSimulationTime >= timeStep) | ||
519 | return 0; | ||
520 | return 1f / (timeStep + totalSimulationTime); | ||
521 | } | 597 | } |
522 | 598 | ||
523 | // Something has collided | 599 | // Something has collided |
524 | private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penitration) | 600 | private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penetration) |
525 | { | 601 | { |
526 | if (localID == TERRAIN_ID || localID == GROUNDPLANE_ID) | 602 | if (localID <= TerrainManager.HighestTerrainID) |
527 | { | 603 | { |
528 | return; // don't send collisions to the terrain | 604 | return; // don't send collisions to the terrain |
529 | } | 605 | } |
530 | 606 | ||
531 | ActorTypes type = ActorTypes.Prim; | 607 | BSPhysObject collider; |
532 | if (collidingWith == TERRAIN_ID || collidingWith == GROUNDPLANE_ID) | 608 | if (!PhysObjects.TryGetValue(localID, out collider)) |
533 | type = ActorTypes.Ground; | 609 | { |
534 | else if (m_avatars.ContainsKey(collidingWith)) | 610 | // If the object that is colliding cannot be found, just ignore the collision. |
535 | type = ActorTypes.Agent; | 611 | 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; | 612 | return; |
542 | } | 613 | } |
543 | BSCharacter actor; | 614 | |
544 | if (m_avatars.TryGetValue(localID, out actor)) { | 615 | // 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); | 616 | BSPhysObject collidee = null; |
546 | m_avatarsWithCollisions.Add(actor); | 617 | PhysObjects.TryGetValue(collidingWith, out collidee); |
547 | return; | 618 | |
619 | // DetailLog("{0},BSScene.SendCollision,collide,id={1},with={2}", DetailLogZero, localID, collidingWith); | ||
620 | |||
621 | if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration)) | ||
622 | { | ||
623 | // If a collision was posted, remember to send it to the simulator | ||
624 | ObjectsWithCollisions.Add(collider); | ||
548 | } | 625 | } |
626 | |||
549 | return; | 627 | return; |
550 | } | 628 | } |
551 | 629 | ||
630 | #endregion // Simulation | ||
631 | |||
552 | public override void GetResults() { } | 632 | public override void GetResults() { } |
553 | 633 | ||
634 | #region Terrain | ||
635 | |||
554 | public override void SetTerrain(float[] heightMap) { | 636 | public override void SetTerrain(float[] heightMap) { |
555 | m_heightMap = heightMap; | 637 | TerrainManager.SetTerrain(heightMap); |
556 | this.TaintedObject("BSScene.SetTerrain", delegate() | ||
557 | { | ||
558 | BulletSimAPI.SetHeightmap(m_worldID, m_heightMap); | ||
559 | }); | ||
560 | } | 638 | } |
561 | 639 | ||
562 | // Someday we will have complex terrain with caves and tunnels | 640 | public override void SetWaterLevel(float baseheight) |
563 | // For the moment, it's flat and convex | ||
564 | public float GetTerrainHeightAtXYZ(Vector3 loc) | ||
565 | { | 641 | { |
566 | return GetTerrainHeightAtXY(loc.X, loc.Y); | 642 | m_waterLevel = baseheight; |
643 | } | ||
644 | // Someday.... | ||
645 | public float GetWaterLevelAtXYZ(Vector3 loc) | ||
646 | { | ||
647 | return m_waterLevel; | ||
567 | } | 648 | } |
568 | 649 | ||
569 | public float GetTerrainHeightAtXY(float tX, float tY) | 650 | public override void DeleteTerrain() |
570 | { | 651 | { |
571 | if (tX < 0 || tX >= Constants.RegionSize || tY < 0 || tY >= Constants.RegionSize) | 652 | // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader); |
572 | return 30; | ||
573 | return m_heightMap[((int)tX) * Constants.RegionSize + ((int)tY)]; | ||
574 | } | 653 | } |
575 | 654 | ||
576 | public override void SetWaterLevel(float baseheight) | 655 | // Although no one seems to check this, I do support combining. |
656 | public override bool SupportsCombining() | ||
577 | { | 657 | { |
578 | m_waterLevel = baseheight; | 658 | return TerrainManager.SupportsCombining(); |
579 | // TODO: pass to physics engine so things will float? | ||
580 | } | 659 | } |
581 | public float GetWaterLevel() | 660 | // This call says I am a child to region zero in a mega-region. 'pScene' is that |
661 | // of region zero, 'offset' is my offset from regions zero's origin, and | ||
662 | // 'extents' is the largest XY that is handled in my region. | ||
663 | public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents) | ||
582 | { | 664 | { |
583 | return m_waterLevel; | 665 | TerrainManager.Combine(pScene, offset, extents); |
584 | } | 666 | } |
585 | 667 | ||
586 | public override void DeleteTerrain() | 668 | // Unhook all the combining that I know about. |
669 | public override void UnCombine(PhysicsScene pScene) | ||
587 | { | 670 | { |
588 | // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader); | 671 | TerrainManager.UnCombine(pScene); |
589 | } | 672 | } |
590 | 673 | ||
591 | public override void Dispose() | 674 | #endregion // Terrain |
675 | |||
676 | public override Dictionary<uint, float> GetTopColliders() | ||
592 | { | 677 | { |
593 | // m_log.DebugFormat("{0}: Dispose()", LogHeader); | 678 | return new Dictionary<uint, float>(); |
679 | } | ||
594 | 680 | ||
595 | // make sure no stepping happens while we're deleting stuff | 681 | public override bool IsThreaded { get { return false; } } |
596 | m_initialized = false; | ||
597 | 682 | ||
598 | foreach (KeyValuePair<uint, BSCharacter> kvp in m_avatars) | 683 | #region Taints |
599 | { | ||
600 | kvp.Value.Destroy(); | ||
601 | } | ||
602 | m_avatars.Clear(); | ||
603 | 684 | ||
604 | foreach (KeyValuePair<uint, BSPrim> kvp in m_prims) | 685 | // Calls to the PhysicsActors can't directly call into the physics engine |
605 | { | 686 | // because it might be busy. We delay changes to a known time. |
606 | kvp.Value.Destroy(); | 687 | // We rely on C#'s closure to save and restore the context for the delegate. |
607 | } | 688 | public void TaintedObject(String ident, TaintCallback callback) |
608 | m_prims.Clear(); | 689 | { |
690 | if (!m_initialized) return; | ||
609 | 691 | ||
610 | // Now that the prims are all cleaned up, there should be no constraints left | 692 | lock (_taintLock) |
611 | if (m_constraintCollection != null) | ||
612 | { | 693 | { |
613 | m_constraintCollection.Dispose(); | 694 | _taintOperations.Add(new TaintCallbackEntry(ident, callback)); |
614 | m_constraintCollection = null; | ||
615 | } | 695 | } |
616 | 696 | ||
617 | // Anything left in the unmanaged code should be cleaned out | 697 | return; |
618 | BulletSimAPI.Shutdown(WorldID); | ||
619 | |||
620 | // Not logging any more | ||
621 | PhysicsLogging.Close(); | ||
622 | } | 698 | } |
623 | 699 | ||
624 | public override Dictionary<uint, float> GetTopColliders() | 700 | // Sometimes a potentially tainted operation can be used in and out of taint time. |
701 | // This routine executes the command immediately if in taint-time otherwise it is queued. | ||
702 | public void TaintedObject(bool inTaintTime, string ident, TaintCallback callback) | ||
625 | { | 703 | { |
626 | return new Dictionary<uint, float>(); | 704 | if (inTaintTime) |
705 | callback(); | ||
706 | else | ||
707 | TaintedObject(ident, callback); | ||
627 | } | 708 | } |
628 | 709 | ||
629 | public override bool IsThreaded { get { return false; } } | 710 | // When someone tries to change a property on a BSPrim or BSCharacter, the object queues |
630 | 711 | // a callback into itself to do the actual property change. That callback is called | |
631 | /// <summary> | 712 | // here just before the physics engine is called to step the simulation. |
632 | /// Routine to figure out if we need to mesh this prim with our mesher | 713 | public void ProcessTaints() |
633 | /// </summary> | ||
634 | /// <param name="pbs"></param> | ||
635 | /// <returns>true if the prim needs meshing</returns> | ||
636 | public bool NeedsMeshing(PrimitiveBaseShape pbs) | ||
637 | { | 714 | { |
638 | // most of this is redundant now as the mesher will return null if it cant mesh a prim | 715 | InTaintTime = true; |
639 | // but we still need to check for sculptie meshing being enabled so this is the most | 716 | ProcessRegularTaints(); |
640 | // convenient place to do it for now... | 717 | ProcessPostTaintTaints(); |
641 | 718 | InTaintTime = false; | |
642 | // int iPropertiesNotSupportedDefault = 0; | 719 | } |
643 | |||
644 | if (pbs.SculptEntry && !_meshSculptedPrim) | ||
645 | { | ||
646 | // Render sculpties as boxes | ||
647 | return false; | ||
648 | } | ||
649 | 720 | ||
650 | // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since Bullet | 721 | private void ProcessRegularTaints() |
651 | // can use an internal representation for the prim | 722 | { |
652 | if (!_forceSimplePrimMeshing) | 723 | if (_taintOperations.Count > 0) // save allocating new list if there is nothing to process |
653 | { | 724 | { |
654 | if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight) | 725 | /* |
655 | || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 | 726 | // Code to limit the number of taints processed per step. Meant to limit step time. |
656 | && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z)) | 727 | // Unsure if a good idea as code assumes that taints are done before the step. |
728 | int taintCount = m_taintsToProcessPerStep; | ||
729 | TaintCallbackEntry oneCallback = new TaintCallbackEntry(); | ||
730 | while (_taintOperations.Count > 0 && taintCount-- > 0) | ||
657 | { | 731 | { |
658 | 732 | bool gotOne = false; | |
659 | if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0 | 733 | lock (_taintLock) |
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 | { | 734 | { |
667 | return false; | 735 | if (_taintOperations.Count > 0) |
736 | { | ||
737 | oneCallback = _taintOperations[0]; | ||
738 | _taintOperations.RemoveAt(0); | ||
739 | gotOne = true; | ||
740 | } | ||
741 | } | ||
742 | if (gotOne) | ||
743 | { | ||
744 | try | ||
745 | { | ||
746 | DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, oneCallback.ident); | ||
747 | oneCallback.callback(); | ||
748 | } | ||
749 | catch (Exception e) | ||
750 | { | ||
751 | DetailLog("{0},BSScene.ProcessTaints,doTaintException,id={1}", DetailLogZero, oneCallback.ident); // DEBUG DEBUG DEBUG | ||
752 | m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, oneCallback.ident, e); | ||
753 | } | ||
668 | } | 754 | } |
669 | } | 755 | } |
670 | } | 756 | if (_taintOperations.Count > 0) |
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 | { | 757 | { |
705 | iPropertiesNotSupportedDefault++; | 758 | DetailLog("{0},BSScene.ProcessTaints,leftTaintsOnList,numNotProcessed={1}", DetailLogZero, _taintOperations.Count); |
706 | } | 759 | } |
707 | } | 760 | */ |
708 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle) | 761 | // swizzle a new list into the list location so we can process what's there |
709 | { | 762 | List<TaintCallbackEntry> oldList; |
710 | if (pbs.PathCurve == (byte)Extrusion.Straight) | 763 | lock (_taintLock) |
711 | { | 764 | { |
712 | iPropertiesNotSupportedDefault++; | 765 | oldList = _taintOperations; |
766 | _taintOperations = new List<TaintCallbackEntry>(); | ||
713 | } | 767 | } |
714 | // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits | 768 | |
715 | else if (pbs.PathCurve == (byte)Extrusion.Curve1) | 769 | foreach (TaintCallbackEntry tcbe in oldList) |
716 | { | 770 | { |
717 | iPropertiesNotSupportedDefault++; | 771 | try |
772 | { | ||
773 | DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG | ||
774 | tcbe.callback(); | ||
775 | } | ||
776 | catch (Exception e) | ||
777 | { | ||
778 | m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e); | ||
779 | } | ||
718 | } | 780 | } |
781 | oldList.Clear(); | ||
719 | } | 782 | } |
720 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle) | 783 | } |
784 | |||
785 | // Schedule an update to happen after all the regular taints are processed. | ||
786 | // Note that new requests for the same operation ("ident") for the same object ("ID") | ||
787 | // will replace any previous operation by the same object. | ||
788 | public void PostTaintObject(String ident, uint ID, TaintCallback callback) | ||
789 | { | ||
790 | if (!m_initialized) return; | ||
791 | |||
792 | string uniqueIdent = ident + "-" + ID.ToString(); | ||
793 | lock (_taintLock) | ||
721 | { | 794 | { |
722 | if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2) | 795 | _postTaintOperations[uniqueIdent] = new TaintCallbackEntry(uniqueIdent, callback); |
723 | { | ||
724 | iPropertiesNotSupportedDefault++; | ||
725 | } | ||
726 | } | 796 | } |
727 | else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle) | 797 | |
798 | return; | ||
799 | } | ||
800 | |||
801 | private void ProcessPostTaintTaints() | ||
802 | { | ||
803 | if (_postTaintOperations.Count > 0) | ||
728 | { | 804 | { |
729 | if (pbs.PathCurve == (byte)Extrusion.Straight) | 805 | Dictionary<string, TaintCallbackEntry> oldList; |
806 | lock (_taintLock) | ||
730 | { | 807 | { |
731 | iPropertiesNotSupportedDefault++; | 808 | oldList = _postTaintOperations; |
809 | _postTaintOperations = new Dictionary<string, TaintCallbackEntry>(); | ||
732 | } | 810 | } |
733 | else if (pbs.PathCurve == (byte)Extrusion.Curve1) | 811 | |
812 | foreach (KeyValuePair<string,TaintCallbackEntry> kvp in oldList) | ||
734 | { | 813 | { |
735 | iPropertiesNotSupportedDefault++; | 814 | try |
815 | { | ||
816 | DetailLog("{0},BSScene.ProcessPostTaintTaints,doTaint,id={1}", DetailLogZero, kvp.Key); // DEBUG DEBUG DEBUG | ||
817 | kvp.Value.callback(); | ||
818 | } | ||
819 | catch (Exception e) | ||
820 | { | ||
821 | m_log.ErrorFormat("{0}: ProcessPostTaintTaints: {1}: Exception: {2}", LogHeader, kvp.Key, e); | ||
822 | } | ||
736 | } | 823 | } |
824 | oldList.Clear(); | ||
737 | } | 825 | } |
738 | if (iPropertiesNotSupportedDefault == 0) | ||
739 | { | ||
740 | return false; | ||
741 | } | ||
742 | */ | ||
743 | return true; | ||
744 | } | 826 | } |
745 | 827 | ||
746 | // Calls to the PhysicsActors can't directly call into the physics engine | 828 | public void PostStepTaintObject(String ident, TaintCallback callback) |
747 | // 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. | ||
749 | public void TaintedObject(String ident, TaintCallback callback) | ||
750 | { | 829 | { |
751 | if (!m_initialized) return; | 830 | if (!m_initialized) return; |
752 | 831 | ||
753 | lock (_taintLock) | 832 | lock (_taintLock) |
754 | _taintedObjects.Add(new TaintCallbackEntry(ident, callback)); | 833 | { |
834 | _postStepOperations.Add(new TaintCallbackEntry(ident, callback)); | ||
835 | } | ||
836 | |||
755 | return; | 837 | return; |
756 | } | 838 | } |
757 | 839 | ||
758 | // When someone tries to change a property on a BSPrim or BSCharacter, the object queues | 840 | private void ProcessPostStepTaints() |
759 | // a callback into itself to do the actual property change. That callback is called | ||
760 | // here just before the physics engine is called to step the simulation. | ||
761 | public void ProcessTaints() | ||
762 | { | 841 | { |
763 | if (_taintedObjects.Count > 0) // save allocating new list if there is nothing to process | 842 | if (_postStepOperations.Count > 0) |
764 | { | 843 | { |
765 | // swizzle a new list into the list location so we can process what's there | ||
766 | List<TaintCallbackEntry> oldList; | 844 | List<TaintCallbackEntry> oldList; |
767 | lock (_taintLock) | 845 | lock (_taintLock) |
768 | { | 846 | { |
769 | oldList = _taintedObjects; | 847 | oldList = _postStepOperations; |
770 | _taintedObjects = new List<TaintCallbackEntry>(); | 848 | _postStepOperations = new List<TaintCallbackEntry>(); |
771 | } | 849 | } |
772 | 850 | ||
773 | foreach (TaintCallbackEntry tcbe in oldList) | 851 | foreach (TaintCallbackEntry tcbe in oldList) |
774 | { | 852 | { |
775 | try | 853 | try |
776 | { | 854 | { |
855 | DetailLog("{0},BSScene.ProcessPostStepTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG | ||
777 | tcbe.callback(); | 856 | tcbe.callback(); |
778 | } | 857 | } |
779 | catch (Exception e) | 858 | catch (Exception e) |
780 | { | 859 | { |
781 | m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e); | 860 | m_log.ErrorFormat("{0}: ProcessPostStepTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e); |
782 | } | 861 | } |
783 | } | 862 | } |
784 | oldList.Clear(); | 863 | oldList.Clear(); |
785 | } | 864 | } |
786 | } | 865 | } |
787 | 866 | ||
867 | public bool AssertInTaintTime(string whereFrom) | ||
868 | { | ||
869 | if (!InTaintTime) | ||
870 | { | ||
871 | DetailLog("{0},BSScene.AssertInTaintTime,NOT IN TAINT TIME,Region={1},Where={2}", DetailLogZero, RegionName, whereFrom); | ||
872 | m_log.ErrorFormat("{0} NOT IN TAINT TIME!! Region={1}, Where={2}", LogHeader, RegionName, whereFrom); | ||
873 | Util.PrintCallStack(); | ||
874 | } | ||
875 | return InTaintTime; | ||
876 | } | ||
877 | |||
878 | #endregion // Taints | ||
879 | |||
788 | #region Vehicles | 880 | #region Vehicles |
789 | 881 | ||
790 | public void VehicleInSceneTypeChanged(BSPrim vehic, Vehicle newType) | 882 | public void VehicleInSceneTypeChanged(BSPrim vehic, Vehicle newType) |
791 | { | 883 | { |
792 | if (newType == Vehicle.TYPE_NONE) | 884 | RemoveVehiclePrim(vehic); |
793 | { | 885 | if (newType != Vehicle.TYPE_NONE) |
794 | RemoveVehiclePrim(vehic); | ||
795 | } | ||
796 | else | ||
797 | { | 886 | { |
798 | // make it so the scene will call us each tick to do vehicle things | 887 | // make it so the scene will call us each tick to do vehicle things |
799 | AddVehiclePrim(vehic); | 888 | AddVehiclePrim(vehic); |
800 | } | 889 | } |
801 | } | 890 | } |
@@ -827,21 +916,22 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
827 | } | 916 | } |
828 | 917 | ||
829 | // Some prims have extra vehicle actions | 918 | // Some prims have extra vehicle actions |
830 | // no locking because only called when physics engine is not busy | 919 | // Called at taint time! |
831 | private void ProcessVehicles(float timeStep) | 920 | private void ProcessVehicles(float timeStep) |
832 | { | 921 | { |
833 | foreach (BSPrim prim in m_vehicles) | 922 | foreach (BSPhysObject pobj in m_vehicles) |
834 | { | 923 | { |
835 | prim.StepVehicle(timeStep); | 924 | pobj.StepVehicle(timeStep); |
836 | } | 925 | } |
837 | } | 926 | } |
838 | #endregion Vehicles | 927 | #endregion Vehicles |
839 | 928 | ||
840 | #region Parameters | 929 | #region INI and command line parameter processing |
841 | 930 | ||
842 | delegate void ParamUser(BSScene scene, IConfig conf, string paramName, float val); | 931 | delegate void ParamUser(BSScene scene, IConfig conf, string paramName, float val); |
843 | delegate float ParamGet(BSScene scene); | 932 | delegate float ParamGet(BSScene scene); |
844 | delegate void ParamSet(BSScene scene, string paramName, uint localID, float val); | 933 | delegate void ParamSet(BSScene scene, string paramName, uint localID, float val); |
934 | delegate void SetOnObject(BSScene scene, BSPhysObject obj, float val); | ||
845 | 935 | ||
846 | private struct ParameterDefn | 936 | private struct ParameterDefn |
847 | { | 937 | { |
@@ -851,6 +941,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
851 | public ParamUser userParam; // get the value from the configuration file | 941 | public ParamUser userParam; // get the value from the configuration file |
852 | public ParamGet getter; // return the current value stored for this parameter | 942 | public ParamGet getter; // return the current value stored for this parameter |
853 | public ParamSet setter; // set the current value for this parameter | 943 | public ParamSet setter; // set the current value for this parameter |
944 | public SetOnObject onObject; // set the value on an object in the physical domain | ||
854 | public ParameterDefn(string n, string d, float v, ParamUser u, ParamGet g, ParamSet s) | 945 | public ParameterDefn(string n, string d, float v, ParamUser u, ParamGet g, ParamSet s) |
855 | { | 946 | { |
856 | name = n; | 947 | name = n; |
@@ -859,6 +950,17 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
859 | userParam = u; | 950 | userParam = u; |
860 | getter = g; | 951 | getter = g; |
861 | setter = s; | 952 | setter = s; |
953 | onObject = null; | ||
954 | } | ||
955 | public ParameterDefn(string n, string d, float v, ParamUser u, ParamGet g, ParamSet s, SetOnObject o) | ||
956 | { | ||
957 | name = n; | ||
958 | desc = d; | ||
959 | defaultValue = v; | ||
960 | userParam = u; | ||
961 | getter = g; | ||
962 | setter = s; | ||
963 | onObject = o; | ||
862 | } | 964 | } |
863 | } | 965 | } |
864 | 966 | ||
@@ -869,7 +971,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
869 | // getters and setters. | 971 | // getters and setters. |
870 | // It is easiest to find an existing definition and copy it. | 972 | // It is easiest to find an existing definition and copy it. |
871 | // Parameter values are floats. Booleans are converted to a floating value. | 973 | // Parameter values are floats. Booleans are converted to a floating value. |
872 | // | 974 | // |
873 | // A ParameterDefn() takes the following parameters: | 975 | // A ParameterDefn() takes the following parameters: |
874 | // -- the text name of the parameter. This is used for console input and ini file. | 976 | // -- 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. | 977 | // -- a short text description of the parameter. This shows up in the console listing. |
@@ -880,6 +982,7 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
880 | // | 982 | // |
881 | // The single letter parameters for the delegates are: | 983 | // The single letter parameters for the delegates are: |
882 | // s = BSScene | 984 | // s = BSScene |
985 | // o = BSPhysObject | ||
883 | // p = string parameter name | 986 | // p = string parameter name |
884 | // l = localID of referenced object | 987 | // l = localID of referenced object |
885 | // v = float value | 988 | // v = float value |
@@ -888,25 +991,40 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
888 | { | 991 | { |
889 | new ParameterDefn("MeshSculptedPrim", "Whether to create meshes for sculpties", | 992 | new ParameterDefn("MeshSculptedPrim", "Whether to create meshes for sculpties", |
890 | ConfigurationParameters.numericTrue, | 993 | ConfigurationParameters.numericTrue, |
891 | (s,cf,p,v) => { s._meshSculptedPrim = cf.GetBoolean(p, s.BoolNumeric(v)); }, | 994 | (s,cf,p,v) => { s.ShouldMeshSculptedPrim = cf.GetBoolean(p, s.BoolNumeric(v)); }, |
892 | (s) => { return s.NumericBool(s._meshSculptedPrim); }, | 995 | (s) => { return s.NumericBool(s.ShouldMeshSculptedPrim); }, |
893 | (s,p,l,v) => { s._meshSculptedPrim = s.BoolNumeric(v); } ), | 996 | (s,p,l,v) => { s.ShouldMeshSculptedPrim = s.BoolNumeric(v); } ), |
894 | new ParameterDefn("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects", | 997 | new ParameterDefn("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects", |
895 | ConfigurationParameters.numericFalse, | 998 | ConfigurationParameters.numericFalse, |
896 | (s,cf,p,v) => { s._forceSimplePrimMeshing = cf.GetBoolean(p, s.BoolNumeric(v)); }, | 999 | (s,cf,p,v) => { s.ShouldForceSimplePrimMeshing = cf.GetBoolean(p, s.BoolNumeric(v)); }, |
897 | (s) => { return s.NumericBool(s._forceSimplePrimMeshing); }, | 1000 | (s) => { return s.NumericBool(s.ShouldForceSimplePrimMeshing); }, |
898 | (s,p,l,v) => { s._forceSimplePrimMeshing = s.BoolNumeric(v); } ), | 1001 | (s,p,l,v) => { s.ShouldForceSimplePrimMeshing = s.BoolNumeric(v); } ), |
1002 | new ParameterDefn("UseHullsForPhysicalObjects", "If true, create hulls for physical objects", | ||
1003 | ConfigurationParameters.numericTrue, | ||
1004 | (s,cf,p,v) => { s.ShouldUseHullsForPhysicalObjects = cf.GetBoolean(p, s.BoolNumeric(v)); }, | ||
1005 | (s) => { return s.NumericBool(s.ShouldUseHullsForPhysicalObjects); }, | ||
1006 | (s,p,l,v) => { s.ShouldUseHullsForPhysicalObjects = s.BoolNumeric(v); } ), | ||
899 | 1007 | ||
900 | new ParameterDefn("MeshLOD", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)", | 1008 | new ParameterDefn("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)", |
901 | 8f, | 1009 | 8f, |
902 | (s,cf,p,v) => { s.m_meshLOD = cf.GetInt(p, (int)v); }, | 1010 | (s,cf,p,v) => { s.MeshLOD = (float)cf.GetInt(p, (int)v); }, |
903 | (s) => { return (float)s.m_meshLOD; }, | 1011 | (s) => { return s.MeshLOD; }, |
904 | (s,p,l,v) => { s.m_meshLOD = (int)v; } ), | 1012 | (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)", | 1013 | new ParameterDefn("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters", |
1014 | 16f, | ||
1015 | (s,cf,p,v) => { s.MeshMegaPrimLOD = (float)cf.GetInt(p, (int)v); }, | ||
1016 | (s) => { return s.MeshMegaPrimLOD; }, | ||
1017 | (s,p,l,v) => { s.MeshMegaPrimLOD = v; } ), | ||
1018 | new ParameterDefn("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD", | ||
1019 | 10f, | ||
1020 | (s,cf,p,v) => { s.MeshMegaPrimThreshold = (float)cf.GetInt(p, (int)v); }, | ||
1021 | (s) => { return s.MeshMegaPrimThreshold; }, | ||
1022 | (s,p,l,v) => { s.MeshMegaPrimThreshold = v; } ), | ||
1023 | new ParameterDefn("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)", | ||
906 | 32f, | 1024 | 32f, |
907 | (s,cf,p,v) => { s.m_sculptLOD = cf.GetInt(p, (int)v); }, | 1025 | (s,cf,p,v) => { s.SculptLOD = (float)cf.GetInt(p, (int)v); }, |
908 | (s) => { return (float)s.m_sculptLOD; }, | 1026 | (s) => { return s.SculptLOD; }, |
909 | (s,p,l,v) => { s.m_sculptLOD = (int)v; } ), | 1027 | (s,p,l,v) => { s.SculptLOD = v; } ), |
910 | 1028 | ||
911 | new ParameterDefn("MaxSubStep", "In simulation step, maximum number of substeps", | 1029 | new ParameterDefn("MaxSubStep", "In simulation step, maximum number of substeps", |
912 | 10f, | 1030 | 10f, |
@@ -928,11 +1046,16 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
928 | (s,cf,p,v) => { s.m_maxUpdatesPerFrame = cf.GetInt(p, (int)v); }, | 1046 | (s,cf,p,v) => { s.m_maxUpdatesPerFrame = cf.GetInt(p, (int)v); }, |
929 | (s) => { return (float)s.m_maxUpdatesPerFrame; }, | 1047 | (s) => { return (float)s.m_maxUpdatesPerFrame; }, |
930 | (s,p,l,v) => { s.m_maxUpdatesPerFrame = (int)v; } ), | 1048 | (s,p,l,v) => { s.m_maxUpdatesPerFrame = (int)v; } ), |
1049 | new ParameterDefn("MaxTaintsToProcessPerStep", "Number of update taints to process before each simulation step", | ||
1050 | 500f, | ||
1051 | (s,cf,p,v) => { s.m_taintsToProcessPerStep = cf.GetInt(p, (int)v); }, | ||
1052 | (s) => { return (float)s.m_taintsToProcessPerStep; }, | ||
1053 | (s,p,l,v) => { s.m_taintsToProcessPerStep = (int)v; } ), | ||
931 | new ParameterDefn("MaxObjectMass", "Maximum object mass (10000.01)", | 1054 | new ParameterDefn("MaxObjectMass", "Maximum object mass (10000.01)", |
932 | 10000.01f, | 1055 | 10000.01f, |
933 | (s,cf,p,v) => { s.m_maximumObjectMass = cf.GetFloat(p, v); }, | 1056 | (s,cf,p,v) => { s.MaximumObjectMass = cf.GetFloat(p, v); }, |
934 | (s) => { return (float)s.m_maximumObjectMass; }, | 1057 | (s) => { return (float)s.MaximumObjectMass; }, |
935 | (s,p,l,v) => { s.m_maximumObjectMass = v; } ), | 1058 | (s,p,l,v) => { s.MaximumObjectMass = v; } ), |
936 | 1059 | ||
937 | new ParameterDefn("PID_D", "Derivitive factor for motion smoothing", | 1060 | new ParameterDefn("PID_D", "Derivitive factor for motion smoothing", |
938 | 2200f, | 1061 | 2200f, |
@@ -969,104 +1092,118 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
969 | -9.80665f, | 1092 | -9.80665f, |
970 | (s,cf,p,v) => { s.m_params[0].gravity = cf.GetFloat(p, v); }, | 1093 | (s,cf,p,v) => { s.m_params[0].gravity = cf.GetFloat(p, v); }, |
971 | (s) => { return s.m_params[0].gravity; }, | 1094 | (s) => { return s.m_params[0].gravity; }, |
972 | (s,p,l,v) => { s.m_params[0].gravity = v; s.TaintedUpdateParameter(p,l,v); } ), | 1095 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].gravity, p, PhysParameterEntry.APPLY_TO_NONE, v); }, |
1096 | (s,o,v) => { BulletSimAPI.SetGravity2(s.World.ptr, new Vector3(0f,0f,v)); } ), | ||
973 | 1097 | ||
974 | 1098 | ||
975 | new ParameterDefn("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)", | 1099 | new ParameterDefn("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)", |
976 | 0f, | 1100 | 0f, |
977 | (s,cf,p,v) => { s.m_params[0].linearDamping = cf.GetFloat(p, v); }, | 1101 | (s,cf,p,v) => { s.m_params[0].linearDamping = cf.GetFloat(p, v); }, |
978 | (s) => { return s.m_params[0].linearDamping; }, | 1102 | (s) => { return s.m_params[0].linearDamping; }, |
979 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].linearDamping, p, l, v); } ), | 1103 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].linearDamping, p, l, v); }, |
1104 | (s,o,v) => { BulletSimAPI.SetDamping2(o.PhysBody.ptr, v, s.m_params[0].angularDamping); } ), | ||
980 | new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)", | 1105 | new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)", |
981 | 0f, | 1106 | 0f, |
982 | (s,cf,p,v) => { s.m_params[0].angularDamping = cf.GetFloat(p, v); }, | 1107 | (s,cf,p,v) => { s.m_params[0].angularDamping = cf.GetFloat(p, v); }, |
983 | (s) => { return s.m_params[0].angularDamping; }, | 1108 | (s) => { return s.m_params[0].angularDamping; }, |
984 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].angularDamping, p, l, v); } ), | 1109 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].angularDamping, p, l, v); }, |
1110 | (s,o,v) => { BulletSimAPI.SetDamping2(o.PhysBody.ptr, s.m_params[0].linearDamping, v); } ), | ||
985 | new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static", | 1111 | new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static", |
986 | 0.2f, | 1112 | 0.2f, |
987 | (s,cf,p,v) => { s.m_params[0].deactivationTime = cf.GetFloat(p, v); }, | 1113 | (s,cf,p,v) => { s.m_params[0].deactivationTime = cf.GetFloat(p, v); }, |
988 | (s) => { return s.m_params[0].deactivationTime; }, | 1114 | (s) => { return s.m_params[0].deactivationTime; }, |
989 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].deactivationTime, p, l, v); } ), | 1115 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].deactivationTime, p, l, v); }, |
1116 | (s,o,v) => { BulletSimAPI.SetDeactivationTime2(o.PhysBody.ptr, v); } ), | ||
990 | new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static", | 1117 | new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static", |
991 | 0.8f, | 1118 | 0.8f, |
992 | (s,cf,p,v) => { s.m_params[0].linearSleepingThreshold = cf.GetFloat(p, v); }, | 1119 | (s,cf,p,v) => { s.m_params[0].linearSleepingThreshold = cf.GetFloat(p, v); }, |
993 | (s) => { return s.m_params[0].linearSleepingThreshold; }, | 1120 | (s) => { return s.m_params[0].linearSleepingThreshold; }, |
994 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].linearSleepingThreshold, p, l, v); } ), | 1121 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].linearSleepingThreshold, p, l, v); }, |
1122 | (s,o,v) => { BulletSimAPI.SetSleepingThresholds2(o.PhysBody.ptr, v, v); } ), | ||
995 | new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static", | 1123 | new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static", |
996 | 1.0f, | 1124 | 1.0f, |
997 | (s,cf,p,v) => { s.m_params[0].angularSleepingThreshold = cf.GetFloat(p, v); }, | 1125 | (s,cf,p,v) => { s.m_params[0].angularSleepingThreshold = cf.GetFloat(p, v); }, |
998 | (s) => { return s.m_params[0].angularSleepingThreshold; }, | 1126 | (s) => { return s.m_params[0].angularSleepingThreshold; }, |
999 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].angularSleepingThreshold, p, l, v); } ), | 1127 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].angularSleepingThreshold, p, l, v); }, |
1128 | (s,o,v) => { BulletSimAPI.SetSleepingThresholds2(o.PhysBody.ptr, v, v); } ), | ||
1000 | new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" , | 1129 | new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" , |
1001 | 0f, // set to zero to disable | 1130 | 0f, // set to zero to disable |
1002 | (s,cf,p,v) => { s.m_params[0].ccdMotionThreshold = cf.GetFloat(p, v); }, | 1131 | (s,cf,p,v) => { s.m_params[0].ccdMotionThreshold = cf.GetFloat(p, v); }, |
1003 | (s) => { return s.m_params[0].ccdMotionThreshold; }, | 1132 | (s) => { return s.m_params[0].ccdMotionThreshold; }, |
1004 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].ccdMotionThreshold, p, l, v); } ), | 1133 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].ccdMotionThreshold, p, l, v); }, |
1134 | (s,o,v) => { BulletSimAPI.SetCcdMotionThreshold2(o.PhysBody.ptr, v); } ), | ||
1005 | new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" , | 1135 | new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" , |
1006 | 0f, | 1136 | 0f, |
1007 | (s,cf,p,v) => { s.m_params[0].ccdSweptSphereRadius = cf.GetFloat(p, v); }, | 1137 | (s,cf,p,v) => { s.m_params[0].ccdSweptSphereRadius = cf.GetFloat(p, v); }, |
1008 | (s) => { return s.m_params[0].ccdSweptSphereRadius; }, | 1138 | (s) => { return s.m_params[0].ccdSweptSphereRadius; }, |
1009 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].ccdSweptSphereRadius, p, l, v); } ), | 1139 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].ccdSweptSphereRadius, p, l, v); }, |
1140 | (s,o,v) => { BulletSimAPI.SetCcdSweptSphereRadius2(o.PhysBody.ptr, v); } ), | ||
1010 | new ParameterDefn("ContactProcessingThreshold", "Distance between contacts before doing collision check" , | 1141 | new ParameterDefn("ContactProcessingThreshold", "Distance between contacts before doing collision check" , |
1011 | 0.1f, | 1142 | 0.1f, |
1012 | (s,cf,p,v) => { s.m_params[0].contactProcessingThreshold = cf.GetFloat(p, v); }, | 1143 | (s,cf,p,v) => { s.m_params[0].contactProcessingThreshold = cf.GetFloat(p, v); }, |
1013 | (s) => { return s.m_params[0].contactProcessingThreshold; }, | 1144 | (s) => { return s.m_params[0].contactProcessingThreshold; }, |
1014 | (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].contactProcessingThreshold, p, l, v); } ), | 1145 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].contactProcessingThreshold, p, l, v); }, |
1146 | (s,o,v) => { BulletSimAPI.SetContactProcessingThreshold2(o.PhysBody.ptr, v); } ), | ||
1015 | 1147 | ||
1016 | new ParameterDefn("TerrainFriction", "Factor to reduce movement against terrain surface" , | 1148 | new ParameterDefn("TerrainFriction", "Factor to reduce movement against terrain surface" , |
1017 | 0.5f, | 1149 | 0.5f, |
1018 | (s,cf,p,v) => { s.m_params[0].terrainFriction = cf.GetFloat(p, v); }, | 1150 | (s,cf,p,v) => { s.m_params[0].terrainFriction = cf.GetFloat(p, v); }, |
1019 | (s) => { return s.m_params[0].terrainFriction; }, | 1151 | (s) => { return s.m_params[0].terrainFriction; }, |
1020 | (s,p,l,v) => { s.m_params[0].terrainFriction = v; s.TaintedUpdateParameter(p,l,v); } ), | 1152 | (s,p,l,v) => { s.m_params[0].terrainFriction = v; /* TODO: set on real terrain */} ), |
1021 | new ParameterDefn("TerrainHitFraction", "Distance to measure hit collisions" , | 1153 | new ParameterDefn("TerrainHitFraction", "Distance to measure hit collisions" , |
1022 | 0.8f, | 1154 | 0.8f, |
1023 | (s,cf,p,v) => { s.m_params[0].terrainHitFraction = cf.GetFloat(p, v); }, | 1155 | (s,cf,p,v) => { s.m_params[0].terrainHitFraction = cf.GetFloat(p, v); }, |
1024 | (s) => { return s.m_params[0].terrainHitFraction; }, | 1156 | (s) => { return s.m_params[0].terrainHitFraction; }, |
1025 | (s,p,l,v) => { s.m_params[0].terrainHitFraction = v; s.TaintedUpdateParameter(p,l,v); } ), | 1157 | (s,p,l,v) => { s.m_params[0].terrainHitFraction = v; /* TODO: set on real terrain */ } ), |
1026 | new ParameterDefn("TerrainRestitution", "Bouncyness" , | 1158 | new ParameterDefn("TerrainRestitution", "Bouncyness" , |
1027 | 0f, | 1159 | 0f, |
1028 | (s,cf,p,v) => { s.m_params[0].terrainRestitution = cf.GetFloat(p, v); }, | 1160 | (s,cf,p,v) => { s.m_params[0].terrainRestitution = cf.GetFloat(p, v); }, |
1029 | (s) => { return s.m_params[0].terrainRestitution; }, | 1161 | (s) => { return s.m_params[0].terrainRestitution; }, |
1030 | (s,p,l,v) => { s.m_params[0].terrainRestitution = v; s.TaintedUpdateParameter(p,l,v); } ), | 1162 | (s,p,l,v) => { s.m_params[0].terrainRestitution = v; /* TODO: set on real terrain */ } ), |
1031 | new ParameterDefn("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.", | 1163 | new ParameterDefn("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.", |
1032 | 0.5f, | 1164 | 0.2f, |
1033 | (s,cf,p,v) => { s.m_params[0].avatarFriction = cf.GetFloat(p, v); }, | 1165 | (s,cf,p,v) => { s.m_params[0].avatarFriction = cf.GetFloat(p, v); }, |
1034 | (s) => { return s.m_params[0].avatarFriction; }, | 1166 | (s) => { return s.m_params[0].avatarFriction; }, |
1035 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarFriction, p, l, v); } ), | 1167 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarFriction, p, l, v); } ), |
1168 | new ParameterDefn("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.", | ||
1169 | 10f, | ||
1170 | (s,cf,p,v) => { s.m_params[0].avatarStandingFriction = cf.GetFloat(p, v); }, | ||
1171 | (s) => { return s.m_params[0].avatarStandingFriction; }, | ||
1172 | (s,p,l,v) => { s.m_params[0].avatarStandingFriction = v; } ), | ||
1036 | new ParameterDefn("AvatarDensity", "Density of an avatar. Changed on avatar recreation.", | 1173 | new ParameterDefn("AvatarDensity", "Density of an avatar. Changed on avatar recreation.", |
1037 | 60f, | 1174 | 60f, |
1038 | (s,cf,p,v) => { s.m_params[0].avatarDensity = cf.GetFloat(p, v); }, | 1175 | (s,cf,p,v) => { s.m_params[0].avatarDensity = cf.GetFloat(p, v); }, |
1039 | (s) => { return s.m_params[0].avatarDensity; }, | 1176 | (s) => { return s.m_params[0].avatarDensity; }, |
1040 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarDensity, p, l, v); } ), | 1177 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarDensity, p, l, v); } ), |
1041 | new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", | 1178 | new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", |
1042 | 0f, | 1179 | 0f, |
1043 | (s,cf,p,v) => { s.m_params[0].avatarRestitution = cf.GetFloat(p, v); }, | 1180 | (s,cf,p,v) => { s.m_params[0].avatarRestitution = cf.GetFloat(p, v); }, |
1044 | (s) => { return s.m_params[0].avatarRestitution; }, | 1181 | (s) => { return s.m_params[0].avatarRestitution; }, |
1045 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarRestitution, p, l, v); } ), | 1182 | (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", | 1183 | new ParameterDefn("AvatarCapsuleRadius", "Radius of space around an avatar", |
1047 | 0.37f, | 1184 | 0.37f, |
1048 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleRadius = cf.GetFloat(p, v); }, | 1185 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleRadius = cf.GetFloat(p, v); }, |
1049 | (s) => { return s.m_params[0].avatarCapsuleRadius; }, | 1186 | (s) => { return s.m_params[0].avatarCapsuleRadius; }, |
1050 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarCapsuleRadius, p, l, v); } ), | 1187 | (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", | 1188 | new ParameterDefn("AvatarCapsuleHeight", "Default height of space around avatar", |
1052 | 1.5f, | 1189 | 1.5f, |
1053 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleHeight = cf.GetFloat(p, v); }, | 1190 | (s,cf,p,v) => { s.m_params[0].avatarCapsuleHeight = cf.GetFloat(p, v); }, |
1054 | (s) => { return s.m_params[0].avatarCapsuleHeight; }, | 1191 | (s) => { return s.m_params[0].avatarCapsuleHeight; }, |
1055 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarCapsuleHeight, p, l, v); } ), | 1192 | (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", | 1193 | new ParameterDefn("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", |
1057 | 0.1f, | 1194 | 0.1f, |
1058 | (s,cf,p,v) => { s.m_params[0].avatarContactProcessingThreshold = cf.GetFloat(p, v); }, | 1195 | (s,cf,p,v) => { s.m_params[0].avatarContactProcessingThreshold = cf.GetFloat(p, v); }, |
1059 | (s) => { return s.m_params[0].avatarContactProcessingThreshold; }, | 1196 | (s) => { return s.m_params[0].avatarContactProcessingThreshold; }, |
1060 | (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarContactProcessingThreshold, p, l, v); } ), | 1197 | (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarContactProcessingThreshold, p, l, v); } ), |
1061 | 1198 | ||
1062 | 1199 | ||
1063 | new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", | 1200 | new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", |
1064 | 0f, // zero to disable | 1201 | 0f, |
1065 | (s,cf,p,v) => { s.m_params[0].maxPersistantManifoldPoolSize = cf.GetFloat(p, v); }, | 1202 | (s,cf,p,v) => { s.m_params[0].maxPersistantManifoldPoolSize = cf.GetFloat(p, v); }, |
1066 | (s) => { return s.m_params[0].maxPersistantManifoldPoolSize; }, | 1203 | (s) => { return s.m_params[0].maxPersistantManifoldPoolSize; }, |
1067 | (s,p,l,v) => { s.m_params[0].maxPersistantManifoldPoolSize = v; } ), | 1204 | (s,p,l,v) => { s.m_params[0].maxPersistantManifoldPoolSize = v; } ), |
1068 | new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", | 1205 | new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", |
1069 | 0f, // zero to disable | 1206 | 0f, |
1070 | (s,cf,p,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); }, | 1207 | (s,cf,p,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); }, |
1071 | (s) => { return s.m_params[0].maxCollisionAlgorithmPoolSize; }, | 1208 | (s) => { return s.m_params[0].maxCollisionAlgorithmPoolSize; }, |
1072 | (s,p,l,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = v; } ), | 1209 | (s,p,l,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = v; } ), |
@@ -1081,12 +1218,12 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1081 | (s) => { return s.m_params[0].shouldForceUpdateAllAabbs; }, | 1218 | (s) => { return s.m_params[0].shouldForceUpdateAllAabbs; }, |
1082 | (s,p,l,v) => { s.m_params[0].shouldForceUpdateAllAabbs = v; } ), | 1219 | (s,p,l,v) => { s.m_params[0].shouldForceUpdateAllAabbs = v; } ), |
1083 | new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", | 1220 | new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", |
1084 | ConfigurationParameters.numericFalse, | 1221 | ConfigurationParameters.numericTrue, |
1085 | (s,cf,p,v) => { s.m_params[0].shouldRandomizeSolverOrder = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, | 1222 | (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; }, | 1223 | (s) => { return s.m_params[0].shouldRandomizeSolverOrder; }, |
1087 | (s,p,l,v) => { s.m_params[0].shouldRandomizeSolverOrder = v; } ), | 1224 | (s,p,l,v) => { s.m_params[0].shouldRandomizeSolverOrder = v; } ), |
1088 | new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", | 1225 | new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", |
1089 | ConfigurationParameters.numericFalse, | 1226 | ConfigurationParameters.numericTrue, |
1090 | (s,cf,p,v) => { s.m_params[0].shouldSplitSimulationIslands = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, | 1227 | (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; }, | 1228 | (s) => { return s.m_params[0].shouldSplitSimulationIslands; }, |
1092 | (s,p,l,v) => { s.m_params[0].shouldSplitSimulationIslands = v; } ), | 1229 | (s,p,l,v) => { s.m_params[0].shouldSplitSimulationIslands = v; } ), |
@@ -1101,6 +1238,11 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1101 | (s) => { return s.m_params[0].numberOfSolverIterations; }, | 1238 | (s) => { return s.m_params[0].numberOfSolverIterations; }, |
1102 | (s,p,l,v) => { s.m_params[0].numberOfSolverIterations = v; } ), | 1239 | (s,p,l,v) => { s.m_params[0].numberOfSolverIterations = v; } ), |
1103 | 1240 | ||
1241 | new ParameterDefn("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)", | ||
1242 | (float)BSLinkset.LinksetImplementation.Compound, | ||
1243 | (s,cf,p,v) => { s.m_params[0].linksetImplementation = cf.GetFloat(p,v); }, | ||
1244 | (s) => { return s.m_params[0].linksetImplementation; }, | ||
1245 | (s,p,l,v) => { s.m_params[0].linksetImplementation = v; } ), | ||
1104 | new ParameterDefn("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", | 1246 | new ParameterDefn("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", |
1105 | ConfigurationParameters.numericFalse, | 1247 | ConfigurationParameters.numericFalse, |
1106 | (s,cf,p,v) => { s.m_params[0].linkConstraintUseFrameOffset = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, | 1248 | (s,cf,p,v) => { s.m_params[0].linkConstraintUseFrameOffset = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); }, |
@@ -1121,28 +1263,27 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1121 | (s,cf,p,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = cf.GetFloat(p, v); }, | 1263 | (s,cf,p,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = cf.GetFloat(p, v); }, |
1122 | (s) => { return s.m_params[0].linkConstraintTransMotorMaxForce; }, | 1264 | (s) => { return s.m_params[0].linkConstraintTransMotorMaxForce; }, |
1123 | (s,p,l,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = v; } ), | 1265 | (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", | 1266 | new ParameterDefn("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", |
1125 | 0.0f, | 1267 | 0.1f, |
1126 | (s,cf,p,v) => { s.m_params[0].linkConstraintCFM = cf.GetFloat(p, v); }, | 1268 | (s,cf,p,v) => { s.m_params[0].linkConstraintCFM = cf.GetFloat(p, v); }, |
1127 | (s) => { return s.m_params[0].linkConstraintCFM; }, | 1269 | (s) => { return s.m_params[0].linkConstraintCFM; }, |
1128 | (s,p,l,v) => { s.m_params[0].linkConstraintCFM = v; } ), | 1270 | (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", | 1271 | new ParameterDefn("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", |
1130 | 0.2f, | 1272 | 0.1f, |
1131 | (s,cf,p,v) => { s.m_params[0].linkConstraintERP = cf.GetFloat(p, v); }, | 1273 | (s,cf,p,v) => { s.m_params[0].linkConstraintERP = cf.GetFloat(p, v); }, |
1132 | (s) => { return s.m_params[0].linkConstraintERP; }, | 1274 | (s) => { return s.m_params[0].linkConstraintERP; }, |
1133 | (s,p,l,v) => { s.m_params[0].linkConstraintERP = v; } ), | 1275 | (s,p,l,v) => { s.m_params[0].linkConstraintERP = v; } ), |
1276 | new ParameterDefn("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", | ||
1277 | 40, | ||
1278 | (s,cf,p,v) => { s.m_params[0].linkConstraintSolverIterations = cf.GetFloat(p, v); }, | ||
1279 | (s) => { return s.m_params[0].linkConstraintSolverIterations; }, | ||
1280 | (s,p,l,v) => { s.m_params[0].linkConstraintSolverIterations = v; } ), | ||
1134 | 1281 | ||
1135 | new ParameterDefn("DetailedStats", "Frames between outputting detailed phys stats. (0 is off)", | 1282 | new ParameterDefn("LogPhysicsStatisticsFrames", "Frames between outputting detailed phys stats. (0 is off)", |
1136 | 0f, | 1283 | 0f, |
1137 | (s,cf,p,v) => { s.m_detailedStatsStep = cf.GetInt(p, (int)v); }, | 1284 | (s,cf,p,v) => { s.m_params[0].physicsLoggingFrames = cf.GetInt(p, (int)v); }, |
1138 | (s) => { return (float)s.m_detailedStatsStep; }, | 1285 | (s) => { return (float)s.m_params[0].physicsLoggingFrames; }, |
1139 | (s,p,l,v) => { s.m_detailedStatsStep = (int)v; } ), | 1286 | (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 | }; | 1287 | }; |
1147 | 1288 | ||
1148 | // Convert a boolean to our numeric true and false values | 1289 | // Convert a boolean to our numeric true and false values |
@@ -1200,11 +1341,12 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1200 | 1341 | ||
1201 | private PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1]; | 1342 | private PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1]; |
1202 | 1343 | ||
1344 | // This creates an array in the correct format for returning the list of | ||
1345 | // parameters. This is used by the 'list' option of the 'physics' command. | ||
1203 | private void BuildParameterTable() | 1346 | private void BuildParameterTable() |
1204 | { | 1347 | { |
1205 | if (SettableParameters.Length < ParameterDefinitions.Length) | 1348 | if (SettableParameters.Length < ParameterDefinitions.Length) |
1206 | { | 1349 | { |
1207 | |||
1208 | List<PhysParameterEntry> entries = new List<PhysParameterEntry>(); | 1350 | List<PhysParameterEntry> entries = new List<PhysParameterEntry>(); |
1209 | for (int ii = 0; ii < ParameterDefinitions.Length; ii++) | 1351 | for (int ii = 0; ii < ParameterDefinitions.Length; ii++) |
1210 | { | 1352 | { |
@@ -1249,60 +1391,54 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1249 | return ret; | 1391 | return ret; |
1250 | } | 1392 | } |
1251 | 1393 | ||
1252 | // 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) | ||
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 | { | ||
1263 | List<uint> operateOn; | ||
1264 | lock (m_avatars) operateOn = new List<uint>(m_avatars.Keys); | ||
1265 | UpdateParameterSet(operateOn, ref loc, parm, localID, val); | ||
1266 | } | ||
1267 | |||
1268 | // update all the localIDs specified | 1394 | // update all the localIDs specified |
1269 | // If the local ID is APPLY_TO_NONE, just change the default value | 1395 | // If the local ID is APPLY_TO_NONE, just change the default value |
1270 | // If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs | 1396 | // If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs |
1271 | // If the localID is a specific object, apply the parameter change to only that object | 1397 | // If the localID is a specific object, apply the parameter change to only that object |
1272 | protected void UpdateParameterSet(List<uint> lIDs, ref float defaultLoc, string parm, uint localID, float val) | 1398 | private void UpdateParameterObject(ref float defaultLoc, string parm, uint localID, float val) |
1273 | { | 1399 | { |
1400 | List<uint> objectIDs = new List<uint>(); | ||
1274 | switch (localID) | 1401 | switch (localID) |
1275 | { | 1402 | { |
1276 | case PhysParameterEntry.APPLY_TO_NONE: | 1403 | case PhysParameterEntry.APPLY_TO_NONE: |
1277 | defaultLoc = val; // setting only the default value | 1404 | defaultLoc = val; // setting only the default value |
1405 | // This will cause a call into the physical world if some operation is specified (SetOnObject). | ||
1406 | objectIDs.Add(TERRAIN_ID); | ||
1407 | TaintedUpdateParameter(parm, objectIDs, val); | ||
1278 | break; | 1408 | break; |
1279 | case PhysParameterEntry.APPLY_TO_ALL: | 1409 | case PhysParameterEntry.APPLY_TO_ALL: |
1280 | defaultLoc = val; // setting ALL also sets the default value | 1410 | defaultLoc = val; // setting ALL also sets the default value |
1281 | List<uint> objectIDs = lIDs; | 1411 | lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys); |
1282 | string xparm = parm.ToLower(); | 1412 | TaintedUpdateParameter(parm, objectIDs, val); |
1283 | float xval = val; | ||
1284 | TaintedObject("BSScene.UpdateParameterSet", delegate() { | ||
1285 | foreach (uint lID in objectIDs) | ||
1286 | { | ||
1287 | BulletSimAPI.UpdateParameter(m_worldID, lID, xparm, xval); | ||
1288 | } | ||
1289 | }); | ||
1290 | break; | 1413 | break; |
1291 | default: | 1414 | default: |
1292 | // setting only one localID | 1415 | // setting only one localID |
1293 | TaintedUpdateParameter(parm, localID, val); | 1416 | objectIDs.Add(localID); |
1417 | TaintedUpdateParameter(parm, objectIDs, val); | ||
1294 | break; | 1418 | break; |
1295 | } | 1419 | } |
1296 | } | 1420 | } |
1297 | 1421 | ||
1298 | // schedule the actual updating of the paramter to when the phys engine is not busy | 1422 | // schedule the actual updating of the paramter to when the phys engine is not busy |
1299 | protected void TaintedUpdateParameter(string parm, uint localID, float val) | 1423 | private void TaintedUpdateParameter(string parm, List<uint> lIDs, float val) |
1300 | { | 1424 | { |
1301 | uint xlocalID = localID; | ||
1302 | string xparm = parm.ToLower(); | ||
1303 | float xval = val; | 1425 | float xval = val; |
1304 | TaintedObject("BSScene.TaintedUpdateParameter", delegate() { | 1426 | List<uint> xlIDs = lIDs; |
1305 | BulletSimAPI.UpdateParameter(m_worldID, xlocalID, xparm, xval); | 1427 | string xparm = parm; |
1428 | TaintedObject("BSScene.UpdateParameterSet", delegate() { | ||
1429 | ParameterDefn thisParam; | ||
1430 | if (TryGetParameter(xparm, out thisParam)) | ||
1431 | { | ||
1432 | if (thisParam.onObject != null) | ||
1433 | { | ||
1434 | foreach (uint lID in xlIDs) | ||
1435 | { | ||
1436 | BSPhysObject theObject = null; | ||
1437 | PhysObjects.TryGetValue(lID, out theObject); | ||
1438 | thisParam.onObject(this, theObject, xval); | ||
1439 | } | ||
1440 | } | ||
1441 | } | ||
1306 | }); | 1442 | }); |
1307 | } | 1443 | } |
1308 | 1444 | ||
@@ -1326,12 +1462,24 @@ public class BSScene : PhysicsScene, IPhysicsParameters | |||
1326 | 1462 | ||
1327 | #endregion Runtime settable parameters | 1463 | #endregion Runtime settable parameters |
1328 | 1464 | ||
1465 | // Debugging routine for dumping detailed physical information for vehicle prims | ||
1466 | private void DumpVehicles() | ||
1467 | { | ||
1468 | foreach (BSPrim prim in m_vehicles) | ||
1469 | { | ||
1470 | BulletSimAPI.DumpRigidBody2(World.ptr, prim.PhysBody.ptr); | ||
1471 | BulletSimAPI.DumpCollisionShape2(World.ptr, prim.PhysShape.ptr); | ||
1472 | } | ||
1473 | } | ||
1474 | |||
1329 | // Invoke the detailed logger and output something if it's enabled. | 1475 | // Invoke the detailed logger and output something if it's enabled. |
1330 | public void DetailLog(string msg, params Object[] args) | 1476 | public void DetailLog(string msg, params Object[] args) |
1331 | { | 1477 | { |
1332 | PhysicsLogging.Write(msg, args); | 1478 | PhysicsLogging.Write(msg, args); |
1479 | // Add the Flush() if debugging crashes. Gets all the messages written out. | ||
1480 | // PhysicsLogging.Flush(); | ||
1333 | } | 1481 | } |
1334 | // used to fill in the LocalID when there isn't one | 1482 | // Used to fill in the LocalID when there isn't one. It's the correct number of characters. |
1335 | public const string DetailLogZero = "0000000000"; | 1483 | public const string DetailLogZero = "0000000000"; |
1336 | 1484 | ||
1337 | } | 1485 | } |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs new file mode 100755 index 0000000..29a23c0 --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs | |||
@@ -0,0 +1,1000 @@ | |||
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 sealed class BSShapeCollection : IDisposable | ||
38 | { | ||
39 | private static string LogHeader = "[BULLETSIM SHAPE COLLECTION]"; | ||
40 | |||
41 | private 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 | public UInt64 shapeKey; | ||
52 | } | ||
53 | |||
54 | // Description of a hull. | ||
55 | // Meshes and hulls have the same shape hash key but we only need hulls for efficient collision calculations. | ||
56 | private struct HullDesc | ||
57 | { | ||
58 | public IntPtr ptr; | ||
59 | public int referenceCount; | ||
60 | public DateTime lastReferenced; | ||
61 | public UInt64 shapeKey; | ||
62 | } | ||
63 | |||
64 | // The sharable set of meshes and hulls. Indexed by their shape hash. | ||
65 | private Dictionary<System.UInt64, MeshDesc> Meshes = new Dictionary<System.UInt64, MeshDesc>(); | ||
66 | private Dictionary<System.UInt64, HullDesc> Hulls = new Dictionary<System.UInt64, HullDesc>(); | ||
67 | |||
68 | public BSShapeCollection(BSScene physScene) | ||
69 | { | ||
70 | PhysicsScene = physScene; | ||
71 | } | ||
72 | |||
73 | public void Dispose() | ||
74 | { | ||
75 | // TODO!!!!!!!!! | ||
76 | } | ||
77 | |||
78 | // Callbacks called just before either the body or shape is destroyed. | ||
79 | // Mostly used for changing bodies out from under Linksets. | ||
80 | // Useful for other cases where parameters need saving. | ||
81 | // Passing 'null' says no callback. | ||
82 | public delegate void ShapeDestructionCallback(BulletShape shape); | ||
83 | public delegate void BodyDestructionCallback(BulletBody body); | ||
84 | |||
85 | // Called to update/change the body and shape for an object. | ||
86 | // First checks the shape and updates that if necessary then makes | ||
87 | // sure the body is of the right type. | ||
88 | // Return 'true' if either the body or the shape changed. | ||
89 | // 'shapeCallback' and 'bodyCallback' are, if non-null, functions called just before | ||
90 | // the current shape or body is destroyed. This allows the caller to remove any | ||
91 | // higher level dependencies on the shape or body. Mostly used for LinkSets to | ||
92 | // remove the physical constraints before the body is destroyed. | ||
93 | // Called at taint-time!! | ||
94 | public bool GetBodyAndShape(bool forceRebuild, BulletSim sim, BSPhysObject prim, | ||
95 | ShapeDestructionCallback shapeCallback, BodyDestructionCallback bodyCallback) | ||
96 | { | ||
97 | PhysicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape"); | ||
98 | |||
99 | bool ret = false; | ||
100 | |||
101 | // This lock could probably be pushed down lower but building shouldn't take long | ||
102 | lock (m_collectionActivityLock) | ||
103 | { | ||
104 | // Do we have the correct geometry for this type of object? | ||
105 | // Updates prim.BSShape with information/pointers to shape. | ||
106 | // Returns 'true' of BSShape is changed to a new shape. | ||
107 | bool newGeom = CreateGeom(forceRebuild, prim, 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 | // Returns 'true' if BSBody was changed. | ||
112 | bool newBody = CreateBody((newGeom || forceRebuild), prim, PhysicsScene.World, | ||
113 | prim.PhysShape, bodyCallback); | ||
114 | ret = newGeom || newBody; | ||
115 | } | ||
116 | DetailLog("{0},BSShapeCollection.GetBodyAndShape,taintExit,force={1},ret={2},body={3},shape={4}", | ||
117 | prim.LocalID, forceRebuild, ret, prim.PhysBody, prim.PhysShape); | ||
118 | |||
119 | return ret; | ||
120 | } | ||
121 | |||
122 | // Track another user of a body. | ||
123 | // We presume the caller has allocated the body. | ||
124 | // Bodies only have one user so the body is just put into the world if not already there. | ||
125 | public void ReferenceBody(BulletBody body, bool inTaintTime) | ||
126 | { | ||
127 | lock (m_collectionActivityLock) | ||
128 | { | ||
129 | DetailLog("{0},BSShapeCollection.ReferenceBody,newBody,body={1}", body.ID, body); | ||
130 | PhysicsScene.TaintedObject(inTaintTime, "BSShapeCollection.ReferenceBody", delegate() | ||
131 | { | ||
132 | if (!BulletSimAPI.IsInWorld2(body.ptr)) | ||
133 | { | ||
134 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, body.ptr); | ||
135 | DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", body.ID, body); | ||
136 | } | ||
137 | }); | ||
138 | } | ||
139 | } | ||
140 | |||
141 | // Release the usage of a body. | ||
142 | // Called when releasing use of a BSBody. BSShape is handled separately. | ||
143 | public void DereferenceBody(BulletBody body, bool inTaintTime, BodyDestructionCallback bodyCallback ) | ||
144 | { | ||
145 | if (body.ptr == IntPtr.Zero) | ||
146 | return; | ||
147 | |||
148 | lock (m_collectionActivityLock) | ||
149 | { | ||
150 | PhysicsScene.TaintedObject(inTaintTime, "BSShapeCollection.DereferenceBody", delegate() | ||
151 | { | ||
152 | DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody,body={1},inTaintTime={2}", | ||
153 | body.ID, body, inTaintTime); | ||
154 | // If the caller needs to know the old body is going away, pass the event up. | ||
155 | if (bodyCallback != null) bodyCallback(body); | ||
156 | |||
157 | if (BulletSimAPI.IsInWorld2(body.ptr)) | ||
158 | { | ||
159 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, body.ptr); | ||
160 | DetailLog("{0},BSShapeCollection.DereferenceBody,removingFromWorld. Body={1}", body.ID, body); | ||
161 | } | ||
162 | |||
163 | // Zero any reference to the shape so it is not freed when the body is deleted. | ||
164 | BulletSimAPI.SetCollisionShape2(PhysicsScene.World.ptr, body.ptr, IntPtr.Zero); | ||
165 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, body.ptr); | ||
166 | }); | ||
167 | } | ||
168 | } | ||
169 | |||
170 | // Track the datastructures and use count for a shape. | ||
171 | // When creating a hull, this is called first to reference the mesh | ||
172 | // and then again to reference the hull. | ||
173 | // Meshes and hulls for the same shape have the same hash key. | ||
174 | // NOTE that native shapes are not added to the mesh list or removed. | ||
175 | // Returns 'true' if this is the initial reference to the shape. Otherwise reused. | ||
176 | public bool ReferenceShape(BulletShape shape) | ||
177 | { | ||
178 | bool ret = false; | ||
179 | switch (shape.type) | ||
180 | { | ||
181 | case ShapeData.PhysicsShapeType.SHAPE_MESH: | ||
182 | MeshDesc meshDesc; | ||
183 | if (Meshes.TryGetValue(shape.shapeKey, out meshDesc)) | ||
184 | { | ||
185 | // There is an existing instance of this mesh. | ||
186 | meshDesc.referenceCount++; | ||
187 | DetailLog("{0},BSShapeCollection.ReferenceShape,existingMesh,key={1},cnt={2}", | ||
188 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount); | ||
189 | } | ||
190 | else | ||
191 | { | ||
192 | // This is a new reference to a mesh | ||
193 | meshDesc.ptr = shape.ptr; | ||
194 | meshDesc.shapeKey = shape.shapeKey; | ||
195 | // We keep a reference to the underlying IMesh data so a hull can be built | ||
196 | meshDesc.referenceCount = 1; | ||
197 | DetailLog("{0},BSShapeCollection.ReferenceShape,newMesh,key={1},cnt={2}", | ||
198 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount); | ||
199 | ret = true; | ||
200 | } | ||
201 | meshDesc.lastReferenced = System.DateTime.Now; | ||
202 | Meshes[shape.shapeKey] = meshDesc; | ||
203 | break; | ||
204 | case ShapeData.PhysicsShapeType.SHAPE_HULL: | ||
205 | HullDesc hullDesc; | ||
206 | if (Hulls.TryGetValue(shape.shapeKey, out hullDesc)) | ||
207 | { | ||
208 | // There is an existing instance of this hull. | ||
209 | hullDesc.referenceCount++; | ||
210 | DetailLog("{0},BSShapeCollection.ReferenceShape,existingHull,key={1},cnt={2}", | ||
211 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount); | ||
212 | } | ||
213 | else | ||
214 | { | ||
215 | // This is a new reference to a hull | ||
216 | hullDesc.ptr = shape.ptr; | ||
217 | hullDesc.shapeKey = shape.shapeKey; | ||
218 | hullDesc.referenceCount = 1; | ||
219 | DetailLog("{0},BSShapeCollection.ReferenceShape,newHull,key={1},cnt={2}", | ||
220 | BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount); | ||
221 | ret = true; | ||
222 | |||
223 | } | ||
224 | hullDesc.lastReferenced = System.DateTime.Now; | ||
225 | Hulls[shape.shapeKey] = hullDesc; | ||
226 | break; | ||
227 | case ShapeData.PhysicsShapeType.SHAPE_UNKNOWN: | ||
228 | break; | ||
229 | default: | ||
230 | // Native shapes are not tracked and they don't go into any list | ||
231 | break; | ||
232 | } | ||
233 | return ret; | ||
234 | } | ||
235 | |||
236 | // Release the usage of a shape. | ||
237 | public void DereferenceShape(BulletShape shape, bool inTaintTime, ShapeDestructionCallback shapeCallback) | ||
238 | { | ||
239 | if (shape.ptr == IntPtr.Zero) | ||
240 | return; | ||
241 | |||
242 | PhysicsScene.TaintedObject(inTaintTime, "BSShapeCollection.DereferenceShape", delegate() | ||
243 | { | ||
244 | if (shape.ptr != IntPtr.Zero) | ||
245 | { | ||
246 | if (shape.isNativeShape) | ||
247 | { | ||
248 | // Native shapes are not tracked and are released immediately | ||
249 | DetailLog("{0},BSShapeCollection.DereferenceShape,deleteNativeShape,ptr={1},taintTime={2}", | ||
250 | BSScene.DetailLogZero, shape.ptr.ToString("X"), inTaintTime); | ||
251 | if (shapeCallback != null) shapeCallback(shape); | ||
252 | BulletSimAPI.DeleteCollisionShape2(PhysicsScene.World.ptr, shape.ptr); | ||
253 | } | ||
254 | else | ||
255 | { | ||
256 | switch (shape.type) | ||
257 | { | ||
258 | case ShapeData.PhysicsShapeType.SHAPE_HULL: | ||
259 | DereferenceHull(shape, shapeCallback); | ||
260 | break; | ||
261 | case ShapeData.PhysicsShapeType.SHAPE_MESH: | ||
262 | DereferenceMesh(shape, shapeCallback); | ||
263 | break; | ||
264 | case ShapeData.PhysicsShapeType.SHAPE_COMPOUND: | ||
265 | DereferenceCompound(shape, shapeCallback); | ||
266 | break; | ||
267 | case ShapeData.PhysicsShapeType.SHAPE_UNKNOWN: | ||
268 | break; | ||
269 | default: | ||
270 | break; | ||
271 | } | ||
272 | } | ||
273 | } | ||
274 | }); | ||
275 | } | ||
276 | |||
277 | // Count down the reference count for a mesh shape | ||
278 | // Called at taint-time. | ||
279 | private void DereferenceMesh(BulletShape shape, ShapeDestructionCallback shapeCallback) | ||
280 | { | ||
281 | MeshDesc meshDesc; | ||
282 | if (Meshes.TryGetValue(shape.shapeKey, out meshDesc)) | ||
283 | { | ||
284 | meshDesc.referenceCount--; | ||
285 | // TODO: release the Bullet storage | ||
286 | if (shapeCallback != null) shapeCallback(shape); | ||
287 | meshDesc.lastReferenced = System.DateTime.Now; | ||
288 | Meshes[shape.shapeKey] = meshDesc; | ||
289 | DetailLog("{0},BSShapeCollection.DereferenceMesh,shape={1},refCnt={2}", | ||
290 | BSScene.DetailLogZero, shape, meshDesc.referenceCount); | ||
291 | |||
292 | } | ||
293 | } | ||
294 | |||
295 | // Count down the reference count for a hull shape | ||
296 | // Called at taint-time. | ||
297 | private void DereferenceHull(BulletShape shape, ShapeDestructionCallback shapeCallback) | ||
298 | { | ||
299 | HullDesc hullDesc; | ||
300 | if (Hulls.TryGetValue(shape.shapeKey, out hullDesc)) | ||
301 | { | ||
302 | hullDesc.referenceCount--; | ||
303 | // TODO: release the Bullet storage (aging old entries?) | ||
304 | |||
305 | // Tell upper layers that, if they have dependencies on this shape, this link is going away | ||
306 | if (shapeCallback != null) shapeCallback(shape); | ||
307 | |||
308 | hullDesc.lastReferenced = System.DateTime.Now; | ||
309 | Hulls[shape.shapeKey] = hullDesc; | ||
310 | DetailLog("{0},BSShapeCollection.DereferenceHull,shape={1},refCnt={2}", | ||
311 | BSScene.DetailLogZero, shape, hullDesc.referenceCount); | ||
312 | } | ||
313 | } | ||
314 | |||
315 | // Remove a reference to a compound shape. | ||
316 | // Taking a compound shape apart is a little tricky because if you just delete the | ||
317 | // physical shape, it will free all the underlying children. We can't do that because | ||
318 | // they could be shared. So, this removes each of the children from the compound and | ||
319 | // dereferences them separately before destroying the compound collision object itself. | ||
320 | // Called at taint-time. | ||
321 | private void DereferenceCompound(BulletShape shape, ShapeDestructionCallback shapeCallback) | ||
322 | { | ||
323 | if (!BulletSimAPI.IsCompound2(shape.ptr)) | ||
324 | { | ||
325 | // Failed the sanity check!! | ||
326 | PhysicsScene.Logger.ErrorFormat("{0} Attempt to free a compound shape that is not compound!! type={1}, ptr={2}", | ||
327 | LogHeader, shape.type, shape.ptr.ToString("X")); | ||
328 | DetailLog("{0},BSShapeCollection.DereferenceCompound,notACompoundShape,type={1},ptr={2}", | ||
329 | BSScene.DetailLogZero, shape.type, shape.ptr.ToString("X")); | ||
330 | return; | ||
331 | } | ||
332 | |||
333 | int numChildren = BulletSimAPI.GetNumberOfCompoundChildren2(shape.ptr); | ||
334 | DetailLog("{0},BSShapeCollection.DereferenceCompound,shape={1},children={2}", BSScene.DetailLogZero, shape, numChildren); | ||
335 | |||
336 | for (int ii = numChildren - 1; ii >= 0; ii--) | ||
337 | { | ||
338 | IntPtr childShape = BulletSimAPI.RemoveChildShapeFromCompoundShapeIndex2(shape.ptr, ii); | ||
339 | DereferenceAnonCollisionShape(childShape); | ||
340 | } | ||
341 | BulletSimAPI.DeleteCollisionShape2(PhysicsScene.World.ptr, shape.ptr); | ||
342 | } | ||
343 | |||
344 | // Sometimes we have a pointer to a collision shape but don't know what type it is. | ||
345 | // Figure out type and call the correct dereference routine. | ||
346 | // Called at taint-time. | ||
347 | private void DereferenceAnonCollisionShape(IntPtr cShape) | ||
348 | { | ||
349 | MeshDesc meshDesc; | ||
350 | HullDesc hullDesc; | ||
351 | |||
352 | BulletShape shapeInfo = new BulletShape(cShape); | ||
353 | if (TryGetMeshByPtr(cShape, out meshDesc)) | ||
354 | { | ||
355 | shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_MESH; | ||
356 | shapeInfo.shapeKey = meshDesc.shapeKey; | ||
357 | } | ||
358 | else | ||
359 | { | ||
360 | if (TryGetHullByPtr(cShape, out hullDesc)) | ||
361 | { | ||
362 | shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_HULL; | ||
363 | shapeInfo.shapeKey = hullDesc.shapeKey; | ||
364 | } | ||
365 | else | ||
366 | { | ||
367 | if (BulletSimAPI.IsCompound2(cShape)) | ||
368 | { | ||
369 | shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_COMPOUND; | ||
370 | } | ||
371 | else | ||
372 | { | ||
373 | if (BulletSimAPI.IsNativeShape2(cShape)) | ||
374 | { | ||
375 | shapeInfo.isNativeShape = true; | ||
376 | shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_BOX; // (technically, type doesn't matter) | ||
377 | } | ||
378 | } | ||
379 | } | ||
380 | } | ||
381 | |||
382 | DetailLog("{0},BSShapeCollection.DereferenceAnonCollisionShape,shape={1}", BSScene.DetailLogZero, shapeInfo); | ||
383 | |||
384 | if (shapeInfo.type != ShapeData.PhysicsShapeType.SHAPE_UNKNOWN) | ||
385 | { | ||
386 | DereferenceShape(shapeInfo, true, null); | ||
387 | } | ||
388 | else | ||
389 | { | ||
390 | PhysicsScene.Logger.ErrorFormat("{0} Could not decypher shape type. Region={1}, addr={2}", | ||
391 | LogHeader, PhysicsScene.RegionName, cShape.ToString("X")); | ||
392 | } | ||
393 | } | ||
394 | |||
395 | // Create the geometry information in Bullet for later use. | ||
396 | // The objects needs a hull if it's physical otherwise a mesh is enough. | ||
397 | // if 'forceRebuild' is true, the geometry is unconditionally rebuilt. For meshes and hulls, | ||
398 | // shared geometries will be used. If the parameters of the existing shape are the same | ||
399 | // as this request, the shape is not rebuilt. | ||
400 | // Info in prim.BSShape is updated to the new shape. | ||
401 | // Returns 'true' if the geometry was rebuilt. | ||
402 | // Called at taint-time! | ||
403 | private bool CreateGeom(bool forceRebuild, BSPhysObject prim, ShapeDestructionCallback shapeCallback) | ||
404 | { | ||
405 | bool ret = false; | ||
406 | bool haveShape = false; | ||
407 | |||
408 | if (!haveShape && prim.PreferredPhysicalShape == ShapeData.PhysicsShapeType.SHAPE_AVATAR) | ||
409 | { | ||
410 | // an avatar capsule is close to a native shape (it is not shared) | ||
411 | ret = GetReferenceToNativeShape(prim, ShapeData.PhysicsShapeType.SHAPE_AVATAR, | ||
412 | ShapeData.FixedShapeKey.KEY_CAPSULE, shapeCallback); | ||
413 | DetailLog("{0},BSShapeCollection.CreateGeom,avatarCapsule,shape={1}", prim.LocalID, prim.PhysShape); | ||
414 | ret = true; | ||
415 | haveShape = true; | ||
416 | } | ||
417 | |||
418 | // Compound shapes are handled special as they are rebuilt from scratch. | ||
419 | // This isn't too great a hardship since most of the child shapes will already been created. | ||
420 | if (!haveShape && prim.PreferredPhysicalShape == ShapeData.PhysicsShapeType.SHAPE_COMPOUND) | ||
421 | { | ||
422 | ret = GetReferenceToCompoundShape(prim, shapeCallback); | ||
423 | DetailLog("{0},BSShapeCollection.CreateGeom,compoundShape,shape={1}", prim.LocalID, prim.PhysShape); | ||
424 | haveShape = true; | ||
425 | } | ||
426 | |||
427 | if (!haveShape) | ||
428 | { | ||
429 | ret = CreateGeomNonSpecial(forceRebuild, prim, shapeCallback); | ||
430 | } | ||
431 | |||
432 | return ret; | ||
433 | } | ||
434 | |||
435 | // Create a mesh/hull shape or a native shape if 'nativeShapePossible' is 'true'. | ||
436 | private bool CreateGeomNonSpecial(bool forceRebuild, BSPhysObject prim, ShapeDestructionCallback shapeCallback) | ||
437 | { | ||
438 | bool ret = false; | ||
439 | bool haveShape = false; | ||
440 | bool nativeShapePossible = true; | ||
441 | PrimitiveBaseShape pbs = prim.BaseShape; | ||
442 | |||
443 | // If the prim attributes are simple, this could be a simple Bullet native shape | ||
444 | if (!haveShape | ||
445 | && pbs != null | ||
446 | && nativeShapePossible | ||
447 | && ((pbs.SculptEntry && !PhysicsScene.ShouldMeshSculptedPrim) | ||
448 | || (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0 | ||
449 | && pbs.ProfileHollow == 0 | ||
450 | && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0 | ||
451 | && pbs.PathBegin == 0 && pbs.PathEnd == 0 | ||
452 | && pbs.PathTaperX == 0 && pbs.PathTaperY == 0 | ||
453 | && pbs.PathScaleX == 100 && pbs.PathScaleY == 100 | ||
454 | && pbs.PathShearX == 0 && pbs.PathShearY == 0) ) ) | ||
455 | { | ||
456 | // It doesn't look like Bullet scales spheres so make sure the scales are all equal | ||
457 | if ((pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1) | ||
458 | && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z) | ||
459 | { | ||
460 | haveShape = true; | ||
461 | if (forceRebuild | ||
462 | || prim.Scale != prim.Size | ||
463 | || prim.PhysShape.type != ShapeData.PhysicsShapeType.SHAPE_SPHERE | ||
464 | ) | ||
465 | { | ||
466 | ret = GetReferenceToNativeShape(prim, ShapeData.PhysicsShapeType.SHAPE_SPHERE, | ||
467 | ShapeData.FixedShapeKey.KEY_SPHERE, shapeCallback); | ||
468 | DetailLog("{0},BSShapeCollection.CreateGeom,sphere,force={1},shape={2}", | ||
469 | prim.LocalID, forceRebuild, prim.PhysShape); | ||
470 | } | ||
471 | } | ||
472 | if (!haveShape && pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight) | ||
473 | { | ||
474 | haveShape = true; | ||
475 | if (forceRebuild | ||
476 | || prim.Scale != prim.Size | ||
477 | || prim.PhysShape.type != ShapeData.PhysicsShapeType.SHAPE_BOX | ||
478 | ) | ||
479 | { | ||
480 | ret = GetReferenceToNativeShape( prim, ShapeData.PhysicsShapeType.SHAPE_BOX, | ||
481 | ShapeData.FixedShapeKey.KEY_BOX, shapeCallback); | ||
482 | DetailLog("{0},BSShapeCollection.CreateGeom,box,force={1},shape={2}", | ||
483 | prim.LocalID, forceRebuild, prim.PhysShape); | ||
484 | } | ||
485 | } | ||
486 | } | ||
487 | |||
488 | // If a simple shape is not happening, create a mesh and possibly a hull. | ||
489 | if (!haveShape && pbs != null) | ||
490 | { | ||
491 | ret = CreateGeomMeshOrHull(prim, shapeCallback); | ||
492 | } | ||
493 | |||
494 | return ret; | ||
495 | } | ||
496 | |||
497 | public bool CreateGeomMeshOrHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback) | ||
498 | { | ||
499 | |||
500 | bool ret = false; | ||
501 | // Note that if it's a native shape, the check for physical/non-physical is not | ||
502 | // made. Native shapes work in either case. | ||
503 | if (prim.IsPhysical && PhysicsScene.ShouldUseHullsForPhysicalObjects) | ||
504 | { | ||
505 | // Update prim.BSShape to reference a hull of this shape. | ||
506 | ret = GetReferenceToHull(prim,shapeCallback); | ||
507 | DetailLog("{0},BSShapeCollection.CreateGeom,hull,shape={1},key={2}", | ||
508 | prim.LocalID, prim.PhysShape, prim.PhysShape.shapeKey.ToString("X")); | ||
509 | } | ||
510 | else | ||
511 | { | ||
512 | ret = GetReferenceToMesh(prim, shapeCallback); | ||
513 | DetailLog("{0},BSShapeCollection.CreateGeom,mesh,shape={1},key={2}", | ||
514 | prim.LocalID, prim.PhysShape, prim.PhysShape.shapeKey.ToString("X")); | ||
515 | } | ||
516 | return ret; | ||
517 | } | ||
518 | |||
519 | // Creates a native shape and assignes it to prim.BSShape. | ||
520 | // "Native" shapes are never shared. they are created here and destroyed in DereferenceShape(). | ||
521 | private bool GetReferenceToNativeShape(BSPhysObject prim, | ||
522 | ShapeData.PhysicsShapeType shapeType, ShapeData.FixedShapeKey shapeKey, | ||
523 | ShapeDestructionCallback shapeCallback) | ||
524 | { | ||
525 | // release any previous shape | ||
526 | DereferenceShape(prim.PhysShape, true, shapeCallback); | ||
527 | |||
528 | // Bullet native objects are scaled by the Bullet engine so pass the size in | ||
529 | prim.Scale = prim.Size; | ||
530 | |||
531 | BulletShape newShape = BuildPhysicalNativeShape(prim, shapeType, shapeKey); | ||
532 | |||
533 | // Don't need to do a 'ReferenceShape()' here because native shapes are not shared. | ||
534 | DetailLog("{0},BSShapeCollection.AddNativeShapeToPrim,create,newshape={1},scale={2}", | ||
535 | prim.LocalID, newShape, prim.Scale); | ||
536 | |||
537 | prim.PhysShape = newShape; | ||
538 | return true; | ||
539 | } | ||
540 | |||
541 | private BulletShape BuildPhysicalNativeShape(BSPhysObject prim, ShapeData.PhysicsShapeType shapeType, | ||
542 | ShapeData.FixedShapeKey shapeKey) | ||
543 | { | ||
544 | BulletShape newShape; | ||
545 | // Need to make sure the passed shape information is for the native type. | ||
546 | ShapeData nativeShapeData = new ShapeData(); | ||
547 | nativeShapeData.Type = shapeType; | ||
548 | nativeShapeData.ID = prim.LocalID; | ||
549 | nativeShapeData.Scale = prim.Scale; | ||
550 | nativeShapeData.Size = prim.Scale; | ||
551 | nativeShapeData.MeshKey = (ulong)shapeKey; | ||
552 | nativeShapeData.HullKey = (ulong)shapeKey; | ||
553 | |||
554 | if (shapeType == ShapeData.PhysicsShapeType.SHAPE_AVATAR) | ||
555 | { | ||
556 | newShape = new BulletShape( | ||
557 | BulletSimAPI.BuildCapsuleShape2(PhysicsScene.World.ptr, 1f, 1f, prim.Scale) | ||
558 | , shapeType); | ||
559 | DetailLog("{0},BSShapeCollection.BuiletPhysicalNativeShape,capsule,scale={1}", prim.LocalID, prim.Scale); | ||
560 | } | ||
561 | else | ||
562 | { | ||
563 | newShape = new BulletShape(BulletSimAPI.BuildNativeShape2(PhysicsScene.World.ptr, nativeShapeData), shapeType); | ||
564 | } | ||
565 | if (newShape.ptr == IntPtr.Zero) | ||
566 | { | ||
567 | PhysicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}", | ||
568 | LogHeader, prim.LocalID, shapeType); | ||
569 | } | ||
570 | newShape.shapeKey = (System.UInt64)shapeKey; | ||
571 | newShape.isNativeShape = true; | ||
572 | |||
573 | return newShape; | ||
574 | } | ||
575 | |||
576 | // Builds a mesh shape in the physical world and updates prim.BSShape. | ||
577 | // Dereferences previous shape in BSShape and adds a reference for this new shape. | ||
578 | // Returns 'true' of a mesh was actually built. Otherwise . | ||
579 | // Called at taint-time! | ||
580 | private bool GetReferenceToMesh(BSPhysObject prim, ShapeDestructionCallback shapeCallback) | ||
581 | { | ||
582 | BulletShape newShape = new BulletShape(IntPtr.Zero); | ||
583 | |||
584 | float lod; | ||
585 | System.UInt64 newMeshKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod); | ||
586 | |||
587 | // if this new shape is the same as last time, don't recreate the mesh | ||
588 | if (newMeshKey == prim.PhysShape.shapeKey && prim.PhysShape.type == ShapeData.PhysicsShapeType.SHAPE_MESH) | ||
589 | return false; | ||
590 | |||
591 | DetailLog("{0},BSShapeCollection.GetReferenceToMesh,create,oldKey={1},newKey={2}", | ||
592 | prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newMeshKey.ToString("X")); | ||
593 | |||
594 | // Since we're recreating new, get rid of the reference to the previous shape | ||
595 | DereferenceShape(prim.PhysShape, true, shapeCallback); | ||
596 | |||
597 | newShape = CreatePhysicalMesh(prim.PhysObjectName, newMeshKey, prim.BaseShape, prim.Size, lod); | ||
598 | // Take evasive action if the mesh was not constructed. | ||
599 | newShape = VerifyMeshCreated(newShape, prim); | ||
600 | |||
601 | ReferenceShape(newShape); | ||
602 | |||
603 | // meshes are already scaled by the meshmerizer | ||
604 | prim.Scale = new OMV.Vector3(1f, 1f, 1f); | ||
605 | prim.PhysShape = newShape; | ||
606 | |||
607 | return true; // 'true' means a new shape has been added to this prim | ||
608 | } | ||
609 | |||
610 | private BulletShape CreatePhysicalMesh(string objName, System.UInt64 newMeshKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod) | ||
611 | { | ||
612 | IMesh meshData = null; | ||
613 | IntPtr meshPtr = IntPtr.Zero; | ||
614 | MeshDesc meshDesc; | ||
615 | if (Meshes.TryGetValue(newMeshKey, out meshDesc)) | ||
616 | { | ||
617 | // If the mesh has already been built just use it. | ||
618 | meshPtr = meshDesc.ptr; | ||
619 | } | ||
620 | else | ||
621 | { | ||
622 | // Pass false for physicalness as this creates some sort of bounding box which we don't need | ||
623 | meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, false); | ||
624 | |||
625 | if (meshData != null) | ||
626 | { | ||
627 | int[] indices = meshData.getIndexListAsInt(); | ||
628 | List<OMV.Vector3> vertices = meshData.getVertexList(); | ||
629 | |||
630 | float[] verticesAsFloats = new float[vertices.Count * 3]; | ||
631 | int vi = 0; | ||
632 | foreach (OMV.Vector3 vv in vertices) | ||
633 | { | ||
634 | verticesAsFloats[vi++] = vv.X; | ||
635 | verticesAsFloats[vi++] = vv.Y; | ||
636 | verticesAsFloats[vi++] = vv.Z; | ||
637 | } | ||
638 | |||
639 | // m_log.DebugFormat("{0}: BSShapeCollection.CreatePhysicalMesh: calling CreateMesh. lid={1}, key={2}, indices={3}, vertices={4}", | ||
640 | // LogHeader, prim.LocalID, newMeshKey, indices.Length, vertices.Count); | ||
641 | |||
642 | meshPtr = BulletSimAPI.CreateMeshShape2(PhysicsScene.World.ptr, | ||
643 | indices.GetLength(0), indices, vertices.Count, verticesAsFloats); | ||
644 | } | ||
645 | } | ||
646 | BulletShape newShape = new BulletShape(meshPtr, ShapeData.PhysicsShapeType.SHAPE_MESH); | ||
647 | newShape.shapeKey = newMeshKey; | ||
648 | |||
649 | return newShape; | ||
650 | } | ||
651 | |||
652 | // See that hull shape exists in the physical world and update prim.BSShape. | ||
653 | // We could be creating the hull because scale changed or whatever. | ||
654 | private bool GetReferenceToHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback) | ||
655 | { | ||
656 | BulletShape newShape; | ||
657 | |||
658 | float lod; | ||
659 | System.UInt64 newHullKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod); | ||
660 | |||
661 | // if the hull hasn't changed, don't rebuild it | ||
662 | if (newHullKey == prim.PhysShape.shapeKey && prim.PhysShape.type == ShapeData.PhysicsShapeType.SHAPE_HULL) | ||
663 | return false; | ||
664 | |||
665 | DetailLog("{0},BSShapeCollection.GetReferenceToHull,create,oldKey={1},newKey={2}", | ||
666 | prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newHullKey.ToString("X")); | ||
667 | |||
668 | // Remove usage of the previous shape. | ||
669 | DereferenceShape(prim.PhysShape, true, shapeCallback); | ||
670 | |||
671 | newShape = CreatePhysicalHull(prim.PhysObjectName, newHullKey, prim.BaseShape, prim.Size, lod); | ||
672 | newShape = VerifyMeshCreated(newShape, prim); | ||
673 | |||
674 | ReferenceShape(newShape); | ||
675 | |||
676 | // hulls are already scaled by the meshmerizer | ||
677 | prim.Scale = new OMV.Vector3(1f, 1f, 1f); | ||
678 | prim.PhysShape = newShape; | ||
679 | return true; // 'true' means a new shape has been added to this prim | ||
680 | } | ||
681 | |||
682 | List<ConvexResult> m_hulls; | ||
683 | private BulletShape CreatePhysicalHull(string objName, System.UInt64 newHullKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod) | ||
684 | { | ||
685 | |||
686 | IntPtr hullPtr = IntPtr.Zero; | ||
687 | HullDesc hullDesc; | ||
688 | if (Hulls.TryGetValue(newHullKey, out hullDesc)) | ||
689 | { | ||
690 | // If the hull shape already is created, just use it. | ||
691 | hullPtr = hullDesc.ptr; | ||
692 | } | ||
693 | else | ||
694 | { | ||
695 | // Build a new hull in the physical world | ||
696 | // Pass false for physicalness as this creates some sort of bounding box which we don't need | ||
697 | IMesh meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, false); | ||
698 | if (meshData != null) | ||
699 | { | ||
700 | |||
701 | int[] indices = meshData.getIndexListAsInt(); | ||
702 | List<OMV.Vector3> vertices = meshData.getVertexList(); | ||
703 | |||
704 | //format conversion from IMesh format to DecompDesc format | ||
705 | List<int> convIndices = new List<int>(); | ||
706 | List<float3> convVertices = new List<float3>(); | ||
707 | for (int ii = 0; ii < indices.GetLength(0); ii++) | ||
708 | { | ||
709 | convIndices.Add(indices[ii]); | ||
710 | } | ||
711 | foreach (OMV.Vector3 vv in vertices) | ||
712 | { | ||
713 | convVertices.Add(new float3(vv.X, vv.Y, vv.Z)); | ||
714 | } | ||
715 | |||
716 | // setup and do convex hull conversion | ||
717 | m_hulls = new List<ConvexResult>(); | ||
718 | DecompDesc dcomp = new DecompDesc(); | ||
719 | dcomp.mIndices = convIndices; | ||
720 | dcomp.mVertices = convVertices; | ||
721 | ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn); | ||
722 | // create the hull into the _hulls variable | ||
723 | convexBuilder.process(dcomp); | ||
724 | |||
725 | // Convert the vertices and indices for passing to unmanaged. | ||
726 | // The hull information is passed as a large floating point array. | ||
727 | // The format is: | ||
728 | // convHulls[0] = number of hulls | ||
729 | // convHulls[1] = number of vertices in first hull | ||
730 | // convHulls[2] = hull centroid X coordinate | ||
731 | // convHulls[3] = hull centroid Y coordinate | ||
732 | // convHulls[4] = hull centroid Z coordinate | ||
733 | // convHulls[5] = first hull vertex X | ||
734 | // convHulls[6] = first hull vertex Y | ||
735 | // convHulls[7] = first hull vertex Z | ||
736 | // convHulls[8] = second hull vertex X | ||
737 | // ... | ||
738 | // convHulls[n] = number of vertices in second hull | ||
739 | // convHulls[n+1] = second hull centroid X coordinate | ||
740 | // ... | ||
741 | // | ||
742 | // TODO: is is very inefficient. Someday change the convex hull generator to return | ||
743 | // data structures that do not need to be converted in order to pass to Bullet. | ||
744 | // And maybe put the values directly into pinned memory rather than marshaling. | ||
745 | int hullCount = m_hulls.Count; | ||
746 | int totalVertices = 1; // include one for the count of the hulls | ||
747 | foreach (ConvexResult cr in m_hulls) | ||
748 | { | ||
749 | totalVertices += 4; // add four for the vertex count and centroid | ||
750 | totalVertices += cr.HullIndices.Count * 3; // we pass just triangles | ||
751 | } | ||
752 | float[] convHulls = new float[totalVertices]; | ||
753 | |||
754 | convHulls[0] = (float)hullCount; | ||
755 | int jj = 1; | ||
756 | foreach (ConvexResult cr in m_hulls) | ||
757 | { | ||
758 | // copy vertices for index access | ||
759 | float3[] verts = new float3[cr.HullVertices.Count]; | ||
760 | int kk = 0; | ||
761 | foreach (float3 ff in cr.HullVertices) | ||
762 | { | ||
763 | verts[kk++] = ff; | ||
764 | } | ||
765 | |||
766 | // add to the array one hull's worth of data | ||
767 | convHulls[jj++] = cr.HullIndices.Count; | ||
768 | convHulls[jj++] = 0f; // centroid x,y,z | ||
769 | convHulls[jj++] = 0f; | ||
770 | convHulls[jj++] = 0f; | ||
771 | foreach (int ind in cr.HullIndices) | ||
772 | { | ||
773 | convHulls[jj++] = verts[ind].x; | ||
774 | convHulls[jj++] = verts[ind].y; | ||
775 | convHulls[jj++] = verts[ind].z; | ||
776 | } | ||
777 | } | ||
778 | // create the hull data structure in Bullet | ||
779 | hullPtr = BulletSimAPI.CreateHullShape2(PhysicsScene.World.ptr, hullCount, convHulls); | ||
780 | } | ||
781 | } | ||
782 | |||
783 | BulletShape newShape = new BulletShape(hullPtr, ShapeData.PhysicsShapeType.SHAPE_HULL); | ||
784 | newShape.shapeKey = newHullKey; | ||
785 | |||
786 | return newShape; // 'true' means a new shape has been added to this prim | ||
787 | } | ||
788 | |||
789 | // Callback from convex hull creater with a newly created hull. | ||
790 | // Just add it to our collection of hulls for this shape. | ||
791 | private void HullReturn(ConvexResult result) | ||
792 | { | ||
793 | m_hulls.Add(result); | ||
794 | return; | ||
795 | } | ||
796 | |||
797 | // Compound shapes are always built from scratch. | ||
798 | // This shouldn't be to bad since most of the parts will be meshes that had been built previously. | ||
799 | private bool GetReferenceToCompoundShape(BSPhysObject prim, ShapeDestructionCallback shapeCallback) | ||
800 | { | ||
801 | // Remove reference to the old shape | ||
802 | // Don't need to do this as the shape is freed when the new root shape is created below. | ||
803 | // DereferenceShape(prim.PhysShape, true, shapeCallback); | ||
804 | |||
805 | BulletShape cShape = new BulletShape( | ||
806 | BulletSimAPI.CreateCompoundShape2(PhysicsScene.World.ptr, false), ShapeData.PhysicsShapeType.SHAPE_COMPOUND); | ||
807 | |||
808 | // Create the shape for the root prim and add it to the compound shape. Cannot be a native shape. | ||
809 | CreateGeomMeshOrHull(prim, shapeCallback); | ||
810 | BulletSimAPI.AddChildShapeToCompoundShape2(cShape.ptr, prim.PhysShape.ptr, OMV.Vector3.Zero, OMV.Quaternion.Identity); | ||
811 | DetailLog("{0},BSShapeCollection.GetReferenceToCompoundShape,addRootPrim,compShape={1},rootShape={2}", | ||
812 | prim.LocalID, cShape, prim.PhysShape); | ||
813 | |||
814 | prim.PhysShape = cShape; | ||
815 | |||
816 | return true; | ||
817 | } | ||
818 | |||
819 | // Create a hash of all the shape parameters to be used as a key | ||
820 | // for this particular shape. | ||
821 | private System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs, out float retLod) | ||
822 | { | ||
823 | // level of detail based on size and type of the object | ||
824 | float lod = PhysicsScene.MeshLOD; | ||
825 | if (pbs.SculptEntry) | ||
826 | lod = PhysicsScene.SculptLOD; | ||
827 | |||
828 | // Mega prims usually get more detail because one can interact with shape approximations at this size. | ||
829 | float maxAxis = Math.Max(size.X, Math.Max(size.Y, size.Z)); | ||
830 | if (maxAxis > PhysicsScene.MeshMegaPrimThreshold) | ||
831 | lod = PhysicsScene.MeshMegaPrimLOD; | ||
832 | |||
833 | retLod = lod; | ||
834 | return pbs.GetMeshKey(size, lod); | ||
835 | } | ||
836 | // For those who don't want the LOD | ||
837 | private System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs) | ||
838 | { | ||
839 | float lod; | ||
840 | return ComputeShapeKey(size, pbs, out lod); | ||
841 | } | ||
842 | |||
843 | // The creation of a mesh or hull can fail if an underlying asset is not available. | ||
844 | // There are two cases: 1) the asset is not in the cache and it needs to be fetched; | ||
845 | // and 2) the asset cannot be converted (like failed decompression of JPEG2000s). | ||
846 | // The first case causes the asset to be fetched. The second case requires | ||
847 | // us to not loop forever. | ||
848 | // Called after creating a physical mesh or hull. If the physical shape was created, | ||
849 | // just return. | ||
850 | private BulletShape VerifyMeshCreated(BulletShape newShape, BSPhysObject prim) | ||
851 | { | ||
852 | // If the shape was successfully created, nothing more to do | ||
853 | if (newShape.ptr != IntPtr.Zero) | ||
854 | return newShape; | ||
855 | |||
856 | // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset | ||
857 | if (prim.BaseShape.SculptEntry && !prim.LastAssetBuildFailed && prim.BaseShape.SculptTexture != OMV.UUID.Zero) | ||
858 | { | ||
859 | prim.LastAssetBuildFailed = true; | ||
860 | BSPhysObject xprim = prim; | ||
861 | DetailLog("{0},BSShapeCollection.VerifyMeshCreated,fetchAsset,lID={1},lastFailed={2}", | ||
862 | LogHeader, prim.LocalID, prim.LastAssetBuildFailed); | ||
863 | Util.FireAndForget(delegate | ||
864 | { | ||
865 | RequestAssetDelegate assetProvider = PhysicsScene.RequestAssetMethod; | ||
866 | if (assetProvider != null) | ||
867 | { | ||
868 | BSPhysObject yprim = xprim; // probably not necessary, but, just in case. | ||
869 | assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset) | ||
870 | { | ||
871 | if (!yprim.BaseShape.SculptEntry) | ||
872 | return; | ||
873 | if (yprim.BaseShape.SculptTexture.ToString() != asset.ID) | ||
874 | return; | ||
875 | |||
876 | yprim.BaseShape.SculptData = asset.Data; | ||
877 | // This will cause the prim to see that the filler shape is not the right | ||
878 | // one and try again to build the object. | ||
879 | // No race condition with the normal shape setting since the rebuild is at taint time. | ||
880 | yprim.ForceBodyShapeRebuild(false); | ||
881 | |||
882 | }); | ||
883 | } | ||
884 | }); | ||
885 | } | ||
886 | else | ||
887 | { | ||
888 | if (prim.LastAssetBuildFailed) | ||
889 | { | ||
890 | PhysicsScene.Logger.ErrorFormat("{0} Mesh failed to fetch asset. lID={1}, texture={2}", | ||
891 | LogHeader, prim.LocalID, prim.BaseShape.SculptTexture); | ||
892 | } | ||
893 | } | ||
894 | |||
895 | // While we figure out the real problem, stick a simple native shape on the object. | ||
896 | BulletShape fillinShape = | ||
897 | BuildPhysicalNativeShape(prim, ShapeData.PhysicsShapeType.SHAPE_BOX, ShapeData.FixedShapeKey.KEY_BOX); | ||
898 | |||
899 | return fillinShape; | ||
900 | } | ||
901 | |||
902 | // Create a body object in Bullet. | ||
903 | // Updates prim.BSBody with the information about the new body if one is created. | ||
904 | // Returns 'true' if an object was actually created. | ||
905 | // Called at taint-time. | ||
906 | private bool CreateBody(bool forceRebuild, BSPhysObject prim, BulletSim sim, BulletShape shape, | ||
907 | BodyDestructionCallback bodyCallback) | ||
908 | { | ||
909 | bool ret = false; | ||
910 | |||
911 | // the mesh, hull or native shape must have already been created in Bullet | ||
912 | bool mustRebuild = (prim.PhysBody.ptr == IntPtr.Zero); | ||
913 | |||
914 | // If there is an existing body, verify it's of an acceptable type. | ||
915 | // If not a solid object, body is a GhostObject. Otherwise a RigidBody. | ||
916 | if (!mustRebuild) | ||
917 | { | ||
918 | CollisionObjectTypes bodyType = (CollisionObjectTypes)BulletSimAPI.GetBodyType2(prim.PhysBody.ptr); | ||
919 | if (prim.IsSolid && bodyType != CollisionObjectTypes.CO_RIGID_BODY | ||
920 | || !prim.IsSolid && bodyType != CollisionObjectTypes.CO_GHOST_OBJECT) | ||
921 | { | ||
922 | // If the collisionObject is not the correct type for solidness, rebuild what's there | ||
923 | mustRebuild = true; | ||
924 | } | ||
925 | } | ||
926 | |||
927 | if (mustRebuild || forceRebuild) | ||
928 | { | ||
929 | // Free any old body | ||
930 | DereferenceBody(prim.PhysBody, true, bodyCallback); | ||
931 | |||
932 | BulletBody aBody; | ||
933 | IntPtr bodyPtr = IntPtr.Zero; | ||
934 | if (prim.IsSolid) | ||
935 | { | ||
936 | bodyPtr = BulletSimAPI.CreateBodyFromShape2(sim.ptr, shape.ptr, | ||
937 | prim.LocalID, prim.RawPosition, prim.RawOrientation); | ||
938 | DetailLog("{0},BSShapeCollection.CreateBody,mesh,ptr={1}", prim.LocalID, bodyPtr.ToString("X")); | ||
939 | } | ||
940 | else | ||
941 | { | ||
942 | bodyPtr = BulletSimAPI.CreateGhostFromShape2(sim.ptr, shape.ptr, | ||
943 | prim.LocalID, prim.ForcePosition, prim.ForceOrientation); | ||
944 | DetailLog("{0},BSShapeCollection.CreateBody,ghost,ptr={1}", prim.LocalID, bodyPtr.ToString("X")); | ||
945 | } | ||
946 | aBody = new BulletBody(prim.LocalID, bodyPtr); | ||
947 | |||
948 | ReferenceBody(aBody, true); | ||
949 | |||
950 | prim.PhysBody = aBody; | ||
951 | |||
952 | ret = true; | ||
953 | } | ||
954 | |||
955 | return ret; | ||
956 | } | ||
957 | |||
958 | private bool TryGetMeshByPtr(IntPtr addr, out MeshDesc outDesc) | ||
959 | { | ||
960 | bool ret = false; | ||
961 | MeshDesc foundDesc = new MeshDesc(); | ||
962 | foreach (MeshDesc md in Meshes.Values) | ||
963 | { | ||
964 | if (md.ptr == addr) | ||
965 | { | ||
966 | foundDesc = md; | ||
967 | ret = true; | ||
968 | break; | ||
969 | } | ||
970 | |||
971 | } | ||
972 | outDesc = foundDesc; | ||
973 | return ret; | ||
974 | } | ||
975 | |||
976 | private bool TryGetHullByPtr(IntPtr addr, out HullDesc outDesc) | ||
977 | { | ||
978 | bool ret = false; | ||
979 | HullDesc foundDesc = new HullDesc(); | ||
980 | foreach (HullDesc hd in Hulls.Values) | ||
981 | { | ||
982 | if (hd.ptr == addr) | ||
983 | { | ||
984 | foundDesc = hd; | ||
985 | ret = true; | ||
986 | break; | ||
987 | } | ||
988 | |||
989 | } | ||
990 | outDesc = foundDesc; | ||
991 | return ret; | ||
992 | } | ||
993 | |||
994 | private void DetailLog(string msg, params Object[] args) | ||
995 | { | ||
996 | if (PhysicsScene.PhysicsLogging.Enabled) | ||
997 | PhysicsScene.DetailLog(msg, args); | ||
998 | } | ||
999 | } | ||
1000 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs new file mode 100755 index 0000000..d59a486 --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs | |||
@@ -0,0 +1,208 @@ | |||
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 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Linq; | ||
31 | using System.Text; | ||
32 | |||
33 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
34 | { | ||
35 | public abstract class BSShape | ||
36 | { | ||
37 | public IntPtr ptr { get; set; } | ||
38 | public ShapeData.PhysicsShapeType type { get; set; } | ||
39 | public System.UInt64 key { get; set; } | ||
40 | public int referenceCount { get; set; } | ||
41 | public DateTime lastReferenced { get; set; } | ||
42 | |||
43 | public BSShape() | ||
44 | { | ||
45 | ptr = IntPtr.Zero; | ||
46 | type = ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; | ||
47 | key = 0; | ||
48 | referenceCount = 0; | ||
49 | lastReferenced = DateTime.Now; | ||
50 | } | ||
51 | |||
52 | // Get a reference to a physical shape. Create if it doesn't exist | ||
53 | public static BSShape GetShapeReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim) | ||
54 | { | ||
55 | BSShape ret = null; | ||
56 | |||
57 | if (prim.PreferredPhysicalShape == ShapeData.PhysicsShapeType.SHAPE_AVATAR) | ||
58 | { | ||
59 | // an avatar capsule is close to a native shape (it is not shared) | ||
60 | ret = BSShapeNative.GetReference(physicsScene, prim, ShapeData.PhysicsShapeType.SHAPE_AVATAR, | ||
61 | ShapeData.FixedShapeKey.KEY_CAPSULE); | ||
62 | physicsScene.DetailLog("{0},BSShape.GetShapeReference,avatarCapsule,shape={1}", prim.LocalID, ret); | ||
63 | } | ||
64 | |||
65 | // Compound shapes are handled special as they are rebuilt from scratch. | ||
66 | // This isn't too great a hardship since most of the child shapes will already been created. | ||
67 | if (ret == null && prim.PreferredPhysicalShape == ShapeData.PhysicsShapeType.SHAPE_COMPOUND) | ||
68 | { | ||
69 | // Getting a reference to a compound shape gets you the compound shape with the root prim shape added | ||
70 | ret = BSShapeCompound.GetReference(prim); | ||
71 | physicsScene.DetailLog("{0},BSShapeCollection.CreateGeom,compoundShape,shape={1}", prim.LocalID, ret); | ||
72 | } | ||
73 | |||
74 | if (ret == null) | ||
75 | ret = GetShapeReferenceNonSpecial(physicsScene, forceRebuild, prim); | ||
76 | |||
77 | return ret; | ||
78 | } | ||
79 | public static BSShape GetShapeReferenceNonSpecial(BSScene physicsScene, bool forceRebuild, BSPhysObject prim) | ||
80 | { | ||
81 | return null; | ||
82 | } | ||
83 | public static BSShape GetShapeReferenceNonNative(BSScene physicsScene, bool forceRebuild, BSPhysObject prim) | ||
84 | { | ||
85 | return null; | ||
86 | } | ||
87 | |||
88 | // Release the use of a physical shape. | ||
89 | public abstract void Dereference(BSScene physicsScene); | ||
90 | |||
91 | // All shapes have a static call to get a reference to the physical shape | ||
92 | // protected abstract static BSShape GetReference(); | ||
93 | |||
94 | public override string ToString() | ||
95 | { | ||
96 | StringBuilder buff = new StringBuilder(); | ||
97 | buff.Append("<p="); | ||
98 | buff.Append(ptr.ToString("X")); | ||
99 | buff.Append(",s="); | ||
100 | buff.Append(type.ToString()); | ||
101 | buff.Append(",k="); | ||
102 | buff.Append(key.ToString("X")); | ||
103 | buff.Append(",c="); | ||
104 | buff.Append(referenceCount.ToString()); | ||
105 | buff.Append(">"); | ||
106 | return buff.ToString(); | ||
107 | } | ||
108 | } | ||
109 | |||
110 | public class BSShapeNull : BSShape | ||
111 | { | ||
112 | public BSShapeNull() : base() | ||
113 | { | ||
114 | } | ||
115 | public static BSShape GetReference() { return new BSShapeNull(); } | ||
116 | public override void Dereference(BSScene physicsScene) { /* The magic of garbage collection will make this go away */ } | ||
117 | } | ||
118 | |||
119 | public class BSShapeNative : BSShape | ||
120 | { | ||
121 | private static string LogHeader = "[BULLETSIM SHAPE NATIVE]"; | ||
122 | public BSShapeNative() : base() | ||
123 | { | ||
124 | } | ||
125 | public static BSShape GetReference(BSScene physicsScene, BSPhysObject prim, | ||
126 | ShapeData.PhysicsShapeType shapeType, ShapeData.FixedShapeKey shapeKey) | ||
127 | { | ||
128 | // Native shapes are not shared and are always built anew. | ||
129 | return new BSShapeNative(physicsScene, prim, shapeType, shapeKey); | ||
130 | } | ||
131 | |||
132 | private BSShapeNative(BSScene physicsScene, BSPhysObject prim, | ||
133 | ShapeData.PhysicsShapeType shapeType, ShapeData.FixedShapeKey shapeKey) | ||
134 | { | ||
135 | ShapeData nativeShapeData = new ShapeData(); | ||
136 | nativeShapeData.Type = shapeType; | ||
137 | nativeShapeData.ID = prim.LocalID; | ||
138 | nativeShapeData.Scale = prim.Scale; | ||
139 | nativeShapeData.Size = prim.Scale; | ||
140 | nativeShapeData.MeshKey = (ulong)shapeKey; | ||
141 | nativeShapeData.HullKey = (ulong)shapeKey; | ||
142 | |||
143 | |||
144 | if (shapeType == ShapeData.PhysicsShapeType.SHAPE_AVATAR) | ||
145 | { | ||
146 | ptr = BulletSimAPI.BuildCapsuleShape2(physicsScene.World.ptr, 1f, 1f, prim.Scale); | ||
147 | physicsScene.DetailLog("{0},BSShapeCollection.BuiletPhysicalNativeShape,capsule,scale={1}", prim.LocalID, prim.Scale); | ||
148 | } | ||
149 | else | ||
150 | { | ||
151 | ptr = BulletSimAPI.BuildNativeShape2(physicsScene.World.ptr, nativeShapeData); | ||
152 | } | ||
153 | if (ptr == IntPtr.Zero) | ||
154 | { | ||
155 | physicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}", | ||
156 | LogHeader, prim.LocalID, shapeType); | ||
157 | } | ||
158 | type = shapeType; | ||
159 | key = (UInt64)shapeKey; | ||
160 | } | ||
161 | // Make this reference to the physical shape go away since native shapes are not shared. | ||
162 | public override void Dereference(BSScene physicsScene) | ||
163 | { | ||
164 | // Native shapes are not tracked and are released immediately | ||
165 | physicsScene.DetailLog("{0},BSShapeCollection.DereferenceShape,deleteNativeShape,shape={1}", BSScene.DetailLogZero, this); | ||
166 | BulletSimAPI.DeleteCollisionShape2(physicsScene.World.ptr, ptr); | ||
167 | ptr = IntPtr.Zero; | ||
168 | // Garbage collection will free up this instance. | ||
169 | } | ||
170 | } | ||
171 | |||
172 | public class BSShapeMesh : BSShape | ||
173 | { | ||
174 | private static string LogHeader = "[BULLETSIM SHAPE MESH]"; | ||
175 | private static Dictionary<System.UInt64, BSShapeMesh> Meshes = new Dictionary<System.UInt64, BSShapeMesh>(); | ||
176 | |||
177 | public BSShapeMesh() : base() | ||
178 | { | ||
179 | } | ||
180 | public static BSShape GetReference() { return new BSShapeNull(); } | ||
181 | public override void Dereference(BSScene physicsScene) { } | ||
182 | } | ||
183 | |||
184 | public class BSShapeHull : BSShape | ||
185 | { | ||
186 | private static string LogHeader = "[BULLETSIM SHAPE HULL]"; | ||
187 | private static Dictionary<System.UInt64, BSShapeHull> Hulls = new Dictionary<System.UInt64, BSShapeHull>(); | ||
188 | |||
189 | public BSShapeHull() : base() | ||
190 | { | ||
191 | } | ||
192 | public static BSShape GetReference() { return new BSShapeNull(); } | ||
193 | public override void Dereference(BSScene physicsScene) { } | ||
194 | } | ||
195 | |||
196 | public class BSShapeCompound : BSShape | ||
197 | { | ||
198 | private static string LogHeader = "[BULLETSIM SHAPE COMPOUND]"; | ||
199 | public BSShapeCompound() : base() | ||
200 | { | ||
201 | } | ||
202 | public static BSShape GetReference(BSPhysObject prim) | ||
203 | { | ||
204 | return new BSShapeNull(); | ||
205 | } | ||
206 | public override void Dereference(BSScene physicsScene) { } | ||
207 | } | ||
208 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs new file mode 100755 index 0000000..7c34af2 --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs | |||
@@ -0,0 +1,479 @@ | |||
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 sealed 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 | BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, m_groundPlane.ptr); | ||
118 | // Ground plane does not move | ||
119 | BulletSimAPI.ForceActivationState2(m_groundPlane.ptr, ActivationState.DISABLE_SIMULATION); | ||
120 | // Everything collides with the ground plane. | ||
121 | BulletSimAPI.SetCollisionFilterMask2(m_groundPlane.ptr, | ||
122 | (uint)CollisionFilterGroups.GroundPlaneFilter, (uint)CollisionFilterGroups.GroundPlaneMask); | ||
123 | |||
124 | Vector3 minTerrainCoords = new Vector3(0f, 0f, HEIGHT_INITIALIZATION - HEIGHT_EQUAL_FUDGE); | ||
125 | Vector3 maxTerrainCoords = new Vector3(DefaultRegionSize.X, DefaultRegionSize.Y, HEIGHT_INITIALIZATION); | ||
126 | int totalHeights = (int)maxTerrainCoords.X * (int)maxTerrainCoords.Y; | ||
127 | float[] initialMap = new float[totalHeights]; | ||
128 | for (int ii = 0; ii < totalHeights; ii++) | ||
129 | { | ||
130 | initialMap[ii] = HEIGHT_INITIALIZATION; | ||
131 | } | ||
132 | UpdateOrCreateTerrain(BSScene.TERRAIN_ID, initialMap, minTerrainCoords, maxTerrainCoords, true); | ||
133 | } | ||
134 | |||
135 | // Release all the terrain structures we might have allocated | ||
136 | public void ReleaseGroundPlaneAndTerrain() | ||
137 | { | ||
138 | if (m_groundPlane.ptr != IntPtr.Zero) | ||
139 | { | ||
140 | if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr)) | ||
141 | { | ||
142 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, m_groundPlane.ptr); | ||
143 | } | ||
144 | m_groundPlane.ptr = IntPtr.Zero; | ||
145 | } | ||
146 | |||
147 | ReleaseTerrain(); | ||
148 | } | ||
149 | |||
150 | // Release all the terrain we have allocated | ||
151 | public void ReleaseTerrain() | ||
152 | { | ||
153 | foreach (KeyValuePair<Vector2, BulletHeightMapInfo> kvp in m_heightMaps) | ||
154 | { | ||
155 | if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, kvp.Value.terrainBody.ptr)) | ||
156 | { | ||
157 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, kvp.Value.terrainBody.ptr); | ||
158 | BulletSimAPI.ReleaseHeightMapInfo2(kvp.Value.Ptr); | ||
159 | } | ||
160 | } | ||
161 | m_heightMaps.Clear(); | ||
162 | } | ||
163 | |||
164 | // The simulator wants to set a new heightmap for the terrain. | ||
165 | public void SetTerrain(float[] heightMap) { | ||
166 | float[] localHeightMap = heightMap; | ||
167 | PhysicsScene.TaintedObject("TerrainManager.SetTerrain", delegate() | ||
168 | { | ||
169 | if (m_worldOffset != Vector3.Zero && MegaRegionParentPhysicsScene != null) | ||
170 | { | ||
171 | // If a child of a mega-region, we shouldn't have any terrain allocated for us | ||
172 | ReleaseGroundPlaneAndTerrain(); | ||
173 | // If doing the mega-prim stuff and we are the child of the zero region, | ||
174 | // the terrain is added to our parent | ||
175 | if (MegaRegionParentPhysicsScene is BSScene) | ||
176 | { | ||
177 | DetailLog("{0},SetTerrain.ToParent,offset={1},worldMax={2}", | ||
178 | BSScene.DetailLogZero, m_worldOffset, m_worldMax); | ||
179 | ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.UpdateOrCreateTerrain(BSScene.CHILDTERRAIN_ID, | ||
180 | localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize, true); | ||
181 | } | ||
182 | } | ||
183 | else | ||
184 | { | ||
185 | // If not doing the mega-prim thing, just change the terrain | ||
186 | DetailLog("{0},SetTerrain.Existing", BSScene.DetailLogZero); | ||
187 | |||
188 | UpdateOrCreateTerrain(BSScene.TERRAIN_ID, localHeightMap, | ||
189 | m_worldOffset, m_worldOffset + DefaultRegionSize, true); | ||
190 | } | ||
191 | }); | ||
192 | } | ||
193 | |||
194 | // If called with no mapInfo for the terrain, this will create a new mapInfo and terrain | ||
195 | // based on the passed information. The 'id' should be either the terrain id or | ||
196 | // BSScene.CHILDTERRAIN_ID. If the latter, a new child terrain ID will be allocated and used. | ||
197 | // The latter feature is for creating child terrains for mega-regions. | ||
198 | // If called with a mapInfo in m_heightMaps but the terrain has no body yet (mapInfo.terrainBody.Ptr == 0) | ||
199 | // then a new body and shape is created and the mapInfo is filled. | ||
200 | // This call is used for doing the initial terrain creation. | ||
201 | // If called with a mapInfo in m_heightMaps and there is an existing terrain body, a new | ||
202 | // terrain shape is created and added to the body. | ||
203 | // This call is most often used to update the heightMap and parameters of the terrain. | ||
204 | // (The above does suggest that some simplification/refactoring is in order.) | ||
205 | private void UpdateOrCreateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords, bool inTaintTime) | ||
206 | { | ||
207 | DetailLog("{0},BSTerrainManager.UpdateOrCreateTerrain,call,minC={1},maxC={2},inTaintTime={3}", | ||
208 | BSScene.DetailLogZero, minCoords, maxCoords, inTaintTime); | ||
209 | |||
210 | float minZ = float.MaxValue; | ||
211 | float maxZ = float.MinValue; | ||
212 | Vector2 terrainRegionBase = new Vector2(minCoords.X, minCoords.Y); | ||
213 | |||
214 | int heightMapSize = heightMap.Length; | ||
215 | for (int ii = 0; ii < heightMapSize; ii++) | ||
216 | { | ||
217 | float height = heightMap[ii]; | ||
218 | if (height < minZ) minZ = height; | ||
219 | if (height > maxZ) maxZ = height; | ||
220 | } | ||
221 | |||
222 | // The shape of the terrain is from its base to its extents. | ||
223 | minCoords.Z = minZ; | ||
224 | maxCoords.Z = maxZ; | ||
225 | |||
226 | BulletHeightMapInfo mapInfo; | ||
227 | if (m_heightMaps.TryGetValue(terrainRegionBase, out mapInfo)) | ||
228 | { | ||
229 | // If this is terrain we know about, it's easy to update | ||
230 | |||
231 | mapInfo.heightMap = heightMap; | ||
232 | mapInfo.minCoords = minCoords; | ||
233 | mapInfo.maxCoords = maxCoords; | ||
234 | mapInfo.minZ = minZ; | ||
235 | mapInfo.maxZ = maxZ; | ||
236 | mapInfo.sizeX = maxCoords.X - minCoords.X; | ||
237 | mapInfo.sizeY = maxCoords.Y - minCoords.Y; | ||
238 | DetailLog("{0},UpdateOrCreateTerrain:UpdateExisting,call,terrainBase={1},minC={2}, maxC={3}, szX={4}, szY={5}", | ||
239 | BSScene.DetailLogZero, terrainRegionBase, mapInfo.minCoords, mapInfo.maxCoords, mapInfo.sizeX, mapInfo.sizeY); | ||
240 | |||
241 | PhysicsScene.TaintedObject(inTaintTime, "BSScene.UpdateOrCreateTerrain:UpdateExisting", delegate() | ||
242 | { | ||
243 | if (MegaRegionParentPhysicsScene != null) | ||
244 | { | ||
245 | // It's possible that Combine() was called after this code was queued. | ||
246 | // If we are a child of combined regions, we don't create any terrain for us. | ||
247 | DetailLog("{0},UpdateOrCreateTerrain:AmACombineChild,taint", BSScene.DetailLogZero); | ||
248 | |||
249 | // Get rid of any terrain that may have been allocated for us. | ||
250 | ReleaseGroundPlaneAndTerrain(); | ||
251 | |||
252 | // I hate doing this, but just bail | ||
253 | return; | ||
254 | } | ||
255 | |||
256 | if (mapInfo.terrainBody.ptr != IntPtr.Zero) | ||
257 | { | ||
258 | // Updating an existing terrain. | ||
259 | DetailLog("{0},UpdateOrCreateTerrain:UpdateExisting,taint,terrainBase={1},minC={2}, maxC={3}, szX={4}, szY={5}", | ||
260 | BSScene.DetailLogZero, terrainRegionBase, mapInfo.minCoords, mapInfo.maxCoords, mapInfo.sizeX, mapInfo.sizeY); | ||
261 | |||
262 | // Remove from the dynamics world because we're going to mangle this object | ||
263 | BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
264 | |||
265 | // Get rid of the old terrain | ||
266 | BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
267 | BulletSimAPI.ReleaseHeightMapInfo2(mapInfo.Ptr); | ||
268 | mapInfo.Ptr = IntPtr.Zero; | ||
269 | |||
270 | /* | ||
271 | // NOTE: This routine is half here because I can't get the terrain shape replacement | ||
272 | // to work. In the short term, the above three lines completely delete the old | ||
273 | // terrain and the code below recreates one from scratch. | ||
274 | // Hopefully the Bullet community will help me out on this one. | ||
275 | |||
276 | // First, release the old collision shape (there is only one terrain) | ||
277 | BulletSimAPI.DeleteCollisionShape2(m_physicsScene.World.Ptr, mapInfo.terrainShape.Ptr); | ||
278 | |||
279 | // Fill the existing height map info with the new location and size information | ||
280 | BulletSimAPI.FillHeightMapInfo2(m_physicsScene.World.Ptr, mapInfo.Ptr, mapInfo.ID, | ||
281 | mapInfo.minCoords, mapInfo.maxCoords, mapInfo.heightMap, TERRAIN_COLLISION_MARGIN); | ||
282 | |||
283 | // Create a terrain shape based on the new info | ||
284 | mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(mapInfo.Ptr)); | ||
285 | |||
286 | // Stuff the shape into the existing terrain body | ||
287 | BulletSimAPI.SetBodyShape2(m_physicsScene.World.Ptr, mapInfo.terrainBody.Ptr, mapInfo.terrainShape.Ptr); | ||
288 | */ | ||
289 | } | ||
290 | // else | ||
291 | { | ||
292 | // Creating a new terrain. | ||
293 | DetailLog("{0},UpdateOrCreateTerrain:CreateNewTerrain,taint,baseX={1},baseY={2},minZ={3},maxZ={4}", | ||
294 | BSScene.DetailLogZero, mapInfo.minCoords.X, mapInfo.minCoords.Y, minZ, maxZ); | ||
295 | |||
296 | mapInfo.ID = id; | ||
297 | mapInfo.Ptr = BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, mapInfo.ID, | ||
298 | mapInfo.minCoords, mapInfo.maxCoords, mapInfo.heightMap, TERRAIN_COLLISION_MARGIN); | ||
299 | |||
300 | // Create the terrain shape from the mapInfo | ||
301 | mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(mapInfo.Ptr), | ||
302 | ShapeData.PhysicsShapeType.SHAPE_TERRAIN); | ||
303 | |||
304 | // The terrain object initial position is at the center of the object | ||
305 | Vector3 centerPos; | ||
306 | centerPos.X = minCoords.X + (mapInfo.sizeX / 2f); | ||
307 | centerPos.Y = minCoords.Y + (mapInfo.sizeY / 2f); | ||
308 | centerPos.Z = minZ + ((maxZ - minZ) / 2f); | ||
309 | |||
310 | mapInfo.terrainBody = new BulletBody(mapInfo.ID, | ||
311 | BulletSimAPI.CreateBodyWithDefaultMotionState2(mapInfo.terrainShape.ptr, | ||
312 | id, centerPos, Quaternion.Identity)); | ||
313 | } | ||
314 | |||
315 | // Make sure the entry is in the heightmap table | ||
316 | m_heightMaps[terrainRegionBase] = mapInfo; | ||
317 | |||
318 | // Set current terrain attributes | ||
319 | BulletSimAPI.SetFriction2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainFriction); | ||
320 | BulletSimAPI.SetHitFraction2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainHitFraction); | ||
321 | BulletSimAPI.SetRestitution2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainRestitution); | ||
322 | BulletSimAPI.SetCollisionFlags2(mapInfo.terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT); | ||
323 | |||
324 | // Return the new terrain to the world of physical objects | ||
325 | BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
326 | |||
327 | // redo its bounding box now that it is in the world | ||
328 | BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr); | ||
329 | |||
330 | BulletSimAPI.SetCollisionFilterMask2(mapInfo.terrainBody.ptr, | ||
331 | (uint)CollisionFilterGroups.TerrainFilter, | ||
332 | (uint)CollisionFilterGroups.TerrainMask); | ||
333 | |||
334 | // Make sure the new shape is processed. | ||
335 | // BulletSimAPI.Activate2(mapInfo.terrainBody.ptr, true); | ||
336 | // BulletSimAPI.ForceActivationState2(mapInfo.terrainBody.ptr, ActivationState.ISLAND_SLEEPING); | ||
337 | BulletSimAPI.ForceActivationState2(mapInfo.terrainBody.ptr, ActivationState.DISABLE_SIMULATION); | ||
338 | |||
339 | m_terrainModified = true; | ||
340 | }); | ||
341 | } | ||
342 | else | ||
343 | { | ||
344 | // We don't know about this terrain so either we are creating a new terrain or | ||
345 | // our mega-prim child is giving us a new terrain to add to the phys world | ||
346 | |||
347 | // if this is a child terrain, calculate a unique terrain id | ||
348 | uint newTerrainID = id; | ||
349 | if (newTerrainID >= BSScene.CHILDTERRAIN_ID) | ||
350 | newTerrainID = ++m_terrainCount; | ||
351 | |||
352 | float[] heightMapX = heightMap; | ||
353 | Vector3 minCoordsX = minCoords; | ||
354 | Vector3 maxCoordsX = maxCoords; | ||
355 | |||
356 | DetailLog("{0},UpdateOrCreateTerrain:NewTerrain,call,id={1}, minC={2}, maxC={3}", | ||
357 | BSScene.DetailLogZero, newTerrainID, minCoords, minCoords); | ||
358 | |||
359 | // Code that must happen at taint-time | ||
360 | PhysicsScene.TaintedObject(inTaintTime, "BSScene.UpdateOrCreateTerrain:NewTerrain", delegate() | ||
361 | { | ||
362 | DetailLog("{0},UpdateOrCreateTerrain:NewTerrain,taint,baseX={1},baseY={2}", BSScene.DetailLogZero, minCoords.X, minCoords.Y); | ||
363 | // Create a new mapInfo that will be filled with the new info | ||
364 | mapInfo = new BulletHeightMapInfo(id, heightMapX, | ||
365 | BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, newTerrainID, | ||
366 | minCoordsX, maxCoordsX, heightMapX, TERRAIN_COLLISION_MARGIN)); | ||
367 | // Put the unfilled heightmap info into the collection of same | ||
368 | m_heightMaps.Add(terrainRegionBase, mapInfo); | ||
369 | // Build the terrain | ||
370 | UpdateOrCreateTerrain(newTerrainID, heightMap, minCoords, maxCoords, true); | ||
371 | |||
372 | m_terrainModified = true; | ||
373 | }); | ||
374 | } | ||
375 | } | ||
376 | |||
377 | // Someday we will have complex terrain with caves and tunnels | ||
378 | public float GetTerrainHeightAtXYZ(Vector3 loc) | ||
379 | { | ||
380 | // For the moment, it's flat and convex | ||
381 | return GetTerrainHeightAtXY(loc.X, loc.Y); | ||
382 | } | ||
383 | |||
384 | // Given an X and Y, find the height of the terrain. | ||
385 | // Since we could be handling multiple terrains for a mega-region, | ||
386 | // the base of the region is calcuated assuming all regions are | ||
387 | // the same size and that is the default. | ||
388 | // Once the heightMapInfo is found, we have all the information to | ||
389 | // compute the offset into the array. | ||
390 | private float lastHeightTX = 999999f; | ||
391 | private float lastHeightTY = 999999f; | ||
392 | private float lastHeight = HEIGHT_INITIAL_LASTHEIGHT; | ||
393 | private float GetTerrainHeightAtXY(float tX, float tY) | ||
394 | { | ||
395 | // You'd be surprized at the number of times this routine is called | ||
396 | // with the same parameters as last time. | ||
397 | if (!m_terrainModified && lastHeightTX == tX && lastHeightTY == tY) | ||
398 | return lastHeight; | ||
399 | |||
400 | lastHeightTX = tX; | ||
401 | lastHeightTY = tY; | ||
402 | float ret = HEIGHT_GETHEIGHT_RET; | ||
403 | |||
404 | int offsetX = ((int)(tX / (int)DefaultRegionSize.X)) * (int)DefaultRegionSize.X; | ||
405 | int offsetY = ((int)(tY / (int)DefaultRegionSize.Y)) * (int)DefaultRegionSize.Y; | ||
406 | Vector2 terrainBaseXY = new Vector2(offsetX, offsetY); | ||
407 | |||
408 | BulletHeightMapInfo mapInfo; | ||
409 | if (m_heightMaps.TryGetValue(terrainBaseXY, out mapInfo)) | ||
410 | { | ||
411 | float regionX = tX - offsetX; | ||
412 | float regionY = tY - offsetY; | ||
413 | int mapIndex = (int)regionY * (int)mapInfo.sizeY + (int)regionX; | ||
414 | try | ||
415 | { | ||
416 | ret = mapInfo.heightMap[mapIndex]; | ||
417 | } | ||
418 | catch | ||
419 | { | ||
420 | // Sometimes they give us wonky values of X and Y. Give a warning and return something. | ||
421 | PhysicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, x={2}, y={3}", | ||
422 | LogHeader, terrainBaseXY, regionX, regionY); | ||
423 | ret = HEIGHT_GETHEIGHT_RET; | ||
424 | } | ||
425 | // DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXY,bX={1},baseY={2},szX={3},szY={4},regX={5},regY={6},index={7},ht={8}", | ||
426 | // BSScene.DetailLogZero, offsetX, offsetY, mapInfo.sizeX, mapInfo.sizeY, regionX, regionY, mapIndex, ret); | ||
427 | } | ||
428 | else | ||
429 | { | ||
430 | PhysicsScene.Logger.ErrorFormat("{0} GetTerrainHeightAtXY: terrain not found: region={1}, x={2}, y={3}", | ||
431 | LogHeader, PhysicsScene.RegionName, tX, tY); | ||
432 | } | ||
433 | m_terrainModified = false; | ||
434 | lastHeight = ret; | ||
435 | return ret; | ||
436 | } | ||
437 | |||
438 | // Although no one seems to check this, I do support combining. | ||
439 | public bool SupportsCombining() | ||
440 | { | ||
441 | return true; | ||
442 | } | ||
443 | |||
444 | // This routine is called two ways: | ||
445 | // One with 'offset' and 'pScene' zero and null but 'extents' giving the maximum | ||
446 | // extent of the combined regions. This is to inform the parent of the size | ||
447 | // of the combined regions. | ||
448 | // and one with 'offset' as the offset of the child region to the base region, | ||
449 | // 'pScene' pointing to the parent and 'extents' of zero. This informs the | ||
450 | // child of its relative base and new parent. | ||
451 | public void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents) | ||
452 | { | ||
453 | m_worldOffset = offset; | ||
454 | m_worldMax = extents; | ||
455 | MegaRegionParentPhysicsScene = pScene; | ||
456 | if (pScene != null) | ||
457 | { | ||
458 | // We are a child. | ||
459 | // We want m_worldMax to be the highest coordinate of our piece of terrain. | ||
460 | m_worldMax = offset + DefaultRegionSize; | ||
461 | } | ||
462 | DetailLog("{0},BSTerrainManager.Combine,offset={1},extents={2},wOffset={3},wMax={4}", | ||
463 | BSScene.DetailLogZero, offset, extents, m_worldOffset, m_worldMax); | ||
464 | } | ||
465 | |||
466 | // Unhook all the combining that I know about. | ||
467 | public void UnCombine(PhysicsScene pScene) | ||
468 | { | ||
469 | // Just like ODE, for the moment a NOP | ||
470 | DetailLog("{0},BSTerrainManager.UnCombine", BSScene.DetailLogZero); | ||
471 | } | ||
472 | |||
473 | |||
474 | private void DetailLog(string msg, params Object[] args) | ||
475 | { | ||
476 | PhysicsScene.PhysicsLogging.Write(msg, args); | ||
477 | } | ||
478 | } | ||
479 | } | ||
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs index 504bd3c..28fae13 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 | } | ||
50 | } | 84 | } |
51 | 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 | } | ||
120 | } | ||
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,11 @@ 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, | ||
197 | SHAPE_COMPOUND = 22, | ||
79 | }; | 198 | }; |
80 | public uint ID; | 199 | public uint ID; |
81 | public PhysicsShapeType Type; | 200 | public PhysicsShapeType Type; |
@@ -91,13 +210,25 @@ public struct ShapeData | |||
91 | public float Restitution; | 210 | public float Restitution; |
92 | public float Collidable; // true of things bump into this | 211 | public float Collidable; // true of things bump into this |
93 | public float Static; // true if a static object. Otherwise gravity, etc. | 212 | public float Static; // true if a static object. Otherwise gravity, etc. |
213 | public float Solid; // true if object cannot be passed through | ||
214 | public Vector3 Size; | ||
94 | 215 | ||
95 | // note that bools are passed as floats since bool size changes by language and architecture | 216 | // note that bools are passed as floats since bool size changes by language and architecture |
96 | public const float numericTrue = 1f; | 217 | public const float numericTrue = 1f; |
97 | public const float numericFalse = 0f; | 218 | public const float numericFalse = 0f; |
219 | |||
220 | // The native shapes have predefined shape hash keys | ||
221 | public enum FixedShapeKey : ulong | ||
222 | { | ||
223 | KEY_BOX = 1, | ||
224 | KEY_SPHERE = 2, | ||
225 | KEY_CONE = 3, | ||
226 | KEY_CYLINDER = 4, | ||
227 | KEY_CAPSULE = 5, | ||
228 | } | ||
98 | } | 229 | } |
99 | [StructLayout(LayoutKind.Sequential)] | 230 | [StructLayout(LayoutKind.Sequential)] |
100 | public struct SweepHit | 231 | public struct SweepHit |
101 | { | 232 | { |
102 | public uint ID; | 233 | public uint ID; |
103 | public float Fraction; | 234 | public float Fraction; |
@@ -153,6 +284,7 @@ public struct ConfigurationParameters | |||
153 | public float terrainHitFraction; | 284 | public float terrainHitFraction; |
154 | public float terrainRestitution; | 285 | public float terrainRestitution; |
155 | public float avatarFriction; | 286 | public float avatarFriction; |
287 | public float avatarStandingFriction; | ||
156 | public float avatarDensity; | 288 | public float avatarDensity; |
157 | public float avatarRestitution; | 289 | public float avatarRestitution; |
158 | public float avatarCapsuleRadius; | 290 | public float avatarCapsuleRadius; |
@@ -168,18 +300,45 @@ public struct ConfigurationParameters | |||
168 | public float shouldEnableFrictionCaching; | 300 | public float shouldEnableFrictionCaching; |
169 | public float numberOfSolverIterations; | 301 | public float numberOfSolverIterations; |
170 | 302 | ||
303 | public float linksetImplementation; | ||
171 | public float linkConstraintUseFrameOffset; | 304 | public float linkConstraintUseFrameOffset; |
172 | public float linkConstraintEnableTransMotor; | 305 | public float linkConstraintEnableTransMotor; |
173 | public float linkConstraintTransMotorMaxVel; | 306 | public float linkConstraintTransMotorMaxVel; |
174 | public float linkConstraintTransMotorMaxForce; | 307 | public float linkConstraintTransMotorMaxForce; |
175 | public float linkConstraintERP; | 308 | public float linkConstraintERP; |
176 | public float linkConstraintCFM; | 309 | public float linkConstraintCFM; |
310 | public float linkConstraintSolverIterations; | ||
311 | |||
312 | public float physicsLoggingFrames; | ||
177 | 313 | ||
178 | public const float numericTrue = 1f; | 314 | public const float numericTrue = 1f; |
179 | public const float numericFalse = 0f; | 315 | public const float numericFalse = 0f; |
180 | } | 316 | } |
181 | 317 | ||
182 | // Values used by Bullet and BulletSim to control collisions | 318 | |
319 | // The states a bullet collision object can have | ||
320 | public enum ActivationState : uint | ||
321 | { | ||
322 | ACTIVE_TAG = 1, | ||
323 | ISLAND_SLEEPING, | ||
324 | WANTS_DEACTIVATION, | ||
325 | DISABLE_DEACTIVATION, | ||
326 | DISABLE_SIMULATION, | ||
327 | } | ||
328 | |||
329 | public enum CollisionObjectTypes : int | ||
330 | { | ||
331 | CO_COLLISION_OBJECT = 1 << 0, | ||
332 | CO_RIGID_BODY = 1 << 1, | ||
333 | CO_GHOST_OBJECT = 1 << 2, | ||
334 | CO_SOFT_BODY = 1 << 3, | ||
335 | CO_HF_FLUID = 1 << 4, | ||
336 | CO_USER_TYPE = 1 << 5, | ||
337 | } | ||
338 | |||
339 | // Values used by Bullet and BulletSim to control object properties. | ||
340 | // Bullet's "CollisionFlags" has more to do with operations on the | ||
341 | // object (if collisions happen, if gravity effects it, ...). | ||
183 | public enum CollisionFlags : uint | 342 | public enum CollisionFlags : uint |
184 | { | 343 | { |
185 | CF_STATIC_OBJECT = 1 << 0, | 344 | CF_STATIC_OBJECT = 1 << 0, |
@@ -191,9 +350,54 @@ public enum CollisionFlags : uint | |||
191 | CF_DISABLE_SPU_COLLISION_PROCESS = 1 << 6, | 350 | CF_DISABLE_SPU_COLLISION_PROCESS = 1 << 6, |
192 | // Following used by BulletSim to control collisions | 351 | // Following used by BulletSim to control collisions |
193 | BS_SUBSCRIBE_COLLISION_EVENTS = 1 << 10, | 352 | BS_SUBSCRIBE_COLLISION_EVENTS = 1 << 10, |
194 | BS_VOLUME_DETECT_OBJECT = 1 << 11, | 353 | BS_FLOATS_ON_WATER = 1 << 11, |
195 | BS_PHANTOM_OBJECT = 1 << 12, | 354 | BS_NONE = 0, |
196 | BS_PHYSICAL_OBJECT = 1 << 13, | 355 | BS_ALL = 0xFFFFFFFF, |
356 | |||
357 | // These are the collision flags switched depending on physical state. | ||
358 | // The other flags are used for other things and should not be fooled with. | ||
359 | BS_ACTIVE = CF_STATIC_OBJECT | ||
360 | | CF_KINEMATIC_OBJECT | ||
361 | | CF_NO_CONTACT_RESPONSE | ||
362 | }; | ||
363 | |||
364 | // Values for collisions groups and masks | ||
365 | public enum CollisionFilterGroups : uint | ||
366 | { | ||
367 | // Don't use the bit definitions!! Define the use in a | ||
368 | // filter/mask definition below. This way collision interactions | ||
369 | // are more easily debugged. | ||
370 | BNoneFilter = 0, | ||
371 | BDefaultFilter = 1 << 0, | ||
372 | BStaticFilter = 1 << 1, | ||
373 | BKinematicFilter = 1 << 2, | ||
374 | BDebrisFilter = 1 << 3, | ||
375 | BSensorTrigger = 1 << 4, | ||
376 | BCharacterFilter = 1 << 5, | ||
377 | BAllFilter = 0xFFFFFFFF, | ||
378 | // Filter groups defined by BulletSim | ||
379 | BGroundPlaneFilter = 1 << 10, | ||
380 | BTerrainFilter = 1 << 11, | ||
381 | BRaycastFilter = 1 << 12, | ||
382 | BSolidFilter = 1 << 13, | ||
383 | BLinksetFilter = 1 << 14, | ||
384 | |||
385 | // The collsion filters and masked are defined in one place -- don't want them scattered | ||
386 | AvatarFilter = BCharacterFilter, | ||
387 | AvatarMask = BAllFilter, | ||
388 | ObjectFilter = BSolidFilter, | ||
389 | ObjectMask = BAllFilter, | ||
390 | StaticObjectFilter = BStaticFilter, | ||
391 | StaticObjectMask = BAllFilter, | ||
392 | LinksetFilter = BLinksetFilter, | ||
393 | LinksetMask = BAllFilter & ~BLinksetFilter, | ||
394 | VolumeDetectFilter = BSensorTrigger, | ||
395 | VolumeDetectMask = ~BSensorTrigger, | ||
396 | TerrainFilter = BTerrainFilter, | ||
397 | TerrainMask = BAllFilter & ~BStaticFilter, | ||
398 | GroundPlaneFilter = BGroundPlaneFilter, | ||
399 | GroundPlaneMask = BAllFilter | ||
400 | |||
197 | }; | 401 | }; |
198 | 402 | ||
199 | // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0 | 403 | // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0 |
@@ -221,250 +425,285 @@ public enum ConstraintParamAxis : int | |||
221 | // =============================================================================== | 425 | // =============================================================================== |
222 | static class BulletSimAPI { | 426 | static class BulletSimAPI { |
223 | 427 | ||
224 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 428 | // Link back to the managed code for outputting log messages |
225 | [return: MarshalAs(UnmanagedType.LPStr)] | 429 | [UnmanagedFunctionPointer(CallingConvention.Cdecl)] |
226 | public static extern string GetVersion(); | 430 | public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg); |
227 | 431 | ||
432 | // =============================================================================== | ||
433 | // Initialization and simulation | ||
228 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 434 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
229 | public static extern uint Initialize(Vector3 maxPosition, IntPtr parms, | 435 | public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms, |
230 | int maxCollisions, IntPtr collisionArray, | 436 | int maxCollisions, IntPtr collisionArray, |
231 | int maxUpdates, IntPtr updateArray); | 437 | int maxUpdates, IntPtr updateArray, |
438 | DebugLogCallback logRoutine); | ||
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 bool UpdateParameter2(IntPtr world, uint localID, String parm, float value); |
235 | 442 | ||
236 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 443 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
237 | public static extern void Shutdown(uint worldID); | 444 | public static extern void SetHeightMap2(IntPtr world, float[] heightmap); |
238 | 445 | ||
239 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 446 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
240 | public static extern bool UpdateParameter(uint worldID, uint localID, | 447 | public static extern void Shutdown2(IntPtr sim); |
241 | [MarshalAs(UnmanagedType.LPStr)]string paramCode, float value); | ||
242 | 448 | ||
243 | // =============================================================================== | ||
244 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 449 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
245 | public static extern int PhysicsStep(uint worldID, float timeStep, int maxSubSteps, float fixedTimeStep, | 450 | public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep, |
246 | out int updatedEntityCount, | 451 | out int updatedEntityCount, |
247 | out IntPtr updatedEntitiesPtr, | 452 | out IntPtr updatedEntitiesPtr, |
248 | out int collidersCount, | 453 | out int collidersCount, |
249 | out IntPtr collidersPtr); | 454 | out IntPtr collidersPtr); |
250 | 455 | ||
251 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 456 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
252 | public static extern bool CreateHull(uint worldID, System.UInt64 meshKey, | 457 | public static extern bool PushUpdate2(IntPtr obj); |
253 | int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls | ||
254 | ); | ||
255 | 458 | ||
459 | // ===================================================================================== | ||
460 | // Mesh, hull, shape and body creation helper routines | ||
256 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 461 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
257 | public static extern bool CreateMesh(uint worldID, System.UInt64 meshKey, | 462 | public static extern IntPtr CreateMeshShape2(IntPtr world, |
258 | int indexCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices, | 463 | int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices, |
259 | int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices | 464 | int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices ); |
260 | ); | ||
261 | 465 | ||
262 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 466 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
263 | public static extern bool DestroyHull(uint worldID, System.UInt64 meshKey); | 467 | public static extern IntPtr CreateHullShape2(IntPtr world, |
468 | int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls); | ||
264 | 469 | ||
265 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 470 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
266 | public static extern bool DestroyMesh(uint worldID, System.UInt64 meshKey); | 471 | public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape); |
267 | 472 | ||
268 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 473 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
269 | public static extern bool CreateObject(uint worldID, ShapeData shapeData); | 474 | public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData); |
270 | 475 | ||
271 | /* Remove old functionality | ||
272 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 476 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
273 | public static extern void CreateLinkset(uint worldID, int objectCount, ShapeData[] shapeDatas); | 477 | public static extern bool IsNativeShape2(IntPtr shape); |
274 | 478 | ||
275 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 479 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
276 | public static extern void AddConstraint(uint worldID, uint id1, uint id2, | 480 | public static extern IntPtr BuildCapsuleShape2(IntPtr world, float radius, float height, Vector3 scale); |
277 | Vector3 frame1, Quaternion frame1rot, | ||
278 | Vector3 frame2, Quaternion frame2rot, | ||
279 | Vector3 lowLinear, Vector3 hiLinear, Vector3 lowAngular, Vector3 hiAngular); | ||
280 | 481 | ||
281 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 482 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
282 | public static extern bool RemoveConstraintByID(uint worldID, uint id1); | 483 | public static extern IntPtr CreateCompoundShape2(IntPtr sim, bool enableDynamicAabbTree); |
283 | 484 | ||
284 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 485 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
285 | public static extern bool RemoveConstraint(uint worldID, uint id1, uint id2); | 486 | public static extern int GetNumberOfCompoundChildren2(IntPtr cShape); |
286 | */ | ||
287 | 487 | ||
288 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 488 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
289 | public static extern Vector3 GetObjectPosition(uint WorldID, uint id); | 489 | public static extern void AddChildShapeToCompoundShape2(IntPtr cShape, IntPtr addShape, Vector3 pos, Quaternion rot); |
290 | 490 | ||
291 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 491 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
292 | public static extern Quaternion GetObjectOrientation(uint WorldID, uint id); | 492 | public static extern IntPtr GetChildShapeFromCompoundShapeIndex2(IntPtr cShape, int indx); |
293 | 493 | ||
294 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 494 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
295 | public static extern bool SetObjectTranslation(uint worldID, uint id, Vector3 position, Quaternion rotation); | 495 | public static extern IntPtr RemoveChildShapeFromCompoundShapeIndex2(IntPtr cShape, int indx); |
296 | 496 | ||
297 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 497 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
298 | public static extern bool SetObjectVelocity(uint worldID, uint id, Vector3 velocity); | 498 | public static extern void RemoveChildShapeFromCompoundShape2(IntPtr cShape, IntPtr removeShape); |
299 | 499 | ||
300 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 500 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
301 | public static extern bool SetObjectAngularVelocity(uint worldID, uint id, Vector3 angularVelocity); | 501 | public static extern void RecalculateCompoundShapeLocalAabb2(IntPtr cShape); |
302 | 502 | ||
303 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 503 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
304 | public static extern bool SetObjectForce(uint worldID, uint id, Vector3 force); | 504 | public static extern IntPtr DuplicateCollisionShape2(IntPtr sim, IntPtr srcShape, uint id); |
305 | 505 | ||
306 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 506 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
307 | public static extern bool SetObjectScaleMass(uint worldID, uint id, Vector3 scale, float mass, bool isDynamic); | 507 | public static extern IntPtr CreateBodyFromShapeAndInfo2(IntPtr sim, IntPtr shape, uint id, IntPtr constructionInfo); |
308 | 508 | ||
309 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 509 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
310 | public static extern bool SetObjectCollidable(uint worldID, uint id, bool phantom); | 510 | public static extern bool DeleteCollisionShape2(IntPtr world, IntPtr shape); |
311 | 511 | ||
312 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 512 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
313 | public static extern bool SetObjectDynamic(uint worldID, uint id, bool isDynamic, float mass); | 513 | public static extern int GetBodyType2(IntPtr obj); |
314 | 514 | ||
315 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 515 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
316 | public static extern bool SetObjectGhost(uint worldID, uint id, bool ghostly); | 516 | public static extern IntPtr CreateBodyFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot); |
317 | 517 | ||
318 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 518 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
319 | public static extern bool SetObjectProperties(uint worldID, uint id, bool isStatic, bool isSolid, bool genCollisions, float mass); | 519 | public static extern IntPtr CreateBodyWithDefaultMotionState2(IntPtr shape, uint id, Vector3 pos, Quaternion rot); |
320 | 520 | ||
321 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 521 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
322 | public static extern bool SetObjectBuoyancy(uint worldID, uint id, float buoyancy); | 522 | public static extern IntPtr CreateGhostFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot); |
323 | 523 | ||
324 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 524 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
325 | public static extern bool HasObject(uint worldID, uint id); | 525 | public static extern IntPtr AllocateBodyInfo2(IntPtr obj); |
326 | 526 | ||
327 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 527 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
328 | public static extern bool DestroyObject(uint worldID, uint id); | 528 | public static extern void ReleaseBodyInfo2(IntPtr obj); |
329 | 529 | ||
330 | // =============================================================================== | ||
331 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 530 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
332 | public static extern SweepHit ConvexSweepTest(uint worldID, uint id, Vector3 to, float extraMargin); | 531 | public static extern void DestroyObject2(IntPtr sim, IntPtr obj); |
333 | 532 | ||
533 | // ===================================================================================== | ||
534 | // Terrain creation and helper routines | ||
334 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 535 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
335 | public static extern RaycastHit RayTest(uint worldID, uint id, Vector3 from, Vector3 to); | 536 | public static extern IntPtr CreateHeightMapInfo2(IntPtr sim, uint id, Vector3 minCoords, Vector3 maxCoords, |
537 | [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin); | ||
336 | 538 | ||
337 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 539 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
338 | public static extern Vector3 RecoverFromPenetration(uint worldID, uint id); | 540 | public static extern IntPtr FillHeightMapInfo2(IntPtr sim, IntPtr mapInfo, uint id, Vector3 minCoords, Vector3 maxCoords, |
541 | [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin); | ||
339 | 542 | ||
340 | // =============================================================================== | ||
341 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 543 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
342 | public static extern void DumpBulletStatistics(); | 544 | public static extern bool ReleaseHeightMapInfo2(IntPtr heightMapInfo); |
343 | 545 | ||
344 | // 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] | 546 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
348 | public static extern void SetDebugLogCallback(DebugLogCallback callback); | 547 | public static extern IntPtr CreateGroundPlaneShape2(uint id, float height, float collisionMargin); |
349 | 548 | ||
350 | // =============================================================================== | 549 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
351 | // =============================================================================== | 550 | public static extern IntPtr CreateTerrainShape2(IntPtr mapInfo); |
352 | // =============================================================================== | ||
353 | // A new version of the API that enables moving all the logic out of the C++ code and into | ||
354 | // the C# code. This will make modifications easier for the next person. | ||
355 | // This interface passes the actual pointers to the objects in the unmanaged | ||
356 | // address space. All the management (calls for creation/destruction/lookup) | ||
357 | // is done in the C# code. | ||
358 | // The names have a "2" tacked on. This will be removed as the C# code gets rebuilt | ||
359 | // and the old code is removed. | ||
360 | 551 | ||
552 | // ===================================================================================== | ||
553 | // Constraint creation and helper routines | ||
361 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 554 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
362 | public static extern IntPtr GetSimHandle2(uint worldID); | 555 | public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2, |
556 | Vector3 frame1loc, Quaternion frame1rot, | ||
557 | Vector3 frame2loc, Quaternion frame2rot, | ||
558 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies); | ||
363 | 559 | ||
364 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 560 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
365 | public static extern IntPtr GetBodyHandleWorldID2(uint worldID, uint id); | 561 | public static extern IntPtr Create6DofConstraintToPoint2(IntPtr world, IntPtr obj1, IntPtr obj2, |
562 | Vector3 joinPoint, | ||
563 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies); | ||
366 | 564 | ||
367 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 565 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
368 | public static extern IntPtr GetBodyHandle2(IntPtr world, uint id); | 566 | public static extern IntPtr CreateHingeConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2, |
567 | Vector3 pivotinA, Vector3 pivotinB, | ||
568 | Vector3 axisInA, Vector3 axisInB, | ||
569 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies); | ||
369 | 570 | ||
370 | // =============================================================================== | ||
371 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 571 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
372 | public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms, | 572 | public static extern void SetConstraintEnable2(IntPtr constrain, float numericTrueFalse); |
373 | int maxCollisions, IntPtr collisionArray, | ||
374 | int maxUpdates, IntPtr updateArray); | ||
375 | 573 | ||
376 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 574 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
377 | public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value); | 575 | public static extern void SetConstraintNumSolverIterations2(IntPtr constrain, float iterations); |
378 | 576 | ||
379 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 577 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
380 | public static extern void SetHeightmap2(IntPtr world, float[] heightmap); | 578 | public static extern bool SetFrames2(IntPtr constrain, |
579 | Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot); | ||
381 | 580 | ||
382 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 581 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
383 | public static extern void Shutdown2(IntPtr sim); | 582 | public static extern bool SetLinearLimits2(IntPtr constrain, Vector3 low, Vector3 hi); |
384 | 583 | ||
385 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 584 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
386 | public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep, | 585 | public static extern bool SetAngularLimits2(IntPtr constrain, Vector3 low, Vector3 hi); |
387 | out int updatedEntityCount, | ||
388 | out IntPtr updatedEntitiesPtr, | ||
389 | out int collidersCount, | ||
390 | out IntPtr collidersPtr); | ||
391 | 586 | ||
392 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 587 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
393 | public static extern bool PushUpdate2(IntPtr obj); | 588 | public static extern bool UseFrameOffset2(IntPtr constrain, float enable); |
394 | 589 | ||
395 | /* | ||
396 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 590 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
397 | public static extern IntPtr CreateMesh2(IntPtr world, int indicesCount, int* indices, int verticesCount, float* vertices ); | 591 | public static extern bool TranslationalLimitMotor2(IntPtr constrain, float enable, float targetVel, float maxMotorForce); |
398 | 592 | ||
399 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 593 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
400 | public static extern bool BuildHull2(IntPtr world, IntPtr mesh); | 594 | public static extern bool SetBreakingImpulseThreshold2(IntPtr constrain, float threshold); |
401 | 595 | ||
402 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 596 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
403 | public static extern bool ReleaseHull2(IntPtr world, IntPtr mesh); | 597 | public static extern bool CalculateTransforms2(IntPtr constrain); |
404 | 598 | ||
405 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 599 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
406 | public static extern bool DestroyMesh2(IntPtr world, IntPtr mesh); | 600 | public static extern bool SetConstraintParam2(IntPtr constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis); |
407 | 601 | ||
408 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 602 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
409 | public static extern IntPtr CreateObject2(IntPtr world, ShapeData shapeData); | 603 | public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain); |
410 | */ | ||
411 | 604 | ||
605 | // ===================================================================================== | ||
606 | // btCollisionWorld entries | ||
412 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 607 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
413 | public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2, | 608 | public static extern void UpdateSingleAabb2(IntPtr world, IntPtr obj); |
414 | Vector3 frame1loc, Quaternion frame1rot, | ||
415 | Vector3 frame2loc, Quaternion frame2rot, | ||
416 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies); | ||
417 | 609 | ||
418 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 610 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
419 | public static extern IntPtr Create6DofConstraintToPoint2(IntPtr world, IntPtr obj1, IntPtr obj2, | 611 | public static extern void UpdateAabbs2(IntPtr world); |
420 | Vector3 joinPoint, | ||
421 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies); | ||
422 | 612 | ||
423 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 613 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
424 | public static extern IntPtr CreateHingeConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2, | 614 | public static extern bool GetForceUpdateAllAabbs2(IntPtr world); |
425 | Vector3 pivotinA, Vector3 pivotinB, | ||
426 | Vector3 axisInA, Vector3 axisInB, | ||
427 | bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies); | ||
428 | 615 | ||
429 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 616 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
430 | public static extern void SetConstraintEnable2(IntPtr constrain, float numericTrueFalse); | 617 | public static extern void SetForceUpdateAllAabbs2(IntPtr world, bool force); |
431 | 618 | ||
619 | // ===================================================================================== | ||
620 | // btDynamicsWorld entries | ||
432 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 621 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
433 | public static extern void SetConstraintNumSolverIterations2(IntPtr constrain, float iterations); | 622 | public static extern bool AddObjectToWorld2(IntPtr world, IntPtr obj); |
434 | 623 | ||
435 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 624 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
436 | public static extern bool SetFrames2(IntPtr constrain, | 625 | public static extern bool RemoveObjectFromWorld2(IntPtr world, IntPtr obj); |
437 | Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot); | ||
438 | 626 | ||
439 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 627 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
440 | public static extern bool SetLinearLimits2(IntPtr constrain, Vector3 low, Vector3 hi); | 628 | public static extern bool AddConstraintToWorld2(IntPtr world, IntPtr constrain, bool disableCollisionsBetweenLinkedObjects); |
441 | 629 | ||
442 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 630 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
443 | public static extern bool SetAngularLimits2(IntPtr constrain, Vector3 low, Vector3 hi); | 631 | public static extern bool RemoveConstraintFromWorld2(IntPtr world, IntPtr constrain); |
632 | // ===================================================================================== | ||
633 | // btCollisionObject entries | ||
634 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
635 | public static extern Vector3 GetAnisotripicFriction2(IntPtr constrain); | ||
444 | 636 | ||
445 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 637 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
446 | public static extern bool UseFrameOffset2(IntPtr constrain, float enable); | 638 | public static extern Vector3 SetAnisotripicFriction2(IntPtr constrain, Vector3 frict); |
447 | 639 | ||
448 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 640 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
449 | public static extern bool TranslationalLimitMotor2(IntPtr constrain, float enable, float targetVel, float maxMotorForce); | 641 | public static extern bool HasAnisotripicFriction2(IntPtr constrain); |
450 | 642 | ||
451 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 643 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
452 | public static extern bool SetBreakingImpulseThreshold2(IntPtr constrain, float threshold); | 644 | public static extern void SetContactProcessingThreshold2(IntPtr obj, float val); |
453 | 645 | ||
454 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 646 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
455 | public static extern bool CalculateTransforms2(IntPtr constrain); | 647 | public static extern float GetContactProcessingThreshold2(IntPtr obj); |
456 | 648 | ||
457 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 649 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
458 | public static extern bool SetConstraintParam2(IntPtr constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis); | 650 | public static extern bool IsStaticObject2(IntPtr obj); |
459 | 651 | ||
460 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 652 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
461 | public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain); | 653 | public static extern bool IsKinematicObject2(IntPtr obj); |
654 | |||
655 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
656 | public static extern bool IsStaticOrKinematicObject2(IntPtr obj); | ||
657 | |||
658 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
659 | public static extern bool HasContactResponse2(IntPtr obj); | ||
660 | |||
661 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
662 | public static extern void SetCollisionShape2(IntPtr sim, IntPtr obj, IntPtr shape); | ||
663 | |||
664 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
665 | public static extern IntPtr GetCollisionShape2(IntPtr obj); | ||
666 | |||
667 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
668 | public static extern int GetActivationState2(IntPtr obj); | ||
669 | |||
670 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
671 | public static extern void SetActivationState2(IntPtr obj, int state); | ||
672 | |||
673 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
674 | public static extern void SetDeactivationTime2(IntPtr obj, float dtime); | ||
675 | |||
676 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
677 | public static extern float GetDeactivationTime2(IntPtr obj); | ||
678 | |||
679 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
680 | public static extern void ForceActivationState2(IntPtr obj, ActivationState state); | ||
681 | |||
682 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
683 | public static extern void Activate2(IntPtr obj, bool forceActivation); | ||
684 | |||
685 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
686 | public static extern bool IsActive2(IntPtr obj); | ||
687 | |||
688 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
689 | public static extern void SetRestitution2(IntPtr obj, float val); | ||
690 | |||
691 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
692 | public static extern float GetRestitution2(IntPtr obj); | ||
693 | |||
694 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
695 | public static extern void SetFriction2(IntPtr obj, float val); | ||
696 | |||
697 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
698 | public static extern float GetFriction2(IntPtr obj); | ||
462 | 699 | ||
700 | /* Haven't defined the type 'Transform' | ||
463 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 701 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
464 | public static extern Vector3 AddObjectToWorld2(IntPtr world, IntPtr obj); | 702 | public static extern Transform GetWorldTransform2(IntPtr obj); |
465 | 703 | ||
466 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 704 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
467 | public static extern Vector3 RemoveObjectFromWorld2(IntPtr world, IntPtr obj); | 705 | public static extern void setWorldTransform2(IntPtr obj, Transform trans); |
706 | */ | ||
468 | 707 | ||
469 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 708 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
470 | public static extern Vector3 GetPosition2(IntPtr obj); | 709 | public static extern Vector3 GetPosition2(IntPtr obj); |
@@ -473,85 +712,296 @@ public static extern Vector3 GetPosition2(IntPtr obj); | |||
473 | public static extern Quaternion GetOrientation2(IntPtr obj); | 712 | public static extern Quaternion GetOrientation2(IntPtr obj); |
474 | 713 | ||
475 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 714 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
476 | public static extern bool SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation); | 715 | public static extern void SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation); |
477 | 716 | ||
478 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 717 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
479 | public static extern bool SetVelocity2(IntPtr obj, Vector3 velocity); | 718 | public static extern IntPtr GetBroadphaseHandle2(IntPtr obj); |
480 | 719 | ||
481 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 720 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
482 | public static extern bool SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity); | 721 | public static extern void SetBroadphaseHandle2(IntPtr obj, IntPtr handle); |
483 | 722 | ||
723 | /* | ||
484 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 724 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
485 | public static extern bool SetObjectForce2(IntPtr obj, Vector3 force); | 725 | public static extern Transform GetInterpolationWorldTransform2(IntPtr obj); |
486 | 726 | ||
487 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 727 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
488 | public static extern bool AddObjectForce2(IntPtr obj, Vector3 force); | 728 | public static extern void SetInterpolationWorldTransform2(IntPtr obj, Transform trans); |
729 | */ | ||
489 | 730 | ||
490 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 731 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
491 | public static extern bool SetCcdMotionThreshold2(IntPtr obj, float val); | 732 | public static extern void SetInterpolationLinearVelocity2(IntPtr obj, Vector3 vel); |
492 | 733 | ||
493 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 734 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
494 | public static extern bool SetCcdSweepSphereRadius2(IntPtr obj, float val); | 735 | public static extern void SetInterpolationAngularVelocity2(IntPtr obj, Vector3 vel); |
495 | 736 | ||
496 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 737 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
497 | public static extern bool SetDamping2(IntPtr obj, float lin_damping, float ang_damping); | 738 | public static extern void SetInterpolationVelocity2(IntPtr obj, Vector3 linearVel, Vector3 angularVel); |
498 | 739 | ||
499 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 740 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
500 | public static extern bool SetDeactivationTime2(IntPtr obj, float val); | 741 | public static extern float GetHitFraction2(IntPtr obj); |
501 | 742 | ||
502 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 743 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
503 | public static extern bool SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold); | 744 | public static extern void SetHitFraction2(IntPtr obj, float val); |
504 | 745 | ||
505 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 746 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
506 | public static extern bool SetContactProcessingThreshold2(IntPtr obj, float val); | 747 | public static extern CollisionFlags GetCollisionFlags2(IntPtr obj); |
507 | 748 | ||
508 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 749 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
509 | public static extern bool SetFriction2(IntPtr obj, float val); | 750 | public static extern CollisionFlags SetCollisionFlags2(IntPtr obj, CollisionFlags flags); |
510 | 751 | ||
511 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 752 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
512 | public static extern bool SetRestitution2(IntPtr obj, float val); | 753 | public static extern CollisionFlags AddToCollisionFlags2(IntPtr obj, CollisionFlags flags); |
513 | 754 | ||
514 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 755 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
515 | public static extern bool SetLinearVelocity2(IntPtr obj, Vector3 val); | 756 | public static extern CollisionFlags RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags); |
516 | 757 | ||
517 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 758 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
518 | public static extern bool SetInterpolation2(IntPtr obj, Vector3 lin, Vector3 ang); | 759 | public static extern float GetCcdMotionThreshold2(IntPtr obj); |
519 | 760 | ||
520 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 761 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
521 | public static extern CollisionFlags GetCollisionFlags2(IntPtr obj); | 762 | public static extern void SetCcdMotionThreshold2(IntPtr obj, float val); |
763 | |||
764 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
765 | public static extern float GetCcdSweptSphereRadius2(IntPtr obj); | ||
766 | |||
767 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
768 | public static extern void SetCcdSweptSphereRadius2(IntPtr obj, float val); | ||
769 | |||
770 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
771 | public static extern IntPtr GetUserPointer2(IntPtr obj); | ||
772 | |||
773 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
774 | public static extern void SetUserPointer2(IntPtr obj, IntPtr val); | ||
775 | |||
776 | // ===================================================================================== | ||
777 | // btRigidBody entries | ||
778 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
779 | public static extern void ApplyGravity2(IntPtr obj); | ||
780 | |||
781 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
782 | public static extern void SetGravity2(IntPtr obj, Vector3 val); | ||
783 | |||
784 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
785 | public static extern Vector3 GetGravity2(IntPtr obj); | ||
786 | |||
787 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
788 | public static extern void SetDamping2(IntPtr obj, float lin_damping, float ang_damping); | ||
789 | |||
790 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
791 | public static extern void SetLinearDamping2(IntPtr obj, float lin_damping); | ||
792 | |||
793 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
794 | public static extern void SetAngularDamping2(IntPtr obj, float ang_damping); | ||
795 | |||
796 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
797 | public static extern float GetLinearDamping2(IntPtr obj); | ||
798 | |||
799 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
800 | public static extern float GetAngularDamping2(IntPtr obj); | ||
801 | |||
802 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
803 | public static extern float GetLinearSleepingThreshold2(IntPtr obj); | ||
804 | |||
805 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
806 | public static extern float GetAngularSleepingThreshold2(IntPtr obj); | ||
807 | |||
808 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
809 | public static extern void ApplyDamping2(IntPtr obj, float timeStep); | ||
810 | |||
811 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
812 | public static extern void SetMassProps2(IntPtr obj, float mass, Vector3 inertia); | ||
813 | |||
814 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
815 | public static extern Vector3 GetLinearFactor2(IntPtr obj); | ||
816 | |||
817 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
818 | public static extern void SetLinearFactor2(IntPtr obj, Vector3 factor); | ||
819 | |||
820 | /* | ||
821 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
822 | public static extern void SetCenterOfMassTransform2(IntPtr obj, Transform trans); | ||
823 | */ | ||
824 | |||
825 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
826 | public static extern void SetCenterOfMassByPosRot2(IntPtr obj, Vector3 pos, Quaternion rot); | ||
827 | |||
828 | // Add a force to the object as if its mass is one. | ||
829 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
830 | public static extern void ApplyCentralForce2(IntPtr obj, Vector3 force); | ||
831 | |||
832 | // Set the force being applied to the object as if its mass is one. | ||
833 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
834 | public static extern void SetObjectForce2(IntPtr obj, Vector3 force); | ||
835 | |||
836 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
837 | public static extern Vector3 GetTotalForce2(IntPtr obj); | ||
838 | |||
839 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
840 | public static extern Vector3 GetTotalTorque2(IntPtr obj); | ||
841 | |||
842 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
843 | public static extern Vector3 GetInvInertiaDiagLocal2(IntPtr obj); | ||
844 | |||
845 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
846 | public static extern void SetInvInertiaDiagLocal2(IntPtr obj, Vector3 inert); | ||
847 | |||
848 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
849 | public static extern void SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold); | ||
850 | |||
851 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
852 | public static extern void ApplyTorque2(IntPtr obj, Vector3 torque); | ||
853 | |||
854 | // Apply force at the given point. Will add torque to the object. | ||
855 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
856 | public static extern void ApplyForce2(IntPtr obj, Vector3 force, Vector3 pos); | ||
857 | |||
858 | // Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass. | ||
859 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
860 | public static extern void ApplyCentralImpulse2(IntPtr obj, Vector3 imp); | ||
861 | |||
862 | // Apply impulse to the object's torque. Force is scaled by object's mass. | ||
863 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
864 | public static extern void ApplyTorqueImpulse2(IntPtr obj, Vector3 imp); | ||
865 | |||
866 | // Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces. | ||
867 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
868 | public static extern void ApplyImpulse2(IntPtr obj, Vector3 imp, Vector3 pos); | ||
869 | |||
870 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
871 | public static extern void ClearForces2(IntPtr obj); | ||
872 | |||
873 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
874 | public static extern void ClearAllForces2(IntPtr obj); | ||
875 | |||
876 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
877 | public static extern void UpdateInertiaTensor2(IntPtr obj); | ||
878 | |||
879 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
880 | public static extern Vector3 GetCenterOfMassPosition2(IntPtr obj); | ||
881 | |||
882 | /* | ||
883 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
884 | public static extern Transform GetCenterOfMassTransform2(IntPtr obj); | ||
885 | */ | ||
886 | |||
887 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
888 | public static extern Vector3 GetLinearVelocity2(IntPtr obj); | ||
889 | |||
890 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
891 | public static extern Vector3 GetAngularVelocity2(IntPtr obj); | ||
892 | |||
893 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
894 | public static extern void SetLinearVelocity2(IntPtr obj, Vector3 val); | ||
895 | |||
896 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
897 | public static extern void SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity); | ||
898 | |||
899 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
900 | public static extern Vector3 GetVelocityInLocalPoint2(IntPtr obj, Vector3 pos); | ||
901 | |||
902 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
903 | public static extern void Translate2(IntPtr obj, Vector3 trans); | ||
904 | |||
905 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
906 | public static extern void UpdateDeactivation2(IntPtr obj, float timeStep); | ||
907 | |||
908 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
909 | public static extern bool WantsSleeping2(IntPtr obj); | ||
910 | |||
911 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
912 | public static extern void SetAngularFactor2(IntPtr obj, float factor); | ||
913 | |||
914 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
915 | public static extern void SetAngularFactorV2(IntPtr obj, Vector3 factor); | ||
916 | |||
917 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
918 | public static extern Vector3 GetAngularFactor2(IntPtr obj); | ||
919 | |||
920 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
921 | public static extern bool IsInWorld2(IntPtr obj); | ||
922 | |||
923 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
924 | public static extern void AddConstraintRef2(IntPtr obj, IntPtr constrain); | ||
925 | |||
926 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
927 | public static extern void RemoveConstraintRef2(IntPtr obj, IntPtr constrain); | ||
928 | |||
929 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
930 | public static extern IntPtr GetConstraintRef2(IntPtr obj, int index); | ||
931 | |||
932 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
933 | public static extern int GetNumConstraintRefs2(IntPtr obj); | ||
934 | |||
935 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
936 | public static extern void SetCollisionFilterMask2(IntPtr body, uint filter, uint mask); | ||
937 | |||
938 | // ===================================================================================== | ||
939 | // btCollisionShape entries | ||
940 | |||
941 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
942 | public static extern float GetAngularMotionDisc2(IntPtr shape); | ||
943 | |||
944 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
945 | public static extern float GetContactBreakingThreshold2(IntPtr shape, float defaultFactor); | ||
946 | |||
947 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
948 | public static extern bool IsPolyhedral2(IntPtr shape); | ||
949 | |||
950 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
951 | public static extern bool IsConvex2d2(IntPtr shape); | ||
952 | |||
953 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
954 | public static extern bool IsConvex2(IntPtr shape); | ||
955 | |||
956 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
957 | public static extern bool IsNonMoving2(IntPtr shape); | ||
958 | |||
959 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
960 | public static extern bool IsConcave2(IntPtr shape); | ||
961 | |||
962 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
963 | public static extern bool IsCompound2(IntPtr shape); | ||
964 | |||
965 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
966 | public static extern bool IsSoftBody2(IntPtr shape); | ||
967 | |||
968 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | ||
969 | public static extern bool IsInfinite2(IntPtr shape); | ||
522 | 970 | ||
523 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 971 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
524 | public static extern IntPtr SetCollisionFlags2(IntPtr obj, CollisionFlags flags); | 972 | public static extern void SetLocalScaling2(IntPtr shape, Vector3 scale); |
525 | 973 | ||
526 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 974 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
527 | public static extern IntPtr AddToCollisionFlags2(IntPtr obj, CollisionFlags flags); | 975 | public static extern Vector3 GetLocalScaling2(IntPtr shape); |
528 | 976 | ||
529 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 977 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
530 | public static extern IntPtr RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags); | 978 | public static extern Vector3 CalculateLocalInertia2(IntPtr shape, float mass); |
531 | 979 | ||
532 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 980 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
533 | public static extern bool SetMassProps2(IntPtr obj, float mass, Vector3 inertia); | 981 | public static extern int GetShapeType2(IntPtr shape); |
534 | 982 | ||
535 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 983 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
536 | public static extern bool UpdateInertiaTensor2(IntPtr obj); | 984 | public static extern void SetMargin2(IntPtr shape, float val); |
537 | 985 | ||
538 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 986 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
539 | public static extern bool SetGravity2(IntPtr obj, Vector3 val); | 987 | public static extern float GetMargin2(IntPtr shape); |
540 | 988 | ||
989 | // ===================================================================================== | ||
990 | // Debugging | ||
541 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 991 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
542 | public static extern IntPtr ClearForces2(IntPtr obj); | 992 | public static extern void DumpRigidBody2(IntPtr sim, IntPtr collisionObject); |
543 | 993 | ||
544 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 994 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
545 | public static extern IntPtr ClearAllForces2(IntPtr obj); | 995 | public static extern void DumpCollisionShape2(IntPtr sim, IntPtr collisionShape); |
546 | 996 | ||
547 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 997 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
548 | public static extern bool SetMargin2(IntPtr obj, float val); | 998 | public static extern void DumpConstraint2(IntPtr sim, IntPtr constrain); |
549 | 999 | ||
550 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1000 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
551 | public static extern bool UpdateSingleAabb2(IntPtr world, IntPtr obj); | 1001 | public static extern void DumpAllInfo2(IntPtr sim); |
552 | 1002 | ||
553 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1003 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
554 | public static extern bool DestroyObject2(IntPtr world, uint id); | 1004 | public static extern void DumpMapInfo2(IntPtr sim, IntPtr manInfo); |
555 | 1005 | ||
556 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] | 1006 | [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity] |
557 | public static extern void DumpPhysicsStatistics2(IntPtr sim); | 1007 | public static extern void DumpPhysicsStatistics2(IntPtr sim); |
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0d1db3b --- /dev/null +++ b/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs | |||
@@ -0,0 +1,33 @@ | |||
1 | using System.Reflection; | ||
2 | using System.Runtime.CompilerServices; | ||
3 | using System.Runtime.InteropServices; | ||
4 | |||
5 | // General Information about an assembly is controlled through the following | ||
6 | // set of attributes. Change these attribute values to modify the information | ||
7 | // associated with an assembly. | ||
8 | [assembly: AssemblyTitle("OpenSim.Region.Physics.BulletSPlugin")] | ||
9 | [assembly: AssemblyDescription("")] | ||
10 | [assembly: AssemblyConfiguration("")] | ||
11 | [assembly: AssemblyCompany("http://opensimulator.org")] | ||
12 | [assembly: AssemblyProduct("OpenSim")] | ||
13 | [assembly: AssemblyCopyright("OpenSimulator developers")] | ||
14 | [assembly: AssemblyTrademark("")] | ||
15 | [assembly: AssemblyCulture("")] | ||
16 | |||
17 | // Setting ComVisible to false makes the types in this assembly not visible | ||
18 | // to COM components. If you need to access a type in this assembly from | ||
19 | // COM, set the ComVisible attribute to true on that type. | ||
20 | [assembly: ComVisible(false)] | ||
21 | |||
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM | ||
23 | [assembly: Guid("520ea11b-20cb-449d-ba05-c01015fed841")] | ||
24 | |||
25 | // Version information for an assembly consists of the following four values: | ||
26 | // | ||
27 | // Major Version | ||
28 | // Minor Version | ||
29 | // Build Number | ||
30 | // Revision | ||
31 | // | ||
32 | [assembly: AssemblyVersion("0.7.5.*")] | ||
33 | [assembly: AssemblyFileVersion("1.0.0.0")] | ||