示例#1
0
        public void CreateDepths(Camera inputCamera)
        {
            if (inputCamera == null)
            {
                return;
            }

            BoundingFrustum frust   = inputCamera.GetFrustum();
            BoundingBox     box     = MathFunctions.GetBoundingBox(frust.GetCorners());
            Vector3         forward = frust.Near.Normal;

            Vector3 z = Vector3.Zero;

            foreach (InstanceData instance in Data)
            {
                z = instance.Transform.Translation - inputCamera.Position;
                instance.Depth = z.LengthSquared();

                if (instance.Depth < CullDistance)
                {
                    // Half plane test. Faster. Much less accurate.
                    //if (Vector3.Dot(z, forward) > 0)
                    if (box.Contains(instance.Transform.Translation) != ContainmentType.Contains)
                    {
                        instance.Depth *= 100;
                    }
                }
                else
                {
                    instance.Depth *= 100;
                }
            }
        }
示例#2
0
        public static void AddBoundingFrustum(BoundingFrustum frustum, Color color, float life)
        {
            DebugShape shape = GetShapeForLines(12, life);

            frustum.GetCorners(corners);

            shape.Vertices[0] = new VertexPositionColor(corners[0], color);
            shape.Vertices[1] = new VertexPositionColor(corners[1], color);
            shape.Vertices[2] = new VertexPositionColor(corners[1], color);
            shape.Vertices[3] = new VertexPositionColor(corners[2], color);
            shape.Vertices[4] = new VertexPositionColor(corners[2], color);
            shape.Vertices[5] = new VertexPositionColor(corners[3], color);
            shape.Vertices[6] = new VertexPositionColor(corners[3], color);
            shape.Vertices[7] = new VertexPositionColor(corners[0], color);

            shape.Vertices[8]  = new VertexPositionColor(corners[4], color);
            shape.Vertices[9]  = new VertexPositionColor(corners[5], color);
            shape.Vertices[10] = new VertexPositionColor(corners[5], color);
            shape.Vertices[11] = new VertexPositionColor(corners[6], color);
            shape.Vertices[12] = new VertexPositionColor(corners[6], color);
            shape.Vertices[13] = new VertexPositionColor(corners[7], color);
            shape.Vertices[14] = new VertexPositionColor(corners[7], color);
            shape.Vertices[15] = new VertexPositionColor(corners[4], color);

            shape.Vertices[16] = new VertexPositionColor(corners[0], color);
            shape.Vertices[17] = new VertexPositionColor(corners[4], color);
            shape.Vertices[18] = new VertexPositionColor(corners[1], color);
            shape.Vertices[19] = new VertexPositionColor(corners[5], color);
            shape.Vertices[20] = new VertexPositionColor(corners[2], color);
            shape.Vertices[21] = new VertexPositionColor(corners[6], color);
            shape.Vertices[22] = new VertexPositionColor(corners[3], color);
            shape.Vertices[23] = new VertexPositionColor(corners[7], color);
        }
        protected virtual void UpdateView()
        {
            Matrix rot = Matrix.CreateFromYawPitchRoll(pitchYawRoll.Y,
                                                       pitchYawRoll.X, pitchYawRoll.Z);

            movement = Vector3.Transform(movement, rot);
            pos     += movement;
            movement = Vector3.Zero;

            Vector3 forward = Vector3.Transform(Vector3.Forward, rot);

            target = pos + forward;

            Vector3 up = Vector3.Transform(Vector3.Up, rot);

            view        = Matrix.CreateLookAt(pos, target, up);
            viewFrustum = new BoundingFrustum(view * proj);

            viewFrustum.GetCorners(frustumCorners);
            clippingFrustum = ClippingFrustum.FromPoints(frustumCorners);

            viewPoint = new Vector2()
            {
                X = pos.X,
                Y = pos.Z
            };
        }
示例#4
0
        /// <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);
        }
示例#5
0
        public void GetObjectsIntersecting <TObject>(BoundingFrustum frustum, HashSet <TObject> set, CollisionType queryType) where TObject : IBoundedObject
        {
            List <SpatialHash <IBoundedObject> > hashes = new List <SpatialHash <IBoundedObject> >();

            switch ((int)queryType)
            {
            case (int)CollisionType.Static:
            case (int)CollisionType.Dynamic:
                hashes.Add(Hashes[queryType]);
                break;

            case ((int)CollisionType.Static | (int)CollisionType.Dynamic):
                hashes.Add(Hashes[CollisionType.Static]);
                hashes.Add(Hashes[CollisionType.Dynamic]);
                break;
            }

            BoundingBox frustumBox = MathFunctions.GetBoundingBox(frustum.GetCorners());

            foreach (var obj in
                     from hash
                     in hashes
                     from pair
                     in hash.HashMap
                     where pair.Value != null && frustumBox.Contains(pair.Key.ToVector3()) == ContainmentType.Contains
                     from obj in pair.Value
                     where obj is TObject && !set.Contains((TObject)obj) && obj.GetBoundingBox().Intersects(frustum)
                     select obj)
            {
                set.Add((TObject)obj);
            }
        }
示例#6
0
        /// <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);
        }
示例#7
0
        public void BoundingFrustum_CalculatesCornersCorrectly()
        {
            var view    = Matrix.CreateLookAt(new Vector3(0, 0, 5), Vector3.Zero, Vector3.Up);
            var proj    = Matrix.CreatePerspectiveFieldOfView((float)Math.PI / 4f, 4f / 3f, 1f, 1000f);
            var frustum = new BoundingFrustum(view * proj);

            var corners = new Vector3[BoundingFrustum.CornerCount];

            frustum.GetCorners(corners);

            TheResultingValue(corners[0]).WithinDelta(0.0001f)
            .ShouldBe(-0.5522f, 0.4142f, 4f);
            TheResultingValue(corners[1]).WithinDelta(0.0001f)
            .ShouldBe(0.5522f, 0.4142f, 4f);
            TheResultingValue(corners[2]).WithinDelta(0.0001f)
            .ShouldBe(0.5522f, -0.4142f, 4f);
            TheResultingValue(corners[3]).WithinDelta(0.0001f)
            .ShouldBe(-0.5522f, -0.4142f, 4f);
            TheResultingValue(corners[4]).WithinDelta(0.0001f)
            .ShouldBe(-552.2851f, 414.2138f, -995.0007f);
            TheResultingValue(corners[5]).WithinDelta(0.0001f)
            .ShouldBe(552.2851f, 414.2138f, -995.0007f);
            TheResultingValue(corners[6]).WithinDelta(0.0001f)
            .ShouldBe(552.2851f, -414.2138f, -995.0007f);
            TheResultingValue(corners[7]).WithinDelta(0.0001f)
            .ShouldBe(-552.2851f, -414.2138f, -995.0007f);
        }
        /// <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);
            }
        }
示例#9
0
        /// <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;
        }
示例#10
0
        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();
        }
示例#11
0
        public override void SetConstants(IGraphicsContext context)
        {
            base.SetConstants(context);
            var camera = context.CurrentCamera;

            Effect.Parameters["wPosCamera"].SetValue(camera.Position);
            Effect.Parameters["near_plane"].SetValue((float)camera.NearPlane);
            Effect.Parameters["far_plane"].SetValue((float)camera.FarPlane);
            Effect.Parameters["fov"].SetValue((float)camera.FieldOfView);

            Vector3[] frustumCornersWS = new Vector3[8];
            Vector4[] frustumCornersVS = new Vector4[8];
            Vector4[] farFrustumCornersVS = new Vector4[4];
            BoundingFrustum frustum = new BoundingFrustum(context.RenderContext.ViewProjD.ToMatrix());
            frustum.GetCorners(frustumCornersWS);

            var view = camera.ViewD.ToMatrix();
            // TODO: take out the translation part of the view matrix
            Vector3.Transform(frustumCornersWS, ref view, frustumCornersVS);

            //  2 ____________  1
            //   |            |
            //   |            |
            //   |            |
            //  3|____________| 0
            //
            for (int i = 4; i < 8; i++)
            {
                farFrustumCornersVS[i - 4] = frustumCornersVS[i];
            }

            Effect.Parameters["frustumCornersVS"].SetValue(farFrustumCornersVS);
        }
示例#12
0
        static public float GetDistanceBetweenCameraNearPlaneAndBoundingBox(BoundingFrustum frustum, BoundingBox boundingBox)
        {
            Vector3[] corners = new Vector3[8];
            boundingBox.GetCorners(corners);

            Vector3 nearPoint = frustum.GetCorners()[0];

            float distanceSqr = float.MaxValue;

            for (int i = 0; i < corners.Length - 1; ++i)
            {
                Vector3 diffVect    = corners[i] - nearPoint;
                float   sqrDiffDist = diffVect.LengthSquared();

                if (sqrDiffDist < distanceSqr)
                {
                    distanceSqr = sqrDiffDist;
                }
            }

            // The distances between the points of a near plane aren't large enough that it will be noticeable, so we
            // don't bother calculating the center of the near plane, we just use a corner.


            return((float)Math.Sqrt(distanceSqr));
        }
        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);
            }
        }
示例#14
0
        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 Render(BoundingFrustum frustum, GraphicsDevice graphicsDevice, Matrix view, Matrix projection, Color color)
        {
            if ((effect == null) == true)
            {
                effect = new BasicEffect(graphicsDevice);
                effect.VertexColorEnabled = true;
                effect.LightingEnabled    = false;
            }

            Vector3[] corners = frustum.GetCorners();
            for (var I = 0; I <= 7; I++)
            {
                verts[I].Position = corners[I];
                verts[I].Color    = color;
            }

            effect.View       = view;
            effect.Projection = projection;

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                graphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.LineList, verts, 0, 8, indices, 0, Convert.ToInt32(indices.Length / 2));
            }
        }
        /// <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);
            }
        }
示例#17
0
        private void GetChunksIntersecting(BoundingFrustum Frustum, HashSet <VoxelChunk> chunks)
        {
            chunks.Clear();
            var frustumBox = MathFunctions.GetBoundingBox(Frustum.GetCorners());
            var minChunk   = ChunkData.ConfineToBounds(GlobalVoxelCoordinate.FromVector3(frustumBox.Min).GetGlobalChunkCoordinate());
            var maxChunk   = ChunkData.ConfineToBounds(GlobalVoxelCoordinate.FromVector3(frustumBox.Max).GetGlobalChunkCoordinate());


            for (var x = minChunk.X; x <= maxChunk.X; ++x)
            {
                for (var y = minChunk.Y; y <= maxChunk.Y; ++y)
                {
                    for (var z = minChunk.Z; z <= maxChunk.Z; ++z)
                    {
                        var chunkCoord = new GlobalChunkCoordinate(x, y, z);
                        var min        = new GlobalVoxelCoordinate(chunkCoord, new LocalVoxelCoordinate(0, 0, 0));
                        var box        = new BoundingBox(min.ToVector3(), min.ToVector3() + new Vector3(VoxelConstants.ChunkSizeX, VoxelConstants.ChunkSizeY, VoxelConstants.ChunkSizeZ));
                        if (Frustum.Contains(box) != ContainmentType.Disjoint)
                        {
                            chunks.Add(ChunkData.GetChunk(chunkCoord));
                        }
                    }
                }
            }
        }
示例#18
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="view"></param>
        /// <param name="projection"></param>
        /// <param name="frustum"></param>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        bool GetFrustumExtent(Matrix view, Matrix projection, Rectangle viewport, BoundingFrustum frustum, out Vector4 min, out Vector4 max)
        {
            min = max = Vector4.Zero;

            var znear = projection.M34 * projection.M43 / projection.M33;

            var viewPoints = frustum.GetCorners()
                             .Select(p0 => Vector3.TransformCoordinate(p0, view))
                             .ToArray();

            var dr = Game.GetService <DebugRender>();

            var lines = new[] {
                new Line(viewPoints[0], viewPoints[1]),
                new Line(viewPoints[1], viewPoints[2]),
                new Line(viewPoints[2], viewPoints[3]),
                new Line(viewPoints[3], viewPoints[0]),

                new Line(viewPoints[4], viewPoints[5]),
                new Line(viewPoints[5], viewPoints[6]),
                new Line(viewPoints[6], viewPoints[7]),
                new Line(viewPoints[7], viewPoints[4]),

                new Line(viewPoints[0], viewPoints[4]),
                new Line(viewPoints[1], viewPoints[5]),
                new Line(viewPoints[2], viewPoints[6]),
                new Line(viewPoints[3], viewPoints[7]),
            };

            lines = lines.Where(line => line.Clip(znear)).ToArray();

            if (!lines.Any())
            {
                return(false);
            }

            var projPoints = new List <Vector3>();

            foreach (var line in lines)
            {
                projPoints.Add(Vector3.TransformCoordinate(line.A, projection));
                projPoints.Add(Vector3.TransformCoordinate(line.B, projection));
            }

            min.X = projPoints.Min(p => p.X);
            min.Y = projPoints.Max(p => p.Y);
            min.Z = projPoints.Min(p => p.Z);

            max.X = projPoints.Max(p => p.X);
            max.Y = projPoints.Min(p => p.Y);
            max.Z = projPoints.Max(p => p.Z);

            min.X = (min.X * 0.5f + 0.5f) * viewport.Width;
            min.Y = (min.Y * -0.5f + 0.5f) * viewport.Height;

            max.X = (max.X * 0.5f + 0.5f) * viewport.Width;
            max.Y = (max.Y * -0.5f + 0.5f) * viewport.Height;

            return(true);
        }
示例#19
0
文件: Frustum.cs 项目: tgjones/osiris
        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);
        }
示例#20
0
    /// <summary>
    /// Test if a frustum is fully inside, outside, or just intersecting the sphere.
    /// </summary>
    /// <param name="frustum">The frustum for testing.</param>
    /// <returns>The containment type.</returns>
    public ContainmentType Contains(BoundingFrustum frustum)
    {
        //check if all corner is in sphere
        bool inside = true;

        Vector3[] corners = frustum.GetCorners();
        foreach (Vector3 corner in corners)
        {
            if (this.Contains(corner) == ContainmentType.Disjoint)
            {
                inside = false;
                break;
            }
        }
        if (inside)
        {
            return(ContainmentType.Contains);
        }

        //check if the distance from sphere center to frustrum face < radius
        double dmin = 0;

        //TODO : calcul dmin

        if (dmin <= Radius * Radius)
        {
            return(ContainmentType.Intersects);
        }

        //else disjoint
        return(ContainmentType.Disjoint);
    }
示例#21
0
        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);
        }
示例#22
0
        public void SetCameraParameters(Camera camera)
        {
            gbufferEffect.Parameters["wPosCamera"].SetValue(camera.Position);
            gbufferEffect.Parameters["near_plane"].SetValue(camera.NearPlane);
            gbufferEffect.Parameters["far_plane"].SetValue(camera.FarPlane);
            gbufferEffect.Parameters["fov"].SetValue(camera.FieldOfView);

            Vector3[]       frustumCornersWS    = new Vector3[8];
            Vector4[]       frustumCornersVS    = new Vector4[8];
            Vector4[]       farFrustumCornersVS = new Vector4[4];
            Matrix          view     = camera.ViewD.ToMatrix();
            MatrixD         viewProj = MatrixD.Multiply(camera.ViewD, camera.ProjD);
            BoundingFrustum frustum  = new BoundingFrustum(viewProj.ToMatrix());

            frustum.GetCorners(frustumCornersWS);

            // TODO: take out the translation part of the view matrix
            Vector3.Transform(frustumCornersWS, ref view, frustumCornersVS);

            //  2 ____________  1
            //   |            |
            //   |            |
            //   |            |
            //  3|____________| 0
            //
            for (int i = 4; i < 8; i++)
            {
                farFrustumCornersVS[i - 4] = frustumCornersVS[i];
            }

            gbufferEffect.Parameters["frustumCornersVS"].SetValue(farFrustumCornersVS);
        }
示例#23
0
        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);
        }
示例#24
0
        /// <summary>
        /// Project a point into 2D space
        /// </summary>
        public static Vector2 Project(Vector3 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();
            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));
        }
示例#25
0
        public void GetChunksIntersecting(BoundingFrustum frustum, HashSet<VoxelChunk> chunks)
        {
            chunks.Clear();
            BoundingBox frustumBox = MathFunctions.GetBoundingBox(frustum.GetCorners());
            GetChunksIntersecting(frustumBox, chunks);

            chunks.RemoveWhere(chunk => frustum.Contains(chunk.GetBoundingBox()) == ContainmentType.Disjoint);
        }
示例#26
0
        /// <summary>
        /// Camera Far Plane Bounding Frustum (in view space). 
        /// With the help of the bounding frustum, the position can be cheaply reconstructed from a depth value.
        /// </summary>
        public void BoundingFrustumViewSpace(Vector3[] cornersViewSpace)
        {
            if (cornersViewSpace.Length != 4)
                throw new ArgumentOutOfRangeException("cornersViewSpace");
            boundingFrustum.Matrix = ViewMatrix * ProjectionMatrix;
            boundingFrustum.GetCorners(cornersWorldSpace);
            // Transform form world space to view space
            for (int i = 0; i < 4; i++)
            {
                cornersViewSpace[i] = Vector3.Transform(cornersWorldSpace[i + 4], ViewMatrix);
            }

            // Swap the last 2 values.
            Vector3 temp = cornersViewSpace[3];
            cornersViewSpace[3] = cornersViewSpace[2];
            cornersViewSpace[2] = temp;
        } // BoundingFrustumViewSpace
		/// <summary>
		/// 
		/// </summary>
		/// <param name="view"></param>
		/// <param name="projection"></param>
		/// <param name="frustum"></param>
		/// <param name="min"></param>
		/// <param name="max"></param>
		/// <returns></returns>
		bool GetFrustumExtent ( Matrix view, Matrix projection, Rectangle viewport, BoundingFrustum frustum, out Vector4 min, out Vector4 max )
		{
			min = max	=	Vector4.Zero;

			var znear	=	projection.M34 * projection.M43 / projection.M33;
			
			var viewPoints = frustum.GetCorners()
					.Select( p0 => Vector3.TransformCoordinate( p0, view ) )
					.ToArray();

			//var dr		=	Game.GetService<DebugRender>();

			var lines = new[]{
				new Line( viewPoints[0], viewPoints[1] ),
				new Line( viewPoints[1], viewPoints[2] ),
				new Line( viewPoints[2], viewPoints[3] ),
				new Line( viewPoints[3], viewPoints[0] ),
														
				new Line( viewPoints[4], viewPoints[5] ),
				new Line( viewPoints[5], viewPoints[6] ),
				new Line( viewPoints[6], viewPoints[7] ),
				new Line( viewPoints[7], viewPoints[4] ),
													
				new Line( viewPoints[0], viewPoints[4] ),
				new Line( viewPoints[1], viewPoints[5] ),
				new Line( viewPoints[2], viewPoints[6] ),
				new Line( viewPoints[3], viewPoints[7] ),
			};

			lines = lines.Where( line => line.Clip(znear) ).ToArray();

			if (!lines.Any()) {
				return false;
			}

			var projPoints = new List<Vector3>();
			
			foreach ( var line in lines ) {
				projPoints.Add( Vector3.TransformCoordinate( line.A, projection ) );
				projPoints.Add( Vector3.TransformCoordinate( line.B, projection ) );
			}

			min.X	=	projPoints.Min( p => p.X );
			min.Y	=	projPoints.Max( p => p.Y );
			min.Z	=	projPoints.Min( p => p.Z );

			max.X	=	projPoints.Max( p => p.X );
			max.Y	=	projPoints.Min( p => p.Y );
			max.Z	=	projPoints.Max( p => p.Z );

			min.X	=	( min.X *  0.5f + 0.5f ) * viewport.Width;
			min.Y	=	( min.Y * -0.5f + 0.5f ) * viewport.Height;

			max.X	=	( max.X *  0.5f + 0.5f ) * viewport.Width;
			max.Y	=	( max.Y * -0.5f + 0.5f ) * viewport.Height;

			return true;
		} 
示例#28
0
        public void ComputeLightViewProjection()
        {
            switch (lightSource.Type)
            {
            case LightType.Directional:
                tmpVec1 = lightSource.TransformedDirection;
                // Matrix with that will rotate in points the direction of the light
                Matrix.CreateLookAt(ref zero, ref tmpVec1, ref up, out tmpMat1);

                // Get the corners of the frustum
                Vector3[] frustumCorners = lightFrustum.GetCorners();

                // Transform the positions of the corners into the direction of the light
                for (int i = 0; i < frustumCorners.Length; i++)
                {
                    Vector3.Transform(ref frustumCorners[i], ref tmpMat1, out frustumCorners[i]);
                }

                // Find the smallest box around the points
                BoundingBox lightBox = BoundingBox.CreateFromPoints(frustumCorners);

                Vector3 boxSize     = lightBox.Max - lightBox.Min;
                Vector3 halfBoxSize = boxSize * 0.5f;

                // The position of the light should be in the center of the back
                // pannel of the box.
                tmpVec1   = lightBox.Min + halfBoxSize;
                tmpVec1.Z = lightBox.Min.Z;

                // We need the position back in world coordinates so we transform
                // the light position by the inverse of the lights rotation
                Matrix.Invert(ref tmpMat1, out tmpMat2);
                Vector3.Transform(ref tmpVec1, ref tmpMat2, out tmpVec1);

                // Create the view matrix for the light
                tmpVec2 = tmpVec1 + lightSource.TransformedDirection;
                Matrix.CreateLookAt(ref tmpVec1, ref tmpVec2, ref up, out tmpMat1);

                // Create the projection matrix for the light
                // The projection is orthographic since we are using a directional light
                Matrix.CreateOrthographic(boxSize.X, boxSize.Y, -boxSize.Z, boxSize.Z, out tmpMat2);

                Matrix.Multiply(ref tmpMat1, ref tmpMat2, out lightViewProjection);
                break;

            case LightType.Point:
            case LightType.SpotLight:
                tmpVec1 = lightSource.TransformedPosition;
                tmpVec2 = lightSource.TransformedDirection;
                Matrix.CreateLookAt(ref tmpVec1, ref tmpVec2, ref up, out tmpMat1);

                Matrix.Multiply(ref tmpMat1, ref lightProjection, out lightViewProjection);
                break;
            }
        }
示例#29
0
        protected override void AddVerticesAndIndices()
        {
            ushort         baseIndex = checked ((ushort)_vertices.Count);
            FrustumCorners corners   = _frustum.GetCorners();

            _vertices.Add(new WireframeVertex(corners.NearTopLeft, Color));
            _vertices.Add(new WireframeVertex(corners.NearTopRight, Color));
            _vertices.Add(new WireframeVertex(corners.NearBottomRight, Color));
            _vertices.Add(new WireframeVertex(corners.NearBottomLeft, Color));

            _vertices.Add(new WireframeVertex(corners.FarTopLeft, Color));
            _vertices.Add(new WireframeVertex(corners.FarTopRight, Color));
            _vertices.Add(new WireframeVertex(corners.FarBottomRight, Color));
            _vertices.Add(new WireframeVertex(corners.FarBottomLeft, Color));

            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 3));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 3));
            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 3));

            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 7));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 7));
            _indices.Add((ushort)(baseIndex + 3));
            _indices.Add((ushort)(baseIndex + 7));

            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 6));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 6));
            _indices.Add((ushort)(baseIndex + 7));
            _indices.Add((ushort)(baseIndex + 6));

            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 6));
            _indices.Add((ushort)(baseIndex + 2));
        }
示例#30
0
        protected override void AddVerticesAndIndices()
        {
            int            baseIndex = _vertices.Count;
            FrustumCorners corners   = _frustum.GetCorners();

            _vertices.Add(new VertexPositionNormalTexture(corners.NearTopLeft, Vector3.One * 0.5f, Vector2.One * 0.5f));
            _vertices.Add(new VertexPositionNormalTexture(corners.NearTopRight, Vector3.One * 0.5f, Vector2.One * 0.5f));
            _vertices.Add(new VertexPositionNormalTexture(corners.NearBottomRight, Vector3.One * 0.5f, Vector2.One * 0.5f));
            _vertices.Add(new VertexPositionNormalTexture(corners.NearBottomLeft, Vector3.One * 0.5f, Vector2.One * 0.5f));

            _vertices.Add(new VertexPositionNormalTexture(corners.FarTopLeft, Vector3.Zero, Vector2.Zero));
            _vertices.Add(new VertexPositionNormalTexture(corners.FarTopRight, Vector3.Zero, Vector2.Zero));
            _vertices.Add(new VertexPositionNormalTexture(corners.FarBottomRight, Vector3.Zero, Vector2.Zero));
            _vertices.Add(new VertexPositionNormalTexture(corners.FarBottomLeft, Vector3.Zero, Vector2.Zero));

            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 3));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 3));
            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 3));

            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 0));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 7));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 7));
            _indices.Add((ushort)(baseIndex + 3));
            _indices.Add((ushort)(baseIndex + 7));

            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 4));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 6));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 6));
            _indices.Add((ushort)(baseIndex + 7));
            _indices.Add((ushort)(baseIndex + 6));

            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 5));
            _indices.Add((ushort)(baseIndex + 1));
            _indices.Add((ushort)(baseIndex + 2));
            _indices.Add((ushort)(baseIndex + 6));
            _indices.Add((ushort)(baseIndex + 2));
        }
示例#31
0
 public IEnumerable <VoxelChunk> EnumerateChunksInBounds(BoundingFrustum Frustum)
 {
     return(EnumerateChunksInBounds(MathFunctions.GetBoundingBox(Frustum.GetCorners()))
            .Where(c =>
     {
         var min = new GlobalVoxelCoordinate(c.ID, new LocalVoxelCoordinate(0, 0, 0));
         var box = new BoundingBox(min.ToVector3(), min.ToVector3() + new Vector3(VoxelConstants.ChunkSizeX, VoxelConstants.ChunkSizeY, VoxelConstants.ChunkSizeZ));
         var r = Frustum.Contains(box) != ContainmentType.Disjoint;
         return r;
     }));
 }
示例#32
0
        public void UpdateComponents(Matrix viewProjection)
        {
            boundingFrustum = new BoundingFrustum(viewProjection);

            Vector3[] corners = boundingFrustum.GetCorners();
            for (int i = 0; i < 8; i++)
            {
                vertices[i].Position = corners[i];
            }
            vertexBuffer.SetData(vertices);
        }
示例#33
0
文件: Utils.cs 项目: thormme/Chimera
        public static BoundingBox GetCameraBoundingBox(Matrix viewTransform, Matrix projectionTransform)
        {
            BoundingFrustum cameraFrustum = new BoundingFrustum(Matrix.Identity);
            cameraFrustum.Matrix = viewTransform * projectionTransform;

            // Get the corners of the frustum
            Vector3[] frustumCorners = cameraFrustum.GetCorners();

            BoundingBox bounds = BoundingBox.CreateFromPoints(frustumCorners);
            return bounds;
        }
示例#34
0
        /// <summary>
        /// Clips a box against a frustum and split the input triangle when they interests.
        /// </summary>
        public static int Intersects(this BoundingBox box, BoundingFrustum frustum, Vector3[] intersections, int startIndex)
        {
            var count = 0;

            frustum.GetCorners(FrustumCorners);
            for (int i = 0; i < TriangleIndices.Length; i += 3)
            {
                count += Triangle.Intersects(ref FrustumCorners[TriangleIndices[i]],
                                             ref FrustumCorners[TriangleIndices[i + 1]],
                                             ref FrustumCorners[TriangleIndices[i + 2]],
                                             ref box, intersections, startIndex + count);
            }
            return(startIndex + count);
        }
示例#35
0
        public ContainmentType Contains(BoundingFrustum frustum)
        {
            Vector3[] corners = frustum.GetCorners();

            for (int i = 0; i < corners.Length; i++)
            {
                if (Contains(corners[i]) == ContainmentType.Disjoint)
                {
                    return(i > 0 ? ContainmentType.Disjoint : ContainmentType.Intersects);
                }
            }

            return(ContainmentType.Contains);
        }
示例#36
0
        private Vector3[] GetFarFrustumCorners(Matrix view, Matrix projection)
        {
            BoundingFrustum frustum   = new BoundingFrustum(view * projection);
            var             cornersWS = frustum.GetCorners();

            Vector3[] cornersVS = new Vector3[cornersWS.Length];
            Vector3.Transform(cornersWS, ref view, cornersVS);
            Vector3[] farFrustumCorners = new Vector3[4];
            for (int i = 0; i < 4; ++i)
            {
                //farFrustumCorners[i] = Vector3.Transform(cornersVS[i + 4], Matrix.Invert(playerCam.view));
                farFrustumCorners[i] = cornersVS[i + 4];
            }
            return(farFrustumCorners);
        }
示例#37
0
        private void UpdateVisibility(BoundingFrustum frustum)
        {
            var boundingBox = TreeBoundingBox;

            // This is to allow non-virtual calls to the culling methods
            var info = new CullingInfo();

            info.Frustum            = frustum;
            info.FrustumBoundingBox = BoundingBox.FromPoints(frustum.GetCorners());
            info.Tree = tree;
            info.CullablesReferenceCounts = cullablesReferenceCounts;
            info.Culler = culler;


            updateVisibility(tree.GetRoot(), ref info, ref boundingBox, false);
        }
    //  IMPORTANT: Bounding box you are trying to change need to have positive/negative infinite values, so initialize it with InitialBox (static member)
    static public void AddFrustum(ref BoundingFrustum frustum, ref BoundingBox bb)
    {
        if (pts == null)
            pts = new Vector3[8];

        frustum.GetCorners(pts);

        AddPoint(ref pts[0], ref bb);
        AddPoint(ref pts[1], ref bb);
        AddPoint(ref pts[2], ref bb);
        AddPoint(ref pts[3], ref bb);
        AddPoint(ref pts[4], ref bb);
        AddPoint(ref pts[5], ref bb);
        AddPoint(ref pts[6], ref bb);
        AddPoint(ref pts[7], ref bb);
    }
示例#39
0
    public ContainmentType Contains(BoundingFrustum frustum)
    {
        //TODO: bad done here need a fix.
        //Because question is not frustum contain box but reverse and this is not the same
        int             i;
        ContainmentType contained;

        Vector3[] corners = frustum.GetCorners();

        // First we check if frustum is in box
        for (i = 0; i < corners.Length; i++)
        {
            this.Contains(ref corners[i], out contained);
            if (contained == ContainmentType.Disjoint)
            {
                break;
            }
        }

        if (i == corners.Length) // This means we checked all the corners and they were all contain or instersect
        {
            return(ContainmentType.Contains);
        }

        if (i != 0)             // if i is not equal to zero, we can fastpath and say that this box intersects
        {
            return(ContainmentType.Intersects);
        }


        // If we get here, it means the first (and only) point we checked was actually contained in the frustum.
        // So we assume that all other points will also be contained. If one of the points is disjoint, we can
        // exit immediately saying that the result is Intersects
        i++;
        for (; i < corners.Length; i++)
        {
            this.Contains(ref corners[i], out contained);
            if (contained != ContainmentType.Contains)
            {
                return(ContainmentType.Intersects);
            }
        }

        // If we get here, then we know all the points were actually contained, therefore result is Contains
        return(ContainmentType.Contains);
    }
示例#40
0
        /// <summary>
        /// From https://jcoluna.wordpress.com/2011/01/18/xna-4-0-light-pre-pass/
        /// Compute the frustum corners for a camera.
        /// Its used to reconstruct the pixel position using only the depth value.
        /// Read here for more information
        /// http://mynameismjp.wordpress.com/2009/03/10/reconstructing-position-from-depth/
        /// </summary>
        /// <param name="cameraFrustum"></param>
        private void ComputeFrustumCorners(BoundingFrustum cameraFrustum)
        {
            cameraFrustum.GetCorners(_cornersWorldSpace);
            //this is the inverse of our camera transform
            Vector3.Transform(_cornersWorldSpace, ref _view, _cornersViewSpace); //put the frustum into view space
            for (int i = 0; i < 4; i++)                                          //take only the 4 farthest points
            {
                _currentFrustumCorners[i] = _cornersViewSpace[i + 4];
            }
            Vector3 temp = _currentFrustumCorners[3];

            _currentFrustumCorners[3] = _currentFrustumCorners[2];
            _currentFrustumCorners[2] = temp;

            _ambientOcclusionShader.FrustumCorners = _currentFrustumCorners;
            //Shaders.deferredEnvironmentParameter_FrustumCorners.SetValue(_currentFrustumCorners);
        }
示例#41
0
        public static void AddBoundingFrustum(BoundingFrustum frustum, Color color)
        {
            // Get a DebugShape we can use to draw the frustum
            DebugShape shape = GetShapeForLines(12);

            // Get the corners of the frustum
            frustum.GetCorners(corners);

            // Fill in the vertices for the bottom of the frustum
            shape.Vertices[0] = new VertexPositionColor(corners[0], color);
            shape.Vertices[1] = new VertexPositionColor(corners[1], color);
            shape.Vertices[2] = new VertexPositionColor(corners[1], color);
            shape.Vertices[3] = new VertexPositionColor(corners[2], color);
            shape.Vertices[4] = new VertexPositionColor(corners[2], color);
            shape.Vertices[5] = new VertexPositionColor(corners[3], color);
            shape.Vertices[6] = new VertexPositionColor(corners[3], color);
            shape.Vertices[7] = new VertexPositionColor(corners[0], color);

            // Fill in the vertices for the top of the frustum
            shape.Vertices[8] = new VertexPositionColor(corners[4], color);
            shape.Vertices[9] = new VertexPositionColor(corners[5], color);
            shape.Vertices[10] = new VertexPositionColor(corners[5], color);
            shape.Vertices[11] = new VertexPositionColor(corners[6], color);
            shape.Vertices[12] = new VertexPositionColor(corners[6], color);
            shape.Vertices[13] = new VertexPositionColor(corners[7], color);
            shape.Vertices[14] = new VertexPositionColor(corners[7], color);
            shape.Vertices[15] = new VertexPositionColor(corners[4], color);

            // Fill in the vertices for the vertical sides of the frustum
            shape.Vertices[16] = new VertexPositionColor(corners[0], color);
            shape.Vertices[17] = new VertexPositionColor(corners[4], color);
            shape.Vertices[18] = new VertexPositionColor(corners[1], color);
            shape.Vertices[19] = new VertexPositionColor(corners[5], color);
            shape.Vertices[20] = new VertexPositionColor(corners[2], color);
            shape.Vertices[21] = new VertexPositionColor(corners[6], color);
            shape.Vertices[22] = new VertexPositionColor(corners[3], color);
            shape.Vertices[23] = new VertexPositionColor(corners[7], color);
        }
        public static void Render(BoundingFrustum frustum,
                                  GraphicsDevice graphicsDevice,
                                  Matrix view,
                                  Matrix projection,
                                  Color color)
        {
            if (_basicEffect.IsNull())
                _basicEffect = new BasicEffect(graphicsDevice)
                                   {
                                       VertexColorEnabled = true,
                                       LightingEnabled = false
                                   };

            var corners = frustum.GetCorners();

            for (var i = 0; i < 8; i++)
            {
                Vertices[i].Position = corners[i];
                Vertices[i].Color = color;
            }

            _basicEffect.View = view;
            _basicEffect.Projection = projection;

            foreach (var pass in _basicEffect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.LineList,
                                                         Vertices,
                                                         0,
                                                         8,
                                                         Indices,
                                                         0,
                                                         Indices.Length/2);
            }
        }
示例#43
0
        Matrix CreateLightViewProjectionMatrix()
        {
            // Matrix with that will rotate in points the direction of the light
            Matrix lightRotation = Matrix.CreateLookAt(Vector3.Zero,
                                                       -lightDir,
                                                       Vector3.Up);

            // Get the corners of the frustum
            //float FOV = MathHelper.Clamp(
            //            (25 * (mouseCamera.cameraPosition.Y / 5)),  // == 90 at height: 18
            //            10, 90 );

            float FOV = MathHelper.ToRadians(45);

            float FAR_PLANE = 20000;

            //float FAR_PLANE = (100 * (MathHelper.Clamp(
            //    (mouseCamera.cameraPosition.Y / 10),
            //    1f, 10f) ));
            //   // *      MathHelper.Clamp( mouseCamera.updownRot, 0.5f, 1f) );

            Matrix newProjMatrix = Matrix.CreatePerspectiveFieldOfView(
                MathHelper.ToRadians( FOV ),   //MathHelper.PiOver4,
               1.0f,
               1f, FAR_PLANE);

            BoundingFrustum newFrustum = new BoundingFrustum(Matrix.CreateLookAt
                (mouseCamera.cameraPosition,
                mouseCamera.cameraPosition + lightDir,
                Vector3.Up) *
                newProjMatrix);

            //cameraFrustum.Matrix = viewMatrix * parentGame.projectionMatrix;
            //Vector3[] frustumCorners = mouseCamera.cameraFrustum.GetCorners();
            Vector3[] frustumCorners = newFrustum.GetCorners();

            // Transform the positions of the corners into the direction of the light
            for (int i = 0; i < frustumCorners.Length; i++)
            {
                frustumCorners[i] = Vector3.Transform(frustumCorners[i], lightRotation);
            }

            // Find the smallest box around the points
            BoundingBox lightBox = BoundingBox.CreateFromPoints(frustumCorners);

            Vector3 boxSize = lightBox.Max - lightBox.Min ;
            Vector3 halfBoxSize = boxSize * 0.5f;

            // The position of the light should be in the center of the back
            // pannel of the box.

            Vector3 lightPosition = lightBox.Min + halfBoxSize;
            lightPosition.Z = lightBox.Min.Z;

            // We need the position back in world coordinates so we transform
            // the light position by the inverse of the lights rotation
            lightPosition = Vector3.Transform(lightPosition,
                                              Matrix.Invert(lightRotation));

            // Create the view matrix for the light
            Matrix lightView = Matrix.CreateLookAt(lightPosition,
                                                   lightPosition - lightDir,
                                                   Vector3.Up);

            // Create the projection matrix for the light
            // The projection is orthographic since we are using a directional light
            Matrix lightProjection = Matrix.CreateOrthographic(boxSize.X, boxSize.Y,
                                                               -boxSize.Z, boxSize.Z);

            return lightView * lightProjection;
        }
示例#44
0
        /// <summary>
        /// Updates this cameras position (used to smooth the movement)
        /// </summary>
        public void Update()
        {
            if (firstRun)
            {
                finalPosition = Position;
                finalTarget = Target;
            }
            firstRun = false;

            if (ControlType == CameraControlType.ThirdPerson)
            {
                Position = Vector3.Lerp(Position, finalPosition, SmoothFactor);
                finalTarget = Target;
            }
            else if (ControlType == CameraControlType.FirstPerson)
            {
                Target = Vector3.Lerp(Target, finalTarget, SmoothFactor);
                finalPosition = Position;
            }

            if (ControlType == CameraControlType.ThirdPerson)
                finalPosition = finalTarget + Vector3.Transform(Vector3.Backward, Matrix.CreateFromYawPitchRoll(Yaw, -Pitch, 0)) * Distance;
            else if (ControlType == CameraControlType.FirstPerson)
                finalTarget = finalPosition + Vector3.Transform(Vector3.Forward, Matrix.CreateFromYawPitchRoll(Yaw, Pitch, 0)) * Distance;

            // Compute the view and projection matrix
            View = Matrix.CreateLookAt(Position, Target, Vector3.Transform(Vector3.Up, Matrix.CreateFromYawPitchRoll(Yaw, -Pitch, Roll)));
            Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, game.GraphicsDevice.Viewport.AspectRatio, NearPlane, FarPlane);

            // Compute frustum and corners
            Frustum = new BoundingFrustum(View * Projection);

            Vector3[] frustumCorners = Frustum.GetCorners();
            for (int i = 0; i < 4; i++)
                frustumCorners[i] = frustumCorners[i + 4];
            Array.Resize(ref frustumCorners, 4);

            Vector3 corner = frustumCorners[2];
            frustumCorners[2] = frustumCorners[3];
            frustumCorners[3] = corner;

            FrustumCorners = frustumCorners;
        }
示例#45
0
        public void Render(GameTime g, Camera cam)
        {
            float dt = (float)g.ElapsedGameTime.TotalSeconds;
            float elapsed = (float)g.TotalGameTime.TotalSeconds;

            device.SetRenderTargets(colorTarget, normalTarget, depthTarget);
            clearGBufferEffect.Parameters["farplane"].SetValue(cam.FarPlane);
            postProcessor.DrawFullScreenQuad(clearGBufferEffect);

            device.BlendState = BlendState.Opaque;
            device.DepthStencilState = DepthStencilState.Default;

            BoundingFrustum frustum = new BoundingFrustum(cam.View * cam.Projection);
            //renderGBufferEffect.Parameters["frustumCorners"].SetValue(frustum.GetCorners());

            foreach (Model m in models)
            {
                foreach (ModelMesh mesh in m.Meshes)
                {
                    foreach (ModelMeshPart meshPart in mesh.MeshParts)
                    {
                        Effect effect = meshPart.Effect;

                        effect.Parameters["World"].SetValue(Matrix.Identity);
                        effect.Parameters["View"].SetValue(cam.View);
                        effect.Parameters["Projection"].SetValue(cam.Projection);
                    }

                    mesh.Draw();
                }
            }

            //Texture2D result = postProcessor.Process(normalTarget, colorTarget, depthTarget, normalTarget);

            device.SetRenderTarget(colorTarget);
            device.Clear(Color.Red);

            //PostProcessor.DrawFullScreenQuad(depthTarget);
            Vector3[] corners = frustum.GetCorners();
            Vector3[] farCorners = new Vector3[4];
            for (int i = 0; i < corners.Length; i++)
            {
                corners[i] = Vector3.Transform(corners[i], cam.View);
            }

            for (int i = 0; i < 4; i++)
            {
                farCorners[i] = corners[i + 4] - corners[i];
            }

            ssaoEffect.Parameters["frustumCorners"].SetValue(farCorners);
            ssaoEffect.Parameters["depthMap"].SetValue(depthTarget);
            ssaoEffect.Parameters["normalMap"].SetValue(normalTarget);
            ssaoEffect.Parameters["noiseMap"].SetValue(NoiseMap);
            ssaoEffect.Parameters["halfPixel"].SetValue(new Vector2(0.5f / (float)device.PresentationParameters.BackBufferWidth,
                                                        0.5f / (float)device.PresentationParameters.BackBufferHeight));
            ssaoEffect.Parameters["Projection"].SetValue(cam.Projection);
            ssaoEffect.Parameters["invProjection"].SetValue(Matrix.Invert(cam.Projection));
            Matrix tempView = cam.View;
            tempView.M41 = 0;
            tempView.M42 = 0;
            tempView.M43 = 0;
            tempView.M44 = 0;
            ssaoEffect.Parameters["View"].SetValue(tempView);
            ssaoEffect.Parameters["radius"].SetValue(radius);

            PostProcessor.DrawFullScreenQuad(ssaoEffect);

            Texture2D result = postProcessor.Process(colorTarget, colorTarget, depthTarget, normalTarget);

            device.SetRenderTarget(null);
            device.Clear(Color.Red);
            postProcessor.DrawFullScreenQuad(result);
        }
示例#46
0
        public void GetChunksIntersecting(BoundingFrustum frustum, HashSet<VoxelChunk> chunks)
        {
            chunks.Clear();
            BoundingBox frustumBox = MathFunctions.GetBoundingBox(frustum.GetCorners());
            GetChunksIntersecting(frustumBox, chunks);

            chunks.RemoveWhere(chunk => frustum.Contains(chunk.GetBoundingBox()) == ContainmentType.Disjoint);
        }
示例#47
0
        public static void Intersects(ref Ray ray, ref BoundingFrustum boundingFrustum, out float? result)
        {
            // TODO: Make test case of this
            if (boundingFrustum.Contains(ray.Position) == ContainmentType.Contains)
            {
                // the ray is inside the frustum
                result = 0.0f;
            }
            else
            {
                result = null;

                var corners = boundingFrustum.GetCorners();
                for (int i = 0; i < (BoundingFrustum.PlaneCount * 2); i++)
                {
                    var v1 = corners[Geometry.TriangleIndices[i + 0]];
                    var v2 = corners[Geometry.TriangleIndices[i + 1]];
                    var v3 = corners[Geometry.TriangleIndices[i + 2]];

                    Intersects(ref ray, ref v1, ref v2, ref v3, out result);

                    if (result.HasValue)
                        break;
                }
            }
        }
示例#48
0
        public static void Render(BoundingFrustum frustum, GraphicsDevice graphicsDevice, Matrix view, Matrix projection, Color color)
        {
            VertexPositionColorNormal[] boxVertices = new VertexPositionColorNormal[8];
            Vector3[] corners = frustum.GetCorners();

            for (int i = 0; i < 8; i++) {
                boxVertices[i].Position = corners[i];
                boxVertices[i].Color = Color.White;
                boxVertices[i].Normal = Vector3.Up;
            }

            short[] boxLines = new short[] {
                0, 1,
                1, 2,
                2, 3,
                3, 0,
                0, 4,
                1, 5,
                2, 6,
                3, 7,
                4, 5,
                5, 6,
                6, 7,
                7, 4
            };

            VertexBuffer buffer = new VertexBuffer(
                graphicsDevice,
                VertexPositionColorNormal.VertexDeclaration,
                boxVertices.Length,
                BufferUsage.WriteOnly);

            buffer.SetData(boxVertices);

            IndexBuffer indexBuffer = new IndexBuffer(graphicsDevice, typeof(short), boxLines.Length, BufferUsage.WriteOnly);

            indexBuffer.SetData(boxLines);

            graphicsDevice.Indices = indexBuffer;
            graphicsDevice.SetVertexBuffer(buffer);

            effect.World = Matrix.Identity;
            effect.View = view;
            effect.Projection = projection;
            effect.DiffuseColor = color.ToVector3();

            foreach (EffectPass pass in effect.CurrentTechnique.Passes) {
                pass.Apply();
                graphicsDevice.DrawIndexedPrimitives(PrimitiveType.LineList, 0, 0, boxVertices.Length, 0, boxLines.Length / 2);
            }
        }
示例#49
0
        public void DrawCamera(RTSRenderer renderer, Rectangle scissor)
        {
            BoundingFrustum f = new BoundingFrustum(renderer.Camera.View * renderer.Camera.Projection);
            Vector3[] corners = f.GetCorners();
            for(int i = 0; i < 4; i++) {
                Vector3 dir = corners[i + 4] - corners[i];
                float min = dir.Length();
                dir /= min;
                Ray r = new Ray(corners[i], dir);

                foreach(Plane p in mapPlanes) {
                    float? v = r.Intersects(p);
                    if(v != null && v.Value < min) {
                        min = v.Value;
                    }
                }

                corners[i + 4] = r.Position + (r.Direction * min);
            }
            VertexPositionColor[] verts = {
                new VertexPositionColor(corners[0], CAMERA_COLOR_START),
                new VertexPositionColor(corners[1], CAMERA_COLOR_START),
                new VertexPositionColor(corners[3], CAMERA_COLOR_START),
                new VertexPositionColor(corners[2], CAMERA_COLOR_START),
                new VertexPositionColor(corners[4], CAMERA_COLOR_END),
                new VertexPositionColor(corners[5], CAMERA_COLOR_END),
                new VertexPositionColor(corners[7], CAMERA_COLOR_END),
                new VertexPositionColor(corners[6], CAMERA_COLOR_END)
            };
            renderer.G.BlendState = BlendState.Additive;
            renderer.G.DepthStencilState = DepthStencilState.None;
            renderer.G.RasterizerState = RasterizerState.CullNone;
            fxCamera.CurrentTechnique.Passes[0].Apply();
            Viewport vp = renderer.G.Viewport;
            renderer.G.Viewport = new Viewport(scissor);
            renderer.G.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, verts, 0, 8, FRUSTUM_INDS, 0, 12);
            renderer.G.Viewport = vp;
        }
示例#50
0
    private void DrawNodeFrustum(TerrainNode node)
    {

      // calculate the width of the patch; first we need a vertex on both sides of the patch, in planet space
      Vector3 p1 = node.Position.AsVector3 + node.VertexBuffer.Vertices[1 * 33 + 1].Position;
      Vector3 p2 = node.Position.AsVector3 + node.VertexBuffer.Vertices[1 * 33 + 33].Position;

      // need to move them to the sphere radius
      p1.Normalize();
      p1 *= (float)sphere.Radius;

      p2.Normalize();
      p2 *= (float)sphere.Radius;

      // now we can calculate the opposite and hypotenuse lengths
      float opposite = Vector3.Distance(p1, p2) * 0.5f;    // width is distance between p1 and p2, and we need just half of it
      float hypotenuse = (float)sphere.Radius;

      // once we have the width we can calculate the field of view
      float fieldOfView = (float)(2.0 * Math.Asin(opposite / hypotenuse));

      // now we can create the view and projection matrixes
      Matrix view = Matrix.CreateLookAt(Vector3.Zero, node.Position.AsVector3, Vector3.Up);
      Matrix projection = Matrix.CreatePerspectiveFieldOfView(fieldOfView, 1.0f, 1.0f, 9000.0f);

      // which then lets us create the bounding frustum
      BoundingFrustum frustum = new BoundingFrustum(view * projection);

      Vector3[] corners = frustum.GetCorners();

      // draw lines between corners

      VertexPositionColor[] vertices = new VertexPositionColor[24];

      Position3 p = Position3.Zero;

      Position3 p0 = node.Position;
      p0.Normalize();
      p0 *= 9000.0f;


      // line 1
      vertices[0] = new VertexPositionColor(corners[0], Color.White);
      vertices[1] = new VertexPositionColor(corners[1], Color.White);

      // line 2
      vertices[2] = new VertexPositionColor(corners[1], Color.White);
      vertices[3] = new VertexPositionColor(corners[2], Color.White);

      // line 3
      vertices[4] = new VertexPositionColor(corners[2], Color.White);
      vertices[5] = new VertexPositionColor(corners[3], Color.White);

      // line 4
      vertices[6] = new VertexPositionColor(corners[3], Color.White);
      vertices[7] = new VertexPositionColor(corners[0], Color.White);


      // line 5
      vertices[8] = new VertexPositionColor(corners[4], Color.White);
      vertices[9] = new VertexPositionColor(corners[5], Color.White);

      // line 6
      vertices[10] = new VertexPositionColor(corners[5], Color.White);
      vertices[11] = new VertexPositionColor(corners[6], Color.White);

      // line 7
      vertices[12] = new VertexPositionColor(corners[6], Color.White);
      vertices[13] = new VertexPositionColor(corners[7], Color.White);

      // line 8
      vertices[14] = new VertexPositionColor(corners[7], Color.White);
      vertices[15] = new VertexPositionColor(corners[4], Color.White);


      // line 9
      vertices[16] = new VertexPositionColor(corners[0], Color.White);
      vertices[17] = new VertexPositionColor(corners[4], Color.White);

      // line 10
      vertices[18] = new VertexPositionColor(corners[1], Color.White);
      vertices[19] = new VertexPositionColor(corners[5], Color.White);

      // line 11
      vertices[20] = new VertexPositionColor(corners[2], Color.White);
      vertices[21] = new VertexPositionColor(corners[6], Color.White);

      // line 12
      vertices[22] = new VertexPositionColor(corners[3], Color.White);
      vertices[23] = new VertexPositionColor(corners[7], Color.White);



      GraphicsDevice device = graphics.GraphicsDevice;
      // TODO : device.RenderState.CullMode = CullMode.None;


      // get world space position for drawing the frustum
      Position3 worldSpacePosition = sphere.Position;

      // translate to camera space by subtracting the camera position, scale by planet scale
      Position3 cameraSpacePosition = (worldSpacePosition - mainCamera.Position) * sphere.Scale;

      // create world matrix
      Matrix cameraSpaceMatrix = sphere.ScaleMatrix * Matrix.CreateTranslation(cameraSpacePosition.AsVector3);


      testEffect.Projection = mainCamera.ProjectionMatrix;
      testEffect.World = cameraSpaceMatrix;
      testEffect.View = mainCamera.ViewMatrix;
      //testEffect.EnableDefaultLighting();
      testEffect.VertexColorEnabled = true;


      testEffect.CurrentTechnique.Passes[0].Apply();
      GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineList, vertices, 0, 12);
    }
示例#51
0
        /// <summary>
        /// Renders the bounding frustum for debugging purposes.
        /// </summary>
        /// <param name="frustum">The frustum to render.</param>
        /// <param name="graphicsDevice">The graphics device to use when rendering.</param>
        /// <param name="view">The current view matrix.</param>
        /// <param name="projection">The current projection matrix.</param>
        /// <param name="color">The color to use drawing the lines of the frustum.</param>
        public static void Render(
            BoundingFrustum frustum,
            GraphicsDevice graphicsDevice,
            Matrix view,
            Matrix projection,
            Color color)
        {
            if (effect == null)
            {
                effect = new BasicEffect(graphicsDevice, null);
                effect.VertexColorEnabled = true;
                effect.LightingEnabled = false;
                vertDecl = new VertexDeclaration(graphicsDevice, VertexPositionColor.VertexElements);
            }

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

            graphicsDevice.VertexDeclaration = vertDecl;

            effect.View = view;
            effect.Projection = projection;

            effect.Begin();
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Begin();

                graphicsDevice.DrawUserIndexedPrimitives(
                    PrimitiveType.LineList,
                    verts,
                    0,
                    8,
                    indices,
                    0,
                    indices.Length / 2);

                pass.End();
            }
            effect.End();
        }
示例#52
0
        public static void DrawBoundingFrustum(BoundingFrustum boundingFrustum, Color color)
        {               
            boundingFrustum.GetCorners(m_frustumCorners);

            DrawCorners(m_frustumCorners, color);
        }
示例#53
0
        // run from another thread during update to calc the view projection matrix and do culling
        public void CalcCascades(ref Matrix view, ref Matrix projection, float nearClip, float farClip, float clipRange)
        {
            // Get the corners of the frustum
            BoundingFrustum cameraFrustum = new BoundingFrustum(view * projection);
            cameraFrustum.GetCorners(frustumCornersWS);
            Matrix eyeTransform = view;
            Vector3.Transform(frustumCornersWS, ref eyeTransform, frustumCornersVS);

            // Get camera near and far values
            float near = nearClip;
            float far = MathHelper.Min(farClip, ShadowDistance);

            splitDepthsTmp[0] = near;
            splitDepthsTmp[NUM_CASCADES] = far;

            // Compute cascade split depths
            for (int i = 1; i < splitDepthsTmp.Length - 1; i++)
                splitDepthsTmp[i] = near + (far - near) * (float)Math.Pow((i / (float)NUM_CASCADES), 2);
            //splitDepthsTmp[1] = 35.0f;

            for (int i = 0; i < NUM_CASCADES; i++)
            {
                // Convert the split depths to percent of view range, so we can pass them to shader later
                LightClipPlanes[i].X = (splitDepthsTmp[i] - nearClip) / clipRange;
                LightClipPlanes[i].Y = (splitDepthsTmp[i + 1] - nearClip) / clipRange;

                // Create the view projection matrix for this cascade
                LightViewProjectionMatrices[i] = CreateLightViewProjectionMatrix(directionToSun, far, splitDepthsTmp[i], splitDepthsTmp[i + 1], i);
                LightFrustums[i] = new Engine.Utilities.FastFrustum(ref LightViewProjectionMatrices[i]);
            }

            Renderer.Instance.DoShadowsCulling(LightFrustums);
        }
示例#54
0
        public void DrawFrustum( BoundingFrustum frustum, Color color )
        {
            var points = frustum.GetCorners();

            DrawLine( points[0], points[1], color );
            DrawLine( points[1], points[2], color );
            DrawLine( points[2], points[3], color );
            DrawLine( points[3], points[0], color );

            DrawLine( points[4], points[5], color );
            DrawLine( points[5], points[6], color );
            DrawLine( points[6], points[7], color );
            DrawLine( points[7], points[4], color );

            DrawLine( points[0], points[4], color );
            DrawLine( points[1], points[5], color );
            DrawLine( points[2], points[6], color );
            DrawLine( points[3], points[7], color );
        }
示例#55
0
        //  Return true if bounding sphere of this object intersects bounding frustum
        public virtual bool GetIntersectionWithBoundingFrustum(ref BoundingFrustum boundingFrustum)
        {
            ContainmentType con = boundingFrustum.Contains(WorldAABB);
            if (con == ContainmentType.Contains)
            {
                return true;
            }

            if (con == ContainmentType.Intersects)
            {
                if (ModelLod0 == null)
                {
                    return true;
                }

                for (int v = 0; v < ModelLod0.GetVerticesCount(); v++)
                {
                    Vector3 vet = ModelLod0.GetVertex(v);
                    Vector3 transformed = Vector3.Transform(vet, WorldMatrix);
                    ContainmentType con2 = boundingFrustum.Contains(transformed);
                    if (con2 != ContainmentType.Disjoint)
                    {
                        return true;
                    }
                }

                boundingFrustum.GetCorners(m_frustumIntersectionCorners);
                MyLine l0 = new MyLine(m_frustumIntersectionCorners[0], m_frustumIntersectionCorners[4], true);
                MyLine l1 = new MyLine(m_frustumIntersectionCorners[1], m_frustumIntersectionCorners[5], true);
                MyLine l2 = new MyLine(m_frustumIntersectionCorners[2], m_frustumIntersectionCorners[6], true);
                MyLine l3 = new MyLine(m_frustumIntersectionCorners[3], m_frustumIntersectionCorners[7], true);

                var prun = ModelLod0.GetTrianglePruningStructure();

                if (prun.GetIntersectionWithLine(this, ref l0).HasValue || prun.GetIntersectionWithLine(this, ref l1).HasValue
                    || prun.GetIntersectionWithLine(this, ref l2).HasValue || prun.GetIntersectionWithLine(this, ref l3).HasValue)
                {
                    return true;
                }
            }

            return false;
        }
示例#56
0
 /// <summary>
 /// Renders the outline of a bounding frustum
 /// </summary>
 /// <param name="frustum">Bounding frustum to render</param>
 /// <param name="color">Color of the frustum lines</param>
 public void DrawWireFrustum(BoundingFrustum frustum, Color color)
 {
     DrawWireShape(frustum.GetCorners(), cubeIndices, color);
 }
示例#57
0
        public static void AddBoundingFrustum(BoundingFrustum frustum, Color color, float life)
        {
            DebugShape shape = GetShapeForLines(12, life);

            frustum.GetCorners(Corners);

            shape.Vertices[0] = new VertexPositionColor(Corners[0], color);
            shape.Vertices[1] = new VertexPositionColor(Corners[1], color);
            shape.Vertices[2] = new VertexPositionColor(Corners[1], color);
            shape.Vertices[3] = new VertexPositionColor(Corners[2], color);
            shape.Vertices[4] = new VertexPositionColor(Corners[2], color);
            shape.Vertices[5] = new VertexPositionColor(Corners[3], color);
            shape.Vertices[6] = new VertexPositionColor(Corners[3], color);
            shape.Vertices[7] = new VertexPositionColor(Corners[0], color);

            shape.Vertices[8] = new VertexPositionColor(Corners[4], color);
            shape.Vertices[9] = new VertexPositionColor(Corners[5], color);
            shape.Vertices[10] = new VertexPositionColor(Corners[5], color);
            shape.Vertices[11] = new VertexPositionColor(Corners[6], color);
            shape.Vertices[12] = new VertexPositionColor(Corners[6], color);
            shape.Vertices[13] = new VertexPositionColor(Corners[7], color);
            shape.Vertices[14] = new VertexPositionColor(Corners[7], color);
            shape.Vertices[15] = new VertexPositionColor(Corners[4], color);

            shape.Vertices[16] = new VertexPositionColor(Corners[0], color);
            shape.Vertices[17] = new VertexPositionColor(Corners[4], color);
            shape.Vertices[18] = new VertexPositionColor(Corners[1], color);
            shape.Vertices[19] = new VertexPositionColor(Corners[5], color);
            shape.Vertices[20] = new VertexPositionColor(Corners[2], color);
            shape.Vertices[21] = new VertexPositionColor(Corners[6], color);
            shape.Vertices[22] = new VertexPositionColor(Corners[3], color);
            shape.Vertices[23] = new VertexPositionColor(Corners[7], color);
        }
示例#58
0
 public static void Intersects(ref BoundingFrustum boundingFrustum, ref Plane plane, out PlaneIntersectionType result)
 {
     var corners = boundingFrustum.GetCorners();
     result = plane.Intersects(corners[0]);
     for (int i = 1; i < corners.Length; i++)
         if (plane.Intersects(corners[i]) != result)
             result = PlaneIntersectionType.Intersecting;
 }