using System; 
using System.Collections.Generic; 
using System.Linq; 
using Microsoft.Xna.Framework; 
using Microsoft.Xna.Framework.Audio; 
using Microsoft.Xna.Framework.Content; 
using Microsoft.Xna.Framework.GamerServices; 
using Microsoft.Xna.Framework.Graphics; 
using Microsoft.Xna.Framework.Input; 
using Microsoft.Xna.Framework.Media; 
 
namespace MouseClickMovement 
{ 
    /// <summary> 
    /// This is the main type for your game 
    /// </summary> 
    public class Game1 : Microsoft.Xna.Framework.Game 
    { 
        GraphicsDeviceManager graphics; 
        SpriteBatch spriteBatch; 
 
        //Used this for some debugging 
        SpriteFont debugFont; 
        //string debugText; 
 
        //Reserve memory for the mouse states 
        MouseState newMouseState, oldMouseState; 
 
        //Reserve memory for the models 
        Model myModel; 
        Model Ground; 
 
        // Reserve memory to move and rotate the model 
        float myModelRotation; 
        Vector3 myModelPosition; 
         
        //used to calculate the amount of rotation of the camera 
        float totalCamPitch = 0f; 
        float totalCamYaw = 0f; 
 
        //the final camera position 
        Vector3 finalCameraPosition; 
 
        // the camera rotation matrix 
        Matrix cameraRotation; 
 
        public Game1() 
        { 
            graphics = new GraphicsDeviceManager(this); 
            Content.RootDirectory = "Content"; 
            //Gets rid of the jaggy edges of your model 
            graphics.PreferMultiSampling = true; 
            //set mouse vissible 
            IsMouseVisible = true; 
        } 
 
        /// <summary> 
        /// Allows the game to perform any initialization it needs to before starting to run. 
        /// This is where it can query for any required services and load any non-graphic 
        /// related content.  Calling base.Initialize will enumerate through any components 
        /// and initialize them as well. 
        /// </summary> 
        protected override void Initialize() 
        { 
            // TODO: Add your initialization logic here 
 
            base.Initialize(); 
        } 
 
        /// <summary> 
        /// LoadContent will be called once per game and is the place to load 
        /// all of your content. 
        /// </summary> 
        protected override void LoadContent() 
        { 
            // Create a new SpriteBatch, which can be used to draw textures. 
            spriteBatch = new SpriteBatch(GraphicsDevice); 
 
            // TODO: use this.Content to load your game content here 
            debugFont = Content.Load<SpriteFont>("debugFont"); 
 
            //Loads models, import your own and point to the right file locations 
            myModel = Content.Load<Model>("frigate"); 
            Ground = Content.Load<Model>("groundplane"); 
 
            //Sets my model's position 
            myModelPosition = Vector3.Zero; 
            //Rotates my model to the right angle 
            myModelRotation = MathHelper.ToRadians(-90f); 
 
            // Sets initial camera pitch 
            totalCamPitch = -35; 
             
 
        } 
 
        /// <summary> 
        /// UnloadContent will be called once per game and is the place to unload 
        /// all content. 
        /// </summary> 
        protected override void UnloadContent() 
        { 
            // TODO: Unload any non ContentManager content here 
        } 
 
        /// <summary> 
        /// Allows the game to run logic such as updating the world, 
        /// checking for collisions, gathering input, and playing audio. 
        /// </summary> 
        /// <param name="gameTime">Provides a snapshot of timing values.</param> 
        protected override void Update(GameTime gameTime) 
        { 
            // Allows the game to exit 
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) 
                this.Exit(); 
             
 
            oldMouseState = newMouseState; 
            newMouseState = Mouse.GetState(); 
 
            // CAMERA ORBIT CODE 
 
            // sets the camera a little to the back of the model, since my model is small i use a small number in Z
            Vector3 cameraOffset = new Vector3(0, 0, 50); 
 
            //if mouse button is pressed 
            if (newMouseState.LeftButton == ButtonState.Pressed) 
            { 
                //set mouse invissible (not really needed) 
                IsMouseVisible = false; 
 
                //Simply set the total camera pitch and yaw to the difference in mouseposition, use -= to invert 
                totalCamPitch += (oldMouseState.Y - newMouseState.Y); 
                totalCamYaw += (oldMouseState.X - newMouseState.X); 
 
                //Set maximum pith to 89 degree's, read Google gimbal lock if you want to know why. 
                if (totalCamPitch >= 89) 
                { 
                    totalCamPitch = 89; 
                } 
                if (totalCamPitch <= -89) 
                { 
                    totalCamPitch = -89; 
                } 
            } 
            else 
            { 
                // put mouse back on if mouse button is released. 
                IsMouseVisible = true; 
            } 
 
            //sets the camera rotation x and y equal to the total yaw and pitch 
            cameraRotation = Matrix.CreateRotationX(MathHelper.ToRadians(totalCamPitch)) * 
                Matrix.CreateRotationY(MathHelper.ToRadians(totalCamYaw)); 
 
            // sets the camera position. 
            Vector3 cameraRotatedPosition = Vector3.Transform(cameraOffset, cameraRotation); 
 
            // finally sets the camera position behind the player 
            finalCameraPosition = cameraRotatedPosition + myModelPosition; 
 
            //debugText = "TotalCamPitch" + totalCamPitch; 
 
            base.Update(gameTime); 
        } 
 
        /// <summary> 
        /// This is called when the game should draw itself. 
        /// </summary> 
        /// <param name="gameTime">Provides a snapshot of timing values.</param> 
        protected override void Draw(GameTime gameTime) 
        { 
            GraphicsDevice.Clear(Color.CornflowerBlue); 
 
            // TODO: Add your drawing code here 
             
            Matrix[] transforms = new Matrix[myModel.Bones.Count]; 
            myModel.CopyAbsoluteBoneTransformsTo(transforms); 
 
 
            //draw the mymodel with the camera attached to it. 
            foreach (ModelMesh mesh in myModel.Meshes) 
            { 
                foreach (BasicEffect effect in mesh.Effects) 
                { 
                    effect.EnableDefaultLighting(); 
 
                    effect.World = transforms[mesh.ParentBone.Index] 
                        * Matrix.CreateRotationY(myModelRotation) 
                        * Matrix.CreateTranslation(myModelPosition); 
 
                    effect.View = Matrix.CreateLookAt(finalCameraPosition, myModelPosition, Vector3.Up); 
 
                    effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45f), 
                        graphics.GraphicsDevice.Viewport.AspectRatio, 1, 10000); 
                } 
                mesh.Draw(); 
            } 
             
            //draws the ground and anything else with the rotation and position given. 
            ModelDraw(Ground, 0f, new Vector3(0, -100, 0)); 
 
            base.Draw(gameTime); 
        } 
 
 
        /// <summary> 
        /// Draws a model on the screen 
        /// </summary> 
        /// <param name="model">The model</param> 
        /// <param name="rotation">Sets the rotation of the model in the world</param> 
        /// <param name="position">Sets the position of the model in the world</param> 
        private void ModelDraw(Model model,float rotation, Vector3 position) 
        { 
            Matrix[] transforms = new Matrix[model.Bones.Count]; 
            model.CopyAbsoluteBoneTransformsTo(transforms); 
 
            foreach (ModelMesh mesh in model.Meshes) 
            { 
                foreach (BasicEffect effect in mesh.Effects) 
                { 
                    effect.EnableDefaultLighting(); 
                    effect.World = transforms[mesh.ParentBone.Index] * 
                        Matrix.CreateScale(1f) *                         
                        Matrix.CreateRotationY(rotation) * 
                        Matrix.CreateTranslation(position); 
 
                    effect.View = Matrix.CreateLookAt(finalCameraPosition, myModelPosition, Vector3.Up); 
 
                    effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45f), 
                        graphics.GraphicsDevice.Viewport.AspectRatio, 1, 10000); 
                } 
                mesh.Draw(); 
            } 
 
        } 
    } 
}