public override void ReportError(PhysX.ErrorCode errorCode, string message, string file, int lineNumber)
        {
            string errorMessage = String.Format("[InWorldz.PhysxPhysics] PhysX ERROR: Code: {0}  Message: {1} ({2}:{3})",
                new object[] { errorCode, message, file, lineNumber });

            if (errorMessage == lastMessage && lastMessageRepeat < MAX_MESSAGES_BEFORE_NOTIFICATION)
            {
                lastMessageRepeat++;
                return;
            }
            else
            {
                if (lastMessageRepeat != 0)
                {
                    m_log.ErrorFormat("[InWorldz.PhysxPhysics] PhysX ERROR: (Last physics message repeats {0} times)", lastMessageRepeat);
                    lastMessageRepeat = 0;
                }

                lastMessage = errorMessage;
            }

            m_log.ErrorFormat(errorMessage);

            if (Settings.Instance.ThrowOnSdkError)
            {
                throw new PhysxSdkException(errorMessage);
            }
        }

 public override void OnShapeHit(PhysX.ControllerShapeHit hit)
 {
     if (OnShapeHitCallback != null)
     {
         OnShapeHitCallback(hit);
     }
 }

 public override void OnContact(PhysX.ContactPairHeader contactPairHeader, PhysX.ContactPair[] pairs)
 {
     if (OnContactCallback != null)
     {
         OnContactCallback(contactPairHeader, pairs);
     }
 }

 public override void OnTrigger(PhysX.TriggerPair[] pairs)
 {
     if (OnTriggerCallback != null)
     {
         OnTriggerCallback(pairs);
     }
 }

 public override void OnSleep(PhysX.Actor[] actors)
 {
     if (OnSleepCallback != null)
     {
         OnSleepCallback(actors);
     }
 }

 public override void OnWake(PhysX.Actor[] actors)
 {
     if (OnWakeCallback != null)
     {
         OnWakeCallback(actors);
     }
 }

 public override void OnObstacleHit(PhysX.ControllerObstacleHit hit)
 {
     if (OnObstacleHitCallback != null)
     {
         OnObstacleHitCallback(hit);
     }
 }

        public static void SetCollisionGroup(CollisionGroupFlag group, PhysX.Shape shape)
        {
            PhysX.FilterData newFilterData = CollisionGroup.GetFilterData(shape.SimulationFilterData.Word0,
                shape.SimulationFilterData.Word1, group);

            shape.SimulationFilterData = newFilterData;
            shape.QueryFilterData = newFilterData;
        }

        private PhysX.RigidDynamic CreateBox(PhysX.Scene scene, int offset)
        {
            const float HEIGHT = 20.0f;

            var rigid = scene.Physics.CreateRigidDynamic();
            var shape = rigid.CreateShape(new PhysX.BoxGeometry(1.0f, 1.0f, 1.0f), material);
            
            rigid.GlobalPose = PhysX.Math.Matrix.Translation(130f, 130f, HEIGHT + offset);

            return rigid;
        }

        private bool IsRideOnPrim(PhysX.Shape shape)
        {
            if (_standingOnPrim == null)
            {
                return false;
            }

            PhysxPrim shapePrim = shape.Actor.UserData as PhysxPrim;

            return IsRideOnPrim(shapePrim);
        }

 public override PhysX.ControllerBehaviorFlag GetBehaviorFlags(PhysX.Shape shape)
 {
     if (IsRideOnPrim(shape))
     {
         return PhysX.ControllerBehaviorFlag.CctCanRideOnObject;
     }
     else
     {
         return 0;
     }
 }

        private PhysX.RigidDynamic CreateSphere(PhysX.Scene scene, int offset)
        {
            const float HEIGHT = 20.0f;

            var rigid = scene.Physics.CreateRigidDynamic();
            var shape = rigid.CreateShape(new PhysX.SphereGeometry(1.0f), material);

            rigid.GlobalPose = PhysX.Math.Matrix.Translation(128f, 128f, HEIGHT + offset);
            rigid.AngularDamping = 0.2f;
            rigid.LinearDamping = 0.2f;

            return rigid;
        }

		protected override void LoadPhysics(PhysX.Scene scene)
		{
			var material = scene.Physics.CreateMaterial(0.7f, 0.7f, 0.1f);

			var sphereA = scene.Physics.CreateRigidDynamic();
			sphereA.CreateShape(new SphereGeometry(1), material);
			sphereA.GlobalPose = Matrix4x4.CreateTranslation(0, 30, 0);

			scene.AddActor(sphereA);

			//

			var sphereB = scene.Physics.CreateRigidDynamic();
			sphereB.CreateShape(new SphereGeometry(1), material);
			sphereB.GlobalPose = Matrix4x4.CreateTranslation(0, 40, 0);

			scene.AddActor(sphereB);

			//

			var sphereC = scene.Physics.CreateRigidDynamic();
			sphereC.CreateShape(new SphereGeometry(1), material);
			sphereC.GlobalPose = Matrix4x4.CreateTranslation(0, 50, 0);

			scene.AddActor(sphereC);

			_sphereC = sphereC;

			//

			var revoluteABJoint = scene.CreateJoint<RevoluteJoint>(sphereA, Matrix4x4.Identity, sphereB, Matrix4x4.Identity);
			revoluteABJoint.SetGlobalFrame(new Vector3(0, 35, 0), new Vector3(0, 0, 1));
			revoluteABJoint.ConstraintFlag = ConstraintFlag.Visualization;

			var revoluteBCJoint = scene.CreateJoint<RevoluteJoint>(sphereB, Matrix4x4.Identity, sphereC, Matrix4x4.Identity);
			revoluteBCJoint.SetGlobalFrame(new Vector3(0, 45, 0), new Vector3(0, 0, 1));
			revoluteBCJoint.ConstraintFlag = ConstraintFlag.Visualization;

			var revoluteAJoint = scene.CreateJoint<RevoluteJoint>(sphereA, Matrix4x4.Identity, null, Matrix4x4.Identity);
			revoluteAJoint.SetGlobalFrame(new Vector3(0, 30, 0), new Vector3(0, 0, 1));
			revoluteAJoint.ConstraintFlag = ConstraintFlag.Visualization;
		}

 private bool TryInformPrimOfContactChange(PhysX.ContactPairHeader contactPairHeader, PhysX.ContactPair[] pairs, int actorIndex)
 {
     PhysxPrim prim = contactPairHeader.Actors[actorIndex].UserData as PhysxPrim;
     if (prim != null)
     {
         prim.OnContactChangeSync(contactPairHeader, pairs, actorIndex);
         return true;
     }
     else
     {
         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;
         }
     }
 }

        private void AddExternalCollidingPrimShape(PhysX.Shape otherShape, PhysxPrim colPrim)
        {
            _externalCollisionReports[otherShape] = new ExternalReport { RemoveAfterReport = false, Reported = false };

            HashSet<PhysX.Shape> primShapes;
            if (!_externalCollisionPrims.TryGetValue(colPrim, out primShapes))
            {
                primShapes = new HashSet<PhysX.Shape>();
                _externalCollisionPrims.Add(colPrim, primShapes);
                colPrim.OnDeleted += colPrim_OnDeleted;
            }

            primShapes.Add(otherShape);
        }

        private void RemoveExternalCollidingPrimShape(PhysX.Shape otherShape, PhysxPrim colPrim)
        {
            _externalCollisionReports.Remove(otherShape);

            HashSet<PhysX.Shape> primShapes;
            if (_externalCollisionPrims.TryGetValue(colPrim, out primShapes))
            {
                primShapes.Remove(otherShape);
                if (primShapes.Count == 0)
                {
                    _externalCollisionPrims.Remove(colPrim);
                    colPrim.OnDeleted -= colPrim_OnDeleted;
                }
            }
        }

 //
 // Motor add torque. It acumulates velocity and impulse
 // torques separately so that they can be applied finally at the end of the physics frame.
 //
 internal void AddTorque(OpenMetaverse.Vector3 force, PhysX.ForceMode mode, string code)
 {
     OpenMetaverse.Vector3 torque = force;
     if (mode == PhysX.ForceMode.VelocityChange)
         AccumTorqueVel += torque;
     if (mode == PhysX.ForceMode.Impulse)
         AccumTorqueImpulse += torque;
     if (VehicleLimits.DebugAngular)
     {
         if (AccumTorqueFirst)
         {
             m_log.DebugFormat("[----------------------]");
             m_log.DebugFormat("[VehicleMotor BgnTorque] InitialVelocity {0}", worldAngularVel * Quaternion.Inverse(rotation));
         }
         m_log.DebugFormat("[VehicleMotor AddTorque] {2} {1} {0}", torque * Quaternion.Inverse(rotation), code, mode);
     }
     AccumTorqueFirst = false;
 }

        private float CalculateDepenetrationZOffset(OpenMetaverse.Vector3 pos, PhysX.Geometry avaGeom, PhysX.Shape avaShape)
        {
            const int MAX_ITERATIONS = 8;
            const float PUSH_MULTIPLIER = 1.5F;
            float pushFactor = 0.1f;

            OpenMetaverse.Vector3 offset = OpenMetaverse.Vector3.Zero;

            bool foundOverlap = false;

            //constant from looking at the rot returned from the live avatar,
            //remember that capsules are always upright, and z rotations don't have an effect
            //on their geometry
            OpenMetaverse.Quaternion capsuleRot = new OpenMetaverse.Quaternion(0f, -0.7071069f, 0f, 0.7071067f);

            for (int i = 0; i < MAX_ITERATIONS; i++)
            {
                foundOverlap = false;
                OpenMetaverse.Vector3 translatedPose = pos + offset;
                PhysX.Shape[] overlap = _scene.SceneImpl.OverlapMultiple(avaGeom, PhysUtil.PositionToMatrix(translatedPose, capsuleRot));

                if (overlap == null)
                {
                    foundOverlap = true;
                }
                else
                {
                    foreach (var shape in overlap)
                    {
                        if (shape != avaShape && !ShapeIsVolumeDetect(shape))
                        {
                            foundOverlap = true;
                            break;
                        }
                    }
                }

                if (foundOverlap && i + 1 < MAX_ITERATIONS)
                {
                    offset += new OpenMetaverse.Vector3(0f, 0f, pushFactor);
                    pushFactor *= PUSH_MULTIPLIER;
                }
                else
                {
                    break;
                }
            }

            if (foundOverlap == false && offset != OpenMetaverse.Vector3.Zero)
            {
                return offset.Z;
            }

            return 0.0f;
        }

 public VehicleMotor(ref PhysxPrim _actor, ref VehicleProperties _props, ref PhysX.Physics _physics, ref PhysxScene _scene)
 {
     this._actor = _actor;
     this._props = _props;
     this._physics = _physics;
     this._scene = _scene;
 }