//全デバイス情報を更新
public void Update(ETrackingUniverseOrigin origin = ETrackingUniverseOrigin.TrackingUniverseStanding)
{
allDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
if (!IsReady())
{
return;
}
//すべてのデバイスの情報を取得
openvr.GetDeviceToAbsoluteTrackingPose(origin, PredictedTime, allDevicePose);
//最終更新フレームを更新
LastFrameCount = Time.frameCount;
}
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);
targetObjs[i].transform.SetPositionAndRotation(mat.pos, mat.rot);
//Debug.Log(mat.pos+":"+ mat.rot);
float test;
this.GetComponent <InputVive> ().Vive_Y_set(mat.rot.y);
// Debug.Log (GetComponent<InputVive> ().Vive_Y_get());
}
}
}
public bool DoPulse()
{
m_vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseRawAndUncalibrated, 0f, m_trackedPoses);
while (m_vrSystem.PollNextEvent(ref m_vrEvent, m_eventSize))
{
switch (m_vrEvent.eventType)
{
case (uint)EVREventType.VREvent_Quit:
case (uint)EVREventType.VREvent_RestartRequested:
case (uint)EVREventType.VREvent_ProcessQuit:
m_active = false;
break;
case (uint)EVREventType.VREvent_TrackedDeviceDeactivated:
{
if (m_leftHandController == m_vrEvent.trackedDeviceIndex)
{
m_leftHandController = OpenVR.k_unTrackedDeviceIndexInvalid;
}
if (m_rightHandController == m_vrEvent.trackedDeviceIndex)
{
m_rightHandController = OpenVR.k_unTrackedDeviceIndexInvalid;
}
}
break;
}
}
if (m_trackedPoses[OpenVR.k_unTrackedDeviceIndex_Hmd].bPoseIsValid)
{
GlmSharp.mat4 l_matrix = GlmSharp.mat4.Identity;
m_trackedPoses[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking.Convert(ref l_matrix);
m_core.GetControlManager().SetHeadTransform(l_matrix);
}
if (m_leftHandController != OpenVR.k_unTrackedDeviceIndexInvalid)
{
GlmSharp.mat4 l_matrix = GlmSharp.mat4.Identity;
m_trackedPoses[m_leftHandController].mDeviceToAbsoluteTracking.Convert(ref l_matrix);
m_core.GetControlManager().SetHandTransform(ControlManager.Hand.Left, l_matrix);
}
else
{
m_leftHandController = m_vrSystem.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.LeftHand);
}
if (m_rightHandController != OpenVR.k_unTrackedDeviceIndexInvalid)
{
GlmSharp.mat4 l_matrix = GlmSharp.mat4.Identity;
m_trackedPoses[m_rightHandController].mDeviceToAbsoluteTracking.Convert(ref l_matrix);
m_core.GetControlManager().SetHandTransform(ControlManager.Hand.Right, l_matrix);
}
else
{
m_rightHandController = m_vrSystem.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.RightHand);
}
return(m_active);
}
public void UpdatePoses()
{
vr.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, Poses);
foreach (var index in Indexes)
{
this.AllDevices[index].Pose = Poses[index].mDeviceToAbsoluteTracking;
}
}
private void TrackingLoop()
{
try
{
EVRInitError initError = EVRInitError.None;
CVRSystem cvrSystem = OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Utility);
var chaperone = OpenVR.Chaperone;
var quadArea = new HmdQuad_t();
chaperone.GetPlayAreaRect(ref quadArea);
_playArea = quadArea.ToPlayArea();
if (initError != EVRInitError.None)
{
throw new InvalidOperationException($"EVR init erro: {initError}");
}
while (_keepReading)
{
TrackedDevicePose_t[] trackedDevicePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
cvrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0f, trackedDevicePoses);
for (uint trackedDeviceIndex = 0; trackedDeviceIndex < OpenVR.k_unMaxTrackedDeviceCount; trackedDeviceIndex++)
{
if (cvrSystem.IsTrackedDeviceConnected(trackedDeviceIndex))
{
ETrackedDeviceClass deviceClass = cvrSystem.GetTrackedDeviceClass(trackedDeviceIndex);
if (true)
{
VRControllerState_t controllerState = new VRControllerState_t();
cvrSystem.GetControllerState(1, ref controllerState, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t)));
ETrackingResult trackingResult = trackedDevicePoses[trackedDeviceIndex].eTrackingResult;
bool trigger = controllerState.rAxis1.x > 0.9f;
bool menuButton = (controllerState.ulButtonPressed & (1ul << (int)EVRButtonId.k_EButton_ApplicationMenu)) != 0;
bool gripButton = (controllerState.ulButtonPressed & (1ul << (int)EVRButtonId.k_EButton_Grip)) != 0;
if (trackingResult == ETrackingResult.Running_OK)
{
HmdMatrix34_t trackingMatrix = trackedDevicePoses[trackedDeviceIndex].mDeviceToAbsoluteTracking;
Vector3 speedVector = trackedDevicePoses[trackedDeviceIndex].vVelocity.ToVelocityVector();
Vector3 position = trackingMatrix.ToPositionVector();
DeviceTrackingData trackingUpdate = new DeviceTrackingData((int)trackedDeviceIndex, deviceClass.ToString(), position, trackingMatrix.ToRotationQuaternion());
NewPoseUpdate?.Invoke(this, trackingUpdate);
}
}
}
}
Thread.Sleep(UpdatedInterval);
}
}
catch (Exception e)
{
Console.WriteLine($"Error: {e}");
}
finally
{
OpenVR.Shutdown();
}
}
private static void SteamVr()
{
Console.WriteLine("Starting");
EVRInitError initError = EVRInitError.None;
CVRSystem cvrSystem = OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Utility);
Console.WriteLine("Error: " + initError.ToString());
if (cvrSystem == null)
{
Console.WriteLine("Error!");
}
while (true)
{
Thread.Sleep(1);
TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
cvrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseRawAndUncalibrated, 0f, trackedDevicePose);
VRControllerState_t controllerState = new VRControllerState_t();
cvrSystem.GetControllerState(1, ref controllerState,
(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t)));
int trigger = controllerState.rAxis1.x > 0.9f ? 1 : 0;
bool topButtom = (controllerState.ulButtonPressed & (1ul << (int)EVRButtonId.k_EButton_ApplicationMenu)) != 0;
TrackedDevicePose_t pose = trackedDevicePose[1];
ETrackingResult trackingResult = pose.eTrackingResult;
HmdMatrix34_t hmdMatrix = pose.mDeviceToAbsoluteTracking;
Position pos = new Position(hmdMatrix);
Rotation rot = new Rotation(hmdMatrix);
Console.WriteLine($"Position: {pos} Rotation: {rot} trigger {trigger} app {topButtom}");
foreach (Socket client in _clients.ToArray())
{
try
{
client.Send(Encoding.ASCII.GetBytes($"S{pos.ToData()} {rot.ToData()} {trigger} {(topButtom ? 1 : 0)}E"));
}
catch (Exception)
{
_clients.Remove(client);
}
}
}
for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (cvrSystem?.IsTrackedDeviceConnected((uint)i) ?? false)
{
ETrackedDeviceClass deviceClass = cvrSystem.GetTrackedDeviceClass((uint)i);
Console.WriteLine($"index: {i} is {deviceClass}");
}
}
Console.ReadLine();
OpenVR.Shutdown();
Console.WriteLine("Shut down");
Console.ReadLine();
}
private void QueryPose(int deviceID)
{
// this array can be reused
TrackedDevicePose_t[] allPoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, allPoses);
var pose = allPoses[deviceID];
if (pose.bPoseIsValid)
{
var absTracking = pose.mDeviceToAbsoluteTracking;
var mat = new SteamVR_Utils.RigidTransform(absTracking);
Debug.Log(mat.pos + " " + mat.rot);
}
}
// get tracked device poses
void Update()
{
// get the poses of all tracked devices
_vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0.0f, _poses);
//_vrSystem.
//print(_poses.Length);
// send the poses to SteamVR_TrackedObject components
SteamVR_Events.NewPoses.Send(_poses);
//SteamVR_Events.
// Check what happens in SteamVRModule.cs to see if its possible to forward events.
}
//----------おまけ(deviceの詳細情報)-------------
//全てのdeviceの情報をログに出力する
private void showDevices()
{
#pragma warning disable 0219
string Tag = "[" + this.GetType().Name + ":" + System.Reflection.MethodBase.GetCurrentMethod(); //クラス名とメソッド名を自動取得
#pragma warning restore 0219
//すべてのdeviceの接続状態を取得
TrackedDevicePose_t[] allDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
openvr.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0f, allDevicePose);
//接続されているdeviceの数をカウントする
uint connectedDeviceNum = 0;
for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (allDevicePose[i].bDeviceIsConnected)
{
connectedDeviceNum++;
}
}
//deviceの詳細情報を1つづつ読み出す
uint connectedDeviceCount = 0;
for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
//接続中だったら、読み取り完了数を1増やす
if (GetPropertyAndPutLog(i, allDevicePose))
{
connectedDeviceCount++;
}
//接続されている数だけ読み取り終わったら終了する
if (connectedDeviceCount >= connectedDeviceNum)
{
break;
}
}
}
/// <summary>
/// Update ViveTracker transforms using the corresponding Vive Tracker devices.
/// </summary>
public override void UpdateTrackers()
{
if (!_ovrInit)
{
return;
}
// Fetch last Vive Tracker devices poses.
_cvrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, _ovrTrackedDevicePoses);
// Apply poses to ViveTracker objects.
foreach (var tracker in _trackers)
{
TrackedDevicePose_t pose = _ovrTrackedDevicePoses[tracker.ID.TrackedDevice_Index];
SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(pose.mDeviceToAbsoluteTracking);
tracker.UpdateState(pose.bDeviceIsConnected && pose.bPoseIsValid && (pose.eTrackingResult == ETrackingResult.Running_OK), rigidTransform.pos, rigidTransform.rot);
}
}
public override bool GetHmdYaw(ref double yaw)
{
if (OpenVRConnStatus != OpenVRConnectionStatus.AllOK)
{
return(false);
}
VRSys.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, PoseArray);
if (!PoseArray[HmdIndex].bPoseIsValid)
{
return(false);
}
yaw = GetYawFromOrientation(GetOrientation(PoseArray[HmdIndex].mDeviceToAbsoluteTracking));
return(true);
}
private 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.Count)
{
var pose = allPoses[_validDeviceIds[i]];
var absTracking = pose.mDeviceToAbsoluteTracking;
var mat = new SteamVR_Utils.RigidTransform(absTracking);
targetObjs[i].transform.SetPositionAndRotation(mat.pos, mat.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);
Quaternion fixingQ = Quaternion.AngleAxis(-90f, new Vector3(1f, 0f, 0f));
targetObjs[i].transform.SetPositionAndRotation(mat.pos, mat.rot * fixingQ);
}
}
}
public void Update()
{
if (!Success)
{
return;
}
TrackedDevices = new VrTrackedDevices(this.vr);
//Initializing object to hold indexes for various tracked objects
vr.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, Poses);
//# Iterate through the pose list to find the active Devices and determine their type
for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (Poses[i].bPoseIsValid)
{
TrackedDevices.AddTrackedDevice(i);
}
}
}
void HMDCoords()
{
if (!vrContext.IsTrackedDeviceConnected((uint)HMD.Id))
{
return;
}
//TrackedDevicePose_t struct is a OpenVR struct. See line 180 in the openvr.h header.
TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[1];
//if (vrContext.IsInputFocusCapturedByAnotherProcess())
// printf("\nINFO--Input Focus by Another Process");
vrContext.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0f, trackedDevicePose);
var mat = ConvertMatrix(trackedDevicePose[0].mDeviceToAbsoluteTracking);
HMD.Position = GetPosition(mat);
HMD.Rotation = GetRotation(mat);
//Console.WriteLine(111111);
//Console.WriteLine(mat);
}
private void UpdatePoses()
{
_vrSystem.GetDeviceToAbsoluteTrackingPose(_trackingOrigin, 0, _allPoses);
for (int i = 0; i < _tracker.Count; i++)
{
int index = _tracker[i].DeviceId;
if (index == -1)
{
continue;
}
var pose = _allPoses[index];
float batteryPercent = 1.0f;
bool isCharging = false;
if (_tracker[i].HasBattery)
{
var error = ETrackedPropertyError.TrackedProp_UnknownProperty;
batteryPercent = _vrSystem.GetFloatTrackedDeviceProperty((uint)index, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref error);
isCharging = _vrSystem.GetBoolTrackedDeviceProperty((uint)index, ETrackedDeviceProperty.Prop_DeviceIsCharging_Bool, ref error);
}
_tracker[i].SetTrackingState(pose.eTrackingResult, batteryPercent, isCharging, false);
if (pose.bPoseIsValid)
{
var absTracking = pose.mDeviceToAbsoluteTracking;
Vector3 pos;
Quaternion rot;
HOVR_Utility.GetPosAndRotation(absTracking, out pos, out rot);
pos.Scale(_posScale);
_tracker[i].ReceivePose(pos, rot);
}
}
}
// Query a Pose and then assign the pose
private void QueryPose(int deviceID)
{
// this array can be reused
TrackedDevicePose_t[] allPoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, allPoses);
var pose = allPoses[genericTrackers[deviceID]];
if (pose.bPoseIsValid)
{
var absTracking = pose.mDeviceToAbsoluteTracking;
var mat = new SteamVR_Utils.RigidTransform(absTracking);
// Assign positions
transform.position = mat.pos;
trackerPos = mat.pos;
transform.rotation = mat.rot;
}
}
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 async Task ParseTrackingFrameAsync(CancellationToken token)
{
try
{
for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (!token.IsCancellationRequested)
{
TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[10];
if (!m_pHMD.IsTrackedDeviceConnected(i))
{
continue;
}
ETrackedDeviceClass trackedDeviceClass = m_pHMD.GetTrackedDeviceClass(i);
switch (trackedDeviceClass)
{
case ETrackedDeviceClass.HMD:
m_pHMD.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, trackedDevicePose);
HmdVector3_t position = GetPosition(trackedDevicePose[0].mDeviceToAbsoluteTracking); // devicePose->mDeviceToAbsoluteTracking);
HmdVector3_t rotation = GetRotationEuler(trackedDevicePose[0].mDeviceToAbsoluteTracking);
int positionX = (int)position.v0;
int positionY = (int)position.v1;
int positionZ = (int)position.v2 * (-1);
int rotationX = (int)rotation.v0 + 360;
int rotationY = (int)rotation.v1 + 90;
int rotationZ = (int)rotation.v2 * (-1);
if (ControlViewModel.teleporOffset[0] != -1)
{
lock (ControlViewModel.teleporOffset)
{
ControlViewModel.transOffSetHeadX = ControlViewModel.teleporOffset[0];
ControlViewModel.transOffSetHeadY = ControlViewModel.teleporOffset[1];
ControlViewModel.transOffSetHeadZ = ControlViewModel.teleporOffset[2];
ControlViewModel.rotOffSetHeadZ = ControlViewModel.teleporOffset[3];
}
}
if (communicationProtocolUdp == false)
{
MessageBuffer mb = new MessageBuffer();
int type = 100;
string ipAdress = ServerManager.clientIpAddressForTracking;
mb.add(type);
mb.add(userId);
mb.add(ipAdress);
mb.add(positionX + ControlViewModel.transOffSetHeadX);
mb.add(positionY + ControlViewModel.transOffSetHeadY);
mb.add(positionZ + ControlViewModel.transOffSetHeadZ);
mb.add(rotationX - ControlViewModel.rotOffSetHeadZ);
mb.add(rotationY);
mb.add(rotationZ);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
Thread.Sleep(20);
break;
}
break;
}
}
}
}
catch (Exception e)
{
log.Warn("ParseTrackingFrameAsync in Hmd Tracking wurde beendet!");
RaiseSampleEvent(new TrackingChangedEventArgs(e));
}
}
/// <summary>
/// Overrides the Update method, called every frame.
/// </summary>
void LateUpdate()
{
try
{
// do nothing unless we are in IVA
hmdIsAllowed = (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA);
// start HMD using the Y key
if (Input.GetKeyDown(KeyCode.Y) && hmdIsAllowed)
{
if (!hmdIsInitialized)
{
log("Initializing HMD...");
try
{
bool retVal = InitHMD();
if (retVal)
{
log("HMD initialized.");
}
}
catch (Exception e)
{
err(e.Message);
}
}
else
{
ResetInitialHmdPosition();
}
}
// perform regular updates if HMD is initialized
if (hmdIsAllowed && hmdIsInitialized)
{
EVRCompositorError vrCompositorError = EVRCompositorError.None;
// get latest HMD pose
//--------------------------------------------------------------
vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseSeated, 0.0f, vrDevicePoses);
HmdMatrix34_t vrLeftEyeTransform = vrSystem.GetEyeToHeadTransform(EVREye.Eye_Left);
HmdMatrix34_t vrRightEyeTransform = vrSystem.GetEyeToHeadTransform(EVREye.Eye_Right);
vrCompositorError = vrCompositor.WaitGetPoses(vrRenderPoses, vrGamePoses);
if (vrCompositorError != EVRCompositorError.None)
{
warn("WaitGetPoses failed: " + (int)vrCompositorError);
return;
}
// convert SteamVR poses to Unity coordinates
var hmdTransform = new SteamVR_Utils.RigidTransform(vrDevicePoses[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking);
var hmdLeftEyeTransform = new SteamVR_Utils.RigidTransform(vrLeftEyeTransform);
var hmdRightEyeTransform = new SteamVR_Utils.RigidTransform(vrRightEyeTransform);
var ctrlPoseLeft = new SteamVR_Utils.RigidTransform(vrDevicePoses[ctrlIndexLeft].mDeviceToAbsoluteTracking);
var ctrlPoseRight = new SteamVR_Utils.RigidTransform(vrDevicePoses[ctrlIndexRight].mDeviceToAbsoluteTracking);
// Render the LEFT eye
//--------------------------------------------------------------
// rotate camera according to the HMD orientation
InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
// translate the camera to match the position of the left eye, from origin
InternalCamera.Instance.transform.localPosition = new Vector3(0f, 0f, 0f);
InternalCamera.Instance.transform.Translate(hmdLeftEyeTransform.pos);
// translate the camera to match the position of the HMD
InternalCamera.Instance.transform.localPosition += hmdTransform.pos;
// move the FlightCamera to match the position of the InternalCamera (so the outside world moves accordingly)
FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
// render the set of cameras
foreach (CameraProperties camStruct in camerasToRender)
{
// set projection matrix
camStruct.camera.projectionMatrix = camStruct.hmdLeftProjMatrix;
// set texture to render to
camStruct.camera.targetTexture = hmdLeftEyeRenderTexture;
// render camera
camStruct.camera.Render();
}
// Render the RIGHT eye (see previous comments)
//--------------------------------------------------------------
InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
InternalCamera.Instance.transform.localPosition = new Vector3(0f, 0f, 0f);
InternalCamera.Instance.transform.Translate(hmdRightEyeTransform.pos);
InternalCamera.Instance.transform.localPosition += hmdTransform.pos;
FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
foreach (CameraProperties camStruct in camerasToRender)
{
camStruct.camera.projectionMatrix = camStruct.hmdRightProjMatrix;
camStruct.camera.targetTexture = hmdRightEyeRenderTexture;
camStruct.camera.Render();
}
try
{
// Set camera position to an HMD-centered position (for regular screen rendering)
//--------------------------------------------------------------
if (renderToScreen)
{
foreach (CameraProperties camStruct in camerasToRender)
{
camStruct.camera.targetTexture = null;
camStruct.camera.projectionMatrix = camStruct.originalProjMatrix;
}
InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
InternalCamera.Instance.transform.localPosition = hmdTransform.pos;
FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
}
// Submit frames to HMD
//--------------------------------------------------------------
vrCompositorError = vrCompositor.Submit(EVREye.Eye_Left, ref hmdLeftEyeTexture, ref hmdTextureBounds, EVRSubmitFlags.Submit_Default);
if (vrCompositorError != EVRCompositorError.None)
{
warn("Submit (Eye_Left) failed: " + (int)vrCompositorError);
}
vrCompositorError = vrCompositor.Submit(EVREye.Eye_Right, ref hmdRightEyeTexture, ref hmdTextureBounds, EVRSubmitFlags.Submit_Default);
if (vrCompositorError != EVRCompositorError.None)
{
warn("Submit (Eye_Right) failed: " + (int)vrCompositorError);
}
vrCompositor.PostPresentHandoff();
// GL.Flush();
} catch (Exception e)
{
err("Exception! " + e.ToString());
}
// disable highlighting of parts due to mouse
// TODO: there needs to be a better way to do this. this affects the Part permanently
Part hoveredPart = Mouse.HoveredPart;
if (hoveredPart != null)
{
hoveredPart.HighlightActive = false;
hoveredPart.highlightColor.a = 0f;// = new Color(0f, 0f, 0f, 0f);
//Debug.Log("[KerbalVR] hovered part: " + hoveredPart.name);
}
// DEBUG
if (Input.GetKeyDown(KeyCode.O))
{
log("POSITION hmdTransform : " + hmdTransform.pos.x + ", " + hmdTransform.pos.y + ", " + hmdTransform.pos.z);
log("POSITION hmdLTransform : " + hmdLeftEyeTransform.pos.x + ", " + hmdLeftEyeTransform.pos.y + ", " + hmdLeftEyeTransform.pos.z);
log("POSITION hmdRTransform : " + hmdRightEyeTransform.pos.x + ", " + hmdRightEyeTransform.pos.y + ", " + hmdRightEyeTransform.pos.z);
log("POSITION ctrlPoseRight : " + ctrlPoseRight.pos.x + ", " + ctrlPoseRight.pos.y + ", " + ctrlPoseRight.pos.z);
log("POSITION InternalCamera.Instance.transform.abs : " + InternalCamera.Instance.transform.position.x + ", " + InternalCamera.Instance.transform.position.y + ", " + InternalCamera.Instance.transform.position.z);
log("POSITION InternalCamera.Instance.transform.rel : " + InternalCamera.Instance.transform.localPosition.x + ", " + InternalCamera.Instance.transform.localPosition.y + ", " + InternalCamera.Instance.transform.localPosition.z);
foreach (Camera c in Camera.allCameras)
{
log("Camera: " + c.name + ", cullingMask = " + c.cullingMask);
}
}
}
// if we are exiting VR, restore the cameras
if (!hmdIsAllowed && hmdIsAllowed_prev)
{
foreach (CameraProperties camStruct in camerasToRender)
{
camStruct.camera.projectionMatrix = camStruct.originalProjMatrix;
camStruct.camera.targetTexture = null;
}
}
hmdIsAllowed_prev = hmdIsAllowed;
}
catch (Exception e)
{
err(e.ToString());
}
}
private static void ReadPoses(float seconsdAhead)
{//to be called from RENDER thread
if (m_vrCompositor == null)
{
return;
}
ProfilerShort.Begin("MOVR:ReadPoses");
//MyLog.Default.WriteLine(" GetPoses");
var error3 = m_vrCompositor.WaitGetPoses(renderPose, gamePose);//TODO will not initialize correctly without it but maybe not necessary to do all the time
m_vrSystem.GetDeviceToAbsoluteTrackingPose(m_vrCompositor.GetTrackingSpace(), seconsdAhead, gamePose);
uint nDevice = 0;
bool firstControllerFound = false;
foreach (var rPose in gamePose)
{
if (!rPose.bDeviceIsConnected)
{
break;
}
if (rPose.bPoseIsValid)
{
switch (m_vrSystem.GetTrackedDeviceClass(nDevice))
{
case ETrackedDeviceClass.HMD:
if (rPose.eTrackingResult != ETrackingResult.Running_OK)
{
Log.WriteLineAndConsole("Pose: " + nDevice + " not Running OK");
continue;
}
PoseToViewMatrix(ref m_viewHMD, ref gamePose[nDevice].mDeviceToAbsoluteTracking);
PoseToTransMatrixD(ref m_headsetPosD, ref gamePose[nDevice].mDeviceToAbsoluteTracking);
m_viewHMD.M42 -= FloorOffset;
//QS1 axes: X red ship's rear
// Y up
// Z from red ship to platform
//translation up-down is inverted
break;
case ETrackedDeviceClass.Controller:
if (!firstControllerFound)
{
firstControllerFound = true;
if (m_controller1ID != nDevice)
{
Log.WriteLine("Controller1 is now ID #" + nDevice);
m_controller1ID = nDevice;
}
}
else
if (m_controller2ID != nDevice)
{
Log.WriteLine("Controller2 is now ID #" + nDevice);
m_controller2ID = nDevice;
}
if (nDevice == m_controller1ID)
{
PoseToTransMatrix(ref m_c1pos, ref gamePose[nDevice].mDeviceToAbsoluteTracking);
}
else
if (nDevice == m_controller2ID)
{
PoseToTransMatrix(ref m_c2pos, ref gamePose[nDevice].mDeviceToAbsoluteTracking);
}
break;
}
}
//else
// Log.WriteLineAndConsole("Pose: " + nDevice + " not valid");
nDevice++;
}
ProfilerShort.End();
}
private void VRInit()
{
// init
var error = EVRInitError.None;
system = OpenVR.Init(ref error);
if (error != EVRInitError.None)
{
throw new Exception();
}
OpenVR.GetGenericInterface(OpenVR.IVRSystem_Version, ref error);
if (error != EVRInitError.None)
{
throw new Exception();
}
TrackedDevicePose_t[] m_rTrackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
TrackedDevicePose_t TrackedDevicePose = new TrackedDevicePose_t();
VRControllerState_t controllerState = new VRControllerState_t();
while (true)
{
system.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, m_rTrackedDevicePose);
for (uint unDevice = 0; unDevice < OpenVR.k_unMaxTrackedDeviceCount; unDevice++)
{
if (!system.IsTrackedDeviceConnected(unDevice))
{
continue;
}
HmdVector3_t position;
HmdQuaternion_t quaternion;
// Get what type of device it is and work with its data
ETrackedDeviceClass trackedDeviceClass = system.GetTrackedDeviceClass(unDevice);
ETrackedControllerRole trackedControllerRole = system.GetControllerRoleForTrackedDeviceIndex(unDevice);
ETrackingResult eTrackingResult;
switch (trackedDeviceClass)
{
case ETrackedDeviceClass.HMD:
// get the position and rotation
position = GetPosition(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
quaternion = GetRotation(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
// for printing some more info to the user about the state of the device/pose
eTrackingResult = m_rTrackedDevicePose[unDevice].eTrackingResult;
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
HmdIndex.Text = String.Format("{0}", unDevice);
HmdVectorX.Text = String.Format("{0:F4}", position.v0);
HmdVectorY.Text = String.Format("{0:F4}", position.v1);
HmdVectorZ.Text = String.Format("{0:F4}", position.v2);
HmdQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
HmdQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
HmdQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
HmdQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
HmdState.Text = GetDeviceState(eTrackingResult);
}));
break;
case ETrackedDeviceClass.Controller:
// get the position and rotation
position = GetPosition(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
quaternion = GetRotation(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
// for printing some more info to the user about the state of the device/pose
eTrackingResult = m_rTrackedDevicePose[unDevice].eTrackingResult;
// get Controllers info
system.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, unDevice, ref controllerState, (uint)Marshal.SizeOf(controllerState), ref TrackedDevicePose);
switch (trackedControllerRole)
{
case ETrackedControllerRole.LeftHand:
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
CLIndex.Text = String.Format("{0}", unDevice);
CLVectorX.Text = String.Format("{0:F4}", position.v0);
CLVectorY.Text = String.Format("{0:F4}", position.v1);
CLVectorZ.Text = String.Format("{0:F4}", position.v2);
CLQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
CLQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
CLQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
CLQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
CLState.Text = GetDeviceState(eTrackingResult);
CLulPressed.Text = String.Format("{0}", controllerState.ulButtonPressed);
CLulTouched.Text = String.Format("{0}", controllerState.ulButtonTouched);
CLAxis0X.Text = String.Format("{0:F4}", controllerState.rAxis0.x);
CLAxis0Y.Text = String.Format("{0:F4}", controllerState.rAxis0.y);
CLAxis1X.Text = String.Format("{0:F4}", controllerState.rAxis1.x);
CLAxis1Y.Text = String.Format("{0:F4}", controllerState.rAxis1.y);
CLAxis2X.Text = String.Format("{0:F4}", controllerState.rAxis2.x);
CLAxis2Y.Text = String.Format("{0:F4}", controllerState.rAxis2.y);
CLAxis3X.Text = String.Format("{0:F4}", controllerState.rAxis3.x);
CLAxis3Y.Text = String.Format("{0:F4}", controllerState.rAxis3.y);
CLAxis4X.Text = String.Format("{0:F4}", controllerState.rAxis4.x);
CLAxis4Y.Text = String.Format("{0:F4}", controllerState.rAxis4.y);
}));
break;
case ETrackedControllerRole.RightHand:
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
CRIndex.Text = String.Format("{0}", unDevice);
CRVectorX.Text = String.Format("{0:F4}", position.v0);
CRVectorY.Text = String.Format("{0:F4}", position.v1);
CRVectorZ.Text = String.Format("{0:F4}", position.v2);
CRQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
CRQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
CRQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
CRQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
CRState.Text = GetDeviceState(eTrackingResult);
CRulPressed.Text = String.Format("{0}", controllerState.ulButtonPressed);
CRulTouched.Text = String.Format("{0}", controllerState.ulButtonTouched);
CRAxis0X.Text = String.Format("{0:F4}", controllerState.rAxis0.x);
CRAxis0Y.Text = String.Format("{0:F4}", controllerState.rAxis0.y);
CRAxis1X.Text = String.Format("{0:F4}", controllerState.rAxis1.x);
CRAxis1Y.Text = String.Format("{0:F4}", controllerState.rAxis1.y);
CRAxis2X.Text = String.Format("{0:F4}", controllerState.rAxis2.x);
CRAxis2Y.Text = String.Format("{0:F4}", controllerState.rAxis2.y);
CRAxis3X.Text = String.Format("{0:F4}", controllerState.rAxis3.x);
CRAxis3Y.Text = String.Format("{0:F4}", controllerState.rAxis3.y);
CRAxis4X.Text = String.Format("{0:F4}", controllerState.rAxis4.x);
CRAxis4Y.Text = String.Format("{0:F4}", controllerState.rAxis4.y);
}));
break;
}
break;
case ETrackedDeviceClass.GenericTracker:
system.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, unDevice, ref controllerState, (uint)Marshal.SizeOf(controllerState), ref TrackedDevicePose);
// get the position and rotation
position = GetPosition(TrackedDevicePose.mDeviceToAbsoluteTracking);
quaternion = GetRotation(TrackedDevicePose.mDeviceToAbsoluteTracking);
// for printing some more info to the user about the state of the device/pose
eTrackingResult = m_rTrackedDevicePose[unDevice].eTrackingResult;
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
TrackerIndex.Text = String.Format("{0}", unDevice);
TrackerVectorX.Text = String.Format("{0:F4}", position.v0);
TrackerVectorY.Text = String.Format("{0:F4}", position.v1);
TrackerVectorZ.Text = String.Format("{0:F4}", position.v2);
TrackerQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
TrackerQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
TrackerQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
TrackerQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
TrackerState.Text = GetDeviceState(eTrackingResult);
}));
break;
}
Thread.Sleep(10);
}
}
}
/// <summary>
/// Overrides the Update method, called every frame.
/// </summary>
void Update()
{
// do nothing unless we are in IVA
hmdIsAllowed = (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA);
// start HMD using the Y key
if (Input.GetKeyDown(KeyCode.Y) && hmdIsAllowed)
{
if (!hmdIsInitialized)
{
Debug.Log("[KerbalVR] Initializing HMD...");
bool retVal = InitHMD();
if (retVal)
{
Debug.Log("[KerbalVR] HMD initialized.");
}
}
else
{
ResetInitialHmdPosition();
}
}
// perform regular updates if HMD is initialized
if (hmdIsAllowed && hmdIsInitialized)
{
EVRCompositorError vrCompositorError = EVRCompositorError.None;
// get latest HMD pose
//--------------------------------------------------------------
vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseSeated, 0.0f, vrDevicePoses);
HmdMatrix34_t vrLeftEyeTransform = vrSystem.GetEyeToHeadTransform(EVREye.Eye_Left);
HmdMatrix34_t vrRightEyeTransform = vrSystem.GetEyeToHeadTransform(EVREye.Eye_Right);
vrCompositorError = vrCompositor.WaitGetPoses(vrRenderPoses, vrGamePoses);
if (vrCompositorError != EVRCompositorError.None)
{
Debug.Log("[KerbalVR] WaitGetPoses failed: " + (int)vrCompositorError);
return;
}
// convert SteamVR poses to Unity coordinates
var hmdTransform = new SteamVR_Utils.RigidTransform(vrDevicePoses[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking);
var hmdLeftEyeTransform = new SteamVR_Utils.RigidTransform(vrLeftEyeTransform);
var hmdRightEyeTransform = new SteamVR_Utils.RigidTransform(vrRightEyeTransform);
var ctrlPoseLeft = new SteamVR_Utils.RigidTransform(vrDevicePoses[ctrlIndexLeft].mDeviceToAbsoluteTracking);
var ctrlPoseRight = new SteamVR_Utils.RigidTransform(vrDevicePoses[ctrlIndexRight].mDeviceToAbsoluteTracking);
// Render the LEFT eye
//--------------------------------------------------------------
// rotate camera according to the HMD orientation
InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
// translate the camera to match the position of the left eye, from origin
InternalCamera.Instance.transform.localPosition = new Vector3(0f, 0f, 0f);
InternalCamera.Instance.transform.Translate(hmdLeftEyeTransform.pos);
// translate the camera to match the position of the HMD
InternalCamera.Instance.transform.localPosition += hmdTransform.pos;
// move the FlightCamera to match the position of the InternalCamera (so the outside world moves accordingly)
FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
// render the set of cameras
foreach (CameraProperties camStruct in camerasToRender)
{
// set projection matrix
camStruct.camera.projectionMatrix = camStruct.hmdLeftProjMatrix;
// set texture to render to
camStruct.camera.targetTexture = hmdLeftEyeRenderTexture;
RenderTexture.active = hmdLeftEyeRenderTexture;
// render camera
camStruct.camera.Render();
}
// Render the RIGHT eye (see previous comments)
//--------------------------------------------------------------
InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
InternalCamera.Instance.transform.localPosition = new Vector3(0f, 0f, 0f);
InternalCamera.Instance.transform.Translate(hmdRightEyeTransform.pos);
InternalCamera.Instance.transform.localPosition += hmdTransform.pos;
FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
foreach (CameraProperties camStruct in camerasToRender)
{
camStruct.camera.projectionMatrix = camStruct.hmdRightProjMatrix;
camStruct.camera.targetTexture = hmdRightEyeRenderTexture;
RenderTexture.active = hmdRightEyeRenderTexture;
camStruct.camera.Render();
}
var origTex = uiCamera.targetTexture;
uiCamera.targetTexture = uiTexture;
RenderTexture.active = uiTexture;
uiCamera.Render();
uiCamera.targetTexture = origTex;
RenderTexture.active = null;
// Set camera position to an HMD-centered position (for regular screen rendering)
//--------------------------------------------------------------
if (renderToScreen)
{
foreach (CameraProperties camStruct in camerasToRender)
{
camStruct.camera.targetTexture = null;
RenderTexture.active = null;
camStruct.camera.projectionMatrix = camStruct.originalProjMatrix;
}
InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
InternalCamera.Instance.transform.localPosition = hmdTransform.pos;
FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
}
// Set position of the hand controller props
//--------------------------------------------------------------
if (propLeftHand != null)
{
propLeftHand.transform.position = InternalCamera.Instance.transform.parent.position;
propLeftHand.transform.rotation = InternalCamera.Instance.transform.parent.rotation;
propLeftHand.transform.Translate(ctrlPoseLeft.pos);
propLeftHand.transform.rotation *= ctrlPoseLeft.rot;
propLeftHandRenderer.enabled = vrDevicePoses[ctrlIndexLeft].bDeviceIsConnected;
uiScreen.transform.position = InternalSpace.InternalToWorld(propLeftHand.transform.position);
uiScreen.transform.rotation = InternalSpace.InternalToWorld(propLeftHand.transform.rotation);
uiScreen.transform.Rotate(90f, 0f, 0f);
}
if (propRightHand != null)
{
propRightHand.transform.position = InternalCamera.Instance.transform.parent.position;
propRightHand.transform.rotation = InternalCamera.Instance.transform.parent.rotation;
propRightHand.transform.Translate(ctrlPoseRight.pos);
propRightHand.transform.rotation *= ctrlPoseRight.rot;
propRightHandRenderer.enabled = vrDevicePoses[ctrlIndexRight].bDeviceIsConnected;
InternalProp closestProp = null;
float closestDistanceSqr = 10000f;
foreach (InternalProp prop in activeVesselInternalProps)
{
if (!prop.name.Equals(propRightHand.name))
{
Vector3 directionToTarget = prop.transform.position - gloveCollider.transform.position;
float distanceToTargetSqr = directionToTarget.sqrMagnitude;
if (distanceToTargetSqr < closestDistanceSqr)
{
closestDistanceSqr = distanceToTargetSqr;
closestProp = prop;
}
}
}
}
/*
* if (closestProp != null && closestDistanceSqr < 0.005f)
* {
* Debug.Log("[KerbalVR] closest prop: " + closestProp + ", " + closestDistanceSqr + " m2");
* foreach (InternalModule mod in closestProp.internalModules)
* {
* Debug.Log("[KerbalVR] module: " + mod.name);
* }
* }
*/
// Submit frames to HMD
//--------------------------------------------------------------
vrCompositorError = vrCompositor.Submit(EVREye.Eye_Left, ref hmdLeftEyeTexture, ref hmdTextureBounds, EVRSubmitFlags.Submit_Default);
if (vrCompositorError != EVRCompositorError.None)
{
Debug.Log("[KerbalVR] Submit (Eye_Left) failed: " + (int)vrCompositorError);
}
vrCompositorError = vrCompositor.Submit(EVREye.Eye_Right, ref hmdRightEyeTexture, ref hmdTextureBounds, EVRSubmitFlags.Submit_Default);
if (vrCompositorError != EVRCompositorError.None)
{
Debug.Log("[KerbalVR] Submit (Eye_Right) failed: " + (int)vrCompositorError);
}
// disable highlighting of parts due to mouse
// TODO: there needs to be a better way to do this. this affects the Part permanently
Part hoveredPart = Mouse.HoveredPart;
if (hoveredPart != null)
{
hoveredPart.HighlightActive = false;
hoveredPart.highlightColor.a = 0f;// = new Color(0f, 0f, 0f, 0f);
//Debug.Log("[KerbalVR] hovered part: " + hoveredPart.name);
}
// DEBUG
if (Input.GetKeyDown(KeyCode.O))
{
Debug.Log("[KerbalVR] POSITION hmdTransform : " + hmdTransform.pos.x + ", " + hmdTransform.pos.y + ", " + hmdTransform.pos.z);
Debug.Log("[KerbalVR] POSITION hmdLTransform : " + hmdLeftEyeTransform.pos.x + ", " + hmdLeftEyeTransform.pos.y + ", " + hmdLeftEyeTransform.pos.z);
Debug.Log("[KerbalVR] POSITION hmdRTransform : " + hmdRightEyeTransform.pos.x + ", " + hmdRightEyeTransform.pos.y + ", " + hmdRightEyeTransform.pos.z);
Debug.Log("[KerbalVR] POSITION ctrlPoseRight : " + ctrlPoseRight.pos.x + ", " + ctrlPoseRight.pos.y + ", " + ctrlPoseRight.pos.z);
Debug.Log("[KerbalVR] POSITION InternalCamera.Instance.transform.abs : " + InternalCamera.Instance.transform.position.x + ", " + InternalCamera.Instance.transform.position.y + ", " + InternalCamera.Instance.transform.position.z);
Debug.Log("[KerbalVR] POSITION InternalCamera.Instance.transform.rel : " + InternalCamera.Instance.transform.localPosition.x + ", " + InternalCamera.Instance.transform.localPosition.y + ", " + InternalCamera.Instance.transform.localPosition.z);
//Debug.Log("[KerbalVR] POSITION myprop.transform : " + testProp.transform.position.x + ", " + testProp.transform.position.y + ", " + testProp.transform.position.z);
uiScreen.layer = (uiScreen.layer == 31) ? 0 : uiScreen.layer + 1;
Debug.Log("[KerbalVR] prop layer = " + propLeftHand.gameObject.layer + ", screen obj layer = " + uiScreen.layer);
foreach (Camera c in Camera.allCameras)
{
Debug.Log("[KerbalVR] Camera: " + c.name + ", cullingMask = " + c.cullingMask);
}
}
}
// if we are exiting VR, restore the cameras
if (!hmdIsAllowed && hmdIsAllowed_prev)
{
foreach (CameraProperties camStruct in camerasToRender)
{
camStruct.camera.projectionMatrix = camStruct.originalProjMatrix;
camStruct.camera.targetTexture = null;
RenderTexture.active = null;
}
}
hmdIsAllowed_prev = hmdIsAllowed;
}
