/// <summary>
        /// Queues a raycast
        /// </summary>
        /// <param name="position">Origin of Ray</param>
        /// <param name="direction">Ray normal</param>
        /// <param name="length">Ray length</param>
        /// <param name="retMethod">Return method to send the results</param>
        public void QueueRequest(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
        {
            lock (m_PendingRequests)
            {
                ODERayCastRequest req = new ODERayCastRequest();
                req.callbackMethod = retMethod;
                req.length = length;
                req.Normal = direction;
                req.Origin = position;

                m_PendingRequests.Add(req);
            }
        }

        /// <summary>
        /// Creates a new instance of the Wheel class.
        /// </summary>
        /// <param name="world">The world.</param>
        /// <param name="car">The RigidBody on which to apply the wheel forces.</param>
        /// <param name="position">The position of the wheel on the body (in body space).</param>
        /// <param name="radius">The wheel radius.</param>
        public Wheel(World world,RigidBody car,JVector position,float radius)
        {
            this.world = world;
            this.car = car;
            this.Position = position;

            raycast = new RaycastCallback(RaycastCallback);

            // set some default values.
            this.SideFriction = 1.5f;
            this.ForwardFriction = 1f;
            this.Radius = radius;
            this.Inertia = 1.0f;
            this.WheelTravel = 0.2f;
            this.MaximumAngularVelocity = 200;
            this.NumberOfRays = 5;
        }

        //Vector3 rawRotation;//, rotation;
        public Tool(Player parent, GameInput gameInput)
        {
            Parent = parent;

            this.gameInput = gameInput;

            raycastCallback = new RaycastCallback(mRaycastCallback);

            slot = getSlot();

            icon = new GuiElement(this.parent.hud);
            icon.setSizeRel(new Vector2(256, 128));

            iconPos = new Vector2(-0.8f, 0.8f - slot * iconDist);
            smoothIconPos = iconPos;
            icon.Position = smoothIconPos;

            icon.setMaterial("hud\\blank_icon.xmf");

            createWeaponModel();
        }

 /// <summary>
 /// Queue a raycast against the physics scene.
 /// The provided callback method will be called when the raycast is complete
 /// 
 /// Many physics engines don't support collision testing at the same time as 
 /// manipulating the physics scene, so we queue the request up and callback 
 /// a custom method when the raycast is complete.
 /// This allows physics engines that give an immediate result to callback immediately
 /// and ones that don't, to callback when it gets a result back.
 /// 
 /// ODE for example will not allow you to change the scene while collision testing or
 /// it asserts, 'opteration not valid for locked space'.  This includes adding a ray to the scene.
 /// 
 /// This is named RayCastWorld to not conflict with modrex's Raycast method.
 /// </summary>
 /// <param name="position">Origin of the ray</param>
 /// <param name="direction">Direction of the ray</param>
 /// <param name="length">Length of ray in meters</param>
 /// <param name="retMethod">Method to call when the raycast is complete</param>
 public virtual void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
 {
     if (retMethod != null)
         retMethod(false, Vector3.Zero, 0, 999999999999f, Vector3.Zero);
 }

        public override bool Raycast(JVector rayOrigin, JVector rayDirection, RaycastCallback raycast, out RigidBody body, out JVector normal, out float fraction)
        {
            throw new NotImplementedException();
            //body = null; normal = JVector.Zero; fraction = float.MaxValue;

            //JVector tempNormal; float tempFraction;
            //bool result = false;

            //// TODO: This can be done better in CollisionSystemPersistenSAP
            //foreach (IBroadphaseEntity e in bodyList)
            //{
            //    if (e is SoftBody)
            //    {
            //        SoftBody softBody = e as SoftBody;
            //        foreach (RigidBody b in softBody.VertexBodies)
            //        {
            //            if (this.Raycast(b, rayOrigin, rayDirection, out tempNormal, out tempFraction))
            //            {
            //                if (tempFraction < fraction && (raycast == null || raycast(b, tempNormal, tempFraction)))
            //                {
            //                    body = b;
            //                    normal = tempNormal;
            //                    fraction = tempFraction;
            //                    result = true;
            //                }
            //            }
            //        }
            //    }
            //    else
            //    {
            //        RigidBody b = e as RigidBody;

            //        if (this.Raycast(b, rayOrigin, rayDirection, out tempNormal, out tempFraction))
            //        {
            //            if (tempFraction < fraction && (raycast == null || raycast(b, tempNormal, tempFraction)))
            //            {
            //                body = b;
            //                normal = tempNormal;
            //                fraction = tempFraction;
            //                result = true;
            //            }
            //        }
            //    }
            //}

            //return result;
        }

 public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
 {
     if (retMethod != null)
     {
         m_rayCastManager.QueueRequest(position, direction, length, retMethod);
     }
 }

 /// <summary>
 /// Sends a ray (definied by start and direction) through the scene (all bodies added).
 /// NOTE: For performance reasons terrain and trianglemeshshape aren't checked
 /// against rays (rays are of infinite length). They are checked against segments
 /// which start at rayOrigin and end in rayOrigin + rayDirection.
 /// </summary>
 public abstract bool Raycast(JVector rayOrigin, JVector rayDirection, RaycastCallback raycast, out RigidBody body, out JVector normal,out float fraction);

        public override bool Raycast(JVector rayOrigin, JVector rayDirection, RaycastCallback raycast, out RigidBody body, out JVector normal, out double fraction)
        {
            body = null; normal = JVector.Zero; fraction = double.MaxValue;

            JVector tempNormal; double tempFraction;
            bool result = false;

            // TODO: This can be done better in CollisionSystemPersistenSAP
            foreach (IBroadphaseEntity e in bodyList)
            {
                if (e is SoftBody)
                {
                    SoftBody softBody = e as SoftBody;
                    foreach (RigidBody b in softBody.VertexBodies)
                    {
                        if (this.Raycast(b, rayOrigin, rayDirection, out tempNormal, out tempFraction))
                        {
                            if (tempFraction < fraction && (raycast == null || raycast(b, tempNormal, tempFraction)))
                            {
                                body = b;
                                normal = tempNormal;
                                fraction = tempFraction;
                                result = true;
                            }
                        }
                    }
                }
                else
                {
                    RigidBody b = e as RigidBody;

                    if (this.Raycast(b, rayOrigin, rayDirection, out tempNormal, out tempFraction))
                    {
                        if (tempFraction < fraction && (raycast == null || raycast(b, tempNormal, tempFraction)))
                        {
                            body = b;
                            normal = tempNormal;
                            fraction = tempFraction;
                            result = true;
                        }
                    }
                }
            }

            return result;
        }

 public override void RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
 {
     if (retMethod != null && actor !=null)
     {
         IntPtr geom;
         if (actor is OdePrim)
             geom = ((OdePrim)actor).prim_geom;
         else if (actor is OdeCharacter)
             geom = ((OdePrim)actor).prim_geom;
         else
             return;
         if (geom == IntPtr.Zero)
             return;
         m_rayCastManager.QueueRequest(geom, position, direction, length, retMethod);
     }
 }

        public void QueueRequest(IntPtr geom, Vector3 position, Vector3 direction, float length, int count, RaycastCallback retMethod)
        {
            ODERayRequest req = new ODERayRequest();
            req.geom = geom;
            req.callbackMethod = retMethod;
            req.length = length;
            req.Normal = direction;
            req.Origin = position;
            req.Count = count;

            m_PendingRequests.Enqueue(req);
        }

 public float getFocus()
 {
     RaycastCallback raycast = new RaycastCallback(RaycastCallback); RigidBody body; JVector normal; float frac;
     bool result = Scene.world.CollisionSystem.Raycast(GenericMethods.FromOpenTKVector(Position), GenericMethods.FromOpenTKVector(PointingDirection),
         raycast, out body, out normal, out frac);
     if (result)
     {
         return frac;
     }
     else
     {
         return zFar;
     }
 }

        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
        {
            if (retMethod != null)
            {
                ODERayRequest req = new ODERayRequest();
                req.actor = null;
                req.callbackMethod = retMethod;
                req.length = length;
                req.Normal = direction;
                req.Origin = position;
                req.Count = 0;
                req.filter = RayFilterFlags.AllPrims;

                m_rayCastManager.QueueRequest(req);
            }
        }

        public bool Raycast(Vector3 origin, Vector3 direction, RaycastCallback callback, out Body body, out Vector3 normal, out float fraction)
        {
            RigidBody rigidBody;
            JVector jitterNormal;

            Jitter.Collision.RaycastCallback jitterCallback = (RigidBody body1, JVector normal1, float fraction1) =>
            {
                return callback((Body)body1.Tag, Conversion.ToTritonVector(ref normal1), fraction1);
            };

            var res = PhysicsWorld.CollisionSystem.Raycast(Conversion.ToJitterVector(ref origin), Conversion.ToJitterVector(ref direction), jitterCallback, out rigidBody, out jitterNormal, out fraction);

            normal = Conversion.ToTritonVector(ref jitterNormal);
            if (rigidBody != null)
            {
                body = (Body)rigidBody.Tag;
            }
            else
            {
                body = null;
            }

            return res;
        }

 public override bool Raycast(JVector rayOrigin, JVector rayDirection, RaycastCallback raycast, out RigidBody body, out JVector normal, out float fraction)
 {
     throw new NotImplementedException();
 }