opensim/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs

/*
 * 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.Reflection;
using System.Collections.Generic;
using System.Xml;
using log4net;
using OMV = OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.PhysicsModules.SharedBase;
using OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet;

namespace OpenSim.Region.PhysicsModule.BulletS
{

    [Serializable]
    public class BSPrim : BSPhysObject
    {
        protected static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private static readonly string LogHeader = "[BULLETS PRIM]";

        // _size is what the user passed. Scale is what we pass to the physics engine with the mesh.
        private OMV.Vector3 _size;  // the multiplier for each mesh dimension as passed by the user

        private bool _grabbed;
        private bool _isSelected;
        private bool _isVolumeDetect;

        private float _mass;    // the mass of this object
        private OMV.Vector3 _acceleration;
        private int _physicsActorType;
        private bool _isPhysical;
        private bool _flying;
        private bool _setAlwaysRun;
        private bool _throttleUpdates;
        private bool _floatOnWater;
        private bool _kinematic;
        private float _buoyancy;

        private int CrossingFailures { get; set; }

        // Keep a handle to the vehicle actor so it is easy to set parameters on same.
        public const string VehicleActorName = "BasicVehicle";

        // Parameters for the hover actor
        public const string HoverActorName = "BSPrim.HoverActor";
        // Parameters for the axis lock actor
        public const String LockedAxisActorName = "BSPrim.LockedAxis";
        // Parameters for the move to target actor
        public const string MoveToTargetActorName = "BSPrim.MoveToTargetActor";
        // Parameters for the setForce and setTorque actors
        public const string SetForceActorName = "BSPrim.SetForceActor";
        public const string SetTorqueActorName = "BSPrim.SetTorqueActor";

        public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
                           OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
                : base(parent_scene, localID, primName, "BSPrim")
        {
            // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
            _physicsActorType = (int)ActorTypes.Prim;
            RawPosition = pos;
            _size = size;
            Scale = size;   // prims are the size the user wants them to be (different for BSCharactes).
            RawOrientation = rotation;
            _buoyancy = 0f;
            RawVelocity = OMV.Vector3.Zero;
            RawRotationalVelocity = OMV.Vector3.Zero;
            BaseShape = pbs;
            _isPhysical = pisPhysical;
            _isVolumeDetect = false;

            _mass = CalculateMass();

            DetailLog("{0},BSPrim.constructor,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(pbs));
            // DetailLog("{0},BSPrim.constructor,call", LocalID);
            // do the actual object creation at taint time
            PhysScene.TaintedObject(LocalID, "BSPrim.create", delegate()
            {
                // Make sure the object is being created with some sanity.
                ExtremeSanityCheck(true /* inTaintTime */);

                CreateGeomAndObject(true);

                CurrentCollisionFlags = PhysScene.PE.GetCollisionFlags(PhysBody);

                IsInitialized = true;
            });
        }

        // called when this prim is being destroyed and we should free all the resources
        public override void Destroy()
        {
            // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID);
            IsInitialized = false;

            base.Destroy();

            // Undo any vehicle properties
            this.VehicleType = (int)Vehicle.TYPE_NONE;

            PhysScene.TaintedObject(LocalID, "BSPrim.Destroy", delegate()
            {
                DetailLog("{0},BSPrim.Destroy,taint,", LocalID);
                // If there are physical body and shape, release my use of same.
                PhysScene.Shapes.DereferenceBody(PhysBody, null);
                PhysBody.Clear();
                PhysShape.Dereference(PhysScene);
                PhysShape = new BSShapeNull();
            });
        }

        // No one uses this property.
        public override bool Stopped {
            get { return false; }
        }

        public override bool IsIncomplete {
            get {
                return ShapeRebuildScheduled;
            }
        }

        // 'true' if this object's shape is in need of a rebuild and a rebuild has been queued.
        // The prim is still available but its underlying shape will change soon.
        // This is protected by a 'lock(this)'.
        public bool ShapeRebuildScheduled { get; protected set; }

        public override OMV.Vector3 Size {
            get { return _size; }
            set {
                // We presume the scale and size are the same. If scale must be changed for
                //     the physical shape, that is done when the geometry is built.
                _size = value;
                Scale = _size;
                ForceBodyShapeRebuild(false);
            }
        }

        public override PrimitiveBaseShape Shape {
            set {
                BaseShape = value;
                DetailLog("{0},BSPrim.changeShape,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(BaseShape));
                PrimAssetState = PrimAssetCondition.Unknown;
                ForceBodyShapeRebuild(false);
            }
        }
        // Cause the body and shape of the prim to be rebuilt if necessary.
        // If there are no changes required, this is quick and does not make changes to the prim.
        // If rebuilding is necessary (like changing from static to physical), that will happen.
        // The 'ShapeRebuildScheduled' tells any checker that the body/shape may change shortly.
        // The return parameter is not used by anyone.
        public override bool ForceBodyShapeRebuild(bool inTaintTime)
        {
            if (inTaintTime)
            {
                // If called in taint time, do the operation immediately
                _mass = CalculateMass();   // changing the shape changes the mass
                CreateGeomAndObject(true);
            }
            else
            {
                lock (this)
                {
                    // If a rebuild is not already in the queue
                    if (!ShapeRebuildScheduled)
                    {
                        // Remember that a rebuild is queued -- this is used to flag an incomplete object
                        ShapeRebuildScheduled = true;
                        PhysScene.TaintedObject(LocalID, "BSPrim.ForceBodyShapeRebuild", delegate()
                        {
                            _mass = CalculateMass();   // changing the shape changes the mass
                            CreateGeomAndObject(true);
                            ShapeRebuildScheduled = false;
                        });
                    }
                }
            }
            return true;
        }
        public override bool Grabbed {
            set { _grabbed = value;
            }
        }
        public override bool Selected {
            set
            {
                if (value != _isSelected)
                {
                    _isSelected = value;
                    PhysScene.TaintedObject(LocalID, "BSPrim.setSelected", delegate()
                    {
                        DetailLog("{0},BSPrim.selected,taint,selected={1}", LocalID, _isSelected);
                        SetObjectDynamic(false);
                    });
                }
            }
        }
        public override bool IsSelected
        {
            get { return _isSelected; }
        }

        public override void CrossingFailure()
        {
            CrossingFailures++;
            if (CrossingFailures > BSParam.CrossingFailuresBeforeOutOfBounds)
            {
                base.RaiseOutOfBounds(RawPosition);
            }
            else if (CrossingFailures == BSParam.CrossingFailuresBeforeOutOfBounds)
            {
                m_log.WarnFormat("{0} Too many crossing failures for {1}", LogHeader, Name);
            }
            return;
        }

        // link me to the specified parent
        public override void link(PhysicsActor obj) {
        }

        // delink me from my linkset
        public override void delink() {
        }

        // Set motion values to zero.
        // Do it to the properties so the values get set in the physics engine.
        // Push the setting of the values to the viewer.
        // Called at taint time!
        public override void ZeroMotion(bool inTaintTime)
        {
            RawVelocity = OMV.Vector3.Zero;
            _acceleration = OMV.Vector3.Zero;
            RawRotationalVelocity = OMV.Vector3.Zero;

            // Zero some other properties in the physics engine
            PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
            {
                if (PhysBody.HasPhysicalBody)
                    PhysScene.PE.ClearAllForces(PhysBody);
            });
        }
        public override void ZeroAngularMotion(bool inTaintTime)
        {
            RawRotationalVelocity = OMV.Vector3.Zero;
            // Zero some other properties in the physics engine
            PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
            {
                // DetailLog("{0},BSPrim.ZeroAngularMotion,call,rotVel={1}", LocalID, _rotationalVelocity);
                if (PhysBody.HasPhysicalBody)
                {
                    PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, RawRotationalVelocity);
                    PhysScene.PE.SetAngularVelocity(PhysBody, RawRotationalVelocity);
                }
            });
        }

        public override void LockAngularMotion(byte axislocks)
        {
            DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axislocks);

            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
            if ((axislocks & 0x02) != 0)
            {
                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X, 0f, 0f);
            }
            if ((axislocks & 0x04) != 0)
            {
                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y, 0f, 0f);
            }
            if ((axislocks & 0x08) != 0)
            {
                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z, 0f, 0f);
            }

            InitializeAxisActor();

            return;
        }

        public override OMV.Vector3 Position {
            get {
                // don't do the GetObjectPosition for root elements because this function is called a zillion times.
                // RawPosition = ForcePosition;
                return RawPosition;
            }
            set {
                // If the position must be forced into the physics engine, use ForcePosition.
                // All positions are given in world positions.
                if (RawPosition == value)
                {
                    DetailLog("{0},BSPrim.setPosition,call,positionNotChanging,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
                    return;
                }
                RawPosition = value;
                PositionSanityCheck(false);

                PhysScene.TaintedObject(LocalID, "BSPrim.setPosition", delegate()
                {
                    DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
                    ForcePosition = RawPosition;
                });
            }
        }

        // NOTE: overloaded by BSPrimDisplaced to handle offset for center-of-gravity.
        public override OMV.Vector3 ForcePosition {
            get {
                RawPosition = PhysScene.PE.GetPosition(PhysBody);
                return RawPosition;
            }
            set {
                RawPosition = value;
                if (PhysBody.HasPhysicalBody)
                {
                    PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
                    ActivateIfPhysical(false);
                }
            }
        }

        // Check that the current position is sane and, if not, modify the position to make it so.
        // Check for being below terrain and being out of bounds.
        // Returns 'true' of the position was made sane by some action.
        private bool PositionSanityCheck(bool inTaintTime)
        {
            bool ret = false;

            // We don't care where non-physical items are placed
            if (!IsPhysicallyActive)
                return ret;

            if (!PhysScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
            {
                // The physical object is out of the known/simulated area.
                // Upper levels of code will handle the transition to other areas so, for
                //     the time, we just ignore the position.
                return ret;
            }

            float terrainHeight = PhysScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
            OMV.Vector3 upForce = OMV.Vector3.Zero;
            float approxSize = Math.Max(Size.X, Math.Max(Size.Y, Size.Z));
            if ((RawPosition.Z + approxSize / 2f) < terrainHeight)
            {
                DetailLog("{0},BSPrim.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, RawPosition, terrainHeight);
                float targetHeight = terrainHeight + (Size.Z / 2f);
                // If the object is below ground it just has to be moved up because pushing will
                //     not get it through the terrain
                RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, targetHeight);
                if (inTaintTime)
                {
                    ForcePosition = RawPosition;
                }
                // If we are throwing the object around, zero its other forces
                ZeroMotion(inTaintTime);
                ret = true;
            }

            if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
            {
                float waterHeight = PhysScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
                // TODO: a floating motor so object will bob in the water
                if (Math.Abs(RawPosition.Z - waterHeight) > 0.1f)
                {
                    // Upforce proportional to the distance away from the water. Correct the error in 1 sec.
                    upForce.Z = (waterHeight - RawPosition.Z) * 1f;

                    // Apply upforce and overcome gravity.
                    OMV.Vector3 correctionForce = upForce - PhysScene.DefaultGravity;
                    DetailLog("{0},BSPrim.PositionSanityCheck,applyForce,pos={1},upForce={2},correctionForce={3}", LocalID, RawPosition, upForce, correctionForce);
                    AddForce(inTaintTime, correctionForce);
                    ret = true;
                }
            }

            return ret;
        }

        // Occasionally things will fly off and really get lost.
        // Find the wanderers and bring them back.
        // Return 'true' if some parameter need some sanity.
        private bool ExtremeSanityCheck(bool inTaintTime)
        {
            bool ret = false;

            int wayOverThere = -1000;
            int wayOutThere = 10000;
            // There have been instances of objects getting thrown way out of bounds and crashing
            //    the border crossing code.
            if (   RawPosition.X < wayOverThere || RawPosition.X > wayOutThere
                || RawPosition.Y < wayOverThere || RawPosition.X > wayOutThere
                || RawPosition.Z < wayOverThere || RawPosition.X > wayOutThere)
            {
                RawPosition = new OMV.Vector3(10, 10, 50);
                ZeroMotion(inTaintTime);
                ret = true;
            }
            if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocitySquared)
            {
                RawVelocity = Util.ClampV(RawVelocity, BSParam.MaxLinearVelocity);
                ret = true;
            }
            if (RawRotationalVelocity.LengthSquared() > BSParam.MaxAngularVelocitySquared)
            {
                RawRotationalVelocity = Util.ClampV(RawRotationalVelocity, BSParam.MaxAngularVelocity);
                ret = true;
            }

            return ret;
        }

        // Return the effective mass of the object.
            // The definition of this call is to return the mass of the prim.
            // If the simulator cares about the mass of the linkset, it will sum it itself.
        public override float Mass
        {
            get { return _mass; }
        }
        // TotalMass returns the mass of the large object the prim may be in (overridden by linkset code)
        public virtual float TotalMass
        {
            get { return _mass; }
        }
        // used when we only want this prim's mass and not the linkset thing
        public override float RawMass {
            get { return _mass; }
        }
        // Set the physical mass to the passed mass.
        // Note that this does not change _mass!
        public override void UpdatePhysicalMassProperties(float physMass, bool inWorld)
        {
            if (PhysBody.HasPhysicalBody && PhysShape.HasPhysicalShape)
            {
                if (IsStatic)
                {
                    PhysScene.PE.SetGravity(PhysBody, PhysScene.DefaultGravity);
                    Inertia = OMV.Vector3.Zero;
                    PhysScene.PE.SetMassProps(PhysBody, 0f, Inertia);
                    PhysScene.PE.UpdateInertiaTensor(PhysBody);
                }
                else
                {
                    if (inWorld)
                    {
                        // Changing interesting properties doesn't change proxy and collision cache
                        //    information. The Bullet solution is to re-add the object to the world
                        //    after parameters are changed.
                        PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
                    }

                    // The computation of mass props requires gravity to be set on the object.
                    Gravity = ComputeGravity(Buoyancy);
                    PhysScene.PE.SetGravity(PhysBody, Gravity);

                    // OMV.Vector3 currentScale = PhysScene.PE.GetLocalScaling(PhysShape.physShapeInfo);   // DEBUG DEBUG
                    // DetailLog("{0},BSPrim.UpdateMassProperties,currentScale{1},shape={2}", LocalID, currentScale, PhysShape.physShapeInfo);   // DEBUG DEBUG

                    Inertia = PhysScene.PE.CalculateLocalInertia(PhysShape.physShapeInfo, physMass);
                    PhysScene.PE.SetMassProps(PhysBody, physMass, Inertia);
                    PhysScene.PE.UpdateInertiaTensor(PhysBody);

                    DetailLog("{0},BSPrim.UpdateMassProperties,mass={1},localInertia={2},grav={3},inWorld={4}",
                                                LocalID, physMass, Inertia, Gravity, inWorld);

                    if (inWorld)
                    {
                        AddObjectToPhysicalWorld();
                    }
                }
            }
        }

        // Return what gravity should be set to this very moment
        public OMV.Vector3 ComputeGravity(float buoyancy)
        {
            OMV.Vector3 ret = PhysScene.DefaultGravity;

            if (!IsStatic)
            {
                ret *= (1f - buoyancy);
                ret *= GravModifier;
            }

            return ret;
        }

        // Is this used?
        public override OMV.Vector3 CenterOfMass
        {
            get { return RawPosition; }
        }

        // Is this used?
        public override OMV.Vector3 GeometricCenter
        {
            get { return RawPosition; }
        }

        public override OMV.Vector3 Force {
            get { return RawForce; }
            set {
                RawForce = value;
                EnableActor(RawForce != OMV.Vector3.Zero, SetForceActorName, delegate()
                {
                    return new BSActorSetForce(PhysScene, this, SetForceActorName);
                });

                // Call update so actor Refresh() is called to start things off
                PhysScene.TaintedObject(LocalID, "BSPrim.setForce", delegate()
                {
                    UpdatePhysicalParameters();
                });
            }
        }

        // Find and return a handle to the current vehicle actor.
        // Return 'null' if there is no vehicle actor.
        public BSDynamics GetVehicleActor(bool createIfNone)
        {
            BSDynamics ret = null;
            BSActor actor;
            if (PhysicalActors.TryGetActor(VehicleActorName, out actor))
            {
                ret = actor as BSDynamics;
            }
            else
            {
                if (createIfNone)
                {
                    ret = new BSDynamics(PhysScene, this, VehicleActorName);
                    PhysicalActors.Add(ret.ActorName, ret);
                }
            }
            return ret;
        }

        public override int VehicleType {
            get {
                int ret = (int)Vehicle.TYPE_NONE;
                BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
                if (vehicleActor != null)
                    ret = (int)vehicleActor.Type;
                return ret;
            }
            set {
                Vehicle type = (Vehicle)value;

                PhysScene.TaintedObject(LocalID, "setVehicleType", delegate()
                {
                    // Some vehicle scripts change vehicle type on the fly as an easy way to
                    //    change all the parameters. Like a plane changing to CAR when on the
                    //    ground. In this case, don't want to zero motion.
                    // ZeroMotion(true /* inTaintTime */);
                    if (type == Vehicle.TYPE_NONE)
                    {
                        // Vehicle type is 'none' so get rid of any actor that may have been allocated.
                        BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
                        if (vehicleActor != null)
                        {
                            PhysicalActors.RemoveAndRelease(vehicleActor.ActorName);
                        }
                    }
                    else
                    {
                        // Vehicle type is not 'none' so create an actor and set it running.
                        BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
                        if (vehicleActor != null)
                        {
                            vehicleActor.ProcessTypeChange(type);
                            ActivateIfPhysical(false);
                        }
                    }
                });
            }
        }
        public override void VehicleFloatParam(int param, float value)
        {
            PhysScene.TaintedObject(LocalID, "BSPrim.VehicleFloatParam", delegate()
            {
                BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
                if (vehicleActor != null)
                {
                    vehicleActor.ProcessFloatVehicleParam((Vehicle)param, value);
                    ActivateIfPhysical(false);
                }
            });
        }
        public override void VehicleVectorParam(int param, OMV.Vector3 value)
        {
            PhysScene.TaintedObject(LocalID, "BSPrim.VehicleVectorParam", delegate()
            {
                BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
                if (vehicleActor != null)
                {
                    vehicleActor.ProcessVectorVehicleParam((Vehicle)param, value);
                    ActivateIfPhysical(false);
                }
            });
        }
        public override void VehicleRotationParam(int param, OMV.Quaternion rotation)
        {
            PhysScene.TaintedObject(LocalID, "BSPrim.VehicleRotationParam", delegate()
            {
                BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
                if (vehicleActor != null)
                {
                    vehicleActor.ProcessRotationVehicleParam((Vehicle)param, rotation);
                    ActivateIfPhysical(false);
                }
            });
        }
        public override void VehicleFlags(int param, bool remove)
        {
            PhysScene.TaintedObject(LocalID, "BSPrim.VehicleFlags", delegate()
            {
                BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
                if (vehicleActor != null)
                {
                    vehicleActor.ProcessVehicleFlags(param, remove);
                }
            });
        }

        public override void SetVehicle(object pvdata)
        {
            PhysScene.TaintedObject(LocalID, "BSPrim.SetVehicle", delegate ()
            {
                BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
                if (vehicleActor != null && (pvdata is VehicleData) )
                {
                    VehicleData vdata = (VehicleData)pvdata;
                    // vehicleActor.ProcessSetVehicle((VehicleData)vdata);

                    vehicleActor.ProcessTypeChange(vdata.m_type);
                    vehicleActor.ProcessVehicleFlags(-1, false);
                    vehicleActor.ProcessVehicleFlags((int)vdata.m_flags, false);

                    // Linear properties
                    vehicleActor.ProcessVectorVehicleParam(Vehicle.LINEAR_MOTOR_DIRECTION, vdata.m_linearMotorDirection);
                    vehicleActor.ProcessVectorVehicleParam(Vehicle.LINEAR_FRICTION_TIMESCALE, vdata.m_linearFrictionTimescale);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE, vdata.m_linearMotorDecayTimescale);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_MOTOR_TIMESCALE, vdata.m_linearMotorTimescale);
                    vehicleActor.ProcessVectorVehicleParam(Vehicle.LINEAR_MOTOR_OFFSET, vdata.m_linearMotorOffset);

                    //Angular properties
                    vehicleActor.ProcessVectorVehicleParam(Vehicle.ANGULAR_MOTOR_DIRECTION, vdata.m_angularMotorDirection);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_MOTOR_TIMESCALE, vdata.m_angularMotorTimescale);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE, vdata.m_angularMotorDecayTimescale);
                    vehicleActor.ProcessVectorVehicleParam(Vehicle.ANGULAR_FRICTION_TIMESCALE, vdata.m_angularFrictionTimescale);

                    //Deflection properties
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_DEFLECTION_EFFICIENCY, vdata.m_angularDeflectionEfficiency);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_DEFLECTION_TIMESCALE, vdata.m_angularDeflectionTimescale);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_DEFLECTION_EFFICIENCY, vdata.m_linearDeflectionEfficiency);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_DEFLECTION_TIMESCALE, vdata.m_linearDeflectionTimescale);

                    //Banking properties
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.BANKING_EFFICIENCY, vdata.m_bankingEfficiency);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.BANKING_MIX, vdata.m_bankingMix);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.BANKING_TIMESCALE, vdata.m_bankingTimescale);

                    //Hover and Buoyancy properties
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.HOVER_HEIGHT, vdata.m_VhoverHeight);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.HOVER_EFFICIENCY, vdata.m_VhoverEfficiency);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.HOVER_TIMESCALE, vdata.m_VhoverTimescale);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.BUOYANCY, vdata.m_VehicleBuoyancy);

                    //Attractor properties
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, vdata.m_verticalAttractionEfficiency);
                    vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, vdata.m_verticalAttractionTimescale);

                    vehicleActor.ProcessRotationVehicleParam(Vehicle.REFERENCE_FRAME, vdata.m_referenceFrame);
                }
            });
        }

        // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
        public override void SetVolumeDetect(int param) {
            bool newValue = (param != 0);
            if (_isVolumeDetect != newValue)
            {
                _isVolumeDetect = newValue;
                PhysScene.TaintedObject(LocalID, "BSPrim.SetVolumeDetect", delegate()
                {
                    // DetailLog("{0},setVolumeDetect,taint,volDetect={1}", LocalID, _isVolumeDetect);
                    SetObjectDynamic(true);
                });
            }
            return;
        }
        public override bool IsVolumeDetect
        {
            get { return _isVolumeDetect; }
        }
        public override void SetMaterial(int material)
        {
            base.SetMaterial(material);
            PhysScene.TaintedObject(LocalID, "BSPrim.SetMaterial", delegate()
            {
                UpdatePhysicalParameters();
            });
        }
        public override float Friction
        {
            get { return base.Friction; }
            set
            {
                if (base.Friction != value)
                {
                    base.Friction = value;
                    PhysScene.TaintedObject(LocalID, "BSPrim.setFriction", delegate()
                    {
                        UpdatePhysicalParameters();
                    });
                }
            }
        }
        public override float Restitution
        {
            get { return base.Restitution; }
            set
            {
                if (base.Restitution != value)
                {
                    base.Restitution = value;
                    PhysScene.TaintedObject(LocalID, "BSPrim.setRestitution", delegate()
                    {
                        UpdatePhysicalParameters();
                    });
                }
            }
        }
        // The simulator/viewer keep density as 100kg/m3.
        // Remember to use BSParam.DensityScaleFactor to create the physical density.
        public override float Density
        {
            get { return base.Density; }
            set
            {
                if (base.Density != value)
                {
                    base.Density = value;
                    PhysScene.TaintedObject(LocalID, "BSPrim.setDensity", delegate()
                    {
                        UpdatePhysicalParameters();
                    });
                }
            }
        }
        public override float GravModifier
        {
            get { return base.GravModifier; }
            set
            {
                if (base.GravModifier != value)
                {
                    base.GravModifier = value;
                    PhysScene.TaintedObject(LocalID, "BSPrim.setGravityModifier", delegate()
                    {
                        UpdatePhysicalParameters();
                    });
                }
            }
        }
        public override OMV.Vector3 ForceVelocity {
            get { return RawVelocity; }
            set {
                RawVelocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
                if (PhysBody.HasPhysicalBody)
                {
                    DetailLog("{0},BSPrim.ForceVelocity,taint,vel={1}", LocalID, RawVelocity);
                    PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
                    ActivateIfPhysical(false);
                }
            }
        }
        public override OMV.Vector3 Torque {
            get { return RawTorque; }
            set {
                RawTorque = value;
                EnableActor(RawTorque != OMV.Vector3.Zero, SetTorqueActorName, delegate()
                {
                    return new BSActorSetTorque(PhysScene, this, SetTorqueActorName);
                });
                DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, RawTorque);

                // Call update so actor Refresh() is called to start things off
                PhysScene.TaintedObject(LocalID, "BSPrim.setTorque", delegate()
                {
                    UpdatePhysicalParameters();
                });
            }
        }
        public override OMV.Vector3 Acceleration {
            get { return _acceleration; }
            set { _acceleration = value; }
        }

        public override OMV.Quaternion Orientation {
            get {
                return RawOrientation;
            }
            set {
                if (RawOrientation == value)
                    return;
                RawOrientation = value;

                PhysScene.TaintedObject(LocalID, "BSPrim.setOrientation", delegate()
                {
                    ForceOrientation = RawOrientation;
                });
            }
        }
        // Go directly to Bullet to get/set the value.
        public override OMV.Quaternion ForceOrientation
        {
            get
            {
                RawOrientation = PhysScene.PE.GetOrientation(PhysBody);
                return RawOrientation;
            }
            set
            {
                RawOrientation = value;
                if (PhysBody.HasPhysicalBody)
                    PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
            }
        }
        public override int PhysicsActorType {
            get { return _physicsActorType; }
            set { _physicsActorType = value; }
        }
        public override bool IsPhysical {
            get { return _isPhysical; }
            set {
                if (_isPhysical != value)
                {
                    _isPhysical = value;
                    PhysScene.TaintedObject(LocalID, "BSPrim.setIsPhysical", delegate()
                    {
                        DetailLog("{0},setIsPhysical,taint,isPhys={1}", LocalID, _isPhysical);
                        SetObjectDynamic(true);
                        // whether phys-to-static or static-to-phys, the object is not moving.
                        ZeroMotion(true);

                    });
                }
            }
        }

        // An object is static (does not move) if selected or not physical
        public override bool IsStatic
        {
            get { return _isSelected || !IsPhysical; }
        }

        // An object is solid if it's not phantom and if it's not doing VolumeDetect
        public override bool IsSolid
        {
            get { return !IsPhantom && !_isVolumeDetect; }
        }

        // The object is moving and is actively being dynamic in the physical world
        public override bool IsPhysicallyActive
        {
            get { return !_isSelected && IsPhysical; }
        }

        // Make gravity work if the object is physical and not selected
        // Called at taint-time!!
        private void SetObjectDynamic(bool forceRebuild)
        {
            // Recreate the physical object if necessary
            CreateGeomAndObject(forceRebuild);
        }

        // Convert the simulator's physical properties into settings on BulletSim objects.
        // There are four flags we're interested in:
        //     IsStatic: Object does not move, otherwise the object has mass and moves
        //     isSolid: other objects bounce off of this object
        //     isVolumeDetect: other objects pass through but can generate collisions
        //     collisionEvents: whether this object returns collision events
        // NOTE: overloaded by BSPrimLinkable to also update linkset physical parameters.
        public virtual void UpdatePhysicalParameters()
        {
            if (!PhysBody.HasPhysicalBody)
            {
                // This would only happen if updates are called for during initialization when the body is not set up yet.
                // DetailLog("{0},BSPrim.UpdatePhysicalParameters,taint,calledWithNoPhysBody", LocalID);
                return;
            }

            // Mangling all the physical properties requires the object not be in the physical world.
            // This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found).
            PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);

            // Set up the object physicalness (does gravity and collisions move this object)
            MakeDynamic(IsStatic);

            // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters)
            PhysicalActors.Refresh();

            // Arrange for collision events if the simulator wants them
            EnableCollisions(SubscribedEvents());

            // Make solid or not (do things bounce off or pass through this object).
            MakeSolid(IsSolid);

            AddObjectToPhysicalWorld();

            // Rebuild its shape
            PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);

            DetailLog("{0},BSPrim.UpdatePhysicalParameters,taintExit,static={1},solid={2},mass={3},collide={4},cf={5:X},cType={6},body={7},shape={8}",
                                        LocalID, IsStatic, IsSolid, Mass, SubscribedEvents(),
                                        CurrentCollisionFlags, PhysBody.collisionType, PhysBody, PhysShape);
        }

        // "Making dynamic" means changing to and from static.
        // When static, gravity does not effect the object and it is fixed in space.
        // When dynamic, the object can fall and be pushed by others.
        // This is independent of its 'solidness' which controls what passes through
        //    this object and what interacts with it.
        protected virtual void MakeDynamic(bool makeStatic)
        {
            if (makeStatic)
            {
                // Become a Bullet 'static' object type
                CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
                // Stop all movement
                ZeroMotion(true);

                // Set various physical properties so other object interact properly
                PhysScene.PE.SetFriction(PhysBody, Friction);
                PhysScene.PE.SetRestitution(PhysBody, Restitution);
                PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);

                // Mass is zero which disables a bunch of physics stuff in Bullet
                UpdatePhysicalMassProperties(0f, false);
                // Set collision detection parameters
                if (BSParam.CcdMotionThreshold > 0f)
                {
                    PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
                    PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
                }

                // The activation state is 'disabled' so Bullet will not try to act on it.
                // PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_SIMULATION);
                // Start it out sleeping and physical actions could wake it up.
                PhysScene.PE.ForceActivationState(PhysBody, ActivationState.ISLAND_SLEEPING);

                // This collides like a static object
                PhysBody.collisionType = CollisionType.Static;
            }
            else
            {
                // Not a Bullet static object
                CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);

                // Set various physical properties so other object interact properly
                PhysScene.PE.SetFriction(PhysBody, Friction);
                PhysScene.PE.SetRestitution(PhysBody, Restitution);
                // DetailLog("{0},BSPrim.MakeDynamic,frict={1},rest={2}", LocalID, Friction, Restitution);

                // per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382
                // Since this can be called multiple times, only zero forces when becoming physical
                // PhysicsScene.PE.ClearAllForces(BSBody);

                // For good measure, make sure the transform is set through to the motion state
                ForcePosition = RawPosition;
                ForceVelocity = RawVelocity;
                ForceRotationalVelocity = RawRotationalVelocity;

                // A dynamic object has mass
                UpdatePhysicalMassProperties(RawMass, false);

                // Set collision detection parameters
                if (BSParam.CcdMotionThreshold > 0f)
                {
                    PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
                    PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
                }

                // Various values for simulation limits
                PhysScene.PE.SetDamping(PhysBody, BSParam.LinearDamping, BSParam.AngularDamping);

                // Whether to allow deactivation of this body when it is at rest.
                if (this.DisableDeactivation)
                {
                    // The user has asked that the physical object never be deactivated.
                    PhysScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_DEACTIVATION);
                    // DetailLog("{0},BSPrim.MakeDynamic,set ActivationState=DISABLE_DEACTIVATION", LocalID);
                }
                else
                {
                    // Force activation of the object so Bullet will act on it.
                    // Must do the ForceActivationState() to overcome the DISABLE_SIMULATION from static objects.
                    PhysScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
                    // DetailLog("{0},BSPrim.MakeDynamic,set ActivationState=ACTIVE_TAG", LocalID);
                }

                PhysScene.PE.SetSleepingThresholds(PhysBody, BSParam.LinearSleepingThreshold, BSParam.AngularSleepingThreshold);
                PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);

                // This collides like an object.
                PhysBody.collisionType = CollisionType.Dynamic;
            }
        }

        // "Making solid" means that other object will not pass through this object.
        // To make transparent, we create a Bullet ghost object.
        // Note: This expects to be called from the UpdatePhysicalParameters() routine as
        //     the functions after this one set up the state of a possibly newly created collision body.
        private void MakeSolid(bool makeSolid)
        {
            CollisionObjectTypes bodyType = (CollisionObjectTypes)PhysScene.PE.GetBodyType(PhysBody);
            if (makeSolid)
            {
                // Verify the previous code created the correct shape for this type of thing.
                if ((bodyType & CollisionObjectTypes.CO_RIGID_BODY) == 0)
                {
                    m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType);
                }
                CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
            }
            else
            {
                if ((bodyType & CollisionObjectTypes.CO_GHOST_OBJECT) == 0)
                {
                    m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType);
                }
                CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);

                // Change collision info from a static object to a ghosty collision object
                PhysBody.collisionType = CollisionType.VolumeDetect;
            }
        }

        // Turn on or off the flag controlling whether collision events are returned to the simulator.
        private void EnableCollisions(bool wantsCollisionEvents)
        {
            if (wantsCollisionEvents)
            {
                CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
            }
            else
            {
                CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
            }
        }

        // Add me to the physical world.
        // Object MUST NOT already be in the world.
        // This routine exists because some assorted properties get mangled by adding to the world.
        internal void AddObjectToPhysicalWorld()
        {
            if (PhysBody.HasPhysicalBody)
            {
                PhysScene.PE.AddObjectToWorld(PhysScene.World, PhysBody);
            }
            else
            {
                m_log.ErrorFormat("{0} Attempt to add physical object without body. id={1}", LogHeader, LocalID);
                DetailLog("{0},BSPrim.AddObjectToPhysicalWorld,addObjectWithoutBody,cType={1}", LocalID, PhysBody.collisionType);
            }
        }

        // prims don't fly
        public override bool Flying {
            get { return _flying; }
            set {
                _flying = value;
            }
        }
        public override bool SetAlwaysRun {
            get { return _setAlwaysRun; }
            set { _setAlwaysRun = value; }
        }
        public override bool ThrottleUpdates {
            get { return _throttleUpdates; }
            set { _throttleUpdates = value; }
        }
        public bool IsPhantom {
            get {
                // SceneObjectPart removes phantom objects from the physics scene
                // so, although we could implement touching and such, we never
                // are invoked as a phantom object
                return false;
            }
        }
        public override bool FloatOnWater {
            set {
                _floatOnWater = value;
                PhysScene.TaintedObject(LocalID, "BSPrim.setFloatOnWater", delegate()
                {
                    if (_floatOnWater)
                        CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
                    else
                        CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
                });
            }
        }
        public override bool Kinematic {
            get { return _kinematic; }
            set { _kinematic = value;
                // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic);
            }
        }
        public override float Buoyancy {
            get { return _buoyancy; }
            set {
                _buoyancy = value;
                PhysScene.TaintedObject(LocalID, "BSPrim.setBuoyancy", delegate()
                {
                    ForceBuoyancy = _buoyancy;
                });
            }
        }
        public override float ForceBuoyancy {
            get { return _buoyancy; }
            set {
                _buoyancy = value;
                // DetailLog("{0},BSPrim.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
                // Force the recalculation of the various inertia,etc variables in the object
                UpdatePhysicalMassProperties(RawMass, true);
                DetailLog("{0},BSPrim.ForceBuoyancy,buoy={1},mass={2},grav={3}", LocalID, _buoyancy, RawMass, Gravity);
                ActivateIfPhysical(false);
            }
        }

        public override bool PIDActive
        {
            get
            {
                return MoveToTargetActive;
            }

            set
            {
                MoveToTargetActive = value;

                EnableActor(MoveToTargetActive, MoveToTargetActorName, delegate()
                {
                    return new BSActorMoveToTarget(PhysScene, this, MoveToTargetActorName);
                });

                // Call update so actor Refresh() is called to start things off
                PhysScene.TaintedObject(LocalID, "BSPrim.PIDActive", delegate()
                {
                    UpdatePhysicalParameters();
                });
            }
        }

        public override OMV.Vector3 PIDTarget
        {
            set
            {
                base.PIDTarget = value;
                BSActor actor;
                if (PhysicalActors.TryGetActor(MoveToTargetActorName, out actor))
                {
                    // if the actor exists, tell it to refresh its values.
                    actor.Refresh();
                }

            }
        }
        // Used for llSetHoverHeight and maybe vehicle height
        // Hover Height will override MoveTo target's Z
        public override bool PIDHoverActive {
            get
            {
            return base.HoverActive;
            }
            set {
                base.HoverActive = value;
                EnableActor(HoverActive, HoverActorName, delegate()
                {
                    return new BSActorHover(PhysScene, this, HoverActorName);
                });

                // Call update so actor Refresh() is called to start things off
                PhysScene.TaintedObject(LocalID, "BSPrim.PIDHoverActive", delegate()
                {
                    UpdatePhysicalParameters();
                });
            }
        }

        public override void AvatarJump(float forceZ) { }

        public override void AddForce(OMV.Vector3 force, bool pushforce) {
            // Per documentation, max force is limited.
            OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);

            // Push forces seem to be scaled differently (follow pattern in ubODE)
            if (!pushforce) {
                // Since this force is being applied in only one step, make this a force per second.
                addForce /= PhysScene.LastTimeStep;
            }

            AddForce(false /* inTaintTime */, addForce);
        }

        // Applying a force just adds this to the total force on the object.
        // This added force will only last the next simulation tick.
        public override void AddForce(bool inTaintTime, OMV.Vector3 force) {
            // for an object, doesn't matter if force is a pushforce or not
            if (IsPhysicallyActive)
            {
                if (force.IsFinite())
                {
                    // DetailLog("{0},BSPrim.addForce,call,force={1}", LocalID, addForce);

                    OMV.Vector3 addForce = force;
                    PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddForce", delegate()
                    {
                        // Bullet adds this central force to the total force for this tick.
                        // Deep down in Bullet:
                        //      linearVelocity += totalForce / mass * timeStep;
                        DetailLog("{0},BSPrim.addForce,taint,force={1}", LocalID, addForce);
                        if (PhysBody.HasPhysicalBody)
                        {
                            PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
                            ActivateIfPhysical(false);
                        }
                    });
                }
                else
                {
                    m_log.WarnFormat("{0}: AddForce: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
                    return;
                }
            }
        }

        public void AddForceImpulse(OMV.Vector3 impulse, bool pushforce, bool inTaintTime) {
            // for an object, doesn't matter if force is a pushforce or not
            if (!IsPhysicallyActive)
            {
                if (impulse.IsFinite())
                {
                    OMV.Vector3 addImpulse = Util.ClampV(impulse, BSParam.MaxAddForceMagnitude);
                    // DetailLog("{0},BSPrim.addForceImpulse,call,impulse={1}", LocalID, impulse);

                    PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddImpulse", delegate()
                    {
                        // Bullet adds this impulse immediately to the velocity
                        DetailLog("{0},BSPrim.addForceImpulse,taint,impulseforce={1}", LocalID, addImpulse);
                        if (PhysBody.HasPhysicalBody)
                        {
                            PhysScene.PE.ApplyCentralImpulse(PhysBody, addImpulse);
                            ActivateIfPhysical(false);
                        }
                    });
                }
                else
                {
                    m_log.WarnFormat("{0}: AddForceImpulse: Got a NaN impulse applied to a prim. LocalID={1}", LogHeader, LocalID);
                    return;
                }
            }
        }

        // BSPhysObject.AddAngularForce()
        public override void AddAngularForce(bool inTaintTime, OMV.Vector3 force)
        {
            if (force.IsFinite())
            {
                OMV.Vector3 angForce = force;
                PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddAngularForce", delegate()
                {
                    if (PhysBody.HasPhysicalBody)
                    {
                        DetailLog("{0},BSPrim.AddAngularForce,taint,angForce={1}", LocalID, angForce);
                        PhysScene.PE.ApplyTorque(PhysBody, angForce);
                        ActivateIfPhysical(false);
                    }
                });
            }
            else
            {
                m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
                return;
            }
        }

        // A torque impulse.
        // ApplyTorqueImpulse adds torque directly to the angularVelocity.
        // AddAngularForce accumulates the force and applied it to the angular velocity all at once.
        // Computed as: angularVelocity += impulse * inertia;
        public void ApplyTorqueImpulse(OMV.Vector3 impulse, bool inTaintTime)
        {
            OMV.Vector3 applyImpulse = impulse;
            PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ApplyTorqueImpulse", delegate()
            {
                if (PhysBody.HasPhysicalBody)
                {
                    PhysScene.PE.ApplyTorqueImpulse(PhysBody, applyImpulse);
                    ActivateIfPhysical(false);
                }
            });
        }

        #region Mass Calculation

        private float CalculateMass()
        {
            float volume = _size.X * _size.Y * _size.Z; // default
            float tmp;

            float returnMass = 0;
            float hollowAmount = (float)BaseShape.ProfileHollow * 2.0e-5f;
            float hollowVolume = hollowAmount * hollowAmount;

            switch (BaseShape.ProfileShape)
            {
                case ProfileShape.Square:
                    // default box

                    if (BaseShape.PathCurve == (byte)Extrusion.Straight)
                        {
                        if (hollowAmount > 0.0)
                            {
                            switch (BaseShape.HollowShape)
                                {
                                case HollowShape.Square:
                                case HollowShape.Same:
                                    break;

                                case HollowShape.Circle:

                                    hollowVolume *= 0.78539816339f;
                                    break;

                                case HollowShape.Triangle:

                                    hollowVolume *= (0.5f * .5f);
                                    break;

                                default:
                                    hollowVolume = 0;
                                    break;
                                }
                            volume *= (1.0f - hollowVolume);
                            }
                        }

                    else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
                        {
                        //a tube

                        volume *= 0.78539816339e-2f * (float)(200 - BaseShape.PathScaleX);
                        tmp= 1.0f -2.0e-2f * (float)(200 - BaseShape.PathScaleY);
                        volume -= volume*tmp*tmp;

                        if (hollowAmount > 0.0)
                            {
                            hollowVolume *= hollowAmount;

                            switch (BaseShape.HollowShape)
                                {
                                case HollowShape.Square:
                                case HollowShape.Same:
                                    break;

                                case HollowShape.Circle:
                                    hollowVolume *= 0.78539816339f;
                                    break;

                                case HollowShape.Triangle:
                                    hollowVolume *= 0.5f * 0.5f;
                                    break;
                                default:
                                    hollowVolume = 0;
                                    break;
                                }
                            volume *= (1.0f - hollowVolume);
                            }
                        }

                    break;

                case ProfileShape.Circle:

                    if (BaseShape.PathCurve == (byte)Extrusion.Straight)
                        {
                        volume *= 0.78539816339f; // elipse base

                        if (hollowAmount > 0.0)
                            {
                            switch (BaseShape.HollowShape)
                                {
                                case HollowShape.Same:
                                case HollowShape.Circle:
                                    break;

                                case HollowShape.Square:
                                    hollowVolume *= 0.5f * 2.5984480504799f;
                                    break;

                                case HollowShape.Triangle:
                                    hollowVolume *= .5f * 1.27323954473516f;
                                    break;

                                default:
                                    hollowVolume = 0;
                                    break;
                                }
                            volume *= (1.0f - hollowVolume);
                            }
                        }

                    else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
                        {
                        volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - BaseShape.PathScaleX);
                        tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY);
                        volume *= (1.0f - tmp * tmp);

                        if (hollowAmount > 0.0)
                            {

                            // calculate the hollow volume by it's shape compared to the prim shape
                            hollowVolume *= hollowAmount;

                            switch (BaseShape.HollowShape)
                                {
                                case HollowShape.Same:
                                case HollowShape.Circle:
                                    break;

                                case HollowShape.Square:
                                    hollowVolume *= 0.5f * 2.5984480504799f;
                                    break;

                                case HollowShape.Triangle:
                                    hollowVolume *= .5f * 1.27323954473516f;
                                    break;

                                default:
                                    hollowVolume = 0;
                                    break;
                                }
                            volume *= (1.0f - hollowVolume);
                            }
                        }
                    break;

                case ProfileShape.HalfCircle:
                    if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
                    {
                    volume *= 0.52359877559829887307710723054658f;
                    }
                    break;

                case ProfileShape.EquilateralTriangle:

                    if (BaseShape.PathCurve == (byte)Extrusion.Straight)
                        {
                        volume *= 0.32475953f;

                        if (hollowAmount > 0.0)
                            {

                            // calculate the hollow volume by it's shape compared to the prim shape
                            switch (BaseShape.HollowShape)
                                {
                                case HollowShape.Same:
                                case HollowShape.Triangle:
                                    hollowVolume *= .25f;
                                    break;

                                case HollowShape.Square:
                                    hollowVolume *= 0.499849f * 3.07920140172638f;
                                    break;

                                case HollowShape.Circle:
                                    // Hollow shape is a perfect cyllinder in respect to the cube's scale
                                    // Cyllinder hollow volume calculation

                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
                                    break;

                                default:
                                    hollowVolume = 0;
                                    break;
                                }
                            volume *= (1.0f - hollowVolume);
                            }
                        }
                    else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
                        {
                        volume *= 0.32475953f;
                        volume *= 0.01f * (float)(200 - BaseShape.PathScaleX);
                        tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY);
                        volume *= (1.0f - tmp * tmp);

                        if (hollowAmount > 0.0)
                            {

                            hollowVolume *= hollowAmount;

                            switch (BaseShape.HollowShape)
                                {
                                case HollowShape.Same:
                                case HollowShape.Triangle:
                                    hollowVolume *= .25f;
                                    break;

                                case HollowShape.Square:
                                    hollowVolume *= 0.499849f * 3.07920140172638f;
                                    break;

                                case HollowShape.Circle:

                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
                                    break;

                                default:
                                    hollowVolume = 0;
                                    break;
                                }
                            volume *= (1.0f - hollowVolume);
                            }
                        }
                        break;

                default:
                    break;
                }



            float taperX1;
            float taperY1;
            float taperX;
            float taperY;
            float pathBegin;
            float pathEnd;
            float profileBegin;
            float profileEnd;

            if (BaseShape.PathCurve == (byte)Extrusion.Straight || BaseShape.PathCurve == (byte)Extrusion.Flexible)
                {
                taperX1 = BaseShape.PathScaleX * 0.01f;
                if (taperX1 > 1.0f)
                    taperX1 = 2.0f - taperX1;
                taperX = 1.0f - taperX1;

                taperY1 = BaseShape.PathScaleY * 0.01f;
                if (taperY1 > 1.0f)
                    taperY1 = 2.0f - taperY1;
                taperY = 1.0f - taperY1;
                }
            else
                {
                taperX = BaseShape.PathTaperX * 0.01f;
                if (taperX < 0.0f)
                    taperX = -taperX;
                taperX1 = 1.0f - taperX;

                taperY = BaseShape.PathTaperY * 0.01f;
                if (taperY < 0.0f)
                    taperY = -taperY;
                taperY1 = 1.0f - taperY;

                }


            volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);

            pathBegin = (float)BaseShape.PathBegin * 2.0e-5f;
            pathEnd = 1.0f - (float)BaseShape.PathEnd * 2.0e-5f;
            volume *= (pathEnd - pathBegin);

            // this is crude aproximation
            profileBegin = (float)BaseShape.ProfileBegin * 2.0e-5f;
            profileEnd = 1.0f - (float)BaseShape.ProfileEnd * 2.0e-5f;
            volume *= (profileEnd - profileBegin);

            returnMass = Density * BSParam.DensityScaleFactor * volume;

            returnMass = Math.Clamp(returnMass, BSParam.MinimumObjectMass, BSParam.MaximumObjectMass);
            // DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
            DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3},pathB={4},pathE={5},profB={6},profE={7},siz={8}",
                                LocalID, Density, volume, returnMass, pathBegin, pathEnd, profileBegin, profileEnd, _size);

            return returnMass;
        }// end CalculateMass
        #endregion Mass Calculation

        // Rebuild the geometry and object.
        // This is called when the shape changes so we need to recreate the mesh/hull.
        // Called at taint-time!!!
        public void CreateGeomAndObject(bool forceRebuild)
        {
            // Create the correct physical representation for this type of object.
            // Updates base.PhysBody and base.PhysShape with the new information.
            // Ignore 'forceRebuild'. 'GetBodyAndShape' makes the right choices and changes of necessary.
            PhysScene.Shapes.GetBodyAndShape(false /*forceRebuild */, PhysScene.World, this, delegate(BulletBody pBody, BulletShape pShape)
            {
                // Called if the current prim body is about to be destroyed.
                // Remove all the physical dependencies on the old body.
                // (Maybe someday make the changing of BSShape an event to be subscribed to by BSLinkset, ...)
                // Note: this virtual function is overloaded by BSPrimLinkable to remove linkset constraints.
                RemoveDependencies();
            });

            // Make sure the properties are set on the new object
            UpdatePhysicalParameters();
            return;
        }

        // Called at taint-time
        protected virtual void RemoveDependencies()
        {
            PhysicalActors.RemoveDependencies();
        }

        #region Extension
        public override object Extension(string pFunct, params object[] pParams)
        {
            DetailLog("{0} BSPrim.Extension,op={1}", LocalID, pFunct);
            object ret = null;
            switch (pFunct)
            {
                case ExtendedPhysics.PhysFunctAxisLockLimits:
                    ret = SetAxisLockLimitsExtension(pParams);
                    break;
                case ExtendedPhysics.PhysFunctDisableDeactivation:
                    ret = DisableDeactivationExtension(pParams);
                    break;
                default:
                    ret = base.Extension(pFunct, pParams);
                    break;
            }
            return ret;
        }

        private void InitializeAxisActor()
        {
            EnableActor(LockedAngularAxis != LockedAxisFree || LockedLinearAxis != LockedAxisFree,
                                        LockedAxisActorName, delegate()
            {
                return new BSActorLockAxis(PhysScene, this, LockedAxisActorName);
            });

            // Update parameters so the new actor's Refresh() action is called at the right time.
            PhysScene.TaintedObject(LocalID, "BSPrim.LockAxis", delegate()
            {
                UpdatePhysicalParameters();
            });
        }

        // Passed an array of an array of parameters, set the axis locking.
        // This expects an int (PHYS_AXIS_*) followed by none or two limit floats
        //    followed by another int and floats, etc.
        private object SetAxisLockLimitsExtension(object[] pParams)
        {
            DetailLog("{0} SetAxisLockLimitsExtension. parmlen={1}", LocalID, pParams.GetLength(0));
            object ret = null;
            try
            {
                int index = 2;
                while (index < pParams.GetLength(0))
                {
                    var funct = PassedParam<int>(pParams, index, 1);
                    DetailLog("{0} SetAxisLockLimitsExtension. op={1}, index={2}", LocalID, funct, index);
                    switch (funct)
                    {
                        // Those that take no parameters
                        case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_X:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Y:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Z:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y:
                        case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_X:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Y:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Z:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_X:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Y:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Z:
                        case ExtendedPhysics.PHYS_AXIS_UNLOCK:
                            ApplyAxisLimits((int)funct, 0f, 0f);
                            index += 1;
                            break;
                        // Those that take two parameters (the limits)
                        case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_X:
                        case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Y:
                        case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Z:
                        case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_X:
                        case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Y:
                        case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Z:
                            var low = PassedParam<float>(pParams, index + 1, 0f);
                            var high = PassedParam<float>(pParams, index + 2, 0f);
                            ApplyAxisLimits((int)funct, low, high);
                            index += 3;
                            break;
                        default:
                            m_log.WarnFormat("{0} SetSxisLockLimitsExtension. Unknown op={1}", LogHeader, funct);
                            index += 1;
                            break;
                    }
                }
                InitializeAxisActor();
                ret = (object)index;
            }
            catch (Exception e)
            {
                m_log.WarnFormat("{0} SetSxisLockLimitsExtension exception in object {1}: {2}", LogHeader, this.Name, e);
                ret = null;
            }
            return ret;    // not implemented yet
        }
        private object DisableDeactivationExtension(object[] pParams)
        {
            object ret = null;
            try
            {
                var disable = PassedParam<int>(pParams, 2, 0);
                DetailLog("{0} DisableDeactivationExtension. disable={1}", LocalID, disable);
                this.DisableDeactivation = (disable != 0);
                ret = (object)1;

                // Update parameters so the prim is rebuilt with the new settings
                PhysScene.TaintedObject(LocalID, "BSPrim.DisableDeactivationExtension", () => { UpdatePhysicalParameters(); });
            }
            catch (Exception e)
            {
                m_log.WarnFormat("{0} DisableDeactivationExtension exception in object {1}: {2}", LogHeader, this.Name, e);
                ret = null;
            }
            return ret;    // not implemented yet
        }

        // Get the passed parameter if it exists and is of the right type.
        // This returns the default value if the parameter is not present or is the wrong type.
        private T PassedParam<T>(object[] pParams, int index, T defaultValue)
        {
            if (pParams.GetLength(0) > index)
            {
                if (pParams[index] is T)
                {
                    return (T)pParams[index];
                }
            }
            return defaultValue;
        }

        // Set the locking parameters.
        // If an axis is locked, the limits for the axis are set to zero,
        // If the axis is being constrained, the high and low value are passed and set.
        // When done here, LockedXXXAxis flags are set and LockedXXXAxixLow/High are set to the range.
        protected void ApplyAxisLimits(int funct, float low, float high)
        {
            DetailLog("{0} ApplyAxisLimits. op={1}, low={2}, high={3}", LocalID, funct, low, high);
            float linearMax = 23000f;
            float angularMax = (float)Math.PI;

            switch (funct)
            {
                case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR:
                    this.LockedLinearAxis = new OMV.Vector3(LockedAxis, LockedAxis, LockedAxis);
                    this.LockedLinearAxisLow = OMV.Vector3.Zero;
                    this.LockedLinearAxisHigh = OMV.Vector3.Zero;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_X:
                    this.LockedLinearAxis.X = LockedAxis;
                    this.LockedLinearAxisLow.X = 0f;
                    this.LockedLinearAxisHigh.X = 0f;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_X:
                    this.LockedLinearAxis.X = LockedAxis;
                    this.LockedLinearAxisLow.X = OMV.Utils.Clamp(low, -linearMax, linearMax);
                    this.LockedLinearAxisHigh.X = OMV.Utils.Clamp(high, -linearMax, linearMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Y:
                    this.LockedLinearAxis.Y = LockedAxis;
                    this.LockedLinearAxisLow.Y = 0f;
                    this.LockedLinearAxisHigh.Y = 0f;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Y:
                    this.LockedLinearAxis.Y = LockedAxis;
                    this.LockedLinearAxisLow.Y = OMV.Utils.Clamp(low, -linearMax, linearMax);
                    this.LockedLinearAxisHigh.Y = OMV.Utils.Clamp(high, -linearMax, linearMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Z:
                    this.LockedLinearAxis.Z = LockedAxis;
                    this.LockedLinearAxisLow.Z = 0f;
                    this.LockedLinearAxisHigh.Z = 0f;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Z:
                    this.LockedLinearAxis.Z = LockedAxis;
                    this.LockedLinearAxisLow.Z = OMV.Utils.Clamp(low, -linearMax, linearMax);
                    this.LockedLinearAxisHigh.Z = OMV.Utils.Clamp(high, -linearMax, linearMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR:
                    this.LockedAngularAxis = new OMV.Vector3(LockedAxis, LockedAxis, LockedAxis);
                    this.LockedAngularAxisLow = OMV.Vector3.Zero;
                    this.LockedAngularAxisHigh = OMV.Vector3.Zero;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X:
                    this.LockedAngularAxis.X = LockedAxis;
                    this.LockedAngularAxisLow.X = 0;
                    this.LockedAngularAxisHigh.X = 0;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_X:
                    this.LockedAngularAxis.X = LockedAxis;
                    this.LockedAngularAxisLow.X = OMV.Utils.Clamp(low, -angularMax, angularMax);
                    this.LockedAngularAxisHigh.X = OMV.Utils.Clamp(high, -angularMax, angularMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y:
                    this.LockedAngularAxis.Y = LockedAxis;
                    this.LockedAngularAxisLow.Y = 0;
                    this.LockedAngularAxisHigh.Y = 0;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Y:
                    this.LockedAngularAxis.Y = LockedAxis;
                    this.LockedAngularAxisLow.Y = OMV.Utils.Clamp(low, -angularMax, angularMax);
                    this.LockedAngularAxisHigh.Y = OMV.Utils.Clamp(high, -angularMax, angularMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z:
                    this.LockedAngularAxis.Z = LockedAxis;
                    this.LockedAngularAxisLow.Z = 0;
                    this.LockedAngularAxisHigh.Z = 0;
                    break;
                case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Z:
                    this.LockedAngularAxis.Z = LockedAxis;
                    this.LockedAngularAxisLow.Z = OMV.Utils.Clamp(low, -angularMax, angularMax);
                    this.LockedAngularAxisHigh.Z = OMV.Utils.Clamp(high, -angularMax, angularMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR:
                    this.LockedLinearAxis = LockedAxisFree;
                    this.LockedLinearAxisLow = new OMV.Vector3(-linearMax, -linearMax, -linearMax);
                    this.LockedLinearAxisHigh = new OMV.Vector3(linearMax, linearMax, linearMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_X:
                    this.LockedLinearAxis.X = FreeAxis;
                    this.LockedLinearAxisLow.X = -linearMax;
                    this.LockedLinearAxisHigh.X = linearMax;
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Y:
                    this.LockedLinearAxis.Y = FreeAxis;
                    this.LockedLinearAxisLow.Y = -linearMax;
                    this.LockedLinearAxisHigh.Y = linearMax;
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Z:
                    this.LockedLinearAxis.Z = FreeAxis;
                    this.LockedLinearAxisLow.Z = -linearMax;
                    this.LockedLinearAxisHigh.Z = linearMax;
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR:
                    this.LockedAngularAxis = LockedAxisFree;
                    this.LockedAngularAxisLow = new OMV.Vector3(-angularMax, -angularMax, -angularMax);
                    this.LockedAngularAxisHigh = new OMV.Vector3(angularMax, angularMax, angularMax);
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_X:
                    this.LockedAngularAxis.X = FreeAxis;
                    this.LockedAngularAxisLow.X = -angularMax;
                    this.LockedAngularAxisHigh.X = angularMax;
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Y:
                    this.LockedAngularAxis.Y = FreeAxis;
                    this.LockedAngularAxisLow.Y = -angularMax;
                    this.LockedAngularAxisHigh.Y = angularMax;
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Z:
                    this.LockedAngularAxis.Z = FreeAxis;
                    this.LockedAngularAxisLow.Z = -angularMax;
                    this.LockedAngularAxisHigh.Z = angularMax;
                    break;
                case ExtendedPhysics.PHYS_AXIS_UNLOCK:
                    ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR, 0f, 0f);
                    ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
                    break;
                default:
                    break;
            }
            return;
        }
        #endregion  // Extension

        // The physics engine says that properties have updated. Update same and inform
        // the world that things have changed.
        // NOTE: BSPrim.UpdateProperties is overloaded by BSPrimLinkable which modifies updates from root and children prims.
        // NOTE: BSPrim.UpdateProperties is overloaded by BSPrimDisplaced which handles mapping physical position to simulator position.
        public override void UpdateProperties(EntityProperties entprop)
        {
            // Let anyone (like the actors) modify the updated properties before they are pushed into the object and the simulator.
            TriggerPreUpdatePropertyAction(ref entprop);

            // 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
            RawPosition = entprop.Position;
            RawOrientation = entprop.Rotation;
            // DEBUG DEBUG DEBUG -- smooth velocity changes a bit. The simulator seems to be
            //    very sensitive to velocity changes.
            if (entprop.Velocity == OMV.Vector3.Zero || !entprop.Velocity.ApproxEquals(RawVelocity, BSParam.UpdateVelocityChangeThreshold))
                RawVelocity = entprop.Velocity;
            _acceleration = entprop.Acceleration;
            RawRotationalVelocity = entprop.RotationalVelocity;

            // DetailLog("{0},BSPrim.UpdateProperties,afterAssign,entprop={1}", LocalID, entprop);   // DEBUG DEBUG

            // The sanity check can change the velocity and/or position.
            if (PositionSanityCheck(true /* inTaintTime */ ))
            {
                entprop.Position = RawPosition;
                entprop.Velocity = RawVelocity;
                entprop.RotationalVelocity = RawRotationalVelocity;
                entprop.Acceleration = _acceleration;
            }

            OMV.Vector3 direction = OMV.Vector3.UnitX * RawOrientation;   // DEBUG DEBUG DEBUG
            DetailLog("{0},BSPrim.UpdateProperties,call,entProp={1},dir={2}", LocalID, entprop, direction);

            // remember the current and last set values
            LastEntityProperties = CurrentEntityProperties;
            CurrentEntityProperties = entprop;

            PhysScene.PostUpdate(this);
        }
    }
}