internal void AvatarKicked(PhysxPrim physxPrim)
 {
     if (_standingOnPrim == physxPrim)
     {
         AvatarNotStandingOnPrim();
     }
 }

 public void AvatarStandingOn(PhysxPrim prim)
 {
     if (_standingOnPrim != prim)
     {
         _timeBeganStandingOnPrim = (uint)Environment.TickCount;
         _standingOnPrim = prim;
     }
 }

 public void PrimWantsCollisionRepeat(PhysxPrim prim)
 {
     _collisionRepeatPrims.Add(prim);
 }

 internal void BeginDelayCommands(PhysxPrim prim, Commands.ICommand initiator)
 {
     DelayedCommandInfo info = new DelayedCommandInfo { Commands = new LinkedList<Commands.ICommand>(), Initiator = initiator };
     _delayedCommands.Add(prim, info);
 }

 internal void RemovePrim(PhysxPrim prim)
 {
     _dynPrims.Remove(prim);
     _allPrims.Remove(prim);
     _collisionRepeatPrims.Remove(prim);
     _kinematicManager.KinematicRemoved(prim);
     _delayedCommands.Remove(prim);
     prim.Dispose();
 }

 internal void PrimMadeStaticKinematic(PhysxPrim actor)
 {
     _dynPrims.Remove(actor);
     _kinematicManager.KinematicChanged(actor);
 }

 internal void AddPrimSync(PhysxPrim prim, bool physical, bool kinematicStatic)
 {
     _allPrims.Add(prim);
     if (physical) _dynPrims.Add(prim);
     if (kinematicStatic) _kinematicManager.KinematicChanged(prim);
 }

 private void HandlePrimChangedShape(PhysxPrim prim, TaintType taint)
 {
     this.QueueCommand(new Commands.ChangedShapeCmd(prim));
 }

        private void ContactedActorDeleted(PhysxPrim deletedActor, PhysxPrim ourActor)
        {
            if (!_touchCounts.IsValueCreated) return;

            int touchCount;
            if (_touchCounts.Value.TryGetValue(deletedActor, out touchCount))
            {
                ProcessContactChange(-touchCount, ourActor, deletedActor);
            }
        }

        public PhysxPrim(PhysxPrim parent, PhysxScene scene, PrimitiveBaseShape baseShape, OpenMetaverse.Vector3 pos,
            OpenMetaverse.Quaternion rotation, PhysicsShape myShape, PhysX.RigidActor myActor,
            bool isPhysical, IPhysicsProperties properties, CollisionGroupFlag collisionGroup)
        {
            _parentPrim = parent;
            _scene = scene;
            _pbs = baseShape;
            _position = pos;
            _rotation = rotation;
            _isPhysical = isPhysical;
            _properties = (PhysicsProperties)properties;
            _collisionGroup = collisionGroup;

            this.AssignActor(myActor, myShape, _isPhysical, DeleteActorFlags.None);

            if (_properties.VehicleProps != null && _properties.VehicleProps.Type != VehicleType.None)
            {
                //init dynamics
                CheckCreateVehicleDynamics();
            }
        }

        private void ReplaceMaterialOnShapes(Material material, PhysxPrim affectedPrim, IEnumerable<PhysX.Shape> shapes)
        {
            Material oldMaterial = affectedPrim.PhysxProperties.PhysxMaterial;
            affectedPrim.PhysxProperties.PhysxMaterial = material;

            PhysX.Material[] materialArr = new PhysX.Material[] { material.PhyMaterial };
            foreach (PhysX.Shape shape in shapes)
            {
                shape.SetMaterials(materialArr);
            }

            if (oldMaterial.Density != material.Density) UpdateMassAndInertia();

            oldMaterial.CheckedDispose();
        }

        /// <summary>
        /// Sets the given prim in our linkset to the given material
        /// </summary>
        /// <param name="material"></param>
        /// <param name="affectedPrim"></param>
        private void SetMaterialSync(Material material, PhysxPrim affectedPrim, bool applyToObject)
        {
            IEnumerable<PhysX.Shape> shapes;

            if (applyToObject)
            {
                ReplaceMaterialOnAllShapes(material);
                return;
            }

            
            if (affectedPrim == this)
            {
                shapes = _actor.Shapes;
            }
            else
            {
                RelatedShapes childShapes;
                if (_childShapes.TryGetValue(affectedPrim, out childShapes))
                {
                    shapes = childShapes.PhyShapes;
                }
                else
                {
                    m_log.ErrorFormat("[InWorldz.PhysxPhysics] Asked to set material for unknown child shape");
                    return;
                }
            }

            ReplaceMaterialOnShapes(material, affectedPrim, shapes);
        }

        private void HandleTrackedCharacterContactChange(int change, PhysxPrim ourPrim, PhysX.Shape primShape, PhysxCharacter other)
        {
            HashSet<PhysX.Shape> collidingShapes;
            if (!_avatarTouchCounts.Value.TryGetValue(other, out collidingShapes))
            {
                if (change < 0)
                {
                    //we have no record of colliding with this object. therefore removing a 
                    //collision leaves no change to state
                    return;
                }

                collidingShapes = new HashSet<PhysX.Shape>();
                _avatarTouchCounts.Value[other] = collidingShapes;
            }

            if (change > 0 && !collidingShapes.Add(primShape))
            {
                //we're already colliding with this object. no change in state
                return;
            }
            else if (change < 0 && !collidingShapes.Remove(primShape))
            {
                //we weren't colliding with this object. no change in state
                return;
            }

            int newTotal = collidingShapes.Count;

            //m_log.DebugFormat("Char Contact Change: This: {0}, Other: {1}, Chg: {2}, Tot: {3}", this.SOPName, other.SOPName, change, collidingShapes.Count);

            if (newTotal == 0 && change < 0)
            {
                //we've lost all contact with this prim, notify of collision_end
                ourPrim.SendCollisionUpdate(new CollisionEventUpdate { OtherColliderLocalId = other.LocalID, Type = CollisionEventUpdateType.CharacterCollisionEnded });
                _avatarTouchCounts.Value.Remove(other);

                return;
            }

            if (newTotal == 1 && change > 0)
            {
                //we have begun colliding with a new object
                ourPrim.SendCollisionUpdate(new CollisionEventUpdate { OtherColliderLocalId = other.LocalID, Type = CollisionEventUpdateType.CharacterCollisionBegan });
            }

            return;
        }

 /// <summary>
 /// Called when a change has been posted for touches between one of our prims and an avatar. We must track
 /// these touches by shape because the collision detection is sometimes one sided in the case of an avatar
 /// touching a prim
 /// </summary>
 /// <param name="change"></param>
 /// <param name="other"></param>
 private void ProcessCharacterContactChange(int change, PhysxPrim ourPrim, PhysX.Shape primShape, PhysxCharacter other)
 {
     if (IsChild && _properties.WantsCollisionNotification)
     {
         HandleTrackedCharacterContactChange(change, ourPrim, primShape, other);
     }
     else if (IsChild && !_properties.WantsCollisionNotification)
     {
         _parentPrim.ProcessCharacterContactChange(change, ourPrim, primShape, other);
     }
     else if (HasActor && (_properties.WantsCollisionNotification || _properties.ChildrenWantCollisionNotification))
     {
         HandleTrackedCharacterContactChange(change, ourPrim, primShape, other);
     }
 }

 private void HandlePrimMadeStatic(PhysxPrim prim, TaintType taint)
 {
     this.QueueCommand(new Commands.SetPhysicalityCmd(prim, false));
 }

 private void HandlePrimMadeDynamic(PhysxPrim prim, TaintType taint)
 {
     this.QueueCommand(new Commands.SetPhysicalityCmd(prim, true));
 }

 /// <summary>
 /// Called when a prim actor shape changes or an actor is deleted.
 /// This invalidates the controller cache to prevent PhysX crashes
 /// due to bugs
 /// </summary>
 /// <param name="prim"></param>
 internal void InvalidateControllerCacheIfContacting(PhysxPrim prim)
 {
     if (_collidingPrims.ContainsKey(prim))
     {
         _controller.InvalidateCache();
     }
 }

        private bool CheckAddDelay(Commands.ICommand cmd, PhysxPrim target)
        {
            DelayedCommandInfo delayInfo;
            if (_delayedCommands.TryGetValue(target, out delayInfo) && delayInfo.Initiator != cmd)
            {
                //if we're already the last delayed command delayed behind the other command
                //for the given prim, we only need to be added once per command so we can safely
                //just return
                if (delayInfo.Commands.Count > 0 && delayInfo.Commands.Last.Value == cmd)
                {
                    return true;
                }

                //before adding this new command to wait, check to see if it is cullable.
                //if the command is cullable, and has the same targets, we replace it with this command
                //maintaining its position in the queue
                LinkedListNode<Commands.ICommand> cmdNode;
                if (cmd.IsCullable
                    && delayInfo.TopCullables != null && delayInfo.TopCullables.TryGetValue(cmd.GetType(), out cmdNode)
                    && HasSameTargets(cmdNode.Value, cmd))
                {
                    cmdNode.Value = cmd;
                    if (cmd.AffectsMultiplePrims()) ((Commands.IMultiPrimCommand)cmd).AddDelay();

                    return true;
                }
                else
                {
                    cmdNode = delayInfo.Commands.AddLast(cmd);
                    if (cmd.AffectsMultiplePrims()) ((Commands.IMultiPrimCommand)cmd).AddDelay();

                    if (cmd.IsCullable)
                    {
                        if (delayInfo.TopCullables == null)
                        {
                            delayInfo.TopCullables = new Dictionary<Type, LinkedListNode<Commands.ICommand>>();
                        }

                        delayInfo.TopCullables.Add(cmd.GetType(), cmdNode);
                    }

                    return true;
                }
            }

            return false;
        }

 private void SetToRemoveAfterReport(PhysX.Shape otherShape, PhysxPrim colPrim)
 {
     ExternalReport report;
     if (_externalCollisionReports.TryGetValue(otherShape, out report))
     {
         if (report.Reported)
         {
             //this collision was reported already. remove it
             RemoveExternalCollidingPrimShape(otherShape, colPrim);
         }
         else
         {
             //this collision hasn't been reported yet. make sure the 
             //collision processor knows to remove it after it is reported
             report.RemoveAfterReport = true;
         }
     }
 }

 internal void PrimMadeDynamic(PhysxPrim prim)
 {
     _dynPrims.Add(prim);
     _kinematicManager.KinematicRemoved(prim);
 }