private void OnNewPoses(params object[] args)
{
var i = (int)index;
isValid = false;
var poses = (Valve.VR.TrackedDevicePose_t[])args[0];
if (poses.Length <= i)
return;
if (!poses[i].bDeviceIsConnected)
return;
if (!poses[i].bPoseIsValid)
return;
isValid = true;
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
if (origin != null)
{
pose = new SteamVR_Utils.RigidTransform(origin) * pose;
pose.pos.x *= origin.localScale.x;
pose.pos.y *= origin.localScale.y;
pose.pos.z *= origin.localScale.z;
transform.position = pose.pos;
transform.rotation = pose.rot;
}
else
{
transform.localPosition = pose.pos;
transform.localRotation = pose.rot;
}
}
private SteamVR()
{
hmd = OpenVR.System;
Debug.Log("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber);
compositor = OpenVR.Compositor;
overlay = OpenVR.Overlay;
// Setup render values
uint w = 0, h = 0;
hmd.GetRecommendedRenderTargetSize(ref w, ref h);
sceneWidth = (float)w;
sceneHeight = (float)h;
float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f;
hmd.GetProjectionRaw(EVREye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom);
float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f;
hmd.GetProjectionRaw(EVREye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom);
tanHalfFov = new Vector2(
Mathf.Max(-l_left, l_right, -r_left, r_right),
Mathf.Max(-l_top, l_bottom, -r_top, r_bottom));
textureBounds = new VRTextureBounds_t[2];
textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.x;
textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.x;
textureBounds[0].vMin = 0.5f - 0.5f * l_bottom / tanHalfFov.y;
textureBounds[0].vMax = 0.5f - 0.5f * l_top / tanHalfFov.y;
textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.x;
textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.x;
textureBounds[1].vMin = 0.5f - 0.5f * r_bottom / tanHalfFov.y;
textureBounds[1].vMax = 0.5f - 0.5f * r_top / tanHalfFov.y;
// Grow the recommended size to account for the overlapping fov
sceneWidth = sceneWidth / Mathf.Max(textureBounds[0].uMax - textureBounds[0].uMin, textureBounds[1].uMax - textureBounds[1].uMin);
sceneHeight = sceneHeight / Mathf.Max(textureBounds[0].vMax - textureBounds[0].vMin, textureBounds[1].vMax - textureBounds[1].vMin);
aspect = tanHalfFov.x / tanHalfFov.y;
fieldOfView = 2.0f * Mathf.Atan(tanHalfFov.y) * Mathf.Rad2Deg;
eyes = new SteamVR_Utils.RigidTransform[] {
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Left)),
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Right)) };
if (SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL"))
graphicsAPI = EGraphicsAPIConvention.API_OpenGL;
else
graphicsAPI = EGraphicsAPIConvention.API_DirectX;
SteamVR_Utils.Event.Listen("initializing", OnInitializing);
SteamVR_Utils.Event.Listen("calibrating", OnCalibrating);
SteamVR_Utils.Event.Listen("out_of_range", OnOutOfRange);
SteamVR_Utils.Event.Listen("device_connected", OnDeviceConnected);
SteamVR_Utils.Event.Listen("new_poses", OnNewPoses);
}
public void UpdateOverlay(SteamVR vr)
{
if (texture != null)
{
var settings = new Compositor_OverlaySettings();
settings.size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(Compositor_OverlaySettings));
settings.curved = curved;
settings.antialias = antialias;
settings.scale = scale;
settings.distance = distance;
settings.alpha = alpha;
settings.uOffset = uvOffset.x;
settings.vOffset = uvOffset.y;
settings.uScale = uvOffset.z;
settings.vScale = uvOffset.w;
settings.gridDivs = gridDivs;
settings.gridWidth = gridWidth;
settings.gridScale = gridScale;
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
settings.transform = offset.ToHmdMatrix44();
// The overlay transform is always rendered in standing space, so we transform it here
// to seated space when using the seated universe origin in Unity.
if (SteamVR_Render.instance.trackingSpace == TrackingUniverseOrigin.TrackingUniverseSeated)
{
var seated = vr.hmd.GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
offset = new SteamVR_Utils.RigidTransform(seated) * offset;
settings.transform = offset.ToHmdMatrix44();
}
}
vr.compositor.SetOverlay(texture.GetNativeTexturePtr(), ref settings);
}
else
{
vr.compositor.ClearOverlay();
}
}
private void OnSteamVrPose(params object[] args)
{
var i = (int)OpenVR.k_unTrackedDeviceIndex_Hmd;
var poses = (TrackedDevicePose_t[])args[0];
if (poses.Length <= i)
return;
if (!poses[i].bDeviceIsConnected)
return;
if (!poses[i].bPoseIsValid)
return;
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
_currentOvrRotation = pose.rot;
}
public void OrientateOverlay()
{
Quaternion rot = Quaternion.Euler(Vector3.Project(HMD.hmd.transform.rotation.eulerAngles, Vector3.up));
transform.position = HMD.hmd.transform.localPosition + rot * Vector3.forward * 3.5f;
Vector3 Pos = transform.position;
Pos.y = HMD.hmd.transform.position.y;
transform.rotation = Quaternion.LookRotation(HMD.hmd.transform.forward);//Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(-HMD.hmd.transform.forward), 0.2f);
transform.rotation = Quaternion.Euler(0f, transform.rotation.eulerAngles.y, 0f);
transform.position = Pos;
//var offset = new SteamVR_Utils.RigidTransform(HMD.hmd.transform, transform);
//var t = offset.ToHmdMatrix34();
var t = new SteamVR_Utils.RigidTransform(transform).ToHmdMatrix34();
OpenVR.Overlay.SetOverlayTransformAbsolute(overlayHandle, SteamVR.settings.trackingSpace, ref t);
}
public void UpdateState(SteamVR_Utils.RigidTransform pose, SteamVR_Controller.Device state)
{
// position the controller object
transform.position = Scene.DevicePoseToWorld(pose.pos);
transform.rotation = Scene.DevicePoseToWorld(pose.rot);
// set the layer to render to
gameObject.layer = Scene.RenderLayer;
// update individual manipulator states (hand controls)
if (role == ETrackedControllerRole.LeftHand)
{
UpdateStateLeft(pose, state);
}
else if (role == ETrackedControllerRole.RightHand)
{
UpdateStateRight(pose, state);
}
else
{
throw new Exception("Unsupported controller role: " + role);
}
}
private void OnSteamVrPose(TrackedDevicePose_t[] poses)
{
var i = (int)OpenVR.k_unTrackedDeviceIndex_Hmd;
if (poses.Length <= i)
{
return;
}
if (!poses[i].bDeviceIsConnected)
{
return;
}
if (!poses[i].bPoseIsValid)
{
return;
}
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
_ovrRot = pose.rot;
}
private void SendTrackingEvents(int steamDeviceIndex, int deviceIndex, TrackedDevicePose_t[] poses)
{
var pose = new SteamVR_Utils.RigidTransform(poses[steamDeviceIndex].mDeviceToAbsoluteTracking);
var localPosition = pose.pos;
var localRotation = pose.rot;
if (localPosition == m_LastPositionValues[steamDeviceIndex] && localRotation == m_LastRotationValues[steamDeviceIndex])
{
return;
}
var inputEvent = InputSystem.CreateEvent <VREvent>();
inputEvent.deviceType = typeof(VRInputDevice);
inputEvent.deviceIndex = deviceIndex;
inputEvent.localPosition = localPosition;
inputEvent.localRotation = localRotation;
m_LastPositionValues[steamDeviceIndex] = inputEvent.localPosition;
m_LastRotationValues[steamDeviceIndex] = inputEvent.localRotation;
InputSystem.QueueEvent(inputEvent);
}
private void OnDevicePosesReady(TrackedDevicePose_t[] devicePoses)
{
// detect devices that have (dis)connected
for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
bool isConnected = devicePoses[i].bDeviceIsConnected;
if (isDeviceConnected[i] != isConnected)
{
SteamVR_Events.DeviceConnected.Send((int)i, isConnected);
}
isDeviceConnected[i] = isConnected;
}
// update poses for tracked devices
SteamVR_Controller.Update();
// update Manipulator objects' state
if (DeviceIndexIsValid(ControllerIndexLeft))
{
SteamVR_Utils.RigidTransform controllerPose = new SteamVR_Utils.RigidTransform(
devicePoses[ControllerIndexLeft].mDeviceToAbsoluteTracking);
SteamVR_Controller.Device controllerState =
SteamVR_Controller.Input((int)ControllerIndexLeft);
ManipulatorLeft.GetComponent <Manipulator>().UpdateState(controllerPose, controllerState);
}
if (DeviceIndexIsValid(ControllerIndexRight))
{
SteamVR_Utils.RigidTransform controllerPose = new SteamVR_Utils.RigidTransform(
devicePoses[ControllerIndexRight].mDeviceToAbsoluteTracking);
SteamVR_Controller.Device controllerState =
SteamVR_Controller.Input((int)ControllerIndexRight);
ManipulatorRight.GetComponent <Manipulator>().UpdateState(controllerPose, controllerState);
}
}
/// <summary>
/// Update the Overlay's Position and return the resulting HmdMatrix34_t
/// </summary>
/// <returns></returns>
private HmdMatrix34_t GetOverlayPosition()
{
if (OverlayReference == null)
{
OverlayReference = new GameObject("Overlay Reference")
{
hideFlags = HideFlags.HideInHierarchy
}
}
;
if (_anchor == OpenVR.k_unTrackedDeviceIndexInvalid)
{
var offset = new SteamVR_Utils.RigidTransform(OverlayReference.transform, transform);
offset.pos.x /= OverlayReference.transform.localScale.x;
offset.pos.y /= OverlayReference.transform.localScale.y;
offset.pos.z /= OverlayReference.transform.localScale.z;
var t = offset.ToHmdMatrix34();
return(t);
}
else
{
if (ZeroReference == null)
{
ZeroReference = new GameObject("Zero Reference")
{
hideFlags = HideFlags.HideInHierarchy
}
}
;
var offset = new SteamVR_Utils.RigidTransform(ZeroReference.transform, OverlayReference.transform);
offset.pos.x /= ZeroReference.transform.localScale.x;
offset.pos.y /= ZeroReference.transform.localScale.y;
offset.pos.z /= ZeroReference.transform.localScale.z;
var t = offset.ToHmdMatrix34();
return(t);
}
}
private void OnNewPoses(TrackedDevicePose_t[] poses)
{
int index = HandType == Hand.LEFT ? HI5_BindInfoManager.LeftID : HI5_BindInfoManager.RightID;
if (index == -1)
{
return;
}
if (poses.Length <= index)
{
return;
}
if (!poses[index].bDeviceIsConnected)
{
return;
}
if (!poses[index].bPoseIsValid)
{
return;
}
var pose = new SteamVR_Utils.RigidTransform(poses[index].mDeviceToAbsoluteTracking);
Vector3 pos = pose.pos;
Quaternion rot = pose.rot;
if (m_Status.Status != GloveStatus.NoGlove &&
m_Status.Status != GloveStatus.NoDongle &&
HI5_Manager.IsDongleAvailable() &&
HI5_Manager.IsHasDongle)
{
ApplyHandMotion_Position(pos, rot);
}
}
void UpdateTrackedObj()
{
TrackedDevicePose_t[] allPoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
_vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, allPoses);
for (int i = 0; i < _validDeviceIds.Count; i++)
{
if (i < targetObjs.Length)
{
var pose = allPoses[_validDeviceIds[i]];
var absTracking = pose.mDeviceToAbsoluteTracking;
var mat = new SteamVR_Utils.RigidTransform(absTracking);
if (origin != null)
{
targetObjs[i].transform.SetPositionAndRotation(origin.TransformPoint(mat.pos), origin.rotation * mat.rot);
}
else
{
targetObjs[i].transform.SetPositionAndRotation(mat.pos, mat.rot);
}
}
}
}
// --------------------- OTHER ---------------------
private void UpdateTrackedDevicePositions()
{
if (!isConnected)
{
return;
}
if (OpenVR.Compositor == null)
{
return;
}
OpenVR.Compositor.GetLastPoses(poses, gamePoses);
if (leftHandIndex != OpenVR.k_unTrackedDeviceIndexInvalid && poses.Length > leftHandIndex)
{
var lPose = new SteamVR_Utils.RigidTransform(poses[leftHandIndex].mDeviceToAbsoluteTracking);
lHandTrans.transform.position = lPose.pos;
lHandTrans.transform.rotation = lPose.rot;
}
if (rightHandIndex != OpenVR.k_unTrackedDeviceIndexInvalid && poses.Length > rightHandIndex)
{
var rPose = new SteamVR_Utils.RigidTransform(poses[rightHandIndex].mDeviceToAbsoluteTracking);
rHandTrans.transform.position = rPose.pos;
rHandTrans.transform.rotation = rPose.rot;
}
if (poses.Length > hmdIndex)
{
var hmdPose = new SteamVR_Utils.RigidTransform(poses[hmdIndex].mDeviceToAbsoluteTracking);
hmdTrans.position = hmdPose.pos;
hmdTrans.rotation = hmdPose.rot;
}
}
//指定されたdeviceが有効かチェックした上で、オーバーレイと交点を持つかチェック
private bool checkRay(uint idx, TrackedDevicePose_t[] allDevicePose, ref VROverlayIntersectionResults_t results)
{
#pragma warning disable 0219
string Tag = "[" + this.GetType().Name + ":" + System.Reflection.MethodBase.GetCurrentMethod(); //クラス名とメソッド名を自動取得
#pragma warning restore 0219
//device indexが有効
if (idx != OpenVR.k_unTrackedDeviceIndexInvalid)
{
//接続されていて姿勢情報が有効
if (allDevicePose[idx].bDeviceIsConnected && allDevicePose[idx].bPoseIsValid)
{
//姿勢情報などを変換してもらう
TrackedDevicePose_t Pose = allDevicePose[idx];
SteamVR_Utils.RigidTransform Trans = new SteamVR_Utils.RigidTransform(Pose.mDeviceToAbsoluteTracking);
//コントローラー用に45度前方に傾けた方向ベクトルを計算
Vector3 vect = (Trans.rot * Quaternion.AngleAxis(45, Vector3.right)) * Vector3.forward;
return(ComputeOverlayIntersection(Trans.pos, vect, ref results));
}
}
return(false);
}
/// <summary>
/// Get the lighthouse positions from SteamVR.
/// </summary>
void OnNewPoses(TrackedDevicePose_t[] poses)
{
ready = false;
// Need at least three slots
if (poses.Length < 3)
{
return;
}
var system = OpenVR.System;
if (system == null)
{
return;
}
int index = 0;
for (int i = 0; i < poses.Length && index < 2; ++i)
{
if (!poses[i].bDeviceIsConnected || !poses[i].bPoseIsValid)
{
continue;
}
// Filter lighthouses
if (system.GetTrackedDeviceClass((uint)i) == ETrackedDeviceClass.TrackingReference)
{
lighthouses[index++] =
new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking).pos;
}
}
ready = index == 2;
}
void _getPose()
{
lock (thisLock)
{
while (!workFinished)
{
TrackedDevicePose_t[]
allPoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, allPoses);
var pose = allPoses[0];
if (pose.bPoseIsValid)
{
var absTracking = pose.mDeviceToAbsoluteTracking;
var mat = new SteamVR_Utils.RigidTransform(absTracking);
Debug.Log("Position: " + mat.pos + " Rotation: " + mat.rot.eulerAngles);
dataManager.AddHeadPos(0.0f, mat.pos, mat.rot.eulerAngles);
}
}
if (workFinished)
{
dataManager.WriteHeadPosData();
}
}
}
private void OnNewPoses(TrackedDevicePose_t[] poses)
{
if (!HI5_Calibration.IsCalibratingBPose)
{
return;
}
if (_deviceType == OPTDeviceType.Unknown)
{
return;
}
if (IsNullOrEmpty(_deviceSerialNumber))
{
return;
}
if (_deviceIndex <= (int)SteamVR_TrackedObject.EIndex.Hmd)
{
return;
}
if (!_steamVrTrackedObject.isValid)
{
return;
}
if (poses[_deviceIndex].eTrackingResult != ETrackingResult.Running_OK)
{
return;
}
var pose = new SteamVR_Utils.RigidTransform(poses[_deviceIndex].mDeviceToAbsoluteTracking);
ExportOpticalData(pose);
}
/// <summary>
/// On LateUpdate, dispatch OpenVR events, run the main HMD loop code.
/// </summary>
private void LateUpdate()
{
// dispatch any OpenVR events
if (hmdState == HmdState.Initialized)
{
DispatchOpenVREvents();
}
// check if the current scene allows VR
HmdIsAllowed = Scene.Instance.SceneAllowsVR();
// process the state of OpenVR
ProcessHmdState();
// check if we are running the HMD
HmdIsRunning = HmdIsAllowed && (hmdState == HmdState.Initialized) && HmdIsEnabled;
// perform regular updates if HMD is initialized
if (HmdIsRunning)
{
EVRCompositorError vrCompositorError = EVRCompositorError.None;
// we've just started VR
if (!hmdIsRunningPrev)
{
Utils.Log("HMD is now on");
Scene.Instance.SetupScene();
ResetInitialHmdPosition();
}
try {
// get latest device poses, emit an event to indicate devices have been updated
float secondsToPhotons = Utils.CalculatePredictedSecondsToPhotons();
OpenVR.System.GetDeviceToAbsoluteTrackingPose(Scene.Instance.TrackingSpace, secondsToPhotons, devicePoses);
SteamVR_Events.NewPoses.Send(devicePoses);
HmdMatrix34_t vrLeftEyeTransform = OpenVR.System.GetEyeToHeadTransform(EVREye.Eye_Left);
HmdMatrix34_t vrRightEyeTransform = OpenVR.System.GetEyeToHeadTransform(EVREye.Eye_Right);
vrCompositorError = OpenVR.Compositor.WaitGetPoses(renderPoses, gamePoses);
if (vrCompositorError != EVRCompositorError.None)
{
throw new Exception("WaitGetPoses failed: (" + (int)vrCompositorError + ") " + vrCompositorError.ToString());
}
// convert SteamVR poses to Unity coordinates
var hmdTransform = new SteamVR_Utils.RigidTransform(devicePoses[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking);
SteamVR_Utils.RigidTransform[] hmdEyeTransform = new SteamVR_Utils.RigidTransform[2];
hmdEyeTransform[0] = new SteamVR_Utils.RigidTransform(vrLeftEyeTransform);
hmdEyeTransform[1] = new SteamVR_Utils.RigidTransform(vrRightEyeTransform);
// don't highlight parts with the mouse
Mouse.HoveredPart = null;
// render each eye
for (int i = 0; i < 2; i++)
{
RenderHmdCameras(
(EVREye)i,
hmdTransform,
hmdEyeTransform[i],
hmdEyeRenderTexture[i],
hmdEyeTexture[i]);
}
// [insert dark magic here]
OpenVR.Compositor.PostPresentHandoff();
// render to the game screen
if (RenderHmdToScreen)
{
Graphics.Blit(hmdEyeRenderTexture[0], null as RenderTexture);
}
} catch (Exception e) {
// shut off VR when an error occurs
Utils.LogError(e);
HmdIsEnabled = false;
HmdIsRunning = false;
}
}
// reset cameras when HMD is turned off
if (!HmdIsRunning && hmdIsRunningPrev)
{
Utils.Log("HMD is now off, resetting cameras...");
Scene.Instance.CloseScene();
// TODO: figure out why we can no longer manipulate the IVA camera in the regular game
}
#if DEBUG
// debug hooks
if (Input.GetKeyDown(KeyCode.Y))
{
// Utils.PrintAllCameras();
// Utils.PrintAllLayers();
Utils.PrintDebug();
// Utils.PrintFonts();
// Utils.PrintCollisionMatrix();
}
#endif
// keep track of whether we were running the HMD
hmdIsRunningPrev = HmdIsRunning;
}
private SteamVR(System.IntPtr pHmd, System.IntPtr pCompositor, System.IntPtr pOverlay)
{
hmd = new CVRSystem(pHmd);
Debug.Log("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber);
compositor = new CVRCompositor(pCompositor);
overlay = new CVROverlay(pOverlay);
var capacity = compositor.GetLastError(null, 0);
if (capacity > 1)
{
var result = new System.Text.StringBuilder((int)capacity);
compositor.GetLastError(result, capacity);
Debug.Log("Compositor - " + result);
}
// Hook up the render thread event.
var error = HmdError.None;
SetUnityRenderCallback(OpenVR.GetGenericInterface(IVRHmdDistortPresent_Version, ref error));
// Setup render values
uint w = 0, h = 0;
hmd.GetRecommendedRenderTargetSize(ref w, ref h);
sceneWidth = (float)w;
sceneHeight = (float)h;
float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f;
hmd.GetProjectionRaw(Hmd_Eye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom);
float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f;
hmd.GetProjectionRaw(Hmd_Eye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom);
tanHalfFov = new Vector2(
Mathf.Max(-l_left, l_right, -r_left, r_right),
Mathf.Max(-l_top, l_bottom, -r_top, r_bottom));
textureBounds = new VRTextureBounds_t[2];
textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.x;
textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.x;
textureBounds[0].vMin = 0.5f - 0.5f * l_bottom / tanHalfFov.y;
textureBounds[0].vMax = 0.5f - 0.5f * l_top / tanHalfFov.y;
textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.x;
textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.x;
textureBounds[1].vMin = 0.5f - 0.5f * r_bottom / tanHalfFov.y;
textureBounds[1].vMax = 0.5f - 0.5f * r_top / tanHalfFov.y;
// Grow the recommended size to account for the overlapping fov
sceneWidth = sceneWidth / Mathf.Max(textureBounds[0].uMax - textureBounds[0].uMin, textureBounds[1].uMax - textureBounds[1].uMin);
sceneHeight = sceneHeight / Mathf.Max(textureBounds[0].vMax - textureBounds[0].vMin, textureBounds[1].vMax - textureBounds[1].vMin);
aspect = tanHalfFov.x / tanHalfFov.y;
fieldOfView = 2.0f * Mathf.Atan(tanHalfFov.y) * Mathf.Rad2Deg;
eyes = new SteamVR_Utils.RigidTransform[] {
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(Hmd_Eye.Eye_Left)),
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(Hmd_Eye.Eye_Right))
};
if (SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL"))
{
graphicsAPI = GraphicsAPIConvention.API_OpenGL;
}
else
{
graphicsAPI = GraphicsAPIConvention.API_DirectX;
}
SteamVR_Utils.Event.Listen("initializing", OnInitializing);
SteamVR_Utils.Event.Listen("calibrating", OnCalibrating);
SteamVR_Utils.Event.Listen("out_of_range", OnOutOfRange);
SteamVR_Utils.Event.Listen("device_connected", OnDeviceConnected);
SteamVR_Utils.Event.Listen("new_poses", OnNewPoses);
}
public static SteamVR_Utils.RigidTransform Interpolate(SteamVR_Utils.RigidTransform a, SteamVR_Utils.RigidTransform b, float t)
{
return(new SteamVR_Utils.RigidTransform(Vector3.Lerp(a.pos, b.pos, t), Quaternion.Slerp(a.rot, b.rot, t)));
}
public SteamVR_Utils.RigidTransform GetInverse()
{
SteamVR_Utils.RigidTransform result = new SteamVR_Utils.RigidTransform(this.pos, this.rot);
result.Inverse();
return(result);
}
public void UpdateComponents()
{
Transform transform = base.transform;
if (transform.childCount == 0)
{
return;
}
using (SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
VRControllerState_t vRControllerState_t = (this.index == SteamVR_TrackedObject.EIndex.None) ? default(VRControllerState_t) : SteamVR_Controller.Input((int)this.index).GetState();
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
CVRRenderModels instance = renderModelInterfaceHolder.instance;
if (instance == null)
{
break;
}
RenderModel_ComponentState_t renderModel_ComponentState_t = default(RenderModel_ComponentState_t);
RenderModel_ControllerMode_State_t renderModel_ControllerMode_State_t = default(RenderModel_ControllerMode_State_t);
if (instance.GetComponentState(this.renderModelName, child.name, ref vRControllerState_t, ref renderModel_ControllerMode_State_t, ref renderModel_ComponentState_t))
{
SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentRenderModel);
child.localPosition = rigidTransform.pos;
child.localRotation = rigidTransform.rot;
Transform transform2 = child.FindChild("attach");
if (transform2 != null)
{
SteamVR_Utils.RigidTransform rigidTransform2 = new SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentLocal);
transform2.position = transform.TransformPoint(rigidTransform2.pos);
transform2.rotation = transform.rotation * rigidTransform2.rot;
}
bool flag = (renderModel_ComponentState_t.uProperties & 2u) != 0u;
if (flag != child.gameObject.activeSelf)
{
child.gameObject.SetActive(flag);
}
}
}
}
}
private void OnNewPoses(params object[] args)
{
if (index == EIndex.None)
{
return;
}
var i = (int)index;
isValid = false;
var poses = (Valve.VR.TrackedDevicePose_t[])args[0];
if (poses.Length <= i)
{
return;
}
if (!poses[i].bDeviceIsConnected)
{
return;
}
if (!poses[i].bPoseIsValid)
{
return;
}
isValid = true;
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
if (origin != null)
{
pose = new SteamVR_Utils.RigidTransform(origin) * pose;
pose.pos.x *= origin.localScale.x;
pose.pos.y *= origin.localScale.y;
pose.pos.z *= origin.localScale.z;
transform.position = pose.pos;
transform.rotation = pose.rot;
}
else
{
transform.localPosition = pose.pos + pose.rot * offset;
transform.localRotation = pose.rot * angles;
}
var vr = SteamVR.instance;
var isController = (vr.hmd.GetTrackedDeviceClass((uint)i) == ETrackedDeviceClass.Controller);
var state = new VRControllerState_t();
var success = vr.hmd.GetControllerState((uint)i, ref state);
var triggerPressed = (state.ulButtonPressed & SteamVR_Controller.ButtonMask.Trigger) != 0;
if (Time.time >= cooldown)
{
if (triggerPressed)
{
Debug.Log("trigger pressed");
GameObject bPrefab = Instantiate(bulletPrefab, pose.pos, pose.rot) as GameObject;
Rigidbody rb = bPrefab.AddComponent <Rigidbody>(); // Add the rigidbody.
rb.mass = 1; // Set the GO's mass to 5 via the Rigidbody.
rb.AddForce(pose.rot * Vector3.down * 3000f);
cooldown = Time.time + attackSpeed;
}
}
}
public void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
return;
if (texture != null)
{
var error = overlay.ShowOverlay(handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(key, ref handle) != EVROverlayError.None)
return;
}
var tex = new Texture_t();
tex.handle = texture.GetNativeTexturePtr();
tex.eType = SteamVR.instance.graphicsAPI;
tex.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(handle, ref tex);
overlay.SetOverlayAlpha(handle, alpha);
overlay.SetOverlayWidthInMeters(handle, scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(handle, curvedRange.x, curvedRange.y);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v0 = mouseScale.x;
vecMouseScale.v1 = mouseScale.y;
overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
offset.pos.z += distance;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
overlay.SetOverlayInputMethod(handle, inputMethod);
if (curved || antialias)
highquality = true;
if (highquality)
{
overlay.SetHighQualityOverlay(handle);
overlay.SetOverlayFlag(handle, VROverlayFlags.Curved, curved);
overlay.SetOverlayFlag(handle, VROverlayFlags.RGSS4X, antialias);
}
else if (overlay.GetHighQualityOverlay() == handle)
{
overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
overlay.HideOverlay(handle);
}
}
public void UpdateComponents()
{
var t = transform;
if (t.childCount == 0)
return;
using (var holder = new RenderModelInterfaceHolder())
{
var controllerState = (index != SteamVR_TrackedObject.EIndex.None) ?
SteamVR_Controller.Input((int)index).GetState() : new VRControllerState_t();
for (int i = 0; i < t.childCount; i++)
{
var child = t.GetChild(i);
var renderModels = holder.instance;
if (renderModels == null)
break;
var componentState = new RenderModel_ComponentState_t();
if (!renderModels.GetComponentState(renderModelName, child.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);
}
}
}
}
private void OnSteamVrPose(params object[] args)
{
var i = (int)OpenVR.k_unTrackedDeviceIndex_Hmd;
var poses = (TrackedDevicePose_t[])args[0];
if (poses.Length <= i)
return;
if (!poses[i].bDeviceIsConnected)
return;
if (!poses[i].bPoseIsValid)
return;
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
var prevRot = _ovrRot;
_ovrRot = pose.rot;
var deltaAngle = Quaternion.Angle(prevRot, _ovrRot);
HasSteadyOpenVrPose = (Mathf.Abs(deltaAngle) < SteadyAngleThreshold);
}
private void OnNewPoses(params object[] args)
{
if (index == EIndex.None || relativeToIndex == EIndex.None)
return;
var i = (int)index;
var relIndex = (int)relativeToIndex;
isValid = false;
var poses = (Valve.VR.TrackedDevicePose_t[])args[0];
if (poses.Length <= Math.Max(i, relIndex))
return;
if (!poses[i].bDeviceIsConnected || !poses[relIndex].bDeviceIsConnected)
return;
if (!poses[i].bPoseIsValid || !poses[relIndex].bPoseIsValid)
return;
isValid = true;
var relPose = new SteamVR_Utils.RigidTransform(poses[relIndex].mDeviceToAbsoluteTracking);
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
if (origin != null)
{
pose = new SteamVR_Utils.RigidTransform(origin) * pose;
pose.pos.x *= origin.localScale.x;
pose.pos.y *= origin.localScale.y;
pose.pos.z *= origin.localScale.z;
ApplyPose(relPose, pose);
}
else
{
ApplyPose(relPose, pose);
}
}
public DelayedPose(SteamVR_Utils.RigidTransform pose)
: this()
{
Pose = pose;
}
private SteamVR(System.IntPtr pHmd, System.IntPtr pCompositor)
{
hmd = new CVRSystem(pHmd);
Debug.Log("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber);
compositor = new CVRCompositor(pCompositor);
var device = new UnityGraphicsDevice();
GetUnityGraphicsDevice(ref device);
switch (device.type)
{
case GfxDeviceRenderer.kGfxRendererD3D11:
compositor.SetGraphicsDevice(Compositor_DeviceType.D3D11, device.ptr);
break;
case GfxDeviceRenderer.kGfxRendererOpenGL:
compositor.SetGraphicsDevice(Compositor_DeviceType.OpenGL, device.ptr);
break;
default:
throw new System.Exception("Unsupported device type.");
}
var capacity = compositor.GetLastError(null, 0);
if (capacity > 1)
{
var result = new System.Text.StringBuilder((int)capacity);
compositor.GetLastError(result, capacity);
Debug.Log("Compositor - " + result);
}
// Register for a callback if our graphics device goes away, so we can properly clean up.
var resetDelegate = new UnityResetDelegate(SteamVR.SafeDispose);
callbackHandle = GCHandle.Alloc(resetDelegate);
SetUnityResetCallback(Marshal.GetFunctionPointerForDelegate(resetDelegate));
// Hook up the render thread present event just in case we wind up needing to use this.
var error = HmdError.None;
SetUnityRenderCallback(OpenVR.GetGenericInterface(IVRHmdDistortPresent_Version, ref error));
// Setup render values
uint w = 0, h = 0;
hmd.GetRecommendedRenderTargetSize(ref w, ref h);
sceneWidth = (float)w;
sceneHeight = (float)h;
float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f;
hmd.GetProjectionRaw(Hmd_Eye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom);
float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f;
hmd.GetProjectionRaw(Hmd_Eye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom);
tanHalfFov = new Vector2(
Mathf.Max(-l_left, l_right, -r_left, r_right),
Mathf.Max(-l_top, l_bottom, -r_top, r_bottom));
textureBounds = new Compositor_TextureBounds[2];
textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.x;
textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.x;
textureBounds[0].vMin = 0.5f + 0.5f * l_bottom / tanHalfFov.y;
textureBounds[0].vMax = 0.5f + 0.5f * l_top / tanHalfFov.y;
textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.x;
textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.x;
textureBounds[1].vMin = 0.5f + 0.5f * r_bottom / tanHalfFov.y;
textureBounds[1].vMax = 0.5f + 0.5f * r_top / tanHalfFov.y;
aspect = tanHalfFov.x / tanHalfFov.y;
fieldOfView = 2.0f * Mathf.Atan(tanHalfFov.y) * Mathf.Rad2Deg;
eyes = new SteamVR_Utils.RigidTransform[] {
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(Hmd_Eye.Eye_Left)),
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(Hmd_Eye.Eye_Right)) };
SteamVR_Utils.Event.Listen("initializing", OnInitializing);
SteamVR_Utils.Event.Listen("calibrating", OnCalibrating);
SteamVR_Utils.Event.Listen("out_of_range", OnOutOfRange);
SteamVR_Utils.Event.Listen("device_connected", OnDeviceConnected);
SteamVR_Utils.Event.Listen("new_poses", OnNewPoses);
}
public static int GetDeviceIndex(SteamVR_Controller.DeviceRelation relation, ETrackedDeviceClass deviceClass = ETrackedDeviceClass.Controller, int relativeTo = 0)
{
int result = -1;
SteamVR_Utils.RigidTransform t = (relativeTo >= 64) ? SteamVR_Utils.RigidTransform.identity : SteamVR_Controller.Input(relativeTo).transform.GetInverse();
CVRSystem system = OpenVR.System;
if (system == null)
{
return(result);
}
float num = float.MinValue;
int num2 = 0;
while ((long)num2 < 64L)
{
if (num2 != relativeTo && system.GetTrackedDeviceClass((uint)num2) == deviceClass)
{
SteamVR_Controller.Device device = SteamVR_Controller.Input(num2);
if (device.connected)
{
if (relation == SteamVR_Controller.DeviceRelation.First)
{
return(num2);
}
Vector3 vector = t * device.transform.pos;
float num3;
if (relation == SteamVR_Controller.DeviceRelation.FarthestRight)
{
num3 = vector.x;
}
else if (relation == SteamVR_Controller.DeviceRelation.FarthestLeft)
{
num3 = -vector.x;
}
else
{
Vector3 vector2 = new Vector3(vector.x, 0f, vector.z);
Vector3 normalized = vector2.normalized;
float num4 = Vector3.Dot(normalized, Vector3.forward);
Vector3 vector3 = Vector3.Cross(normalized, Vector3.forward);
if (relation == SteamVR_Controller.DeviceRelation.Leftmost)
{
num3 = ((vector3.y <= 0f) ? num4 : (2f - num4));
}
else
{
num3 = ((vector3.y >= 0f) ? num4 : (2f - num4));
}
}
if (num3 > num)
{
result = num2;
num = num3;
}
}
}
num2++;
}
return(result);
}
/// <summary>
/// Push Updates to our Overlay to the OpenVR System
/// </summary>
private void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (OverlayTexture != null)
{
var error = overlay.ShowOverlay(_handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(Key, ref _handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t
{
handle = OverlayTexture.GetNativeTexturePtr(),
eType = SteamVR.instance.textureType,
eColorSpace = EColorSpace.Auto
};
overlay.SetOverlayColor(_handle, 1f, 1f, 1f);
//overlay.SetOverlayGamma(_handle, 2.2f); // Doesn't exist yet :(
overlay.SetOverlayTexture(_handle, ref tex);
overlay.SetOverlayAlpha(_handle, AnimateOnGaze == AnimationType.Alpha || AnimateOnGaze == AnimationType.AlphaAndScale ? _alpha : Alpha);
overlay.SetOverlayWidthInMeters(_handle, AnimateOnGaze == AnimationType.Scale || AnimateOnGaze == AnimationType.AlphaAndScale ? _scale : Scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(_handle, CurvedRange.x, CurvedRange.y);
var textureBounds = new VRTextureBounds_t
{
uMin = (0 + UvOffset.x) * UvOffset.z,
vMin = (1 + UvOffset.y) * UvOffset.w,
uMax = (1 + UvOffset.x) * UvOffset.z,
vMax = (0 + UvOffset.y) * UvOffset.w
};
overlay.SetOverlayTextureBounds(_handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t
{
v0 = MouseScale.x,
v1 = MouseScale.y
};
overlay.SetOverlayMouseScale(_handle, ref vecMouseScale);
if (_anchor != OpenVR.k_unTrackedDeviceIndexInvalid) // Attached to some HOTK_TrackedDevice, used for Controllers
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_handle, _anchor, ref t);
}
else if (AnchorDevice == MountDevice.World) // Attached to World
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformAbsolute(_handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else
{
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null) // Attached to Camera (We are Rendering)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(_handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else // Attached to Camera (We are Not Rendering)
{
var t = GetOverlayPosition();
overlay.SetOverlayTransformTrackedDeviceRelative(_handle, 0, ref t);
}
}
overlay.SetOverlayInputMethod(_handle, InputMethod);
if (Highquality)
{
if (HighQualityOverlay != this && HighQualityOverlay != null)
{
if (HighQualityOverlay.Highquality)
{
Debug.LogWarning("Only one Overlay can be in HighQuality mode as per the OpenVR API.");
HighQualityOverlay.Highquality = false;
}
HighQualityOverlay = this;
}
else if (HighQualityOverlay == null)
{
HighQualityOverlay = this;
}
overlay.SetHighQualityOverlay(_handle);
overlay.SetOverlayFlag(_handle, VROverlayFlags.Curved, Curved);
overlay.SetOverlayFlag(_handle, VROverlayFlags.RGSS4X, Antialias);
}
else if (overlay.GetHighQualityOverlay() == _handle)
{
overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
overlay.HideOverlay(_handle);
}
}
private void OnNewPoses(params object[] args)
{
// If our Tracked Type changes, we are no longer valid
if (_type != Type)
{
_type = Type;
IsValid = false;
}
// If we aren't valid, try and find our index
if (!IsValid)
{
Index = EIndex.None;
if (Type != EType.None)
{
switch (Type)
{
case EType.None:
return;
case EType.HMD:
if (HOTK_TrackedDeviceManager.Instance.HMDIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
{
Index = (EIndex)HOTK_TrackedDeviceManager.Instance.HMDIndex;
}
break;
case EType.LeftController:
if (HOTK_TrackedDeviceManager.Instance.LeftIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
{
Index = (EIndex)HOTK_TrackedDeviceManager.Instance.LeftIndex;
}
break;
case EType.RightController:
if (HOTK_TrackedDeviceManager.Instance.RightIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
{
Index = (EIndex)HOTK_TrackedDeviceManager.Instance.RightIndex;
}
break;
case EType.ThirdController:
if (HOTK_TrackedDeviceManager.Instance.ThirdIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
{
Index = (EIndex)HOTK_TrackedDeviceManager.Instance.ThirdIndex;
}
break;
case EType.FourthController:
if (HOTK_TrackedDeviceManager.Instance.FourthIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
{
Index = (EIndex)HOTK_TrackedDeviceManager.Instance.FourthIndex;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
//UpdateRenderModel();
}
// Check if our device is valid
IsValid = false;
if (Index == EIndex.None)
{
return; // This TrackedDevice is not set to track anything
}
var i = (int)Index;
var poses = (TrackedDevicePose_t[])args[0];
if (poses.Length <= i)
{
return; // SteamVR did not send poses this update
}
if (!poses[i].bDeviceIsConnected)
{
return; // SteamVR reports device has been disconnected or was never connected
}
if (!poses[i].bPoseIsValid)
{
return; // SteamVR reports device is not valid (not being tracked currently)
}
IsValid = true;
// Get our poses and change our position/rotation to match the device
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
if (Origin != null) // Our device is 'anchored' to something else in the scene
{
pose = new SteamVR_Utils.RigidTransform(Origin) * pose;
pose.pos.x *= Origin.localScale.x;
pose.pos.y *= Origin.localScale.y;
pose.pos.z *= Origin.localScale.z;
transform.position = pose.pos;
transform.rotation = pose.rot;
}
else // Our device is not attached to anything, use it's raw tracked position
{
transform.localPosition = pose.pos;
transform.localRotation = pose.rot;
}
}
private SteamVR()
{
hmd = OpenVR.System;
Debug.Log("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber);
compositor = OpenVR.Compositor;
overlay = OpenVR.Overlay;
// Setup render values
uint w = 0, h = 0;
hmd.GetRecommendedRenderTargetSize(ref w, ref h);
sceneWidth = (float)w;
sceneHeight = (float)h;
float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f;
hmd.GetProjectionRaw(EVREye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom);
float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f;
hmd.GetProjectionRaw(EVREye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom);
tanHalfFov = new Vector2(
Mathf.Max(-l_left, l_right, -r_left, r_right),
Mathf.Max(-l_top, l_bottom, -r_top, r_bottom));
textureBounds = new VRTextureBounds_t[2];
textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.x;
textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.x;
textureBounds[0].vMin = 0.5f - 0.5f * l_bottom / tanHalfFov.y;
textureBounds[0].vMax = 0.5f - 0.5f * l_top / tanHalfFov.y;
textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.x;
textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.x;
textureBounds[1].vMin = 0.5f - 0.5f * r_bottom / tanHalfFov.y;
textureBounds[1].vMax = 0.5f - 0.5f * r_top / tanHalfFov.y;
#if (UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
SteamVR.Unity.SetSubmitParams(textureBounds[0], textureBounds[1], EVRSubmitFlags.Submit_Default);
#endif
// Grow the recommended size to account for the overlapping fov
sceneWidth = sceneWidth / Mathf.Max(textureBounds[0].uMax - textureBounds[0].uMin, textureBounds[1].uMax - textureBounds[1].uMin);
sceneHeight = sceneHeight / Mathf.Max(textureBounds[0].vMax - textureBounds[0].vMin, textureBounds[1].vMax - textureBounds[1].vMin);
aspect = tanHalfFov.x / tanHalfFov.y;
fieldOfView = 2.0f * Mathf.Atan(tanHalfFov.y) * Mathf.Rad2Deg;
eyes = new SteamVR_Utils.RigidTransform[] {
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Left)),
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Right))
};
if (SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL"))
{
graphicsAPI = EGraphicsAPIConvention.API_OpenGL;
}
else
{
graphicsAPI = EGraphicsAPIConvention.API_DirectX;
}
SteamVR_Utils.Event.Listen("initializing", OnInitializing);
SteamVR_Utils.Event.Listen("calibrating", OnCalibrating);
SteamVR_Utils.Event.Listen("out_of_range", OnOutOfRange);
SteamVR_Utils.Event.Listen("device_connected", OnDeviceConnected);
SteamVR_Utils.Event.Listen("new_poses", OnNewPoses);
}
public void Init(SteamVR_Camera tracker, SteamVR.Hmd_Eye eye, float depth)
{
this.tracker = tracker;
this.eye = eye;
var hmd = SteamVR.IHmd.instance;
var i = (int)eye;
uint x = 0, y = 0, w = 0, h = 0;
hmd.GetEyeOutputViewport(eye, ref x, ref y, ref w, ref h);
overlaySettings.kernel = new Vector3[] { // AA sub-pixel sampling (2x2 RGSS)
new Vector3(0.125f / w, -0.375f / h, 0),
new Vector3(0.375f / w, 0.125f / h, 0),
new Vector3(-0.125f / w, 0.375f / h, 0),
new Vector3(-0.375f / w, -0.125f / h, 0)
};
float left = 0.0f, right = 0.0f, top = 0.0f, bottom = 0.0f;
hmd.GetProjectionRaw(eye, ref left, ref right, ref top, ref bottom);
var camera = GetComponent <Camera>();
float zFar = camera.farClipPlane;
float zNear = camera.nearClipPlane;
var m = Matrix4x4.identity;
float idx = 1.0f / (right - left);
float idy = 1.0f / (bottom - top);
float idz = 1.0f / (zFar - zNear);
float sx = right + left;
float sy = bottom + top;
m[0, 0] = 2 * idx; m[0, 1] = 0; m[0, 2] = sx * idx; m[0, 3] = 0;
m[1, 0] = 0; m[1, 1] = 2 * idy; m[1, 2] = sy * idy; m[1, 3] = 0;
m[2, 0] = 0; m[2, 1] = 0; m[2, 2] = -zFar * idz; m[2, 3] = -zFar * zNear * idz;
m[3, 0] = 0; m[3, 1] = 0; m[3, 2] = -1.0f; m[3, 3] = 0;
camera.projectionMatrix = m;
camera.depth = depth; // enforce rendering order
camera.eventMask = 0; // disable mouse events
camera.orthographic = false; // force perspective
camera.aspect = (float)w / h;
// Use fov of projection matrix (which is grown to account for non-linear undistort)
camera.fieldOfView = (Mathf.Atan(bottom) - Mathf.Atan(top)) * Mathf.Rad2Deg;
// Copy and clear clearFlags to avoid duplicate work.
if ((int)clearFlags == 0)
{
clearFlags = camera.clearFlags;
camera.clearFlags = CameraClearFlags.Nothing;
}
camera.targetTexture = SteamVR_Camera.sceneTexture;
overlaySettings.invProj = m.inverse;
transform.parent = tracker.offset;
transform.localScale = Vector3.one;
var t = new SteamVR_Utils.RigidTransform(hmd.GetHeadFromEyePose(eye));
transform.localPosition = t.pos;
transform.localRotation = t.rot;
if (distortMesh[i] == null)
{
var viewportWidth = SteamVR_Camera.viewportTexture.width;
var viewportHeight = SteamVR_Camera.viewportTexture.height;
var eyeViewport = new Rect(
2.0f * x / viewportWidth - 1.0f,
2.0f * y / viewportHeight - 1.0f,
2.0f * w / viewportWidth,
2.0f * h / viewportHeight);
distortMesh[i] = SteamVR_Utils.CreateDistortMesh(hmd, eye, 32, 32, eyeViewport);
}
}
public void ReadConfig()
{
try {
var mCam = new HmdMatrix34_t();
var readCamMatrix = false;
object c = config; // box
var lines = File.ReadAllLines(configPath);
foreach (var line in lines)
{
var split = line.Split('=');
if (split.Length == 2)
{
var key = split[0];
if (key == "m")
{
var values = split[1].Split(',');
if (values.Length == 12)
{
mCam.m0 = float.Parse(values[0]);
mCam.m1 = float.Parse(values[1]);
mCam.m2 = float.Parse(values[2]);
mCam.m3 = float.Parse(values[3]);
mCam.m4 = float.Parse(values[4]);
mCam.m5 = float.Parse(values[5]);
mCam.m6 = float.Parse(values[6]);
mCam.m7 = float.Parse(values[7]);
mCam.m8 = float.Parse(values[8]);
mCam.m9 = float.Parse(values[9]);
mCam.m10 = float.Parse(values[10]);
mCam.m11 = float.Parse(values[11]);
readCamMatrix = true;
}
}
else if (key == "disableStandardAssets")
{
var field = c.GetType().GetField(key);
if (field != null)
{
field.SetValue(c, bool.Parse(split[1]));
}
}
else
{
var field = c.GetType().GetField(key);
if (field != null)
{
field.SetValue(c, float.Parse(split[1]));
}
}
}
}
config = (Config)c; //unbox
// Convert calibrated camera matrix settings.
if (readCamMatrix)
{
var t = new SteamVR_Utils.RigidTransform(mCam);
config.x = t.pos.x;
config.y = t.pos.y;
config.z = t.pos.z;
var angles = t.rot.eulerAngles;
config.rx = angles.x;
config.ry = angles.y;
config.rz = angles.z;
}
} catch {
}
}
private void OnNewPoses(params object[] args)
{
if (index == EIndex.None)
return;
var i = (int)index;
isValid = false;
var poses = (Valve.VR.TrackedDevicePose_t[])args[0];
if (poses.Length <= i)
return;
if (!poses[i].bDeviceIsConnected)
return;
if (!poses[i].bPoseIsValid)
return;
isValid = true;
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
if (origin != null)
{
pose = new SteamVR_Utils.RigidTransform(origin) * pose;
pose.pos.x *= origin.localScale.x;
pose.pos.y *= origin.localScale.y;
pose.pos.z *= origin.localScale.z;
transform.position = pose.pos;
transform.rotation = pose.rot;
}
else
{
transform.localPosition = pose.pos + pose.rot*offset;
transform.localRotation = pose.rot*angles;
}
var vr = SteamVR.instance;
var isController = (vr.hmd.GetTrackedDeviceClass((uint)i) == ETrackedDeviceClass.Controller);
var state = new VRControllerState_t();
var success = vr.hmd.GetControllerState((uint)i, ref state);
var triggerPressed = (state.ulButtonPressed & SteamVR_Controller.ButtonMask.Trigger) != 0;
if (Time.time >= cooldown) {
if (triggerPressed) {
Debug.Log ("trigger pressed");
GameObject bPrefab = Instantiate(bulletPrefab, pose.pos, pose.rot) as GameObject;
Rigidbody rb = bPrefab.AddComponent<Rigidbody>(); // Add the rigidbody.
rb.mass = 1; // Set the GO's mass to 5 via the Rigidbody.
rb.AddForce (pose.rot*Vector3.down * 3000f);
cooldown = Time.time + attackSpeed;
}
}
}
public void ReadConfig()
{
try
{
var mCam = new HmdMatrix34_t();
var readCamMatrix = false;
object c = config; // box
var lines = System.IO.File.ReadAllLines(configPath);
foreach (var line in lines)
{
var split = line.Split('=');
if (split.Length == 2)
{
var key = split[0];
if (key == "m")
{
var values = split[1].Split(',');
if (values.Length == 12)
{
mCam.m0 = float.Parse(values[0]);
mCam.m1 = float.Parse(values[1]);
mCam.m2 = float.Parse(values[2]);
mCam.m3 = float.Parse(values[3]);
mCam.m4 = float.Parse(values[4]);
mCam.m5 = float.Parse(values[5]);
mCam.m6 = float.Parse(values[6]);
mCam.m7 = float.Parse(values[7]);
mCam.m8 = float.Parse(values[8]);
mCam.m9 = float.Parse(values[9]);
mCam.m10 = float.Parse(values[10]);
mCam.m11 = float.Parse(values[11]);
readCamMatrix = true;
}
}
else if (key == "disableStandardAssets")
{
var field = c.GetType().GetField(key);
if (field != null)
field.SetValue(c, bool.Parse(split[1]));
}
else
{
var field = c.GetType().GetField(key);
if (field != null)
field.SetValue(c, float.Parse(split[1]));
}
}
}
config = (Config)c; //unbox
// Convert calibrated camera matrix settings.
if (readCamMatrix)
{
var t = new SteamVR_Utils.RigidTransform(mCam);
config.x = t.pos.x;
config.y = t.pos.y;
config.z = t.pos.z;
var angles = t.rot.eulerAngles;
config.rx = angles.x;
config.ry = angles.y;
config.rz = angles.z;
}
}
catch { }
}
public void UpdateTracking()
{
var head = SteamVR_Utils.RigidTransform.identity;
if (!disableTracking)
{
var hmd = SteamVR.IHmd.instance;
var pose = new SteamVR.HmdMatrix34_t();
if (Time.renderedFrameCount != renderedFrameCount)
{
renderedFrameCount = Time.renderedFrameCount;
var result = SteamVR.HmdTrackingResult.TrackingResult_Uninitialized;
if (hmd.GetTrackerFromHeadPose(0.0f, ref pose, ref result))
head = new SteamVR_Utils.RigidTransform(pose);
var calibrating =
result == SteamVR.HmdTrackingResult.TrackingResult_Calibrating_InProgress ||
result == SteamVR.HmdTrackingResult.TrackingResult_Calibrating_OutOfRange;
if (calibrating != SteamVR_Camera.calibrating)
{
SteamVR_Utils.Event.Send("calibrating", calibrating);
}
var trackingOutOfRange =
result == SteamVR.HmdTrackingResult.TrackingResult_Running_OutOfRange ||
result == SteamVR.HmdTrackingResult.TrackingResult_Calibrating_OutOfRange;
if (trackingOutOfRange != SteamVR_Camera.trackingOutOfRange)
{
SteamVR_Utils.Event.Send("absolute_tracking", !trackingOutOfRange);
}
}
else
{
if (hmd.GetLastTrackerFromHeadPose(ref pose))
head = new SteamVR_Utils.RigidTransform(pose);
}
}
offset.localPosition = head.pos;
offset.localRotation = head.rot;
// Update shared optional overlay shader variables
if (overlaySettings.texture != null && applyDistortion)
{
distortMaterial.SetFloat("alpha", Mathf.Clamp01(overlaySettings.alpha));
distortMaterial.SetVector("uvOffset", overlaySettings.uvOffset);
var rot = Matrix4x4.identity;
rot.SetColumn(0, head.rot * Vector3.right);
rot.SetColumn(1, head.rot * Vector3.up);
rot.SetColumn(2, head.rot * Vector3.forward);
distortMaterial.SetMatrix("rot", rot);
float aspect = (float)overlaySettings.texture.width / overlaySettings.texture.height;
if (overlaySettings.curved)
{
var range = new Vector2(0.1f, 1.0f); // probably should make this tweakable
var theta = Mathf.Lerp(60.0f, 5.0f, Mathf.SmoothStep(range.x, range.y, -offset.localPosition.z));
var coef = new Vector4(2.0f * theta * Mathf.Deg2Rad, aspect / overlaySettings.scale, aspect, 2.0f * overlaySettings.distance);
distortMaterial.SetVector("coef", coef);
overlaySettings.radius = overlaySettings.scale / coef.x;
}
else
{
var coef = new Vector4(1.0f / overlaySettings.scale, aspect / overlaySettings.scale, 0, 0);
distortMaterial.SetVector("coef", coef);
overlaySettings.radius = 0.0f;
}
}
}
// Helper to create (or reuse if possible) each of our different overlay types.
ulong GetOverlayHandle(string overlayName, Transform transform, float widthInMeters = 1.0f)
{
ulong handle = OpenVR.k_ulOverlayHandleInvalid;
var overlay = OpenVR.Overlay;
if (overlay == null)
return handle;
var key = SteamVR_Overlay.key + "." + overlayName;
var error = overlay.FindOverlay(key, ref handle);
if (error != EVROverlayError.None)
error = overlay.CreateOverlay(key, overlayName, ref handle);
if (error == EVROverlayError.None)
{
overlay.ShowOverlay(handle);
overlay.SetOverlayAlpha(handle, alpha);
overlay.SetOverlayWidthInMeters(handle, widthInMeters);
// D3D textures are upside-down in Unity to match OpenGL.
if (SteamVR.instance.graphicsAPI == EGraphicsAPIConvention.API_DirectX)
{
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = 0;
textureBounds.vMin = 1;
textureBounds.uMax = 1;
textureBounds.vMax = 0;
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
}
// Convert from world space to tracking space using the top-most camera.
var vrcam = (loadingScreenDistance == 0.0f) ? SteamVR_Render.Top() : null;
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
else
{
var t = new SteamVR_Utils.RigidTransform(transform).ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
}
return handle;
}
private void OnNewPoses(params object[] args)
{
var poses = (TrackedDevicePose_t[])args[0];
if (poses.Length <= OpenVR.k_unTrackedDeviceIndex_Hmd)
return;
if (!poses[OpenVR.k_unTrackedDeviceIndex_Hmd].bPoseIsValid)
return;
var hmd = new SteamVR_Utils.RigidTransform(poses[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking);
zoffset = hmd.pos.z;
}
public void Multiply(SteamVR_Utils.RigidTransform a, SteamVR_Utils.RigidTransform b)
{
this.rot = a.rot * b.rot;
this.pos = a.pos + a.rot * b.pos;
}
public void UpdateOverlay()
{
CVROverlay overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (this.texture != null)
{
EVROverlayError eVROverlayError = overlay.ShowOverlay(this.handle);
if ((eVROverlayError == EVROverlayError.InvalidHandle || eVROverlayError == EVROverlayError.UnknownOverlay) && overlay.FindOverlay(SteamVR_Overlay.key, ref this.handle) != EVROverlayError.None)
{
return;
}
Texture_t texture_t = default(Texture_t);
texture_t.handle = this.texture.GetNativeTexturePtr();
texture_t.eType = SteamVR.instance.graphicsAPI;
texture_t.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(this.handle, ref texture_t);
overlay.SetOverlayAlpha(this.handle, this.alpha);
overlay.SetOverlayWidthInMeters(this.handle, this.scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(this.handle, this.curvedRange.x, this.curvedRange.y);
VRTextureBounds_t vRTextureBounds_t = default(VRTextureBounds_t);
vRTextureBounds_t.uMin = (0f + this.uvOffset.x) * this.uvOffset.z;
vRTextureBounds_t.vMin = (1f + this.uvOffset.y) * this.uvOffset.w;
vRTextureBounds_t.uMax = (1f + this.uvOffset.x) * this.uvOffset.z;
vRTextureBounds_t.vMax = (0f + this.uvOffset.y) * this.uvOffset.w;
overlay.SetOverlayTextureBounds(this.handle, ref vRTextureBounds_t);
HmdVector2_t hmdVector2_t = default(HmdVector2_t);
hmdVector2_t.v0 = this.mouseScale.x;
hmdVector2_t.v1 = this.mouseScale.y;
overlay.SetOverlayMouseScale(this.handle, ref hmdVector2_t);
SteamVR_Camera steamVR_Camera = SteamVR_Render.Top();
if (steamVR_Camera != null && steamVR_Camera.origin != null)
{
SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(steamVR_Camera.origin, base.transform);
rigidTransform.pos.x = rigidTransform.pos.x / steamVR_Camera.origin.localScale.x;
rigidTransform.pos.y = rigidTransform.pos.y / steamVR_Camera.origin.localScale.y;
rigidTransform.pos.z = rigidTransform.pos.z / steamVR_Camera.origin.localScale.z;
rigidTransform.pos.z = rigidTransform.pos.z + this.distance;
HmdMatrix34_t hmdMatrix34_t = rigidTransform.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(this.handle, SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t);
}
overlay.SetOverlayInputMethod(this.handle, this.inputMethod);
if (this.curved || this.antialias)
{
this.highquality = true;
}
if (this.highquality)
{
overlay.SetHighQualityOverlay(this.handle);
overlay.SetOverlayFlag(this.handle, VROverlayFlags.Curved, this.curved);
overlay.SetOverlayFlag(this.handle, VROverlayFlags.RGSS4X, this.antialias);
}
else if (overlay.GetHighQualityOverlay() == this.handle)
{
overlay.SetHighQualityOverlay(0uL);
}
}
else
{
overlay.HideOverlay(this.handle);
}
}
public void Interpolate(SteamVR_Utils.RigidTransform to, float t)
{
this.pos = SteamVR_Utils.Lerp(this.pos, to.pos, t);
this.rot = SteamVR_Utils.Slerp(this.rot, to.rot, t);
}
private SteamVR(System.IntPtr pHmd, System.IntPtr pCompositor, System.IntPtr pOverlay)
{
hmd = new CVRSystem(pHmd);
Debug.Log("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber);
compositor = new CVRCompositor(pCompositor);
overlay = new CVROverlay(pOverlay);
var capacity = compositor.GetLastError(null, 0);
if (capacity > 1)
{
var result = new System.Text.StringBuilder((int)capacity);
compositor.GetLastError(result, capacity);
Debug.Log("Compositor - " + result);
}
// Setup render values
uint w = 0, h = 0;
hmd.GetRecommendedRenderTargetSize(ref w, ref h);
sceneWidth = (float)w;
sceneHeight = (float)h;
float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f;
hmd.GetProjectionRaw(Hmd_Eye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom);
float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f;
hmd.GetProjectionRaw(Hmd_Eye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom);
tanHalfFov = new Vector2(
Mathf.Max(-l_left, l_right, -r_left, r_right),
Mathf.Max(-l_top, l_bottom, -r_top, r_bottom));
textureBounds = new VRTextureBounds_t[2];
textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.x;
textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.x;
textureBounds[0].vMin = 0.5f - 0.5f * l_bottom / tanHalfFov.y;
textureBounds[0].vMax = 0.5f - 0.5f * l_top / tanHalfFov.y;
textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.x;
textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.x;
textureBounds[1].vMin = 0.5f - 0.5f * r_bottom / tanHalfFov.y;
textureBounds[1].vMax = 0.5f - 0.5f * r_top / tanHalfFov.y;
Unity.SetSubmitParams(textureBounds[0], textureBounds[1], VRSubmitFlags_t.Submit_Default);
// Grow the recommended size to account for the overlapping fov
sceneWidth = sceneWidth / Mathf.Max(textureBounds[0].uMax - textureBounds[0].uMin, textureBounds[1].uMax - textureBounds[1].uMin);
sceneHeight = sceneHeight / Mathf.Max(textureBounds[0].vMax - textureBounds[0].vMin, textureBounds[1].vMax - textureBounds[1].vMin);
aspect = tanHalfFov.x / tanHalfFov.y;
fieldOfView = 2.0f * Mathf.Atan(tanHalfFov.y) * Mathf.Rad2Deg;
eyes = new SteamVR_Utils.RigidTransform[] {
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(Hmd_Eye.Eye_Left)),
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(Hmd_Eye.Eye_Right)) };
if (SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL"))
graphicsAPI = GraphicsAPIConvention.API_OpenGL;
else
graphicsAPI = GraphicsAPIConvention.API_DirectX;
SteamVR_Utils.Event.Listen("initializing", OnInitializing);
SteamVR_Utils.Event.Listen("calibrating", OnCalibrating);
SteamVR_Utils.Event.Listen("out_of_range", OnOutOfRange);
SteamVR_Utils.Event.Listen("device_connected", OnDeviceConnected);
SteamVR_Utils.Event.Listen("new_poses", OnNewPoses);
}
void Update()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
// See if anything has changed since this gets called whenever anything gets touched.
var fields = GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
bool modified = false;
if (values == null)
{
modified = true;
}
else
{
foreach (var f in fields)
{
if (!values.Contains(f) || !f.GetValue(this).Equals(values[f]))
{
modified = true;
break;
}
}
}
if (modified)
{
SetModel(modelOverride);
values = new Hashtable();
foreach (var f in fields)
values[f] = f.GetValue(this);
}
return; // Do not update transforms (below) when not playing in Editor (to avoid keeping OpenVR running all the time).
}
#endif
// Update component transforms dynamically.
if (updateDynamically)
{
using (var holder = new RenderModelInterfaceHolder())
{
var controllerState = SteamVR_Controller.Input((int)index).GetState();
var t = transform;
var baseTransform = new SteamVR_Utils.RigidTransform(t);
for (int i = 0; i < t.childCount; i++)
{
var child = t.GetChild(i);
var renderModels = holder.instance;
if (renderModels == null)
break;
var componentState = new RenderModel_ComponentState_t();
if (!renderModels.GetComponentState(renderModelName, child.name, ref controllerState, 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 = baseTransform * new SteamVR_Utils.RigidTransform(componentState.mTrackingToComponentLocal);
attach.position = attachTransform.pos;
attach.rotation = attachTransform.rot;
}
bool visible = (componentState.uProperties & (uint)EVRComponentProperty.VRComponentProperty_IsVisible) != 0;
if (visible != child.gameObject.activeSelf)
{
child.gameObject.SetActive(visible);
}
}
}
}
}
private void OnNewPoses(params object[] args)
{
var poses = (TrackedDevicePose_t[])args[0];
// Update eye offsets to account for IPD changes.
eyes[0] = new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Left));
eyes[1] = new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Right));
for (int i = 0; i < poses.Length; i++)
{
var connected = poses[i].bDeviceIsConnected;
if (connected != SteamVR.connected[i])
{
SteamVR_Utils.Event.Send("device_connected", i, connected);
}
}
if (poses.Length > OpenVR.k_unTrackedDeviceIndex_Hmd)
{
var result = poses[OpenVR.k_unTrackedDeviceIndex_Hmd].eTrackingResult;
var initializing = result == ETrackingResult.Uninitialized;
if (initializing != SteamVR.initializing)
{
SteamVR_Utils.Event.Send("initializing", initializing);
}
var calibrating =
result == ETrackingResult.Calibrating_InProgress ||
result == ETrackingResult.Calibrating_OutOfRange;
if (calibrating != SteamVR.calibrating)
{
SteamVR_Utils.Event.Send("calibrating", calibrating);
}
var outOfRange =
result == ETrackingResult.Running_OutOfRange ||
result == ETrackingResult.Calibrating_OutOfRange;
if (outOfRange != SteamVR.outOfRange)
{
SteamVR_Utils.Event.Send("out_of_range", outOfRange);
}
}
}
private SteamVR()
{
hmd = OpenVR.System;
Debug.Log("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber);
compositor = OpenVR.Compositor;
overlay = OpenVR.Overlay;
// Setup render values
uint w = 0, h = 0;
hmd.GetRecommendedRenderTargetSize(ref w, ref h);
sceneWidth = (float)w;
sceneHeight = (float)h;
float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f;
hmd.GetProjectionRaw(EVREye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom);
float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f;
hmd.GetProjectionRaw(EVREye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom);
tanHalfFov = new Vector2(
Mathf.Max(-l_left, l_right, -r_left, r_right),
Mathf.Max(-l_top, l_bottom, -r_top, r_bottom));
textureBounds = new VRTextureBounds_t[2];
textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.x;
textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.x;
textureBounds[0].vMin = 0.5f - 0.5f * l_bottom / tanHalfFov.y;
textureBounds[0].vMax = 0.5f - 0.5f * l_top / tanHalfFov.y;
textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.x;
textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.x;
textureBounds[1].vMin = 0.5f - 0.5f * r_bottom / tanHalfFov.y;
textureBounds[1].vMax = 0.5f - 0.5f * r_top / tanHalfFov.y;
// Grow the recommended size to account for the overlapping fov
sceneWidth = sceneWidth / Mathf.Max(textureBounds[0].uMax - textureBounds[0].uMin, textureBounds[1].uMax - textureBounds[1].uMin);
sceneHeight = sceneHeight / Mathf.Max(textureBounds[0].vMax - textureBounds[0].vMin, textureBounds[1].vMax - textureBounds[1].vMin);
aspect = tanHalfFov.x / tanHalfFov.y;
fieldOfView = 2.0f * Mathf.Atan(tanHalfFov.y) * Mathf.Rad2Deg;
eyes = new SteamVR_Utils.RigidTransform[] {
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Left)),
new SteamVR_Utils.RigidTransform(hmd.GetEyeToHeadTransform(EVREye.Eye_Right))
};
switch (SystemInfo.graphicsDeviceType)
{
#if (UNITY_5_4)
case UnityEngine.Rendering.GraphicsDeviceType.OpenGL2:
#endif
case UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore:
case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2:
case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3:
textureType = ETextureType.OpenGL;
break;
#if !(UNITY_5_4)
case UnityEngine.Rendering.GraphicsDeviceType.Vulkan:
textureType = ETextureType.Vulkan;
break;
#endif
default:
textureType = ETextureType.DirectX;
break;
}
SteamVR_Events.Initializing.Listen(OnInitializing);
SteamVR_Events.Calibrating.Listen(OnCalibrating);
SteamVR_Events.OutOfRange.Listen(OnOutOfRange);
SteamVR_Events.DeviceConnected.Listen(OnDeviceConnected);
SteamVR_Events.NewPoses.Listen(OnNewPoses);
}
private void OnNewPoses(TrackedDevicePose_t[] poses)
{
if (index == EIndex.None)
{
return;
}
var i = (int)index;
isValid = false;
if (poses.Length <= i)
{
return;
}
if (!poses[i].bDeviceIsConnected)
{
return;
}
var trackerIndex = SteamVR_Controller.GetDeviceIndex(SteamVR_Controller.DeviceRelation.First, ETrackedDeviceClass.GenericTracker);
if (i == trackerIndex)
{
tracker = this.gameObject;
}
if (index == EIndex.Hmd)
{
isValid = true;
return;
if (poses[0].bPoseIsValid)
{
headCamera.transform.SetParent(headTracking.transform);
}
else
{
if (tracker != null)
{
headCamera.transform.SetParent(tracker.transform);
}
}
}
if (!poses[i].bPoseIsValid)
{
return;
}
isValid = true;
var pose = new SteamVR_Utils.RigidTransform(poses[i].mDeviceToAbsoluteTracking);
if (origin != null)
{
transform.position = origin.transform.TransformPoint(pose.pos);
transform.rotation = origin.rotation * pose.rot;
}
else
{
transform.localPosition = pose.pos;
transform.localRotation = pose.rot;
}
}
public void UpdateOverlay(SteamVR vr)
{
if (texture != null)
{
var error = vr.overlay.ShowOverlay(handle);
if (error == VROverlayError.InvalidHandle || error == VROverlayError.UnknownOverlay)
{
if (vr.overlay.FindOverlay(key, ref handle) != VROverlayError.None)
return;
}
vr.overlay.SetOverlayTexture(handle, texture.GetNativeTexturePtr());
vr.overlay.SetOverlayAlpha(handle, alpha);
vr.overlay.SetOverlayGamma(handle, gamma);
vr.overlay.SetOverlayWidthInMeters(handle, scale);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
vr.overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v = new float[] { mouseScale.x, mouseScale.y };
vr.overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
offset.pos.z += distance;
var t = offset.ToHmdMatrix34();
vr.overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
vr.overlay.SetOverlayVisibility(handle, visibility);
vr.overlay.SetOverlayInputMethod(handle, inputMethod);
if (curved || antialias)
highquality = true;
if (highquality)
{
vr.overlay.SetHighQualityOverlay(handle);
vr.overlay.SetOverlayFlag(handle, VROverlayFlags.Curved, curved);
vr.overlay.SetOverlayFlag(handle, VROverlayFlags.RGSS4X, antialias);
}
else if (vr.overlay.GetHighQualityOverlay() == handle)
{
vr.overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
vr.overlay.HideOverlay(handle);
}
}
public void UpdateOverlay()
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return;
}
if (texture != null)
{
var error = overlay.ShowOverlay(handle);
if (error == EVROverlayError.InvalidHandle || error == EVROverlayError.UnknownOverlay)
{
if (overlay.FindOverlay(key, ref handle) != EVROverlayError.None)
{
return;
}
}
var tex = new Texture_t();
tex.handle = texture.GetNativeTexturePtr();
tex.eType = SteamVR.instance.graphicsAPI;
tex.eColorSpace = EColorSpace.Auto;
overlay.SetOverlayTexture(handle, ref tex);
overlay.SetOverlayAlpha(handle, alpha);
overlay.SetOverlayWidthInMeters(handle, scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(handle, curvedRange.x, curvedRange.y);
var textureBounds = new VRTextureBounds_t();
textureBounds.uMin = (0 + uvOffset.x) * uvOffset.z;
textureBounds.vMin = (1 + uvOffset.y) * uvOffset.w;
textureBounds.uMax = (1 + uvOffset.x) * uvOffset.z;
textureBounds.vMax = (0 + uvOffset.y) * uvOffset.w;
overlay.SetOverlayTextureBounds(handle, ref textureBounds);
var vecMouseScale = new HmdVector2_t();
vecMouseScale.v0 = mouseScale.x;
vecMouseScale.v1 = mouseScale.y;
overlay.SetOverlayMouseScale(handle, ref vecMouseScale);
var vrcam = SteamVR_Render.Top();
if (vrcam != null && vrcam.origin != null)
{
var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
offset.pos.x /= vrcam.origin.localScale.x;
offset.pos.y /= vrcam.origin.localScale.y;
offset.pos.z /= vrcam.origin.localScale.z;
offset.pos.z += distance;
var t = offset.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(handle, SteamVR_Render.instance.trackingSpace, ref t);
}
overlay.SetOverlayInputMethod(handle, inputMethod);
if (curved || antialias)
{
highquality = true;
}
if (highquality)
{
overlay.SetHighQualityOverlay(handle);
overlay.SetOverlayFlag(handle, VROverlayFlags.Curved, curved);
overlay.SetOverlayFlag(handle, VROverlayFlags.RGSS4X, antialias);
}
else if (overlay.GetHighQualityOverlay() == handle)
{
overlay.SetHighQualityOverlay(OpenVR.k_ulOverlayHandleInvalid);
}
}
else
{
overlay.HideOverlay(handle);
}
}
private void UpdateDevicePose(bool obj)
{
IVRModuleDeviceState prevState;
IVRModuleDeviceStateRW currState;
FlushDeviceState();
var vrSystem = OpenVR.System;
var vrCompositor = OpenVR.Compositor;
if (vrSystem == null || vrCompositor == null)
{
for (uint i = 0, imax = GetDeviceStateLength(); i < imax; ++i)
{
if (TryGetValidDeviceState(i, out prevState, out currState) && currState.isConnected)
{
currState.Reset();
}
}
return;
}
vrCompositor.GetLastPoses(m_poses, m_gamePoses);
for (uint i = 0u, imax = (uint)m_poses.Length; i < imax; ++i)
{
if (!m_poses[i].bDeviceIsConnected)
{
if (TryGetValidDeviceState(i, out prevState, out currState) && prevState.isConnected)
{
s_devicePathHandles[i] = OpenVR.k_ulInvalidInputValueHandle;
currState.Reset();
}
}
else
{
EnsureValidDeviceState(i, out prevState, out currState);
if (!prevState.isConnected)
{
currState.isConnected = true;
currState.deviceClass = (VRModuleDeviceClass)vrSystem.GetTrackedDeviceClass(i);
currState.serialNumber = QueryDeviceStringProperty(vrSystem, i, ETrackedDeviceProperty.Prop_SerialNumber_String);
currState.modelNumber = QueryDeviceStringProperty(vrSystem, i, ETrackedDeviceProperty.Prop_ModelNumber_String);
currState.renderModelName = QueryDeviceStringProperty(vrSystem, i, ETrackedDeviceProperty.Prop_RenderModelName_String);
SetupKnownDeviceModel(currState);
m_originDataCache.Clear();
}
// update device status
currState.isPoseValid = m_poses[i].bPoseIsValid;
currState.isOutOfRange = m_poses[i].eTrackingResult == ETrackingResult.Running_OutOfRange || m_poses[i].eTrackingResult == ETrackingResult.Calibrating_OutOfRange;
currState.isCalibrating = m_poses[i].eTrackingResult == ETrackingResult.Calibrating_InProgress || m_poses[i].eTrackingResult == ETrackingResult.Calibrating_OutOfRange;
currState.isUninitialized = m_poses[i].eTrackingResult == ETrackingResult.Uninitialized;
currState.velocity = new Vector3(m_poses[i].vVelocity.v0, m_poses[i].vVelocity.v1, -m_poses[i].vVelocity.v2);
currState.angularVelocity = new Vector3(-m_poses[i].vAngularVelocity.v0, -m_poses[i].vAngularVelocity.v1, m_poses[i].vAngularVelocity.v2);
var rigidTransform = new SteamVR_Utils.RigidTransform(m_poses[i].mDeviceToAbsoluteTracking);
currState.position = rigidTransform.pos;
currState.rotation = rigidTransform.rot;
}
}
ProcessConnectedDeviceChanged();
ProcessDevicePoseChanged();
}
public void UpdatePos()
{
SteamVR_Utils.RigidTransform rigid = new SteamVR_Utils.RigidTransform(this.transform);
Valve.VR.HmdMatrix34_t trans = rigid.ToHmdMatrix34();
SteamVR.instance.overlay.SetKeyboardTransformAbsolute(Valve.VR.ETrackingUniverseOrigin.TrackingUniverseStanding, ref trans);
}