Engine.cs

Go to the documentation of this file.

#region Using Statements
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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
using visLU.Effects;
#endregion

namespace visLU
{
    class Engine : Microsoft.Xna.Framework.DrawableGameComponent
    {
        #region Variables
        //##########################################################################################

        private Game game;
        private GraphicsDevice device;
        private SpriteBatch spriteBatch;
        private SpriteFont spriteBatchFont;

        private Data input;
        private RenderTarget2D sceneTarget;
        private Camera[] cameras;
        private Viewport viewport;        
       
        //__________________________________________________________________________________________
        #endregion

        #region Properties
        public Data Input
        {
            set { input = value; }
            get { return input; }
        }
        #endregion

        #region Constructor





        public Engine(Game _game) : base(_game)
        {
            game = _game;

          
            input = new Data(GameProperties.Instance.dataDir + GameProperties.Instance.dataFilename, _game);
            if(input == null)
                throw new InvalidOperationException("Data was not loaded.");
            
            cameras = Game.Services.GetService(typeof(Camera[])) as Camera[];
            if (cameras == null)
                throw new InvalidOperationException("Camera  Service not found.");

            Console.WriteLine("ENGINE STARTED");

        }
        #endregion

        #region Methods
        //##########################################################################################

        #region Initialize()
        //-----------------------------------INITIALIZE()-------------------------------------------

        public override void Initialize()
        {

            spriteBatch = Game.Services.GetService(typeof(SpriteBatch)) as SpriteBatch;
            if (spriteBatch == null)
                throw new InvalidOperationException("SpriteBatch Service not found"); 

            device = Game.GraphicsDevice;

            //init cameras

            //cameras[0] -> 3d view
            cameras[0].CameraPosition = new Vector3(1.5f, 1.5f, 2.0f);
            //cameras[0].CameraTarget = new Vector3(0.5f, 0.5f, 0.0f);
            cameras[0].CameraTarget = GameProperties.Instance.dataOrigin;
            cameras[0].CameraUpVector = Vector3.Left;
            #region debug
            //cameras[0].CameraPosition = new Vector3(0.0f, 0.0f, 5.0f); 
            //cameras[0].CameraTarget = new Vector3(0.0f, 0.0f, 0.0f);
            #endregion

            //cameras[1] -> top view
            cameras[1].CameraPosition = new Vector3(0.0f, 2.0f, 0.0f);
            //cameras[1].CameraTarget = new Vector3(0.5f, 0.0f, 0.0f);
            cameras[0].CameraTarget = GameProperties.Instance.dataOrigin;
            cameras[1].CameraUpVector = Vector3.UnitZ;

            //cameras[2] -> side view
            cameras[2].CameraPosition = new Vector3(2.0f, 0.0f, 0.0f);
            //cameras[2].CameraTarget = new Vector3(0.0f, 0.5f, 0.0f);
            cameras[0].CameraTarget = GameProperties.Instance.dataOrigin;
            cameras[2].CameraUpVector = Vector3.Up;

            //cameras[3] -> front view
            cameras[3].CameraPosition = new Vector3(0.0f, 0.0f, 2.0f);
            //cameras[3].CameraTarget = new Vector3(0.5f, 0.5f, 0.0f);
            cameras[0].CameraTarget = GameProperties.Instance.dataOrigin;
            cameras[3].CameraUpVector = Vector3.Up;
            
            //init data
            input.Initialize();
            
            base.Initialize();
        }
        //__________________________________________________________________________________________
        #endregion

        #region LoadContent()
        //-----------------------------------LOAD_CONTENT()-----------------------------------------
        protected override void LoadContent()
        {
            spriteBatchFont = Game.Content.Load<SpriteFont>("Fonts\\spriteFont1");

            viewport = GraphicsDevice.Viewport;
            GameProperties.Instance.XNAViewport = viewport; //: resize when in form resized

            //texture filter
            initializeTextureFilter();

            //define RenderTarget
            //device.PresentationParameters.MultiSampleType = MultiSampleType.NonMaskable;
            device.PresentationParameters.MultiSampleType = device.DepthStencilBuffer.MultiSampleType;
            sceneTarget = (RenderTarget2D)device.GetRenderTarget(0);  
            //device.PresentationParameters.BackBufferHeight, 1, device.PresentationParameters.BackBufferFormat); 
            base.LoadContent();

        }


        //__________________________________________________________________________________________
        #endregion

        #region UnloadContent()
        //-----------------------------------UNLOAD_CONTENT()---------------------------------------

        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
            base.UnloadContent();
        }

        //__________________________________________________________________________________________
        #endregion

        #region Update()
        //-----------------------------------UPDATE()-----------------------------------------------

        public override void Update(GameTime gameTime)
        {
 
            //load data
            if (GameProperties.Instance.engineState.loadData)
            {
                input = new Data(GameProperties.Instance.dataDir + GameProperties.Instance.dataFilename, game);
                input.Initialize(); 
                if (!GameProperties.Instance.fullscreen)
                GameProperties.Instance.engineState.loadData = false;

            }

            //set camera
            if (GameProperties.Instance.engineState.updateCamera)
            {
                int currentView;
                switch (GameProperties.Instance.viewMode)
                {
                    case ViewMode.VolView: //single 3d view

                        currentView = 0;
                        break;

                    case ViewMode.TopView: //single top view
                        currentView = 1;
                        break;

                    case ViewMode.SideView: //single side view
                        currentView = 2;
                        break;

                    case ViewMode.FrontView: //single front view
                        currentView = 3;
                        break;

                    default:
                        currentView = 0;
                        break;

                }

                //set parameters to draw the correct scene view
                input.Camera = cameras[currentView];
                input.CurrentCamera = currentView;
                if (!GameProperties.Instance.fullscreen)
                GameProperties.Instance.engineState.updateCamera = false;

            }

            //update input 
            if (GameProperties.Instance.engineState.updateData)
            {
                input.Update(gameTime);
                if (!GameProperties.Instance.fullscreen)
                GameProperties.Instance.engineState.updateData = false;
            }

            base.Update(gameTime);
        }

        //__________________________________________________________________________________________
        #endregion

        #region Draw()
        //-----------------------------------DRAW()-------------------------------------------------

        public override void Draw(GameTime gameTime)
        {
           
            if (GameProperties.Instance.engineState.drawData)
            {
                device.RenderState.DepthBufferEnable = true;
                device.RenderState.DepthBufferWriteEnable = true;
                // turn Backface Culling off
                device.RenderState.CullMode = CullMode.None;
                device.SetRenderTarget(0, sceneTarget);

                try
                {
                    device.Clear(Color.Black);
                    device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                //draw view mode
                drawText(gameTime);
                //draw input 
                input.Draw(gameTime);
                //RenderScene(gameTime);

                if(!GameProperties.Instance.fullscreen)
                  GameProperties.Instance.engineState.drawData = false;
            }

            base.Draw(gameTime);

        }

        #region Draw Scene
        /*private void RenderScene(GameTime gameTime)
        {
           

            device.SetRenderTarget(0, sceneTarget);
            try
            {
                device.Clear(Color.Black);
                device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            
            input.Draw(gameTime);
              

            #region depricated
            //set camera
            int currentView;
            switch (GameProperties.Instance.viewMode)
            {
                case ViewMode.VolView: //single 3d view

                    currentView = 0;
                    break;

                case ViewMode.TopView: //single top view
                    currentView = 1;
                    break;

                case ViewMode.SideView: //single side view
                    currentView = 2;
                    break;

                case ViewMode.FrontView: //single front view
                    currentView = 3;
                    break;

                default:
                    currentView = 0;
                    break;

            }

            //set parameters to draw the correct scene view
            input.Camera = cameras[currentView];
            input.CurrentCamera = currentView;
            //input.shader.SetEffectParameter(cameras[currentView].ViewProjection);
            #endregion

        } */

        //__________________________________________________________________________________________
        #endregion

        private void drawText(GameTime gameTime)
        {
            GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);

            switch ((int)GameProperties.Instance.viewMode)
            {
                case 0:
                    spriteBatch.DrawString(spriteBatchFont, ("3D View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
                case 1:
                    spriteBatch.DrawString(spriteBatchFont, ("Top View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
                case 2:
                    spriteBatch.DrawString(spriteBatchFont, ("Side View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
                case 3:
                    spriteBatch.DrawString(spriteBatchFont, ("Front View"),
                    new Vector2(50,50), Color.Silver);
                    break;
                default:
                    spriteBatch.DrawString(spriteBatchFont, ("3d View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
            }

            spriteBatch.End();
            GraphicsDevice.RenderState.DepthBufferEnable = true;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = true;
        }
        //__________________________________________________________________________________________
        #endregion

        #region additional Methods
        //##########################################################################################


        #region Initialize Texture Filter



        private void initializeTextureFilter()
        {
            /*

                device.SamplerStates[0].MipFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MipFilter");
                device.SamplerStates[0].MinFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MinFilter");
                device.SamplerStates[0].MagFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MagFilter");
             */

            
            if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMipMapLinear == true)
            {
                device.SamplerStates[0].MipFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MipFilter");
            }

            if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMinifyAnisotropic == true)
            {
                device.SamplerStates[0].MinFilter = TextureFilter.Anisotropic;
                Console.WriteLine("using Anisotropic MinFilter");
            }
            else if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMinifyLinear == true)
            {
                device.SamplerStates[0].MinFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MinFilter");
            }

            if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMagnifyAnisotropic == true)
            {
                device.SamplerStates[0].MagFilter = TextureFilter.Anisotropic;
                Console.WriteLine("using Anisotropic MagFilter");
            }
            else if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMagnifyLinear == true)
            {
                device.SamplerStates[0].MagFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MagFilter");
            }
            
        }

        #endregion

        private void ActivateAlphaBlending()
        {
            device.RenderState.AlphaBlendEnable = true;
            device.RenderState.SourceBlend = Blend.SourceAlpha;
            device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
        }

        private void DeactivateAlphaBlending()
        {
            device.RenderState.AlphaBlendEnable = false;
            device.RenderState.SourceBlend = Blend.One;
            device.RenderState.DestinationBlend = Blend.Zero;
        }

        private void setNonTextureFilter()
        {
            device.SamplerStates[0].MipFilter = TextureFilter.None;
            device.SamplerStates[0].MinFilter = TextureFilter.None;
            device.SamplerStates[0].MagFilter = TextureFilter.None;
        }


        //__________________________________________________________________________________________

        #endregion        

  
       #endregion
    }
}