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

namespace OpenSim.Region.PhysicsModule.BulletS
{
    public sealed class BSCharacter : BSPhysObject
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private static readonly string LogHeader = "[BULLETS CHAR]";

        // private bool _stopped;
        private bool _grabbed;
        private bool _selected;
        private float _mass;
        private float _avatarVolume;
        private float _collisionScore;
        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 OMV.Vector3 _size;
        private float _footOffset;

        private BSActorAvatarMove m_moveActor;
        private const string AvatarMoveActorName = "BSCharacter.AvatarMove";

        private OMV.Vector3 _PIDTarget;
        private float _PIDTau;
    
    //        public override OMV.Vector3 RawVelocity
    //        { get { return base.RawVelocity; }
    //            set {
    //                if (value != base.RawVelocity)
    //                    Util.PrintCallStack();
    //                Console.WriteLine("Set rawvel to {0}", value);
    //                base.RawVelocity = value; }
    //        }
    
        // Avatars are always complete (in the physics engine sense)
        public override bool IsIncomplete { get { return false; } }

        public BSCharacter(
                uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 vel, OMV.Vector3 size, float footOffset, bool isFlying)
    
                : base(parent_scene, localID, avName, "BSCharacter")
        {
            _physicsActorType = (int)ActorTypes.Agent;
            RawPosition = pos;
    
            _flying = isFlying;
            RawOrientation = OMV.Quaternion.Identity;
            RawVelocity = vel;
            _buoyancy = ComputeBuoyancyFromFlying(isFlying);
            Friction = BSParam.AvatarStandingFriction;
            Density = BSParam.AvatarDensity;
            _isPhysical = true;
    
            _footOffset = footOffset;
            // Adjustments for zero X and Y made in Size()
            // This also computes avatar scale, volume, and mass
            SetAvatarSize(size, footOffset, true /* initializing */);
    
            DetailLog(
                "{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5},pos={6},vel={7}",
                LocalID, Size, Scale, Density, _avatarVolume, RawMass, pos, vel);
    
            // do actual creation in taint time
            PhysScene.TaintedObject(LocalID, "BSCharacter.create", delegate()
            {
                DetailLog("{0},BSCharacter.create,taint", LocalID);
    
                // New body and shape into PhysBody and PhysShape
                PhysScene.Shapes.GetBodyAndShape(true, PhysScene.World, this);
    
                // The avatar's movement is controlled by this motor that speeds up and slows down
                //    the avatar seeking to reach the motor's target speed.
                // This motor runs as a prestep action for the avatar so it will keep the avatar
                //    standing as well as moving. Destruction of the avatar will destroy the pre-step action.
                m_moveActor = new BSActorAvatarMove(PhysScene, this, AvatarMoveActorName);
                PhysicalActors.Add(AvatarMoveActorName, m_moveActor);
    
                SetPhysicalProperties();
    
                IsInitialized = true;
            });
            return;
        }

        // called when this character is being destroyed and the resources should be released
        public override void Destroy()
        {
            IsInitialized = false;
    
            base.Destroy();
    
            DetailLog("{0},BSCharacter.Destroy", LocalID);
            PhysScene.TaintedObject(LocalID, "BSCharacter.destroy", delegate()
            {
                PhysScene.Shapes.DereferenceBody(PhysBody, null /* bodyCallback */);
                PhysBody.Clear();
                PhysShape.Dereference(PhysScene);
                PhysShape = new BSShapeNull();
            });
        }

        private void SetPhysicalProperties()
        {
            PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
    
            ForcePosition = RawPosition;
    
            // Set the velocity
            m_moveActor?.SetVelocityAndTarget(RawVelocity, RawVelocity, false);
    
            ForceVelocity = RawVelocity;
            TargetVelocity = RawVelocity;
    
            // This will enable or disable the flying buoyancy of the avatar.
            // Needs to be reset especially when an avatar is recreated after crossing a region boundry.
            Flying = _flying;
    
            PhysScene.PE.SetRestitution(PhysBody, BSParam.AvatarRestitution);
            PhysScene.PE.SetMargin(PhysShape.physShapeInfo, PhysScene.Params.collisionMargin);
            PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
            PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
            if (BSParam.CcdMotionThreshold > 0f)
            {
                PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
                PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
            }
    
            UpdatePhysicalMassProperties(RawMass, false);
    
            // Make so capsule does not fall over
            PhysScene.PE.SetAngularFactorV(PhysBody, OMV.Vector3.Zero);
    
            // The avatar mover sets some parameters.
            PhysicalActors.Refresh();
    
            PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_CHARACTER_OBJECT);
    
            PhysScene.PE.AddObjectToWorld(PhysScene.World, PhysBody);
    
            // PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
            PhysScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_DEACTIVATION);
            PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);
    
            // Do this after the object has been added to the world
            if (BSParam.AvatarToAvatarCollisionsByDefault)
                PhysBody.collisionType = CollisionType.Avatar;
            else
                PhysBody.collisionType = CollisionType.PhantomToOthersAvatar;
    
            PhysBody.ApplyCollisionMask(PhysScene);
        }

        public override void RequestPhysicsterseUpdate()
        {
            base.RequestPhysicsterseUpdate();
        }

        // No one calls this method so I don't know what it could possibly mean
        public override bool Stopped { get { return false; } }
    
        public override OMV.Vector3 Size {
            get
            {
                return _size;
            }
    
            set {
                setAvatarSize(value, _footOffset);
            }
        }

        // OpenSim 0.9 introduces a common avatar size computation
        public override void setAvatarSize(OMV.Vector3 size, float feetOffset)
        {
            SetAvatarSize(size, feetOffset, false /* initializing */);
        }

        // Internal version that, if initializing, doesn't do all the updating of the physics engine
        public void SetAvatarSize(OMV.Vector3 size, float feetOffset, bool initializing)
        {
            OMV.Vector3 newSize = size;
            if (newSize.IsFinite())
            {
                // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
                //     replace with the default values.
                if (newSize.X == 0f) newSize.X = BSParam.AvatarCapsuleDepth;
                if (newSize.Y == 0f) newSize.Y = BSParam.AvatarCapsuleWidth;
    
                if (newSize.X < 0.01f) newSize.X = 0.01f;
                if (newSize.Y < 0.01f) newSize.Y = 0.01f;
                if (newSize.Z < 0.01f) newSize.Z = BSParam.AvatarCapsuleHeight;
            }
            else
            {
                newSize = new OMV.Vector3(BSParam.AvatarCapsuleDepth, BSParam.AvatarCapsuleWidth, BSParam.AvatarCapsuleHeight);
            }
    
            // This is how much the avatar size is changing. Positive means getting bigger.
            // The avatar altitude must be adjusted for this change.
            float heightChange = newSize.Z - Size.Z;
    
            _size = newSize;
    
            Scale = ComputeAvatarScale(Size);
            ComputeAvatarVolumeAndMass();
            DetailLog("{0},BSCharacter.setSize,call,size={1},scale={2},density={3},volume={4},mass={5}",
                            LocalID, _size, Scale, Density, _avatarVolume, RawMass);
    
            PhysScene.TaintedObject(LocalID, "BSCharacter.setSize", delegate()
            {
                if (PhysBody.HasPhysicalBody && PhysShape.physShapeInfo.HasPhysicalShape)
                {
                    PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
                    UpdatePhysicalMassProperties(RawMass, true);
    
                    // Adjust the avatar's position to account for the increase/decrease in size
                    ForcePosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, RawPosition.Z + heightChange / 2f);
    
                    // Make sure this change appears as a property update event
                    PhysScene.PE.PushUpdate(PhysBody);
                }
            });
        }

        public override PrimitiveBaseShape Shape
        {
            set { BaseShape = value; }
        }

        public override bool Grabbed {
            set { _grabbed = value; }
        }

        public override bool Selected {
            set { _selected = value; }
        }

        public override bool IsSelected
        {
            get { return _selected; }
        }

        public override void CrossingFailure() { return; }
        public override void link(PhysicsActor obj) { return; }
        public override void delink() { return; }

        // 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 directly into the physics engine
            PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
            {
                if (PhysBody.HasPhysicalBody)
                    PhysScene.PE.ClearAllForces(PhysBody);
            });
        }

        public override void ZeroAngularMotion(bool inTaintTime)
        {
            RawRotationalVelocity = OMV.Vector3.Zero;
    
            PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
            {
                if (PhysBody.HasPhysicalBody)
                {
                    PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, OMV.Vector3.Zero);
                    PhysScene.PE.SetAngularVelocity(PhysBody, OMV.Vector3.Zero);
                    // The next also get rid of applied linear force but the linear velocity is untouched.
                    PhysScene.PE.ClearForces(PhysBody);
                }
            });
        }

        public override void LockAngularMotion(byte axislocks) { return; }

        public override OMV.Vector3 Position {
            get {
                // Don't refetch the position because this function is called a zillion times
                // RawPosition = PhysicsScene.PE.GetObjectPosition(Scene.World, LocalID);
                return RawPosition;
            }
            set {
                RawPosition = value;
    
                PhysScene.TaintedObject(LocalID, "BSCharacter.setPosition", delegate()
                {
                    DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
                    PositionSanityCheck();
                    ForcePosition = RawPosition;
                });
            }
        }

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

        // Check that the current position is sane and, if not, modify the position to make it so.
        // Check for being below terrain or on water.
        // Returns 'true' of the position was made sane by some action.
        private bool PositionSanityCheck()
        {
            bool ret = false;
    
            // TODO: check for out of bounds
            if (!PhysScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
            {
                // The character is out of the known/simulated area.
                // Force the avatar position to be within known. ScenePresence will use the position
                //    plus the velocity to decide if the avatar is moving out of the region.
                RawPosition = PhysScene.TerrainManager.ClampPositionIntoKnownTerrain(RawPosition);
                DetailLog("{0},BSCharacter.PositionSanityCheck,notWithinKnownTerrain,clampedPos={1}", LocalID, RawPosition);
                return true;
            }

            // If below the ground, move the avatar up
            float terrainHeight = PhysScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
            if (Position.Z < terrainHeight)
            {
                DetailLog("{0},BSCharacter.PositionSanityCheck,adjustForUnderGround,pos={1},terrain={2}", LocalID, RawPosition, terrainHeight);
                RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, terrainHeight + BSParam.AvatarBelowGroundUpCorrectionMeters);
                ret = true;
            }
            if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
            {
                float waterHeight = PhysScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
                if (Position.Z < waterHeight)
                {
                    RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, waterHeight);
                    ret = true;
                }
            }
    
            return ret;
        }

        // A version of the sanity check that also makes sure a new position value is
        //    pushed back to the physics engine. This routine would be used by anyone
        //    who is not already pushing the value.
        private bool PositionSanityCheck(bool inTaintTime)
        {
            bool ret = false;
            if (PositionSanityCheck())
            {
                // The new position value must be pushed into the physics engine but we can't
                //    just assign to "Position" because of potential call loops.
                PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.PositionSanityCheck", delegate()
                {
                    DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
                    ForcePosition = RawPosition;
                });
                ret = true;
            }
            return ret;
        }
    
        public override float Mass { get { return _mass; } }

        // used when we only want this prim's mass and not the linkset thing
        public override float RawMass {
            get {return _mass; }
        }

        public override void UpdatePhysicalMassProperties(float physMass, bool inWorld)
        {
            OMV.Vector3 localInertia = PhysScene.PE.CalculateLocalInertia(PhysShape.physShapeInfo, physMass);
            PhysScene.PE.SetMassProps(PhysBody, physMass, localInertia);
        }

        public override OMV.Vector3 Force {
            get { return RawForce; }
            set {
                RawForce = value;
                // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force);
                PhysScene.TaintedObject(LocalID, "BSCharacter.SetForce", delegate()
                {
                    DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, RawForce);
                    if (PhysBody.HasPhysicalBody)
                        PhysScene.PE.SetObjectForce(PhysBody, RawForce);
                });
            }
        }

        // Avatars don't do vehicles
        public override int VehicleType { get { return (int)Vehicle.TYPE_NONE; } set { return; } }
        public override void VehicleFloatParam(int param, float value) { }
        public override void VehicleVectorParam(int param, OMV.Vector3 value) {}
        public override void VehicleRotationParam(int param, OMV.Quaternion rotation) { }
        public override void VehicleFlags(int param, bool remove) { }

        // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
        public override void SetVolumeDetect(int param) { return; }
        public override bool IsVolumeDetect { get { return false; } }

        public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } }
        public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } }

        // PhysicsActor.TargetVelocity
        // Sets the target in the motor. This starts the changing of the avatar's velocity.
        public override OMV.Vector3 TargetVelocity
        {
            get
            {
                return base.m_targetVelocity;
            }
            set
            {
                DetailLog("{0},BSCharacter.setTargetVelocity,call,vel={1}", LocalID, value);
                OMV.Vector3 targetVel = value;
                if (!_flying)
                {
                    if (_setAlwaysRun)
                        targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 1f);
                    else
                        if (BSParam.AvatarWalkVelocityFactor != 1f)
                            targetVel *= new OMV.Vector3(BSParam.AvatarWalkVelocityFactor, BSParam.AvatarWalkVelocityFactor, 1f);
                }
                base.m_targetVelocity = targetVel;
    
                if (m_moveActor != null)
                    m_moveActor.SetVelocityAndTarget(RawVelocity, base.m_targetVelocity, false /* inTaintTime */);
            }
        }

        // Directly setting velocity means this is what the user really wants now.
        public override OMV.Vector3 Velocity {
            get { return RawVelocity; }
            set {
                if (m_moveActor != null)
                {
                    // m_moveActor.SetVelocityAndTarget(OMV.Vector3.Zero, OMV.Vector3.Zero, false /* inTaintTime */);
                    m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false /* inTaintTime */);
                }
                base.Velocity = value;
            }
        }

        // SetMomentum just sets the velocity without a target. We need to stop the movement actor if a character.
        public override void SetMomentum(OMV.Vector3 momentum)
        {
            if (m_moveActor != null)
            {
                // m_moveActor.SetVelocityAndTarget(OMV.Vector3.Zero, OMV.Vector3.Zero, false /* inTaintTime */);
                m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false /* inTaintTime */);
            }
            base.SetMomentum(momentum);
        }

        public override OMV.Vector3 ForceVelocity {
            get { return RawVelocity; }
            set {
                DetailLog("{0},BSCharacter.ForceVelocity.set={1}", LocalID, value);
    
                RawVelocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
                PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
                PhysScene.PE.Activate(PhysBody, true);
            }
        }

        public override OMV.Vector3 Torque {
            get { return RawTorque; }
            set { RawTorque = value;
            }
        }

        public override float CollisionScore {
            get { return _collisionScore; }
            set { _collisionScore = value;
            }
        }

        public override OMV.Vector3 Acceleration {
            get { return _acceleration; }
            set { _acceleration = value; }
        }

        public override OMV.Quaternion Orientation {
            get { return RawOrientation; }
            set {
                // Orientation is set zillions of times when an avatar is walking. It's like
                //      the viewer doesn't trust us.
                if (RawOrientation != value)
                {
                    RawOrientation = value;
                    PhysScene.TaintedObject(LocalID, "BSCharacter.setOrientation", delegate()
                    {
                        // Bullet assumes we know what we are doing when forcing orientation
                        //    so it lets us go against all the rules and just compensates for them later.
                        // This forces rotation to be only around the Z axis and doesn't change any of the other axis.
                        // This keeps us from flipping the capsule over which the veiwer does not understand.
                        float oRoll, oPitch, oYaw;
                        RawOrientation.GetEulerAngles(out oRoll, out oPitch, out oYaw);
                        OMV.Quaternion trimmedOrientation = OMV.Quaternion.CreateFromEulers(0f, 0f, oYaw);
                        // DetailLog("{0},BSCharacter.setOrientation,taint,val={1},valDir={2},conv={3},convDir={4}",
                        //                 LocalID, RawOrientation, OMV.Vector3.UnitX * RawOrientation,
                        //                 trimmedOrientation, OMV.Vector3.UnitX * trimmedOrientation);
                        ForceOrientation = trimmedOrientation;
                    });
                }
            }
        }

        // 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)
                {
                    // RawPosition = PhysicsScene.PE.GetPosition(BSBody);
                    PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
                }
            }
        }

        public override int PhysicsActorType {
            get { return _physicsActorType; }
            set { _physicsActorType = value;
            }
        }

        public override bool IsPhysical {
            get { return _isPhysical; }
            set { _isPhysical = value;
            }
        }

        public override bool IsSolid {
            get { return true; }
        }

        public override bool IsStatic {
            get { return false; }
        }

        public override bool IsPhysicallyActive {
            get { return true; }
        }

        public override bool Flying {
            get { return _flying; }
            set {
                _flying = value;
    
                // simulate flying by changing the effect of gravity
                Buoyancy = ComputeBuoyancyFromFlying(_flying);
            }
        }

        // Flying is implimented by changing the avatar's buoyancy.
        // Would this be done better with a vehicle type?
        private float ComputeBuoyancyFromFlying(bool ifFlying) {
            return ifFlying ? 1f : 0f;
        }

        public override bool
            SetAlwaysRun {
            get { return _setAlwaysRun; }
            set { _setAlwaysRun = value; }
        }

        public override bool ThrottleUpdates {
            get { return _throttleUpdates; }
            set { _throttleUpdates = value; }
        }

        public override bool FloatOnWater {
            set {
                _floatOnWater = value;
                PhysScene.TaintedObject(LocalID, "BSCharacter.setFloatOnWater", delegate()
                {
                    if (PhysBody.HasPhysicalBody)
                    {
                        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; }
        }

        // neg=fall quickly, 0=1g, 1=0g, pos=float up
        public override float Buoyancy {
            get { return _buoyancy; }
            set { _buoyancy = value;
                PhysScene.TaintedObject(LocalID, "BSCharacter.setBuoyancy", delegate()
                {
                    DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
                    ForceBuoyancy = _buoyancy;
                });
            }
        }

        public override float ForceBuoyancy {
            get { return _buoyancy; }
            set {
                _buoyancy = value;
                DetailLog("{0},BSCharacter.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
                // Buoyancy is faked by changing the gravity applied to the object
                float  grav = BSParam.Gravity * (1f - _buoyancy);
                Gravity = new OMV.Vector3(0f, 0f, grav);
                if (PhysBody.HasPhysicalBody)
                    PhysScene.PE.SetGravity(PhysBody, Gravity);
            }
        }

        // Used for MoveTo
        public override OMV.Vector3 PIDTarget {
            set { _PIDTarget = value; }
        }

        public override bool PIDActive { get; set; }

        public override float PIDTau {
            set { _PIDTau = value; }
        }

        public override void AvatarJump(float impulseZ)
        {
            AddForce(false, new OMV.Vector3(0, 0, 0.22f * Mass * impulseZ / PhysScene.m_fixedTimeStep));
        }

        public override void AddForce(OMV.Vector3 force, bool pushforce)
        {
            // Since this force is being applied in only one step, make this a force per second.
            OMV.Vector3 addForce = force;
    
            // The interaction of this force with the simulator rate and collision occurance is tricky.
            // ODE multiplies the force by 100
            // ubODE multiplies the force by 5.3
            // BulletSim, after much in-world testing, thinks it gets a similar effect by multiplying mass*0.315f
            //    This number could be a feature of friction or timing, but it seems to move avatars the same as ubODE
            addForce *= Mass * BSParam.AvatarAddForcePushFactor;
    
            DetailLog("{0},BSCharacter.addForce,call,force={1},addForce={2},push={3},mass={4}", LocalID, force, addForce, pushforce, Mass);
            AddForce(false, addForce);
        }

        public override void AddForce(bool inTaintTime, OMV.Vector3 force)
        {
            if (force.IsFinite())
            {
                OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);
                // DetailLog("{0},BSCharacter.addForce,call,force={1},push={2},inTaint={3}", LocalID, addForce, pushforce, inTaintTime);
    
                PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.AddForce", delegate()
                {
                    // Bullet adds this central force to the total force for this tick
                    // DetailLog("{0},BSCharacter.addForce,taint,force={1}", LocalID, addForce);
                    if (PhysBody.HasPhysicalBody)
                    {
                        // Bullet adds this central force to the total force for this tick.
                        // Deep down in Bullet:
                        //      linearVelocity += totalForce / mass * timeStep;
                        PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
                        PhysScene.PE.Activate(PhysBody, true);
                    }
                    if (m_moveActor != null)
                    {
                        m_moveActor.SuppressStationayCheckUntilLowVelocity(BSParam.AvatarAddForceFrames);
                    }
                });
            }
            else
            {
                m_log.WarnFormat("{0}: Got a NaN force applied to a character. LocalID={1}", LogHeader, LocalID);
                return;
            }
        }

        public override void AddAngularForce(bool inTaintTime, OMV.Vector3 force) {
        }

        // The avatar's physical shape (whether capsule or cube) is unit sized. BulletSim sets
        //    the scale of that unit shape to create the avatars full size.
        private OMV.Vector3 ComputeAvatarScale(OMV.Vector3 size)
        {
            OMV.Vector3 newScale = size;
    
            if (BSParam.AvatarUseBefore09SizeComputation)
            {
    
                // Bullet's capsule total height is the "passed height + radius * 2";
                // The base capsule is 1 unit in diameter and 2 units in height (passed radius=0.5, passed height = 1)
                // The number we pass in for 'scaling' is the multiplier to get that base
                //     shape to be the size desired.
                // So, when creating the scale for the avatar height, we take the passed height
                //     (size.Z) and remove the caps.
                // An oddity of the Bullet capsule implementation is that it presumes the Y
                //     dimension is the radius of the capsule. Even though some of the code allows
                //     for a asymmetrical capsule, other parts of the code presume it is cylindrical.
    
                // Scale is multiplier of radius with one of "0.5"
    
                float heightAdjust = BSParam.AvatarHeightMidFudge;
                if (BSParam.AvatarHeightLowFudge != 0f || BSParam.AvatarHeightHighFudge != 0f)
                {
                    const float AVATAR_LOW = 1.1f;
                    const float AVATAR_MID = 1.775f; // 1.87f
                    const float AVATAR_HI = 2.45f;
                    // An avatar is between 1.1 and 2.45 meters. Midpoint is 1.775m.
                    float midHeightOffset = size.Z - AVATAR_MID;
                    if (midHeightOffset < 0f)
                    {
                        // Small avatar. Add the adjustment based on the distance from midheight
                        heightAdjust += ((-1f * midHeightOffset) / (AVATAR_MID - AVATAR_LOW)) * BSParam.AvatarHeightLowFudge;
                    }
                    else
                    {
                        // Large avatar. Add the adjustment based on the distance from midheight
                        heightAdjust += ((midHeightOffset) / (AVATAR_HI - AVATAR_MID)) * BSParam.AvatarHeightHighFudge;
                    }
                }
                if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
                {
                    newScale.X = size.X / 2f;
                    newScale.Y = size.Y / 2f;
                    // The total scale height is the central cylindar plus the caps on the two ends.
                    newScale.Z = (size.Z + (Math.Min(size.X, size.Y) * 2) + heightAdjust) / 2f;
                }
                else
                {
                    newScale.Z = size.Z + heightAdjust;
                }
                // m_log.DebugFormat("{0} ComputeAvatarScale: size={1},adj={2},scale={3}", LogHeader, size, heightAdjust, newScale);
    
                // If smaller than the endcaps, just fake like we're almost that small
                if (newScale.Z < 0)
                    newScale.Z = 0.1f;
    
                DetailLog("{0},BSCharacter.ComputeAvatarScale,size={1},lowF={2},midF={3},hiF={4},adj={5},newScale={6}",
                    LocalID, size, BSParam.AvatarHeightLowFudge, BSParam.AvatarHeightMidFudge, BSParam.AvatarHeightHighFudge, heightAdjust, newScale);
            }
            else
            {
                newScale.Z = size.Z + _footOffset;
                DetailLog("{0},BSCharacter.ComputeAvatarScale,using newScale={1}, footOffset={2}", LocalID, newScale, _footOffset);
            }
    
            return newScale;
        }

        // set _avatarVolume and _mass based on capsule size, _density and Scale
        private void ComputeAvatarVolumeAndMass()
        {
            if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
            {
                _avatarVolume = (float)(
                                Math.PI
                                * Size.X / 2f
                                * Size.Y / 2f    // the area of capsule cylinder
                                * Size.Z         // times height of capsule cylinder
                              + 1.33333333f
                                * Math.PI
                                * Size.X / 2f
                                * Math.Min(Size.X, Size.Y) / 2
                                * Size.Y / 2f    // plus the volume of the capsule end caps
                                );
            }
            else
            {
                _avatarVolume = Size.X * Size.Y * Size.Z;
            }
            _mass = Density * BSParam.DensityScaleFactor * _avatarVolume;
        }

        // The physics engine says that properties have updated. Update same and inform
        // the world that things have changed.
        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);
    
            RawPosition = entprop.Position;
            RawOrientation = entprop.Rotation;
    
            // Smooth velocity. OpenSimulator is VERY sensitive to changes in velocity of the avatar
            //    and will send agent updates to the clients if velocity changes by more than
            //    0.001m/s. Bullet introduces a lot of jitter in the velocity which causes many
            //    extra updates.
            //
            // XXX: Contrary to the above comment, setting an update threshold here above 0.4 actually introduces jitter to
            // avatar movement rather than removes it.  The larger the threshold, the bigger the jitter.
            // This is most noticeable in level flight and can be seen with
            // the "show updates" option in a viewer.  With an update threshold, the RawVelocity cycles between a lower
            // bound and an upper bound, where the difference between the two is enough to trigger a large delta v update
            // and subsequently trigger an update in ScenePresence.SendTerseUpdateToAllClients().  The cause of this cycle (feedback?)
            // has not yet been identified.
            //
            // If there is a threshold below 0.4 or no threshold check at all (as in ODE), then RawVelocity stays constant and extra
            // updates are not triggered in ScenePresence.SendTerseUpdateToAllClients().
    //        if (!entprop.Velocity.ApproxEquals(RawVelocity, 0.1f))
                RawVelocity = entprop.Velocity;
    
            _acceleration = entprop.Acceleration;
            RawRotationalVelocity = entprop.RotationalVelocity;
    
            // Do some sanity checking for the avatar. Make sure it's above ground and inbounds.
            if (PositionSanityCheck(true))
            {
                DetailLog("{0},BSCharacter.UpdateProperties,updatePosForSanity,pos={1}", LocalID, RawPosition);
                entprop.Position = RawPosition;
            }
    
            // remember the current and last set values
            LastEntityProperties = CurrentEntityProperties;
            CurrentEntityProperties = entprop;
    
            // Tell the linkset about value changes
            // Linkset.UpdateProperties(UpdatedProperties.EntPropUpdates, this);
    
            // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop.
            // PhysScene.PostUpdate(this);
    
            DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
                    LocalID, RawPosition, RawOrientation, RawVelocity, _acceleration, RawRotationalVelocity);
        }
    }
}