// Update is called once per frame void GetInput(InputDevice inputDevice) { if(inputDevice.MenuWasPressed) { Application.LoadLevel(1); } }
public Editor(InputDevice input) { this.input = input; player = new Player(input); player.position.Y = 0.0f; player.position.Z = 15.0f; camera = new FirstPersonCamera(player); camera.width = Application.WIDTH; camera.height = Application.HEIGHT; camera.near = 0.1f; camera.far = 500; camera.fov = 1.1f; depth_values = new float[]{ 0, -150, -400}; curr_depth_index = 0; cursor = new Cursor(6); cursor.color = Color.Gray; level = new Level(); asset_list = new List<object>(); asset_list.Add(Resources.box_model); asset_list.Add(Resources.rock_model); asset_list.Add(Resources.seaurchin_model); asset_list.Add(Resources.ray_texture); asset_list.Add(Resources.starfish_model); instance = this; }
void Update() { //Check for A button to change scene to correct boss inputDevice = InputManager.ActiveDevice; if(Input.GetKeyDown(KeyCode.A) || inputDevice.GetControl(InputControlType.Action1).WasPressed){ GameController.LoadLastScene(); } }
public void changePlayer(InputDevice inputDevice) { if (inputDevice.Action4.WasPressed ) { } }
// Use this for initialization void Start() { asource = this.GetComponent<AudioSource>(); inputDevice = (InputManager.Devices.Count > 0) ? InputManager.Devices[0] : null; started_timer = true; timer = max_timer; }
// Update is called once per frame void Update() { if (InputManager.Devices.Count - 1 >= playerIndex) myDevice = InputManager.Devices[playerIndex]; else myDevice = null; if (myDevice == null) return; aIn = myDevice.Action1.WasPressed; for (int i = 0; i < InputManager.Devices.Count; i++) { if(i < 2){ controllers[i].color = Color.blue; } else { controllers[i].color = Color.red; } } if (InputManager.Devices.Count < 4) { Text prompt = GameObject.Find("Instructions").GetComponent<Text>(); prompt.text = "Waiting for "+(4-InputManager.Devices.Count)+" more players..."; } if (aIn) { Launch (); } }
public static float GetAxisRawForPlayer(string axisName, int playerIndex, InputDevice device) { // return Input.GetAxisRaw (ConcatPlayerIndex(axisName, playerIndex, device)); float xbox = Input.GetAxisRaw (ConcatPlayerIndex (axisName, playerIndex, InputDevices.GetAllInputDevices () [(int)InputDevices.ControllerTypes.XBox])); float keyboard = Input.GetAxisRaw (ConcatPlayerIndex (axisName, playerIndex, InputDevices.GetAllInputDevices () [(int)InputDevices.ControllerTypes.Keyboard])); return xbox + keyboard; }
public static bool GetButtonUpForPlayer(string buttonName, int playerIndex, InputDevice device) { // return Input.GetButtonUp (ConcatPlayerIndex (buttonName, playerIndex, device)); bool xbox = Input.GetButtonUp (ConcatPlayerIndex (buttonName, playerIndex, InputDevices.GetAllInputDevices () [(int)InputDevices.ControllerTypes.XBox])); bool keyboard = Input.GetButtonUp (ConcatPlayerIndex (buttonName, playerIndex, InputDevices.GetAllInputDevices () [(int)InputDevices.ControllerTypes.Keyboard])); return xbox || keyboard; }
// Use this for initialization void Start() { start_btn = exit_game_button.GetComponent<console_button>(); asource = this.GetComponent<AudioSource>(); inputDevice = (InputManager.Devices.Count > 0) ? InputManager.Devices[0] : null; start_btn.set_selected(); }
void UpdateCubeWithInputDevice( InputDevice inputDevice ) { // Set object material color based on which action is pressed. if (inputDevice.Action1) { cubeRenderer.material.color = Color.green; } else if (inputDevice.Action2) { cubeRenderer.material.color = Color.red; } else if (inputDevice.Action3) { cubeRenderer.material.color = Color.blue; } else if (inputDevice.Action4) { cubeRenderer.material.color = Color.yellow; } else { cubeRenderer.material.color = Color.white; } // Rotate target object with both sticks and d-pad. transform.Rotate( Vector3.down, 500.0f * Time.deltaTime * inputDevice.Direction.X, Space.World ); transform.Rotate( Vector3.right, 500.0f * Time.deltaTime * inputDevice.Direction.Y, Space.World ); transform.Rotate( Vector3.down, 500.0f * Time.deltaTime * inputDevice.RightStickX, Space.World ); transform.Rotate( Vector3.right, 500.0f * Time.deltaTime * inputDevice.RightStickY, Space.World ); }
//mouvement du player sur les axes x et z public void checkInputPlayer(InputDevice inputDevice) { inputDevice = (InputManager.Devices.Count > playerNum) ? InputManager.Devices[playerNum] : null; if(inputDevice!=null) updateWithInControle (inputDevice); }
public MonkActions(InputDevice device) { spawn0 = CreatePlayerAction ("Spawn0"); spawn1 = CreatePlayerAction ("Spawn1"); spawn2 = CreatePlayerAction ("Spawn2"); spawn3 = CreatePlayerAction ("Spawn3"); fireTurret = CreatePlayerAction ("FireTurret"); moveUnitLeft = CreatePlayerAction ("MoveUnitLeft"); moveUnitRight = CreatePlayerAction ("MoveUnitRight"); moveHorizontal = CreateOneAxisPlayerAction (moveUnitLeft, moveUnitRight); moveUnitUp = CreatePlayerAction ("MoveUnitUp"); moveUnitDown = CreatePlayerAction ("MoveUnitDown"); moveVertical = CreateOneAxisPlayerAction (moveUnitDown,moveUnitUp); Device = device; spawn0.AddDefaultBinding (InputControlType.Action1); spawn1.AddDefaultBinding (InputControlType.Action2); spawn2.AddDefaultBinding (InputControlType.Action3); spawn3.AddDefaultBinding (InputControlType.Action4); fireTurret.AddDefaultBinding (InputControlType.RightTrigger); moveUnitLeft.AddDefaultBinding (InputControlType.LeftStickLeft); moveUnitRight.AddDefaultBinding (InputControlType.LeftStickRight); moveUnitUp.AddDefaultBinding (InputControlType.LeftStickUp); moveUnitDown.AddDefaultBinding (InputControlType.LeftStickDown); }
public override void OnActive(double elapsed, InputDevice input) { editor.Update(elapsed); if (input.IsPressed(Buttons.Start)) screenmanager.FadeIn(menu_screen); }
Cursor CreateButton( InputDevice inputDevice ) { if (colorSelectionManagers.Count < maxColorSelectors) { // Pop a position off the list. We'll add it back if the player is removed. //var playerPosition = spawnPoints[0]; //spawnPoints.RemoveAt( 0 ); var gameObject = (GameObject) Instantiate( colorSelectionManagerPrefab, new Vector3(0,0,0), Quaternion.identity ); gameObject.transform.SetParent(GameObject.Find("ColorInputManager").transform); gameObject.transform.localPosition = new Vector3(0,0,0); gameObject.transform.localScale = new Vector3(1,1,1); var buttonManager = gameObject.GetComponent<Cursor>(); buttonManager.device = inputDevice; buttonManager.liaison = layla; //scale.c1 = Color.cyan; //colorSelectionManagers.Add( buttonManager ); // Debug.Log("Adding a new player with device: " + inputDevice); layla.GetComponent<GameControlLiaison>().CreatePlayer(inputDevice); return buttonManager; } return null; }
// Update is called once per frame void GetInput(InputDevice inputDevice) { if(inputDevice.MenuWasPressed) { Join (); } if (playerJoined) { if(!playerReady) { if(inputDevice.Action1) { Ready (); } if(inputDevice.Action2.WasPressed) { Leave (); } } else { if(inputDevice.Action2.WasPressed) { Unready (); } } } }
public SpaceShip(PlayerIndex playerNumber, Vector2 position, float rotation, SpriteSheet spriteSheet, ProjectileSystem projectileSystem, GameSettings settings, ContentManager content) { // instantiate the player's number with a player index m_playerNumber = playerNumber; if(m_playerNumber == PlayerIndex.One) { m_colour = SpaceShipColour.Red; } else if(m_playerNumber == PlayerIndex.Two) { m_colour = SpaceShipColour.Blue; } else if(m_playerNumber == PlayerIndex.Three) { m_colour = SpaceShipColour.Green; } else if(m_playerNumber == PlayerIndex.Four) { m_colour = SpaceShipColour.Yellow; } // instantiate the player's input device type m_inputDevice = settings.getInputDevice(playerNumber); if(m_inputDevice == InputDevice.Controller1) { m_controllerNumber = PlayerIndex.One; } else if(m_inputDevice == InputDevice.Controller2) { m_controllerNumber = PlayerIndex.Two; } else if(m_inputDevice == InputDevice.Controller3) { m_controllerNumber = PlayerIndex.Three; } else if(m_inputDevice == InputDevice.Controller4) { m_controllerNumber = PlayerIndex.Four; } else { m_controllerNumber = PlayerIndex.One; } // instantiate local variables this.position = position; this.rotation = rotation; m_scale = new Vector2(1, 1); m_maximumVelocity = 5.8f; m_acceleration = 0.048f; m_rotationSpeed = 3.1f; m_settings = settings; m_spriteSheet = spriteSheet; m_projectileSystem = projectileSystem; if(m_spriteSheet == null) { return; } // initialize sprite / sprite animation arrays m_idleSprite = new Sprite[3]; m_movingAnimation = new SpriteAnimation[3]; // set the space ship sprite sheet offset based on the space ship colour int spriteOffset = 0; if(m_colour == SpaceShipColour.Red) { spriteOffset = 0; } else if(m_colour == SpaceShipColour.Blue) { spriteOffset = 18; } else if(m_colour == SpaceShipColour.Green) { spriteOffset = 3; } else if(m_colour == SpaceShipColour.Yellow) { spriteOffset = 21; } // load the idle sprites for each colour for(int i=0;i<3;i++) { m_idleSprite[i] = m_spriteSheet.getSprite(i + spriteOffset); } // create and store the movement animations for each colour for(int i=0;i<3;i++) { m_movingAnimation[i] = new SpriteAnimation(0.16f, SpriteAnimationType.Loop); m_movingAnimation[i].addSprite(m_spriteSheet.getSprite(i + spriteOffset + 6)); m_movingAnimation[i].addSprite(m_spriteSheet.getSprite(i + spriteOffset + 12)); } m_offset = new Vector2(m_idleSprite[1].xOffset * 0.9f, m_idleSprite[1].yOffset * 0.9f); m_size = new Vector2(m_offset.X * 2.0f, m_offset.Y * 2.0f); updateInitialValues(); }
public Player(int index, int playerInputLayer, InputDevice inputDevice) { m_playerIndex = index; m_playerInputLayer = playerInputLayer; m_money = 500; m_health = 3; m_device = inputDevice; }
public void BindPlayer(int index, InputDevice device) { isPlayerBound = true; PlayerIndex = index; playerDevice = device; fighter.SetHuman (true); }
public Player(int num, InputDevice d) { playerNum = num; device = d; ResetElementStats(Element.EARTH); ResetElementStats(Element.FIRE); ResetElementStats(Element.WATER); }
void OnDeviceDetached( InputDevice inputDevice ) { var player = FindPlayerUsingDevice( inputDevice ); if (player != null) { //RemovePlayer( player ); } }
// Use this for initialization void Start() { if (InputManager.Devices.Count >= playerID) { iDevice = InputManager.Devices[playerID - 1]; } headOriginPos = head.transform.localPosition; }
public void Show(InputDevice inputUsed, int monsterChoice) { this.monsterChoice = monsterChoice; ShowMonsterChoice(); this.inputUsed = inputUsed; isInUse = true; }
public void Init(InputDevice device, UnitColor color){ base.Init(color); attackerActions = new AttackerActions(device); motor.Init(attackerActions); atk.Init(attackerActions); }
public bool PlayerJoin(InputDevice inputDevice) { if (!activeDevices.Contains(inputDevice)) { activeDevices.Add(inputDevice); return true; } return false; }
public Player(InputDevice input, int monsterChoice, string name, Color color) { kills = 0; deaths = 0; this.input = input; this.monsterChoice = monsterChoice; this.name = name; this.color = color; }
public override void OnActive(double elapsed, InputDevice input) { if (input.IsPressed(Buttons.B)) { TransitionTo(parent); } base.OnActive(elapsed, input); }
//For now this is called whenever a device is connected or disconnected. //This is because we need to reconnect to the controller we originally connected to. public void DeviceUpdate() { foreach(InputDevice d in InputManager.Devices) { if (d.Meta == m_device.Meta) { m_device = d; return; } } }
private void Update() { inputDevice = InputManager.ActiveDevice; h = inputDevice.LeftStickX.Value; v = inputDevice.LeftStickY.Value; orbitH = inputDevice.RightStickX; orbitV = inputDevice.RightStickY; //print (inputDevice.RightStickX); //---------------------------------------------------------------------------------------------------------------------- // Character Movement //---------------------------------------------------------------------------------------------------------------------- if (inputDevice.LeftStickY.WasPressed) { onInput(InputEvent.StartRunning); onInput(InputEvent.faceOppositeDirection); } if (inputDevice.LeftStickY.WasReleased) onInput(InputEvent.StopRunning); //---------------------------------------------------------------------------------------------------------------------- // Jumping //---------------------------------------------------------------------------------------------------------------------- if (inputDevice.Action4.IsPressed) jumpKeyHoldDuration += Time.deltaTime; // if pressed Y or pressed Space if (inputDevice.Action4.WasReleased) { onInput(InputEvent.JumpUp); // Reset the jump key timer jumpKeyHoldDuration = 0.0f; } //---------------------------------------------------------------------------------------------------------------------- // Recenter Camera //---------------------------------------------------------------------------------------------------------------------- if (inputDevice.RightBumper.WasReleased) onInput(InputEvent.RecenterCam); //---------------------------------------------------------------------------------------------------------------------- // Camera Orbiting //---------------------------------------------------------------------------------------------------------------------- if (inputDevice.RightStickX.IsPressed) onInput(InputEvent.OrbitCamera); if (inputDevice.RightStickX.WasReleased) onInput(InputEvent.CamBehind); }
void UpdateCubeWithInputDevice(InputDevice device) { if (device.RightStick.X == 0 && device.RightStick.Y == 0 ) { stick.transform.position = player.transform.position; } else { stick.transform.position = player.transform.position + new Vector3 (device.RightStick.X * 3, device.RightStick.Y * 3, stick.transform.position.z); } }
public override void OnActive(double elapsed, InputDevice input) { if (input.IsPressed(Buttons.Start) || input.IsPressed(Buttons.B)) TransitionTo(parent); if (input.IsPressed(Buttons.A) && curr_option == 3) Application.GetInstance().Exit(); base.OnActive(elapsed, input); }
private bool ThereIsNoPlayerUsingJoystick(InputDevice inputDevice) { return(FindPlayerUsingJoystick(inputDevice) == null); }
private void GetRightDevice() { InputDevices.GetDevicesAtXRNode(rightHand, devicesRight); DeviceRight = devicesRight.FirstOrDefault(); }
public RemoteControlEventArgs() { _rcb = RemoteControlButton.Unknown; _device = InputDevice.Key; }
public TraceEffect(Grid parent, double radius, Point center, Vector direction, double minLength, int i) { Index = i; Center = center; Radius = radius; Direction = direction; MainBall.Height = MainBall.Width = radius * 2; MainBall.Margin = new Thickness { Left = center.X - radius, Top = center.Y - radius }; InputDevice d = null; var ball = new Ellipse { Fill = Brushes.pending, Width = radius, Height = radius, HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, }; var line = new Line { Stroke = Brushes.pending, HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, IsHitTestVisible = false }; Action <Point> moveTo = newTo => { ball.Margin = new Thickness { Left = newTo.X - ball.Width / 2, Top = newTo.Y - ball.Width / 2 }; line.X2 = newTo.X; line.Y2 = newTo.Y; }; EventHandler <TouchEventArgs> start = (s, e) => { if (d != null) { return; } d = e.Device; MainBall.Fill = Brushes.picked; moveTo(e.GetTouchPoint(parent).Position); ReadyToMove?.Invoke(this, EventArgs.Empty); }; MainBall.TouchDown += start; ball.TouchDown += start; var to = center + Direction; line.X1 = center.X; line.Y1 = center.Y; moveTo(to); ball.Height = Width / 3; ball.Width = Width / 3; parent.Children.Add(line); parent.Children.Add(MainBall); parent.Children.Add(ball); moveTo(to); Func <TouchEventArgs, bool> tryMove = e => { if (e.Device != d) { return(false); } var newTo = e.GetTouchPoint(parent).Position; Direction = newTo - Center; moveTo(newTo); return(true); }; parent.TouchMove += (s, e) => { if (tryMove(e)) { Moving?.Invoke(this, EventArgs.Empty); } }; Func <GradientStopCollection> tempSc = () => { var r = new Random(); var b = new byte[3]; var rr = new List <Color>(); for (var ii = 0; ii < 3; ii++) { r.NextBytes(b); rr.Add(Color.FromArgb(255, b[0], b[1], b[2])); } var os = 0; return(new GradientStopCollection(rr.Select(rrrr => new GradientStop { Color = rrrr, Offset = os++ / 2.0 }))); }; parent.TouchLeave += (s, e) => { if (!tryMove(e)) { return; } d = null; Released = true; if (Direction.Length < minLength) { Direction = new Vector(); moveTo(center); } else { var sc = tempSc(); ball.Fill = MainBall.Fill = new RadialGradientBrush(sc); line.Fill = new LinearGradientBrush(sc); } Moved?.Invoke(this, EventArgs.Empty); }; }
private bool deviceIsController(InputDevice device) { return(!device.Name.Equals("None", StringComparison.InvariantCulture)); }
/// <inheritdoc /> protected override void UpdateButtonData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice) { using (UpdateButtonDataPerfMarker.Auto()) { Debug.Assert(interactionMapping.AxisType == AxisType.Digital); InputFeatureUsage <bool> buttonUsage; // These mappings are flipped from the base class, // where thumbstick is primary and touchpad is secondary. switch (interactionMapping.InputType) { case DeviceInputType.TouchpadTouch: buttonUsage = CommonUsages.primary2DAxisTouch; break; case DeviceInputType.TouchpadPress: buttonUsage = CommonUsages.primary2DAxisClick; break; case DeviceInputType.ThumbStickPress: buttonUsage = CommonUsages.secondary2DAxisClick; break; default: base.UpdateButtonData(interactionMapping, inputDevice); return; } if (inputDevice.TryGetFeatureValue(buttonUsage, out bool buttonPressed)) { interactionMapping.BoolData = buttonPressed; } // If our value changed raise it. if (interactionMapping.Changed) { // Raise input system event if it's enabled if (interactionMapping.BoolData) { CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction); } else { CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction); } } } }
/// <summary> /// Gets or adds a controller using the InputDevice name provided. /// </summary> /// <param name="inputDevice">The InputDevice from XR SDK.</param> /// <returns>The controller reference.</returns> protected virtual GenericXRSDKController GetOrAddController(InputDevice inputDevice) { using (GetOrAddControllerPerfMarker.Auto()) { // If a device is already registered with the ID provided, just return it. if (ActiveControllers.ContainsKey(inputDevice)) { var controller = ActiveControllers[inputDevice]; Debug.Assert(controller != null); return(controller); } Handedness controllingHand; if (inputDevice.characteristics.IsMaskSet(InputDeviceCharacteristics.Left)) { controllingHand = Handedness.Left; } else if (inputDevice.characteristics.IsMaskSet(InputDeviceCharacteristics.Right)) { controllingHand = Handedness.Right; } else { controllingHand = Handedness.None; } SupportedControllerType currentControllerType = GetCurrentControllerType(inputDevice); Type controllerType = GetControllerType(currentControllerType); if (controllerType == null) { return(null); } InputSourceType inputSourceType = GetInputSourceType(currentControllerType); IMixedRealityPointer[] pointers = RequestPointers(currentControllerType, controllingHand); IMixedRealityInputSource inputSource = Service?.RequestNewGenericInputSource($"{currentControllerType} Controller {controllingHand}", pointers, inputSourceType); GenericXRSDKController detectedController = Activator.CreateInstance(controllerType, TrackingState.NotTracked, controllingHand, inputSource, null) as GenericXRSDKController; if (detectedController == null || !detectedController.Enabled) { // Controller failed to be set up correctly. Debug.LogError($"Failed to create {controllerType.Name} controller"); // Return null so we don't raise the source detected. return(null); } for (int i = 0; i < detectedController.InputSource?.Pointers?.Length; i++) { detectedController.InputSource.Pointers[i].Controller = detectedController; } ActiveControllers.Add(inputDevice, detectedController); Service?.RaiseSourceDetected(detectedController.InputSource, detectedController); return(detectedController); } }
// Update is called once per frame void Update() { InputDevice device = InputDevices.GetDeviceAtXRNode(inputSource); device.TryGetFeatureValue(CommonUsages.primary2DAxis, out inputAxis); }
void OnGUI() { switch (inputDevice) { case InputDevice.MouseKeyboard: if (isJoystickInput()) { inputDevice = InputDevice.Joystick; if (hud != null) { hud.controllerInput = true; hud.ShowText("Control scheme changed to Controller", 2f, 0.5f); } } else if (isMobileInput()) { inputDevice = InputDevice.Mobile; if (hud != null) { hud.controllerInput = true; hud.ShowText("Control scheme changed to Mobile", 2f, 0.5f); } } break; case InputDevice.Joystick: if (isMouseKeyboard()) { inputDevice = InputDevice.MouseKeyboard; if (hud != null) { hud.controllerInput = false; hud.ShowText("Control scheme changed to Keyboard/Mouse", 2f, 0.5f); } } else if (isMobileInput()) { inputDevice = InputDevice.Mobile; if (hud != null) { hud.controllerInput = true; hud.ShowText("Control scheme changed to Mobile", 2f, 0.5f); } } break; case InputDevice.Mobile: if (isMouseKeyboard()) { inputDevice = InputDevice.MouseKeyboard; if (hud != null) { hud.controllerInput = false; hud.ShowText("Control scheme changed to Keyboard/Mouse", 2f, 0.5f); } } else if (isJoystickInput()) { inputDevice = InputDevice.Joystick; if (hud != null) { hud.controllerInput = true; hud.ShowText("Control scheme changed to Controller", 2f, 0.5f); } } break; } }
private void ConnectInterfaces(object obj, InputDevice device = null) { var mainMenu = obj as IMainMenu; if (device != null) { var ray = obj as IRay; if (ray != null) { foreach (var proxy in m_AllProxies) { if (!proxy.active) { continue; } var node = GetDeviceNode(device); if (node.HasValue) { bool continueSearching = true; Transform rayOrigin; if (proxy.rayOrigins.TryGetValue(node.Value, out rayOrigin)) { ray.rayOrigin = rayOrigin; // Specific proxy ray setting DefaultProxyRay dpr = null; var customRay = obj as ICustomRay; if (customRay != null) { dpr = rayOrigin.GetComponentInChildren <DefaultProxyRay>(); customRay.showDefaultRay = dpr.Show; customRay.hideDefaultRay = dpr.Hide; } var lockableRay = obj as ILockRay; if (lockableRay != null) { dpr = dpr ?? rayOrigin.GetComponentInChildren <DefaultProxyRay>(); lockableRay.lockRay = dpr.LockRay; lockableRay.unlockRay = dpr.UnlockRay; } continueSearching = false; } if (mainMenu != null) { Transform mainMenuOrigin; if (proxy.menuOrigins.TryGetValue(node.Value, out mainMenuOrigin)) { mainMenu.menuOrigin = mainMenuOrigin; Transform alternateMenuOrigin; if (proxy.alternateMenuOrigins.TryGetValue(node.Value, out alternateMenuOrigin)) { mainMenu.alternateMenuOrigin = alternateMenuOrigin; } } } if (!continueSearching) { break; } } } } } var locomotion = obj as ILocomotion; if (locomotion != null) { locomotion.viewerPivot = VRView.viewerPivot; } var instantiateUI = obj as IInstantiateUI; if (instantiateUI != null) { instantiateUI.instantiateUI = InstantiateUI; } var raycaster = obj as IRaycaster; if (raycaster != null) { raycaster.getFirstGameObject = GetFirstGameObject; } var highlight = obj as IHighlight; if (highlight != null) { highlight.setHighlight = m_HighlightModule.SetHighlight; } var placeObjects = obj as IPlaceObjects; if (placeObjects != null) { placeObjects.placeObject = PlaceObject; } var positionPreview = obj as IPositionPreview; if (positionPreview != null) { positionPreview.positionPreview = m_ObjectPlacementModule.PositionPreview; positionPreview.getPreviewOriginForRayOrigin = GetPreviewOriginForRayOrigin; } var selectionChanged = obj as ISelectionChanged; if (selectionChanged != null) { m_SelectionChanged += selectionChanged.OnSelectionChanged; } if (mainMenu != null) { mainMenu.menuTools = m_AllTools.ToList(); mainMenu.selectTool = SelectTool; mainMenu.menuWorkspaces = m_AllWorkspaceTypes.ToList(); mainMenu.createWorkspace = CreateWorkspace; mainMenu.node = GetDeviceNode(device); mainMenu.setup(); } }
private static GamePadCapabilities CapabilitiesOfDevice(InputDevice device) { //TODO: There is probably a better way to do this. Maybe device.GetMotionRange and device.GetKeyCharacterMap? //Or not http://stackoverflow.com/questions/11686703/android-enumerating-the-buttons-on-a-gamepad var capabilities = new GamePadCapabilities(); capabilities.IsConnected = true; capabilities.GamePadType = GamePadType.GamePad; capabilities.HasLeftVibrationMotor = capabilities.HasRightVibrationMotor = device.Vibrator.HasVibrator; switch (device.Name) { case "OUYA Game Controller": capabilities.HasAButton = true; capabilities.HasBButton = true; capabilities.HasXButton = true; capabilities.HasYButton = true; capabilities.HasLeftXThumbStick = true; capabilities.HasLeftYThumbStick = true; capabilities.HasRightXThumbStick = true; capabilities.HasRightYThumbStick = true; capabilities.HasLeftShoulderButton = true; capabilities.HasRightShoulderButton = true; capabilities.HasLeftTrigger = true; capabilities.HasRightTrigger = true; capabilities.HasDPadDownButton = true; capabilities.HasDPadLeftButton = true; capabilities.HasDPadRightButton = true; capabilities.HasDPadUpButton = true; break; case "Microsoft X-Box 360 pad": capabilities.HasAButton = true; capabilities.HasBButton = true; capabilities.HasXButton = true; capabilities.HasYButton = true; capabilities.HasLeftXThumbStick = true; capabilities.HasLeftYThumbStick = true; capabilities.HasRightXThumbStick = true; capabilities.HasRightYThumbStick = true; capabilities.HasLeftShoulderButton = true; capabilities.HasRightShoulderButton = true; capabilities.HasLeftTrigger = true; capabilities.HasRightTrigger = true; capabilities.HasDPadDownButton = true; capabilities.HasDPadLeftButton = true; capabilities.HasDPadRightButton = true; capabilities.HasDPadUpButton = true; capabilities.HasStartButton = true; capabilities.HasBackButton = true; break; } return(capabilities); }
/// <summary> /// Update spatial pointer and spatial grip data. /// </summary> protected override void UpdatePoseData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice) { using (UpdatePoseDataPerfMarker.Auto()) { Debug.Assert(interactionMapping.AxisType == AxisType.SixDof); // Update the interaction data source switch (interactionMapping.InputType) { case DeviceInputType.SpatialPointer: if (inputDevice.TryGetFeatureValue(CustomUsages.PointerPosition, out currentPointerPosition)) { currentPointerPose.Position = MixedRealityPlayspace.TransformPoint(currentPointerPosition); } if (inputDevice.TryGetFeatureValue(CustomUsages.PointerRotation, out currentPointerRotation)) { currentPointerPose.Rotation = MixedRealityPlayspace.Rotation * currentPointerRotation; } interactionMapping.PoseData = currentPointerPose; // If our value changed raise it. if (interactionMapping.Changed) { // Raise input system event if it's enabled CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionMapping.PoseData); } break; default: base.UpdatePoseData(interactionMapping, inputDevice); break; } } }
public void SetDrivers(InputDevice device, InputFeatureUsage <Vector3> angularVelocityUsage) { m_Device = device; m_AngularVelocityUsage = angularVelocityUsage; }
/// <summary> /// Gets the current controller type for the InputDevice name provided. /// </summary> /// <param name="inputDevice">The InputDevice from XR SDK.</param> /// <returns>The supported controller type.</returns> protected virtual SupportedControllerType GetCurrentControllerType(InputDevice inputDevice) { Debug.Log($"{inputDevice.name} does not have a defined controller type, falling back to generic controller type"); return(SupportedControllerType.GenericUnity); }
public void Devices_SupportXboxControllerOnWindows() { var description = new InputDeviceDescription { interfaceName = "XInput", }; InputDevice device = null; Assert.That(() => device = InputSystem.AddDevice(description), Throws.Nothing); var gamepad = (XInputController)device; Assert.That(gamepad.name, Is.EqualTo("XInputControllerWindows")); // Test right and down and that the layouts get inversion correct InputSystem.QueueStateEvent(gamepad, new XINPUT_GAMEPADState { triggerLeft = 255, triggerRight = 255, leftX = 32767, leftY = -32767, rightX = 32767, rightY = -32767, }); InputSystem.Update(); Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.rightTrigger.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.leftStick.x.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(-0.9999).Within(0.001)); Assert.That(gamepad.rightStick.x.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.rightStick.y.ReadValue(), Is.EqualTo(-0.9999).Within(0.001)); // Test left and up and that the layouts get inversion correct InputSystem.QueueStateEvent(gamepad, new XINPUT_GAMEPADState { triggerLeft = 255, triggerRight = 255, leftX = -32767, leftY = 32767, rightX = -32767, rightY = 32767, }); InputSystem.Update(); Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.rightTrigger.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.leftStick.x.ReadValue(), Is.EqualTo(-0.9999).Within(0.001)); Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); Assert.That(gamepad.rightStick.x.ReadValue(), Is.EqualTo(-0.9999).Within(0.001)); Assert.That(gamepad.rightStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001)); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 1 }, gamepad.dpad.up); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 2 }, gamepad.dpad.down); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 4 }, gamepad.dpad.left); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 8 }, gamepad.dpad.right); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 16 }, gamepad.startButton); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 32 }, gamepad.selectButton); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 64 }, gamepad.leftStickButton); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 128 }, gamepad.rightStickButton); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 256 }, gamepad.leftShoulder); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 512 }, gamepad.rightShoulder); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 4096 }, gamepad.buttonSouth); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 8192 }, gamepad.buttonEast); AssertButtonPress(gamepad, new XINPUT_GAMEPADState { buttons = 16384 }, gamepad.buttonWest); }
bool ThereIsNoPlayerUsingDevice(InputDevice inputDevice) { return(FindPlayerUsingDevice(inputDevice) == null); }
void Awake() { device = InputManager.Devices[player_num]; }
public static float PlayVibration(string situationName, InputDevice device) { float duration = 0f; switch (situationName) { case "HookDestruction": device.Vibrate(balanceData.mediumRumble, 0f); duration = balanceData.mediumVibrationDuration; return(duration); case "RopeCut": device.Vibrate(balanceData.mediumRumble, 0f); duration = balanceData.shortVibrationDuration; return(duration); case "Dash": device.Vibrate(0f, balanceData.mediumVibration); duration = balanceData.shortVibrationDuration; return(duration); // TO DEBUG case "Death": CameraShaker.Instance.ShakeOnce(balanceData.heavyMagnitude, balanceData.roughness, balanceData.fadeIn, balanceData.fadeOut * 3f); device.Vibrate(balanceData.heavyVibration); duration = balanceData.longVibrationDuration; return(duration); // Works for both player to player collision and player to platform collision case "CollisionPlayerPlayer": device.Vibrate(0f, balanceData.lightVibration); duration = balanceData.shortVibrationDuration; return(duration); case "CollisionArrowPlayer": CameraShaker.Instance.ShakeOnce(balanceData.lightMagnitude, balanceData.roughness, balanceData.fadeIn, balanceData.fadeOut); device.Vibrate(0f, balanceData.mediumLightVibration); duration = balanceData.mediumVibrationDuration; return(duration); case "KillingPlayer": device.Vibrate(balanceData.lightRumble, balanceData.heavyVibration); duration = balanceData.mediumVibration; return(duration); case "CollisionArrowShield": device.Vibrate(balanceData.mediumlightRumble, 0f); duration = balanceData.mediumVibrationDuration; return(duration); case "CollisionArrowArrow": CameraShaker.Instance.ShakeOnce(balanceData.lightMagnitude, balanceData.roughness, balanceData.fadeIn, balanceData.fadeOut); device.Vibrate(balanceData.mediumRumble, 0f); duration = balanceData.mediumVibrationDuration; return(duration); case "LaserEdge": CameraShaker.Instance.ShakeOnce(balanceData.lightMagnitude, balanceData.roughness, balanceData.fadeIn, balanceData.fadeOut / 2f); device.Vibrate(balanceData.mediumRumble, balanceData.mediumVibration); duration = balanceData.mediumVibrationDuration; return(duration); case "HookheadOnPlayer": device.Vibrate(0f, balanceData.lightVibration); duration = balanceData.mediumVibrationDuration; return(duration); // TO TEST case "HookProjectileDestroyed": device.Vibrate(balanceData.lightRumble, 0f); duration = balanceData.mediumVibrationDuration; return(duration); default: return(0f); } }
/// <inheritdoc /> protected override void UpdateButtonData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice) { using (UpdateButtonDataPerfMarker.Auto()) { Debug.Assert(interactionMapping.AxisType == AxisType.Digital); // Update the interaction data source switch (interactionMapping.InputType) { case DeviceInputType.Select: if (inputDevice.TryGetFeatureValue(CommonUsages.primaryButton, out bool buttonPressed)) { interactionMapping.BoolData = buttonPressed; } break; default: base.UpdateButtonData(interactionMapping, inputDevice); return; } // If our value changed raise it. if (interactionMapping.Changed) { // Raise input system event if it's enabled if (interactionMapping.BoolData) { CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction); } else { CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction); } } } }
/// <inheritdoc /> protected override void UpdateDualAxisData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice) { using (UpdateDualAxisDataPerfMarker.Auto()) { Debug.Assert(interactionMapping.AxisType == AxisType.DualAxis); InputFeatureUsage <Vector2> axisUsage; // These mappings are flipped from the base class, // where thumbstick is primary and touchpad is secondary. switch (interactionMapping.InputType) { case DeviceInputType.ThumbStick: axisUsage = CommonUsages.secondary2DAxis; break; case DeviceInputType.Touchpad: axisUsage = CommonUsages.primary2DAxis; break; default: base.UpdateDualAxisData(interactionMapping, inputDevice); return; } if (inputDevice.TryGetFeatureValue(axisUsage, out Vector2 axisData)) { // Update the interaction data source interactionMapping.Vector2Data = axisData; } // If our value changed raise it. if (interactionMapping.Changed) { // Raise input system event if it's enabled CoreServices.InputSystem?.RaisePositionInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionMapping.Vector2Data); } } }
bool JoinButtonWasPressedOnDevice(InputDevice inputDevice) { return(inputDevice.Action1.WasPressed || inputDevice.Action2.WasPressed || inputDevice.Action3.WasPressed || inputDevice.Action4.WasPressed); }
/// <inheritdoc /> protected override void UpdateSingleAxisData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice) { using (UpdateSingleAxisDataPerfMarker.Auto()) { Debug.Assert(interactionMapping.AxisType == AxisType.SingleAxis); // Update the interaction data source switch (interactionMapping.InputType) { case DeviceInputType.TriggerPress: case DeviceInputType.GripPress: if (inputDevice.TryGetFeatureValue(CommonUsages.grip, out float gripAmount)) { interactionMapping.BoolData = Mathf.Approximately(gripAmount, 1.0f); } break; default: base.UpdateSingleAxisData(interactionMapping, inputDevice); return; } // If our value changed raise it. if (interactionMapping.Changed) { // Raise bool input system event if it's available if (interactionMapping.BoolData) { CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction); } else { CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction); } } } }
private uint GetControllerId(InputDevice inputDevice) { var handedness = ((uint)(inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Right) ? 2 : inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Left) ? 1 : 0)); return(GetControllerId(handedness)); }
public UserChange(InputUser user, InputUserChange change, InputDevice device = null) { this.user = user; this.change = change; this.device = device; }
public void SetupDevice(int playerNum, InputDevice newDevice, Controls newControls) { pauseMenuUI [playerNum].SetDevice(1, newDevice, newControls); }
public bool GetState(InputDevice inputDevice) { var unityDevice = inputDevice as UnityInputDevice; return(unityDevice.ReadRawButtonState(ButtonIndex)); }
public RemoteControlEventArgs(RemoteControlButton rcb, InputDevice device) { _rcb = rcb; _device = device; }
public float GetValue(InputDevice inputDevice) { return(GetState(inputDevice) ? 1.0f : 0.0f); }
public static bool IsPressed(this InputDevice device, Button button, out bool isPressed, float pressThreshold = -1.0f) { if ((int)button >= s_ButtonData.Length) { throw new ArgumentException("[InputHelpers.IsPressed] The value of <button> is out or the supported range."); } if (!device.isValid) { isPressed = false; return(false); } ButtonInfo info = s_ButtonData[(int)button]; switch (info.type) { case ButtonReadType.Binary: { if (device.TryGetFeatureValue(new InputFeatureUsage <bool>(info.name), out bool value)) { isPressed = value; return(true); } } break; case ButtonReadType.Axis1D: { if (device.TryGetFeatureValue(new InputFeatureUsage <float>(info.name), out float value)) { float threshold = (pressThreshold >= 0.0f) ? pressThreshold : s_DefaultPressThreshold; isPressed = value >= threshold; return(true); } } break; case ButtonReadType.Axis2DUp: { if (device.TryGetFeatureValue(new InputFeatureUsage <Vector2>(info.name), out Vector2 value)) { float threshold = (pressThreshold >= 0.0f) ? pressThreshold : s_DefaultPressThreshold; isPressed = value.y >= threshold; return(true); } } break; case ButtonReadType.Axis2DDown: { if (device.TryGetFeatureValue(new InputFeatureUsage <Vector2>(info.name), out Vector2 value)) { float threshold = (pressThreshold >= 0.0f) ? pressThreshold : s_DefaultPressThreshold; isPressed = value.y <= -threshold; return(true); } } break; case ButtonReadType.Axis2DLeft: { if (device.TryGetFeatureValue(new InputFeatureUsage <Vector2>(info.name), out Vector2 value)) { float threshold = (pressThreshold >= 0.0f) ? pressThreshold : s_DefaultPressThreshold; isPressed = value.x <= -threshold; return(true); } } break; case ButtonReadType.Axis2DRight: { if (device.TryGetFeatureValue(new InputFeatureUsage <Vector2>(info.name), out Vector2 value)) { float threshold = (pressThreshold >= 0.0f) ? pressThreshold : s_DefaultPressThreshold; isPressed = value.x >= threshold; return(true); } } break; default: break; } isPressed = false; return(false); }
private void checkActiveDeviceController(InputDevice device) { //_inputModule.allowMouseInput = !deviceIsController(InputManager.ActiveDevice); }