public Vector2 GetAxis(WVR_InputId _id)
        {
            if (!this._connected)
            {
                return(Vector2.zero);
            }

            bool _isTouchId = false;

            for (int _t = 0; _t < touchIds.Length; _t++)
            {
                if (_id == touchIds [_t])
                {
                    _isTouchId = true;
                    break;
                }
            }

            if (!_isTouchId)
            {
                Log.e(LOG_TAG, "GetAxis, button " + _id + " does NOT have axis!");
                return(Vector2.zero);
            }

            axis = Interop.WVR_GetInputAnalogAxis(DeviceType, _id);

            //Log.d (LOG_TAG, "GetAxis: {" + axis.x + ", " + axis.y + "}");
            return(new Vector2(axis.x, axis.y));
        }
Esempio n. 2
0
    private Vector2 GetAxis(WVR_AnalogState_t[] analogArray, WVR_InputId _id, WVR_AnalogType aType, int _count)
    {
        Vector2 axis = Vector2.zero;

        if (_count > 0)
        {
            for (int i = 0; i < _count; i++)
            {
                if (analogArray [i].id == _id &&
                    analogArray [i].type == aType)
                {
                    axis.x = analogArray [i].axis.x;
                    axis.y = _id == WVR_InputId.WVR_InputId_Alias1_Trigger ? 0 : analogArray [i].axis.y;                        // trigger does NOT have y value
                    //if (Log.FLAG_BUTTON)
                    //	Log.d (LOG_TAG, "button " + _id + " x=" + axis.x + ", y=" + axis.y);
                    break;
                }
                else
                {
                    Log.e(LOG_TAG, "GetAxis() states unsynchronized! device: " + device
                          + ", analogArray[" + i + "].id: " + analogArray [i].id
                          + ", analogArray[" + i + "].type]: " + analogArray [i].type);
                }
            }
        }
        else
        {
            Log.e(LOG_TAG, "GetAxis() no axis!!");
        }

        return(axis);
    }
Esempio n. 3
0
    private int GetTouchInputMapping(int touchIds_Index, keyMappingInputType status)
    {
        WVR_InputId _btn    = touchIds[touchIds_Index];
        bool        _result = WaveVR_ButtonList.Instance.GetInputMappingPair(this.device, ref _btn);

        if (!_result)
        {
            PrintInfoLog("GetInputMappingPair failed.");
            return(-1);
        }

        int _index = -1;

        for (int i = 0; i < touchIds.Length; i++)
        {
            if (_btn == touchIds[i])
            {
                _index = i;
                break;
            }
        }

        if (_index >= 0 && _index < touchIds.Length)
        {
            PrintInfoLog(status.ToString() + " button: " + touchIds[touchIds_Index] + " is mapped to " + _btn);
        }
        else
        {
            PrintInfoLog("Can't get index in touchIds.");
        }

        return(_index);
    }
Esempio n. 4
0
    public bool GetInputMappingPair(WaveVR_Controller.EDeviceType device, ref WVR_InputId destination)
    {
        if (!WaveVR.Instance.Initialized)
        {
            return(false);
        }

        // Default true in editor mode, destination will be equivallent to source.
        bool _result = true;

        WVR_DeviceType _type = WaveVR_Controller.Input(device).DeviceType;

        /*
         *      uint _ret = Interop.WVR_GetInputMappingTable (_type, this.inputTable, WaveVR_ButtonList.inputTableSize);
         *      for (int _i = 0; _i < (int)_ret; _i++)
         *      {
         *              PrintDebugLog ("GetInputMappingPair " + device + " table: " + _type + " " + this.inputTable [_i].source.id + " to " + inputTable [_i].destination.id);
         *              if (this.inputTable [_i].destination.id == destination)
         *              {
         *                      destination = this.inputTable [_i].source.id;
         *                      _result = true;
         *                      break;
         *              }
         *      }
         */
        _result = Interop.WVR_GetInputMappingPair(_type, destination, ref this.inputPair);
        if (_result)
        {
            destination = this.inputPair.source.id;
        }

        return(_result);
    }
Esempio n. 5
0
        public Vector2 GetAxis(WVR_InputId _id)
        {
            if (!connected)
            {
                return(Vector2.zero);
            }

            if (_id != WVR_InputId.WVR_InputId_Alias1_Touchpad && _id != WVR_InputId.WVR_InputId_Alias1_Trigger)
            {
                Log.e(LOG_TAG, "GetAxis, button " + _id + " does NOT have axis!");
                return(Vector2.zero);
            }

            #if UNITY_EDITOR || UNITY_STANDALONE
            if (isEditorMode)
            {
                var system = WaveVR_PoseSimulator.Instance;
                axis = system.GetAxis(DeviceType, _id);
            }
            else
            #endif
            {
                axis = Interop.WVR_GetInputAnalogAxis(DeviceType, _id);
            }

            //Log.d (LOG_TAG, "GetAxis: {" + axis.x + ", " + axis.y + "}");
            return(new Vector2(axis.x, axis.y));
        }
        private void Update_TouchState(WVR_InputId _id)
        {
            if (AllowTouchActionInAFrame(_id))
            {
                bool _touched = false;

                #if UNITY_EDITOR || UNITY_STANDALONE
                if (isEditorMode && !WaveVR.Instance.isSimulatorOn)
                {
                    var system = WaveVR_PoseSimulator.Instance;
                    _touched = system.GetButtonTouchState(DeviceType, _id);
                }
                else
                #endif
                {
                    _touched = GetEventState_Touch(_id);

                    /*
                     * if(this._connected)
                     *  _touched = Interop.WVR_GetInputTouchState (DeviceType, _id);
                     * if (_touched)
                     *  Log.gpl.d (LOG_TAG, "Update_TouchState(), " + DeviceType + " " + _id + " is touched." + "left-handed? " + IsLeftHanded);
                     */
                }

                for (int _t = 0; _t < touchIds.Length; _t++)
                {
                    if (_id == touchIds [_t])
                    {
                        prevState_touch [_t] = state_touch [_t];
                        state_touch [_t]     = _touched;
                    }
                }
            }
        }
 /// <summary>
 /// Triggers the haptic pulse.
 /// This function is for vibrating 1 time during the "durationMicroSec" micro seconds with normal strength.
 /// For changing the frequency or the strength, please use "TriggerVibration" instead.
 /// </summary>
 /// <param name="_durationMicroSec">Duration micro sec.</param>
 /// <param name="_id">Identifier.</param>
 public void TriggerHapticPulse(
     uint durationMicroSec = 1000000,
     WVR_InputId id        = WVR_InputId.WVR_InputId_Alias1_Touchpad
     )
 {
     TriggerVibration(id, durationMicroSec, 1, WVR_Intensity.WVR_Intensity_Normal);
 }
Esempio n. 8
0
 public void TriggerHapticPulse(
     uint _durationMicroSec = 1000000,
     WVR_InputId _id        = WVR_InputId.WVR_InputId_Alias1_Touchpad
     )
 {
     WaveVR_Controller.Input(this.DeviceType).TriggerHapticPulse();
 }
        /// <summary>
        /// Check if button state is equivallent to specified state.
        /// </summary>
        /// <returns><c>true</c>, equal, <c>false</c> otherwise.</returns>
        /// <param name="_id">input button</param>
        public bool GetPress(WVR_InputId _id)
        {
            bool _state = false;

            switch (_id)
            {
            case WVR_InputId.WVR_InputId_Alias1_Menu:
                _state = (state.BtnPressed & Input_Mask_Menu) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Grip:
                _state = (state.BtnPressed & Input_Mask_Grip) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Touchpad:
                _state = (state.BtnPressed & Input_Mask_Touchpad) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Trigger:
                _state = (state.BtnPressed & Input_Mask_Trigger) != 0 ? true : false;
                break;

            default:
                break;
            }

            return(_state);
        }
Esempio n. 10
0
    public bool GetInputButtonState(WVR_DeviceType type, WVR_InputId id)
    {
        bool pressed = false;

        switch (type)
        {
        case WVR_DeviceType.WVR_DeviceType_Controller_Right:
            for (int _p = 0; _p < pressIds.Length; _p++)
            {
                if (id == pressIds [_p])
                {
                    pressed = state_press_right [_p];
                    break;
                }
            }
            break;

        case WVR_DeviceType.WVR_DeviceType_Controller_Left:
            for (int _p = 0; _p < pressIds.Length; _p++)
            {
                if (id == pressIds [_p])
                {
                    pressed = state_press_left [_p];
                    break;
                }
            }
            break;

        default:
            break;
        }
        return(pressed);
    }
Esempio n. 11
0
    public bool GetInputTouchState(WVR_DeviceType type, WVR_InputId id)
    {
        bool touched = false;

        switch (type)
        {
        case WVR_DeviceType.WVR_DeviceType_Controller_Right:
            for (int _t = 0; _t < touchIds.Length; _t++)
            {
                if (id == touchIds [_t])
                {
                    touched = state_touch_right [_t];
                    break;
                }
            }
            break;

        case WVR_DeviceType.WVR_DeviceType_Controller_Left:
            for (int _t = 0; _t < touchIds.Length; _t++)
            {
                if (id == touchIds [_t])
                {
                    touched = state_touch_left [_t];
                    break;
                }
            }
            break;

        default:
            break;
        }
        return(touched);
    }
        private void Update_PressState(WVR_InputId _id)
        {
            if (AllowPressActionInAFrame(_id))
            {
                bool _pressed = false;

                #if UNITY_EDITOR || UNITY_STANDALONE
                if (isEditorMode && !WaveVR.Instance.isSimulatorOn)
                {
                    var system = WaveVR_PoseSimulator.Instance;
                    _pressed = system.GetButtonPressState(DeviceType, _id);
                }
                else
                #endif
                {
                    _pressed = GetEventState_Press(_id);

                    /*
                     * if (this._connected)
                     *  _pressed = Interop.WVR_GetInputButtonState (DeviceType, _id);
                     * if (_pressed)
                     *  Log.gpl.d (LOG_TAG, "Update_PressState(), " + DeviceType + " " + _id + " is pressed." + "left-handed? " + IsLeftHanded);
                     */
                }

                for (int _p = 0; _p < pressIds.Length; _p++)
                {
                    if (_id == pressIds [_p])
                    {
                        prevState_press [_p] = state_press [_p];
                        state_press [_p]     = _pressed;
                    }
                }
            }
        }
Esempio n. 13
0
    public bool GetInputMappingPair(WVR_DeviceType type, WVR_InputId destination, ref WVR_InputMappingPair_t pair)
    {
        WVR_InputMappingPair_t[] inputTable = new WVR_InputMappingPair_t[10];
        switch (type)
        {
        case WVR_DeviceType.WVR_DeviceType_HMD:
            inputTable = inputTable_Hmd;
            break;

        case WVR_DeviceType.WVR_DeviceType_Controller_Right:
            inputTable = inputTable_Right;
            break;

        case WVR_DeviceType.WVR_DeviceType_Controller_Left:
            inputTable = inputTable_Left;
            break;

        default:
            break;
        }

        for (int i = 0; i < inputTable.Length; i++)
        {
            if (destination == inputTable [i].destination.id)
            {
                pair.source      = inputTable [i].source;
                pair.destination = inputTable [i].destination;
                return(true);
            }
        }

        return(false);
    }
Esempio n. 14
0
        private void Update_TouchState(WVR_InputId _id)
        {
            if (AllowTouchActionInAFrame(_id))
            {
                bool _touched = false;

                #if UNITY_EDITOR || UNITY_STANDALONE
                if (isEditorMode)
                {
                    var system = WaveVR_PoseSimulator.Instance;
                    _touched = system.GetButtonTouchState(DeviceType, _id);
                }
                else
                #endif
                {
                    _touched = Interop.WVR_GetInputTouchState(DeviceType, _id);
                }

                for (int _t = 0; _t < touchIds.Length; _t++)
                {
                    if (_id == touchIds [_t])
                    {
                        prevState_touch [_t] = state_touch [_t];
                        state_touch [_t]     = _touched;
                    }
                }
            }
        }
    private int GetPressInputMapping(int pressIds_Index, keyMappingInputType status)
    {
        WVR_InputId _btn    = pressIds[pressIds_Index];
        bool        _result = WaveVR_ButtonList.Instance != null?WaveVR_ButtonList.Instance.GetInputMappingPair(this.device, ref _btn) : false;

        if (!_result)
        {
            PrintInfoLog("GetInputMappingPair failed[" + pressIds[pressIds_Index] + "].");
            return(-1);
        }

        int _index = -1;

        for (int i = 0; i < pressIds.Length; i++)
        {
            if (pressObjectArrays[i].hasEffect && _btn == pressIds[i])
            {
                _index = i;
                break;
            }
        }

        if (_index >= 0 && _index < pressIds.Length)
        {
            PrintInfoLog(status.ToString() + " button: " + pressIds[pressIds_Index] + " is mapped to " + _btn);
        }
        else
        {
            PrintInfoLog("Can't get index in pressIds.");
        }

        return(_index);
    }
    private void updateDpadPressText()
    {
        if (this.dpad_press_text == null)
        {
            return;
        }

        WVR_DeviceType _type = WaveVR_Controller.Input(this.DeviceType).DeviceType;

        foreach (WVR_InputId _dpadId in this.dpadIds)
        {
            if (WaveVR_ButtonList.Instance != null && WaveVR_ButtonList.Instance.IsButtonAvailable(this.DeviceType, _dpadId))
            {
                if (WaveVR_Controller.Input(this.DeviceType).GetPressDown(_dpadId))
                {
                    this.dpad_press_text.text = _dpadId.ToString();
                    PrintDebugLog("updateDpadPressText() " + _dpadId + " is pressed down.");

                    WVR_InputId _btn    = _dpadId;
                    bool        _result = WaveVR_ButtonList.Instance.GetInputMappingPair(this.DeviceType, ref _btn);
                    if (_result)
                    {
                        PrintDebugLog("updateDpadPressText() " + _dpadId + " is mapping from " + _type + " button " + _btn);
                    }
                }

                if (WaveVR_Controller.Input(this.DeviceType).GetPressUp(_dpadId))
                {
                    this.dpad_press_text.text = "";
                    PrintDebugLog("updateDpadPressText() " + _dpadId + " is pressed up.");
                }
            }
        }
    }
Esempio n. 17
0
        /// <summary>
        /// If true, button with _id is touched, else untouched..
        /// </summary>
        /// <returns><c>true</c>, if touch was gotten, <c>false</c> otherwise.</returns>
        /// <param name="_id">WVR_ButtonId, id of button</param>
        public bool GetTouchUp(WVR_InputId _id)
        {
            bool _state = false;

            Update_TouchState(_id);

            switch (_id)
            {
            case WVR_InputId.WVR_InputId_Alias1_Touchpad:
                _state = (
                    (((state.BtnTouched & Input_Mask_Touchpad) == 0) &&
                     ((pre_state.BtnTouched & Input_Mask_Touchpad) != 0))
                    ? true : false);
                break;

            case WVR_InputId.WVR_InputId_Alias1_Trigger:
                _state = (
                    (((state.BtnTouched & Input_Mask_Trigger) == 0) &&
                     ((pre_state.BtnTouched & Input_Mask_Trigger) != 0))
                    ? true : false);
                break;

            default:
                break;
            }

            return(_state);
        }
Esempio n. 18
0
        /// <summary>
        /// Check if button state is equivallent to specified state.
        /// </summary>
        /// <returns><c>true</c>, equal, <c>false</c> otherwise.</returns>
        /// <param name="_id">input button</param>
        public bool GetPress(WVR_InputId _id)
        {
            bool _state = false;

            Update_PressState(_id);

            switch (_id)
            {
            case WVR_InputId.WVR_InputId_Alias1_Menu:
                _state = (state.BtnPressed & Input_Mask_Menu) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Grip:
                _state = (state.BtnPressed & Input_Mask_Grip) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_DPad_Left:
                _state = (state.BtnPressed & Input_Mask_DPad_Left) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_DPad_Up:
                _state = (state.BtnPressed & Input_Mask_DPad_Up) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_DPad_Right:
                _state = (state.BtnPressed & Input_Mask_DPad_Right) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_DPad_Down:
                _state = (state.BtnPressed & Input_Mask_DPad_Down) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Volume_Up:
                _state = (state.BtnPressed & Input_Mask_Volume_Up) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Volume_Down:
                _state = (state.BtnPressed & Input_Mask_Volume_Down) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Touchpad:
                _state = (state.BtnPressed & Input_Mask_Touchpad) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Trigger:
                _state = (state.BtnPressed & Input_Mask_Trigger) != 0 ? true : false;
                break;

            case WVR_InputId.WVR_InputId_Alias1_Bumper:
                _state = (state.BtnPressed & Input_Mask_Bumper) != 0 ? true : false;
                break;

            default:
                break;
            }

            return(_state);
        }
Esempio n. 19
0
        public Vector2 GetAxis(WVR_InputId _id)
        {
            if (_id != WVR_InputId.WVR_InputId_Alias1_Touchpad && _id != WVR_InputId.WVR_InputId_Alias1_Trigger)
            {
                Log.e(LOG_TAG, "GetAxis, button " + _id + " does NOT have axis!");
                return(Vector2.zero);
            }

            bool           _connected = false;
            WVR_DeviceType _type      = this.DeviceType;

            #if UNITY_EDITOR || UNITY_STANDALONE
            if (isEditorMode)
            {
                _connected = WaveVR_Controller.Input(this.DeviceType).connected;
                _type      = WaveVR_Controller.Input(this.DeviceType).DeviceType;
            }
            else
            #endif
            {
                if (WaveVR.Instance != null)
                {
                    WaveVR.Device _device = WaveVR.Instance.getDeviceByType(this.DeviceType);
                    _connected = _device.connected;
                    _type      = _device.type;
                }
            }

            #if UNITY_EDITOR || UNITY_STANDALONE
            if (isEditorMode)
            {
                if (!WaveVR.Instance.isSimulatorOn)
                {
                    var system = WaveVR_PoseSimulator.Instance;
                    axis = system.GetAxis(_type, WVR_InputId.WVR_InputId_Alias1_Trigger);
                }
                else
                {
                    if (_connected)
                    {
                        axis = WaveVR_Utils.WVR_GetInputAnalogAxis_S((int)_type, (int)_id);
                    }
                }
            }
            else
            #endif
            {
                if (_connected)
                {
                    axis = Interop.WVR_GetInputAnalogAxis(_type, _id);
                }
            }

            //Log.d (LOG_TAG, "GetAxis: {" + axis.x + ", " + axis.y + "}");
            return(new Vector2(axis.x, axis.y));
        }
Esempio n. 20
0
        public Vector2 GetAxis(WVR_InputId _id)
        {
            if (_id != WVR_InputId.WVR_InputId_Alias1_Touchpad && _id != WVR_InputId.WVR_InputId_Alias1_Trigger)
            {
                Log.e(LOG_TAG, "GetAxis, button " + _id + " does NOT have axis!");
                return(Vector2.zero);
            }

            return(WaveVR_Controller.Input(this.DeviceType).GetAxis(_id));
        }
        public Vector2 GetAxis(WVR_InputId btn)
        {
            // No axis if disconnected or untouched.
            if (!_connected || !GetTouch(btn))
            {
                return(Vector2.zero);
            }

            axis = Interop.WVR_GetInputAnalogAxis(DeviceType, btn);
            return(new Vector2(axis.x, axis.y));
        }
 public void SetEventState_Press(WVR_InputId btn, bool down)
 {
     for (int _p = 0; _p < pressIds.Length; _p++)
     {
         if (pressIds [_p] == btn)
         {
             event_state_press [_p] = down;
             Log.d(LOG_TAG, "SetEventState_Press() " + this.DeviceType + ", " + pressIds [_p] + ": " + event_state_press [_p]);
             break;
         }
     }
 }
        public void TriggerHapticPulse(
            uint _durationMicroSec = 1000000,
            WVR_InputId _id        = WVR_InputId.WVR_InputId_Alias1_Touchpad
            )
        {
            if (!this.connected)
            {
                return;
            }

            Interop.WVR_TriggerVibration(DeviceType, _id, _durationMicroSec, 1, WVR_Intensity.WVR_Intensity_Normal);
        }
 public void SetEventState_Touch(WVR_InputId btn, bool down)
 {
     for (int _t = 0; _t < touchIds.Length; _t++)
     {
         if (touchIds [_t] == btn)
         {
             event_state_touch [_t] = down;
             Log.d(LOG_TAG, "SetEventState_Touch() " + this.DeviceType + ", " + touchIds [_t] + ": " + event_state_touch [_t]);
             break;
         }
     }
 }
    public bool GetInputMappingPair(WaveVR_Controller.EDeviceType device, ref EButtons destination)
    {
        bool        _result = false;
        WVR_InputId _wbtn   = (WVR_InputId)destination;

        _result = GetInputMappingPair(device, ref _wbtn);
        if (_result)
        {
            destination = GetEButtonsType(_wbtn);
        }

        return(_result);
    }
        /// <summary>
        /// Triggers the vibration.
        /// </summary>
        /// <param name="id">Button ID.</param>
        /// <param name="durationMicroSec">Duration micro sec.</param>
        /// <param name="frequency">Frequency.</param>
        /// <param name="intensity">Vibration strength.</param>
        public void TriggerVibration(
            WVR_InputId id,
            uint durationMicroSec,
            uint frequency,
            WVR_Intensity intensity)
        {
            if (!this.connected)
            {
                return;
            }

            Interop.WVR_TriggerVibration(DeviceType, id, durationMicroSec, frequency, intensity);
        }
    public bool GetInputMappingPair(WaveVR_Controller.EDeviceType device, ref WaveVR_ButtonList.EButtons destination)
    {
        WVR_InputId id = (WVR_InputId)destination;

        bool ret = GetInputMappingPair(device, ref id);

        if (ret)
        {
            destination = GetEButtonsType(id);
        }

        return(ret);
    }
Esempio n. 28
0
    private void _UpdateCanvas(WVR_DeviceType type, bool isDeviceConnected)
    {
        PrintDebugLog("_UpdateCanvas" + " type=" + type + " isDeviceConnected=" + isDeviceConnected);
#if UNITY_ANDROID && !UNITY_EDITOR
        if (isDeviceConnected && (type == WVR_DeviceType.WVR_DeviceType_Controller_Left || type == WVR_DeviceType.WVR_DeviceType_Controller_Right))
        {
            int    mask_btn   = Interop.WVR_GetInputDeviceCapability(type, WVR_InputType.WVR_InputType_Button);
            string mask_base2 = Convert.ToString(mask_btn, 2);
            PrintDebugLog("type=" + type + " mask_btn=" + mask_btn + " mask_base2=" + mask_base2);

            for (WVR_InputId id = WVR_InputId.WVR_InputId_0; id < WVR_InputId.WVR_InputId_Max; id++)
            {
                GameObject go = _FindGO(type, id);
                if (go)
                {
                    //set unsupported button gray
                    if ((mask_btn & (1 << (int)id)) == 0)
                    {
                        go.GetComponent <Image> ().color = Color.gray;
                    }
                    else
                    {
                        go.GetComponent <Image> ().color = Color.white;
                    }
                }
            }
            //special treatment of digital trigger and trigger
            GameObject go_trigger = _FindGO(type, WVR_InputId.WVR_InputId_Alias1_Trigger);
            if (go_trigger)
            {
                if ((mask_btn & ((1 << (int)WVR_InputId.WVR_InputId_Alias1_Digital_Trigger) | (1 << (int)WVR_InputId.WVR_InputId_Alias1_Trigger))) == 0)
                {
                    go_trigger.GetComponent <Image> ().color = Color.gray;
                }
                else
                {
                    go_trigger.GetComponent <Image> ().color = Color.white;
                }
            }
        }
#endif

        //set active state of the left or right canvas according to the connected state
        if (m_type2Canvas.ContainsKey(type))
        {
            if (m_type2Canvas [type])
            {
                m_type2Canvas [type].SetActive(isDeviceConnected);
            }
        }
    }
Esempio n. 29
0
    private GameObject _FindGO(WVR_DeviceType type, WVR_InputId id)
    {
        GameObject go = null;

        if (m_type2Dict.ContainsKey(type))
        {
            if (m_type2Dict[type].ContainsKey(id))
            {
                go = m_type2Dict [type] [id];
            }
        }

        return(go);
    }
        public bool GetEventState_Touch(WVR_InputId btn)
        {
            bool _touch = false;

            for (int _t = 0; _t < touchIds.Length; _t++)
            {
                if (touchIds [_t] == btn)
                {
                    _touch = event_state_touch [_t];
                    break;
                }
            }
            return(_touch);
        }