Пример #1
0
        private static void Update_R_Vive(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            var primaryButtonPress = GetUnityButton(1);
            var menuPress          = GetUnityButton(0);
            var padPress           = GetUnityButton(9);
            var triggerTouch       = GetUnityButton(15);
            var padTouch           = GetUnityButton(17);

            var padX    = GetUnityAxis(4);
            var padY    = GetUnityAxis(5);
            var trigger = GetUnityAxis(10);
            var grip    = GetUnityAxis(12);

            currState.SetButtonPress(VRModuleRawButton.A, primaryButtonPress);
            currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, menuPress);
            currState.SetButtonPress(VRModuleRawButton.Touchpad, padPress);
            currState.SetButtonPress(VRModuleRawButton.Trigger, AxisToPress(prevState.GetButtonPress(VRModuleRawButton.Trigger), trigger, 0.55f, 0.45f));
            currState.SetButtonPress(VRModuleRawButton.Grip, grip >= 1.0f);

            currState.SetButtonTouch(VRModuleRawButton.Touchpad, padTouch);
            currState.SetButtonTouch(VRModuleRawButton.Trigger, triggerTouch);

            currState.SetAxisValue(VRModuleRawAxis.TouchpadX, padX);
            currState.SetAxisValue(VRModuleRawAxis.TouchpadY, -padY);
            currState.SetAxisValue(VRModuleRawAxis.Trigger, trigger);
        }
Пример #2
0
        private static void Update_R_OculusTouch(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            var aPress       = GetUnityButton(0);
            var bPress       = GetUnityButton(1);
            var stickPress   = GetUnityButton(9);
            var gripPress    = GetUnityButton(5);
            var aTouch       = GetUnityButton(10);
            var bTouch       = GetUnityButton(11);
            var triggerTouch = GetUnityButton(15);
            var stickTouch   = GetUnityButton(17);

            var stickX  = GetUnityAxis(4);
            var stickY  = GetUnityAxis(5);
            var trigger = GetUnityAxis(10);
            var grip    = GetUnityAxis(12);

            currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, bPress);
            currState.SetButtonPress(VRModuleRawButton.A, aPress);
            currState.SetButtonPress(VRModuleRawButton.Touchpad, stickPress);
            currState.SetButtonPress(VRModuleRawButton.Trigger, AxisToPress(prevState.GetButtonPress(VRModuleRawButton.Trigger), trigger, 0.55f, 0.45f));
            currState.SetButtonPress(VRModuleRawButton.Grip, gripPress);
            currState.SetButtonPress(VRModuleRawButton.CapSenseGrip, gripPress);

            currState.SetButtonTouch(VRModuleRawButton.ApplicationMenu, bTouch);
            currState.SetButtonTouch(VRModuleRawButton.A, aTouch);
            currState.SetButtonTouch(VRModuleRawButton.Touchpad, stickTouch);
            currState.SetButtonTouch(VRModuleRawButton.Trigger, triggerTouch);
            currState.SetButtonTouch(VRModuleRawButton.Grip, grip >= 0.05f);
            currState.SetButtonTouch(VRModuleRawButton.CapSenseGrip, grip >= 0.05f);

            currState.SetAxisValue(VRModuleRawAxis.TouchpadX, stickX);
            currState.SetAxisValue(VRModuleRawAxis.TouchpadY, -stickY);
            currState.SetAxisValue(VRModuleRawAxis.Trigger, trigger);
            currState.SetAxisValue(VRModuleRawAxis.CapSenseGrip, grip);
        }
        // this function will skip VRModule.HMD_DEVICE_INDEX (preserved index for HMD)
        private uint FindAndEnsureUnusedNotHMDDeviceState(out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState)
        {
            var len = GetDeviceStateLength();

            for (uint i = 0u, imax = len; i < imax; ++i)
            {
                if (i == VRModule.HMD_DEVICE_INDEX)
                {
                    continue;
                }
                if (TryGetValidDeviceState(i, out prevState, out currState))
                {
                    if (prevState.isConnected)
                    {
                        continue;
                    }
                    if (currState.isConnected)
                    {
                        continue;
                    }
                }

                EnsureValidDeviceState(i, out prevState, out currState);
                return(i);
            }

            EnsureValidDeviceState(len, out prevState, out currState);
            return(len);
        }
Пример #4
0
        private static void Update_R_Knuckles(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            var innerPress   = GetUnityButton(0);
            var outerPress   = GetUnityButton(1);
            var padPress     = GetUnityButton(9);
            var triggerTouch = GetUnityButton(15);
            var padTouch     = GetUnityButton(17);

            var padX    = GetUnityAxis(4);
            var padY    = GetUnityAxis(5);
            var trigger = GetUnityAxis(10);
            var grip    = GetUnityAxis(12);
            var index   = GetUnityAxis(21);
            var middle  = GetUnityAxis(23);
            var ring    = GetUnityAxis(25);
            var pinky   = GetUnityAxis(27);

            currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, outerPress);
            currState.SetButtonPress(VRModuleRawButton.A, innerPress);
            currState.SetButtonPress(VRModuleRawButton.Touchpad, padPress);
            currState.SetButtonPress(VRModuleRawButton.Trigger, AxisToPress(prevState.GetButtonPress(VRModuleRawButton.Trigger), trigger, 0.55f, 0.45f));
            currState.SetButtonPress(VRModuleRawButton.Grip, grip >= 1.0f);

            currState.SetButtonTouch(VRModuleRawButton.Touchpad, padTouch);
            currState.SetButtonTouch(VRModuleRawButton.Trigger, triggerTouch);

            currState.SetAxisValue(VRModuleRawAxis.TouchpadX, padX);
            currState.SetAxisValue(VRModuleRawAxis.TouchpadY, -padY);
            currState.SetAxisValue(VRModuleRawAxis.Trigger, trigger);
            currState.SetAxisValue(VRModuleRawAxis.CapSenseGrip, grip);
            currState.SetAxisValue(VRModuleRawAxis.IndexCurl, index);
            currState.SetAxisValue(VRModuleRawAxis.MiddleCurl, middle);
            currState.SetAxisValue(VRModuleRawAxis.RingCurl, ring);
            currState.SetAxisValue(VRModuleRawAxis.PinkyCurl, pinky);
        }
        private static void Update_L_OculusTouch(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            var xPress       = GetUnityButton(2);
            var yPress       = GetUnityButton(3);
            var stickPress   = GetUnityButton(8);
            var gripPress    = GetUnityButton(4);
            var xTouch       = GetUnityButton(12);
            var yTouch       = GetUnityButton(13);
            var triggerTouch = GetUnityButton(14);
            var stickTouch   = GetUnityButton(16);

            var stickX  = GetUnityAxis(1);
            var stickY  = GetUnityAxis(2);
            var trigger = GetUnityAxis(9);
            var grip    = GetUnityAxis(11);

            currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, yPress);
            currState.SetButtonPress(VRModuleRawButton.A, xPress);
            currState.SetButtonPress(VRModuleRawButton.Touchpad, stickPress);
            currState.SetButtonPress(VRModuleRawButton.Trigger, AxisToPress(prevState.GetButtonPress(VRModuleRawButton.Trigger), trigger, 0.55f, 0.45f));
            currState.SetButtonPress(VRModuleRawButton.Grip, gripPress);
            currState.SetButtonPress(VRModuleRawButton.CapSenseGrip, gripPress);

            currState.SetButtonTouch(VRModuleRawButton.ApplicationMenu, yTouch);
            currState.SetButtonTouch(VRModuleRawButton.A, xTouch);
            currState.SetButtonTouch(VRModuleRawButton.Touchpad, stickTouch);
            currState.SetButtonTouch(VRModuleRawButton.Trigger, triggerTouch);
            currState.SetButtonTouch(VRModuleRawButton.Grip, grip >= 0.05f);
            currState.SetButtonTouch(VRModuleRawButton.CapSenseGrip, grip >= 0.05f);

            currState.SetAxisValue(VRModuleRawAxis.TouchpadX, stickX);
            currState.SetAxisValue(VRModuleRawAxis.TouchpadY, -stickY);
            currState.SetAxisValue(VRModuleRawAxis.Trigger, trigger);
            currState.SetAxisValue(VRModuleRawAxis.CapSenseGrip, grip);
        }
        private static void UpdateRightControllerInput(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            //Debug.LogError("输入:" + currState.deviceModel);
            switch (currState.deviceModel)
            {
            case VRModuleDeviceModel.ViveCosmosControllerRight:
            case VRModuleDeviceModel.ViveController:
                Update_R_Vive(prevState, currState);
                break;

            case VRModuleDeviceModel.OculusQuestControllerRight:
            case VRModuleDeviceModel.OculusGoController:
            case VRModuleDeviceModel.OculusTouchRight:
                Update_R_OculusTouch(prevState, currState);
                break;

            case VRModuleDeviceModel.KnucklesRight:
                Update_R_Knuckles(prevState, currState);
                break;

            case VRModuleDeviceModel.WMRControllerRight:
                Update_R_MicrosoftMR(prevState, currState);
                break;

            case VRModuleDeviceModel.zSpaceStylusController:
                zSpaceDeviceInput(currState);
                break;

            case VRModuleDeviceModel.PCStylusController:
                HandleDeviceInput(currState);
                break;
            }
        }
Пример #7
0
        private static void Update_R_MicrosoftMR(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            var menuPress    = GetUnityButton(0);
            var padPress     = GetUnityButton(9);
            var triggerPress = GetUnityButton(15);
            var padTouch     = GetUnityButton(17);

            var stickX  = GetUnityAxis(4);
            var stickY  = GetUnityAxis(5);
            var trigger = GetUnityAxis(10);
            var grip    = GetUnityAxis(12);
            var padX    = GetUnityAxis(19);
            var padY    = GetUnityAxis(20);

            currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, menuPress);
            currState.SetButtonPress(VRModuleRawButton.Touchpad, padPress);
            currState.SetButtonPress(VRModuleRawButton.Trigger, triggerPress);
            currState.SetButtonPress(VRModuleRawButton.Grip, grip >= 1f);

            currState.SetButtonTouch(VRModuleRawButton.Touchpad, padTouch);
            currState.SetButtonTouch(VRModuleRawButton.Trigger, AxisToPress(prevState.GetButtonPress(VRModuleRawButton.Trigger), trigger, 0.25f, 0.20f));

            currState.SetAxisValue(VRModuleRawAxis.TouchpadX, padX);
            currState.SetAxisValue(VRModuleRawAxis.TouchpadY, -padY);
            currState.SetAxisValue(VRModuleRawAxis.Trigger, trigger);
            currState.SetAxisValue(VRModuleRawAxis.JoystickX, stickX);
            currState.SetAxisValue(VRModuleRawAxis.JoystickY, -stickY);
        }
Пример #8
0
        private static void UpdateRightControllerInput(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            switch (currState.deviceModel)
            {
            case VRModuleDeviceModel.ViveCosmosControllerRight:
            case VRModuleDeviceModel.ViveController:
                Update_R_Vive(prevState, currState);
                break;

            case VRModuleDeviceModel.OculusQuestControllerRight:
            case VRModuleDeviceModel.OculusGoController:
            case VRModuleDeviceModel.OculusTouchRight:
                Update_R_OculusTouch(prevState, currState);
                break;

            case VRModuleDeviceModel.KnucklesRight:
            case VRModuleDeviceModel.IndexControllerRight:
                Update_R_Knuckles(prevState, currState);
                break;

            case VRModuleDeviceModel.WMRControllerRight:
                Update_R_MicrosoftMR(prevState, currState);
                break;
            }
        }
Пример #9
0
 private void EnsureValidDeviceState(uint index, out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState)
 {
     if (!TryGetValidDeviceState(index, out prevState, out currState))
     {
         prevState = m_prevStates[index] = new DeviceState(index);
         currState = m_currStates[index] = new DeviceState(index);
     }
 }
Пример #10
0
            private bool TryGetCurrentOriginDataAndDeviceState(CVRInput vrInput, out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState, out ulong originDevicePath)
            {
                OriginData    originData;
                EVRInputError error;

                if (!s_moduleInstance.TryGetDeviceIndexFromOrigin(vrInput, CurrentOrigin, out originData, out error))
                {
                    Debug.LogError("GetOriginTrackedDeviceInfo failed! error=" + error + " action=" + pressActions.CurrentPath);
                    prevState        = null;
                    currState        = null;
                    originDevicePath = 0ul;
                    return(false);
                }

                originDevicePath = originData.devicePath;
                return(s_moduleInstance.TryGetValidDeviceState(originData.deviceIndex, out prevState, out currState) && currState.isConnected);
            }
 private bool TryGetValidDeviceState(uint index, out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState)
 {
     DeviceState prevRawState;
     DeviceState currRawState;
     if (TryGetValidDeviceState(index, out prevRawState, out currRawState))
     {
         prevState = prevRawState;
         currState = currRawState;
         return true;
     }
     else
     {
         prevState = null;
         currState = null;
         return false;
     }
 }
Пример #12
0
            public bool TryGetCurrentAnalogData(CVRInput vrInput, out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState, ref InputAnalogActionData_t data)
            {
                ulong originDevicePath;

                if (!TryGetCurrentOriginDataAndDeviceState(vrInput, out prevState, out currState, out originDevicePath))
                {
                    return(false);
                }

                var error = vrInput.GetAnalogActionData(CurrentHandle, ref data, s_moduleInstance.m_analogDataSize, originDevicePath);

                if (error != EVRInputError.None)
                {
                    Debug.LogError("GetAnalogActionData failed! action=" + CurrentPath + " error=" + error);
                    return(false);
                }

                return(true);
            }
Пример #13
0
        private static void UpdateLeftControllerInput(IVRModuleDeviceState prevState, IVRModuleDeviceStateRW currState)
        {
            switch (currState.deviceModel)
            {
            case VRModuleDeviceModel.ViveController:
                Update_L_Vive(prevState, currState);
                break;

            case VRModuleDeviceModel.OculusTouchLeft:
                Update_L_OculusTouch(prevState, currState);
                break;

            case VRModuleDeviceModel.KnucklesLeft:
                Update_L_Knuckles(prevState, currState);
                break;

            case VRModuleDeviceModel.WMRControllerLeft:
                Update_L_MicrosoftMR(prevState, currState);
                break;
            }
        }
Пример #14
0
 protected void EnsureValidDeviceState(uint index, out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState)
 {
     Instance.EnsureValidDeviceState(index, out prevState, out currState);
 }
 // this function will skip VRModule.HMD_DEVICE_INDEX (preserved index for HMD)
 protected uint FindAndEnsureUnusedNotHMDDeviceState(out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState)
 {
     return(Instance.FindAndEnsureUnusedNotHMDDeviceState(out prevState, out currState));
 }
Пример #16
0
 protected bool TryGetValidDeviceState(uint index, out IVRModuleDeviceState prevState, out IVRModuleDeviceStateRW currState)
 {
     return(Instance.TryGetValidDeviceState(index, out prevState, out currState));
 }
        public static void SetupTrackingDeviceIcon(Image image, IVRModuleDeviceState deviceState, bool bound)
        {
            VRModuleDeviceModel deviceModel;
            string spriteName;
            var    scale = Vector3.one;

            switch (deviceState.deviceModel)
            {
            case VRModuleDeviceModel.KnucklesLeft:
                spriteName = MODEL_PROJECT_SPRITE_PREFIX + VRModuleDeviceModel.KnucklesRight;
                scale.x    = -1f;
                break;

            case VRModuleDeviceModel.OculusTouchLeft:
                spriteName = MODEL_PROJECT_SPRITE_PREFIX + VRModuleDeviceModel.OculusTouchRight;
                scale.x    = -1f;
                break;

            default:
                switch (deviceState.deviceClass)
                {
                case VRModuleDeviceClass.HMD:
                    spriteName = "binding_ui_project_HMD";
                    break;

                case VRModuleDeviceClass.Controller:
                    spriteName = MODEL_PROJECT_SPRITE_PREFIX + VRModuleDeviceModel.ViveController;
                    break;

                case VRModuleDeviceClass.GenericTracker:
                    spriteName = MODEL_PROJECT_SPRITE_PREFIX + VRModuleDeviceModel.ViveTracker;
                    break;

                default:
                    spriteName = MODEL_PROJECT_SPRITE_PREFIX + deviceState.deviceModel.ToString();
                    break;
                }
                break;
            }

            var sprite = GetSprite(spriteName);

            //Debug.Log("SetupTrackingDeviceIcon " + deviceModel + " " + bound + " " + spriteName + " null?" + (sprite == null));
            if (sprite == null)
            {
                image.enabled = false;
            }
            else
            {
                image.enabled = true;
                image.sprite  = sprite;

                var spriteRect  = sprite.rect;
                var spritePivot = sprite.pivot;
                image.SetNativeSize();
                image.rectTransform.sizeDelta *= 0.2326f;
                image.rectTransform.pivot      = new Vector2(spritePivot.x / spriteRect.width, spritePivot.y / spriteRect.height);

                image.transform.localScale = scale;

                if (bound)
                {
                    image.color = new Color32(0x21, 0xE3, 0xD8, 0xFF);
                }
                else
                {
                    image.color = new Color32(0x9F, 0xEC, 0x28, 0xFF);
                }
            }
        }