ヽ｜∵｜ゝ(Fantom) の 開発blog？

using UnityEngine;

//反転オプションプロパティ (※Logicool Rumble Gamepad F510 でのデフォ例。任意で良い)
bool InvertH { get; set; } = false;  //水平方向反転オプション (UI などでユーザー設定できるようにしておく)
bool InvertV { get; set; } = true;   //垂直方向反転オプション (UI などでユーザー設定できるようにしておく)

//右スティックの入力による方向の取得
float h = Input.GetAxis("HorizontalStickR");   //水平方向 ※InputManager で付けた名前
float v = Input.GetAxis("VerticalStickR");     //垂直方向 ※InputManager で付けた名前
Vector2 dir = new Vector2(h * (InvertH ? 1 : -1), v * (InvertV ? 1 : -1));

//方向による処理など・・・
Debug.Log($"h = {h}, v = {v}, dir = {dir}");

#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
using System.Runtime.InteropServices;

public static class WindowsUtil  //※名前は任意
{
    //https://forum.unity.com/threads/capslock-detection.538792/
    [DllImport("user32.dll")]
    public static extern short GetKeyState(int keyCode);

    //CapsLock の状態取得
    public static bool IsCapsLockOn
        => (((ushort)GetKeyState(0x14)) & 0xffff) != 0; //※.NET 4.x
}
#endif

using UnityEngine;

bool IsCapsLockOn { get; set; }

private void Awake()
{
    #if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
    IsCapsLockOn = WindowsUtil.IsCapsLockOn;  //Windows API を定義したクラス
    #endif
}

private void Update()
{
    if (Input.anyKeyDown)
    {
        if (Input.GetKeyDown(KeyCode.CapsLock))
        {
            IsCapsLockOn = !IsCapsLockOn;
        }

        Debug.Log($"IsCapsLockOn = {IsCapsLockOn}"); //※.NET 4.x
    }
}

・・・(中略 ※前述のコード)・・・
private void OnApplicationFocus(bool focus)
{
    if (focus)
    {
        #if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
        IsCapsLockOn = WindowsUtil.IsCapsLockOn;
        #endif
    }
}

private void OnApplicationPause(bool pause)
{
    if (!pause)  //Resume
    {
        #if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
        IsCapsLockOn = WindowsUtil.IsCapsLockOn;
        #endif
    }
}

・・・(中略)・・・
private IEnumerator OnApplicationFocus(bool focus)
{
    if (focus)
    {
        yield return null;
        #if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
        IsCapsLockOn = WindowsUtil.IsCapsLockOn;
        #endif
    }
}

//OnApplicationPause も同様

using System;
using System.Linq;
using UnityEngine;

public class KeycodeTest : MonoBehaviour { //※クラス名は任意

    KeyCode[] keyCodes = Enum.GetValues(typeof(KeyCode)).Cast<KeyCode>().ToArray();

    // Update is called once per frame
    private void Update () {
        if (Input.anyKeyDown) //※KeyDown のみ
        {
            foreach (var key in keyCodes)
            {
                if (Input.GetKeyDown(key))
                {
                    Debug.Log(key);
                    break;
                }
            }
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.Events;

namespace FantomLib
{
    /// <summary>
    /// ピンチ操作を取得してコールバックする
    /// 2018/01/09 Fantom (Unity 5.6.3p1)
    /// http://fantom1x.blog130.fc2.com/blog-entry-288.html
    ///（使い方）
    ///・適当な GameObject にアタッチして、インスペクタから OnPinchStart, OnPinch にコールバックする関数を登録すれば使用可。
    ///・またはプロパティ IsPinching, Width, Delta, Ratio をフレーム毎監視しても良い（こちらの場合は使用してない状態（IsPinching=false, Width=0, Delta=0, Ratio=1）も含まれる）。
    ///（仕様説明）
    ///・内部的には画面でタッチされた2本の指の間隔をピクセル単位で取得する。ただし戻り値は画面幅で割った正規化された値とピクセルそのもので返すかを選べる（isNormalized）。
    ///・ピンチの操作は1本→2本となったときのみ認識する。3本以上→2本になったときは無効。
    ///・タッチデバイスを UNITY_ANDROID, UNITY_IOS としているので、他のデバイスも加えたい場合は #if の条件文にデバイスを追加する（Input.touchCount が取得できるもののみ）。
    /// </summary>
    public class PinchInput : MonoBehaviour
    {
        public bool isNormalized = true;        //画面幅（or 高さ）で正規化した値でコールバックする（false=ピクセル単位で返す）
        public bool widthReference = true;      //isNormalized=true のとき、画面幅（Screen.width）を基準にする（false=高さ（Screen.height）を基準）[単位が px/Screen.width のようになる]

        //認識する画面上の領域（0.0～1.0）[(0,0):画面左下, (1,1):画面右上]
        public Rect validArea = new Rect(0, 0, 1, 1);

        //ピンチ検出プロパティ（フレーム毎取得用）
        public bool IsPinching {
            get; private set;
        }

        //ピンチ幅(距離) プロパティ（フレーム毎取得用）
        public float Width {
            get; private set;
        }

        //ピンチ幅(距離)の直前との差分 プロパティ（フレーム毎取得用）
        public float Delta {
            get; private set;
        }

        //ピンチ幅(距離)の変化比 プロパティ（フレーム毎取得用）
        public float Ratio {
            get; private set;
        }


        //ピンチ開始コールバック
        [Serializable]
        public class PinchStartHandler : UnityEvent<float, Vector2> { } //Width, center（２指間の中心座標）が返る
        public PinchStartHandler OnPinchStart;

        //ピンチ中コールバック（伸縮率とその差分）
        [Serializable]
        public class PinchHandler : UnityEvent<float, float, float> { } //Width, Delta, Ratio が返る
        public PinchHandler OnPinch;


        //Local Values
        float startDistance;            //ピンチ開始時の指の距離（px）
        float oldDistance;              //直前の伸縮距離（px）


        //アクティブになったら、初期化する（アプリの中断などしたときはリセットする）
        void OnEnable()
        {
            IsPinching = false;
        }

        // Update is called once per frame
        void Update()
        {
            //プロパティはフレーム毎にリセット
            Width = 0; Delta = 0; Ratio = 1;

#if !UNITY_EDITOR && (UNITY_ANDROID || UNITY_IOS)   //タッチで取得したいプラットフォームのみ
            if (Input.touchCount == 2) //ピンチでの操作（2本指のみ）
            {
                //※fingerId と touches[] のインデクスは必ずしも一致しないらしいので fingerId=1 となっている方を取得（指1本→2本になったとき可能とするため）
                Touch touch = (Input.touches[1].fingerId == 1) ? Input.touches[1] : Input.touches[0];
                if (!IsPinching && touch.phase == TouchPhase.Began)   //新しく認識したときのみ
                {
                    //認識する画面上の領域内か？（2本の指の中心の座標を基準にする）
                    Vector2 center = (Input.touches[0].position + Input.touches[1].position) / 2;
                    if (validArea.xMin * Screen.width <= center.x && center.x <= validArea.xMax * Screen.width && 
                        validArea.yMin * Screen.height <= center.y && center.y <= validArea.yMax * Screen.height)
                    {
                        IsPinching = true;      //ピンチ開始

                        //fingerId=0～1 のみ（必ず最初と2本目の指）。指3本→2本（0-2 など）は不可とする。
                        Width = startDistance = oldDistance = Vector2.Distance(Input.touches[0].position, Input.touches[1].position);
                        if (isNormalized)
                        {
                            float unit = widthReference ? Screen.width : Screen.height;
                            Width /= unit;      //画面幅で正規化すれば、解像度に依存しなくなる
                            center /= unit;
                        }

                        if (OnPinchStart != null)
                            OnPinchStart.Invoke(Width, center); //開始時は必ず Delta=0, Ratio=1 となる
                    }
                }
                else if (IsPinching)  //既に認識されているときのみ：3本→2本になったときは無効になる
                {
                    float endDistance = Vector2.Distance(Input.touches[0].position, Input.touches[1].position);
                    Width = endDistance;
                    Delta = endDistance - oldDistance;      //直前との差分
                    Ratio = endDistance / startDistance;    //開始時のピンチ幅(px距離)を基準にした倍率になる
                    oldDistance = endDistance;

                    if (isNormalized)
                    {
                        float unit = widthReference ? Screen.width : Screen.height;
                        Width /= unit;      //画面幅で正規化すれば、解像度に依存しなくなる
                        Delta /= unit;
                    }

                    if (OnPinch != null)
                        OnPinch.Invoke(Width, Delta, Ratio);
                }
            }
            else  //タッチが2つでないときは全て無効にする
#endif
            {
                IsPinching = false;
            }
        }
    }
}

using UnityEngine;

namespace FantomLib
{
    /// <summary>
    /// ピンチでスケールを変化させる（ローカルスケール）
    /// 2018/01/09 Fantom (Unity 5.6.3p1)
    /// http://fantom1x.blog130.fc2.com/blog-entry-288.html
    ///（使い方）
    ///・伸縮したい GameObject にアタッチして、インスペクタから PinchInput のコールバックを登録すれば使用可。
    /// </summary>
    public class PinchToScale : MonoBehaviour
    {
        public Transform target;    //スケール変化させるオブジェクト

        //Local Values
        Vector3 startScale;         //ピンチ開始時スケール
        Vector3 initScale;          //起動初期スケール（リセット用）


        // Use this for initialization
        private void Start()
        {
            if (target == null)
                target = gameObject.transform;  //指定がないときは自身を対象とする

            initScale = target.localScale;
        }

        //width: ピンチ幅, center: ピンチの2本指の中心の座標
        public void OnPinchStart(float width, Vector2 center)
        {
            if (target != null)
                startScale = target.localScale;
        }

        //width: ピンチ幅, delta: 直前のピンチ幅の差, ratio: ピンチ幅の開始時からの伸縮比(1:ピンチ開始時, 1以上拡大, 1より下(1/2,1/3,...)縮小)
        public void OnPinch(float width, float delta, float ratio)
        {
            if (target != null)
                target.localScale = startScale * ratio;
        }

        //スケールを元に戻す
        public void ResetScale()
        {
            if (target != null)
                target.localScale = initScale;
        }
    }
}

using System;
using UnityEngine;

namespace FantomLib
{
    /// <summary>
    /// ピンチで距離を操作する
    /// 2018/01/09 Fantom (Unity 5.6.3p1)
    /// http://fantom1x.blog130.fc2.com/blog-entry-288.html
    ///（使い方）
    ///・カメラなどの GameObject にアタッチして、インスペクタから PinchInput のコールバックを登録すれば使用可。
    ///・距離は target からの直線距離となる。
    /// </summary>
    public class PinchToDistance : MonoBehaviour
    {
        public Transform target;            //視点となるオブジェクト
        public float speed = 2f;            //変化速度
        public float minDistance = 1.0f;    //近づける最小距離
        public bool lookAt = true;          //オブジェクトの方を向く

        //LocalValues
        float initDistance;                 //起動初期距離（リセット用）


        // Use this for initialization
        private void Start()
        {
            if (target != null)
            {
                Vector3 dir = target.position - transform.position;
                initDistance = dir.magnitude;
                if (lookAt)
                    transform.LookAt(target.position);
            }
        }

        //width: ピンチ幅, delta: 直前のピンチ幅の差, ratio: ピンチ幅の開始時からの伸縮比(1:ピンチ開始時, 1以上拡大, 1より下(1/2,1/3,...)縮小)
        public void OnPinch(float width, float delta, float ratio)
        {
            if (target == null)
                return;

            Vector3 dir = target.position - transform.position;
            float distance = Math.Max(minDistance, dir.magnitude - delta * speed);
            Vector3 pos = target.position - dir.normalized * distance;
            transform.position = pos;
            if (lookAt)
                transform.LookAt(target.position);
        }

        //初期の距離に戻す
        public void ResetDistance()
        {
            if (target == null)
                return;

            Vector3 dir = target.position - transform.position;
            Vector3 pos = target.position - dir.normalized * initDistance;
            transform.position = pos;
            if (lookAt)
                transform.LookAt(target.position);
        }
    }
}