public void Draw(
            ref BoundingFrustum boundingFrustum,
            Effect effect,
            ref Color vertexColor)
        {
            var coners = boundingFrustum.GetCorners();
            var vertices = new VertexPositionColor[8];
            for (int i = 0; i < 8; i++)
            {
                vertices[i].Position = coners[i];
                vertices[i].Color = vertexColor;
            }

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                    PrimitiveType.LineList,
                    vertices,
                    0,
                    8,
                    indices,
                    0,
                    primitiveCount);
            }
        }

        public void CullMeshes(ref ChunkCoordinate current, ref BoundingFrustum frustum)
        {
            BoundingBox box;
            if (!current.Equals(ref _previous))
            {
                _solidMeshes.Sort((x, y) => x.Position.LengthSquared().CompareTo(y.Position.LengthSquared()));
                _transparentMeshes.Sort((x, y) => -x.Position.LengthSquared().CompareTo(y.Position.LengthSquared()));
            }

            for (int i = 0; i < _solidMeshes.Count; i++)
            {
                _solidMeshes[i].GetBoundingBox(out box);
                if (frustum.Contains(box) != ContainmentType.Disjoint)
                {
                    _solidMeshRenderQueue.Enqueue(_solidMeshes[i]);
                }
            }

            for (int i = 0; i < _transparentMeshes.Count; i++)
            {
               _transparentMeshes[i].GetBoundingBox(out box);
               if (frustum.Contains(box) != ContainmentType.Disjoint)
               {
                   _transparentMeshRenderQueue.Enqueue(_transparentMeshes[i]);
               }
            }
        }

 /// <summary>
 /// Public constructor. Creates a new camera.
 /// </summary>
 /// <param name="world">The world transformation matrix holding the cameras position and orientation.</param>
 /// <param name="projection">The projection transformation matrix specifing the perspective on the world.</param>
 public Camera(Matrix world, Matrix projection)
 {
     _world = world;
     _view = Matrix.Invert(world);
     _projection = projection;
     _frustum = new BoundingFrustum(_view * _projection);
 }

        public Projector()
            : base()
        {
            const float near = 0.2f;
            const float far = 2.3f;
            const float scale = 1.0f / ScreenDistance * near;
            projection = Matrix.CreatePerspectiveOffCenter(
                scale * Skreen.Left, scale * Skreen.Right,
                scale * -Skreen.Height / 2, scale * Skreen.Height / 2,
                near, far);
            view = Matrix.CreateTranslation(0.0f, -Skreen.Height / 2, -ScreenDistance);

            // this.Width = Screen.PixelWidth;
            // this.Height = Screen.PixelHeight;
            // this.Left = WinScreen.AllScreens.Where(s => s != WinScreen.PrimaryScreen).First().Bounds.Left;
            // this.WindowState = FormWindowState.Maximized;
            // this.FormBorderStyle = FormBorderStyle.None;
            
            var num = Skreen.PixelHeight;
            var frustum = new BoundingFrustum(view * projection);
            var corners = frustum.GetCorners();
            var tpos = corners[4];
            var tray = (corners[7] - corners[4]) / (float)num;
            var bpos = corners[5];
            var bray = (corners[6] - corners[5]) / (float)num;

            SweptPlanes = new Plane[num];
            var projectorPos = Vector3.Zero;//.Invert(this.View).Translation;
            for (int i = 0; i < num; ++i)
                SweptPlanes[i] = new Plane(projectorPos, tpos + (float)i * tray, bpos + (float)i * bray);
        }

        public void UpdateFromBoundingFrustum(BoundingFrustum sourceBoundingFrustum)
        {
            #region Create the lines if necessary

            if (mLines.Count == 0)
            {
                for (int i = 0; i < NumberOfLines; i++)
                {
                    Line line = ShapeManager.AddLine();
                    mLines.Add(line);
                }
            }

            #endregion

            Vector3[] corners = sourceBoundingFrustum.GetCorners();

            mLines[0].SetFromAbsoluteEndpoints(corners[0], corners[1]);
            mLines[1].SetFromAbsoluteEndpoints(corners[1], corners[2]);
            mLines[2].SetFromAbsoluteEndpoints(corners[2], corners[3]);
            mLines[3].SetFromAbsoluteEndpoints(corners[3], corners[0]);

            mLines[4].SetFromAbsoluteEndpoints(corners[4], corners[5]);
            mLines[5].SetFromAbsoluteEndpoints(corners[5], corners[6]);
            mLines[6].SetFromAbsoluteEndpoints(corners[6], corners[7]);
            mLines[7].SetFromAbsoluteEndpoints(corners[7], corners[4]);

            mLines[8].SetFromAbsoluteEndpoints(corners[0], corners[4]);
            mLines[9].SetFromAbsoluteEndpoints(corners[1], corners[5]);
            mLines[10].SetFromAbsoluteEndpoints(corners[2], corners[6]);
            mLines[11].SetFromAbsoluteEndpoints(corners[3], corners[7]);


            sourceBoundingFrustum.Near.ToString();
        }

        public static void DrawWireframe(PrimitiveDrawer primitiveDrawer,
			Matrix cameraView, Matrix cameraProjection,
			BoundingFrustum frustum, Color color)
        {
            // The points returned correspond to the corners of the BoundingFrustum faces that are
            // perpendicular to the z-axis. The near face is the face with the larger z value, and
            // the far face is the face with the smaller z value. Points 0 to 3 correspond to the
            // near face in a clockwise order starting at its upper-left corner when looking toward
            // the origin from the positive z direction. Points 4 to 7 correspond to the far face
            // in a clockwise order starting at its upper-left corner when looking toward the
            // origin from the positive z direction.
            frustum.GetCorners(Corners);

            FrustumVertices[6].Position = Corners[0];
            FrustumVertices[7].Position = Corners[1];
            FrustumVertices[5].Position = Corners[2];
            FrustumVertices[4].Position = Corners[3];
            FrustumVertices[2].Position = Corners[4];
            FrustumVertices[3].Position = Corners[5];
            FrustumVertices[1].Position = Corners[6];
            FrustumVertices[0].Position = Corners[7];

            primitiveDrawer.Draw(Matrix.Identity, cameraView, cameraProjection, color, null,
                PrimitiveType.LineList, FrustumVertices, WireFrustumIndices, false);
        }

        /// <summary>
        /// Draw a bounding frustrum representation
        /// </summary>
        /// <param name="frustum">Frustrum</param>
        /// <param name="camera">Camera</param>
        /// <param name="color">Color</param>
        public static void Draw(BoundingFrustum frustum, BaseCamera camera, Color color)
        {
            if (effect == null)
            {
                effect = new BasicEffect(YnG.GraphicsDevice);
                effect.VertexColorEnabled = true;
                effect.LightingEnabled = false;
            }

            Vector3[] corners = frustum.GetCorners();
            for (int i = 0; i < 8; i++)
            {
                vertices[i].Position = corners[i];
                vertices[i].Color = color;
            }

            effect.View = camera.View;
            effect.Projection = camera.Projection;

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                YnG.GraphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.LineList, vertices, 0, 8, indices, 0, indices.Length / 2);
            }
        }

        public Main()
        {
            graphics = new GraphicsDeviceManager(this);

            graphics.SynchronizeWithVerticalRetrace = false;
            graphics.ApplyChanges();

            resolution = Settings.Default.WindowResolution;

            graphics.PreferredBackBufferWidth = resolution.X;
            graphics.PreferredBackBufferHeight = resolution.Y;

            Content.RootDirectory = "Content";

            camera = new FreeLookCamera(this);
            cameraHandler = new CameraHandler(this);
            fps = new FPS(this);
            hud = new HUD(this);

            Components.Add(camera);
            Components.Add(cameraHandler);
            Components.Add(fps);
            Components.Add(hud);

            Services.AddService(typeof(ICamera), camera);

            fakeViewFrustum = new BoundingFrustum(Matrix.Identity);
        }

 public FirstPersonCamera(Game game)
     : base(game)
 {
     
     Position = new Vector3(0, 0, 1);
     _viewFrustum = new BoundingFrustum(Matrix.Identity);
 }

        public override void Draw(BoundingFrustum VisibleArea, Vector3 Position)
        {
            Manager.ResetFor2D();
            MyGame.graphics.GraphicsDevice.RenderState.CullMode = CullMode.None;
            Manager.TexturedEffect.CurrentTechnique = Manager.TexturedEffect.Techniques["TexturedCloud"];
            Manager.TexturedEffect.Parameters["InputTexture"].SetValue(NoiseMap);
            Manager.TexturedEffect.Parameters["ColorMapTexture"].SetValue(ColorMap);
            for (int i = 1; i < 2; i++)
            {
                Matrix transform = Transforms.Rotation
                        * Matrix.CreateScale(Transforms.Scale * 0.75f * i / 3)
                        * Matrix.CreateTranslation(Transforms.Position + Position);
                effect.Parameters["World"].SetValue(transform);
                Manager.TexturedEffect.Parameters["TextureAlphaThreshold"].SetValue(0.33f + 0.27f * i / 3);
                MyGame.graphics.GraphicsDevice.VertexDeclaration = DefaultDeclaration;

                effect.Begin();
                effect.CurrentTechnique.Passes.First<EffectPass>().Begin();
                MyGame.graphics.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionTexture>(
                    PrimitiveType.TriangleList
                    , ModelVertices
                    , 0
                    , ModelVertices.Length
                    , ModelIndices
                    , 0
                    , ModelIndices.Length / 3);
                effect.CurrentTechnique.Passes.First<EffectPass>().End();
                effect.End();
            }
            Manager.TexturedEffect.Parameters["TextureAlphaThreshold"].SetValue(0.33f);
            base.Draw(VisibleArea, Position);
            MyGame.graphics.GraphicsDevice.RenderState.CullMode = CullMode.CullCounterClockwiseFace;
        }

 public void Draw(DoubleVector3 cameraLocation, BoundingFrustum originBasedViewFrustum, Matrix originBasedViewMatrix, Matrix projectionMatrix)
 {
     foreach (var face in _faces)
     {
         face.Draw(cameraLocation, originBasedViewFrustum, originBasedViewMatrix, projectionMatrix);
     }
 }

        public void Draw(GameTime gameTime, BoundingFrustum VisibleArea)
        {
            if (units.Count > 0)
            {
                VertexPositionColor[] display = new VertexPositionColor[units.Count * 2];
                int[] pointIndex = new int[units.Count];
                for (int i = 0; i < units.Count; i++)
                {
                    display[i * 2] = new VertexPositionColor(units[i].Position, DisplayColor);
                    pointIndex[i] = i * 2;
                    if (units[i].Target != null)
                    {
                        display[i * 2 + 1] = new VertexPositionColor(units[i].Target.Position, DisplayColor);
                    }
                    else
                    {
                        display[i * 2 + 1] = display[i * 2];
                    }
                }

                Manager.ResetFor3D();
                MyGame.graphics.GraphicsDevice.VertexDeclaration = UnitDeclaration;
                MyGame.graphics.GraphicsDevice.RenderState.PointSize = 5.0f;
                Manager.OrdinaryEffect.CurrentTechnique = Manager.OrdinaryEffect.Techniques["Ordinary"];
                Manager.OrdinaryEffect.Parameters["World"].SetValue(Matrix.Identity);
                Manager.OrdinaryEffect.Begin();
                Manager.OrdinaryEffect.CurrentTechnique.Passes.First<EffectPass>().Begin();
                MyGame.graphics.GraphicsDevice.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, display, 0, display.Length / 2);
                MyGame.graphics.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(PrimitiveType.PointList, display, 0, display.Length
                    , pointIndex, 0, pointIndex.Length);
                Manager.OrdinaryEffect.CurrentTechnique.Passes.First<EffectPass>().End();
                Manager.OrdinaryEffect.End();
            }
        }

        /// <summary>
        /// Project a point into 2D space
        /// </summary>
        public static Vector2 Project(BoundingFrustum VisibleArea, Vector3 Point)
        {
            //Acquires the frustum of the area of the screen in view.
            //Then it stores the corners of the area.
            Vector3[] corners = VisibleArea.GetCorners();
            Ray ray = new Ray(Point, Point - Manager.CameraFocus - Manager.CameraLocation);

            float? DistanceToFar = ray.Intersects(VisibleArea.Far);
            float? DistanceToNear = ray.Intersects(VisibleArea.Near);
            Vector3 ScreenCoord;
            if (DistanceToFar.HasValue)
            {
                ScreenCoord = ray.Position + ray.Direction * DistanceToFar.Value;
                ScreenCoord = new Vector3(
                    Vector3.Dot(
                        Vector3.Normalize(corners[5] - corners[4])
                        , ScreenCoord - corners[4])
                    / (corners[5] - corners[4]).Length()
                    , Vector3.Dot(
                        Vector3.Normalize(corners[7] - corners[4])
                        , ScreenCoord - corners[4])
                    / (corners[7] - corners[4]).Length()
                    , 0);
            }
            else
            {
                //Make sure this is off the screen
                return Vector2.One * (Manager.GameWindow.Width + Manager.GameWindow.Height);
            }
            return new Vector2(ScreenCoord.X * Manager.GameWindow.Width, ScreenCoord.Y * Manager.GameWindow.Height);
        }

        /// <summary>
        /// Unproject a screen coordinate into a ray
        /// </summary>
        public static Ray Unproject(Vector2 Point)
        {
            //Acquires the frustum of the area of the screen in view
            //Then it stores the corners of the area
            BoundingFrustum VisibleArea = new BoundingFrustum(Manager.View * Manager.Projection);
            Vector3[] corners = VisibleArea.GetCorners();
            Vector3 Position = new Vector3(Point, 0.0f);
            Ray ray = new Ray();

            //Point on the near plane of the visible area
            ray.Position =
                corners[0] * (1 - Position.X) * (1 - Position.Y)
                + corners[1] * Position.X * (1 - Position.Y)
                + corners[2] * Position.X * Position.Y
                + corners[3] * (1 - Position.X) * Position.Y;
            Position =
                corners[4] * (1 - Position.X) * (1 - Position.Y)
                + corners[5] * Position.X * (1 - Position.Y)
                + corners[6] * Position.X * Position.Y
                + corners[7] * (1 - Position.X) * Position.Y;
            //Direction between the two points
            ray.Direction = Vector3.Normalize(Position - ray.Position);

            return ray;
        }

 public SingleScreenSpaceShadow(IRenderContext context)
     : base(context)
 {
     lspsmLightCamera = new LspsmLightCamera();
     lightCameraFrustum = new BoundingFrustum(Matrix.Identity);
     shadowCasters = new List<Actor>();
 }

 public Dof(IRenderContext renderContext)
     : base(renderContext)
 {
     depthMapFormat = DefaultDepthMapFormat;
     Settings = DofSettings.Default;
     cameraFrustum = new BoundingFrustum(Matrix.Identity);
 }

        public void CalibrateExtrinsics(PointF[] imagePoints, MCvPoint3D32f[] worldPoints)
        {
            if (Intrinsics == null)
                throw new Exception("Intrinsics of camera are still unknown, unable to calibrate extrinsic paramters.");
            
            Extrinsics = CameraCalibration.FindExtrinsicCameraParams2(worldPoints, imagePoints, Intrinsics);

            InitializeWorldAndViewMatrices();
            BoundingFrustum = new BoundingFrustum(View * Projection);

            using (var img = new Image<Bgr, byte>(ImageWidth, ImageHeight))
            {
                foreach (var p in imagePoints)
                    img.Draw(new Cross2DF(p, 20, 20), new Bgr(255, 0, 255), 1);

                var projectedCorners = CameraCalibration.ProjectPoints(worldPoints, Extrinsics, Intrinsics);
                foreach (var p in projectedCorners)
                    img.Draw(new Cross2DF(p, 6, 6), new Bgr(255, 255, 0), 1);

                var und = Intrinsics.Undistort(img);

                img.Save(Path.Combine(Global.TmpDir, "reproject.png"));
                und.Save(Path.Combine(Global.TmpDir, "undistorted.png"));
            }
        }

        public Camera(String ID, Vector3 Position, Vector3 Target)
        {
            this.ID = ID;
            this.Position = Position;
            this.Target = Target;
            this.Up = Vector3.Up;
            Updateable = true;

            this.NearPlane = GameApplication.Instance.NearPlane;
            this.FarPlane = GameApplication.Instance.FarPlane;
            this.AspectRatio = (float)GameApplication.Instance.GetGraphics().Viewport.Width /
                            (float)GameApplication.Instance.GetGraphics().Viewport.Height;
            this.FieldOfView = MathHelper.PiOver4;

            // create the view matrix
            View = Matrix.CreateLookAt(this.Position, this.Target, this.Up);

            // create projection matrix
            Projection = Utils.CreateProjectionMatrix();

            Frustum = new BoundingFrustum(Matrix.Multiply(View, Projection));

            // add the camera to the camera manager
            CameraManager.Instance.AddCamera(this.ID, this);
        }

        public Selection(Settings settings, IVisibleRanges visibleRanges)
        {
            this.settings = settings;
            VisibleRanges = visibleRanges;

            Frustum = new BoundingFrustum(Matrix.Identity);
            selectedNodes = new SelectedNode[MaxSelectedNodeCount];
        }

 public void Update(IViewProject viewProject)
 {
     View = viewProject.View;
     Projection = viewProject.Projection;
     
     BoundingFrustum = new BoundingFrustum(View * Projection);
     World = Matrix.Invert(View);
 }