public void TestExplicitOperator()
        {
            var rad = new Radian(1.0f);

              Assert.AreEqual((Radian)1.0f, rad);
              Assert.AreEqual(1.0f, (float)rad);
        }

 public virtual void SetCameraOrientation(Radian roll, Radian yaw, Radian pitch)
 {
     _lastOrientation = new Quaternion(roll, Vector3.UNIT_Z)
         * new Quaternion(yaw, Vector3.UNIT_Y)
         * new Quaternion(pitch, Vector3.UNIT_X);
     CameraOrientation = _lastOrientation;
 }

		public override void MakeOrthoMatrix( Radian fovy, Real aspectRatio, Real near, Real far, out Matrix4 dest,
		                                      bool forGpuPrograms )
		{
			var thetaY = fovy/2.0f;
			var tanThetaY = Utility.Tan( thetaY );
			var tanThetaX = tanThetaY*aspectRatio;

			var half_w = tanThetaX*near;
			var half_h = tanThetaY*near;

			var iw = 1.0f/( half_w );
			var ih = 1.0f/( half_h );
			Real q = 0.0f;

			if ( far != 0 )
			{
				q = 1.0/( far - near );
			}

			dest = Matrix4.Zero;
			dest.m00 = iw;
			dest.m11 = ih;
			dest.m22 = q;
			dest.m23 = -near/( far - near );
			dest.m33 = 1;

			if ( forGpuPrograms )
			{
				dest.m22 = -dest.m22;
			}
		}

        public override void MakeOrthoMatrix(Radian fov, Real aspectRatio, Real near, Real far, out Matrix4 dest, bool forGpuPrograms)
        {
            float thetaY = Utility.DegreesToRadians(fov / 2.0f);
            float tanThetaY = Utility.Tan(thetaY);
            float tanThetaX = tanThetaY * aspectRatio;

            float halfW = tanThetaX * near;
            float halfH = tanThetaY * near;

            var w = 1.0f / (halfW);
            var h = 1.0f / (halfH);
            var q = 0.0f;

            if (far != 0)
            {
                q = 1.0f / (far - near);
            }

            dest = Matrix4.Zero;
            dest.m00 = w;
            dest.m11 = h;
            dest.m22 = q;
            dest.m23 = -near / (far - near);
            dest.m33 = 1;

            if (forGpuPrograms)
            {
                dest.m22 = -dest.m22;
            }
        }

        /**
         * @param relativePositionToCameraTarget Default camera position with respecto to camera target
         * @param autoResetTime If greater than zero the camera will be resetted to its initial position after the amount of seconds specified.
         * @param resetDistance true for correcting the camera distance to the target when resetting. If false, the camera will maintaing the current distance to target.
         * @param resetRotationFactor Speed factor for correcting the camera rotation when resetting.
         * @param offset Offset applied to the center of the sphere.
         */
        public SphericCameraMode(CameraControlSystem cam
             , Vector3 relativePositionToCameraTarget
             , float outerSphereRadius
            , Vector3 offset
             , Vector3 fixedAxis, float innerSphereRadius = 0.0f
             , float autoResetTime = 3.0f
             , bool resetDistance = true
             , float resetRotationFactor = 1.0f)
            : base(cam)
        {
            _relativePositionToCameraTarget = relativePositionToCameraTarget;
            _outerSphereRadius = outerSphereRadius;
            _innerSphereRadius = innerSphereRadius;
            _autoResetTime = autoResetTime;
            _resetDistance = resetDistance;
            _resetRotationFactor = resetRotationFactor;
            _offset = offset;
            _fixedAxis = fixedAxis;
            _resseting = false;
            _LastRessetingDiff = new Radian(2.0f * Mogre.Math.PI);

            if (innerSphereRadius > outerSphereRadius) { throw new Exception("Inner radious greater than outer radious"); }
            if (innerSphereRadius > relativePositionToCameraTarget.Length
                || outerSphereRadius < relativePositionToCameraTarget.Length) {
                throw new Exception("relativePositionToCameraTarget param value not valid.");
            }
        }

 /// <summary>
 /// Constructor to create a new Euler Angle struct from angle values. 
 /// The rotation will be applied in the order Yaw-Pitch- Roll, which are related to the axis order Y-X-Z. 
 /// </summary>
 public Euler(Radian yaw, Radian pitch, Radian roll)
 {
     mYaw = yaw;
     mPitch = pitch;
     mRoll = roll;
     mChanged = true;
     mCachedQuaternion = Quaternion.IDENTITY;
 }

        /// <summary>
        /// Creates a Rotater. This removes any existing nlerpers and rotaters attached to the lthing.
        /// </summary>
        /// <param name="owner">What lthing are we affecting?</param>
        /// <param name="duration">How long as we going to rotate?</param>
        /// <param name="angle">Rotation angle</param>
        /// <param name="mode">Rotation axis mode</param>
        /// <returns>The new rotater</returns>
        public Rotater CreateRotater(LThing owner, float duration, Radian angle, RotaterAxisMode mode)
        {
            RemoveRotater(owner);

            Rotater newRotater = new Rotater(owner, duration, angle, mode);
            Rotaters.TryAdd(owner, newRotater);
            return newRotater;
        }

 public OrbitalWithMouseCameraMode(CameraControlSystem cam
      , MOIS.MouseButtonID activateButton
      , Radian initialHorizontalRotation
      , Radian initialVerticalRotation, float initialZoom = 1)
     : base(cam, initialHorizontalRotation, initialVerticalRotation, initialZoom)
 {
     _activateButton = activateButton;
 }

 public Sprite(Texture texture)
 {
     Texture = texture;
     Color = Color.White;
     Position = Vector2.Zero;
     Scale = new Vector2(1.0f, 1.0f);
     Rotation = new Radian(0.0f);
     SourceRect = new Rectangle(0, 0, Texture.Width, Texture.Height);
 }

        public void TestEquatable()
        {
            var rad = new Radian(1.0f);
              var f = 1.0f;

              Assert.IsTrue(rad.Equals(rad));
              Assert.IsTrue(rad.Equals(f));
              Assert.IsFalse(rad.Equals(null));
        }

			public override void SetDesiredVelocity( Radian velocity, float maxTorque )
			{
				if( joint.jointID == dJointID.Zero )
					return;

				Ode.dJointSetHingeParam( joint.jointID, Ode.dJointParams.dParamVel,
					joint.Body1.Static ? velocity : -velocity );
				Ode.dJointSetHingeParam( joint.jointID, Ode.dJointParams.dParamFMax, maxTorque );
			}

        public override void Update(int elapsed)
        {
            float rotateFactor = elapsed * 0.125f / 1000.0f;
            var yawAmount = new Radian((0.4f + 0.25f * MathUtils.Sin(new Radian(this.game.TotalGameTime / 15040))) * rotateFactor);
            Yaw(yawAmount);
            var pitchAmount = new Radian((0.35f + 0.212f * MathUtils.Cos(new Radian(this.game.TotalGameTime / 38040))) * rotateFactor);

            float moveFactor = elapsed * 27.5f / 1000.0f;
            MoveRelative(Vector3.UnitZ * moveFactor);
        }

        public virtual void SetCameraRelativePosition(Vector3 posRelativeToCameraTarget
            , Radian roll, Radian yaw, Radian pitch)
        {
            RelativePosToTarget = posRelativeToCameraTarget;

            _rotationOffset = new Quaternion(roll, Vector3.UNIT_Z)
                            * new Quaternion(yaw, Vector3.UNIT_Y)
                            * new Quaternion(pitch, Vector3.UNIT_X);

            InstantUpdate();
        }

        protected override void Rotate(Radian yawAngle, Radian pitchAngle)
        {
            base.Rotate(yawAngle,pitchAngle);

            var debugOverlay = OverlayManager.Singleton.GetByName("Core/DebugOverlay");
            debugOverlay.Show();

            var myCurr = OverlayManager.Singleton.GetOverlayElement("Core/CurrFps");

            myCurr.Caption = State.CameraManager.RenderWindow.LastFPS.ToString();
        }

        /// <summary>
        /// USE THE LThingHelperManager FOR THIS!
        /// </summary>
        public Rotater(LThing thingToRotate, float duration, Radian angle, Vector3 axis, RotaterAxisMode mode = RotaterAxisMode.Explicit)
        {
            this.thing = thingToRotate;
            this.duration = duration;
            this.angle = angle;
            this.axis = axis;
            this.mode = mode;

            orient = new Quaternion();

            PhysicsMain.PreSimulate += PreSimulate;
        }

        public void Radian_Wrap_Test()
        {
            var radian = new Radian(MathUtils.PI);
            var wrapAngle = new Radian(MathUtils.PI);
            Assert.AreEqual(new Radian(0.0f), radian.Wrap(wrapAngle));

            radian = new Radian(MathUtils.PI / 4);
            Assert.AreEqual(new Radian(MathUtils.PI / 4), radian.Wrap(wrapAngle));

            radian = new Radian(-MathUtils.PI / 4);
            Assert.AreEqual(new Radian(MathUtils.PI * 3 / 4), radian.Wrap(wrapAngle));
        }

        public override void Rotate(Radian yawAngle, Radian pitchAngle)
        {
            var xAxis = new Vector3();
            var yAxis = new Vector3();
            var zAxis = new Vector3();

            Body.Orientation.ToAxes(out xAxis, out yAxis, out zAxis);
            //            var yaw = new Quaternion(yawAngle, Vector3.UNIT_Y);
            //            var pitch = new Quaternion(pitchAngle, xAxis);

            var data = Body.UserData as PhysicsControlData;
            data.Torque += (yAxis * yawAngle.ValueRadians + xAxis * pitchAngle.ValueRadians)/5.0f;
        }

        static Quaternion GlobalEulerToQuat(Radian rotX, Radian rotY, Radian rotZ)
        {
            Quaternion q1 = new Quaternion(),
                       q2 = new Quaternion(),
                       q3 = new Quaternion(),
                       q = new Quaternion();
            q1.FromAngleAxis(rotX, Vector3.UNIT_X);
            q2.FromAngleAxis(rotY, Vector3.UNIT_Y);
            q3.FromAngleAxis(rotZ, Vector3.UNIT_Z);

            // global axes
            q = q3 * q2 * q1;
            return q;
        }

        public void Radian_Constructor_Test()
        {
            var r = new Radian();
            Assert.AreEqual(0.0f, r.Value);

            r = new Radian(3.14f);
            Assert.AreEqual(3.14f, r.Value);

            var r2 = new Radian(r);
            Assert.AreEqual(r.Value, r2.Value);

            var r3 = r;
            Assert.AreEqual(r.Value, r3.Value);
        }

        public Kart(ThingBlock block, ThingDefinition def)
            : base(block, def)
        {
            DefaultMaxSpeed = MaxSpeed = def.GetFloatProperty("maxspeed", 180f);
            MaxReverseSpeed = def.GetFloatProperty("maxreversespeed", 4f);

            MaxSpeedSquared = MaxSpeed * MaxSpeed;
            MaxReverseSpeedSquared = MaxReverseSpeed * MaxReverseSpeed;

            IsInAir = false;

            FrontDriftAngle = new Degree(def.GetFloatProperty("FrontDriftAngle", 46)).ValueRadians;
            BackDriftAngle = new Degree(def.GetFloatProperty("BackDriftAngle", 55)).ValueRadians;
            DriftTransitionAngle = new Degree(def.GetFloatProperty("DriftTransitionAngle", 40));
        }