public void DrawReflectionMap(GameCamera.FreeCamera camera, float time, LightsAndShadows.Shadow shadow, LightsAndShadows.Light light, QuadTree tree)
        {
            Plane reflectionPlane = CreatePlane(waterHeight - 0.5f, new Vector3(0, -1, 0), camera.reflectionViewMatrix, true);
            //device.ClipPlanes[0].Plane = reflectionPlane;
            //device.ClipPlanes[0].IsEnabled = true;
            //device.SetRenderTarget(0, reflectionRenderTarget);

            effect.Parameters["ClipPlane0"].SetValue(new Vector4(reflectionPlane.Normal, reflectionPlane.D));
            //effect.Parameters["ClipPlane0"].SetValue(new Vector4(-reflectionPlane.Normal, -reflectionPlane.D));

            effect.Parameters["Clipping"].SetValue(true);    // Allows the geometry to be clipped for the purpose of creating a refraction map
            device.SetRenderTarget(reflectionRenderTarget);

            device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
            sky.DrawSkyDome(camera);
               // tree.Draw(camera, time, shadow, light);

            //device.ClipPlanes[0].IsEnabled = false;
            effect.Parameters["Clipping"].SetValue(false);

            //device.SetRenderTarget(0, null);
            device.SetRenderTarget(null);

            reflectionMap = reflectionRenderTarget;
            //System.IO.Stream ss = System.IO.File.OpenWrite("C:\Test\Reflection.jpg");
            //reflectionRenderTarget.SaveAsJpeg(ss, 500, 500);
            //ss.Close();
        }

 public virtual void Draw(GameCamera camera)
 {
     foreach (Particle particle in particles)
     {
         particle.Draw(camera);
     }
 }

 public override void Draw(GameCamera camera)
 {
     if (Active)
     {
         base.Draw(camera);
     }
 }

        public GameMap(GameModelDTO data)
            : base(data)
        {
            Camera = new GameCamera();

            worldMatrix = new WorldMatrix(this);
        }

        public override void Draw(GameCamera camera)
        {
            generator.Draw(camera);

            foreach (ModelMesh mesh in Model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.Alpha = transparency;
                }
            }

            base.Draw(camera);

            Scale = Scale + OUTER_EXTRA_SIZE;
            foreach (ModelMesh mesh in explosion.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.Alpha = MathHelper.Max(outerAlpha - transparency, 0);
                }
            }
            drawExtraModel(camera, explosion);
            //foreach (ModelMesh mesh in explosion.Meshes)
            //{
            //    foreach (BasicEffect effect in mesh.Effects)
            //    {
            //        effect.Alpha = 1f;
            //    }
            //}
            Scale = Scale - OUTER_EXTRA_SIZE;
        }

 protected Scene()
 {
     camera = new GameCamera(this, new Vector3(0.0f, 50.0f, 0.0f), new Quaternion(), Space394Game.GameInstance.AspectRatio);
     sceneObjects = new Dictionary<int, SceneObject>();
     queuedForAdd = new List<SceneObject>();
     queuedForRemoval = new List<SceneObject>();
 }

        public Player()
        {
            Camera = new GameCamera();

            Mysz = new MOIS.MouseState_NativePtr();
            InventoryItem = null;
        }

		//ncrunch: no coverage end

		private void InitializeCamera()
		{
			Camera = new GameCamera(1 / 25.0f, 1 / 10.0f, 0.01f);
			Camera.AllowedMovementRect = Rectangle.FromCenter(Vector2D.Half,
				new Size(Size.Width, Size.Height) * 1.5f);
			Camera.ResetToMinZoom();
		}

    // Use this for initialization
    void Start()
    {
        cam = GetComponent<GameCamera>();
        timer = GetComponentInChildren<Timer>();

        PlayerPrefs.SetInt ("playerScore", 0);
        SpawnPlayer ();
    }

 // Use this for initialization
 void Start()
 {
     cam = GetComponent<GameCamera> ();
     if (GameObject.FindGameObjectWithTag("Spawn")) {
         checkpoint = GameObject.FindGameObjectWithTag("Spawn").transform.position;
     }
     spawnPlayer (checkpoint);
 }

 // Use this for initialization
 void Start()
 {
     camera = GetComponent<GameCamera>();
     Object clone = Instantiate(player, new Vector3(0, 5, 0), Quaternion.identity);
     Object Enemy1 = Instantiate(enemy, new Vector3(50, 7, 0), Quaternion.identity);
     Object Enemy2 = Instantiate(enemy, new Vector3(118, 3, 0), Quaternion.identity);
     camera.SetTarget((clone as GameObject).transform);
 }

		public override void Initialize()
		{
			base.Initialize();
			camera = new GameCamera(1 / 15.0f);
			var grid = new Grid3D(new Size(10, 10));
			grid.RenderLayer = -10;
			new Player();
		}

        /// <summary>
        /// Create terrain at <paramref name="position"/>
        /// </summary>
        /// <param name="position"></param>
        /// <param name="textures"></param>
        /// <param name="device"></param>
        /// <param name="scale"></param>
        /// <param name="Content"></param>
        /// <param name="camera"></param>
        public QuadTree(Vector3 position, List<Texture2D> textures, GraphicsDevice device, int scale, ContentManager Content, GameCamera.FreeCamera camera)
        {
            shadow = new LightsAndShadows.Shadow();
            light = new LightsAndShadows.Light(0.7f, 0.4f, new Vector3(513, 100, 513));

            ViewFrustrum = new BoundingFrustum(camera.View * camera.Projection);
             //  Model model = Content.Load<Model>("Models/stone2");
              //  this.model = new LoadModel(model, Vector3.One, Vector3.Up, new Vector3(1), device);
            this.textures = textures;
            effect = Content.Load<Effect>("Effects/MultiTextured");
            effect2 = Content.Load<Effect>("Effects/Shadows");
            Device = device;

            _position = position;
            _topNodeSize = textures[4].Width - 1;

            _vertices = new MapRender(textures[4],scale);
            _buffers = new BufferManager(_vertices.Vertices, device);
            _rootNode = new QuadNode(NodeType.FullNode, _topNodeSize, 1, null, this, 0);

            //Construct an array large enough to hold all of the indices we'll need.
            Indices = _vertices.indices;

            envBilbList.Add(new EnvBilb(textures[6], textures[5], device, Content, scale));
             foreach (EnvBilb pass in envBilbList)
            {
                pass.GenerateObjPositions(_vertices.Vertices, _vertices.TerrainWidth, _vertices.TerrainLength, _vertices.heightData);
                pass.CreateBillboardVerticesFromList();
            }

            /*
            envModelList.Add(new EnvModel(textures[6], model, device, Content, scale));

               foreach (EnvModel pass1 in envModelList)
            {
                pass1.GenerateObjPositions(_vertices.Vertices, _vertices.TerrainWidth, _vertices.TerrainLength, _vertices.heightData);
                pass1.CreateModelFromList();
            }
             * */

               effect.Parameters["xTexture0"].SetValue(textures[1]);
               effect.Parameters["xTexture1"].SetValue(textures[0]);
               effect.Parameters["xTexture2"].SetValue(textures[2]);
               effect.Parameters["xTexture3"].SetValue(textures[3]);
               effect.Parameters["xTexture5"].SetValue(textures[7]);
               Matrix worldMatrix = Matrix.Identity;
               effect.Parameters["xWorld"].SetValue(worldMatrix);
               effect.Parameters["xEnableLighting"].SetValue(true);
               effect.Parameters["xAmbient"].SetValue(light.Ambient);
               effect.Parameters["xLightPower"].SetValue(light.LightPower);

               effect.Parameters["Ground"].SetValue(textures[7]);
               effect.Parameters["GroundText0"].SetValue(textures[8]);
               effect.Parameters["GroundText1"].SetValue(textures[9]);
               effect.Parameters["GroundText2"].SetValue(textures[10]);

               _rootNode.EnforceMinimumDepth();
        }

		public void Initialize()
		{
			Command.Register("ViewPanning", new Trigger[] { new MouseDragTrigger(MouseButton.Middle) });
			Command.Register("ViewZooming", new Trigger[] { new MouseZoomTrigger() });
			Command.Register("TurnViewRight", new Trigger[] { new KeyTrigger(Key.E) });
			Command.Register("TurnViewLeft", new Trigger[] { new KeyTrigger(Key.Q) });
			camera = new GameCamera(1 / 15.0f);
			new Player();
		}

		public void CreateGameCamera()
		{
			Command.Register("ViewPanning", new Trigger[] { new MouseDragTrigger(MouseButton.Middle) });
			Command.Register("ViewZooming", new Trigger[] { new MouseZoomTrigger() });
			Command.Register("TurnViewRight", new Trigger[]{new KeyTrigger(Key.E, State.Pressed)});
			Command.Register("TurnViewLeft", new Trigger[]{new KeyTrigger(Key.Q, State.Pressed)});
			gameCamera = new GameCamera(0.1f, 2.0f);
			new Grid3D(new Size(10.0f, 10.0f));
			gameCamera.AllowedMovementRect = new Rectangle(-4.0f, -4.0f, 8.0f, 8.0f);
		}

 public override void Draw(GameCamera camera)
 {
     #if DEBUG
     detectionSphere.debugDraw(camera);
     firstTrailingSphere.debugDraw(camera);
     secondTrailingSphere.debugDraw(camera);
     #endif
     trailGenerator.Draw(camera);
     base.Draw(camera);
 }

        public override void Draw(GameCamera.FreeCamera camera)
        {
            if (house != null)
            {
                house.Model.Draw(camera);
            }
            else
            {
                model.Draw(camera);

            }
        }

 public override void Draw(GameCamera camera)
 {
     if (Active)
     {
         for (int i = 0; i < particles.Count(); i++)
         {
             particles[i].Draw(camera);
         }
         Space394Game.GameInstance.GraphicsDevice.DepthStencilState = DepthStencilState.Default;
     }
     else { }
 }

    void Start()
    {
        var currLevel = int.Parse(Application.loadedLevelName.Split(' ')[Application.loadedLevelName.Split(' ').Length-1]);
        if (currLevel >= levelCount) currentLevel = currLevel;

        cam = GetComponent<GameCamera>();
        if (GameObject.FindGameObjectWithTag("Spawn")) {
            checkpoint = GameObject.FindGameObjectWithTag("Spawn").transform.position;
        }

        SpawnPlayer(checkpoint);
    }

 void Start()
 {
     stateManager = GetComponent<StateManager> ();
     adMnan = GetComponent<AdMan> ();
     gameStats = GetComponent<GameStats> ();
     menuManager = GetComponent<MenuManager> ();
     lanePlacer = GameObject.Find ("PROCEDURAL").GetComponent<LanePlacer> ();
     gameCamera = Camera.main.GetComponent<GameCamera> ();
     //		if(isFirstGame){
     //			menuManager.SwitchMenu(MenuManager.MenuTypes.PreGame);
     //		}
 }