InputInfo FindInfoForDevice(SteamVR_Controller.Device dev)
{
for (int i = 0; i < _devices.Length; i++)
{
if (_devices[i].device == dev)
return _devices[i];
}
return null;
}
void FeedBack(SteamVR_Controller.Device device, int power, float duration)
{
this.UpdateAsObservable()
.TakeUntil(Observable.Timer(TimeSpan.FromMilliseconds(duration)))
.Subscribe(v =>
{
device.TriggerHapticPulse((ushort)power);
}
);
}
void DropItem(SteamVR_Controller.Device device)
{
if (itemInHand != null)
{
itemInHand.Dispatch(ObtainableItemEventType.OnDropOff, this);
itemInHand.owner = null;
itemInHand.GetComponent<Rigidbody>().velocity = device.velocity * 1.4f;
itemInHand = null;
}
}
void Update()
{
if (controller == null || trackedController == null)
{
return;
}
device = SteamVR_Controller.Input((int)controller.index);
// Touch down, possible chance for a swipe
if ((int)controller.index != -1 && device.GetTouchDown(Valve.VR.EVRButtonId.k_EButton_Axis0))
{
trackingSwipe = true;
// Record start time and position
mStartPosition = new Vector2(device.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0).x,
device.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0).y);
mSwipeStartTime = Time.time;
}
// Touch up , possible chance for a swipe
else if (device.GetTouchUp(Valve.VR.EVRButtonId.k_EButton_Axis0))
{
trackingSwipe = false;
trackingSwipe = true;
checkSwipe = true;
}
else if (trackingSwipe)
{
endPosition = new Vector2(device.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0).x,
device.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0).y);
}
if (checkSwipe)
{
checkSwipe = false;
float deltaTime = Time.time - mSwipeStartTime;
Vector2 swipeVector = endPosition - mStartPosition;
float velocity = swipeVector.magnitude / deltaTime;
if (velocity > mMinVelocity &&
swipeVector.magnitude > mMinSwipeDist)
{
// if the swipe has enough velocity and enough distance
swipeVector.Normalize();
float angleOfSwipe = Vector2.Dot(swipeVector, mXAxis);
angleOfSwipe = Mathf.Acos(angleOfSwipe) * Mathf.Rad2Deg;
// Detect left and right swipe
if (angleOfSwipe < mAngleRange)
{
MenuEvents.ForEach(x =>
{
if (x.Active)
{
x.SwipeRight.Invoke();
}
});
}
else if ((180.0f - angleOfSwipe) < mAngleRange)
{
MenuEvents.ForEach(x =>
{
if (x.Active)
{
x.SwipeLeft.Invoke();
}
});
}
else
{
// Detect top and bottom swipe
angleOfSwipe = Vector2.Dot(swipeVector, mYAxis);
angleOfSwipe = Mathf.Acos(angleOfSwipe) * Mathf.Rad2Deg;
if (angleOfSwipe < mAngleRange)
{
MenuEvents.ForEach(x =>
{
if (x.Active)
{
x.SwipeUp.Invoke();
}
});
}
else if ((180.0f - angleOfSwipe) < mAngleRange)
{
MenuEvents.ForEach(x =>
{
if (x.Active)
{
x.SwipeDown.Invoke();
}
});
}
}
}
}
checkPadClicked();
}
void Update()
{
// Device hot plugging support
if (GetActiveChildCount(controllerManager.transform) != lastControllerAmount)
{
UpdateDeviceList();
}
lastControllerAmount = controllerManager.transform.childCount;
// If no devices are connected or dashboard is open, wait for new devices
if (devices.Count <= 0)
{
Debug.LogWarning("No devices!");
return;
}
// Wait until user presses trigger to start
if (!started)
{
for (int i = 0; i < devices.Count; ++i)
{
SteamVR_TrackedObject device = devices[i].GetComponent <SteamVR_TrackedObject>();
if (device != null && device.index != SteamVR_TrackedObject.EIndex.Hmd)
{
if (SteamVR_Controller.Input((int)device.index).GetAxis(EVRButtonId.k_EButton_SteamVR_Trigger).x > 0.8f)
{
GetChannels(devices[i].position);
started = true;
}
}
}
// Only run main code once we have started
return;
}
// Find closest channels
currentChannel = -1;
float closestDistance = 99999f;
for (int i = 0; i < channels.Count; ++i)
{
float dist = Vector3.Distance(channels[i].poses[0].pos, devices[channelController].position);
if (dist < closestDistance)
{
closestDistance = dist;
channelStrenght = dist;
currentChannel = i;
}
}
// Switch and blend closest channels
if (currentChannel != -1)
{
if (lastChannel != currentChannel)
{
compitingChannel = lastChannel;
// Research this
ChannelManager.e.SwitchChannels(ChannelManager.allChannels[currentChannel], ChannelManager.allChannels[compitingChannel]);
}
lastChannel = currentChannel;
float blend = channelBlendCurve.Evaluate(channelStrenght);
ChannelManager.e.SetChannelBlendValue(blend);
Debug.DrawLine(channels[currentChannel].poses[0].pos, devices[channelController].position, Color.green);
Debug.DrawLine(channels[compitingChannel].poses[0].pos, devices[channelController].position, Color.yellow);
}
// Update channel noise
//pairs controllers with poses
if (currentChannel >= 0)
{
float[] deviceNoises = new float[devices.Count];
float[] deviceRotationNoises = new float[devices.Count];
globalMinDist = 999f;
bestPairing = new List <int>();
recCompMin(new List <int>());
//bestPairing.ForEach(dBug);
for (int i = 1; i < devices.Count; ++i)
{
//reservedPoses.Add(i);
//Debug.Log(i.ToString());
//Debug.Log(bestPairing.Count.ToString());
//Debug.Log(globalMinDist.ToString());
Debug.DrawLine(channels[currentChannel].poses[i].pos, devices[bestPairing[i - 1]].position, Color.cyan);
deviceNoises[i] = Vector3.Distance(channels[currentChannel].poses[bestPairing[i - 1]].pos, devices[i].position);
deviceRotationNoises[i] = Quaternion.Angle(channels[currentChannel].poses[bestPairing[i - 1]].rot, devices[i].rotation) / 180.0f;
}
// sets shader parameters and haptics
for (int i = 1; i < 6; ++i)
{
tvParams.SetParameter(i - 1, 0.0f);
}
for (int i = 1; i < deviceNoises.Length; ++i)
{
float value = noiseCurve.Evaluate(deviceNoises[i]);
value += rotationNoiseCurve.Evaluate(deviceRotationNoises[i]);
Debug.Log(value);
tvParams.SetParameter(i - 1, value);
hapticsVal += Time.deltaTime * 10.0f;
//if (hapticsVal > 1.0f)
{
hapticsVal -= 1.0f;
ushort hapticsAmount = (ushort)(1800.0f * hapticsCurve.Evaluate(noiseCurve.Evaluate(deviceNoises[i])));
SteamVR_TrackedObject device = devices[i].GetComponent <SteamVR_TrackedObject>();
if (device != null && device.index != SteamVR_TrackedObject.EIndex.Hmd)
{
SteamVR_Controller.Input((int)device.index).TriggerHapticPulse(hapticsAmount, EVRButtonId.k_EButton_SteamVR_Touchpad);
}
}
}
// Manage audio and UI
if (AudioManager.instance != null)
{
float avarage = 0.0f;
float avarageRot = 0.0f;
for (int i = 1; i < deviceNoises.Length; ++i)
{
avarage += deviceNoises[i];
avarageRot += deviceRotationNoises[i];
}
avarage = avarage / (deviceNoises.Length - 1);
avarageRot = avarageRot / (deviceNoises.Length - 1);
avarage = Mathf.Clamp01(avarage);
avarageRot = Mathf.Clamp01(avarageRot);
float connectionAmount = noiseCurve.Evaluate(avarage) + rotationNoiseCurve.Evaluate(avarageRot);
connectionBar[0].SetActive(connectionAmount < 0.9f);
connectionBar[1].SetActive(connectionAmount < 0.8f);
connectionBar[2].SetActive(connectionAmount < 0.7f);
connectionBar[3].SetActive(connectionAmount < 0.6f);
connectionBar[4].SetActive(connectionAmount < 0.5f);
connectionBar[5].SetActive(connectionAmount < 0.4f);
connectionBar[6].SetActive(connectionAmount < 0.3f);
connectionBar[7].SetActive(connectionAmount < 0.2f);
connectionBar[8].SetActive(connectionAmount < 0.1f);
connectionBar[9].SetActive(connectionAmount < 0.05f);
AudioManager.instance.distortion = connectionAmount;
}
// Draw debug for channel points
for (int i = 0; i < channels.Count; ++i)
{
if (i == this.currentChannel)
{
for (int j = 0; j < devices.Count; ++j)
{
Debug.DrawLine(channels[i].poses[j].pos, RotatePointAroundPivot(channels[i].poses[j].pos + Vector3.up * 0.1f, channels[i].poses[j].pos, channels[i].poses[j].rot.eulerAngles), channels[i].debugColor);
}
}
}
}
}
private void GetHandleInput()
{
controllerIndex = (uint)trackedObj.index;
device = SteamVR_Controller.Input((int)trackedObj.index);
Vector2 currentTriggerAxis = device.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger);
Vector2 currentTouchpadAxis = device.GetAxis();
if (hapticPulseCountdown > 0)
{
device.TriggerHapticPulse(hapticPulseStrength);
hapticPulseCountdown -= 1;
}
if (Vector2ShallowEquals(triggerAxis, currentTriggerAxis))
{
triggerAxisChanged = false;
}
else
{
OnTriggerAxisChanged(SetControllerEventArgs(ref triggerPressed, true, currentTriggerAxis.x));
triggerAxisChanged = true;
}
if (Vector2ShallowEquals(touchpadAxis, currentTouchpadAxis))
{
touchpadAxisChanged = false;
}
else
{
OnTouchpadAxisChanged(SetControllerEventArgs(ref touchpadTouched, true, 1f));
touchpadAxisChanged = true;
}
touchpadAxis = new Vector2(currentTouchpadAxis.x, currentTouchpadAxis.y);
triggerAxis = new Vector2(currentTriggerAxis.x, currentTriggerAxis.y);
if (device.GetPressDown(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
OnTriggerPressedDown(SetControllerEventArgs(ref triggerPressed, true, currentTouchpadAxis.x));
triggerDown = true;
}
else
{
triggerDown = false;
}
if (device.GetPressUp(SteamVR_Controller.ButtonMask.Trigger))
{
OnTriggerPressedUp(SetControllerEventArgs(ref triggerPressed, false, 0f));
triggerUp = true;
}
else
{
triggerUp = false;
}
if (device.GetPressDown(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
OnMenuPressedDown(SetControllerEventArgs(ref applicationMenuPressed, true, 1f));
}
if (device.GetPressUp(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
OnMenuPressedUp(SetControllerEventArgs(ref applicationMenuPressed, false, 0f));
}
//Grip
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Grip))
{
OnGripPressedDown(SetControllerEventArgs(ref gripPressed, true, 1f));
}
else if (device.GetPressUp(SteamVR_Controller.ButtonMask.Grip))
{
OnGripPressedUp(SetControllerEventArgs(ref gripPressed, false, 0f));
}
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
OnTouchpadPressedDown(SetControllerEventArgs(ref touchpadPressed, true, 1f));
}
else if (device.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad))
{
OnTouchpadPressedUp(SetControllerEventArgs(ref touchpadPressed, false, 0f));
}
}
IEnumerator Start()
{
// We are a "no SteamVR fallback hand" if we have this camera set
// we'll use the right mouse to look around and left mouse to interact
// - don't need to find the device
if (noSteamVRFallbackCamera)
{
yield break;
}
//Debug.Log( "VRHand - initializing connection routine" );
// Acquire the correct device index for the hand we want to be
// Also for the other hand if we get there first
while (true)
{
// Don't need to run this every frame
yield return(new WaitForSeconds(1.0f));
// We have a controller now, break out of the loop!
if (controller != null)
{
break;
}
//Debug.Log( "VRHand - checking controllers..." );
// Initialize both hands simultaneously
if (startingHandType == HandType.Left || startingHandType == HandType.Right)
{
// Left/right relationship.
// Wait until we have a clear unique left-right relationship to initialize.
int leftIndex = SteamVR_Controller.GetDeviceIndex(SteamVR_Controller.DeviceRelation.Leftmost);
int rightIndex = SteamVR_Controller.GetDeviceIndex(SteamVR_Controller.DeviceRelation.Rightmost);
if (leftIndex == -1 || rightIndex == -1 || leftIndex == rightIndex)
{
//Debug.Log( string.Format( "...Left/right hand relationship not yet established: leftIndex={0}, rightIndex={1}", leftIndex, rightIndex ) );
continue;
}
int myIndex = (startingHandType == HandType.Right) ? rightIndex : leftIndex;
int otherIndex = (startingHandType == HandType.Right) ? leftIndex : rightIndex;
InitController(myIndex);
if (otherHand)
{
otherHand.InitController(otherIndex);
}
}
else
{
// No left/right relationship. Just wait for a connection
var vr = SteamVR.instance;
for (int i = 0; i < Valve.VR.OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (vr.hmd.GetTrackedDeviceClass((uint)i) != Valve.VR.ETrackedDeviceClass.Controller)
{
//Debug.Log( string.Format( "VRHand - device {0} is not a controller", i ) );
continue;
}
var device = SteamVR_Controller.Input(i);
if (!device.valid)
{
//Debug.Log( string.Format( "VRHand - device {0} is not valid", i ) );
continue;
}
if ((otherHand != null) && (otherHand.controller != null))
{
// Other hand is using this index, so we cannot use it.
if (i == (int)otherHand.controller.index)
{
//Debug.Log( string.Format( "VRHand - device {0} is owned by the other hand", i ) );
continue;
}
}
InitController(i);
}
}
}
}
void Update()
{
//if we don't have one of these, something is wrong, and we shouldn't do anything
if (hmd == null || Left == null || Right == null)
{
return;
}
//If we have the left controller
if (Left.isValid)
{
deviceLeft = SteamVR_Controller.Input((int)Left.index);
VRInputDevice tempDevice = VRInput.GetDevice("ViveLeft");
tempDevice.isTracked = true;
tempDevice.SetInt("Index", (int)Left.index);
tempDevice.transform = Left.transform;
tempDevice.position = Left.transform.position;
tempDevice.forward = Left.transform.forward;
tempDevice.up = Left.transform.up;
tempDevice.right = Left.transform.right;
tempDevice.velocity = deviceLeft.velocity;
tempDevice.rotation = Left.transform.rotation;
tempDevice.angularVelocity = deviceLeft.angularVelocity;
tempDevice.SetButton("Trigger", GetButtonInt(deviceLeft, EVRButtonId.k_EButton_SteamVR_Trigger));
tempDevice.SetButton("Menu", GetButtonInt(deviceLeft, EVRButtonId.k_EButton_ApplicationMenu));
tempDevice.SetButton("Touchpad", GetButtonInt(deviceLeft, EVRButtonId.k_EButton_SteamVR_Touchpad));
tempDevice.SetButton("Grip", GetButtonInt(deviceLeft, EVRButtonId.k_EButton_Grip));
tempDevice.SetTouchButton("Touchpad", GetTouchButtonInt(deviceLeft, EVRButtonId.k_EButton_SteamVR_Touchpad));
Vector2 touchpadVector = deviceLeft.GetAxis(EVRButtonId.k_EButton_SteamVR_Touchpad);
tempDevice.SetAxis("TouchpadX", touchpadVector.x);
tempDevice.SetAxis("TouchpadY", touchpadVector.y);
tempDevice.SetAxis("TouchpadR", Mathf.Sqrt(touchpadVector.x * touchpadVector.x + touchpadVector.y * touchpadVector.y));
tempDevice.SetAxis("TouchpadT", Mathf.Atan2(touchpadVector.y, touchpadVector.x) * Mathf.Rad2Deg);
tempDevice.SetAxis("Trigger", deviceLeft.GetAxis(EVRButtonId.k_EButton_SteamVR_Trigger).x);
tempDevice.Vibrate();
/*
* ViveInput.Left.IsTracked = true;
* ViveInput.Left.Index = (int)Left.index;
* ViveInput.Left.Transform = Left.transform;
*
* ViveInput.Left.Position = Left.transform.position;//deviceLeft.transform.pos;
* ViveInput.Left.Forward = Left.transform.forward;
* ViveInput.Left.Up = Left.transform.up;
* ViveInput.Left.Right = Left.transform.right;
* ViveInput.Left.Velocity = deviceLeft.velocity;
* ViveInput.Left.Rotation = Left.transform.rotation;//deviceLeft.transform.rot;
* ViveInput.Left.AngularVelocity = deviceLeft.angularVelocity;
*
*
* ViveInput.Left.Buttons.Trigger = getButtonState(deviceLeft, EVRButtonId.k_EButton_SteamVR_Trigger);
* ViveInput.Left.TriggerAxis = deviceLeft.GetAxis(EVRButtonId.k_EButton_SteamVR_Trigger);
* ViveInput.Left.Buttons.Grip = getButtonState(deviceLeft, EVRButtonId.k_EButton_Grip);
* ViveInput.Left.Buttons.TouchpadButton = getButtonState (deviceLeft, EVRButtonId.k_EButton_SteamVR_Touchpad);
* ViveInput.Left.Buttons.Menu = getButtonState (deviceLeft, EVRButtonId.k_EButton_ApplicationMenu);
*
* ViveInput.Left.TouchpadAxis = deviceLeft.GetAxis (EVRButtonId.k_EButton_SteamVR_Touchpad);
* if(ViveInput.Left.Buttons.TouchpadButton.Equals(ButtonState.Touched) || ViveInput.Left.Buttons.TouchpadButton.Equals(ButtonState.Pressed)) {
* ViveInput.Left.TouchpadDeltaX = (ViveInput.Left.TouchpadAxis.x - lastLeftTouchpad.x) * Time.deltaTime;
* ViveInput.Left.TouchpadDeltaY = (ViveInput.Left.TouchpadAxis.y - lastLeftTouchpad.y) * Time.deltaTime;
* ViveInput.Left.TouchpadDeltaR = ((ViveInput.Left.TouchpadAxis).magnitude - (lastLeftTouchpad).magnitude) * Time.deltaTime;
* ViveInput.Left.TouchpadDeltaT = getDeltaAngle(ViveInput.Left.TouchpadAxis, lastLeftTouchpad) * Time.deltaTime;
* } else {
* ViveInput.Left.TouchpadDeltaX = ViveInput.Left.TouchpadDeltaY = ViveInput.Left.TouchpadDeltaR = ViveInput.Left.TouchpadDeltaT = 0f;
* }
* ViveInput.Left.TouchpadDir = getTouchpadDir(ViveInput.Left.TouchpadAxis, ViveInput.Left.Buttons.TouchpadButton);
*
* lastLeftTouchpad = ViveInput.Left.TouchpadAxis;
*/
}
else
{
VRInput.GetDevice("ViveLeft").isTracked = false;
deviceLeft = null;
//deviceLeft = null;
//ViveInput.Left.IsTracked = false;
}
//If we have the right controller
if (Right.isValid)
{
deviceRight = SteamVR_Controller.Input((int)Right.index);
VRInputDevice tempDevice = VRInput.GetDevice("ViveRight");
tempDevice.isTracked = true;
tempDevice.SetInt("Index", (int)Right.index);
tempDevice.transform = Right.transform;
tempDevice.position = Right.transform.position;
tempDevice.forward = Right.transform.forward;
tempDevice.up = Right.transform.up;
tempDevice.right = Right.transform.right;
tempDevice.velocity = deviceRight.velocity;
tempDevice.rotation = Right.transform.rotation;
tempDevice.angularVelocity = deviceRight.angularVelocity;
tempDevice.SetButton("Trigger", GetButtonInt(deviceRight, EVRButtonId.k_EButton_SteamVR_Trigger));
tempDevice.SetButton("Menu", GetButtonInt(deviceRight, EVRButtonId.k_EButton_ApplicationMenu));
tempDevice.SetButton("Touchpad", GetButtonInt(deviceRight, EVRButtonId.k_EButton_SteamVR_Touchpad));
tempDevice.SetButton("Grip", GetButtonInt(deviceRight, EVRButtonId.k_EButton_Grip));
tempDevice.SetTouchButton("Touchpad", GetTouchButtonInt(deviceRight, EVRButtonId.k_EButton_SteamVR_Touchpad));
Vector2 touchpadVector = deviceRight.GetAxis(EVRButtonId.k_EButton_SteamVR_Touchpad);
tempDevice.SetAxis("TouchpadX", touchpadVector.x);
tempDevice.SetAxis("TouchpadY", touchpadVector.y);
tempDevice.SetAxis("TouchpadR", Mathf.Sqrt(touchpadVector.x * touchpadVector.x + touchpadVector.y * touchpadVector.y));
tempDevice.SetAxis("TouchpadT", Mathf.Atan2(touchpadVector.y, touchpadVector.x) * Mathf.Rad2Deg);
tempDevice.SetAxis("Trigger", deviceRight.GetAxis(EVRButtonId.k_EButton_SteamVR_Trigger).x);
tempDevice.Vibrate();
/*
* ViveInput.Right.IsTracked = true;
* ViveInput.Right.Index = (int)Right.index;
* ViveInput.Right.Transform = Right.transform;
*
* ViveInput.Right.Position = Right.transform.position;//deviceRight.transform.pos;
* ViveInput.Right.Forward = Right.transform.forward;
* ViveInput.Right.Up = Right.transform.up;
* ViveInput.Right.Right = Right.transform.right;
* ViveInput.Right.Velocity = deviceRight.velocity;
* ViveInput.Right.Rotation = Right.transform.rotation;//deviceRight.transform.rot;
* ViveInput.Right.AngularVelocity = deviceRight.angularVelocity;
*
* ViveInput.Right.Buttons.Trigger = getButtonState(deviceRight, EVRButtonId.k_EButton_SteamVR_Trigger);
* ViveInput.Right.TriggerAxis = deviceRight.GetAxis(EVRButtonId.k_EButton_SteamVR_Trigger);
* ViveInput.Right.Buttons.Grip = getButtonState(deviceRight, EVRButtonId.k_EButton_Grip);
* ViveInput.Right.Buttons.TouchpadButton = getButtonState (deviceRight, EVRButtonId.k_EButton_SteamVR_Touchpad);
* ViveInput.Right.Buttons.Menu = getButtonState (deviceRight, EVRButtonId.k_EButton_ApplicationMenu);
*
* ViveInput.Right.TouchpadAxis = deviceRight.GetAxis (EVRButtonId.k_EButton_SteamVR_Touchpad);
* if(ViveInput.Right.Buttons.TouchpadButton.Equals(ButtonState.Touched) || ViveInput.Right.Buttons.TouchpadButton.Equals(ButtonState.Pressed)) {
* ViveInput.Right.TouchpadDeltaX = (ViveInput.Right.TouchpadAxis.x - lastRightTouchpad.x) * Time.deltaTime;
* ViveInput.Right.TouchpadDeltaY = (ViveInput.Right.TouchpadAxis.y - lastRightTouchpad.y) * Time.deltaTime;
* ViveInput.Right.TouchpadDeltaR = ((ViveInput.Right.TouchpadAxis).magnitude - (lastRightTouchpad).magnitude) * Time.deltaTime;
* ViveInput.Right.TouchpadDeltaT = getDeltaAngle(ViveInput.Right.TouchpadAxis, lastRightTouchpad) * Time.deltaTime;
* } else {
* ViveInput.Right.TouchpadDeltaX = ViveInput.Right.TouchpadDeltaY = ViveInput.Right.TouchpadDeltaR = ViveInput.Right.TouchpadDeltaT = 0f;
* }
* ViveInput.Right.TouchpadDir = getTouchpadDir(ViveInput.Right.TouchpadAxis, ViveInput.Right.Buttons.TouchpadButton);
*
* lastRightTouchpad = ViveInput.Right.TouchpadAxis;
*/
}
else
{
VRInput.GetDevice("ViveRight").isTracked = false;
deviceRight = null;
//ViveInput.Right.IsTracked = false;
}
#if UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0 || UNITY_4
//If we have the HMD
if (hmd.isValid)
{
deviceHMD = SteamVR_Controller.Input((int)hmd.index);
VRInputDevice tempDevice = VRInput.GetDevice("ViveHMD");
tempDevice.isTracked = true;
tempDevice.SetInt("Index", (int)hmd.index);
tempDevice.transform = hmd.transform;
tempDevice.position = hmd.transform.position;
tempDevice.forward = hmd.transform.forward;
tempDevice.up = hmd.transform.up;
tempDevice.right = hmd.transform.right;
tempDevice.velocity = deviceHMD.velocity;
tempDevice.rotation = hmd.transform.rotation;
tempDevice.angularVelocity = deviceHMD.angularVelocity;
/*
* ViveInput.HMD.IsTracked = true;
* ViveInput.HMD.Index = (int)hmd.index;
* ViveInput.HMD.Transform = hmd.transform;
*
* ViveInput.HMD.Position = hmd.transform.position;
* ViveInput.HMD.Forward = hmd.transform.forward;
* ViveInput.HMD.Up = hmd.transform.up;
* ViveInput.HMD.Right = hmd.transform.right;
* ViveInput.HMD.Velocity = deviceHMD.velocity;
* ViveInput.HMD.Rotation = deviceHMD.transform.rot;
* ViveInput.HMD.AngularVelocity = deviceHMD.angularVelocity;
*
* ViveInput.HMD.Buttons.Trigger = ButtonState.Inactive;
* ViveInput.HMD.Buttons.Grip = ButtonState.Inactive;
* ViveInput.HMD.Buttons.TouchpadButton = ButtonState.Inactive;
* ViveInput.HMD.Buttons.Menu = ButtonState.Inactive;
*
* ViveInput.HMD.TouchpadAxis = Vector3.zero;
*/
}
else
{
VRInput.GetDevice("ViveHMD").isTracked = false;
deviceHMD = null;
//ViveInput.HMD.IsTracked = false;
}
#else
if (VRDevice.isPresent)
{
VRInputDevice tempDevice = VRInput.GetDevice("ViveHMD");
tempDevice.isTracked = true;
tempDevice.transform = hmd;
tempDevice.position = hmd.position;
tempDevice.forward = hmd.forward;
tempDevice.up = hmd.up;
tempDevice.right = hmd.right;
tempDevice.rotation = hmd.transform.rotation;
tempDevice.velocity = (hmd.position - lastPosition) / Time.deltaTime;
tempDevice.angularVelocity = (hmd.rotation * Quaternion.Inverse(lastRotation)).eulerAngles / Time.deltaTime;
lastPosition = hmd.position;
lastRotation = hmd.rotation;
tempDevice.SetString("Model", VRDevice.model);
tempDevice.SetFloat("RefreshRate", VRDevice.refreshRate);
tempDevice.SetVector3("Head", InputTracking.GetLocalPosition(VRNode.Head));
tempDevice.SetVector3("LeftEye", InputTracking.GetLocalPosition(VRNode.LeftEye));
tempDevice.SetVector3("RightEye", InputTracking.GetLocalPosition(VRNode.RightEye));
tempDevice.SetVector3("CenterEye", InputTracking.GetLocalPosition(VRNode.CenterEye));
tempDevice.SetQuaternion("Head", InputTracking.GetLocalRotation(VRNode.Head));
tempDevice.SetQuaternion("LeftEye", InputTracking.GetLocalRotation(VRNode.LeftEye));
tempDevice.SetQuaternion("RightEye", InputTracking.GetLocalRotation(VRNode.RightEye));
tempDevice.SetQuaternion("CenterEye", InputTracking.GetLocalRotation(VRNode.CenterEye));
}
else
{
VRInput.GetDevice("ViveHMD").isTracked = false;
}
#endif
}
void Update()
{
controllerIndex = (uint)trackedController.index;
device = SteamVR_Controller.Input((int)controllerIndex);
Vector2 currentTriggerAxis = device.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger);
Vector2 currentTouchpadAxis = device.GetAxis();
if (Vector2ShallowEquals(triggerAxis, currentTriggerAxis))
{
triggerAxisChanged = false;
}
else
{
OnTriggerAxisChanged(SetButtonEvent(ref triggerAxisChanged, true, currentTriggerAxis.x));
}
if (Vector2ShallowEquals(touchpadAxis, currentTouchpadAxis))
{
touchpadAxisChanged = false;
}
else
{
OnTouchpadAxisChanged(SetButtonEvent(ref touchpadTouched, true, 1f));
touchpadAxisChanged = true;
}
touchpadAxis = new Vector2(currentTouchpadAxis.x, currentTouchpadAxis.y);
triggerAxis = new Vector2(currentTriggerAxis.x, currentTriggerAxis.y);
//Trigger
if (device.GetTouchDown(SteamVR_Controller.ButtonMask.Trigger))
{
OnTriggerClicked(SetButtonEvent(ref triggerPressed, true, currentTriggerAxis.x));
EmitAlias(ButtonAlias.Trigger, true, currentTriggerAxis.x, ref triggerPressed);
}
else if (device.GetTouchUp(SteamVR_Controller.ButtonMask.Trigger))
{
OnTriggerUnclicked(SetButtonEvent(ref triggerPressed, false, 0f));
EmitAlias(ButtonAlias.Trigger, false, 0f, ref triggerPressed);
}
//ApplicationMenu
if (device.GetTouchDown(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
OnApplicationMenuClicked(SetButtonEvent(ref applicationMenuPressed, true, 1f));
EmitAlias(ButtonAlias.Application_Menu, true, 1f, ref applicationMenuPressed);
}
else if (device.GetTouchUp(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
OnApplicationMenuUnclicked(SetButtonEvent(ref applicationMenuPressed, false, 0f));
EmitAlias(ButtonAlias.Application_Menu, false, 0f, ref applicationMenuPressed);
}
//Grip
if (device.GetTouchDown(SteamVR_Controller.ButtonMask.Grip))
{
OnGripClicked(SetButtonEvent(ref gripPressed, true, 1f));
EmitAlias(ButtonAlias.Grip, true, 1f, ref gripPressed);
}
else if (device.GetTouchUp(SteamVR_Controller.ButtonMask.Grip))
{
OnGripUnclicked(SetButtonEvent(ref gripPressed, false, 0f));
EmitAlias(ButtonAlias.Grip, false, 0f, ref gripPressed);
}
//Touchpad Clicked
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
OnTouchpadClicked(SetButtonEvent(ref touchpadPressed, true, 1f));
EmitAlias(ButtonAlias.Touchpad_Press, true, 1f, ref touchpadPressed);
}
else if (device.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad))
{
OnTouchpadUnclicked(SetButtonEvent(ref touchpadPressed, false, 0f));
EmitAlias(ButtonAlias.Touchpad_Press, false, 0f, ref touchpadPressed);
}
//Touchpad Touched
if (device.GetTouchDown(SteamVR_Controller.ButtonMask.Touchpad))
{
OnTouchpadTouched(SetButtonEvent(ref touchpadTouched, true, 1f));
EmitAlias(ButtonAlias.Touchpad_Touch, true, 1f, ref touchpadTouched);
}
else if (device.GetTouchUp(SteamVR_Controller.ButtonMask.Touchpad))
{
OnTouchpadUntouched(SetButtonEvent(ref touchpadTouched, false, 0f));
EmitAlias(ButtonAlias.Touchpad_Touch, false, 0f, ref touchpadTouched);
}
}
// Corourtine to handle all the steps across loading boundaries.
IEnumerator LoadLevel()
{
// Optionally rotate loading screen transform around the camera into view.
// We assume here that the loading screen is already facing toward the origin,
// and that the progress bar transform (if any) is a child and will follow along.
if (loadingScreen != null && loadingScreenDistance > 0.0f)
{
// Wait until we have tracking.
var hmd = SteamVR_Controller.Input((int)OpenVR.k_unTrackedDeviceIndex_Hmd);
while (!hmd.hasTracking)
{
yield return(null);
}
var tloading = hmd.transform;
tloading.rot = Quaternion.Euler(0.0f, tloading.rot.eulerAngles.y, 0.0f);
tloading.pos += tloading.rot * new Vector3(0.0f, 0.0f, loadingScreenDistance);
var t = loadingScreenTransform != null ? loadingScreenTransform : transform;
t.position = tloading.pos;
t.rotation = tloading.rot;
}
_active = this;
SteamVR_Events.Loading.Send(true);
// Calculate rate for fading in loading screen and progress bar.
if (loadingScreenFadeInTime > 0.0f)
{
fadeRate = 1.0f / loadingScreenFadeInTime;
}
else
{
alpha = 1.0f;
}
var overlay = OpenVR.Overlay;
// Optionally create our loading screen overlay.
if (loadingScreen != null && overlay != null)
{
loadingScreenOverlayHandle = GetOverlayHandle("loadingScreen", loadingScreenTransform != null ? loadingScreenTransform : transform, loadingScreenWidthInMeters);
if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
{
var texture = new Texture_t();
texture.handle = loadingScreen.GetNativeTexturePtr();
texture.eType = SteamVR.instance.textureType;
texture.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(loadingScreenOverlayHandle, ref texture);
}
}
bool fadedForeground = false;
// Fade out to compositor
SteamVR_Events.LoadingFadeOut.Send(fadeOutTime);
// Optionally set a skybox to use as a backdrop in the compositor.
var compositor = OpenVR.Compositor;
if (compositor != null)
{
if (front != null)
{
SteamVR_Skybox.SetOverride(front, back, left, right, top, bottom);
// Explicitly fade to the compositor since loading will cause us to stop rendering.
compositor.FadeGrid(fadeOutTime, true);
yield return(new WaitForSeconds(fadeOutTime));
}
else if (backgroundColor != Color.clear)
{
// Otherwise, use the specified background color.
if (showGrid)
{
// Set compositor background color immediately, and start fading to it.
compositor.FadeToColor(0.0f, backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a, true);
compositor.FadeGrid(fadeOutTime, true);
yield return(new WaitForSeconds(fadeOutTime));
}
else
{
// Fade the foreground color in (which will blend on top of the scene), and then cut to the compositor.
compositor.FadeToColor(fadeOutTime, backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a, false);
yield return(new WaitForSeconds(fadeOutTime + 0.1f));
compositor.FadeGrid(0.0f, true);
fadedForeground = true;
}
}
}
// Now that we're fully faded out, we can stop submitting frames to the compositor.
SteamVR_Render.pauseRendering = true;
// Continue waiting for the overlays to fully fade in before continuing.
while (alpha < 1.0f)
{
yield return(null);
}
// Keep us from getting destroyed when loading the new level, otherwise this coroutine will get stopped prematurely.
transform.parent = null;
DontDestroyOnLoad(gameObject);
if (!string.IsNullOrEmpty(internalProcessPath))
{
Debug.Log("Launching external application...");
var applications = OpenVR.Applications;
if (applications == null)
{
Debug.Log("Failed to get OpenVR.Applications interface!");
}
else
{
var workingDirectory = Directory.GetCurrentDirectory();
var fullPath = Path.Combine(workingDirectory, internalProcessPath);
Debug.Log("LaunchingInternalProcess");
Debug.Log("ExternalAppPath = " + internalProcessPath);
Debug.Log("FullPath = " + fullPath);
Debug.Log("ExternalAppArgs = " + internalProcessArgs);
Debug.Log("WorkingDirectory = " + workingDirectory);
var error = applications.LaunchInternalProcess(fullPath, internalProcessArgs, workingDirectory);
Debug.Log("LaunchInternalProcessError: " + error);
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#elif !UNITY_METRO
System.Diagnostics.Process.GetCurrentProcess().Kill();
#endif
}
}
else
{
var mode = loadAdditive ? UnityEngine.SceneManagement.LoadSceneMode.Additive : UnityEngine.SceneManagement.LoadSceneMode.Single;
if (loadAsync)
{
Application.backgroundLoadingPriority = ThreadPriority.Low;
async = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(levelName, mode);
// Performing this in a while loop instead seems to help smooth things out.
//yield return async;
while (!async.isDone)
{
yield return(null);
}
}
else
{
UnityEngine.SceneManagement.SceneManager.LoadScene(levelName, mode);
}
}
yield return(null);
System.GC.Collect();
yield return(null);
Shader.WarmupAllShaders();
// Optionally wait a short period of time after loading everything back in, but before we start rendering again
// in order to give everything a change to settle down to avoid any hitching at the start of the new level.
yield return(new WaitForSeconds(postLoadSettleTime));
SteamVR_Render.pauseRendering = false;
// Fade out loading screen.
if (loadingScreenFadeOutTime > 0.0f)
{
fadeRate = -1.0f / loadingScreenFadeOutTime;
}
else
{
alpha = 0.0f;
}
// Fade out to compositor
SteamVR_Events.LoadingFadeIn.Send(fadeInTime);
// Refresh compositor reference since loading scenes might have invalidated it.
compositor = OpenVR.Compositor;
if (compositor != null)
{
// Fade out foreground color if necessary.
if (fadedForeground)
{
compositor.FadeGrid(0.0f, false);
compositor.FadeToColor(fadeInTime, 0.0f, 0.0f, 0.0f, 0.0f, false);
yield return(new WaitForSeconds(fadeInTime));
}
else
{
// Fade scene back in, and reset skybox once no longer visible.
compositor.FadeGrid(fadeInTime, false);
yield return(new WaitForSeconds(fadeInTime));
if (front != null)
{
SteamVR_Skybox.ClearOverride();
}
}
}
// Finally, stick around long enough for our overlays to fully fade out.
while (alpha > 0.0f)
{
yield return(null);
}
if (overlay != null)
{
if (progressBarOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
{
overlay.HideOverlay(progressBarOverlayHandle);
}
if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
{
overlay.HideOverlay(loadingScreenOverlayHandle);
}
}
Destroy(gameObject);
_active = null;
SteamVR_Events.Loading.Send(false);
}
void Start()
{
m_trackedObj = GetComponent <SteamVR_TrackedObject>();
m_deivce = SteamVR_Controller.Input((int)m_trackedObj.index);
}
public override void OnExitControl(GameObject control)
{
var device = SteamVR_Controller.Input(_index);
//device.TriggerHapticPulse(600);
}
void FixedUpdate()
{
head.position = hmd.position;
head.rotation = hmd.rotation;
leftHand.transform.position = leftController.position;
rightHand.transform.position = rightController.position;
leftHand.transform.rotation = leftController.rotation;
rightHand.transform.rotation = rightController.rotation;
int leftIndex = (int)leftController.GetComponent <SteamVR_TrackedObject>().index;
if (leftIndex >= 0)
{
float leftTrigger = SteamVR_Controller.Input(leftIndex).GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger).magnitude;
if (leftHand.intersected != null && leftTrigger > 0.2f)
{
leftHeldObject = leftHand.intersected;
saveMaxLeft = leftHand.intersected.maxAngularVelocity;
leftHand.intersected.maxAngularVelocity = Mathf.Infinity;
}
if (leftHeldObject != null && leftTrigger <= 0.2f)
{
//release it
leftHeldObject.isKinematic = false;
leftHeldObject.velocity = SteamVR_Controller.Input(leftIndex).velocity;
leftHeldObject.angularVelocity = SteamVR_Controller.Input(leftIndex).angularVelocity;
leftHeldObject.maxAngularVelocity = saveMaxLeft;
leftHeldObject = null;
}
if (leftHeldObject != null)
{
//force the object to follow my hand (isKinematic == true)
leftHeldObject.isKinematic = true;
leftHeldObject.position = leftHand.transform.position;
leftHeldObject.rotation = leftHand.transform.rotation;
//force the object to follow my hand (isKinematic == false)
//leftHeldObject.velocity = (leftHand.transform.position - leftHeldObject.position) / Time.deltaTime;
//float angle;
//Vector3 axis;
//Quaternion q = leftHand.transform.rotation * Quaternion.Inverse(leftHeldObject.rotation);
//q.ToAngleAxis(out angle, out axis);
//leftHeldObject.angularVelocity = axis * angle * Mathf.Deg2Rad / Time.deltaTime;
}
}
int rightIndex = (int)rightController.GetComponent <SteamVR_TrackedObject>().index;
if (rightIndex >= 0)
{
float rightTrigger = SteamVR_Controller.Input(rightIndex).GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger).magnitude;
if (rightHand.intersected != null && rightTrigger > 0.2f)
{
rightHeldObject = rightHand.intersected;
saveMaxRight = rightHand.intersected.maxAngularVelocity;
rightHand.intersected.maxAngularVelocity = Mathf.Infinity;
}
if (rightHeldObject != null && rightTrigger <= 0.2f)
{
//release it
rightHeldObject.isKinematic = false;
rightHeldObject.velocity = SteamVR_Controller.Input(rightIndex).velocity;
rightHeldObject.angularVelocity = SteamVR_Controller.Input(rightIndex).angularVelocity;
rightHeldObject.maxAngularVelocity = saveMaxRight;
rightHeldObject = null;
}
if (rightHeldObject != null)
{
//force the object to follow my hand (isKinematic == true)
rightHeldObject.isKinematic = true;
rightHeldObject.position = rightHand.transform.position;
rightHeldObject.rotation = rightHand.transform.rotation;
//force the object to follow my hand (isKinematic == false)
//rightHeldObject.velocity = (rightHand.transform.position - rightHeldObject.position) / Time.deltaTime;
//float angle;
//Vector3 axis;
//Quaternion q = rightHand.transform.rotation * Quaternion.Inverse(rightHeldObject.rotation);
//q.ToAngleAxis(out angle, out axis);
//rightHeldObject.angularVelocity = axis * angle * Mathf.Deg2Rad / Time.deltaTime;
}
}
}
void Update()
{
// Force controller update in case no one else called this frame to ensure prevState gets updated.
SteamVR_Controller.Update();
// Dispatch any OpenVR events.
var system = OpenVR.System;
if (system != null)
{
var vrEvent = new VREvent_t();
var size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t));
for (int i = 0; i < 64; i++)
{
if (!system.PollNextEvent(ref vrEvent, size))
{
break;
}
switch ((EVREventType)vrEvent.eventType)
{
case EVREventType.VREvent_InputFocusCaptured: // another app has taken focus (likely dashboard)
if (vrEvent.data.process.oldPid == 0)
{
SteamVR_Events.InputFocus.Send(false);
}
break;
case EVREventType.VREvent_InputFocusReleased: // that app has released input focus
if (vrEvent.data.process.pid == 0)
{
SteamVR_Events.InputFocus.Send(true);
}
break;
case EVREventType.VREvent_ShowRenderModels:
SteamVR_Events.HideRenderModels.Send(false);
break;
case EVREventType.VREvent_HideRenderModels:
SteamVR_Events.HideRenderModels.Send(true);
break;
default:
SteamVR_Events.System((EVREventType)vrEvent.eventType).Send(vrEvent);
break;
}
}
}
// Ensure various settings to minimize latency.
Application.targetFrameRate = -1;
Application.runInBackground = true; // don't require companion window focus
QualitySettings.maxQueuedFrames = -1;
QualitySettings.vSyncCount = 0; // this applies to the companion window
if (lockPhysicsUpdateRateToRenderFrequency && Time.timeScale > 0.0f)
{
var vr = SteamVR.instance;
if (vr != null)
{
var timing = new Compositor_FrameTiming();
timing.m_nSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(Compositor_FrameTiming));
vr.compositor.GetFrameTiming(ref timing, 0);
Time.fixedDeltaTime = Time.timeScale / vr.hmd_DisplayFrequency;
}
}
}
void FixedUpdate()
{
device = SteamVR_Controller.Input((int)paddle.index);
}
void Update()
{
if (Dreapta)
{
isright = false;
if (isleft)
{
// If we are currently teleporting (ie handling the fade in/out transition)...
if (CurrentTeleportState == TeleportState.Teleporting)
{
// Wait until half of the teleport time has passed before the next event (note: both the switch from fade
// out to fade in and the switch from fade in to stop the animation is half of the fade duration)
if (Time.time - TeleportTimeMarker >= TeleportFadeDuration / 2)
{
if (FadingIn)
{
// We have finished fading in
CurrentTeleportState = TeleportState.None;
}
else
{
// We have finished fading out - time to teleport!
Vector3 offset = OriginTransform.position - HeadTransform.position;
offset.y = 0;
OriginTransform.position = Pointer.SelectedPoint + offset;
}
TeleportTimeMarker = Time.time;
FadingIn = !FadingIn;
}
}
// At this point, we are NOT actively teleporting. So now we care about controller input.
else if (CurrentTeleportState == TeleportState.Selecting)
{
Debug.Assert(ActiveController != null);
// Here, there is an active controller - that is, the user is holding down on the trackpad.
// Poll controller for pertinent button data
int index = (int)ActiveController.index;
var device = SteamVR_Controller.Input(index);
bool shouldTeleport = device.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad);
bool shouldCancel = device.GetPressUp(SteamVR_Controller.ButtonMask.Grip);
if (shouldTeleport || shouldCancel)
{
// If the user has decided to teleport (ie lets go of touchpad) then remove all visual indicators
// related to selecting things and actually teleport
// If the user has decided to cancel (ie squeezes grip button) then remove visual indicators and do nothing
if (shouldTeleport && Pointer.PointOnNavMesh)
{
// Begin teleport sequence
CurrentTeleportState = TeleportState.Teleporting;
TeleportTimeMarker = Time.time;
}
else
{
CurrentTeleportState = TeleportState.None;
}
// Reset active controller, disable pointer, disable visual indicators
ActiveController = null;
Pointer.enabled = false;
RoomBorder.enabled = false;
//RoomBorder.Transpose = Matrix4x4.TRS(OriginTransform.position, Quaternion.identity, Vector3.one);
if (NavmeshAnimator != null)
{
NavmeshAnimator.SetBool(EnabledAnimatorID, false);
}
Pointer.transform.parent = null;
Pointer.transform.position = Vector3.zero;
Pointer.transform.rotation = Quaternion.identity;
Pointer.transform.localScale = Vector3.one;
}
else
{
// The user is still deciding where to teleport and has the touchpad held down.
// Note: rendering of the parabolic pointer / marker is done in ParabolicPointer
Vector3 offset = HeadTransform.position - OriginTransform.position;
offset.y = 0;
// Render representation of where the chaperone bounds will be after teleporting
RoomBorder.enabled = Pointer.PointOnNavMesh;
RoomBorder.Transpose = Matrix4x4.TRS(Pointer.SelectedPoint - offset, Quaternion.identity, Vector3.one);
// Haptic feedback click every [HaptickClickAngleStep] degrees
if (Pointer.CurrentParabolaAngleY >= 45) // Don't click when at max degrees
{
LastClickAngle = Pointer.CurrentPointVector;
}
float angleClickDiff = Vector3.Angle(LastClickAngle, Pointer.CurrentPointVector);
if (IsClicking && Mathf.Abs(angleClickDiff) > HapticClickAngleStep)
{
LastClickAngle = Pointer.CurrentPointVector;
if (Pointer.PointOnNavMesh)
{
device.TriggerHapticPulse();
}
}
// Trigger a stronger haptic pulse when "entering" a teleportable surface
if (Pointer.PointOnNavMesh && !IsClicking)
{
IsClicking = true;
device.TriggerHapticPulse(750);
LastClickAngle = Pointer.CurrentPointVector;
}
else if (!Pointer.PointOnNavMesh && IsClicking)
{
IsClicking = false;
}
}
}
else //CurrentTeleportState == TeleportState.None
{
// At this point the user is not holding down on the touchpad at all or has canceled a teleport and hasn't
// let go of the touchpad. So we wait for the user to press the touchpad and enable visual indicators
// if necessary.
foreach (SteamVR_TrackedObject obj in Controllers)
{
int index = (int)obj.index;
if (index == -1)
{
continue;
}
var device = SteamVR_Controller.Input(index);
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
Vector2 touchpad = (device.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0));
if (touchpad.y < 0.7f)
{
ActiveController = obj;
Pointer.transform.parent = obj.transform;
Pointer.transform.localPosition = Vector3.zero;
Pointer.transform.localRotation = Quaternion.identity;
Pointer.transform.localScale = Vector3.one;
Pointer.enabled = true;
CurrentTeleportState = TeleportState.Selecting;
}
// Set active controller to this controller, and enable the parabolic pointer and visual indicators
// that the user can use to determine where they are able to teleport.
if (NavmeshAnimator != null)
{
NavmeshAnimator.SetBool(EnabledAnimatorID, true);
}
Pointer.ForceUpdateCurrentAngle();
LastClickAngle = Pointer.CurrentPointVector;
IsClicking = Pointer.PointOnNavMesh;
}
}
}
}
if (isright)
{
// If we are currently teleporting (ie handling the fade in/out transition)...
if (CurrentTeleportState == TeleportState.Teleporting)
{
// Wait until half of the teleport time has passed before the next event (note: both the switch from fade
// out to fade in and the switch from fade in to stop the animation is half of the fade duration)
if (Time.time - TeleportTimeMarker >= TeleportFadeDuration / 2)
{
if (FadingIn)
{
// We have finished fading in
CurrentTeleportState = TeleportState.None;
}
else
{
// We have finished fading out - time to teleport!
Vector3 offset = OriginTransform.position - HeadTransform.position;
offset.y = 0;
OriginTransform.position = Pointer.SelectedPoint + offset;
}
TeleportTimeMarker = Time.time;
FadingIn = !FadingIn;
}
}
// At this point, we are NOT actively teleporting. So now we care about controller input.
else if (CurrentTeleportState == TeleportState.Selecting)
{
Debug.Assert(ActiveController != null);
// Here, there is an active controller - that is, the user is holding down on the trackpad.
// Poll controller for pertinent button data
int index = (int)ActiveController.index;
var device = SteamVR_Controller.Input(index);
bool shouldTeleport = device.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad);
bool shouldCancel = device.GetPressUp(SteamVR_Controller.ButtonMask.Grip);
if (shouldTeleport || shouldCancel)
{
// If the user has decided to teleport (ie lets go of touchpad) then remove all visual indicators
// related to selecting things and actually teleport
// If the user has decided to cancel (ie squeezes grip button) then remove visual indicators and do nothing
if (shouldTeleport && Pointer.PointOnNavMesh)
{
// Begin teleport sequence
CurrentTeleportState = TeleportState.Teleporting;
TeleportTimeMarker = Time.time;
}
else
{
CurrentTeleportState = TeleportState.None;
}
// Reset active controller, disable pointer, disable visual indicators
ActiveController = null;
Pointer.enabled = false;
RoomBorder.enabled = false;
//RoomBorder.Transpose = Matrix4x4.TRS(OriginTransform.position, Quaternion.identity, Vector3.one);
if (NavmeshAnimator != null)
{
NavmeshAnimator.SetBool(EnabledAnimatorID, false);
}
Pointer.transform.parent = null;
Pointer.transform.position = Vector3.zero;
Pointer.transform.rotation = Quaternion.identity;
Pointer.transform.localScale = Vector3.one;
}
else
{
// The user is still deciding where to teleport and has the touchpad held down.
// Note: rendering of the parabolic pointer / marker is done in ParabolicPointer
Vector3 offset = HeadTransform.position - OriginTransform.position;
offset.y = 0;
// Render representation of where the chaperone bounds will be after teleporting
RoomBorder.enabled = Pointer.PointOnNavMesh;
RoomBorder.Transpose = Matrix4x4.TRS(Pointer.SelectedPoint - offset, Quaternion.identity, Vector3.one);
// Haptic feedback click every [HaptickClickAngleStep] degrees
if (Pointer.CurrentParabolaAngleY >= 45) // Don't click when at max degrees
{
LastClickAngle = Pointer.CurrentPointVector;
}
float angleClickDiff = Vector3.Angle(LastClickAngle, Pointer.CurrentPointVector);
if (IsClicking && Mathf.Abs(angleClickDiff) > HapticClickAngleStep)
{
LastClickAngle = Pointer.CurrentPointVector;
if (Pointer.PointOnNavMesh)
{
device.TriggerHapticPulse();
}
}
// Trigger a stronger haptic pulse when "entering" a teleportable surface
if (Pointer.PointOnNavMesh && !IsClicking)
{
IsClicking = true;
device.TriggerHapticPulse(750);
LastClickAngle = Pointer.CurrentPointVector;
}
else if (!Pointer.PointOnNavMesh && IsClicking)
{
IsClicking = false;
}
}
}
else //CurrentTeleportState == TeleportState.None
{
// At this point the user is not holding down on the touchpad at all or has canceled a teleport and hasn't
// let go of the touchpad. So we wait for the user to press the touchpad and enable visual indicators
// if necessary.
foreach (SteamVR_TrackedObject obj in Controllers)
{
int index = (int)obj.index;
if (index == -1)
{
continue;
}
var device = SteamVR_Controller.Input(index);
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
Vector2 touchpad = (device.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0));
if (touchpad.y < 0.7f)
{
ActiveController = obj;
Pointer.transform.parent = obj.transform;
Pointer.transform.localPosition = Vector3.zero;
Pointer.transform.localRotation = Quaternion.identity;
Pointer.transform.localScale = Vector3.one;
Pointer.enabled = true;
CurrentTeleportState = TeleportState.Selecting;
}
// Set active controller to this controller, and enable the parabolic pointer and visual indicators
// that the user can use to determine where they are able to teleport.
if (NavmeshAnimator != null)
{
NavmeshAnimator.SetBool(EnabledAnimatorID, true);
}
Pointer.ForceUpdateCurrentAngle();
LastClickAngle = Pointer.CurrentPointVector;
IsClicking = Pointer.PointOnNavMesh;
}
}
}
}
}
}
private void SetDeviceIndex(int index)
{
DeviceIndex = index;
Controller = SteamVR_Controller.Input(index);
}
void Update()
{
_trackedObject = GetComponent <SteamVR_TrackedObject>();
_device = SteamVR_Controller.Input((int)_trackedObject.index);
_touchPosition = _device.GetAxis();
if (_isCanvasMode)
{
if (_device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
switch (GetTouchPositionOfGamePad())
{
case 0:
//When clicking on the top
ExecuteEvents.Execute <IColorCanvas>(
target: _system,
eventData: null,
functor: (reciever, y) => reciever.ChangeHead(1)
);
break;
case 2:
//When clicking on the under
ExecuteEvents.Execute <IColorCanvas>(
target: _system,
eventData: null,
functor: (reciever, y) => reciever.ChangeHead(-1)
);
break;
case 1:
//When clicking on the ringt
ExecuteEvents.Execute <IColorCanvas>(
target: _system,
eventData: null,
functor: (reciever, y) => reciever.ChangeValue(10)
);
break;
case 3:
//When clicking on the left
ExecuteEvents.Execute <IColorCanvas>(
target: _system,
eventData: null,
functor: (reciever, y) => reciever.ChangeValue(-10)
);
break;
default:
break;
}
}
}
else
{
//トリガーを離した
if (_device.GetTouchUp(SteamVR_Controller.ButtonMask.Trigger))
{
ReleaseObject();
}
//タッチパッドをクリック
if (_device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
_toolMode = GetTouchPositionOfGamePad();
ChangeTool(_toolMode);
}
if (_device.GetPressDown(SteamVR_Controller.ButtonMask.Grip))
{
InstantiateGrid();
}
}
}
void Update()
{
foreach (var index in controllerIndices)
{
var overlay = SteamVR_Overlay.instance;
if (overlay && point && pointer)
{
var t = SteamVR_Controller.Input(index).transform;
pointer.transform.localPosition = t.pos;
pointer.transform.localRotation = t.rot;
var results = new SteamVR_Overlay.IntersectionResults();
var hit = overlay.ComputeIntersection(t.pos, t.rot * Vector3.forward, ref results);
if (hit)
{
point.transform.localPosition = results.point;
point.transform.localRotation = Quaternion.LookRotation(results.normal);
}
continue;
}
foreach (var buttonId in buttonIds)
{
if (SteamVR_Controller.Input(index).GetPressDown(buttonId))
{
//Debug.Log(buttonId + " press down");
if (SteamVR_Controller.Input(index).GetPressUp(buttonId))
{
//Debug.Log(buttonId + " press up");
if (buttonId == EVRButtonId.k_EButton_SteamVR_Trigger)
{
SteamVR_Controller.Input(index).TriggerHapticPulse();
PrintControllerStatus(index);
}
}
}
if (SteamVR_Controller.Input(index).GetPress(buttonId))
{
Debug.Log(buttonId);
}
}
foreach (var buttonId in axisIds)
{
if (SteamVR_Controller.Input(index).GetTouchDown(buttonId))
{
Debug.Log(buttonId + " touch down");
}
if (SteamVR_Controller.Input(index).GetTouchUp(buttonId))
{
Debug.Log(buttonId + " touch up");
}
if (SteamVR_Controller.Input(index).GetTouch(buttonId))
{
var axis = SteamVR_Controller.Input(index).GetAxis(buttonId);
Debug.Log("axis: " + axis);
}
}
}
}
void Start()
{
controllerIndex = (uint)trackedController.index;
device = SteamVR_Controller.Input((int)controllerIndex);
}
private void TriggerPressed(object sender, ClickedEventArgs e)
{
ShootPaintball();
SteamVR_Controller.Input((int)trackedObj.index).TriggerHapticPulse(2500);
}
// Update is called once per frame
void Update()
{
float x;
float y;
SteamVR_TrackedObject trackedObjWandr = wandr.GetComponent <SteamVR_TrackedObject> ();
SteamVR_TrackedObject trackedObjWandl = wandl.GetComponent <SteamVR_TrackedObject> ();
SteamVR_Controller.Device deviceR = null;
SteamVR_Controller.Device deviceL = null;
if (trackedObjWandr != null)
{
deviceR = SteamVR_Controller.Input((int)trackedObjWandr.index);
}
if (trackedObjWandr != null)
{
deviceL = SteamVR_Controller.Input((int)trackedObjWandl.index);
}
//Hold for a few iterations in order not to enter the loop several times in a row with the same interaction
count += 1;
x = deviceR.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad).x;
y = deviceR.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad).y;
if (x != 0 || y != 0)
{
if (y > 0) //top Part of pad
{
if (x > 0) //Top Right
{
if (y > x)
{
}
else
{
isNormalized = false;
SetDataText(lastGrabbedObject);
}
}
else//Top Left
{
if (y > -x)
{
}
else
{
isNormalized = true;
SetDataText(lastGrabbedObject);
}
}
}
else//bottom part of pad
{
if (x > 0)//bottom Right
{
if (-y > x)
{
}
else
{
isNormalized = false;
SetDataText(lastGrabbedObject);
}
}
else//bottom Left
{
if (-y > -x)
{
}
else
{
isNormalized = true;
SetDataText(lastGrabbedObject);
}
}
}
}
if (deviceR.GetPress(SteamVR_Controller.ButtonMask.Trigger))
{
if (grabbedObject == null)
{
if (currentObject != null)
{
grabbedObject = currentObject;
// If object had a rigidbody, grabbed save the rigidbody's kinematic state
// so it can be restored on release of the object
Rigidbody body = null;
body = grabbedObject.GetComponent <Rigidbody> ();
if (body != null)
{
wasKinematic = body.isKinematic;
body.isKinematic = true;
}
//Read the parameters of the data Point(Dont kn ow if I will put this here or not)
// Save away to original parentage of the grabbed object
if (grabbedObject.tag == "attr")
{
grabbedObjectParent = attrHolder.transform;
}
else
{
// Save away to original parentage of the grabbed object
grabbedObjectParent = grabbedObject.transform.parent;
}
// Make the grabbed object a child of the wand
grabbedObject.transform.parent = wandr.transform;
currentObject = null;
// Disable collision between yourself and the grabbed object so that the grabbed object
// does not apply its physics to you and push you off the world
Physics.IgnoreCollision(cameraRig.GetComponent <Collider>(), grabbedObject.GetComponent <Collider>(), true);
if (deviceR.GetPress(SteamVR_Controller.ButtonMask.Grip))
{
if (grabbedObject.GetComponent <AttrProperties> ().inWorld == true)
{
if (grabbedObject.GetComponent <AttrProperties> ().isActive == true)
{
grabbedObject.GetComponent <AttrProperties> ().isActive = false;
grabbedObject.GetComponent <Light>().enabled = false;
}
else
{
if (attrCycle == 0)
{
grabbedObject.GetComponent <AttrProperties> ().isActive = true;
grabbedObject.GetComponent <Light>().enabled = true;
grabbedObjectParent = attrHolder.transform;
attrCycle = 1;
}
else if (attrCycle == 1)
{
grabbedObject.GetComponent <AttrProperties> ().inWorld = false;
grabbedObjectParent = attrArm.transform;
attrCycle = 0;
}
}
}
else
{
grabbedObject.GetComponent <AttrProperties> ().inWorld = true;
grabbedObjectParent = attrHolder.transform;
}
count = 0;
}
}
}
}
else
{
if (grabbedObject != null)
{
// Restore the original parentage of the grabbed object
grabbedObject.transform.parent = grabbedObjectParent;
// If object had a rigidbody, restore its kinematic state
Rigidbody body = null;
body = grabbedObject.GetComponent <Rigidbody> ();
if (body != null)
{
body.isKinematic = wasKinematic;
}
// Re-enstate collision between self and object
Physics.IgnoreCollision(cameraRig.GetComponent <Collider> (), grabbedObject.GetComponent <Collider> (), false);
grabbedObject = null;
currentObject = null;
}
}
}
public void UpdateComponents(CVRRenderModels renderModels)
{
if (renderModels == null)
{
return;
}
var t = transform;
if (t.childCount == 0)
{
return;
}
var controllerState = (index != SteamVR_TrackedObject.EIndex.None)
? SteamVR_Controller.Input((int)index).GetState()
: new VRControllerState_t();
if (nameCache == null)
{
nameCache = new Dictionary <int, string>();
}
for (int i = 0; i < t.childCount; i++)
{
var child = t.GetChild(i);
// Cache names since accessing an object's name allocate memory.
string name;
if (!nameCache.TryGetValue(child.GetInstanceID(), out name))
{
name = child.name;
nameCache.Add(child.GetInstanceID(), name);
}
var componentState = new RenderModel_ComponentState_t();
if (
!renderModels.GetComponentState(renderModelName, name, ref controllerState, ref controllerModeState,
ref componentState))
{
continue;
}
var componentTransform = new SteamVR_Utils.RigidTransform(componentState.mTrackingToComponentRenderModel);
child.localPosition = componentTransform.pos;
child.localRotation = componentTransform.rot;
var attach = child.FindChild(k_localTransformName);
if (attach != null)
{
var attachTransform = new SteamVR_Utils.RigidTransform(componentState.mTrackingToComponentLocal);
attach.position = t.TransformPoint(attachTransform.pos);
attach.rotation = t.rotation * attachTransform.rot;
}
bool visible = (componentState.uProperties & (uint)EVRComponentProperty.IsVisible) != 0;
if (visible != child.gameObject.activeSelf)
{
child.gameObject.SetActive(visible);
}
}
}
public void CheckController(SteamVR_TrackedObject controller)
{
SteamVR_Controller.Device input = null;
if (controller != null)
{
input = SteamVR_Controller.Input((int)controller.index);
}
Vector3 origin;
Vector3 direction;
Quaternion rotation;
origin = controller.transform.position;
direction = controller.transform.rotation * new Vector3(0, 0, 100);
rotation = controller.transform.rotation;
bool hitScreen = false;
// Mouse simulation
if (Visible())
{
RaycastHit[] rcasts = Physics.RaycastAll(origin, direction);
foreach (RaycastHit rcast in rcasts)
{
if (rcast.collider.gameObject != this.gameObject)
{
continue;
}
hitScreen = true;
if (m_manager.ShowLine)
{
m_line.enabled = true;
m_line.SetPosition(0, origin);
m_line.SetPosition(1, rcast.point);
}
else
{
m_line.enabled = false;
}
//
float dx = m_manager.GetScreenWidth(ScreenId);
float dy = m_manager.GetScreenHeight(ScreenId);
Vector2 offset = m_manager.GetScreenOffset(this);
// float vx = rcast.textureCoord.x * m_manager.textureScale;
// float vy = rcast.textureCoord.y * m_manager.textureScale;
float vx = rcast.textureCoord.x;
float vy = rcast.textureCoord.y;
vy = 1 - vy;
float x = (vx * dx) + offset.x;
float y = (vy * dy) + offset.y;
int iX = (int)x;
int iY = (int)y;
// Debug.Log($"{x} {y} {ScreenId}");
m_manager.SetCursorPos(iX, iY);
if (m_lastShowClick == 0)
{
//if (m_manager.EnableZoom)
if (m_manager.ViveZoom != VdmDesktopManager.ViveButton.None)
{
if (input.GetPressDown(MyButtonToViveButton(m_manager.ViveZoom)))
{
VdmDesktopManager.ActionInThisFrame = true;
m_distanceBeforeZoom = (controller.transform.position - rcast.point).magnitude;
float distanceDelta = m_distanceBeforeZoom - m_manager.ControllerZoomDistance;
Vector3 vectorMove = rotation * new Vector3(0, 0, -distanceDelta);
m_positionZoomed = m_positionNormal + vectorMove;
m_rotationZoomed = m_rotationNormal;
//m_positionZoomed = controller.transform.position + controller.transform.rotation * new Vector3(0, 0, m_manager.ControllerZoomDistance);
ZoomIn();
}
if (input.GetPressUp(MyButtonToViveButton(m_manager.ViveZoom)))
{
VdmDesktopManager.ActionInThisFrame = true;
ZoomOut();
}
}
}
if (m_manager.ViveLeftClick != VdmDesktopManager.ViveButton.None)
{
if (input.GetPressDown(MyButtonToViveButton(m_manager.ViveLeftClick)))
{
m_lastLeftTriggerClick = Time.time;
m_manager.SimulateMouseLeftDown();
VdmDesktopManager.ActionInThisFrame = true;
}
if (input.GetPressUp(MyButtonToViveButton(m_manager.ViveLeftClick)))
{
if (m_lastLeftTriggerClick != 0)
{
m_manager.SimulateMouseLeftUp();
m_lastLeftTriggerClick = 0;
VdmDesktopManager.ActionInThisFrame = true;
}
}
}
if (m_manager.ViveTouchPadForClick)
{
if (input.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad) && (input.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0).x < -0.2f))
{
m_lastLeftTouchClick = Time.time;
m_manager.SimulateMouseLeftDown();
VdmDesktopManager.ActionInThisFrame = true;
}
if (input.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad) && (input.GetAxis(Valve.VR.EVRButtonId.k_EButton_Axis0).x > -0.2f))
{
m_lastRightTouchClick = Time.time;
m_manager.SimulateMouseRightDown();
VdmDesktopManager.ActionInThisFrame = true;
}
}
if (m_lastLeftTouchClick != 0)
{
if (input.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad))
{
m_manager.SimulateMouseLeftUp();
m_lastLeftTouchClick = 0;
VdmDesktopManager.ActionInThisFrame = true;
}
}
if (m_lastRightTouchClick != 0)
{
if (input.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad))
{
m_manager.SimulateMouseRightUp();
m_lastRightTouchClick = 0;
VdmDesktopManager.ActionInThisFrame = true;
}
}
}
}
if ((Visible() == false) || (hitScreen))
{
if (input.GetPressDown(MyButtonToViveButton(m_manager.ViveShow)))
{
if (m_lastShowClick == 0)
{
VdmDesktopManager.ActionInThisFrame = true;
if (hitScreen == false)
{
Show();
// Don't set m_positionNormal.
Vector3 startDistance = controller.transform.rotation * new Vector3(0, 0, m_manager.ControllerZoomDistance);
transform.position = controller.transform.position + startDistance;
transform.rotation = controller.transform.rotation;
m_lastShowClick = Time.time - 10;
}
else
{
m_lastShowClick = Time.time;
}
transform.SetParent(controller.transform);
m_controllerAttach = true;
}
}
}
if (input.GetPressUp(MyButtonToViveButton(m_manager.ViveShow)))
{
if (m_lastShowClick != 0)
{
if (Time.time - m_lastShowClick < 0.5f)
{
Hide();
}
VdmDesktopManager.ActionInThisFrame = true;
m_lastShowClick = 0;
transform.SetParent(m_manager.transform);
m_controllerAttach = false;
m_positionNormal = transform.position;
m_rotationNormal = transform.rotation;
}
}
}
public override void Haptic(float Time)
{
SteamVR_Controller.Input((int)m_trackedController.controllerIndex).TriggerHapticPulse((ushort)(Time * 1000));
}
protected void InitDevice()
{
m_device = SteamVR_Controller.Input((int)m_tracked.index);
}
private void Update()
{
if (m_deviceController)
{
//Renew Objects
m_lineManager.Renew();
m_rodManagement.Renew();
//Rod Controll
SteamVR_Controller.Device device = SteamVR_Controller.Input((int)m_deviceController.index);
m_currentForce = m_lineManager.Spring.currentForce;
if (reelModel)
{
reelModel.localEulerAngles =
new Vector3(
0f,
0f,
reelModel.localEulerAngles.z + m_controllerClass.ReelAngularVelocity
);
}
//釣り竿の投げに関する処理
if (m_releaseTriger)
{
//投げた直後
if (m_threadLength == float.PositiveInfinity)
{
//着水したら
if (m_lineManager.FishingHook.transform.position.y <= 0f || m_lineManager.FishingHookInstance.IsCollision)
{
m_lineManager.Spring.spring = 100000000f;
m_threadLength = (
m_lineManager.Spring.transform.position -
m_lineManager.FishingHook.transform.position).magnitude;
m_lineManager.Spring.maxDistance = m_threadLength;
if (m_lineManager.FishingHookInstance)
{
m_lineManager.FishingHookInstance.IsFishing = true;
}
GameManagement.main.startFIshing();
Debug.Log(m_threadLength + " meter");
}
//ルアー着水後
}
else
{
float value = m_controllerClass.ReelAngularVelocity;
float reelSpd = 0.0025f;
if (m_threadLength <= 0f)
{
GameManagement.main.standby();
m_lineManager.FishingHookInstance.IsFishing = false;
}
if (GameManagement.main.gamePhase == GameManagement.GamePhase.ExpireYarn)
{
reelSpd = 0.02f;
}
if (value > 0.1f)
{
m_threadLength -= value * reelSpd;
}
GUITextLog.main.println(m_threadLength + "m");
GUITextLog.main.println(m_lineManager.Spring.currentForce.magnitude + "");
//gui_debug_3dLine.main.draw( m_lineManager.FishingHook.position, m_lineManager.FishingHook.position + m_lineManager.Spring.currentForce );
if (m_threadLength <= 0f)
{
//ゲームクリア処理
if (m_lineManager.FishingHookInstance.GetFish)
{
Vehicle.Boat.main.hangFish(m_lineManager.FishingHookInstance.GetFish);
m_lineManager.FishingHookInstance.GetFish.DeleteFish();
GameManagement.main.getFish();
}
returnLure();
}
if (m_threadLength > 8f && Random.Range(0f, 1f) <= 0.05f && m_lineManager.FishingHookInstance.GetFish)
{
Ray ray = new Ray(RodTip.position, m_lineManager.FishingHook.position - RodTip.position);
RaycastHit _Hit;
if (Physics.Raycast(ray, out _Hit, 500f, (int)Mathf.Pow(2, LayerMask.NameToLayer("Water"))))
{
GameObject obj = Instantiate(GameManagement.main.effect_Splash);
obj.transform.position = ray.origin + ray.direction.normalized * _Hit.distance;
Destroy(obj, 3f);
}
}
//Debug.Log(value);
m_lineManager.Spring.maxDistance = m_threadLength;
}
}
else
{
m_lineManager.Spring.maxDistance = 0f;
}
/*
* //Debug
* if(m_lineManager.FishingHookInstance.IsFishing)
* gui_debug_3dLine.main.setColor(Color.cyan);
* else
* gui_debug_3dLine.main.setColor(Color.red);
*
* gui_debug_3dLine.main.draw(Float.transform.position,Float.transform.position + Vector3.up * 500f);
*/
}
else
{
if (m_controllerClass && m_controllerClass.ControllerTracker)
{
m_deviceController =
m_controllerClass.ControllerTracker;
StartCoroutine(C_Vibration());
StartCoroutine(C_CheckThrowRod());
}
}
}
public void Start()
{
Device = SteamVR_Controller.Input((int)Controller.controllerIndex);
}
//釣り竿の投げ判定
private IEnumerator C_CheckThrowRod()
{
yield return(new WaitForSeconds(1f));
bool isApproaching = false;
float old_dot = float.NaN;
float throwAngle = 45f;
Vector3 throwVector =
Quaternion.Euler(-throwAngle, 0f, 0f) * Vector3.forward;
SteamVR_Controller.Device device = SteamVR_Controller.Input((int)m_deviceController.index);
Rigidbody rodRb = m_rodManagement.RodPartsList[1].GetComponent <Rigidbody>();
while (true)
{
if (!m_releaseTriger && GameManagement.main.gamePhase < GameManagement.GamePhase.GetFish)
{
float ang = 0f;
if (transform.up.y < 0.3f)
{
ang = Mathf.Atan2(-transform.up.x, -transform.up.z) * Mathf.Rad2Deg;
}
else
{
ang = Mathf.Atan2(transform.forward.x, transform.forward.z) * Mathf.Rad2Deg;
if (transform.position.y < transform.position.y - transform.up.y)
{
ang += 180f;
}
}
GUITextLog.main.println(transform.up.y + "");
throwVector =
Quaternion.Euler(-throwAngle, ang, 0f) * Vector3.forward;
Vector3 vel = m_lineManager.FishingHook.velocity;
//gui_debug_3dLine.main.draw(transform.position,transform.position + throwVector);
float dot = Vector3.Dot(throwVector, vel.normalized);
GUITextLog.main.println("" + rodRb.angularVelocity.x);
if (
rodRb.angularVelocity.x > 0.1f
)
{
if (
old_dot != float.NaN &&
dot > 0.5f &&
vel.magnitude > 12f
)
{
if (isApproaching)
{
vel += Camera.main.transform.forward;
m_lineManager.FishingHook.velocity += throwVector * vel.magnitude;
m_lineManager.FishingHook.velocity /= 2f;
m_releaseTriger = true;
Debug.Log(vel.magnitude);
releaseLure();
}
}
}
if (old_dot > dot)
{
isApproaching = true;
}
else
{
isApproaching = false;
}
old_dot = dot;
if (device.GetPressUp(SteamVR_Controller.ButtonMask.Trigger))
{
Debug.Log(vel.magnitude + "");
if (vel.magnitude > 8f)
{
releaseLure();
}
}
else
{
}
}
/*
* gui_debug_3dLine.main.setColor(Color.red);
* gui_debug_3dLine.main.draw(
* transform.position,
* transform.position + throwVector
* );
*
* gui_debug_3dLine.main.setColor(Color.blue);
* gui_debug_3dLine.main.draw(
* transform.position,
* transform.position + transform.forward
* );
*
* Debug.Log(Vector3.Dot(throwVector,transform.forward));
*/
yield return(new WaitForFixedUpdate());
}
}
private void SetDeviceIndex(int index)
{
DeviceIndex = index;
Controller = SteamVR_Controller.Input(index);
StartCoroutine(DoInitialize());
}
private bool IsTriggerPressed()
{
return(SteamVR_Controller.Input((int)RightController.index).GetPressDown(EVRButtonId.k_EButton_SteamVR_Trigger));
}
// Update is called once per frame
void Update()
{
device = SteamVR_Controller.Input((int)controller.index);
if (device.GetTouchDown(SteamVR_Controller.ButtonMask.Touchpad))
{
//load new scene
//SteamVR_LoadLevel.Begin("Teleport");
//reset position of finger to 0, 0 (I think)
touchLast_x = device.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad).x;
touchLast_y = device.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad).y;
}
//detect when our user is toucing the touchpad
if (device.GetTouch(SteamVR_Controller.ButtonMask.Touchpad))
{
objMenu.SetActive(true);
touchCurrent_x = device.GetAxis(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad).x;
//how much did the finger move this frame?
distance_x = touchCurrent_x - touchLast_x;
//cache our fingers location so we know where it was last frame
touchLast_x = touchCurrent_x;
//add the distance travelled to the swipeSum variable
swipeSum_x += distance_x;
if (!hasSwipedRight)
{
if (swipeSum_x > 0.5f)
{
swipeSum_x = 0;
SwipeLeft();
hasSwipedRight = true;
hasSwipedLeft = false;
}
}
if (!hasSwipedLeft)
{
if (swipeSum_x < -0.5f)
{
swipeSum_x = 0;
SwipeRight();
hasSwipedLeft = true;
hasSwipedRight = false;
}
}
}
if (device.GetTouchUp(SteamVR_Controller.ButtonMask.Touchpad))
{
objMenu.SetActive(false);
swipeSum_x = 0;
touchCurrent_x = 0;
touchLast_x = 0;
hasSwipedLeft = false;
hasSwipedRight = false;
}
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
//spawn object currently selected by menu
SpawnObject();
//objectMenuManager.SpawnCurrentObject();
}
if (device.GetPressDown(SteamVR_Controller.ButtonMask.Grip))
{
objectMenuManager.DestroyObject();
}
}
private void Update()
{
foreach (int current in this.controllerIndices)
{
SteamVR_Overlay instance = SteamVR_Overlay.instance;
if (instance && this.point && this.pointer)
{
SteamVR_Utils.RigidTransform transform = SteamVR_Controller.Input(current).transform;
this.pointer.transform.localPosition = transform.pos;
this.pointer.transform.localRotation = transform.rot;
SteamVR_Overlay.IntersectionResults intersectionResults = default(SteamVR_Overlay.IntersectionResults);
bool flag = instance.ComputeIntersection(transform.pos, transform.rot * Vector3.forward, ref intersectionResults);
if (flag)
{
this.point.transform.localPosition = intersectionResults.point;
this.point.transform.localRotation = Quaternion.LookRotation(intersectionResults.normal);
}
}
else
{
EVRButtonId[] array = this.buttonIds;
for (int i = 0; i < array.Length; i++)
{
EVRButtonId eVRButtonId = array[i];
if (SteamVR_Controller.Input(current).GetPressDown(eVRButtonId))
{
Debug.Log(eVRButtonId + " press down");
}
if (SteamVR_Controller.Input(current).GetPressUp(eVRButtonId))
{
Debug.Log(eVRButtonId + " press up");
if (eVRButtonId == EVRButtonId.k_EButton_Axis1)
{
SteamVR_Controller.Input(current).TriggerHapticPulse(500, EVRButtonId.k_EButton_Axis0);
this.PrintControllerStatus(current);
}
}
if (SteamVR_Controller.Input(current).GetPress(eVRButtonId))
{
Debug.Log(eVRButtonId);
}
}
EVRButtonId[] array2 = this.axisIds;
for (int j = 0; j < array2.Length; j++)
{
EVRButtonId eVRButtonId2 = array2[j];
if (SteamVR_Controller.Input(current).GetTouchDown(eVRButtonId2))
{
Debug.Log(eVRButtonId2 + " touch down");
}
if (SteamVR_Controller.Input(current).GetTouchUp(eVRButtonId2))
{
Debug.Log(eVRButtonId2 + " touch up");
}
if (SteamVR_Controller.Input(current).GetTouch(eVRButtonId2))
{
Vector2 axis = SteamVR_Controller.Input(current).GetAxis(eVRButtonId2);
Debug.Log("axis: " + axis);
}
}
}
}
}
