aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs')
-rw-r--r--OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs1387
1 files changed, 729 insertions, 658 deletions
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
27using System; 28using System;
28using System.Reflection; 29using System.Reflection;
29using System.Collections.Generic; 30using System.Collections.Generic;
@@ -36,32 +37,18 @@ using OpenSim.Region.Physics.ConvexDecompositionDotNet;
36 37
37namespace OpenSim.Region.Physics.BulletSPlugin 38namespace OpenSim.Region.Physics.BulletSPlugin
38{ 39{
40
39 [Serializable] 41 [Serializable]
40public sealed class BSPrim : PhysicsActor 42public 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}