Example #1
0
        public override void Deactivate(VrSession session)
        {
            if (_brushSelector != null)
            {
                _brushSelector.Dispose();
                _brushSelector = null;
            }

            DeleteBrushTempGfx();
        }
Example #2
0
        public override void Update(VrUpdateArgs args)
        {
            var session = args.Session;

            DeleteBrushTempGfx();

            var input = session.SemanticInput();

            if (_trackedBrushInstruction != null)
            {
                if (input.IsSelectPressed)
                {
                    // Drag brush
                    var relatedMI = FindRelatedMoveInstruction(_trackedBrushInstruction);
                    if (relatedMI != null)
                    {
                        Matrix4 wobjMat = relatedMI.GetWorkObject().ObjectFrame.GlobalMatrix;
                        Vector3 point   = wobjMat.InverseRigid().MultiplyPoint(session.RightController.PointerTransform.Translation);
                        var     pos     = PathEditingHelper.GetBrushEventPosition(_trackedBrushInstruction);
                        string  val     = ((int)(point[(int)pos.Item1 - 1] * 1000)).ToString();
                        if (val != pos.Item2.Value)
                        {
                            WithUndoAppend("VR Move SetBrush", () => { pos.Item2.Value = val; });
                        }
                        _brushSelector.Caption = _trackedBrushInstruction.DisplayName;
                    }
                    return;
                }
            }

            var hitObj = GetHitObject(session.RightController.PointerTransform.Translation);

            var trackedMoveInstruction = hitObj?.Item1 as RsMoveInstruction;

            if (trackedMoveInstruction != null)
            {
                //:TODO: Supported for PaintC??
                if (trackedMoveInstruction.Name != "PaintL" && trackedMoveInstruction.Name != "PaintC" ||
                    trackedMoveInstruction.GetToTarget() == null)
                {
                    trackedMoveInstruction = null;
                }
            }

            var trackedBrushInstr = hitObj?.Item1 as RsActionInstruction;

            if (trackedBrushInstr != null && !string.Equals(trackedBrushInstr.Name, "SetBrush", StringComparison.OrdinalIgnoreCase))
            {
                trackedBrushInstr = null;
            }

            if (trackedMoveInstruction != _trackedMoveInstruction)
            {
                _trackedMoveInstruction = trackedMoveInstruction;
                if (_brushSelector == null)
                {
                    _brushSelector = new VrScrollSelector(session.RightController, "", _brushValues, _lastBrushNum);
                }
                _brushSelector.Caption = (_trackedMoveInstruction != null) ? "Add SetBrush" : "Brush Number";
            }

            else if (trackedBrushInstr != _trackedBrushInstruction || _brushSelector == null)
            {
                if (_brushSelector != null)
                {
                    _brushSelector.Dispose();
                }

                _trackedBrushInstruction = trackedBrushInstr;
                if (_trackedBrushInstruction != null)
                {
                    var numarg = _trackedBrushInstruction.InstructionArguments["BrushNumber"];
                    _brushSelector = new VrScrollSelector(session.RightController, _trackedBrushInstruction.DisplayName, _brushValues, numarg.Value);
                }
                else
                {
                    _brushSelector = new VrScrollSelector(session.RightController, (_trackedMoveInstruction != null) ? "Add SetBrush" : "Brush Number", _brushValues, _lastBrushNum);
                }
            }

            if (_trackedBrushInstruction != null && input.DeleteClick)
            {
                var path = (RsPathProcedure)_trackedBrushInstruction.Parent;
                WithUndo("VR Delete SetBrush", () => { path.Instructions.Remove(_trackedBrushInstruction); });
                _trackedBrushInstruction = null;
                return;
            }

            bool brushNumUpdated = _brushSelector.Update();

            if (brushNumUpdated)
            {
                _lastBrushNum = _brushSelector.SelectedValue;
            }

            if (_trackedMoveInstruction != null && _trackedBrushInstruction == null)
            {
                Matrix4 wobjMat = _trackedMoveInstruction.GetWorkObject().ObjectFrame.GlobalMatrix;

                CreateBrushPlanePreview(hitObj.Item2, wobjMat);

                if (input.SelectClick)
                {
                    Vector3 point = wobjMat.InverseRigid().MultiplyPoint(hitObj.Item2);
                    var     axis  = ComputeBrushAxis();
                    int     val   = (int)(point[(int)axis - 1] * 1000);
                    WithUndo("VR Create SetBrush", () =>
                    {
                        PathEditingHelper.CreateSetBrush(
                            _trackedMoveInstruction,
                            axis,
                            val,
                            _brushSelector.SelectedValue);
                    }
                             );
                    DeleteBrushTempGfx();
                }
            }
            else if (_trackedBrushInstruction != null && brushNumUpdated)
            {
                var numarg = _trackedBrushInstruction.InstructionArguments["BrushNumber"];
                WithUndo("VR Edit SetBrush", () => { numarg.Value = _brushSelector.SelectedValue; });
                _brushSelector.Caption = _trackedBrushInstruction.DisplayName;
            }
        }
Example #3
0
        public override void Update(VrUpdateArgs args)
        {
            var session = args.Session;

            // KNARK - Rift
            var wand = session.RightController as VrViveWandController;

            if (wand == null)
            {
                return;
            }

            RsMoveInstruction mi = null;

            if (_currentMoveInstruction != null)
            {
                // "Sticky" selection - don't remove the UI until 1) user releases the touchpad and 2) moves controller a bit away from path
                //:NOTE: Sticky distance can be annoying when editing nearby segments - review. Use shorter dist if another MI is closer/picked?
                if (wand.InputState.IsTouchPadTouched || _pickedPos.Distance(wand.PointerTransform.Translation) < _stickyDist && _hasScrolled)
                {
                    mi = _currentMoveInstruction;
                }
            }

            if (mi == null && !wand.InputState.IsGripPressed && !wand.InputState.IsTouchPadPressed && !wand.InputState.IsTriggerPressed)
            {
                mi = GetPickedMoveInstruction(session);
            }

            if (mi != _currentMoveInstruction)
            {
                // Selected MI has changed, delete any old UI and create a new if needed
                if (_selector != null)
                {
                    _selector.Dispose(); _selector = null; _hasScrolled = false;
                }
                _currentMoveInstruction = mi;
                if (mi != null)
                {
                    _pickedPos = session.RightController.PointerTransform.Translation;
                    var task = mi.GetInternalParentOfType <RsTask>();
                    //:TODO: Some paint stations have too many speeddatas for this type of UI to make sense. How to handle?

                    string taskName = task.Name;
                    if (string.IsNullOrEmpty(taskName))
                    {
                        taskName = "T_ROB1";                                 // station/dummy tasks
                    }
                    var speeds = task.GetTaskContext().SymbolTable.GetVisibleDataDeclarations("/RAPID/" + taskName, "speeddata")
                                 .Where(s => !s.Name.StartsWith("vrot")) //???
                                 .Take(60)                               //TEST
                                 .Select(s => s.Name)
                                 .ToList();

                    speeds.Sort(ABB.Robotics.RobotStudio.UI.UIServices.NaturalOrderSort);
                    string speed = GetSpeedArg(mi).Value;
                    int    tmp   = speeds.FindIndex(s => s.Equals(speed, StringComparison.OrdinalIgnoreCase));
                    if (tmp == -1)
                    {
                        speeds.Insert(0, "Unknown");
                        speed = speeds[0];
                    }
                    else
                    {
                        speed = speeds[tmp];                     // fix capitalization
                    }
                    string title = "->" + mi.GetToTarget().Name; // TEST - what do we want here?
                    _selector     = new VrScrollSelector(session.RightController, title, speeds, speed);
                    _newSelection = true;
                }
            }
            else if (_currentMoveInstruction != null && _selector != null)
            {
                if (wand.InputState.IsTouchPadTouched)
                {
                    _hasScrolled = true;
                }

                // Same selection - update _selector and apply results
                bool ok = _selector.Update();
                if (ok && _selector.SelectedValue != "Unknown")
                {
                    Action foo = () => { GetSpeedArg(_currentMoveInstruction).Value = _selector.SelectedValue; };
                    if (_newSelection)
                    {
                        _newSelection = false;
                        WithUndo("VR Edit Speed", foo);
                    }
                    else
                    {
                        WithUndoAppend("VR Edit Speed", foo);
                    }
                }
            }
        }