Esempio n. 1
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _amount))
                {
                    return(false);
                }
            }

            SuperController sc         = SuperController.singleton;
            var             multiplier = _multiplier * Mathf.Abs(args.Data);

            if (InputWrapper.GetKey(KeyCode.LeftShift) || InputWrapper.GetKey(KeyCode.RightShift))
            {
                multiplier *= 5.0f;
            }

            var scale = sc.motionAnimationMaster.playbackSpeed + (_amount * multiplier);

            sc.motionAnimationMaster.playbackSpeed = Mathf.Clamp(scale, _min, _max);
            return(true);
        }
Esempio n. 2
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _rotationsPerSecond))
                {
                    return(false);
                }
            }

            var controller = SuperController.singleton.GetFreeController(_atomUid, _controllerName) ?? TargetAtom(args)?.mainController;

            if (controller != null)
            {
                var rotate = 360 * Time.deltaTime * _rotationsPerSecond * Mathf.Abs(args.Data);
                var target = controller.transform;

                if (_axis == Axis.X)
                {
                    target.Rotate(rotate, 0, 0);
                }
                else if (_axis == Axis.Y)
                {
                    target.Rotate(0, rotate, 0);
                }
                else if (_axis == Axis.Z)
                {
                    target.Rotate(0, 0, rotate);
                }
            }
            return(true);
        }
Esempio n. 3
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _amount))
                {
                    return(false);
                }
            }

            SuperController sc         = SuperController.singleton;
            var             multiplier = _multiplier * Mathf.Abs(args.Data);

            if (InputWrapper.GetKey(KeyCode.LeftShift) || InputWrapper.GetKey(KeyCode.RightShift))
            {
                multiplier *= 5.0f;
            }

            var scale = sc.worldScale + (_amount * multiplier);

            SuperController.singleton.worldScale = Mathf.Clamp(scale, _worldScaleMin, _worldScaleMax);

            //// Modify player height with scale
            Vector3 dir = Vector3.down;

            dir *= multiplier * 0.0011f;
            sc.navigationRig.position += dir;
            return(true);
        }
Esempio n. 4
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var controller = SuperController.singleton.GetFreeController(_atomUid, _controllerName) ?? TargetAtom(args)?.mainController;

            if (controller != null)
            {
                float proportion  = Mathf.Lerp(0, 1, Mathf.Abs(args.Data));
                var   transform   = controller.transform;
                var   newPosition = new Vector3(transform.position.x, transform.position.y, transform.position.z);
                var   newValue    = Mathf.Lerp(_min, _max, proportion);
                if (_axis == Axis.X)
                {
                    newPosition.x = newValue;
                }
                else if (_axis == Axis.Y)
                {
                    newPosition.y = newValue;
                }
                else if (_axis == Axis.Z)
                {
                    newPosition.z = newValue;
                }

                transform.position = newPosition;
            }
            return(true);
        }
Esempio n. 5
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _unitsPerSecond))
                {
                    return(false);
                }
            }

            if (_windowCamera != null)
            {
                var rotate = 360 * Time.deltaTime * _unitsPerSecond * Mathf.Abs(args.Data);
                var target = _windowCamera.transform;

                if (_axis == Axis.X)
                {
                    target.Rotate(rotate, 0, 0);
                }
                else if (_axis == Axis.Y)
                {
                    target.Rotate(0, rotate, 0);
                }
                else if (_axis == Axis.Z)
                {
                    target.Rotate(0, 0, rotate);
                }
            }
            return(true);
        }
Esempio n. 6
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _unitsPerSecond))
                {
                    return(false);
                }

                if (_direction == Vector3.forward)
                {
                    // invert the direction for forward/back if using an axis
                    _direction = Vector3.back;
                }
            }

            if (_windowCamera != null)
            {
                var multiplier = 1.0f;
                if (InputWrapper.GetKey(KeyCode.LeftShift) || InputWrapper.GetKey(KeyCode.RightShift) || args.KeyBinding.KeyChord.HasAxis)
                {
                    multiplier *= 3.0f;
                }
                _windowCamera.transform.Translate(_direction * Time.deltaTime * _unitsPerSecond * multiplier * Mathf.Abs(args.Data));
            }
            return(true);
        }
Esempio n. 7
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var plugin = SuperController.singleton.GetPluginStorable(_atomUid, _pluginName);

            plugin?.CallAction(_key);
            return(true);
        }
Esempio n. 8
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _unitsPerSecond))
                {
                    return(false);
                }
            }

            var controller = SuperController.singleton.GetFreeController(_atomUid, _controllerName) ?? TargetController(args);

            if (controller != null)
            {
                var direction = Vector3.right;
                if (_axis == Axis.X)
                {
                    direction = Vector3.right;
                }
                else if (_axis == Axis.Y)
                {
                    direction = Vector3.up;
                }
                else if (_axis == Axis.Z)
                {
                    direction = Vector3.forward;
                }

                controller.transform.Translate(direction * Time.deltaTime * _unitsPerSecond * Mathf.Abs(args.Data));
            }
            return(true);
        }
Esempio n. 9
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var controller = SuperController.singleton.GetFreeController(_atomUid, _controllerName) ?? TargetAtom(args)?.mainController;

            SuperController.singleton.SelectController(controller);
            return(true);
        }
Esempio n. 10
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var plugin = SuperController.singleton.GetPluginStorable(_atomUid, _pluginName);

            plugin?.SetBoolParamValue(_key, _value);
            return(true);
        }
Esempio n. 11
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _amount))
                {
                    return(false);
                }
            }

            var plugin = SuperController.singleton.GetPluginStorable(_atomUid, _pluginName);

            var floatParam = plugin?.GetFloatJSONParam(_key) ?? null;

            if (floatParam == null)
            {
                return(false);
            }

            var newValue = Mathf.Clamp(floatParam.val + _amount, floatParam.min, floatParam.max);

            plugin?.SetFloatParamValue(_key, newValue);
            return(true);
        }
Esempio n. 12
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var target = TargetAtom(args);

            // there is some polling that is done with a timeout
            // so do this work async without blocking any run loop
            SuperController.singleton.StartCoroutine(DoWorkCoroutine(target));
            return(true);
        }
Esempio n. 13
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var selected = TargetAtom(args);

            if (selected != null)
            {
                SuperController.singleton.StartCoroutine(DeleteAtom(selected));
            }
            return(true);
        }
Esempio n. 14
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var target = TargetAtom(args);

            if (target != null)
            {
                target.hidden = !target.hidden;
            }
            return(true);
        }
Esempio n. 15
0
        // TODO: consider integrating with acidbubbles debug plugin
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var selected = TargetAtom(args);

            if (selected != null)
            {
                DumpObject(selected);
            }
            return(true);
        }
Esempio n. 16
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var selected = TargetAtom(args);

            if (selected != null)
            {
                var trigger = selected.GetComponentInChildren <UIButtonTrigger>();
                trigger?.button?.onClick?.Invoke();
            }
            return(true);
        }
Esempio n. 17
0
 public virtual Atom TargetAtom(CommandExecuteEventArgs args)
 {
     if (_predicate == null)
     {
         return(SuperController.singleton.GetSelectedAtom());
     }
     else
     {
         return(SelectableAtoms().Where(_predicate).FirstOrDefault());
     }
 }
Esempio n. 18
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var perfMonitorButton = UserPreferences.singleton.transform
                                    .Find((p) => p.EndsWith("PerfMon Toggle"))
                                    .FirstOrDefault()
                                    ?.GetComponent <UnityEngine.UI.Toggle>();

            if (perfMonitorButton != null)
            {
                perfMonitorButton.isOn = !perfMonitorButton.isOn;
            }
            return(true);
        }
Esempio n. 19
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _value))
                {
                    return(false);
                }
            }

            SuperController.singleton.monitorCameraFOV = Mathf.Clamp(SuperController.singleton.monitorCameraFOV + _value, _min, _max);
            return(true);
        }
Esempio n. 20
0
        public override Atom TargetAtom(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, 1))
                {
                    return(null);
                }
            }

            var current = SuperController.singleton.GetSelectedAtom();

            return(SelectableAtoms()
                   .LoopOnceStartingWhen((a) => a.uid.Equals(current?.uid))
                   .First(_predicate) ?? current);
        }
Esempio n. 21
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _indexDelta))
                {
                    return(false);
                }
            }

            var values       = UserPreferences.singleton.msaaPopup.popupValues;
            var currentIndex = values.ToList().FindIndex((val) => UserPreferences.singleton.msaaPopup.currentValue.Equals(val));
            var newValue     = values[Mathf.Clamp(currentIndex + _indexDelta, 0, values.Length - 1)];

            UserPreferences.singleton.SetMsaaFromString(newValue);
            return(true);
        }
Esempio n. 22
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var atom = SuperController.singleton.GetAtomByUid(_atomUid);

            if (atom == null)
            {
                return(false);
            }

            // select the atom plugin tab first
            new AtomSelectTab("Plugins", atom).Execute(args);

            // click the "add" button
            var ui = atom.GetComponentInChildren <MVRPluginManagerUI>();

            if (ui != null)
            {
                ui?.addPluginButton?.onClick?.Invoke();
                if (_showFilePrompt)
                {
                    // find the newest empty plugin ui section that was added
                    var lastAddedPluginUi = atom.GetComponentsInChildren <MVRPluginUI>()
                                            .Where((x) => x.urlText.text.Equals(string.Empty))
                                            .LastOrDefault();
                    if (lastAddedPluginUi != null)
                    {
                        // prompt the user to select a file
                        lastAddedPluginUi.fileBrowseButton?.onClick?.Invoke();
                        // wait up to 120 seconds for user to have made a choice and open
                        atom.StartCoroutine(Waiter(120, lastAddedPluginUi, (found) =>
                        {
                            if (found != null && _openPluginUi)
                            {
                                found.openUIButton?.onClick?.Invoke();
                            }
                            return;
                        }));
                    }
                }
            }
            return(true);
        }
Esempio n. 23
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _unitsPerSecond))
                {
                    return(false);
                }
            }

            // this algorithm from Supercontroller.cs ProcessMouseControl()
            var navigation = SuperController.singleton.navigationRig;
            var target     = _target();

            if (navigation != null && target != null)
            {
                var amount = _unitsPerSecond * Mathf.Abs(args.Data) * Time.deltaTime;

                // from SuperController ProcessMouseControl
                // float num3 = 0.1f;
                // if (amount < -0.5f)
                // {
                //     num3 = 0f - amount;
                // }

                Vector3 forward = target.forward;
                Vector3 val8    = amount * forward * SuperController.singleton.focusDistance;
                Vector3 val9    = navigation.position + val8;
                SuperController.singleton.focusDistance *= 1f - amount;
                Vector3 up3  = navigation.up;
                float   num4 = Vector3.Dot(val8, up3);
                val9 += up3 * (0f - num4);

                navigation.position = val9;
                SuperController.singleton.playerHeightAdjust += num4;
            }

            return(true);
        }
Esempio n. 24
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _incrementBy))
                {
                    return(false);
                }
            }

            var plugin = SuperController.singleton.GetPluginStorable(_atomUid, _pluginName);

            var choices       = plugin.GetStringChooserJSONParamChoices(_key);
            var selectedIndex = choices.FindIndex((c) => c.Equals(plugin.GetStringChooserParamValue(_key)));
            var newValue      = choices[Mathf.Clamp(selectedIndex + _incrementBy, 0, choices.Count - 1)];

            plugin?.SetStringChooserParamValue(_key, newValue);
            return(true);
        }
Esempio n. 25
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var selected = TargetAtom(args);

            if (selected != null)
            {
                var pattern = selected.GetComponentInChildren <AnimationPattern>();
                if (pattern != null)
                {
                    switch (_action)
                    {
                    case PLAY:
                        pattern.Play();
                        break;

                    case RESET_AND_PLAY:
                        pattern.ResetAndPlay();
                        break;

                    case PAUSE:
                        pattern.Pause();
                        break;

                    case UNPAUSE:
                        pattern.UnPause();
                        break;

                    case TOGGLE_PAUSE:
                        pattern.TogglePause();
                        break;

                    case RESET:
                        pattern.ResetAnimation();
                        break;
                    }
                }
            }
            return(true);
        }
Esempio n. 26
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            var plugin = SuperController.singleton.GetPluginStorable(_atomUid, _pluginName);

            if (plugin == null)
            {
                return(false);
            }
            // make sure the atom plugin tab is showing
            if (new AtomSelectTab("Plugins", plugin.containingAtom).Execute(args))
            {
                var atom = plugin.containingAtom;
                foreach (var scriptController in atom.GetComponentsInChildren <MVRScriptControllerUI>())
                {
                    if (scriptController.label.text.Equals(plugin.name))
                    {
                        scriptController.openUIButton?.onClick?.Invoke();
                        return(true);
                    }
                }
            }
            return(true);
        }
Esempio n. 27
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _value))
                {
                    return(false);
                }
            }

            var multiplier = _multiplier;

            if (InputWrapper.GetKey(KeyCode.LeftShift) || InputWrapper.GetKey(KeyCode.RightShift))
            {
                multiplier *= 5.0f;
            }
            var scale = TimeControl.singleton.currentScale + (_value * multiplier);

            TimeControl.singleton.currentScale = Mathf.Clamp(scale, _min, _max);
            return(true);
        }
Esempio n. 28
0
        public override bool Execute(CommandExecuteEventArgs args)
        {
            if (args.KeyBinding.KeyChord.HasAxis)
            {
                // make sure the keybinding and value change are going the
                // same "direction" (for the case where the axis is involved)
                if (!MathUtilities.SameSign(args.Data, _unitsPerSecond))
                {
                    return(false);
                }
            }

            // this algorithm from Supercontroller.cs ProcessMouseControl()
            var navigation = SuperController.singleton.navigationRig;
            var target     = _target();

            if (navigation != null && target != null)
            {
                var rotate = 360 * Time.deltaTime * _unitsPerSecond * Mathf.Abs(args.Data);

                if (_axis == Axis.X)
                {
                    navigation.RotateAround(target.Value, navigation.up, rotate);
                }
                else if (_axis == Axis.Y)
                {
                    navigation.RotateAround(target.Value, navigation.right, rotate);
                }
                else if (_axis == Axis.Z)
                {
                    navigation.RotateAround(target.Value, navigation.forward, rotate);
                }
            }

            return(true);
        }
Esempio n. 29
0
 public override bool Execute(CommandExecuteEventArgs args)
 {
     SuperController.singleton.StartCoroutine(SuperController.singleton.AddAtomByType(_type, useuid: null, userInvoked: false));
     return(true);
 }