public void SetControllerModel(WaveVR_Controller.EDeviceType type, GameObject model) { PrintDebugLog("SetControllerModel() type: " + type + ", Model: " + (model != null ? model.name : "null")); bool found = false; for (int i = 0; i < ControllerModels.Count; i++) { if (ControllerModels [i].DeviceType == type) { if (ControllerModels [i].Model != null) { ControllerModels [i].Model.SetActive(false); } ControllerModels [i].Model = model; ControllerModels [i].Model.SetActive(true); found = true; break; } } if (!found) { ControllerModels.Add(new ControllerModel(type, model)); } }
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); }
public void OnPointerEnter(PointerEventData eventData) { WaveVR_Controller.EDeviceType type = eventData.enterEventCamera.gameObject.GetComponent <WaveVR_PoseTrackerManager>().Type; GameObject target = eventData.enterEventCamera.gameObject; if (target.GetComponent <WaveVR_PoseTrackerManager>()) { if (type == WaveVR_Controller.EDeviceType.NonDominant) { m_LeftController = target; isControllerFocus_L = true; } // Right-Hand mode if (!WaveVR_Controller.IsLeftHanded) { GetComponent <MeshRenderer>().material.SetColor("_Color", Color.blue); } // Left-Hand mode else if (WaveVR_Controller.IsLeftHanded) { GetComponent <MeshRenderer>().material.SetColor("_Color", Color.red); } } NonFocusControllerType = type; }
public void SetControllerBeamLength(WaveVR_Controller.EDeviceType dt, float length) { if (this.controllerInputModule != null) { this.controllerInputModule.ChangeBeamLength(dt, length); } }
void onAdaptiveControllerModelReady(params object[] args) { WaveVR_Controller.EDeviceType device = (WaveVR_Controller.EDeviceType)args[0]; if (device == this.device) { CollectEffectObjects(); } }
void onAdaptiveControllerModelReady(params object[] args) { #if UNITY_EDITOR if (Application.isPlaying) { return; } #endif WaveVR_Controller.EDeviceType _device = (WaveVR_Controller.EDeviceType)args[0]; if (this.deviceType == _device) { WaveVR_RenderModel wrm = this.GetComponentInChildren <WaveVR_RenderModel>(); if (wrm != null) { GameObject modelObj = wrm.gameObject; int modelchild = modelObj.transform.childCount; PrintDebugLog("onAdaptiveControllerModelReady() model child: " + modelchild); for (int j = 0; j < modelchild; j++) { GameObject childName = modelObj.transform.GetChild(j).gameObject; if (childName.name == "__CM__Emitter" || childName.name == "_[CM]_Emitter") { emitter = childName; PrintDebugLog("emitter local position (" + emitter.transform.localPosition.x + ", " + emitter.transform.localPosition.y + ", " + emitter.transform.localPosition.z + ")"); PrintDebugLog("emitter local EulerAngles " + emitter.transform.localEulerAngles); if (moveToEmitter != null) { PrintDebugLog("__CM__Emitter is found, update objects' parent"); foreach (GameObject mgo in moveToEmitter) { if (mgo != null) { PrintDebugLog("Move " + mgo.name + " to be children of emitter"); mgo.transform.parent = emitter.transform; mgo.transform.localRotation = Quaternion.identity; mgo.transform.localPosition = Vector3.zero; mgo.SetActive(false); mgo.SetActive(true); } } } break; } } } else { PrintDebugLog("WaveVR_RenderModel is not found"); } } }
public WaveVR_RaycastResult GetRaycastResult(WaveVR_Controller.EDeviceType device) { for (int i = 0; i < RaycastResults.Count; i++) { if (RaycastResults [i].Type == device) { return(RaycastResults [i].Result); } } return(null); }
public GameObject GetControllerModel(WaveVR_Controller.EDeviceType type) { for (int i = 0; i < ControllerModels.Count; i++) { if (ControllerModels [i].DeviceType == type) { return(ControllerModels [i].Model); } } return(null); }
public bool HasControllerLoader(WaveVR_Controller.EDeviceType type) { for (int i = 0; i < ControllerModels.Count; i++) { if (ControllerModels [i].DeviceType == type) { return(ControllerModels [i].HasLoader); } } return(false); }
public void OnPointerEnter(PointerEventData eventData) { WaveVR_Controller.EDeviceType type = WaveVR_Controller.EDeviceType.NonDominant; //eventData.enterEventCamera.gameObject.GetComponent<WaveVR_PoseTrackerManager>().Type; GameObject target = eventData.enterEventCamera.gameObject; if (target.GetComponent <WaveVR_PoseTrackerManager>()) { //if (type == WaveVR_Controller.EDeviceType.Dominant) //{ // m_RightController = target; // isControllerFocus_R = true; //} //else if (type == WaveVR_Controller.EDeviceType.NonDominant) { m_LeftController = eventData.enterEventCamera.gameObject; isControllerFocus_L = true; } if (WaveVR_Controller.Input(curFocusControllerType).GetPressDown(WVR_InputId.WVR_InputId_Alias1_Trigger)) { dragging = false; Vector3 fwd_L = m_LeftController.transform.TransformDirection(Vector3.forward); Ray ray = new Ray(WaveVR_Controller.Input(curFocusControllerType).transform.pos, fwd_L); //var ray = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (GetComponent <Collider>().Raycast(ray, out hit, Mathf.Infinity)) { dragging = true; } } if (WaveVR_Controller.Input(curFocusControllerType).GetPressUp(WVR_InputId.WVR_InputId_Alias1_Trigger)) { dragging = false; } if (dragging && WaveVR_Controller.Input(curFocusControllerType).GetPress(WVR_InputId.WVR_InputId_Alias1_Trigger)) { Vector3 fwd_L = m_LeftController.transform.TransformDirection(Vector3.forward); Ray ray = new Ray(WaveVR_Controller.Input(curFocusControllerType).transform.pos, fwd_L); //var ray = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (GetComponent <Collider>().Raycast(ray, out hit, Mathf.Infinity)) { var point = hit.point; point = GetComponent <Collider>().ClosestPointOnBounds(point); SetThumbPosition(point); SendMessage("OnDrag", Vector3.one - (thumb.position - GetComponent <Collider>().bounds.min) / GetComponent <Collider>().bounds.size.x); } } } curFocusControllerType = type; }
public void SetRaycastResult(WaveVR_Controller.EDeviceType device, GameObject gameObject, Vector3 worldPosition) { for (int i = 0; i < RaycastResults.Count; i++) { if (RaycastResults [i].Type == device) { RaycastResults [i].Result.gameObject = gameObject; RaycastResults [i].Result.worldPosition = worldPosition; break; } } }
public void MarkControllerLoader(WaveVR_Controller.EDeviceType type, bool value) { PrintDebugLog(type + " " + (value ? "has" : "doesn't have") + " ControllerLoader."); for (int i = 0; i < ControllerModels.Count; i++) { if (ControllerModels [i].DeviceType == type) { ControllerModels [i].HasLoader = value; return; } } }
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); }
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); }
public void SetControllerModel(WaveVR_Controller.EDeviceType type, GameObject model) { PrintDebugLog("SetControllerModel() type: " + type + ", model: " + (model != null ? model.name : "null")); if (((ControllerModel)ControllerModels [type]).model != null) { ((ControllerModel)ControllerModels [type]).model.SetActive(false); } ((ControllerModel)ControllerModels [type]).model = model; if (((ControllerModel)ControllerModels [type]).model != null) { ((ControllerModel)ControllerModels [type]).model.SetActive(true); } }
void OnEnable() { PrintDebugLog("OnEnable"); sessionid = 0; if (WhichHand == ControllerHand.Controller_Right) { deviceType = WaveVR_Controller.EDeviceType.Dominant; } else { deviceType = WaveVR_Controller.EDeviceType.NonDominant; } connected = checkConnection(); if (connected) { WaveVR.Device _device = WaveVR.Instance.getDeviceByType(this.deviceType); if (!checkChild()) { if (isProcessing) { PrintDebugLog("OnEnable - Controller connected, model is loading!"); } else { PrintDebugLog("Controller load when OnEnable!"); onLoadController(_device.type); } } else { if (isRenderModelNameSameAsPrevious()) { PrintDebugLog("OnEnable - Controller connected, model was loaded!"); } else { PrintDebugLog("Controller load when OnEnable, render model is different!"); deleteChild(); onLoadController(_device.type); } } } #if !UNITY_EDITOR WaveVR_Utils.Event.Listen(WaveVR_Utils.Event.DEVICE_CONNECTED, onDeviceConnected); WaveVR_Utils.Event.Listen(WaveVR_Utils.Event.DEVICE_ROLE_CHANGED, onDeviceRoleChanged); WaveVR_Utils.Event.Listen(WaveVR_Utils.Event.OEM_CONFIG_CHANGED, onOEMConfigChanged); #endif }
void OnControllerLoaded(params object[] args) { WaveVR_Controller.EDeviceType _type = (WaveVR_Controller.EDeviceType)args [0]; if (_type == WaveVR_Controller.EDeviceType.Dominant) { this.dominantController = (GameObject)args [1]; Log.d(LOG_TAG, "OnControllerLoaded() dominant: " + this.dominantController.name); } if (_type == WaveVR_Controller.EDeviceType.NonDominant) { this.nonDominantController = (GameObject)args [1]; Log.d(LOG_TAG, "OnControllerLoaded() nondominant: " + this.nonDominantController.name); } }
private void setupButtonAttributes(WaveVR_Controller.EDeviceType device, List <WaveVR_ButtonList.EButtons> buttons, WVR_InputAttribute_t[] inputAttributes, int count) { WVR_DeviceType dev_type = WaveVR_Controller.Input(device).DeviceType; for (int i = 0; i < count; i++) { switch (buttons[i]) { case WaveVR_ButtonList.EButtons.Menu: case WaveVR_ButtonList.EButtons.Grip: case WaveVR_ButtonList.EButtons.DPadLeft: case WaveVR_ButtonList.EButtons.DPadUp: case WaveVR_ButtonList.EButtons.DPadRight: case WaveVR_ButtonList.EButtons.DPadDown: case WaveVR_ButtonList.EButtons.VolumeUp: case WaveVR_ButtonList.EButtons.VolumeDown: case WaveVR_ButtonList.EButtons.Bumper: case WaveVR_ButtonList.EButtons.A_X: case WaveVR_ButtonList.EButtons.B_Y: case WaveVR_ButtonList.EButtons.Back: case WaveVR_ButtonList.EButtons.Enter: inputAttributes[i].id = (WVR_InputId)buttons[i]; inputAttributes[i].capability = (uint)WVR_InputType.WVR_InputType_Button; inputAttributes[i].axis_type = WVR_AnalogType.WVR_AnalogType_None; break; case WaveVR_ButtonList.EButtons.Touchpad: case WaveVR_ButtonList.EButtons.Thumbstick: inputAttributes[i].id = (WVR_InputId)buttons[i]; inputAttributes[i].capability = (uint)(WVR_InputType.WVR_InputType_Button | WVR_InputType.WVR_InputType_Touch | WVR_InputType.WVR_InputType_Analog); inputAttributes[i].axis_type = WVR_AnalogType.WVR_AnalogType_2D; break; case WaveVR_ButtonList.EButtons.Trigger: inputAttributes[i].id = (WVR_InputId)buttons[i]; inputAttributes[i].capability = (uint)(WVR_InputType.WVR_InputType_Button | WVR_InputType.WVR_InputType_Touch | WVR_InputType.WVR_InputType_Analog); inputAttributes[i].axis_type = WVR_AnalogType.WVR_AnalogType_1D; break; default: break; } DEBUG("setupButtonAttributes() " + device + " (" + dev_type + ") " + buttons [i] + ", capability: " + inputAttributes [i].capability + ", analog type: " + inputAttributes [i].axis_type); } }
private void SetEmitter(GameObject gobj) { WaveVR_Beam _beam = gobj.GetComponent <WaveVR_Beam> (); WaveVR_ControllerPointer _pointer = gobj.GetComponent <WaveVR_ControllerPointer> (); if (_beam == null && _pointer == null) { return; } WaveVR_Controller.EDeviceType _focus_dev = WaveVR_Controller.EDeviceType.Head; #if UNITY_EDITOR if (Application.isEditor) { _focus_dev = this.Type; } else #endif { WVR_DeviceType _focus_dt = WaveVR_Utils.WVR_GetFocusedController(); if (_focus_dt == WVR_DeviceType.WVR_DeviceType_Controller_Right) { _focus_dev = WaveVR_Controller.EDeviceType.Dominant; } if (_focus_dt == WVR_DeviceType.WVR_DeviceType_Controller_Left) { _focus_dev = WaveVR_Controller.EDeviceType.NonDominant; } } if (_focus_dev == WaveVR_Controller.EDeviceType.Head) { return; } if (_focus_dev != this.Type) { if (_beam != null) { PrintDebugLog("SetEmitter() focus type: " + _focus_dev + " hide beam."); _beam.ShowBeam = false; } if (_pointer != null) { PrintDebugLog("SetEmitter() focus type: " + _focus_dev + " hide pointer."); _pointer.ShowPointer = false; } } }
public Device getDeviceByType(WaveVR_Controller.EDeviceType type) { if (type == WaveVR_Controller.EDeviceType.Head) { return(hmd); } if (type == WaveVR_Controller.EDeviceType.Dominant) { return(WaveVR_Controller.IsLeftHanded ? controllerLeft : controllerRight); } if (type == WaveVR_Controller.EDeviceType.NonDominant) { return(WaveVR_Controller.IsLeftHanded ? controllerRight : controllerLeft); } return(null); }
void OnEnable() { PrintDebugLog("OnEnable"); if (mLoadingState == LoadingState.LoadingState_LOADING) { deleteChild("RenderModel doesn't expect model is in loading, delete all children"); } if (WhichHand == ControllerHand.Controller_Dominant) { deviceType = WaveVR_Controller.EDeviceType.Dominant; modelSpecify = ModelSpecify.MS_Dominant; } else { deviceType = WaveVR_Controller.EDeviceType.NonDominant; modelSpecify = ModelSpecify.MS_NonDominant; } connected = checkConnection(); if (connected) { WaveVR.Device _device = WaveVR.Instance.getDeviceByType(this.deviceType); if (mLoadingState == LoadingState.LoadingState_LOADED) { if (isRenderModelNameSameAsPrevious()) { PrintDebugLog("OnEnable - Controller connected, model was loaded!"); } else { deleteChild("Controller load when OnEnable, render model is different!"); onLoadController(_device.type); } } else { PrintDebugLog("Controller load when OnEnable!"); onLoadController(_device.type); } } WaveVR_Utils.Event.Listen(WaveVR_Utils.Event.DEVICE_CONNECTED, onDeviceConnected); WaveVR_Utils.Event.Listen(WaveVR_Utils.Event.OEM_CONFIG_CHANGED, onOEMConfigChanged); }
public bool IsButtonAvailable(WaveVR_Controller.EDeviceType device, WVR_InputId button) { if (device == WaveVR_Controller.EDeviceType.Head) { return(this.usableButtons_hmd.Contains(button)); } if (device == WaveVR_Controller.EDeviceType.Dominant) { return(this.usableButtons_dominant.Contains(button)); } if (device == WaveVR_Controller.EDeviceType.NonDominant) { return(this.usableButtons_nonDominant.Contains(button)); } return(false); }
public Device getDeviceByType(WaveVR_Controller.EDeviceType type) { switch (type) { case WaveVR_Controller.EDeviceType.Head: return(hmd); case WaveVR_Controller.EDeviceType.Dominant: return(WaveVR_Controller.IsLeftHanded ? controllerLeft : controllerRight); case WaveVR_Controller.EDeviceType.NonDominant: return(WaveVR_Controller.IsLeftHanded ? controllerRight : controllerLeft); default: Assert.raiseExceptions = true; return(hmd); // Should not happen } }
public void SetupControllerButtonList(WaveVR_Controller.EDeviceType device, List <WaveVR_ButtonList.EControllerButtons> list) { PrintDebugLog("SetupControllerButtonList() " + device); switch (device) { case WaveVR_Controller.EDeviceType.Dominant: this.DominantButtons = list; ResetInputRequest(WaveVR_Controller.EDeviceType.Dominant); break; case WaveVR_Controller.EDeviceType.NonDominant: this.NonDominantButtons = list; ResetInputRequest(WaveVR_Controller.EDeviceType.NonDominant); break; default: break; } }
private void setupButtonAttributes(WaveVR_Controller.EDeviceType device, List <EButtons> buttons, WVR_InputAttribute_t[] inputAttributes, int count) { WVR_DeviceType _type = WaveVR_Controller.Input(device).DeviceType; for (int _i = 0; _i < count; _i++) { switch (buttons [_i]) { case EButtons.Menu: case EButtons.Grip: case EButtons.DPadLeft: case EButtons.DPadUp: case EButtons.DPadRight: case EButtons.DPadDown: case EButtons.VolumeUp: case EButtons.VolumeDown: case EButtons.HMDEnter: inputAttributes [_i].id = (WVR_InputId)buttons [_i]; inputAttributes [_i].capability = (uint)WVR_InputType.WVR_InputType_Button; inputAttributes [_i].axis_type = WVR_AnalogType.WVR_AnalogType_None; break; case EButtons.Touchpad: case EButtons.Thumbstick: inputAttributes [_i].id = (WVR_InputId)buttons [_i]; inputAttributes [_i].capability = (uint)(WVR_InputType.WVR_InputType_Button | WVR_InputType.WVR_InputType_Touch | WVR_InputType.WVR_InputType_Analog); inputAttributes [_i].axis_type = WVR_AnalogType.WVR_AnalogType_2D; break; case EButtons.Trigger: inputAttributes [_i].id = (WVR_InputId)buttons [_i]; inputAttributes [_i].capability = (uint)(WVR_InputType.WVR_InputType_Button | WVR_InputType.WVR_InputType_Touch | WVR_InputType.WVR_InputType_Analog); inputAttributes [_i].axis_type = WVR_AnalogType.WVR_AnalogType_1D; break; default: break; } PrintDebugLog("setupButtonAttributes() " + device + " (" + _type + ") " + buttons [_i] + " analog type: " + inputAttributes [_i].axis_type); } }
public void OnPointerExit(PointerEventData eventData) { RaycastHit hit; if (m_LeftController && isControllerFocus_L) { //L_Controller Leave Vector3 fwd_L = m_LeftController.transform.TransformDirection(Vector3.forward); if (!Physics.Raycast(m_LeftController.transform.position, fwd_L, out hit)) { isControllerFocus_L = false; if (isControllerFocus_R) { NonFocusControllerType = WaveVR_Controller.EDeviceType.Dominant; GetComponent <MeshRenderer>().material.SetColor("_Color", Color.red); return; } } } NonFocusControllerType = WaveVR_Controller.EDeviceType.Head; GetComponent <MeshRenderer>().material.SetColor("_Color", Color.green); }
public static string GetControllerName(WaveVR_Controller.EDeviceType type) { string retString = ""; if (type == WaveVR_Controller.EDeviceType.Head) { Log.w(LOG_TAG, "EDeviceType is Head"); return(retString); } WVR_DeviceType deviceType = WaveVR_Controller.Input(type).DeviceType; if (WaveVR_Controller.Input(type).connected) { int bufferSize = 128; uint resultVertLength = 128; string parameterName = "GetRenderModelName"; IntPtr ptrParameterName = Marshal.StringToHGlobalAnsi(parameterName); IntPtr ptrResult = Marshal.AllocHGlobal(bufferSize); uint ret = Interop.WVR_GetParameters(deviceType, ptrParameterName, ptrResult, resultVertLength); if (ret > 0) { retString = Marshal.PtrToStringAnsi(ptrResult); } else { Log.w(LOG_TAG, "WVR_GetParameters returns empty"); } } else { Log.w(LOG_TAG, type + " controller is disconnect"); } Log.i(LOG_TAG, "GetControllerName returns " + retString); return(retString); }
private void BroadcastToObjects(CIndex index) { var obj = ControllerObjects [(uint)index]; if (obj != null) { if (ControllerConnected [(uint)index] == false) { PrintDebugLog("BroadcastToObjects() disable controller " + index); obj.SetActive(false); } else { PrintDebugLog("BroadcastToObjects() enable controller " + index); // means object with index is not null and connected. obj.SetActive(true); WaveVR_Controller.EDeviceType _device = index == CIndex.Dominant ? WaveVR_Controller.EDeviceType.Dominant : WaveVR_Controller.EDeviceType.NonDominant; obj.BroadcastMessage("SetDeviceIndex", _device, SendMessageOptions.DontRequireReceiver); } } }
private void ResetInputRequest(WaveVR_Controller.EDeviceType device) { DEBUG("ResetInputRequest() " + device); switch (device) { case WaveVR_Controller.EDeviceType.Head: createHmdRequestAttributes(); SetHmdInputRequest(); break; case WaveVR_Controller.EDeviceType.Dominant: createDominantRequestAttributes(); SetDominantInputRequest(); break; case WaveVR_Controller.EDeviceType.NonDominant: createNonDominantRequestAttributes(); SetNonDominantInputRequest(); break; default: break; } }
public void SetDeviceIndex(WaveVR_Controller.EDeviceType device) { Log.i(LOG_TAG, "SetDeviceIndex, _index = " + device); this.eDevice = device; }