OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into careminster 

Conflicts:
	OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
avinationmerge
Melanie 2013-04-02 23:47:19 +01:00
parent 4bfc469584 3332af4060
commit 41a652f6bd
22 changed files with 545 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
OpenSim/Data/MSSQL/Resources/RegionStore.migrations
View File

@ -1153,7 +1153,7 @@ COMMIT
BEGIN TRANSACTION
ALTER TABLE prims ADD COLUMN DynAttrs TEXT;
ALTER TABLE prims ADD DynAttrs TEXT;
COMMIT
@ -1161,10 +1161,10 @@ COMMIT
BEGIN TRANSACTION
ALTER TABLE prims ADD COLUMN `PhysicsShapeType` tinyint(4) NOT NULL default '0';
ALTER TABLE prims ADD COLUMN `Density` double NOT NULL default '1000';
ALTER TABLE prims ADD COLUMN `GravityModifier` double NOT NULL default '1';
ALTER TABLE prims ADD COLUMN `Friction` double NOT NULL default '0.6';
ALTER TABLE prims ADD COLUMN `Restitution` double NOT NULL default '0.5';
ALTER TABLE prims ADD `PhysicsShapeType` tinyint(4) NOT NULL default '0';
ALTER TABLE prims ADD `Density` double NOT NULL default '1000';
ALTER TABLE prims ADD `GravityModifier` double NOT NULL default '1';
ALTER TABLE prims ADD `Friction` double NOT NULL default '0.6';
ALTER TABLE prims ADD `Restitution` double NOT NULL default '0.5';
COMMIT

3
OpenSim/Region/CoreModules/Framework/UserManagement/HGUserManagementModule.cs
View File

@ -50,12 +50,11 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
#region ISharedRegionModule
public new void Initialise(IConfigSource config)
{
string umanmod = config.Configs["Modules"].GetString("UserManagementModule", base.Name);
string umanmod = config.Configs["Modules"].GetString("UserManagementModule", Name);
if (umanmod == Name)
{
m_Enabled = true;

14
OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
View File

@ -4362,17 +4362,17 @@ namespace OpenSim.Region.Framework.Scenes
}
/// <summary>
///
/// Update this part's offset position.
/// </summary>
/// <param name="pos"></param>
public void UpdateOffSet(Vector3 pos)
public void UpdateOffSet(Vector3 newPos)
{
if ((pos.X != OffsetPosition.X) ||
(pos.Y != OffsetPosition.Y) ||
(pos.Z != OffsetPosition.Z))
{
Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
Vector3 oldPos = OffsetPosition;
if ((newPos.X != oldPos.X) ||
(newPos.Y != oldPos.Y) ||
(newPos.Z != oldPos.Z))
{
if (ParentGroup.RootPart.GetStatusSandbox())
{
if (Util.GetDistanceTo(ParentGroup.RootPart.StatusSandboxPos, newPos) > 10)

6
OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs
View File

@ -259,12 +259,12 @@ public override BulletShape CreateHullShape(BulletWorld world, int hullCount, fl
BSPhysicsShapeType.SHAPE_HULL);
}
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
{
BulletWorldUnman worldu = world as BulletWorldUnman;
BulletShapeUnman shapeu = meshShape as BulletShapeUnman;
return new BulletShapeUnman(
BSAPICPP.BuildHullShapeFromMesh2(worldu.ptr, shapeu.ptr),
BSAPICPP.BuildHullShapeFromMesh2(worldu.ptr, shapeu.ptr, parms),
BSPhysicsShapeType.SHAPE_HULL);
}
@ -1411,7 +1411,7 @@ public static extern IntPtr CreateHullShape2(IntPtr world,
int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape);
public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape, HACDParams parms);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData);

3
OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
View File

@ -1773,10 +1773,9 @@ private sealed class BulletConstraintXNA : BulletConstraint
return new BulletShapeXNA(compoundshape, BSPhysicsShapeType.SHAPE_HULL);
}
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
{
/* TODO */ return null;
}
public override BulletShape CreateMeshShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)

175
OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs Executable file
View File

@ -0,0 +1,175 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyrightD
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using OMV = OpenMetaverse;
namespace OpenSim.Region.Physics.BulletSPlugin
{
public class BSActorLockAxis : BSActor
{
bool TryExperimentalLockAxisCode = true;
BSConstraint LockAxisConstraint = null;
public BSActorLockAxis(BSScene physicsScene, BSPhysObject pObj, string actorName)
: base(physicsScene, pObj,actorName)
{
m_physicsScene.DetailLog("{0},BSActorLockAxis,constructor", m_controllingPrim.LocalID);
LockAxisConstraint = null;
}
// BSActor.isActive
public override bool isActive
{
get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
}
// Release any connections and resources used by the actor.
// BSActor.Dispose()
public override void Dispose()
{
RemoveAxisLockConstraint();
}
// Called when physical parameters (properties set in Bullet) need to be re-applied.
// Called at taint-time.
// BSActor.Refresh()
public override void Refresh()
{
m_physicsScene.DetailLog("{0},BSActorLockAxis,refresh,lockedAxis={1},enabled={2},pActive={3}",
m_controllingPrim.LocalID, m_controllingPrim.LockedAxis, Enabled, m_controllingPrim.IsPhysicallyActive);
// If all the axis are free, we don't need to exist
if (m_controllingPrim.LockedAxis == m_controllingPrim.LockedAxisFree)
{
m_physicsScene.DetailLog("{0},BSActorLockAxis,refresh,allAxisFree,removing={1}", m_controllingPrim.LocalID, ActorName);
m_controllingPrim.PhysicalActors.RemoveAndRelease(ActorName);
return;
}
// If the object is physically active, add the axis locking constraint
if (Enabled
&& m_controllingPrim.IsPhysicallyActive
&& TryExperimentalLockAxisCode
&& m_controllingPrim.LockedAxis != m_controllingPrim.LockedAxisFree)
{
if (LockAxisConstraint == null)
AddAxisLockConstraint();
}
else
{
RemoveAxisLockConstraint();
}
}
// The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
// Register a prestep action to restore physical requirements before the next simulation step.
// Called at taint-time.
// BSActor.RemoveBodyDependencies()
public override void RemoveBodyDependencies()
{
if (LockAxisConstraint != null)
{
// If a constraint is set up, remove it from the physical scene
RemoveAxisLockConstraint();
// Schedule a call before the next simulation step to restore the constraint.
m_physicsScene.PostTaintObject(m_controllingPrim.LockedAxisActorName, m_controllingPrim.LocalID, delegate()
{
Refresh();
});
}
}
private void AddAxisLockConstraint()
{
// Lock that axis by creating a 6DOF constraint that has one end in the world and
// the other in the object.
// http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=20817
// http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=26380
// Remove any existing axis constraint (just to be sure)
RemoveAxisLockConstraint();
BSConstraint6Dof axisConstrainer = new BSConstraint6Dof(m_physicsScene.World, m_controllingPrim.PhysBody,
OMV.Vector3.Zero, OMV.Quaternion.Identity,
false /* useLinearReferenceFrameB */, true /* disableCollisionsBetweenLinkedBodies */);
LockAxisConstraint = axisConstrainer;
m_physicsScene.Constraints.AddConstraint(LockAxisConstraint);
// The constraint is tied to the world and oriented to the prim.
// Free to move linearly in the region
OMV.Vector3 linearLow = OMV.Vector3.Zero;
OMV.Vector3 linearHigh = m_physicsScene.TerrainManager.DefaultRegionSize;
axisConstrainer.SetLinearLimits(linearLow, linearHigh);
// Angular with some axis locked
float fPI = (float)Math.PI;
OMV.Vector3 angularLow = new OMV.Vector3(-fPI, -fPI, -fPI);
OMV.Vector3 angularHigh = new OMV.Vector3(fPI, fPI, fPI);
if (m_controllingPrim.LockedAxis.X != 1f)
{
angularLow.X = 0f;
angularHigh.X = 0f;
}
if (m_controllingPrim.LockedAxis.Y != 1f)
{
angularLow.Y = 0f;
angularHigh.Y = 0f;
}
if (m_controllingPrim.LockedAxis.Z != 1f)
{
angularLow.Z = 0f;
angularHigh.Z = 0f;
}
if (!axisConstrainer.SetAngularLimits(angularLow, angularHigh))
{
m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetAngularLimits", m_controllingPrim.LocalID);
}
m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,create,linLow={1},linHi={2},angLow={3},angHi={4}",
m_controllingPrim.LocalID, linearLow, linearHigh, angularLow, angularHigh);
// Constants from one of the posts mentioned above and used in Bullet's ConstraintDemo.
axisConstrainer.TranslationalLimitMotor(true /* enable */, 5.0f, 0.1f);
axisConstrainer.RecomputeConstraintVariables(m_controllingPrim.RawMass);
}
private void RemoveAxisLockConstraint()
{
if (LockAxisConstraint != null)
{
m_physicsScene.Constraints.RemoveAndDestroyConstraint(LockAxisConstraint);
LockAxisConstraint = null;
m_physicsScene.DetailLog("{0},BSActorLockAxis.RemoveAxisLockConstraint,destroyingConstraint", m_controllingPrim.LocalID);
}
}
}
}

131
OpenSim/Region/Physics/BulletSPlugin/BSActors.cs Executable file
View File

@ -0,0 +1,131 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyrightD
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Text;
namespace OpenSim.Region.Physics.BulletSPlugin
{
public class BSActorCollection
{
private BSScene PhysicsScene { get; set; }
private Dictionary<string, BSActor> m_actors;
public BSActorCollection(BSScene physicsScene)
{
PhysicsScene = physicsScene;
m_actors = new Dictionary<string, BSActor>();
}
public void Add(string name, BSActor actor)
{
m_actors[name] = actor;
}
public bool RemoveAndRelease(string name)
{
bool ret = false;
if (m_actors.ContainsKey(name))
{
BSActor beingRemoved = m_actors[name];
beingRemoved.Dispose();
m_actors.Remove(name);
ret = true;
}
return ret;
}
public void Clear()
{
Release();
m_actors.Clear();
}
public bool HasActor(string name)
{
return m_actors.ContainsKey(name);
}
public void ForEachActor(Action<BSActor> act)
{
foreach (KeyValuePair<string, BSActor> kvp in m_actors)
act(kvp.Value);
}
public void Release()
{
ForEachActor(a => a.Dispose());
}
public void Refresh()
{
ForEachActor(a => a.Refresh());
}
public void RemoveBodyDependencies()
{
ForEachActor(a => a.RemoveBodyDependencies());
}
}
// =============================================================================
/// <summary>
/// Each physical object can have 'actors' who are pushing the object around.
/// This can be used for hover, locking axis, making vehicles, etc.
/// Each physical object can have multiple actors acting on it.
///
/// An actor usually registers itself with physics scene events (pre-step action)
/// and modifies the parameters on the host physical object.
/// </summary>
public abstract class BSActor
{
protected BSScene m_physicsScene { get; private set; }
protected BSPhysObject m_controllingPrim { get; private set; }
protected bool Enabled { get; set; }
public string ActorName { get; private set; }
public BSActor(BSScene physicsScene, BSPhysObject pObj, string actorName)
{
m_physicsScene = physicsScene;
m_controllingPrim = pObj;
ActorName = actorName;
Enabled = true;
}
// Return 'true' if activily updating the prim
public virtual bool isActive
{
get { return Enabled; }
}
// Turn the actor on an off.
public virtual void Enable(bool setEnabled)
{
Enabled = setEnabled;
}
// Release any connections and resources used by the actor.
public abstract void Dispose();
// Called when physical parameters (properties set in Bullet) need to be re-applied.
public abstract void Refresh();
// The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
// Register a prestep action to restore physical requirements before the next simulation step.
public abstract void RemoveBodyDependencies();
}
}

17
OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
View File

@ -191,6 +191,21 @@ public struct ConfigurationParameters
public const float numericFalse = 0f;
}
// Parameters passed for the conversion of a mesh to a hull using Bullet's HACD library.
[StructLayout(LayoutKind.Sequential)]
public struct HACDParams
{
// usual default values
public float maxVerticesPerHull; // 100
public float minClusters; // 2
public float compacityWeight; // 0.1
public float volumeWeight; // 0.0
public float concavity; // 100
public float addExtraDistPoints; // false
public float addNeighboursDistPoints; // false
public float addFacesPoints; // false
public float shouldAdjustCollisionMargin; // false
}
// The states a bullet collision object can have
public enum ActivationState : uint
@ -308,7 +323,7 @@ public abstract BulletShape CreateMeshShape(BulletWorld world,
public abstract BulletShape CreateHullShape(BulletWorld world,
int hullCount, float[] hulls);
public abstract BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape);
public abstract BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms);
public abstract BulletShape BuildNativeShape(BulletWorld world, ShapeData shapeData);

9
OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
View File

@ -61,6 +61,7 @@ public sealed class BSCharacter : BSPhysObject
private OMV.Vector3 _rotationalVelocity;
private bool _kinematic;
private float _buoyancy;
private bool _isStationaryStanding; // true is standing on a stationary object
private BSVMotor _velocityMotor;
@ -84,6 +85,7 @@ public sealed class BSCharacter : BSPhysObject
_buoyancy = ComputeBuoyancyFromFlying(isFlying);
Friction = BSParam.AvatarStandingFriction;
Density = BSParam.AvatarDensity / BSParam.DensityScaleFactor;
_isStationaryStanding = false;
// Old versions of ScenePresence passed only the height. If width and/or depth are zero,
// replace with the default values.
@ -208,6 +210,7 @@ public sealed class BSCharacter : BSPhysObject
// The code below uses whether the collider is static or moving to decide whether to zero motion.
_velocityMotor.Step(timeStep);
_isStationaryStanding = false;
// If we're not supposed to be moving, make sure things are zero.
if (_velocityMotor.ErrorIsZero() && _velocityMotor.TargetValue == OMV.Vector3.Zero)
@ -221,6 +224,7 @@ public sealed class BSCharacter : BSPhysObject
if (!ColliderIsMoving)
{
DetailLog("{0},BSCharacter.MoveMotor,collidingWithStationary,zeroingMotion", LocalID);
_isStationaryStanding = true;
ZeroMotion(true /* inTaintTime */);
}
@ -882,7 +886,10 @@ public sealed class BSCharacter : BSPhysObject
// the world that things have changed.
public override void UpdateProperties(EntityProperties entprop)
{
_position = entprop.Position;
// Don't change position if standing on a stationary object.
if (!_isStationaryStanding)
_position = entprop.Position;
_orientation = entprop.Rotation;
// Smooth velocity. OpenSimulator is VERY sensitive to changes in velocity of the avatar

2
OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
View File

@ -85,7 +85,9 @@ public abstract class BSConstraint : IDisposable
{
bool ret = false;
if (m_enabled)
{
ret = PhysicsScene.PE.SetAngularLimits(m_constraint, low, high);
}
return ret;
}

4
OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs
View File

@ -97,14 +97,14 @@ public sealed class BSConstraint6Dof : BSConstraint
// A 6 Dof constraint that is fixed in the world and constrained to a on-the-fly created static object
public BSConstraint6Dof(BulletWorld world, BulletBody obj1, Vector3 frameInBloc, Quaternion frameInBrot,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj1; // Look out for confusion down the road
m_constraint = PhysicsScene.PE.Create6DofConstraintFixed(m_world, m_body1,
frameInBloc, frameInBrot,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
world.physicsScene.DetailLog("{0},BS6DofConstraint,createFixed,wID={1},rID={2},rBody={3}",
BSScene.DetailLogZero, world.worldID, obj1.ID, obj1.AddrString);

207
OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
View File

@ -40,13 +40,14 @@ using OpenSim.Region.Physics.Manager;
namespace OpenSim.Region.Physics.BulletSPlugin
{
public sealed class BSDynamics
public sealed class BSDynamics : BSActor
{
private static string LogHeader = "[BULLETSIM VEHICLE]";
private BSScene PhysicsScene { get; set; }
// the prim this dynamic controller belongs to
private BSPrim Prim { get; set; }
private BSPrim ControllingPrim { get; set; }
private bool m_haveRegisteredForSceneEvents;
// mass of the vehicle fetched each time we're calles
private float m_vehicleMass;
@ -129,11 +130,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
public bool enableAngularDeflection;
public bool enableAngularBanking;
public BSDynamics(BSScene myScene, BSPrim myPrim)
public BSDynamics(BSScene myScene, BSPrim myPrim, string actorName)
: base(myScene, myPrim, actorName)
{
PhysicsScene = myScene;
Prim = myPrim;
ControllingPrim = myPrim;
Type = Vehicle.TYPE_NONE;
m_haveRegisteredForSceneEvents = false;
SetupVehicleDebugging();
}
@ -155,7 +157,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Return 'true' if this vehicle is doing vehicle things
public bool IsActive
{
get { return (Type != Vehicle.TYPE_NONE && Prim.IsPhysicallyActive); }
get { return (Type != Vehicle.TYPE_NONE && ControllingPrim.IsPhysicallyActive); }
}
// Return 'true' if this a vehicle that should be sitting on the ground
@ -167,7 +169,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
#region Vehicle parameter setting
public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
{
VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
switch (pParam)
{
case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
@ -195,7 +197,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
break;
case Vehicle.BUOYANCY:
m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f);
m_VehicleGravity = Prim.ComputeGravity(m_VehicleBuoyancy);
m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
break;
case Vehicle.HOVER_EFFICIENCY:
m_VhoverEfficiency = ClampInRange(0f, pValue, 1f);
@ -258,7 +260,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
{
VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
switch (pParam)
{
case Vehicle.ANGULAR_FRICTION_TIMESCALE:
@ -294,7 +296,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
{
VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
switch (pParam)
{
case Vehicle.REFERENCE_FRAME:
@ -308,7 +310,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
internal void ProcessVehicleFlags(int pParam, bool remove)
{
VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", Prim.LocalID, pParam, remove);
VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", ControllingPrim.LocalID, pParam, remove);
VehicleFlag parm = (VehicleFlag)pParam;
if (pParam == -1)
m_flags = (VehicleFlag)0;
@ -323,7 +325,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
public void ProcessTypeChange(Vehicle pType)
{
VDetailLog("{0},ProcessTypeChange,type={1}", Prim.LocalID, pType);
VDetailLog("{0},ProcessTypeChange,type={1}", ControllingPrim.LocalID, pType);
// Set Defaults For Type
Type = pType;
switch (pType)
@ -563,12 +565,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
m_linearMotor = new BSVMotor("LinearMotor", m_linearMotorTimescale,
m_linearMotorDecayTimescale, m_linearFrictionTimescale,
1f);
m_linearMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG DEBUG (enables detail logging)
m_linearMotor.PhysicsScene = m_physicsScene; // DEBUG DEBUG DEBUG (enables detail logging)
m_angularMotor = new BSVMotor("AngularMotor", m_angularMotorTimescale,
m_angularMotorDecayTimescale, m_angularFrictionTimescale,
1f);
m_angularMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG DEBUG (enables detail logging)
m_angularMotor.PhysicsScene = m_physicsScene; // DEBUG DEBUG DEBUG (enables detail logging)
/* Not implemented
m_verticalAttractionMotor = new BSVMotor("VerticalAttraction", m_verticalAttractionTimescale,
@ -578,13 +580,23 @@ namespace OpenSim.Region.Physics.BulletSPlugin
m_verticalAttractionMotor.FrictionTimescale = new Vector3(BSMotor.Infinite, BSMotor.Infinite, 0.1f);
m_verticalAttractionMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG DEBUG (enables detail logging)
*/
if (this.Type == Vehicle.TYPE_NONE)
{
UnregisterForSceneEvents();
}
else
{
RegisterForSceneEvents();
}
}
#endregion // Vehicle parameter setting
public void Refresh()
// BSActor.Refresh()
public override void Refresh()
{
// If asking for a refresh, reset the physical parameters before the next simulation step.
PhysicsScene.PostTaintObject("BSDynamics.Refresh", Prim.LocalID, delegate()
m_physicsScene.PostTaintObject("BSDynamics.Refresh", ControllingPrim.LocalID, delegate()
{
SetPhysicalParameters();
});
@ -597,49 +609,90 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (IsActive)
{
// Remember the mass so we don't have to fetch it every step
m_vehicleMass = Prim.TotalMass;
m_vehicleMass = ControllingPrim.TotalMass;
// Friction affects are handled by this vehicle code
PhysicsScene.PE.SetFriction(Prim.PhysBody, BSParam.VehicleFriction);
PhysicsScene.PE.SetRestitution(Prim.PhysBody, BSParam.VehicleRestitution);
m_physicsScene.PE.SetFriction(ControllingPrim.PhysBody, BSParam.VehicleFriction);
m_physicsScene.PE.SetRestitution(ControllingPrim.PhysBody, BSParam.VehicleRestitution);
// Moderate angular movement introduced by Bullet.
// TODO: possibly set AngularFactor and LinearFactor for the type of vehicle.
// Maybe compute linear and angular factor and damping from params.
PhysicsScene.PE.SetAngularDamping(Prim.PhysBody, BSParam.VehicleAngularDamping);
PhysicsScene.PE.SetLinearFactor(Prim.PhysBody, BSParam.VehicleLinearFactor);
PhysicsScene.PE.SetAngularFactorV(Prim.PhysBody, BSParam.VehicleAngularFactor);
m_physicsScene.PE.SetAngularDamping(ControllingPrim.PhysBody, BSParam.VehicleAngularDamping);
m_physicsScene.PE.SetLinearFactor(ControllingPrim.PhysBody, BSParam.VehicleLinearFactor);
m_physicsScene.PE.SetAngularFactorV(ControllingPrim.PhysBody, BSParam.VehicleAngularFactor);
// Vehicles report collision events so we know when it's on the ground
PhysicsScene.PE.AddToCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
m_physicsScene.PE.AddToCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
Prim.Inertia = PhysicsScene.PE.CalculateLocalInertia(Prim.PhysShape, m_vehicleMass);
PhysicsScene.PE.SetMassProps(Prim.PhysBody, m_vehicleMass, Prim.Inertia);
PhysicsScene.PE.UpdateInertiaTensor(Prim.PhysBody);
ControllingPrim.Inertia = m_physicsScene.PE.CalculateLocalInertia(ControllingPrim.PhysShape, m_vehicleMass);
m_physicsScene.PE.SetMassProps(ControllingPrim.PhysBody, m_vehicleMass, ControllingPrim.Inertia);
m_physicsScene.PE.UpdateInertiaTensor(ControllingPrim.PhysBody);
// Set the gravity for the vehicle depending on the buoyancy
// TODO: what should be done if prim and vehicle buoyancy differ?
m_VehicleGravity = Prim.ComputeGravity(m_VehicleBuoyancy);
m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
// The actual vehicle gravity is set to zero in Bullet so we can do all the application of same.
PhysicsScene.PE.SetGravity(Prim.PhysBody, Vector3.Zero);
m_physicsScene.PE.SetGravity(ControllingPrim.PhysBody, Vector3.Zero);
VDetailLog("{0},BSDynamics.SetPhysicalParameters,mass={1},inert={2},vehGrav={3},aDamp={4},frict={5},rest={6},lFact={7},aFact={8}",
Prim.LocalID, m_vehicleMass, Prim.Inertia, m_VehicleGravity,
ControllingPrim.LocalID, m_vehicleMass, ControllingPrim.Inertia, m_VehicleGravity,
BSParam.VehicleAngularDamping, BSParam.VehicleFriction, BSParam.VehicleRestitution,
BSParam.VehicleLinearFactor, BSParam.VehicleAngularFactor
);
}
else
{
if (Prim.PhysBody.HasPhysicalBody)
PhysicsScene.PE.RemoveFromCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
if (ControllingPrim.PhysBody.HasPhysicalBody)
m_physicsScene.PE.RemoveFromCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
}
}
public bool RemoveBodyDependencies(BSPhysObject prim)
// BSActor.RemoveBodyDependencies
public override void RemoveBodyDependencies()
{
Refresh();
return IsActive;
}
// BSActor.Release()
public override void Dispose()
{
UnregisterForSceneEvents();
Type = Vehicle.TYPE_NONE;
Enabled = false;
return;
}
private void RegisterForSceneEvents()
{
if (!m_haveRegisteredForSceneEvents)
{
m_physicsScene.BeforeStep += this.Step;
m_physicsScene.AfterStep += this.PostStep;
ControllingPrim.OnPreUpdateProperty += this.PreUpdateProperty;
m_haveRegisteredForSceneEvents = true;
}
}
private void UnregisterForSceneEvents()
{
if (m_haveRegisteredForSceneEvents)
{
m_physicsScene.BeforeStep -= this.Step;
m_physicsScene.AfterStep -= this.PostStep;
ControllingPrim.OnPreUpdateProperty -= this.PreUpdateProperty;
m_haveRegisteredForSceneEvents = false;
}
}
private void PreUpdateProperty(ref EntityProperties entprop)
{
// A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
// TODO: handle physics introduced by Bullet with computed vehicle physics.
if (IsActive)
{
entprop.RotationalVelocity = Vector3.Zero;
}
}
#region Known vehicle value functions
@ -686,14 +739,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (m_knownChanged != 0)
{
if ((m_knownChanged & m_knownChangedPosition) != 0)
Prim.ForcePosition = m_knownPosition;
ControllingPrim.ForcePosition = m_knownPosition;
if ((m_knownChanged & m_knownChangedOrientation) != 0)
Prim.ForceOrientation = m_knownOrientation;
ControllingPrim.ForceOrientation = m_knownOrientation;
if ((m_knownChanged & m_knownChangedVelocity) != 0)
{
Prim.ForceVelocity = m_knownVelocity;
ControllingPrim.ForceVelocity = m_knownVelocity;
// Fake out Bullet by making it think the velocity is the same as last time.
// Bullet does a bunch of smoothing for changing parameters.
// Since the vehicle is demanding this setting, we override Bullet's smoothing
@ -702,28 +755,28 @@ namespace OpenSim.Region.Physics.BulletSPlugin
}
if ((m_knownChanged & m_knownChangedForce) != 0)
Prim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
ControllingPrim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
if ((m_knownChanged & m_knownChangedForceImpulse) != 0)
Prim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
ControllingPrim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0)
{
Prim.ForceRotationalVelocity = m_knownRotationalVelocity;
ControllingPrim.ForceRotationalVelocity = m_knownRotationalVelocity;
// PhysicsScene.PE.SetInterpolationAngularVelocity(Prim.PhysBody, m_knownRotationalVelocity);
}
if ((m_knownChanged & m_knownChangedRotationalImpulse) != 0)
Prim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/);
ControllingPrim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/);
if ((m_knownChanged & m_knownChangedRotationalForce) != 0)
{
Prim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
ControllingPrim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
}
// If we set one of the values (ie, the physics engine didn't do it) we must force
// an UpdateProperties event to send the changes up to the simulator.
PhysicsScene.PE.PushUpdate(Prim.PhysBody);
m_physicsScene.PE.PushUpdate(ControllingPrim.PhysBody);
}
m_knownChanged = 0;
}
@ -736,7 +789,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if ((m_knownHas & m_knownChangedTerrainHeight) == 0 || pos != lastRememberedHeightPos)
{
lastRememberedHeightPos = pos;
m_knownTerrainHeight = Prim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
m_knownTerrainHeight = ControllingPrim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
m_knownHas |= m_knownChangedTerrainHeight;
}
return m_knownTerrainHeight;
@ -748,7 +801,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
if ((m_knownHas & m_knownChangedWaterLevel) == 0)
{
m_knownWaterLevel = Prim.PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(pos);
m_knownWaterLevel = ControllingPrim.PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(pos);
m_knownHas |= m_knownChangedWaterLevel;
}
return (float)m_knownWaterLevel;
@ -760,7 +813,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
if ((m_knownHas & m_knownChangedPosition) == 0)
{
m_knownPosition = Prim.ForcePosition;
m_knownPosition = ControllingPrim.ForcePosition;
m_knownHas |= m_knownChangedPosition;
}
return m_knownPosition;
@ -779,7 +832,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
if ((m_knownHas & m_knownChangedOrientation) == 0)
{
m_knownOrientation = Prim.ForceOrientation;
m_knownOrientation = ControllingPrim.ForceOrientation;
m_knownHas |= m_knownChangedOrientation;
}
return m_knownOrientation;
@ -798,7 +851,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
if ((m_knownHas & m_knownChangedVelocity) == 0)
{
m_knownVelocity = Prim.ForceVelocity;
m_knownVelocity = ControllingPrim.ForceVelocity;
m_knownHas |= m_knownChangedVelocity;
}
return m_knownVelocity;
@ -839,7 +892,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
if ((m_knownHas & m_knownChangedRotationalVelocity) == 0)
{
m_knownRotationalVelocity = Prim.ForceRotationalVelocity;
m_knownRotationalVelocity = ControllingPrim.ForceRotationalVelocity;
m_knownHas |= m_knownChangedRotationalVelocity;
}
return (Vector3)m_knownRotationalVelocity;
@ -914,11 +967,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// for the physics engine to note the changes so an UpdateProperties event will happen.
PushKnownChanged();
if (PhysicsScene.VehiclePhysicalLoggingEnabled)
PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody);
if (m_physicsScene.VehiclePhysicalLoggingEnabled)
m_physicsScene.PE.DumpRigidBody(m_physicsScene.World, ControllingPrim.PhysBody);
VDetailLog("{0},BSDynamics.Step,done,pos={1}, force={2},velocity={3},angvel={4}",
Prim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity);
ControllingPrim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity);
}
// Called after the simulation step
@ -926,8 +979,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
if (!IsActive) return;
if (PhysicsScene.VehiclePhysicalLoggingEnabled)
PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody);
if (m_physicsScene.VehiclePhysicalLoggingEnabled)
m_physicsScene.PE.DumpRigidBody(m_physicsScene.World, ControllingPrim.PhysBody);
}
// Apply the effect of the linear motor and other linear motions (like hover and float).
@ -967,12 +1020,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleVelocity /= VehicleVelocity.Length();
VehicleVelocity *= BSParam.VehicleMaxLinearVelocity;
VDetailLog("{0}, MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}",
Prim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
ControllingPrim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
}
else if (newVelocityLengthSq < 0.001f)
VehicleVelocity = Vector3.Zero;
VDetailLog("{0}, MoveLinear,done,isColl={1},newVel={2}", Prim.LocalID, Prim.IsColliding, VehicleVelocity );
VDetailLog("{0}, MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.IsColliding, VehicleVelocity );
} // end MoveLinear()
@ -997,7 +1050,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleVelocity += linearMotorVelocityW;
VDetailLog("{0}, MoveLinear,velocity,origVelW={1},velV={2},correctV={3},correctW={4},newVelW={5}",
Prim.LocalID, origVelW, currentVelV, linearMotorCorrectionV, linearMotorVelocityW, VehicleVelocity);
ControllingPrim.LocalID, origVelW, currentVelV, linearMotorCorrectionV, linearMotorVelocityW, VehicleVelocity);
}
public void ComputeLinearTerrainHeightCorrection(float pTimestep)
@ -1011,7 +1064,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
newPosition.Z = GetTerrainHeight(VehiclePosition) + 1f;
VehiclePosition = newPosition;
VDetailLog("{0}, MoveLinear,terrainHeight,terrainHeight={1},pos={2}",
Prim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition);
ControllingPrim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition);
}
}
@ -1050,7 +1103,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
pos.Z = m_VhoverTargetHeight;
VehiclePosition = pos;
VDetailLog("{0}, MoveLinear,hover,pos={1},lockHoverHeight", Prim.LocalID, pos);
VDetailLog("{0}, MoveLinear,hover,pos={1},lockHoverHeight", ControllingPrim.LocalID, pos);
}
}
else
@ -1079,7 +1132,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
*/
VDetailLog("{0}, MoveLinear,hover,pos={1},eff={2},hoverTS={3},height={4},target={5},err={6},corr={7}",
Prim.LocalID, VehiclePosition, m_VhoverEfficiency,
ControllingPrim.LocalID, VehiclePosition, m_VhoverEfficiency,
m_VhoverTimescale, m_VhoverHeight, m_VhoverTargetHeight,
verticalError, verticalCorrection);
}
@ -1124,7 +1177,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
VehiclePosition = pos;
VDetailLog("{0}, MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}",
Prim.LocalID, m_BlockingEndPoint, posChange, pos);
ControllingPrim.LocalID, m_BlockingEndPoint, posChange, pos);
}
}
return changed;
@ -1164,7 +1217,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Another approach is to measure if we're going up. If going up and not colliding,
// the vehicle is in the air. Fix that by pushing down.
if (!Prim.IsColliding && VehicleVelocity.Z > 0.1)
if (!ControllingPrim.IsColliding && VehicleVelocity.Z > 0.1)
{
// Get rid of any of the velocity vector that is pushing us up.
float upVelocity = VehicleVelocity.Z;
@ -1186,7 +1239,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
}
*/
VDetailLog("{0}, MoveLinear,limitMotorUp,collide={1},upVel={2},newVel={3}",
Prim.LocalID, Prim.IsColliding, upVelocity, VehicleVelocity);
ControllingPrim.LocalID, ControllingPrim.IsColliding, upVelocity, VehicleVelocity);
}
}
}
@ -1196,14 +1249,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
Vector3 appliedGravity = m_VehicleGravity * m_vehicleMass;
// Hack to reduce downward force if the vehicle is probably sitting on the ground
if (Prim.IsColliding && IsGroundVehicle)
if (ControllingPrim.IsColliding && IsGroundVehicle)
appliedGravity *= BSParam.VehicleGroundGravityFudge;
VehicleAddForce(appliedGravity);
VDetailLog("{0}, MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={3}",
Prim.LocalID, m_VehicleGravity,
Prim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
ControllingPrim.LocalID, m_VehicleGravity,
ControllingPrim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
}
// =======================================================================
@ -1227,11 +1280,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
// The vehicle is not adding anything angular wise.
VehicleRotationalVelocity = Vector3.Zero;
VDetailLog("{0}, MoveAngular,done,zero", Prim.LocalID);
VDetailLog("{0}, MoveAngular,done,zero", ControllingPrim.LocalID);
}
else
{
VDetailLog("{0}, MoveAngular,done,nonZero,angVel={1}", Prim.LocalID, VehicleRotationalVelocity);
VDetailLog("{0}, MoveAngular,done,nonZero,angVel={1}", ControllingPrim.LocalID, VehicleRotationalVelocity);
}
// ==================================================================
@ -1262,7 +1315,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
torqueFromOffset.Z = 0;
VehicleAddAngularForce(torqueFromOffset * m_vehicleMass);
VDetailLog("{0}, BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", Prim.LocalID, torqueFromOffset);
VDetailLog("{0}, BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", ControllingPrim.LocalID, torqueFromOffset);
}
}
@ -1288,7 +1341,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// }
VehicleRotationalVelocity += angularMotorContributionV * VehicleOrientation;
VDetailLog("{0}, MoveAngular,angularTurning,angularMotorContrib={1}", Prim.LocalID, angularMotorContributionV);
VDetailLog("{0}, MoveAngular,angularTurning,angularMotorContrib={1}", ControllingPrim.LocalID, angularMotorContributionV);
}
// From http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial:
@ -1334,7 +1387,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleRotationalVelocity += vertContributionV;
VDetailLog("{0}, MoveAngular,verticalAttraction,diffAxis={1},diffAng={2},corrRot={3},contrib={4}",
Prim.LocalID,
ControllingPrim.LocalID,
differenceAxis,
differenceAngle,
correctionRotation,
@ -1433,9 +1486,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleRotationalVelocity += deflectContributionV * VehicleOrientation;
VDetailLog("{0}, MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}",
Prim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
VDetailLog("{0}, MoveAngular,Deflection,fwdSpd={1},defEff={2},defTS={3}",
Prim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale);
ControllingPrim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale);
}
}
@ -1501,7 +1554,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VDetailLog("{0}, MoveAngular,Banking,rollComp={1},speed={2},rollComp={3},yAng={4},mYAng={5},ret={6}",
Prim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV);
ControllingPrim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV);
}
}
@ -1540,7 +1593,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (rotq != m_rot)
{
VehicleOrientation = m_rot;
VDetailLog("{0}, LimitRotation,done,orig={1},new={2}", Prim.LocalID, rotq, m_rot);
VDetailLog("{0}, LimitRotation,done,orig={1},new={2}", ControllingPrim.LocalID, rotq, m_rot);
}
}
@ -1554,8 +1607,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Invoke the detailed logger and output something if it's enabled.
private void VDetailLog(string msg, params Object[] args)
{
if (Prim.PhysicsScene.VehicleLoggingEnabled)
Prim.PhysicsScene.DetailLog(msg, args);
if (ControllingPrim.PhysicsScene.VehicleLoggingEnabled)
ControllingPrim.PhysicsScene.DetailLog(msg, args);
}
}
}

13
OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
View File

@ -78,6 +78,9 @@ public abstract class BSPhysObject : PhysicsActor
Name = name; // PhysicsActor also has the name of the object. Someday consolidate.
TypeName = typeName;
// The collection of things that push me around
PhysicalActors = new BSActorCollection(PhysicsScene);
// Initialize variables kept in base.
GravModifier = 1.0f;
Gravity = new OMV.Vector3(0f, 0f, BSParam.Gravity);
@ -109,6 +112,10 @@ public abstract class BSPhysObject : PhysicsActor
{
UnRegisterAllPreStepActions();
UnRegisterAllPostStepActions();
PhysicsScene.TaintedObject("BSPhysObject.Destroy", delegate()
{
PhysicalActors.Release();
});
}
public BSScene PhysicsScene { get; protected set; }
@ -180,7 +187,7 @@ public abstract class BSPhysObject : PhysicsActor
Friction = matAttrib.friction;
Restitution = matAttrib.restitution;
Density = matAttrib.density / BSParam.DensityScaleFactor;
DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density);
// DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density);
}
// Stop all physical motion.
@ -230,6 +237,7 @@ public abstract class BSPhysObject : PhysicsActor
public OMV.Vector3 LockedAxis { get; set; } // zero means locked. one means free.
public readonly OMV.Vector3 LockedAxisFree = new OMV.Vector3(1f, 1f, 1f); // All axis are free
public readonly String LockedAxisActorName = "BSPrim.LockedAxis";
#region Collisions
@ -413,6 +421,9 @@ public abstract class BSPhysObject : PhysicsActor
#endregion // Collisions
#region Per Simulation Step actions
public BSActorCollection PhysicalActors;
// There are some actions that must be performed for a physical object before each simulation step.
// These actions are optional so, rather than scanning all the physical objects and asking them
// if they have anything to do, a physical object registers for an event call before the step is performed.

129
OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
View File

@ -72,7 +72,8 @@ public class BSPrim : BSPhysObject
private int CrossingFailures { get; set; }
public BSDynamics VehicleController { get; private set; }
public BSDynamics VehicleActor;
public string VehicleActorName = "BasicVehicle";
private BSVMotor _targetMotor;
private OMV.Vector3 _PIDTarget;
@ -100,11 +101,12 @@ public class BSPrim : BSPhysObject
_isPhysical = pisPhysical;
_isVolumeDetect = false;
VehicleController = new BSDynamics(PhysicsScene, this); // add vehicleness
VehicleActor = new BSDynamics(PhysicsScene, this, VehicleActorName);
PhysicalActors.Add(VehicleActorName, VehicleActor);
_mass = CalculateMass();
DetailLog("{0},BSPrim.constructor,call", LocalID);
// DetailLog("{0},BSPrim.constructor,call", LocalID);
// do the actual object creation at taint time
PhysicsScene.TaintedObject("BSPrim.create", delegate()
{
@ -126,7 +128,7 @@ public class BSPrim : BSPhysObject
// Undo any vehicle properties
this.VehicleType = (int)Vehicle.TYPE_NONE;
PhysicsScene.TaintedObject("BSPrim.destroy", delegate()
PhysicsScene.TaintedObject("BSPrim.Destroy", delegate()
{
DetailLog("{0},BSPrim.Destroy,taint,", LocalID);
// If there are physical body and shape, release my use of same.
@ -257,98 +259,32 @@ public class BSPrim : BSPhysObject
});
}
bool TryExperimentalLockAxisCode = false;
BSConstraint LockAxisConstraint = null;
public override void LockAngularMotion(OMV.Vector3 axis)
{
DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
// "1" means free, "0" means locked
OMV.Vector3 locking = new OMV.Vector3(1f, 1f, 1f);
OMV.Vector3 locking = LockedAxisFree;
if (axis.X != 1) locking.X = 0f;
if (axis.Y != 1) locking.Y = 0f;
if (axis.Z != 1) locking.Z = 0f;
LockedAxis = locking;
if (TryExperimentalLockAxisCode && LockedAxis != LockedAxisFree)
if (LockedAxis != LockedAxisFree)
{
// Lock that axis by creating a 6DOF constraint that has one end in the world and
// the other in the object.
// http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=20817
// http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=26380
PhysicsScene.TaintedObject("BSPrim.LockAngularMotion", delegate()
{
CleanUpLockAxisPhysicals(true /* inTaintTime */);
BSConstraint6Dof axisConstrainer = new BSConstraint6Dof(PhysicsScene.World, PhysBody,
OMV.Vector3.Zero, OMV.Quaternion.Inverse(RawOrientation),
true /* useLinearReferenceFrameB */, true /* disableCollisionsBetweenLinkedBodies */);
LockAxisConstraint = axisConstrainer;
PhysicsScene.Constraints.AddConstraint(LockAxisConstraint);
// The constraint is tied to the world and oriented to the prim.
// Free to move linearly
OMV.Vector3 linearLow = OMV.Vector3.Zero;
OMV.Vector3 linearHigh = PhysicsScene.TerrainManager.DefaultRegionSize;
axisConstrainer.SetLinearLimits(linearLow, linearHigh);
// Angular with some axis locked
float f2PI = (float)Math.PI * 2f;
OMV.Vector3 angularLow = new OMV.Vector3(-f2PI, -f2PI, -f2PI);
OMV.Vector3 angularHigh = new OMV.Vector3(f2PI, f2PI, f2PI);
if (LockedAxis.X != 1f)
// If there is not already an axis locker, make one
if (!PhysicalActors.HasActor(LockedAxisActorName))
{
angularLow.X = 0f;
angularHigh.X = 0f;
DetailLog("{0},BSPrim.LockAngularMotion,taint,registeringLockAxisActor", LocalID);
PhysicalActors.Add(LockedAxisActorName, new BSActorLockAxis(PhysicsScene, this, LockedAxisActorName));
}
if (LockedAxis.Y != 1f)
{
angularLow.Y = 0f;
angularHigh.Y = 0f;
}
if (LockedAxis.Z != 1f)
{
angularLow.Z = 0f;
angularHigh.Z = 0f;
}
axisConstrainer.SetAngularLimits(angularLow, angularHigh);
DetailLog("{0},BSPrim.LockAngularMotion,create,linLow={1},linHi={2},angLow={3},angHi={4}",
LocalID, linearLow, linearHigh, angularLow, angularHigh);
// Constants from one of the posts mentioned above and used in Bullet's ConstraintDemo.
axisConstrainer.TranslationalLimitMotor(true /* enable */, 5.0f, 0.1f);
axisConstrainer.RecomputeConstraintVariables(RawMass);
UpdatePhysicalParameters();
});
}
else
{
// Everything seems unlocked
CleanUpLockAxisPhysicals(false /* inTaintTime */);
}
return;
}
// Get rid of any constraint built for LockAxis
// Most often the constraint is removed when the constraint collection is cleaned for this prim.
private void CleanUpLockAxisPhysicals(bool inTaintTime)
{
if (LockAxisConstraint != null)
{
PhysicsScene.TaintedObject(inTaintTime, "BSPrim.CleanUpLockAxisPhysicals", delegate()
{
if (LockAxisConstraint != null)
{
PhysicsScene.Constraints.RemoveAndDestroyConstraint(LockAxisConstraint);
LockAxisConstraint = null;
DetailLog("{0},BSPrim.CleanUpLockAxisPhysicals,destroyingConstraint", LocalID);
}
});
}
}
public override OMV.Vector3 RawPosition
{
@ -604,7 +540,7 @@ public class BSPrim : BSPhysObject
public override int VehicleType {
get {
return (int)VehicleController.Type; // if we are a vehicle, return that type
return (int)VehicleActor.Type; // if we are a vehicle, return that type
}
set {
Vehicle type = (Vehicle)value;
@ -613,20 +549,8 @@ public class BSPrim : BSPhysObject
{
// Done at taint time so we're sure the physics engine is not using the variables
// Vehicle code changes the parameters for this vehicle type.
VehicleController.ProcessTypeChange(type);
VehicleActor.ProcessTypeChange(type);
ActivateIfPhysical(false);
// If an active vehicle, register the vehicle code to be called before each step
if (VehicleController.Type == Vehicle.TYPE_NONE)
{
UnRegisterPreStepAction("BSPrim.Vehicle", LocalID);
UnRegisterPostStepAction("BSPrim.Vehicle", LocalID);
}
else
{
RegisterPreStepAction("BSPrim.Vehicle", LocalID, VehicleController.Step);
RegisterPostStepAction("BSPrim.Vehicle", LocalID, VehicleController.PostStep);
}
});
}
}
@ -634,7 +558,7 @@ public class BSPrim : BSPhysObject
{
PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate()
{
VehicleController.ProcessFloatVehicleParam((Vehicle)param, value);
VehicleActor.ProcessFloatVehicleParam((Vehicle)param, value);
ActivateIfPhysical(false);
});
}
@ -642,7 +566,7 @@ public class BSPrim : BSPhysObject
{
PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate()
{
VehicleController.ProcessVectorVehicleParam((Vehicle)param, value);
VehicleActor.ProcessVectorVehicleParam((Vehicle)param, value);
ActivateIfPhysical(false);
});
}
@ -650,7 +574,7 @@ public class BSPrim : BSPhysObject
{
PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate()
{
VehicleController.ProcessRotationVehicleParam((Vehicle)param, rotation);
VehicleActor.ProcessRotationVehicleParam((Vehicle)param, rotation);
ActivateIfPhysical(false);
});
}
@ -658,7 +582,7 @@ public class BSPrim : BSPhysObject
{
PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate()
{
VehicleController.ProcessVehicleFlags(param, remove);
VehicleActor.ProcessVehicleFlags(param, remove);
});
}
@ -915,7 +839,8 @@ public class BSPrim : BSPhysObject
MakeDynamic(IsStatic);
// Update vehicle specific parameters (after MakeDynamic() so can change physical parameters)
VehicleController.Refresh();
VehicleActor.Refresh();
PhysicalActors.Refresh();
// Arrange for collision events if the simulator wants them
EnableCollisions(SubscribedEvents());
@ -1721,9 +1646,9 @@ public class BSPrim : BSPhysObject
volume *= (profileEnd - profileBegin);
returnMass = Density * BSParam.DensityScaleFactor * volume;
DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
returnMass = Util.Clamp(returnMass, BSParam.MinimumObjectMass, BSParam.MaximumObjectMass);
// DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
return returnMass;
}// end CalculateMass
@ -1752,7 +1677,8 @@ public class BSPrim : BSPhysObject
protected virtual void RemoveBodyDependencies()
{
VehicleController.RemoveBodyDependencies(this);
VehicleActor.RemoveBodyDependencies();
PhysicalActors.RemoveBodyDependencies();
}
// The physics engine says that properties have updated. Update same and inform
@ -1761,13 +1687,6 @@ public class BSPrim : BSPhysObject
{
TriggerPreUpdatePropertyAction(ref entprop);
// A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
// TODO: handle physics introduced by Bullet with computed vehicle physics.
if (VehicleController.IsActive)
{
entprop.RotationalVelocity = OMV.Vector3.Zero;
}
// DetailLog("{0},BSPrim.UpdateProperties,entry,entprop={1}", LocalID, entprop); // DEBUG DEBUG
// Assign directly to the local variables so the normal set actions do not happen

2
OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
View File

@ -463,7 +463,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
if (!m_initialized) return null;
DetailLog("{0},BSScene.AddPrimShape,call", localID);
// DetailLog("{0},BSScene.AddPrimShape,call", localID);
BSPhysObject prim = new BSPrimLinkable(localID, primName, this, position, size, rotation, pbs, isPhysical);
lock (PhysObjects) PhysObjects.Add(localID, prim);

33
OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
View File

@ -199,15 +199,8 @@ public sealed class BSTerrainManager : IDisposable
if (MegaRegionParentPhysicsScene is BSScene)
{
DetailLog("{0},SetTerrain.ToParent,offset={1},worldMax={2}", BSScene.DetailLogZero, m_worldOffset, m_worldMax);
// This looks really odd but this region is passing its terrain to its mega-region root region
// and the creation of the terrain must happen on the root region's taint thread and not
// my taint thread.
((BSScene)MegaRegionParentPhysicsScene).PostTaintObject("TerrainManager.SetTerrain.Mega-" + m_worldOffset.ToString(), 0, delegate()
{
((BSScene)MegaRegionParentPhysicsScene).TerrainManager.UpdateTerrain(
BSScene.CHILDTERRAIN_ID, localHeightMap,
m_worldOffset, m_worldOffset + DefaultRegionSize, true /* inTaintTime */);
});
((BSScene)MegaRegionParentPhysicsScene).TerrainManager.AddMegaRegionChildTerrain(
BSScene.CHILDTERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
}
}
else
@ -215,12 +208,23 @@ public sealed class BSTerrainManager : IDisposable
// If not doing the mega-prim thing, just change the terrain
DetailLog("{0},SetTerrain.Existing", BSScene.DetailLogZero);
UpdateTerrain(BSScene.TERRAIN_ID, localHeightMap,
m_worldOffset, m_worldOffset + DefaultRegionSize, true /* inTaintTime */);
UpdateTerrain(BSScene.TERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
}
});
}
// Another region is calling this region passing a terrain.
// A region that is not the mega-region root will pass its terrain to the root region so the root region
// physics engine will have all the terrains.
private void AddMegaRegionChildTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
{
// Since we are called by another region's thread, the action must be rescheduled onto our processing thread.
PhysicsScene.PostTaintObject("TerrainManager.AddMegaRegionChild" + m_worldOffset.ToString(), 0, delegate()
{
UpdateTerrain(id, heightMap, minCoords, maxCoords);
});
}
// If called for terrain has has not been previously allocated, a new terrain will be built
// based on the passed information. The 'id' should be either the terrain id or
// BSScene.CHILDTERRAIN_ID. If the latter, a new child terrain ID will be allocated and used.
@ -230,11 +234,10 @@ public sealed class BSTerrainManager : IDisposable
// This call is most often used to update the heightMap and parameters of the terrain.
// (The above does suggest that some simplification/refactoring is in order.)
// Called during taint-time.
private void UpdateTerrain(uint id, float[] heightMap,
Vector3 minCoords, Vector3 maxCoords, bool inTaintTime)
private void UpdateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
{
DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3},inTaintTime={4}",
BSScene.DetailLogZero, id, minCoords, maxCoords, inTaintTime);
DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3}",
BSScene.DetailLogZero, id, minCoords, maxCoords);
// Find high and low points of passed heightmap.
// The min and max passed in is usually the area objects can be in (maximum

12
OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
View File

@ -114,9 +114,9 @@ public class BasicVehicles : OpenSimTestCase
// Instead the appropriate values are set and calls are made just the parts of the
// controller we want to exercise. Stepping the physics engine then applies
// the actions of that one feature.
TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
TestVehicle.VehicleController.enableAngularVerticalAttraction = true;
TestVehicle.VehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
TestVehicle.VehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
TestVehicle.VehicleActor.enableAngularVerticalAttraction = true;
TestVehicle.IsPhysical = true;
PhysicsScene.ProcessTaints();
@ -124,9 +124,9 @@ public class BasicVehicles : OpenSimTestCase
// Step the simulator a bunch of times and vertical attraction should orient the vehicle up
for (int ii = 0; ii < simSteps; ii++)
{
TestVehicle.VehicleController.ForgetKnownVehicleProperties();
TestVehicle.VehicleController.ComputeAngularVerticalAttraction();
TestVehicle.VehicleController.PushKnownChanged();
TestVehicle.VehicleActor.ForgetKnownVehicleProperties();
TestVehicle.VehicleActor.ComputeAngularVerticalAttraction();
TestVehicle.VehicleActor.PushKnownChanged();
PhysicsScene.Simulate(simulationTimeStep);
}

4
OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
View File

@ -609,7 +609,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
if (!(MainConsole.Instance.ConsoleScene == null || MainConsole.Instance.ConsoleScene == m_Scene))
return;
MainConsole.Instance.OutputFormat(GetStatusReport());
MainConsole.Instance.Output(GetStatusReport());
}
public string GetStatusReport()
@ -708,7 +708,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
sb.AppendFormat("Containing part UUID: {0}\n", instance.ObjectID);
sb.AppendFormat("Position : {0}\n", sop.AbsolutePosition);
MainConsole.Instance.OutputFormat(sb.ToString());
MainConsole.Instance.Output(sb.ToString());
}
private void HandleSuspendScript(IScriptInstance instance)

BIN
bin/lib32/BulletSim.dll
View File

Binary file not shown.

BIN
bin/lib32/libBulletSim.so
View File

Binary file not shown.

BIN
bin/lib64/BulletSim.dll
View File

Binary file not shown.

BIN
bin/lib64/libBulletSim.so
View File

Binary file not shown.