Merge branch 'master' into careminster

Conflicts:
	OpenSim/Region/Framework/Scenes/SceneObjectPart.cs

OpenSim/Data/MSSQL/Resources/RegionStore.migrations

@@ -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 `PhysicsShapeType` tinyint(4) NOT NULL default '0';
-ALTER TABLE prims ADD COLUMN `Density` double NOT NULL default '1000';
+ALTER TABLE prims ADD `Density` double NOT NULL default '1000';
-ALTER TABLE prims ADD COLUMN `GravityModifier` double NOT NULL default '1';
+ALTER TABLE prims ADD `GravityModifier` double NOT NULL default '1';
-ALTER TABLE prims ADD COLUMN `Friction` double NOT NULL default '0.6';
+ALTER TABLE prims ADD `Friction` double NOT NULL default '0.6';
-ALTER TABLE prims ADD COLUMN `Restitution` double NOT NULL default '0.5';
+ALTER TABLE prims ADD `Restitution` double NOT NULL default '0.5';
 
 COMMIT

OpenSim/Region/CoreModules/Framework/UserManagement/HGUserManagementModule.cs

@@ -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;

OpenSim/Region/Framework/Scenes/SceneObjectPart.cs

@@ -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) ||
+            Vector3 oldPos = OffsetPosition;
-                (pos.Y != OffsetPosition.Y) ||
-                (pos.Z != OffsetPosition.Z))
-            {
-                Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
 
+            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)

OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs

@@ -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);

OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs

@@ -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)

OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs

@@ -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);
+        }
+    }
+}
+}

OpenSim/Region/Physics/BulletSPlugin/BSActors.cs

@@ -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();
+
+}
+}

OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs

@@ -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);
 

OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs

@@ -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

OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs

@@ -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;
     }
 

OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs

@@ -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);

OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs

@@ -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;
+            ControllingPrim = myPrim;
-            Prim = 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);
+                m_physicsScene.PE.SetFriction(ControllingPrim.PhysBody, BSParam.VehicleFriction);
-                PhysicsScene.PE.SetRestitution(Prim.PhysBody, BSParam.VehicleRestitution);
+                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);
+                m_physicsScene.PE.SetAngularDamping(ControllingPrim.PhysBody, BSParam.VehicleAngularDamping);
-                PhysicsScene.PE.SetLinearFactor(Prim.PhysBody, BSParam.VehicleLinearFactor);
+                m_physicsScene.PE.SetLinearFactor(ControllingPrim.PhysBody, BSParam.VehicleLinearFactor);
-                PhysicsScene.PE.SetAngularFactorV(Prim.PhysBody, BSParam.VehicleAngularFactor);
+                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);
+                ControllingPrim.Inertia = m_physicsScene.PE.CalculateLocalInertia(ControllingPrim.PhysShape, m_vehicleMass);
-                PhysicsScene.PE.SetMassProps(Prim.PhysBody, m_vehicleMass, Prim.Inertia);
+                m_physicsScene.PE.SetMassProps(ControllingPrim.PhysBody, m_vehicleMass, ControllingPrim.Inertia);
-                PhysicsScene.PE.UpdateInertiaTensor(Prim.PhysBody);
+                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)
+                if (ControllingPrim.PhysBody.HasPhysicalBody)
-                    PhysicsScene.PE.RemoveFromCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                    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)
+            if (m_physicsScene.VehiclePhysicalLoggingEnabled)
-                PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody);
+                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)
+            if (m_physicsScene.VehiclePhysicalLoggingEnabled)
-                PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody);
+                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,
+                            ControllingPrim.LocalID, m_VehicleGravity,
-                            Prim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
+                            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)
+            if (ControllingPrim.PhysicsScene.VehicleLoggingEnabled)
-                Prim.PhysicsScene.DetailLog(msg, args);
+                ControllingPrim.PhysicsScene.DetailLog(msg, args);
         }
     }
 }

OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs

@@ -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.

OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs

@@ -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 */);
+                // If there is not already an axis locker, make one
-
+                if (!PhysicalActors.HasActor(LockedAxisActorName))
-                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)
                 {
-                    angularLow.X = 0f;
+                    DetailLog("{0},BSPrim.LockAngularMotion,taint,registeringLockAxisActor", LocalID);
-                    angularHigh.X = 0f;
+                    PhysicalActors.Add(LockedAxisActorName, new BSActorLockAxis(PhysicsScene, this, LockedAxisActorName));
                 }
-                if (LockedAxis.Y != 1f)
+                UpdatePhysicalParameters();
-                {
-                    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);
             });
         }
-        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

OpenSim/Region/Physics/BulletSPlugin/BSScene.cs

@@ -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);

OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs

@@ -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
+                    ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.AddMegaRegionChildTerrain(
-                    //    and the creation of the terrain must happen on the root region's taint thread and not
+                                        BSScene.CHILDTERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
-                    //    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 */);
-                    });
                 }
             }
             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,
+                UpdateTerrain(BSScene.TERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
-                                    m_worldOffset, m_worldOffset + DefaultRegionSize, true /* inTaintTime */);
             }
         });
     }
 
+    // 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, 
+    private void UpdateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
-                            Vector3 minCoords, Vector3 maxCoords, bool inTaintTime)
     {
-        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3},inTaintTime={4}",
+        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3}",
-                            BSScene.DetailLogZero, id, minCoords, maxCoords, inTaintTime);
+                            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

OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs

@@ -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.VehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
-        TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
+        TestVehicle.VehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
-        TestVehicle.VehicleController.enableAngularVerticalAttraction = true;
+        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.VehicleActor.ForgetKnownVehicleProperties();
-            TestVehicle.VehicleController.ComputeAngularVerticalAttraction();
+            TestVehicle.VehicleActor.ComputeAngularVerticalAttraction();
-            TestVehicle.VehicleController.PushKnownChanged();
+            TestVehicle.VehicleActor.PushKnownChanged();
 
             PhysicsScene.Simulate(simulationTimeStep);
         }

OpenSim/Region/ScriptEngine/XEngine/XEngine.cs

@@ -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)