protected override bool ExampleApp_FrameStarted(FrameEvent evt)
        {
            if(base.ExampleApp_FrameStarted(evt) == false )
                return false;

            if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_N ) )
            {
                pThrusters.SetDefaultDimensions( fDefDim + 0.25f, fDefDim + 0.25f );
                fDefDim += 0.25f;
            }

            if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_M ) )
            {
                pThrusters.SetDefaultDimensions( fDefDim - 0.25f, fDefDim - 0.25f );
                fDefDim -= 0.25f;
            }

            if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_H ) )
            {
                pThrusters.GetEmitter( 0 ).ParticleVelocity = fDefVel + 1;
                pThrusters.GetEmitter( 1 ).ParticleVelocity = fDefVel + 1;
                fDefVel += 1;
            }

            if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_J ) && !( fDefVel < 0.0f ) )
            {
                pThrusters.GetEmitter( 0 ).ParticleVelocity = fDefVel - 1;
                pThrusters.GetEmitter( 1 ).ParticleVelocity = fDefVel - 1;
                fDefVel -= 1;
            }

            return true;
        }

        /// <summary>
        /// We can't use constraints because otherwise we wouldn't be able to do loops.
        /// </summary>
        void PreSimulate(DiscreteDynamicsWorld world, FrameEvent evt)
        {
            // if the kart's gone, then we can get rid of this handler too
            if (kart == null || kart.Vehicle.IsDisposed) {
                Detach();
                return;
            }
            // don't self-right if we're paused
            else if (Pauser.IsPaused)
                return;

            // so first we get the kart's orientation
            // then we basically get its local Y axis and average it with the global Y axis to make more of a smooth transition
            Vector3 locY = kart.ActualOrientation.YAxis;

            // first of all, if we're self righted enough, we can get rid of this handler
            if (locY.DirectionEquals(Vector3.UNIT_Y, closeEnoughToUp)) { // 3 degrees
                //Detach();
                return;
            }

            // stop it spinning
            kart.Body.AngularVelocity = Vector3.ZERO;

            // update its rotation to point upwards
            var quat = kart.ActualOrientation;
            // make the x and z factors smaller, so that all that's left at the end is the Y pointing upwards
            quat.x *= 0.92f;
            quat.z *= 0.92f;
            quat.Normalise();

            // then update the body's transform
            kart.Body.SetOrientation(quat);
        }

 public override void Update(FrameEvent evt)
 {
     Animate(evt);
     //Here goes the collision detection with the player
     // (ignore until week 8) ...
     base.Update(evt);
 }

        bool FrameStarted(FrameEvent evt)
        {
            if (PhysicsMain.DrawLines) {

                MogreDebugDrawer.Singleton.Build();
            }
            return true;
        }

        protected override bool ExampleApp_FrameStarted(FrameEvent evt)
        {
            // Rotate fountains
            mFountainNode.Yaw(evt.timeSinceLastFrame * 30);

            // Call default
            return base.ExampleApp_FrameStarted(evt);
        }

        bool Skeletal_FrameStarted(FrameEvent evt)
        {
            for (int i = 0; i < NUM_ROBOTS; ++i)
            {
                _animState[i].AddTime(evt.timeSinceLastFrame * _animationSpeed[i]);
            }

            return true;
        }

        public virtual void Update(FrameEvent frameEvent)
        {
            //if (State.MainWindow.RenderWindowFocused == false) return;

            State.InputManger.Capture();

            Rotate(YawAngle(), PitchAngle());

            Translate(GetTranslation() * frameEvent.timeSinceLastFrame);
        }

        public virtual void Update(FrameEvent evt)
        {
            // Projectile collision detection goes here
            // (ignore until week 8) ...

            if (!remove && time.Milliseconds > maxTime)
            {
                Dispose();
                remove = true;
            }
        }

        protected override bool UpdateCamera(FrameEvent evt)
        {
            base.UpdateCamera(evt);

            Vector3 displacement = CameraNode._getDerivedPosition() - TargetNode.Position;

            TargetNode.Orientation = CameraNode.Orientation;
            TargetNode.Translate(displacement * _cameraTightness * evt.timeSinceLastFrame);

            return true;
        }

        protected override bool ExampleApp_FrameStarted(FrameEvent evt)
        {
            if(base.ExampleApp_FrameStarted(evt) == false )
                return false;

            // Rotate fountains
            mFountainNode.Yaw(new Degree(evt.timeSinceLastFrame * 30));

            // Call default
            return true;
        }

        protected override bool ExampleApp_FrameStarted(FrameEvent evt)
        {
            if(base.ExampleApp_FrameStarted(evt) == false )
                return false;

            foreach (AnimationState ani in this.mAnimStateList)
            {
                ani.AddTime(evt.timeSinceLastFrame);
            }

            return true;
        }

        public override void Update(FrameEvent frameEvent)
        {
            if (!State.MainWindow.IsRenderWindowFocused) return;

            State.InputManger.Capture();

            bool leftButtonDown = State.InputManger.MouseState.ButtonDown(MouseButtonID.MB_Left);
            bool rightButtonDown = State.InputManger.MouseState.ButtonDown(MouseButtonID.MB_Right);

            bool ctrl = State.InputManger.InputKeyboard.IsKeyDown(KeyCode.KC_LCONTROL);
            bool shift = State.InputManger.InputKeyboard.IsKeyDown(KeyCode.KC_LSHIFT);
            bool alt = State.InputManger.InputKeyboard.IsKeyDown(KeyCode.KC_LMENU);

            Vector3 amount = GetTranslation()*frameEvent.timeSinceLastFrame;

            if (ctrl && shift)
            {
                State.SelectedNode.Rotate(amount.x/5.0f, amount.z/5.0f);
                State.SelectedNode.Rotate(5.0f*YawAngle(), 5.0f*PitchAngle());
                //State.SelectedNode.MoveForward(amount);
            }
            else if (ctrl)
            {
                State.SelectedNode.Translate(amount);
                State.SelectedNode.Translate(10.0f*new Vector3(-YawAngle().ValueRadians, 0, PitchAngle().ValueRadians));
            }
            else if (shift)
            {
                State.SelectedNode.Translate(new Vector3(amount.x, amount.z, amount.y));
                State.SelectedNode.Translate(10.0f*new Vector3(-YawAngle().ValueRadians, -PitchAngle().ValueRadians, 0));
            }
            else if (alt)
            {
                State.SelectedNode.Scale = 1 + amount.z/2;
                State.SelectedNode.Scale = 1 + 2*PitchAngle().ValueRadians;
            }
            else if (leftButtonDown)
            {
                Translate(amount);
                Rotate(YawAngle(), PitchAngle());
            }
            else
            {
                Translate(amount);
            }

            //Joystick rotation
            if (State.InputManger.InputJoyStick != null)
                Rotate(RotateJoystickAxis(3, true), RotateJoystickAxis(2, true));

            //base.Update(frameEvent);
            State.MainWindow.UpdatePropertyTreeGrid();
        }

        /// <summary>
        /// Apply a force every frame (can probably reduce this) to the player
        /// </summary>
        bool FrameStarted(FrameEvent evt)
        {
            // if someone is typing something into a text box, we don't want to move around!
            if (LKernel.Get<InputSwallowerManager>().IsSwallowed())
                return true;

            var player = LKernel.Get<PlayerManager>().MainPlayer;
            if (player != null) {
                player.Actor.AddForceAtLocalPos(keyboardHandler.MovementVector * player.Kart.MoveSpeed, Vector3.ZERO);
            }

            return true;
        }

 /// <summary>
 /// update all of our animations, but only if we aren't paused
 /// </summary>
 bool FrameStarted(FrameEvent evt)
 {
     if (!Pauser.IsPaused) {
         foreach (AnimationBlender b in blenders) {
             if (!b.Source.HasEnded)
                 b.AddTime(evt.timeSinceLastFrame);
         }
         foreach (AnimationState state in states) {
             if (!state.HasEnded)
                 state.AddTime(evt.timeSinceLastFrame);
         }
     }
     return true;
 }

        protected override bool ExampleApp_FrameStarted(FrameEvent evt)
        {
            // Change curvature / tiling
            // Delay timer to stop too quick updates of curvature
            float timeDelay = 0;

            bool updateSky;
            updateSky = false;

            if(!base.ExampleApp_FrameStarted(evt))
                return false;

            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_H) && timeDelay <= 0)
            {
                mCurvature += 1;
                timeDelay = 0.1f;
                updateSky = true;
            }
            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_G) && timeDelay <= 0)
            {
                mCurvature -= 1;
                timeDelay = 0.1f;
                updateSky = true;
            }

            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_U) && timeDelay <= 0)
            {
                mTiling += 1;
                timeDelay = 0.1f;
                updateSky = true;
            }
            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_Y) && timeDelay <= 0)
            {
                mTiling -= 1;
                timeDelay = 0.1f;
                updateSky = true;
            }

            if (timeDelay > 0)
                timeDelay -= evt.timeSinceLastFrame;

            if (updateSky)
            {
                sceneMgr.SetSkyDome(true, "Examples/CloudySky", mCurvature, mTiling);
            }

            return true;
        }

        bool FrameStarted(FrameEvent evt)
        {
            if (elapsed >= 0.1f) {
                elapsed = 0;

                var mainPlayer = LKernel.GetG<PlayerManager>().MainPlayer;

                if (label.Visible && LKernel.GetG<LevelManager>().IsValidLevel && mainPlayer != null && mainPlayer.Kart != null && !mainPlayer.Kart.Body.IsDisposed) {
                    Kart kart = mainPlayer.Kart;

                    Mogre.Vector3 axisA = new Mogre.Vector3(0,1,0);
                    Quaternion quat1;
                    quat1 = kart.ActualOrientation.XAxis.GetRotationTo(axisA);

                    label.Text = string.Format(
            @"Speed: {0}
            Turn angle: {1}, {2}, {3}, {4}
            Linear velocity: {5}, {6}
            Wheel friction: {7}, {8}
            Skid info: {9}, {10}
            Brake? {11}
            AccelMultiplier: {12}
            IntOr: {13}
            Gravity: {14}
            KartDriftState: {15} , WheelDriftState: {16}
            Player Pos: {17} X, {18} Y, {19} Z
            Quat: {20}
            Quat W: {21}",
                        kart.VehicleSpeed,
                        Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(0)), Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(1)),
                        Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(2)), Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(3)),
                        kart.Body.LinearVelocity.Length, kart.Body.LinearVelocity,
                        kart.Vehicle.GetWheelInfo(0).FrictionSlip, kart.Vehicle.GetWheelInfo(2).FrictionSlip,
                        kart.Vehicle.GetWheelInfo(0).SkidInfo, kart.Vehicle.GetWheelInfo(2).SkidInfo,
                        kart.WheelFL.IsBrakeOn,
                        kart.Acceleration,
                        kart.InterpolatedOrientation,
                        kart.Body.Gravity,
                        kart.DriftState, kart.WheelFL.DriftState,
                        mainPlayer.NodePosition.x, mainPlayer.NodePosition.y, mainPlayer.NodePosition.z,
                        quat1,
                        quat1.w*180/Math.PI);
                }
            }
            elapsed += evt.timeSinceLastFrame;
            return true;
        }

        /// <summary>
        /// After every frame, adjust the volumes appropriately
        /// </summary>
        bool FrameEnded(FrameEvent evt)
        {
            if (Pauser.IsPaused)
                return true;

            progress += evt.timeSinceLastFrame;
            // if the progress is over the duration, or sounds don't exist, we've finished
            if (progress > duration || soundToFadeOut == null || soundToFadeIn == null) {
                Detach();
                return true;
            }

            // adjust volumes relatively
            float relProgress = progress / duration;
            soundToFadeOut.Volume = 1f - (relProgress * initialFadeOutVolume);
            soundToFadeIn.Volume = relProgress * targetFadeInVolume;

            return true;
        }

		/// <summary>
		/// Count down!
		/// </summary>
		private bool FrameStarted(FrameEvent evt) {
			if (!Pauser.IsPaused) {
				if (!three && elapsed >= INITIAL_DELAY) {
					Invoke(RaceCountdownState.Three);
					three = true;
					elapsed = INITIAL_DELAY;
				}
				else if (!two && elapsed >= INITIAL_DELAY + 1) {
					Invoke(RaceCountdownState.Two);
					two = true;
					elapsed = INITIAL_DELAY + 1;
				}
				else if (!one && elapsed >= INITIAL_DELAY + 2) {
					Invoke(RaceCountdownState.One);
					one = true;
					elapsed = INITIAL_DELAY + 2;
				}
				else if (!go && elapsed >= INITIAL_DELAY + 3) {
#if ENABLE_COUNTDOWN
					foreach (var player in LKernel.Get<PlayerManager>().Players) {
						// first make sure all of the karts can't be controlled
						player.IsControlEnabled = true;
					}
                    LKernel.GetG<ItemManager>().spawning = true;
#endif

					Invoke(RaceCountdownState.Go);
					go = true;
					elapsed = INITIAL_DELAY + 3;
				}
				else if (!oneSecondAfterGo && elapsed >= INITIAL_DELAY + 4) {
					Invoke(RaceCountdownState.OneSecondAfterGo);
					oneSecondAfterGo = true;

					// don't need to keep checking the time any more
					Detach();
				}

				elapsed += evt.timeSinceLastFrame;
			}
			return true;
		}

        protected override void HandleInput(FrameEvent evt)
        {
            base.HandleInput(evt);

            // Show/Hide information

            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_F1))
            {
                showInformation = !showInformation;

            }

            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_1) && !(inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_LSHIFT) || inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_RSHIFT)))
            {
                manager.TimeMultiplier = 1.0f;
            }
            if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_1) && (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_LSHIFT) || inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_RSHIFT)))
            {
                manager.TimeMultiplier = -1.0f;
            }
        }

        /// <summary>
        /// Change the width of the jet engine based on our current speed
        /// </summary>
        bool FrameStarted(FrameEvent evt)
        {
            // crop it to be between 0 and 1
            float relSpeed = _vehicle.CurrentSpeedKmHour / topSpeedKmHour;

            if (relSpeed < 0.5f && !idleState)
            {

                new SoundCrossfader(fullSound, idleSound, 1.65f, 2.0f);

                idleState = true;
            }
            if (relSpeed > 0.5f && idleState)
            {
                new SoundCrossfader(idleSound, fullSound, 1.45f, 2.0f);

                idleState = false;
            }

            return true;
        }