示例#1
1
        /// <summary>
        /// Checks the mouse's position set in the in-game world plane.
        /// </summary>
        /// <param name="mousePosition">Mouse's position on screen</param>
        /// <param name="camera">Camera object</param>
        /// <param name="device">Graphics device used in rendering</param>
        /// <returns></returns>
        public static Vector3 getMouseWorldPosition(Vector2 mousePosition,CameraAndLights camera,GraphicsDevice device)
        {
            Vector3 nearsource = new Vector3(mousePosition,0f);
            Vector3 farsource = new Vector3(mousePosition,CameraAndLights.nearClip);

            Vector3 nearPoint = device.Viewport.Unproject(nearsource,
                                                          camera.projectionMatrix,
                                                          camera.viewMatrix,
                                                          Matrix.Identity);

            Vector3 farPoint = device.Viewport.Unproject(farsource,
                                                         camera.projectionMatrix,
                                                         camera.viewMatrix,
                                                         Matrix.Identity);

            // Create a ray from the near clip plane to the far clip plane.
            Vector3 direction = farPoint - nearPoint;
            direction.Normalize();
            Ray pickRay = new Ray(nearPoint,direction);

            Plane floor = new Plane(new Vector3(0f,1f,0f),0f);

            float denominator = Vector3.Dot(floor.Normal,pickRay.Direction);
            float numerator = Vector3.Dot(floor.Normal,pickRay.Position) + floor.D;
            float dist = -(numerator / denominator);

            Vector3 mouseWorldPos = nearPoint + direction * dist;

            return mouseWorldPos * new Vector3(1f,0f,1f);
        }
示例#2
0
        public override void CalculateLocalMouse(Ray mouseRay, Action<VertexPositionColor, VertexPositionColor> debug)
        {
            MouseHover = false;

            var verts = new Vector3[3];
            verts[0] = new Vector3(-0.5f, -0.5f, 0);
            verts[1] = new Vector3(0.5f, -0.5f, 0);
            verts[2] = new Vector3(-0.5f, 0.5f, 0);

            for (int i = 0; i < 3; ++i)
                verts[i] = Vector3.Transform(verts[i], localTransformation);

            debug(new VertexPositionColor(verts[0], Color.Red), new VertexPositionColor(verts[1], Color.Red));
            debug(new VertexPositionColor(verts[0], Color.Green), new VertexPositionColor(verts[2], Color.Green));

            var distance = mouseRay.Intersects(new Plane(verts[0], verts[1], verts[2]));
            if (distance == null || !distance.HasValue) return;
            if (distance.Value < 0) return; //GUI plane is behind camera
            var interesectionPoint = mouseRay.Position + (mouseRay.Direction * distance.Value);

            debug(new VertexPositionColor(verts[0], Color.Blue), new VertexPositionColor(interesectionPoint, Color.Blue));

            var x = ScalarProjection(interesectionPoint - verts[0], verts[1] - verts[0]) / (verts[1] - verts[0]).Length();
            var y = ScalarProjection(interesectionPoint - verts[0], verts[2] - verts[0]) / (verts[2] - verts[0]).Length();

            LocalMouseX = (int)(x * uiCamera.viewportDimensions.X);
            LocalMouseY = (int)(y * uiCamera.viewportDimensions.Y);

            MouseHover = true;
        }
示例#3
0
        public override void CalculateLocalMouse(Ray MouseRay, Action<Gem.Render.SceneNode, float> HoverCallback)
        {
            MouseHover = false;

            if (InteractWithMouse == false) return;

            var localMouse = GetLocalMouseRay(MouseRay);

            var intersection = Mesh.RayIntersection(localMouse);

            if (intersection.Intersects)
            {
                LocalMouse = Vector2.Transform(intersection.UV, UVTransform);
                if (AlphaMouse)
                {
                    var pixel = new Color[] { new Color(1.0f, 1.0f, 1.0f, 1.0f) };
                    var pX = (int)System.Math.Round(LocalMouse.X * Texture.Width);
                    var pY = (int)System.Math.Round(LocalMouse.Y * Texture.Height);
                    Texture.GetData<Color>(0, new Rectangle(pX, pY, 1, 1), pixel, 0, 1);
                    if (pixel[0].A > 0.01f)
                        HoverCallback(this, intersection.Distance);
                }
                else
                    HoverCallback(this, intersection.Distance);
            }
        }
示例#4
0
        public static List<IPickable> GetPickables(Point a_clickPoint)
        {
            var camera = CameraManager.ActiveCamera;

               Vector3 nearSource = camera.Viewport.Unproject(new Vector3(a_clickPoint.X, a_clickPoint.Y, camera.Viewport.MinDepth), camera.Projection, camera.View, Matrix.Identity);
               Vector3 farSource = camera.Viewport.Unproject(new Vector3(a_clickPoint.X, a_clickPoint.Y, camera.Viewport.MaxDepth), camera.Projection, camera.View, Matrix.Identity);
               Vector3 direction = farSource - nearSource;

               direction.Normalize();

               var ray = new Ray(nearSource, direction);

               var pickables = new List<IPickable>();
               var rays = new List<Ray>();
               var map = new Dictionary<float?, IPickable>();

               foreach (var pickable in ComponentManager.Pickables.Values)
               {
               BoundingBox boundingBox = pickable.GetBoundingBox();
               float? distance;
               ray.Intersects(ref boundingBox, out distance);
               if (distance != null)
               {
                   map[distance] = pickable;
                   pickables.Add(pickable);
               }
               }

               return pickables;
        }
        public float? checkCollisionAgainstEnvironment(Ray ray)
        {
            float? collided = null;
            foreach (Collidable c in stationaryCollidables)
            {
                if (c.type == CollisionType.environment && collided == null)
                {
                    Vector3[] points = new Vector3[2];
                    points[0] = Vector3.Transform(c.boundingBox.Min, c.getComponent<Spatial>().transform);
                    points[1] = Vector3.Transform(c.boundingBox.Max, c.getComponent<Spatial>().transform);
                    BoundingBox bb = BoundingBox.CreateFromPoints(points);
                    if (ray.Intersects(bb) != null)
                    {
                        if (c.children.Count > 0)
                        {
                            collided = checkAgainstChildren(c, ray);
                        }
                        else
                        {
                            collided = checkAgainstMesh(c.getComponent<Drawable3D>(), ray);
                        }
                    }
                }
            }

            return collided;
        }
示例#6
0
        public void Update(float dt)
        {
            Position += Velocity * dt;
            Velocity -= new Vector3(0, Gravity * dt, 0);
            Velocity *= (1f - Damping);

            Vector3 direction = Velocity;
            direction.Normalize();
            Ray ray = new Ray(Position, direction);//Vector3.Transform(Vector3.Forward, Orientation));
            RayCastResult result;
            Sector.Redria.Space.RayCast(ray, 2, out result);
            if (result.HitObject != null)
            {
                if (result.HitObject.Tag is ShipObj)
                {
                    var ship = (ShipObj)result.HitObject.Tag;
                    var magnitude = Velocity.Length();
                    //var angle = Vector3.Dot(result.HitData.Normal,Velocity)/magnitude;
                    float velocity = magnitude;//(float)(magnitude*angle);
                    ship.BulletStrike(Data,velocity);
                }
                Sector.Redria.Bullets.Remove(this);
            }
            if (Position.Y < -5) Sector.Redria.Bullets.Remove(this);
        }
示例#7
0
 public Shot(Ray Trac, float Caliber, Being Origin)
 {
     Tracer = Trac;
     TimeToDie = Environment.TickCount+100;
     this.Caliber = Caliber;
     this.Origin = Origin;
 }
示例#8
0
文件: Shader.cs 项目: furaga/CGs
        public Vector3 shading(Vector3 pos, Vector3 norm, Ray ray, Actor actor, bool isShade)
        {
            // 点光源
            var l = light - pos;
            var l2 = l.LengthSquared();
            l.Normalize();

            // 視線
            var dir = ray.Position - pos;
            dir.Normalize();

            // ハーフベクトル
            var h = dir + l;
            h.Normalize();

            var ln = Vector3.Dot(l, norm);
            var hn = Vector3.Dot(h, norm);
            if (ln < 0) ln = 0;
            if (hn < 0) hn = 0;

            var dst = actor.GetColor(isShade ? 0.0f : ln, hn, pos);

            // 光源の色の反映
            dst.X *= lightColor.X;
            dst.Y *= lightColor.Y;
            dst.Z *= lightColor.Z;

            // 光の強さの適当な補正
            //dst *= Math.Min(1.5f, 500000.0f / (10000.0f + l2));
            //dst *= Math.Min(1.0f, l.Y + 0.1f);

            return dst;
        }
示例#9
0
        /// <summary>
        /// Determines whether there is a cliff nearby.
        /// </summary>
        /// <param name="position">Position to look from.</param>
        /// <param name="facingDirection">Direction to check in.</param>
        /// <param name="filter">Anonymous function to filter out unwanted objects.</param>
        /// <param name="space">The space to check for a cliff in.</param>
        /// <param name="distance">The distance to check at.</param>
        /// <returns>True if a cliff was detected, false otherwise.</returns>
        public static bool FindCliff(Vector3 position, Vector3 facingDirection, Func<BroadPhaseEntry, bool> filter, Space space, float distance)
        {
            // If there is a wall before the requested distance assume there is no cliff.
            Ray forwardRay = new Ray(position, new Vector3(facingDirection.X, 0, facingDirection.Z));
            RayCastResult forwardResult = new RayCastResult();
            space.RayCast(forwardRay, filter, out forwardResult);
            if ((forwardResult.HitData.Location - position).Length() < distance)
            {
                return false;
            }

            facingDirection.Normalize();
            Ray futureDownRay = new Ray(position + new Vector3(facingDirection.X * distance, 0, facingDirection.Z * distance), Vector3.Down);
            RayCastResult result = new RayCastResult();
            space.RayCast(futureDownRay, filter, out result);

            Vector3 drop = result.HitData.Location - futureDownRay.Position;
            if (drop.Y < -6.0f)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
示例#10
0
        public Monstre GetSourisBoxIntercept(List<Monstre> monstres)
        {
            Vector3 nearScreenPoint = new Vector3(ÉtatSouris.X, ÉtatSouris.Y, 0);
             Vector3 farScreenPoint = new Vector3(ÉtatSouris.X, ÉtatSouris.Y, 1);
             Vector3 nearWorldPoint = Jeu.PériphériqueGraphique.GraphicsDevice.Viewport.Unproject(nearScreenPoint, ScèneJeu.CaméraJeu.Projection, ScèneJeu.CaméraJeu.Vue, Matrix.Identity);
             Vector3 farWorldPoint = Jeu.PériphériqueGraphique.GraphicsDevice.Viewport.Unproject(farScreenPoint, ScèneJeu.CaméraJeu.Projection, ScèneJeu.CaméraJeu.Vue, Matrix.Identity);
             Vector3 direction = farWorldPoint - nearWorldPoint;
             Ray raySouris = new Ray(nearWorldPoint, direction);

             float distancemin = float.MaxValue;
             float? distance;
             Monstre cible = null;
             foreach (Monstre monstre in monstres)
             {
            foreach (BoundingBox box in monstre.BoxList)
            {
               distance = raySouris.Intersects(box);
               if (distance != null && distance < distancemin)
               {
                  distancemin = (float)distance;
                  cible = monstre;
               }
            }
             }
             return cible;
        }
示例#11
0
        private void GenerateRect()
        {
            int minX = int.MaxValue;
            int minZ = int.MaxValue;
            int maxX = int.MinValue;
            int maxZ = int.MinValue;
            var corners = Frustum.GetCorners();

            Plane plane = new Plane(new Vector4(0, 1, 0, 0));
            for (int i = 4; i < corners.Length; i++)
            {
                Ray ray = new Ray(corners[i - 4], corners[i]);
                var distance = ray.Intersects(plane);
                if (distance.HasValue)
                {
                    var pos2 = ray.Position + ray.Direction * distance.Value;
                    if ((int)pos2.X > maxX)
                        maxX = (int)pos2.X;
                    if ((int)pos2.X < minX)
                        minX = (int)pos2.X;
                    if ((int)pos2.Z > maxZ)
                        maxZ = (int)pos2.Z;
                    if ((int)pos2.Z < minZ)
                        minZ = (int)pos2.Z;
                }
                // Console.WriteLine("distance[{0}]: {1} pos2:{2}", i, distance, pos2.ToString());
            }
            quadRect = new Rectangle(minX, minZ, Math.Abs(maxX - minX), Math.Abs(maxZ - minZ));
            // Console.WriteLine("X: {0},{1} Z:{2},{3}", minX, maxX, minZ, maxZ);
        }
示例#12
0
文件: LoS.cs 项目: Linusa/AI_Project
        public bool canSee()
        {
            if ((EntityManager.Instance.GetPlayer() as Rabbit).IsHidden)
                return false;
            Vector2 vecToRabbit = EntityManager.Instance.GetPlayer().Position - agent.Position;
            if (vecToRabbit.LengthSquared() < rangeSqrd)
            {
                vecToRabbit.Normalize();
                float relativeAngle = (float)Angles.AngleFromUToV(agent.Heading, vecToRabbit);
                if (relativeAngle < angleWidth && relativeAngle > angleWidth * -1)
                {
                    foreach (Wall wall in WallManager.Instance.Walls)
                    {
                        float? inter = new Ray(new Vector3(agent.Position, 0),
                            new Vector3(vecToRabbit, 0)).Intersects(
                                new BoundingBox(new Vector3(wall.BoundingBox.Left,wall.BoundingBox.Top,-10),
                                                new Vector3(wall.BoundingBox.Right,wall.BoundingBox.Bottom,10)
                                                ));
                        if (inter != null && (float)inter
                            < range)
                            return false;
                    }
                    return true;
                }
            }

            return false;
        }
示例#13
0
        // This selects a particular tile given a ray from the camera
        public Objects.Tile Intersects(Ray ray)
        {
            // It's possible that multiple tiles intersect, so we need to create a list
            // of potential tiles to select.
            LinkedList<Objects.Tile> possibles = new LinkedList<Objects.Tile>();
            foreach (Objects.Tile t in m_Tiles)
            {
                if (t.AABB.Intersects(ray) != null)
                {
                    possibles.AddLast(t);
                }
            }

            // Now select the tile that is the closest to the start position of the ray
            Objects.Tile retval = null;
            float fBestDist = 999999999.0f;
            foreach (Objects.Tile t in possibles)
            {
                float fDist = Vector3.DistanceSquared(t.Position, ray.Position);
                if (fDist < fBestDist)
                {
                    retval = t;
                    fBestDist = fDist;
                }
            }

            return retval;
        }
示例#14
0
        public override bool Intersect(Ray tRay, out float fDistance)
        {
            // calculate the vector from the ray origin to centre of sphere
            Vector3 tOriginToCentre = Centre - tRay.Position;

            // get the closest approach of the ray to the sphere
            float fClosestApproach = Vector3.Dot(tOriginToCentre, tRay.Direction);

            // if this is less than 0, the sphere is behind the ray origin
            if (fClosestApproach < 0)
            {
                fDistance = 0.0f;
                return false;
            }
            else
            {
                // calculate the distance from the centre of the sphere to
                // the closest approach
                float fLengthSq = tOriginToCentre.LengthSquared();
                float fHalfCordSq = (Radius * Radius) - fLengthSq + (fClosestApproach * fClosestApproach);

                // ray misses the sphere
                if (fHalfCordSq < 0)
                {
                    fDistance = 0.0f;
                    return false;
                }
                else
                {
                    fDistance = fClosestApproach - (float) Math.Sqrt(fHalfCordSq);
                    return true;
                }
            }
        }
示例#15
0
        /// <summary>
        /// Tests all models in the scene graph for intersection with the relative mouse coordinates. 
        /// </summary>
        /// <returns>The ModelNode object that claims to be hit by the mouse</returns>
        /// <remarks>Note that currently this algorithm uses bounding spheres, so for certain objects it will be rather inaccurate.</remarks>
        public ModelNode GetIntersectingModel(Matrix projectionMatrix, Matrix viewMatrix, Matrix worldMatrix, GraphicsDevice graphicsDevice, Vector2 mousePosition)
        {
            // Create 2 positions in screenspace near and far.
            Vector3 nearSource = new Vector3(mousePosition, 0f);
            Vector3 farSource = new Vector3(mousePosition, 1f);

            // Get equivalent positions in world space.
            Vector3 nearPoint = graphicsDevice.Viewport.Unproject(nearSource, projectionMatrix, viewMatrix, worldMatrix);
            Vector3 farPoint = graphicsDevice.Viewport.Unproject(farSource, projectionMatrix, viewMatrix, worldMatrix);

            // Find direction for cursor ray.
            Vector3 direction = farPoint - nearPoint;
            direction.Normalize();

            // and then create a new ray using nearPoint as the source.
            Ray cursorRay = new Ray(nearPoint, direction);

            foreach (ModelNode modelNode in ModelGraph)
            {
                ModelNode modelToReturn = modelNode.GetIntersectingModel(cursorRay);

                if (modelToReturn != null)
                    return modelToReturn;
            }

            return null;
        }
示例#16
0
        public Face DetermineSide(BoundingBox box, Ray ray)
        {
            Face selectedFace = Face.NONE;
            float closestDist = float.MaxValue;
            BoundingBox[] sides =
            {
                new BoundingBox(new Vector3(box.Min.X, box.Min.Y, box.Min.Z), new Vector3(box.Min.X, box.Max.Y, box.Max.Z)), //-x LEFT
                new BoundingBox(new Vector3(box.Max.X, box.Min.Y, box.Min.Z), new Vector3(box.Max.X, box.Max.Y, box.Max.Z)), //+x RIGHT
                new BoundingBox(new Vector3(box.Min.X, box.Min.Y, box.Min.Z), new Vector3(box.Max.X, box.Min.Y, box.Max.Z)), //-y TOP
                new BoundingBox(new Vector3(box.Min.X, box.Max.Y, box.Min.Z), new Vector3(box.Max.X, box.Max.Y, box.Max.Z)), //+y BOTTOM
                new BoundingBox(new Vector3(box.Min.X, box.Min.Y, box.Min.Z), new Vector3(box.Max.X, box.Max.Y, box.Min.Z)), //-z BACK
                new BoundingBox(new Vector3(box.Min.X, box.Min.Y, box.Max.Z), new Vector3(box.Max.X, box.Max.Y, box.Max.Z))  //+z FRONT
            };

            for (int i = 0; i < sides.Length; ++i)
            {
                float? d = ray.Intersects(sides[i]);
                if (d.HasValue)
                {
                    if (d.Value < closestDist)
                    {
                        closestDist = d.Value;
                        selectedFace = (Face)i;
                    }
                }
            }
            return selectedFace;
        }
示例#17
0
        /// <summary>
        /// Returns the mouse X, Y and Z coordinates on the world so that the Y is always on ground zero (0).
        /// </summary>
        /// <param name="game"></param>
        /// <returns></returns>
        public static Vector3 GetMouseWorldPosition(Game game)
        {
            GraphicsDevice graphicsDevice = game.GraphicsDevice;
            MouseState mouseState = Mouse.GetState();

            Vector3 nearSource = new Vector3((float) mouseState.X, (float) mouseState.Y, 0f);
            Vector3 farSource = new Vector3((float) mouseState.X, (float) mouseState.Y, 1f);
            Vector3 nearPoint = graphicsDevice.Viewport.Unproject(nearSource, game.Camera.Projection, game.Camera.View, Matrix.Identity);
            Vector3 farPoint = graphicsDevice.Viewport.Unproject(farSource, game.Camera.Projection, game.Camera.View, Matrix.Identity);

            // Create a ray from the near clip plane to the far clip plane.
            Vector3 direction = farPoint - nearPoint;
            direction.Normalize();

            // Create a ray.
            Ray ray = new Ray(nearPoint, direction);

            // Calculate the ray-plane intersection point.
            Vector3 n = new Vector3(0f, 1f, 0f);
            Plane p = new Plane(n, 0f);

            // Calculate distance of intersection point from r.origin.
            float denominator = Vector3.Dot(p.Normal, ray.Direction);
            float numerator = Vector3.Dot(p.Normal, ray.Position) + p.D;
            float t = -(numerator / denominator);

            // Calculate the picked position on the y = 0 plane.
            Vector3 pickedPosition = nearPoint + direction * t;

            return pickedPosition;
        }
 public WaypointsCollection ConnectWaypoints(WaypointsCollection col)
 {
     WaypointsCollection resp = new WaypointsCollection(col.MapName);
     foreach (Waypoint item in col.GetWaypointsList())
     {
         item.NeightBorWaypointsId = new List<int>();
         foreach (Waypoint item2 in col.GetWaypointsList())
         {
             if (item.Id != item2.Id)
             {
                 Vector3 dir = item2.WorldPos - item.WorldPos;
                 if (dir.Length() < maxDistance)
                 {
                     float dist = dir.Length() * 1.2f;
                     dir.Normalize();
                     Ray raio = new Ray(item.WorldPos + new Vector3(0, altura, 0), dir);
                     SegmentInterceptInfo ri = world.PhysicWorld.SegmentIntersect(raio, (a) => true, dist);
                     if (ri != null)
                     {
                         continue;
                     }
                     else
                     {
                         
                         item.NeightBorWaypointsId.Add(item2.Id);
                     }
                 }
             }
         }
     }
     resp.State = WaypointsState.Connected;
     resp.IdWaypoint = col.IdWaypoint;
     return resp;
 }
示例#19
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;
        }
示例#20
0
        /// <summary>
        /// Defines the closest obstacle
        /// </summary>
        public void DetectClosestObstacle()
        {
            float closestObstacleDistance = float.MaxValue;
            _closestObstacle = null;

            var localAgentMatrix = Matrix.Invert(AutonomousAgent.ParentObject.World);

            foreach (SceneEntity obstacle in Context.Keys)
            {
                Vector3 localPos = Vector3.Transform(obstacle.World.Translation, localAgentMatrix);

                if (UseLineOfSight)
                {
                    if (localPos.Z > 0f)
                        continue;
                }

                float expandedRadius = obstacle.WorldBoundingSphere.Radius + AutonomousAgent.ParentObject.WorldBoundingSphere.Radius - AllowedPenetration;

                var ray = new Ray(Vector3.Zero, Vector3.Forward);
                float? result = ray.Intersects(new BoundingSphere(localPos, expandedRadius));
                if (result.HasValue && result.Value < closestObstacleDistance)
                {
                    closestObstacleDistance = result.Value;

                    _closestObstacle = obstacle;
                    _closestObstacleLocalPosition = localPos;
                }
            }
        }
示例#21
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);
        }
示例#22
0
        /// <summary>
        /// レイの始点からレイに沿って指定の長さにある点を取得します。
        /// </summary>
        /// <param name="ray">レイ。</param>
        /// <param name="size">サイズ。</param>
        /// <param name="result">指定の点。</param>
        public static void GetPoint(ref Ray ray, float size, out Vector3 result)
        {
            Vector3 vector;
            Vector3.Multiply(ref ray.Direction, size, out vector);

            Vector3.Add(ref ray.Position, ref vector, out result);
        }
示例#23
0
文件: Animated.cs 项目: ylyking/Myre
        /// <summary>
        /// Test a ray (in model space) for intersection with individual bones.
        /// </summary>
        /// <param name="ray"></param>
        /// <returns></returns>
        public IEnumerable<KeyValuePair<string, float>> Intersections(Ray ray)
        {
            return _model
                .Model
                .SkinningData
                .Bounds
                .Select((b, i) =>
                {
                    Matrix transform;
                    Matrix.Invert(ref _worldTransforms[i], out transform);

                    var start = Vector3.Transform(ray.Position, transform);             //Transform ray into bone space
                    var direction = Vector3.TransformNormal(ray.Direction, transform);

                    float? depth = b.Intersects(new Ray(start, direction));             //Intersect new ray in bone space
                    var name = _model.Model.SkinningData.Names[i];

                    return new KeyValuePair<string, float?>(name, depth);

                })
                .Where(a => a.Value.HasValue)                                           //Only pass values which intersect
            // ReSharper disable PossibleInvalidOperationException
                .Select(a => new KeyValuePair<string, float>(a.Key, a.Value.Value))     //Select float (now we know it's not null)
            // ReSharper restore PossibleInvalidOperationException
                .OrderBy(a => a.Value)                                                  //Order by distance along ray
                .ToArray();
        }
示例#24
0
 public IntersectionInfo(float distance, Ray originalRay, Vector3 baryCoord, Geomertry geomertry)
 {
     Distance = distance;
     BaryCoord = baryCoord;
     OriginalRay = originalRay;
     Geomertry = geomertry;
 }
示例#25
0
        public override void CalculateLocalMouse(Ray MouseRay, Action<Gem.Render.SceneNode, float> HoverCallback)
        {
            MouseHover = false;

            if (InteractWithMouse == false) return;

            MouseRay.Direction = Vector3.Normalize(MouseRay.Direction);

            var inverseTransform = Matrix.Invert(Orientation.Transform);
            var localMouseSource = Vector3.Transform(MouseRay.Position, inverseTransform);

            var forwardPoint = MouseRay.Position + MouseRay.Direction;
            forwardPoint = Vector3.Transform(forwardPoint, inverseTransform);

            var localMouse = new Ray(localMouseSource, forwardPoint - localMouseSource);

            var intersection = Mesh.RayIntersection(localMouse);

            if (intersection.Intersects)
            {
                LocalMouse = Vector2.Transform(intersection.UV, UVTransform);
                if (AlphaMouse)
                {
                    var pixel = new Color[] { new Color(1.0f, 1.0f, 1.0f, 1.0f) };
                    var pX = (int)System.Math.Round(LocalMouse.X * Texture.Width);
                    var pY = (int)System.Math.Round(LocalMouse.Y * Texture.Height);
                    Texture.GetData<Color>(0, new Rectangle(pX, pY, 1, 1), pixel, 0, 1);
                    if (pixel[0].A > 0.01f)
                        HoverCallback(this, intersection.Distance);
                }
                else
                    HoverCallback(this, intersection.Distance);
            }
        }
示例#26
0
 public void Setup()
 {
     r1 = new Ray();
     r2 = new Ray(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
     r3 = new Ray(new Vector3(2.25f, 3.754321f, 4.387f), new Vector3(-1, -1, -1));
     r4 = new Ray(new Vector3(1, 1, 1), new Vector3(1, 1, 1));
 }
示例#27
0
        public override void ProcessMouseDown(object sender, System.Windows.Forms.MouseEventArgs e, System.Drawing.Rectangle bounds)
        {
            try
            {
                Viewport view  = new Viewport(bounds.X, bounds.Y, bounds.Width, bounds.Height);
                Vector2  mouse = new Vector2(e.Location.X, e.Location.Y);
                Microsoft.Xna.Framework.Ray r = cameraManager.currentCamera.GetMouseRay(mouse, view);
                float         dist            = 0;
                Vector3       pos;
                Vector3       norm;
                CollisionSkin cs = new CollisionSkin();

                lock (physicsManager.PhysicsSystem)
                {
                    if (physicsManager.PhysicsSystem.CollisionSystem.SegmentIntersect(out dist, out cs, out pos, out norm, new Segment(r.Position, r.Direction * 1000), new Helper.Physics.DefaultCollisionPredicate()))
                    {
                        Body b = cs.Owner;
                        if (b == null)
                        {
                            return;
                        }
                        Gobject go = b.ExternalData as Gobject;
                        SelectGameObject(go);
                    }
                }
            }
            catch (Exception E)
            {
                System.Diagnostics.Debug.WriteLine(E.StackTrace);
            }
        }
示例#28
0
        private void PlayMouseDown(System.Windows.Forms.MouseEventArgs e, System.Drawing.Rectangle bounds)
        {
            try
            {
                Viewport view  = new Viewport(bounds.X, bounds.Y, bounds.Width, bounds.Height);
                Vector2  mouse = new Vector2(e.Location.X, e.Location.Y);
                Microsoft.Xna.Framework.Ray r = cameraManager.currentCamera.GetMouseRay(mouse, view);
                float         dist            = 0;
                Vector3       pos;
                Vector3       norm;
                CollisionSkin cs = new CollisionSkin();

                if (GetClickedPoint(out dist, out cs, out pos, out norm, new Segment(r.Position, r.Direction * 1000)))
                {
                    Body b = cs.Owner;
                    if (b == null)
                    {
                        return;
                    }
                    Gobject go = b.ExternalData as Gobject;
                    SelectGameObject(go);
                }
            }
            catch (Exception E)
            {
                System.Diagnostics.Debug.WriteLine(E.StackTrace);
            }
        }
        public static void CalculateMouse3DPosition()
        {
            Plane GroundPlane = new Plane(0, 1, 0, 0); // x - lewo prawo Z- gora dol
               int mouseX =    mouseState.X;
               int mouseY =    mouseState.Y;
               Vector3 nearsource = new Vector3((float)mouseX, (float)mouseY, 0f);
               Vector3 farsource = new Vector3((float)mouseX, (float)mouseY, 1f);

               Matrix world = Matrix.CreateTranslation(0, 0, 0);

               Vector3 nearPoint = device.Viewport.Unproject(nearsource,
               Projection, View, Matrix.Identity);

               Vector3 farPoint = device.Viewport.Unproject(farsource,
               Projection, View, Matrix.Identity);

               Vector3 direction = farPoint - nearPoint;
               direction.Normalize();
               Ray pickRay = new Ray(nearPoint, direction);
               float? position = pickRay.Intersects(GroundPlane);

               if (position != null)
               {
               MousePosition = pickRay.Position + pickRay.Direction * position.Value;
               MousePosition.Y = 30f;
               }
               else
               MousePosition = new Vector3(0, 0, 0);
        }
示例#30
0
        //Binary search of intersection between pointer's ray and terrain
        //This function returns Vector with coordinates where our pointer collides with terrain
        public static Vector3 BinarySearch(Ray ray)
        {
            //Set all needed variables (accuracy, height etc.)
            float accuracy = 0.01f;
            float heightAtStartingPoint = Terrain.GetExactHeightAt(ray.Position.X, ray.Position.Z);
            float currentError = ray.Position.Y - heightAtStartingPoint;
            int counter = 0;

            //This loop will find our collision point
            while (currentError < accuracy)
            {
                ray.Direction /= 2.0f;
                Vector3 nextPoint = ray.Position + ray.Direction;
                float heightAtNextPoint = Terrain.GetExactHeightAt(nextPoint.X, nextPoint.Z);
                if (nextPoint.Y < heightAtNextPoint)
                {
                    ray.Position = nextPoint;
                    currentError = ray.Position.Y - heightAtNextPoint;
                }
                //There is no point to iterate more than 1000 times
                //Accuracy is still good enough so we can break the loop
                if (counter++ == 1000) break;
            }

            return ray.Position;
        }
示例#31
0
        public Vector3? GetCollisionPosition()
        {
            MouseState mouseState = Mouse.GetState();

            Vector3 nearSource = new Vector3(mouseState.X, mouseState.Y, 0f);
            Vector3 farSource = new Vector3(mouseState.X, mouseState.Y, 1f);

            Vector3 nearPoint = device.Viewport.Unproject(
                nearSource,
                camera.projection,
                camera.view,
                Matrix.Identity);

            Vector3 farPoint = device.Viewport.Unproject(
                farSource,
                camera.projection,
                camera.view,
                Matrix.Identity);

            Vector3 direction = farPoint - nearPoint;
            direction.Normalize();

            Ray pickRay = new Ray(nearPoint, direction);

            Nullable<float> result = pickRay.Intersects(new Plane(Vector3.Up, 0f));
            Vector3? resultVector = direction * result;
            Vector3? collisionPoint = resultVector + nearPoint;

            return collisionPoint;
        }
示例#32
0
        public void BoundingCylinder_Ray_Test()
        {
            BoundingCylinder cyl = new BoundingCylinder (sideA: Vector3.Zero, sideB: Vector3.Up * 100, radius: 100f);
            Ray ray;
            ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Up);
            Assert.IsNotNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Down);
            Assert.IsNotNull (ray.Intersects (cyl));

            ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Forward);
            Assert.IsNotNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Left);
            Assert.IsNotNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, -1, 0), direction: Vector3.Forward);
            Assert.IsNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, -1, 0), direction: Vector3.Left);
            Assert.IsNull (ray.Intersects (cyl));

            // hier sollte eigentlich (0,100,0) auch noch drin sein, nicht nur (0,99,0),
            // also wie bei SideA!
            ray = new Ray (position: new Vector3 (0, 99, 0), direction: Vector3.Forward);
            Assert.IsNotNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, 99, 0), direction: Vector3.Left);
            Assert.IsNotNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, 101, 0), direction: Vector3.Forward);
            Assert.IsNull (ray.Intersects (cyl));
            ray = new Ray (position: new Vector3 (0, 101, 0), direction: Vector3.Left);
            Assert.IsNull (ray.Intersects (cyl));
        }
示例#33
0
        private bool GetClickedPoint(float x, float y, System.Drawing.Rectangle bounds, out float dist, out CollisionSkin cs, out Vector3 pos, out Vector3 norm)
        {
            Viewport view  = new Viewport(bounds.X, bounds.Y, bounds.Width, bounds.Height);
            Vector2  mouse = new Vector2(x, y);

            Microsoft.Xna.Framework.Ray r = cameraManager.currentCamera.GetMouseRay(mouse, view);
            return(GetClickedPoint(out dist, out cs, out pos, out norm, new Segment(r.Position, r.Direction * 1000)));
        }
示例#34
0
        //Ray
        public static Ray Convert(Microsoft.Xna.Framework.Ray ray)
        {
            Ray toReturn;

            Convert(ref ray.Position, out toReturn.Position);
            Convert(ref ray.Direction, out toReturn.Direction);
            return(toReturn);
        }
示例#35
0
        public void OnUse(object actor, Microsoft.Xna.Framework.Ray ray, object item)
        {
            //GetBase Vars
            //get Actor
            IActor myActor = actor as IActor;
            //Get GameServer
            IGameServer Server = myActor.State as IGameServer;
            //Get systems
            var SystemsCollection = Server.Biomes.GetSystems();
            //Get system the player is in
            uint currentSystemID = myActor.InstanceID;
            //Define currentSystems for TryGetValue
            IBiomeSystem currentSystem;

            //Find the currentSystem based on its ID
            SystemsCollection.TryGetValue(currentSystemID, out currentSystem);
            //Get the chunk's ID, that the player is in
            uint currentChunkID = myActor.ConnectedChunk;
            //Search current system for the chunk based on its ID
            IChunk currentChunk = currentSystem.ChunkCollection.First(sys => sys.ID == currentChunkID);

            //get Starting Point from ray object (its a local Pos)
            DoubleVector3 rayStartPointAsLocalPosition = new DoubleVector3(System.Convert.ToDouble(ray.Position.X), System.Convert.ToDouble(ray.Position.Y), System.Convert.ToDouble(ray.Position.Z));
            //get direction of the Ray from ray object (essentially, where is the player looking to)
            DoubleVector3 rayDirection = new DoubleVector3(System.Convert.ToDouble(ray.Direction.X), System.Convert.ToDouble(ray.Direction.Y), System.Convert.ToDouble(ray.Direction.Z));
            //calculate true global Pos (its needed for the new ray Object)
            DoubleVector3 rayStartPointAsTrueGlobalPos = DoubleVector3.Transform(rayStartPointAsLocalPosition, currentChunk.World);
            //Create new Ray Object with calculated outputs
            PreciseRay hitRay = new PreciseRay(rayStartPointAsTrueGlobalPos, rayDirection);

            //execute RayCast
            //set up return objects for coming operation
            IChunk        hitChunk   = null as IChunk;
            DoubleVector3 hitPoint   = DoubleVector3.Zero;
            DoubleVector3 buildPoint = DoubleVector3.Zero;
            //Do rayCast with calculated Ray Object
            Boolean rayCastResult = currentSystem.PreciseRayCast(hitRay, (double)6.0, ref hitChunk, ref hitPoint, ref buildPoint, false);

            Point3D fakeGlobalPos = Point3D.Zero;

            if (rayCastResult)   //if something was hit by the raycast
            {
                fakeGlobalPos =  //calculate the position of what has been hit as fakeGlobalPos
                                new Point3D(
                    (int)hitChunk.Position.X + (int)hitPoint.X,
                    (int)hitChunk.Position.Y + (int)hitPoint.Y,
                    (int)hitChunk.Position.Z + (int)hitPoint.Z
                    );
            }
            ;

            SNScriptUtils._Utils.setPos(myActor, "1", fakeGlobalPos);

            Server.ChatManager.SendActorMessage("RayCast result is" + hitPoint.ToString(), myActor);
        }
示例#36
0
        public static float?intersects(Microsoft.Xna.Framework.Ray ray, IEnumerable <BlockLoc> blockList)
        {
            float?minDist = null;

            foreach (BlockLoc test in blockList)
            {
                float?thisIntersection = new BoundingBox(test.toWorldSpaceVector3(), test.toWorldSpaceVector3() + new Vector3(1, 1, 1)).Intersects(ray);
                if (thisIntersection != null)
                {
                    if (minDist == null || (float)minDist > (float)thisIntersection)
                    {
                        minDist = thisIntersection;
                    }
                }
            }
            return(minDist);
        }
示例#37
0
        public override float?intersects(Microsoft.Xna.Framework.Ray ray)
        {
            float?intersection = null;
            Tree  closest      = null; //currently found but not used for anything

            foreach (Tree test in trees)
            {
                float?thisIntersecton = Intersection.intersects(ray, test.getTrunkBlocks());
                if (thisIntersecton.HasValue)
                {
                    if (intersection.HasValue == false || (float)thisIntersecton < (float)intersection)
                    {
                        intersection = thisIntersecton;
                        closest      = test;
                    }
                }
            }
            return(intersection);
        }
示例#38
0
        public override SegmentInterceptInfo SegmentIntersect(Microsoft.Xna.Framework.Ray raio, System.Func <IPhysicObject, bool> filter, float maxDistance)
        {
            SegmentInterceptInfo SegmentInterceptInfo = null;

            foreach (var hits in Scene.RaycastAllShapes(new StillDesign.PhysX.Ray(raio.Position.AsPhysX(), raio.Direction.AsPhysX()), ShapesType.All))
            {
                if (filter(hits.Shape.Actor.UserData as IPhysicObject))
                {
                    if (SegmentInterceptInfo == null || SegmentInterceptInfo.Distance > hits.Distance)
                    {
                        SegmentInterceptInfo                = new SegmentInterceptInfo();
                        SegmentInterceptInfo.Distance       = hits.Distance;
                        SegmentInterceptInfo.ImpactNormal   = hits.WorldNormal.AsXNA();
                        SegmentInterceptInfo.ImpactPosition = hits.WorldImpact.AsXNA();
                        SegmentInterceptInfo.PhysicObject   = hits.Shape.Actor.UserData as IPhysicObject;
                    }
                }
            }
            return(SegmentInterceptInfo);
        }
示例#39
0
        private void BuildMouseDown(Point dPos, System.Windows.Forms.MouseEventArgs e, System.Drawing.Rectangle bounds)
        {
            try
            {
                Viewport view  = new Viewport(bounds.X, bounds.Y, bounds.Width, bounds.Height);
                Vector2  mouse = new Vector2(WindowLocationX, WindowLocationY);
                Microsoft.Xna.Framework.Ray r = cameraManager.currentCamera.GetMouseRay(mouse, view);
                float         dist            = 0;
                Vector3       pos;
                Vector3       norm;
                CollisionSkin cs = new CollisionSkin();

                if (GetClickedPoint(out dist, out cs, out pos, out norm, new Segment(r.Position, r.Direction * 1000)))
                {
                    buildLastMouseDownPosition = pos;
                }
            }
            catch (Exception E)
            {
                System.Diagnostics.Debug.WriteLine(E.StackTrace);
            }
        }
示例#40
0
 public override float?intersects(Microsoft.Xna.Framework.Ray ray)
 {
     return(Intersection.intersects(ray, blocksToBeRemoved));
 }
示例#41
0
        public bool RayCast(Microsoft.Xna.Framework.Ray ray, float maximumLength, IList <BroadPhaseEntry> outputIntersections)
        {
            if (maximumLength == float.MaxValue)
            {
                throw new NotSupportedException("The Grid2DSortAndSweep broad phase cannot accelerate infinite ray casts.  Consider specifying a maximum length or using a broad phase which supports infinite ray casts.");
            }

            //Use 2d line rasterization.
            //Compute the exit location in the cell.
            //Test against each bounding box up until the exit value is reached.
            float   length = 0;
            Int2    cellIndex;
            Vector3 currentPosition = ray.Position;

            Grid2DSortAndSweep.ComputeCell(ref currentPosition, out cellIndex);
            while (true)
            {
                float cellWidth = 1 / Grid2DSortAndSweep.cellSizeInverse;
                float nextT;  //Distance along ray to next boundary.
                float nextTy; //Distance along ray to next boundary along y axis.
                float nextTz; //Distance along ray to next boundary along z axis.
                //Find the next cell.
                if (ray.Direction.Y > 0)
                {
                    nextTy = ((cellIndex.Y + 1) * cellWidth - currentPosition.Y) / ray.Direction.Y;
                }
                else if (ray.Direction.Y < 0)
                {
                    nextTy = ((cellIndex.Y) * cellWidth - currentPosition.Y) / ray.Direction.Y;
                }
                else
                {
                    nextTy = 10e10f;
                }
                if (ray.Direction.Z > 0)
                {
                    nextTz = ((cellIndex.Z + 1) * cellWidth - currentPosition.Z) / ray.Direction.Z;
                }
                else if (ray.Direction.Z < 0)
                {
                    nextTz = ((cellIndex.Z) * cellWidth - currentPosition.Z) / ray.Direction.Z;
                }
                else
                {
                    nextTz = 10e10f;
                }

                bool yIsMinimum = nextTy < nextTz;
                nextT = yIsMinimum ? nextTy : nextTz;



                //Grab the cell that we are currently in.
                GridCell2D cell;
                if (owner.cellSet.TryGetCell(ref cellIndex, out cell))
                {
                    float endingX;
                    if (ray.Direction.X < 0)
                    {
                        endingX = currentPosition.X;
                    }
                    else
                    {
                        endingX = currentPosition.X + ray.Direction.X * nextT;
                    }

                    //To fully accelerate this, the entries list would need to contain both min and max interval markers.
                    //Since it only contains the sorted min intervals, we can't just start at a point in the middle of the list.
                    //Consider some giant bounding box that spans the entire list.
                    for (int i = 0; i < cell.entries.count &&
                         cell.entries.Elements[i].item.boundingBox.Min.X <= endingX; i++)   //TODO: Try additional x axis pruning?
                    {
                        float?intersects;
                        var   item = cell.entries.Elements[i].item;
                        ray.Intersects(ref item.boundingBox, out intersects);
                        if (intersects != null && intersects < maximumLength && !outputIntersections.Contains(item))
                        {
                            outputIntersections.Add(item);
                        }
                    }
                }

                //Move the position forward.
                length += nextT;
                if (length > maximumLength) //Note that this catches the case in which the ray is pointing right down the middle of a row (resulting in a nextT of 10e10f).
                {
                    break;
                }
                Vector3 offset;
                Vector3.Multiply(ref ray.Direction, nextT, out offset);
                Vector3.Add(ref offset, ref currentPosition, out currentPosition);
                if (yIsMinimum)
                {
                    if (ray.Direction.Y < 0)
                    {
                        cellIndex.Y -= 1;
                    }
                    else
                    {
                        cellIndex.Y += 1;
                    }
                }
                else
                if (ray.Direction.Z < 0)
                {
                    cellIndex.Z -= 1;
                }
                else
                {
                    cellIndex.Z += 1;
                }
            }
            return(outputIntersections.Count > 0);
        }
示例#42
0
 public bool RayCast(Microsoft.Xna.Framework.Ray ray, IList <BroadPhaseEntry> outputIntersections)
 {
     throw new NotSupportedException("The Grid2DSortAndSweep broad phase cannot accelerate infinite ray casts.  Consider specifying a maximum length or using a broad phase which supports infinite ray casts.");
 }
示例#43
0
 public static void Convert(ref Microsoft.Xna.Framework.Ray ray, out Ray bepuRay)
 {
     Convert(ref ray.Position, out bepuRay.Position);
     Convert(ref ray.Direction, out bepuRay.Direction);
 }
示例#44
0
 public static void Convert(ref Ray ray, out Microsoft.Xna.Framework.Ray xnaRay)
 {
     Convert(ref ray.Position, out xnaRay.Position);
     Convert(ref ray.Direction, out xnaRay.Direction);
 }
示例#45
0
        // Algorithm copied from: http://www.cs.utah.edu/~awilliam/box/box.pdf
        // This is the non-optimized version of:

        /*
         * Ray-box intersection using IEEE numerical properties to ensure that the
         * test is both robust and efficient, as described in:
         *
         *      Amy Williams, Steve Barrus, R. Keith Morley, and Peter Shirley
         *      "An Efficient and Robust Ray-Box Intersection Algorithm"
         *      Journal of graphics tools, 10(1):49-54, 2005
         *
         */
        private bool ComputeEntryAndExitSignedDistances(Ray rtRay, out float tMin, out float tMax)
        {
            float yMin = float.MaxValue, zMin = float.MaxValue;
            float yMax = float.MinValue, zMax = float.MinValue;

            tMin = float.MaxValue;
            tMax = float.MinValue;
            if (rtRay.Direction.X > 0)
            {
                tMin = (Bounds.Min.X - rtRay.Origin.X) / rtRay.Direction.X;
                tMax = (Bounds.Max.X - rtRay.Origin.X) / rtRay.Direction.X;
            }
            else if (rtRay.Direction.X < 0)
            {
                tMin = (Bounds.Max.X - rtRay.Origin.X) / rtRay.Direction.X;
                tMax = (Bounds.Min.X - rtRay.Origin.X) / rtRay.Direction.X;
            }
            if (rtRay.Direction.Y > 0)
            {
                yMin = (Bounds.Min.Y - rtRay.Origin.Y) / rtRay.Direction.Y;
                yMax = (Bounds.Max.Y - rtRay.Origin.Y) / rtRay.Direction.Y;
            }
            else if (rtRay.Direction.Y < 0)
            {
                yMin = (Bounds.Max.Y - rtRay.Origin.Y) / rtRay.Direction.Y;
                yMax = (Bounds.Min.Y - rtRay.Origin.Y) / rtRay.Direction.Y;
            }

            if ((tMin > yMax) || (yMin > tMax))
            {
                return(false);
            }
            if (yMin > tMin)
            {
                tMin = yMin;
            }
            if (yMax < tMax)
            {
                tMax = yMax;
            }

            if (rtRay.Direction.Z > 0)
            {
                zMin = (Bounds.Min.Z - rtRay.Origin.Z) / rtRay.Direction.Z;
                zMax = (Bounds.Max.Z - rtRay.Origin.Z) / rtRay.Direction.Z;
            }
            else if (rtRay.Direction.Z < 0)
            {
                zMin = (Bounds.Max.Z - rtRay.Origin.Z) / rtRay.Direction.Z;
                zMax = (Bounds.Min.Z - rtRay.Origin.Z) / rtRay.Direction.Z;
            }

            if ((tMin > zMax) || (zMin > tMax))
            {
                return(false);
            }
            if (zMin > tMin)
            {
                tMin = zMin;
            }
            if (zMax < tMax)
            {
                tMax = zMax;
            }

            return(true);

#if THIS_IS_USELESS
            // apparantly ray/BoundingBox returns _one_ of the intersection positions, but not always the closest one!!
            // USELESS!!
            Microsoft.Xna.Framework.Ray r = new Microsoft.Xna.Framework.Ray(rtRay.Origin, rtRay.Direction);

            float?dist = r.Intersects(Bounds);
            if (null == dist)
            {
                return(null);
            }

            float[] distances = new float[2];
            if (Bounds.Contains(rtRay.Origin) == ContainmentType.Contains)
            { // originated from inside, let's find the back-end existing position
                Microsoft.Xna.Framework.Ray backRay = new Microsoft.Xna.Framework.Ray(rtRay.Origin, -rtRay.Direction);
                float?backDist = backRay.Intersects(Bounds);
                distances[0] = (float)-backDist; // this will be a negative value
                distances[1] = (float)dist;
            }
            else
            {
                // dist is the entry position, now find the exist position
                distances[0] = (float)dist;
                // advance the ray position without going out of this node
                r.Position = r.Position + (distances[0] + float.Epsilon) * r.Direction;
                if (Bounds.Contains(r.Position) == ContainmentType.Contains)
                {
                    distances[1] = (float)r.Intersects(Bounds);
                }
                else
                {
                    distances[1] = distances[0] + float.Epsilon;
                }
            }
            return(distances);
#endif
        }
示例#46
0
 public Nullable <float> Intersects(Ray ray)
 {
     return(ray.Intersects(this));
 }
示例#47
0
 public void Intersects(ref Ray ray, out Nullable <float> result)
 {
     result = Intersects(ray);
 }
示例#48
0
 public abstract float?intersects(Microsoft.Xna.Framework.Ray ray);
示例#49
0
 public override float?intersects(Microsoft.Xna.Framework.Ray ray)
 {
     return(new BoundingBox(objectLoc.toWorldSpaceVector3() - new Vector3(1, 1, 1),
                            objectLoc.toWorldSpaceVector3() + new Vector3(2, 2, 2)).Intersects(ray));
 }
示例#50
0
文件: Bounds.cs 项目: mikecrews/FFWD
        public bool IntersectRay(Microsoft.Xna.Framework.Ray r)
        {
            float?res = box.Intersects(r);

            return(res.HasValue);
        }
示例#51
0
 internal JobSite getJobSiteAlongRay(Microsoft.Xna.Framework.Ray ray)
 {
     return((JobSite)Intersection.getNearestIntersectableAlongRay(ray, jobSites));
 }
示例#52
0
 public override float?intersects(Microsoft.Xna.Framework.Ray ray)
 {
     return(Intersection.intersects(ray, plantBlocks.Keys.ToList()));
 }