UnityEngine.Input.GetKeyUp(UnityEngine.KeyCode)

Here are the examples of the csharp api class UnityEngine.Input.GetKeyUp(UnityEngine.KeyCode) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

58 Examples 7

1. Example

Project: Blog
Source File: InputSourceKeyboard.cs
public static bool GetKeyUp(KeyCode keyCode)
	{
		return Input.GetKeyUp(keyCode);
	}

2. Example

Project: Blog
Source File: InputSourceKeyboard.cs
public static bool GetKeyUp(KeyCode keyCode)
	{
		return Input.GetKeyUp(keyCode);
	}

3. Example

Project: Memoria
Source File: Input.cs
public static Boolean GetKeyUp(KeyCode keyName)
        {
            return UnityEngine.Input.GetKeyUp(keyName);
        }

4. Example

Project: Rentitas
Source File: Inspect.cs
public void Update()
        {
            if (Input.GetKeyUp(KeyCode.F2))
                ShowInspector = !ShowInspector;
        }

5. Example

Project: MRDesignLabs_Unity_LunarModule
Source File: InputSourceKeyboard.cs
public static bool GetKeyUp(KeyCode keyCode)
	{
		return Input.GetKeyUp(keyCode);
	}

6. Example

Project: MRDesignLabs_Unity_Tools
Source File: InputSourceKeyboard.cs
public static bool GetKeyUp(KeyCode keyCode)
	{
		return Input.GetKeyUp(keyCode);
	}

7. Example

Project: CodeLabs-GameDev-2-UnityWin10
Source File: GameManager.cs
void Update()
        {
            if (Input.GetKeyUp(KeyCode.F1))
            {

            }
            else if (Input.GetKeyUp(KeyCode.F11))
            {

            }
        }

8. Example

Project: CodeLabs-GameDev-2-UnityWin10
Source File: GameManager.cs
void Update ()
        {
            if (Input.GetKeyUp(KeyCode.F1))
            {
            //LAB_ANSWER_BEGIN 
               UnityEngine.WSA.Launcher.LaunchUri(HelpPath, false);
            //LAB_ANSWER_END 
            } 
            else if (Input.GetKeyUp (KeyCode.F11))
            {
//LAB_ANSWER_BEGIN 
#if NETFX_CORE && WINDOWS_UWP
                //Dispatch from App to UI Thread 
                UnityEngine.WSA.Application.InvokeOnUIThread( ()=>
                {
                    var appView = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView();
                    if (appView.IsFullScreen)
                        appView.ExitFullScreenMode(); 
                    else
                        appView.TryEnterFullScreenMode(); 
                } , false); 
#endif
//LAB_ANSWER_END 
            }
        }

9. Example

Project: Realtime-Unity3d
Source File: TerminalView.cs
protected void Update()
        {
            if (Input.GetKeyUp(VisiblityKey))
            {
                IsVisible = !IsVisible;
            }

        }

10. Example

Project: synthesis
Source File: InputControl.cs
public static bool GetKeyUp(KeyCode key)
    {
        return Input.GetKeyUp(key);
    }

11. Example

Project: synthesis
Source File: InputControl.cs
public static bool GetMouseButtonUp(MouseButton button)
    {
        if (button != MouseButton.None)
        {
            return Input.GetKeyUp((KeyCode)((int)KeyCode.Mouse0 + (int)button));
        }

        return false;
    }

12. Example

Project: knight
Source File: KeyboardInput.cs
public override bool IsKeyUp(InputKey rInputKey)
        {
            KeyCode rKeyCode = KeyCode.None;
            if (mKeys.TryGetValue(rInputKey, out rKeyCode))
            {
                return Input.GetKeyUp(rKeyCode);
            }
            return false;
        }

13. Example

Project: Unity3D.Amqp
Source File: AmqpConsole.cs
private void Update()
        {
            if (Input.GetKeyUp(ToggleKey)) Toggle();
        }

14. Example

Project: HoloViveObserver
Source File: Teleport.cs
private bool WasTeleportButtonReleased( Hand hand )
		{
			if ( IsEligibleForTeleport( hand ) )
			{
				if ( hand.noSteamVRFallbackCamera != null )
				{
					return Input.GetKeyUp( KeyCode.T );
				}
				else
				{
					return hand.controller.GetPressUp( SteamVR_Controller.ButtonMask.Touchpad );
				}
			}

			return false;
		}

15. Example

Project: Illusion-Plugins
Source File: Inspector.cs
public void OnUpdate()
        {

            if (Input.GetKeyUp(KeyCode.Alpha0))
            {
    /n ..... /n //View Source file for more details /n }

16. Example

Project: Yugioh-For-HoloLens
Source File: AboutScreen.cs
void Update()
    {
        if (Input.GetKeyUp(KeyCode.Return))
        {
            // Treat 'Return' key as pressing the Close button and dismiss the About Screen
            OnStartAR();
        }
        else if (Input.GetKeyUp(KeyCode.JoystickButton0))
        {
            // Similar to above except detecting the first Joystick button
            // Allows external controllers to dismiss the About Screen
            // On an ODG R7 this is the select button
            OnStartAR();
        }
        else if (Input.GetKeyUp(KeyCode.Escape))
        {
#if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
#elif UNITY_ANDROID
            // On Android, the Back button is mapped to the Esc key
            Application.Quit();
#endif
        }
    }

17. Example

Project: unite-12
Source File: Test.cs
private void Update() {
        if (Input.GetKeyUp(KeyCode.Space) || Input.GetKeyUp(KeyCode.Return)) {
            Application.LoadLevel("Main");
        }
    }

18. Example

Project: UnityWindowsCapture
Source File: WebBrowser.cs
private void CheckKey(KeyCode code)
        {
            if (Input.GetKeyDown(code))
                _mainEngine.SendCharEvent((int) code, KeyboardEventType.Down);
            if (Input.GetKeyUp(KeyCode.Backspace))
                _mainEngine.SendCharEvent((int) code, KeyboardEventType.Up);
        }

19. Example

Project: UnityWindowsCapture
Source File: WebBrowser2D.cs
private void CheckKey(KeyCode code)
        {
            if (Input.GetKeyDown(code))
                _mainEngine.SendCharEvent((int) code, KeyboardEventType.Down);
            if (Input.GetKeyUp(KeyCode.Backspace))
                _mainEngine.SendCharEvent((int) code, KeyboardEventType.Up);
        }

20. Example

Project: synthesis
Source File: MouseInput.cs
public override float getInputUp(bool exactKeyModifiers = false, string axis="", InputDevice device=InputDevice.Any)
    {
        if (
            device != InputDevice.Any
            &&
            device != InputDevice.KeyboardAndMouse
            ||
            !checkModifiers(exactKeyModifiers)
           )
        {
            return 0;
        }

        if (mButton != MouseButton.None)
        {
            KeyCode mouseButton = (KeyCode)((int)KeyCode.Mouse0 + (int)mButton);

            return Input.GetKeyUp(mouseButton) ? 1 : 0;
        }

        return getInputByAxis();
    }

21. Example

Project: PrecisionEngineering
Source File: AltKeyFix.cs
public static bool IsKeyUp(SavedInputKey @this)
        {
            int num = @this.value;
            var keyCode = (KeyCode) (num & MASK_KEY);
            return keyCode != KeyCode.None && Input.GetKeyUp(keyCode) &&
                   (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl)) ==
                   ((num & MASK_CONTROL) != 0) &&
                   (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)) == ((num & MASK_SHIFT) != 0) &&
                   (Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt)) == ((num & MASK_ALT) != 0);
        }

22. Example

Project: self-hosted-php-sql-leaderboard
Source File: HighScore.cs
void Update()
    {
        if (pressspace && Input.GetKeyUp(KeyCode.Space))
        {
            Application.LoadLevel(0); //Restart the game if space is pressed after the scores are shown.
        }
    }

23. Example

Project: UnityHello
Source File: UnityEngine_InputWrap.cs
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetKeyUp(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 1 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.KeyCode)))
			{
				UnityEngine.KeyCode arg0 = (UnityEngine.KeyCode)ToLua.ToObject(L, 1);
				bool o = UnityEngine.Input.GetKeyUp(arg0);
				LuaDLL.lua_pushboolean(L, o);
				return 1;
			}
			else if (count == 1 && TypeChecker.CheckTypes(L, 1, typeof(string)))
			{
				string arg0 = ToLua.ToString(L, 1);
				bool o = UnityEngine.Input.GetKeyUp(arg0);
				LuaDLL.lua_pushboolean(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Input.GetKeyUp");
			}
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

24. Example

Project: Yugioh-For-HoloLens
Source File: RpsCore.cs
public void Update()
    {

        // for debugging, it's useful to have a few actions tied to keys/n ..... /n //View Source file for more details /n }

25. Example

Project: tango-examples-unity
Source File: RpsCore.cs
public void Update()
    {
		// Check if we are out of context, which means we likely got back to th/n ..... /n //View Source file for more details /n }

26. Example

Project: synthesis
Source File: KeyboardInput.cs
public override float getInputUp(bool exactKeyModifiers = false, string axis = "", InputDevice device = InputDevice.Any)
    {
        if (
            device != InputDevice.Any
            &&
            device != InputDevice.KeyboardAndMouse
            ||
            !checkModifiersForKeys(exactKeyModifiers)
           )
        {
            return 0;
        }

        float sensitivity = 1;

        if (
            axis != null
            &&
            (
             axis.Equals("Mouse X")
             ||
             axis.Equals("Mouse Y")
            )
           )
        {
            sensitivity = 0.1f;
        }

        return Input.GetKeyUp(mKey) ? sensitivity : 0;
    }

27. Example

Project: DiscordUnity
Source File: DiscordVoiceExample.cs
void Update()
    {
        if (Input.GetKeyDown(KeyCode.V))
        {
            sendClip = Microphone.Start("Microphone (3- Logitech USB Headset)", true, 1, 48000);
            sending = true;
        }

        if (Input.GetKeyUp(KeyCode.V))
        {
            sending = false;
            Microphone.End("Microphone (3- Logitech USB Headset)");
        }

        if (client.isUpdatable)
        {
            client.Update();
        }
    }

28. Example

Project: TrafficReport
Source File: QueryTool.cs
protected override void OnToolGUI(Event e)
        {
            if (Input.GetKeyUp(Config.instance.keyCode))
            {
                Log.info("Toggling tool");
                toolActive = !toolActive;
            }

            if (toolActive && Input.GetKeyUp(KeyCode.Escape))
            {
                toolActive = false;
                return;
            }


            if (paths != null)
            {
                paths.Update();
            }
            else
            {
                Log.debug("paths was NULL");
                base.OnToolGUI(e);
                return;
            }

            if (ToolsModifierControl.toolController.IsInsideUI)
                return;

            if (Event.current.type == EventType.MouseDown)
            {

                if (m_hoverInstance == null)
                {
                    currentReport = null;
                    ui.SetSelectedData(null);
                    ui.SetHighlightData(null,0);
                    paths.SetReport(null);
                }
                
                if (Event.current.button == 0)
                {
                    HandleLeftClick();
                }
                else if (Event.current.button == 1)
                {
                    HandleRightClick();
                }
            }
            else
            {
                HandleHover();
            }

        }

29. Example

Project: MixedRealityToolkit-Unity
Source File: FadeScript.cs
private void Update()
        {
            if (Busy)
            {
                CalculateFade();
            }

            if (Input.GetKeyUp(KeyCode.F))
            {
                DoFade(3, 3, () => { Debug.Log("Done fading out"); }, () => { Debug.Log("Done fading in"); });
            }
        }

30. Example

Project: MRDesignLabs_Unity_PeriodicTable
Source File: FadeScript.cs
private void Update()
        {
            if (Busy)
            {
                CalculateFade();
            }

            if (Input.GetKeyUp(KeyCode.F))
            {
                DoFade(3, 3, () => { Debug.Log("Done fading out"); }, () => { Debug.Log("Done fading in"); });
            }
        }

31. Example

Project: VRGIN
Source File: KeyStroke.cs
public bool Check(KeyMode mode = KeyMode.PressDown)
        {
            if (modifiers.Count == 0 && keys.Count == 0) return false;

            return modifiers.All(key => Input.GetKey(key))
                && keys.All(key => (mode == KeyMode.Press 
                                    ? Input.GetKey(key) 
                                    : (mode == KeyMode.PressDown
                                        ? Input.GetKeyDown(key)
                                        : Input.GetKeyUp(key))))
                && MODIFIER_LIST.Except(modifiers).All(invalidModifier => !Input.GetKey(invalidModifier));
        }

32. Example

Project: GalaxyExplorer
Source File: KeyboardInput.cs
private void Update()
    {
        // Check for all keys that are registered for events
        foreach (KeyCodeEventPair keyCheck in keyCallbacks.Keys)
        {
            bool eventTriggered = false;

            switch (keyCheck.keyEvent)
            {
                case KeyEvent.KeyDown:
                    eventTriggered = Input.GetKey(keyCheck.keyCode);
                    break;
                case KeyEvent.KeyPressed:
                    eventTriggered = Input.GetKeyDown(keyCheck.keyCode);
                    break;
                case KeyEvent.KeyReleased:
                    eventTriggered = Input.GetKeyUp(keyCheck.keyCode);
                    break;
            }

            if (eventTriggered)
            {
                frameEvents.Enqueue(keyCheck);
            }
        }

        while (frameEvents.Count > 0)
        {
            HandleKeyEvent(frameEvents.Dequeue());
        }
    }

33. Example

Project: A-Star-Pathfinding-for-Platformers
Source File: Map.cs
void Update()
    {
        inputs[(int)KeyInput.GoRight] = Input.GetKey(goRightKey);
        inputs[(int)KeyInput.GoLeft] = Input.GetKey(goLeftKey);
        inputs[(int)KeyInput.GoDown] = Input.GetKey(goDownKey);
        inputs[(int)KeyInput.Jump] = Input.GetKey(goJumpKey);

        if (Input.GetKeyUp(KeyCode.Mouse0))
            lastMouseTileX = lastMouseTileY = -1;

        Vector2 mousePos = Input.mousePosition;
        Vector2 cameraPos = Camera.main.transform.position;
        var mousePosInWorld = cameraPos + mousePos - new Vector2(gameCamera.pixelWidth / 2, gameCamera.pixelHeight / 2);

        int mouseTileX, mouseTileY;
        GetMapTileAtPoint(mousePosInWorld, out mouseTileX, out mouseTileY);

        if (Input.GetKeyDown(KeyCode.Mouse0))
        {
            player.TappedOnTile(new Vector2i(mouseTileX, mouseTileY));
        }

        if (Input.GetKey(KeyCode.Mouse1) || Input.GetKey(KeyCode.Mouse2))
        {
            if (mouseTileX != lastMouseTileX || mouseTileY != lastMouseTileY || Input.GetKeyDown(KeyCode.Mouse1) || Input.GetKeyDown(KeyCode.Mouse2))
            {
                if (!IsNotEmpty(mouseTileX, mouseTileY))
                    SetTile(mouseTileX, mouseTileY, TileType.Block );
                else
                    SetTile(mouseTileX, mouseTileY, TileType.Empty);

                lastMouseTileX = mouseTileX;
                lastMouseTileY = mouseTileY;
            }
        }
    }

34. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

35. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

36. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

37. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

38. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

39. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

40. Example

Project: Blog
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

41. Example

Project: UWO
Source File: TestController.cs
void FireBullet(bool isFire)
	{
		if (Input.GetKey(KeyCode.F) || isFire) {
			if (fireCoolDownCount_ <= 0 && Score.CanUse(fireConsumePoint)) {
				fireCoolDownCount_ = fireCoolDownFrame;

				var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
				var direction = ray.direction;
				RaycastHit hit;
				if (Physics.Raycast(ray, out hit, Mathf.Infinity)) {
					direction = (hit.point - transform.position).normalized;
				}
				var obj = Instantiate(bullet, transform.position + direction, bullet.transform.rotation) as GameObject;
				obj.GetComponent<Rigidbody>().AddForce(direction * 3000);
				Synchronizer.Instantiate(emitEffect, obj.transform.position, obj.transform.rotation);
				Score.Sub(fireConsumePoint);
				SoundManager.Play("FireBullet", obj.transform.position);
			}
		}
		if (Input.GetKeyUp(KeyCode.F)) {
			fireCoolDownCount_ = 0;
		}
		--fireCoolDownCount_;
	}

42. Example

Project: MRDesignLabs_Unity
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

43. Example

Project: MRDesignLabs_Unity
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

44. Example

Project: Holographic-Photo-Project
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

45. Example

Project: MixedRealityCompanionKit
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

46. Example

Project: MixedRealityToolkit-Unity
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

47. Example

Project: MRDesignLabs_Unity_LunarModule
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

48. Example

Project: MRDesignLabs_Unity_PeriodicTable
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

49. Example

Project: HoloBot
Source File: KeyboardManager.cs
private void Update()
        {
            lock (detectedKeyEvents)
            {
                pendingKeyEvents.AddRange(detectedKeyEvents);
                detectedKeyEvents.Clear();
            }

            // Check for all keys that are registered for events
            foreach (KeyCodeEventPair keyCheck in registeredCallbacks.Keys)
            {
                bool eventTriggered = false;

                switch (keyCheck.KeyEvent)
                {
                    case KeyEvent.KeyHeld:
                        eventTriggered = Input.GetKey(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyDown:
                        eventTriggered = Input.GetKeyDown(keyCheck.KeyCode);
                        break;
                    case KeyEvent.KeyUp:
                        eventTriggered = Input.GetKeyUp(keyCheck.KeyCode);
                        break;
                }

                if (eventTriggered)
                {
                    pendingKeyEvents.Add(keyCheck);
                }
            }

            for (int eventIndex = 0; eventIndex < pendingKeyEvents.Count; eventIndex++)
            {
                HandleKeyEvent(pendingKeyEvents[eventIndex]);
            }
            pendingKeyEvents.Clear();
        }

50. Example

Project: Memoria
Source File: HonoInputManager.cs
private void ScanKeySources()
    {
        this.ResetSources();
        if (this.isDisablePrimaryKe/n ..... /n //View Source file for more details /n }