Exemple #1
0
        bool Raycast(float maxDistance, out Vector3 hitPos, out Drawable hitDrawable)
        {
            var input = GetSubsystem <Input>();

            hitDrawable = null;
            hitPos      = new Vector3();

            var    graphics = GetSubsystem <Graphics>();
            Camera camera   = CameraNode.GetComponent <Camera>();

            IntVector2     pos       = input.MousePosition;
            Ray            cameraRay = camera.GetScreenRay((float)pos.X / graphics.Width, (float)pos.Y / graphics.Height);
            RayOctreeQuery query     = new RayOctreeQuery(cameraRay, RayQueryLevel.RAY_TRIANGLE, maxDistance, Constants.DRAWABLE_GEOMETRY);

            // Pick only geometry objects, not eg. zones or lights, only get the first (closest) hit
            scene.GetComponent <Octree>().RaycastSingle(query);

            if (query.Results.Count > 0)
            {
                var first = query.Results.First();
                hitPos      = first.Position;
                hitDrawable = first.Drawable;
                return(true);
            }

            return(false);
        }
        public static bool Raycast(Scene scene, Engn_Camera cam, float maxDistance, out Vector3 hitPos, out Drawable hitDrawable)
        {
            hitDrawable = null;
            hitPos      = Vector3.Zero;

            var oct = scene.GetComponent <Octree>();
            RayQueryResultList results = new RayQueryResultList();
            var ray = cam.GetRay();

            var query = new RayOctreeQuery(results, ray, RayQueryLevel.RayTriangle, maxDistance, DrawableFlags.DrawableGeometry);

            oct.Raycast(query);

            for (int i = 0; i < results.Count; i++)
            {
                var result = results[i];
                hitDrawable = result.Drawable;
                if (hitDrawable != null)
                {
                    if (hitDrawable.Node.GetComponent <WirePlane>() != null)
                    {
                        hitDrawable = null;
                        continue;
                    }
                }
                hitPos = result.Position;
                return(true);
            }

            return(false);
        }
Exemple #3
0
        public void RaycastSingle(ref RayOctreeQuery query)
        {
            if (SpacePartitioner != null)
            {
                SpacePartitioner.RaycastSingle(ref query);
                return;
            }

            throw new NotImplementedException();
        }
        void SubscribeToEvents()
        {
            SubscribeToEvent <PostUpdateEvent>(e =>
            {
                if (vehicle == null)
                {
                    return;
                }

                Node vehicleNode = vehicle.Node;

                // Physics update has completed. Position camera behind vehicle
                Quaternion dir = Quaternion.FromAxisAngle(Vector3.UnitY, vehicleNode.Rotation.YawAngle);

                dir = dir * Quaternion.FromAxisAngle(Vector3.UnitY, vehicle.Controls.Yaw);
                dir = dir * Quaternion.FromAxisAngle(Vector3.UnitX, vehicle.Controls.Pitch);

                Vector3 cameraTargetPos = vehicleNode.Position - (dir * new Vector3(0.0f, 0.0f, CameraDistance));
                Vector3 cameraStartPos  = vehicleNode.Position;


                // and move it closer to the vehicle if something in between
                Ray cameraRay         = new Ray(cameraStartPos, cameraTargetPos - cameraStartPos);
                float cameraRayLength = (cameraTargetPos - cameraStartPos).Length;

                // Raycast camera against static objects (physics collision mask 2)
                var query = new RayOctreeQuery(cameraRay, RayQueryLevel.RAY_TRIANGLE, cameraRayLength, Constants.DRAWABLE_ANY, 2);

                PhysicsRaycastResult result = new PhysicsRaycastResult();

                scene.GetComponent <PhysicsWorld>().RaycastSingle(ref result, cameraRay, cameraRayLength, 2);
                if (result.Body != null)
                {
                    cameraTargetPos = cameraStartPos + cameraRay.Direction * (result.Distance - 0.5f);
                }

                CameraNode.Position = cameraTargetPos;
                CameraNode.Rotation = dir;
            });
        }
Exemple #5
0
        bool Raycast(float maxDistance, out Vector3 hitPos, out Drawable hitDrawable)
        {
            hitDrawable = null;
            hitPos      = Vector3.Zero;

            var graphics = GetSubsystem <Graphics>();
            var input    = GetSubsystem <Input>();

            IntVector2 pos       = input.MousePosition;
            Ray        cameraRay = camera.GetScreenRay((float)pos.X / graphics.Width, (float)pos.Y / graphics.Height);

            RayOctreeQuery query = new RayOctreeQuery(cameraRay, RayQueryLevel.RAY_TRIANGLE, maxDistance, Constants.DRAWABLE_GEOMETRY);

            scene.GetComponent <Octree>().RaycastSingle(query);

            if (query.Results.Count > 0)
            {
                var first = query.Results.First();
                hitPos      = first.Position;
                hitDrawable = first.Drawable;
                return(true);
            }
            return(false);
        }
        protected override void Render()
        {
            RenderToolbar();

            var padding = ui.GetStyle().FramePadding;
            var spacing = ui.GetStyle().ItemSpacing;
            var size    = new System.Numerics.Vector2(ui.GetWindowWidth() - padding.X - spacing.X,
                                                      ui.GetWindowHeight() - ui.GetCursorPos().Y - spacing.Y);

            if (ui.BeginChild(0xF00, size, false, WindowFlags.Default))
            {
                var viewSize = ui.GetWindowSize();
                _view.Size = viewSize;
                var viewPos = ui.GetCursorScreenPos();
                ui.Image(_view.Texture.NativeInstance, viewSize, Vector2.Zero, Vector2.One, Vector4.One, Vector4.Zero);
                if (Input.IsMouseVisible)
                {
                    _isMouseHoveringViewport = ui.IsItemHovered(HoveredFlags.Default);
                }

                _gizmo.SetScreenRect(viewPos, viewSize);

                var isClickedLeft  = Input.GetMouseButtonClick((int)MouseButton.Left) && ui.IsItemHovered(HoveredFlags.AllowWhenBlockedByPopup);
                var isClickedRight = Input.GetMouseButtonClick((int)MouseButton.Right) && ui.IsItemHovered(HoveredFlags.AllowWhenBlockedByPopup);

                _gizmo.ManipulateSelection(_view.Camera);

                if (ui.IsWindowHovered())
                {
                    WindowFlags |= WindowFlags.NoMove;
                }
                else
                {
                    WindowFlags &= ~WindowFlags.NoMove;
                }

                if (!_gizmo.IsActive && (isClickedLeft || isClickedRight) && Input.IsMouseVisible)
                {
                    // Handle object selection.
                    var pos = Input.MousePosition - new IntVector2(viewPos);

                    var cameraRay = _view.Camera.GetScreenRay(pos.X / size.X, pos.Y / size.Y);
                    // Pick only geometry objects, not eg. zones or lights, only get the first (closest) hit

                    var query = new RayOctreeQuery(cameraRay, RayQueryLevel.Triangle, float.PositiveInfinity, DrawableFlags.Geometry);
                    _view.Scene.GetComponent <Octree>().RaycastSingle(query);

                    if (query.Result.Length == 0)
                    {
                        // When object geometry was not hit by a ray - query for object bounding box.
                        query = new RayOctreeQuery(cameraRay, RayQueryLevel.Obb, float.PositiveInfinity, DrawableFlags.Geometry);
                        _view.Scene.GetComponent <Octree>().RaycastSingle(query);
                    }

                    if (query.Result.Length > 0)
                    {
                        var clickNode = query.Result[0].Drawable.Node;
                        // Temporary nodes can not be selected.
                        while (clickNode != null && clickNode.HasTag("__EDITOR_OBJECT__"))
                        {
                            clickNode = clickNode.Parent;
                        }

                        if (clickNode != null)
                        {
                            var appendSelection = Input.GetKeyDown(InputEvents.KeyCtrl);
                            if (!appendSelection)
                            {
                                _gizmo.UnselectAll();
                            }
                            _gizmo.ToggleSelection(clickNode);

                            // Notify inspector
                            _eventArgs.Clear();
                            _eventArgs[InspectItem.Inspectable] = Variant.FromObject(this);
                            SendEvent <InspectItem>(_eventArgs);

                            if (isClickedRight)
                            {
                                ui.OpenPopup("Node context menu");
                            }
                        }
                    }
                    else
                    {
                        _gizmo.UnselectAll();
                    }
                }

                RenderNodeContextMenu();
            }
            ui.EndChild();
        }