private static void CreateFile(string fullPath, CodeCompileUnit compileUnit)
{
// Generate the code with the C# code provider.
CSharpCodeProvider provider = new CSharpCodeProvider();
// Build the output file name.
string fullSourceFilePath = fullPath;
//Debug.Log("[SteamVR] Writing class to: " + fullSourceFilePath);
string path = GetClassPath();
string[] parts = path.Split('/');
for (int partIndex = 0; partIndex < parts.Length - 1; partIndex++)
{
string directoryPath = string.Join("/", parts.Take(partIndex + 1).ToArray());
if (Directory.Exists(directoryPath) == false)
{
Directory.CreateDirectory(directoryPath);
//Debug.Log("[SteamVR] Created directory: " + directoryPath);
}
}
string priorMD5 = null;
FileInfo file = new FileInfo(fullSourceFilePath);
if (file.Exists)
{
file.IsReadOnly = false;
priorMD5 = SteamVR_Utils.GetBadMD5HashFromFile(fullSourceFilePath);
}
// Create a TextWriter to a StreamWriter to the output file.
using (StreamWriter sw = new StreamWriter(fullSourceFilePath, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(compileUnit, tw,
new CodeGeneratorOptions()
{
BracingStyle = "C"
});
// Close the output file.
tw.Close();
string newMD5 = SteamVR_Utils.GetBadMD5HashFromFile(fullSourceFilePath);
if (priorMD5 != newMD5)
{
fileChanged = true;
}
}
//Debug.Log("[SteamVR] Complete! Input class at: " + fullSourceFilePath);
}
private IEnumerator RenderLoop()
{
while (Application.isPlaying)
{
yield return(this.waitForEndOfFrame);
if (!SteamVR_Render.pauseRendering)
{
CVRCompositor compositor = OpenVR.Compositor;
if (compositor != null)
{
if (!compositor.CanRenderScene() || cameras.Length < 1)
{
continue;
}
compositor.SetTrackingSpace(SteamVR.settings.trackingSpace);
SteamVR_Utils.QueueEventOnRenderThread(201510020);
SteamVR.Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - Begin");
SteamVR_Camera.GetSceneTexture(this.cameras[0].GetComponent <Camera>()).GetNativeTexturePtr();
SteamVR.Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - End");
compositor.GetLastPoses(this.poses, this.gamePoses);
SteamVR_Events.NewPoses.Send(this.poses);
SteamVR_Events.NewPosesApplied.Send();
}
SteamVR_Overlay instance = SteamVR_Overlay.instance;
if (instance != null)
{
instance.UpdateOverlay();
}
if (this.CheckExternalCamera())
{
this.RenderExternalCamera();
}
SteamVR instance2 = SteamVR.instance;
this.RenderEye(instance2, EVREye.Eye_Left);
this.RenderEye(instance2, EVREye.Eye_Right);
foreach (SteamVR_Camera steamVR_Camera in this.cameras)
{
steamVR_Camera.transform.localPosition = Vector3.zero;
steamVR_Camera.transform.localRotation = Quaternion.identity;
}
if (this.cameraMask != null)
{
this.cameraMask.Clear();
}
}
}
yield break;
}
void OnRenderImage(RenderTexture src, RenderTexture dest)
{
if (SteamVR_Render.Top() == this)
{
int eventID;
if (SteamVR_Render.eye == EVREye.Eye_Left)
{
// Get gpu started on work early to avoid bubbles at the top of the frame.
SteamVR_Utils.QueueEventOnRenderThread(SteamVR.OpenVRMagic.k_nRenderEventID_Flush);
eventID = SteamVR.OpenVRMagic.k_nRenderEventID_SubmitL;
}
else
{
eventID = SteamVR.OpenVRMagic.k_nRenderEventID_SubmitR;
}
// Queue up a call on the render thread to Submit our render target to the compositor.
SteamVR_Utils.QueueEventOnRenderThread(eventID);
}
if (SteamVR_Camera.doomp)
{
Debug.Log(Time.frameCount.ToString() + "/Camera_OnRenderImage");
DumpRenderTexture(src, Application.streamingAssetsPath + "/Camera_OnRenderImage_src.png");
}
RenderTexture.active = dest;
SteamVR_Camera.blitMaterial.mainTexture = src;
GL.PushMatrix();
GL.LoadOrtho();
SteamVR_Camera.blitMaterial.SetPass(0);
GL.Begin(7);
GL.TexCoord2(0.0f, 0.0f); GL.Vertex3(-1, 1, 0);
GL.TexCoord2(1.0f, 0.0f); GL.Vertex3(1, 1, 0);
GL.TexCoord2(1.0f, 1.0f); GL.Vertex3(1, -1, 0);
GL.TexCoord2(0.0f, 1.0f); GL.Vertex3(-1, -1, 0);
GL.End();
GL.PopMatrix();
if (SteamVR_Camera.doomp)
{
DumpRenderTexture(dest, Application.streamingAssetsPath + "/Camera_OnRenderImage_dst.png");
}
RenderTexture.active = null;
}
private static MethodInfo GetMethod(string methodName, Type[] parameters = null)
{
if (xrMetadataStoreType == null)
{
xrMetadataStoreType = SteamVR_Utils.FindType("UnityEditor.XR.Management.Metadata.XRPackageMetadataStore");
}
if (parameters == null)
{
return(xrMetadataStoreType.GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic));
}
else
{
return(xrMetadataStoreType.GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic, null, parameters, null));
}
}
private static void CreateFile(string fullPath, CodeCompileUnit compileUnit)
{
// Generate the code with the C# code provider.
CSharpCodeProvider provider = new CSharpCodeProvider();
// Build the output file name.
string fullSourceFilePath = fullPath;
//Debug.Log("[SteamVR] Writing class to: " + fullSourceFilePath);
string path = GetClassPath();
string priorMD5 = null;
FileInfo file = new FileInfo(fullSourceFilePath);
if (file.Exists)
{
file.IsReadOnly = false;
priorMD5 = SteamVR_Utils.GetBadMD5HashFromFile(fullSourceFilePath);
}
// Create a TextWriter to a StreamWriter to the output file.
using (StreamWriter sw = new StreamWriter(fullSourceFilePath, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(compileUnit, tw,
new CodeGeneratorOptions()
{
BracingStyle = "C"
});
// Close the output file.
tw.Close();
string newMD5 = SteamVR_Utils.GetBadMD5HashFromFile(fullSourceFilePath);
if (priorMD5 != newMD5)
{
fileChanged = true;
}
}
//Debug.Log("[SteamVR] Complete! Input class at: " + fullSourceFilePath);
}
/// <summary>
/// SteamVR keeps a log of past poses so you can retrieve old poses or estimated poses in the future by passing in a secondsFromNow value that is negative or positive.
/// </summary>
/// <param name="secondsFromNow">The time offset in the future (estimated) or in the past (previously recorded) you want to get data from</param>
/// <returns>true if we successfully returned a pose</returns>
public bool GetPoseAtTimeOffset(float secondsFromNow, out Vector3 positionAtTime, out Quaternion rotationAtTime, out Vector3 velocityAtTime, out Vector3 angularVelocityAtTime)
{
EVRInputError err = OpenVR.Input.GetPoseActionDataRelativeToNow(handle, universeOrigin, secondsFromNow, ref tempPoseActionData, poseActionData_size, inputSourceHandle);
if (err != EVRInputError.None)
{
Debug.LogError("<b>[SteamVR]</b> GetPoseActionData error (" + fullPath + "): " + err.ToString() + " handle: " + handle.ToString()); //todo: this should be an error
velocityAtTime = Vector3.zero;
angularVelocityAtTime = Vector3.zero;
positionAtTime = Vector3.zero;
rotationAtTime = Quaternion.identity;
return(false);
}
velocityAtTime = GetUnityCoordinateVelocity(tempPoseActionData.pose.vVelocity);
angularVelocityAtTime = GetUnityCoordinateAngularVelocity(tempPoseActionData.pose.vAngularVelocity);
positionAtTime = SteamVR_Utils.GetPosition(tempPoseActionData.pose.mDeviceToAbsoluteTracking);
rotationAtTime = SteamVR_Utils.GetRotation(tempPoseActionData.pose.mDeviceToAbsoluteTracking);
return(true);
}
/// <summary>
/// Load from disk and deserialize the actions file
/// </summary>
/// <param name="force">Force a refresh of this file from disk</param>
public static bool InitializeFile(bool force = false)
{
string projectPath = Application.dataPath;
int lastIndex = projectPath.LastIndexOf("/");
projectPath = projectPath.Remove(lastIndex, projectPath.Length - lastIndex);
actionsFilePath = Path.Combine(projectPath, SteamVR_Settings.instance.actionsFilePath);
string jsonText = null;
if (File.Exists(actionsFilePath))
{
jsonText = System.IO.File.ReadAllText(actionsFilePath);
}
else
{
Debug.LogErrorFormat("[SteamVR] Actions file does not exist in project root: {0}", actionsFilePath);
return(false);
}
if (fileInitialized == true || (fileInitialized == true && force == false))
{
string newHash = SteamVR_Utils.GetBadMD5Hash(jsonText);
if (newHash == actionFileHash)
{
return(true);
}
actionFileHash = newHash;
}
actionFile = Newtonsoft.Json.JsonConvert.DeserializeObject <SteamVR_Input_ActionFile>(jsonText);
actionFile.InitializeHelperLists();
fileInitialized = true;
return(true);
}
protected IEnumerator DoRangeOfMotionBlend(EVRSkeletalMotionRange oldRangeOfMotion, EVRSkeletalMotionRange newRangeOfMotion, float overTime)
{
float startTime = Time.time;
float endTime = startTime + overTime;
while (Time.time < endTime)
{
yield return(null);
float lerp = (Time.time - startTime) / overTime;
if (skeletonBlend > 0)
{
skeletonAction.SetRangeOfMotion(oldRangeOfMotion);
skeletonAction.UpdateValueWithoutEvents();
CopyBonePositions(oldROMPositionBuffer);
CopyBoneRotations(oldROMRotationBuffer);
skeletonAction.SetRangeOfMotion(newRangeOfMotion);
skeletonAction.UpdateValueWithoutEvents();
CopyBonePositions(newROMPositionBuffer);
CopyBoneRotations(newROMRotationBuffer);
for (int boneIndex = 0; boneIndex < bones.Length; boneIndex++)
{
if (bones[boneIndex] == null)
{
continue;
}
if (SteamVR_Utils.IsValid(newROMRotationBuffer[boneIndex]) == false || SteamVR_Utils.IsValid(oldROMRotationBuffer[boneIndex]) == false)
{
continue;
}
Vector3 blendedRangeOfMotionPosition = Vector3.Lerp(oldROMPositionBuffer[boneIndex], newROMPositionBuffer[boneIndex], lerp);
Quaternion blendedRangeOfMotionRotation = Quaternion.Lerp(oldROMRotationBuffer[boneIndex], newROMRotationBuffer[boneIndex], lerp);
if (skeletonBlend < 1)
{
if (blendPoser != null)
{
SetBonePosition(boneIndex, Vector3.Lerp(blendSnapshot.bonePositions[boneIndex], blendedRangeOfMotionPosition, skeletonBlend));
SetBoneRotation(boneIndex, Quaternion.Lerp(blendSnapshot.boneRotations[boneIndex], blendedRangeOfMotionRotation, skeletonBlend));
}
else
{
SetBonePosition(boneIndex, Vector3.Lerp(bones[boneIndex].localPosition, blendedRangeOfMotionPosition, skeletonBlend));
SetBoneRotation(boneIndex, Quaternion.Lerp(bones[boneIndex].localRotation, blendedRangeOfMotionRotation, skeletonBlend));
}
}
else
{
SetBonePosition(boneIndex, blendedRangeOfMotionPosition);
SetBoneRotation(boneIndex, blendedRangeOfMotionRotation);
}
}
}
if (onBoneTransformsUpdated != null)
{
onBoneTransformsUpdated.Invoke(this, inputSource);
}
if (onBoneTransformsUpdatedEvent != null)
{
onBoneTransformsUpdatedEvent.Invoke(this, inputSource);
}
}
rangeOfMotionBlendRoutine = null;
}
public void UpdateComponents(CVRRenderModels renderModels)
{
if (renderModels == null)
{
return;
}
if (transform.childCount == 0)
{
return;
}
if (nameCache == null)
{
nameCache = new Dictionary <int, string>();
}
for (int childIndex = 0; childIndex < transform.childCount; childIndex++)
{
Transform child = transform.GetChild(childIndex);
// Cache names since accessing an object's name allocate memory.
string componentName;
if (!nameCache.TryGetValue(child.GetInstanceID(), out componentName))
{
componentName = child.name;
nameCache.Add(child.GetInstanceID(), componentName);
}
var componentState = new RenderModel_ComponentState_t();
if (!renderModels.GetComponentStateForDevicePath(renderModelName, componentName,
SteamVR_Input_Source.GetHandle(inputSource), ref controllerModeState, ref componentState))
{
continue;
}
child.localPosition = SteamVR_Utils.GetPosition(componentState.mTrackingToComponentRenderModel);
child.localRotation = SteamVR_Utils.GetRotation(componentState.mTrackingToComponentRenderModel);
Transform attach = null;
for (int childChildIndex = 0; childChildIndex < child.childCount; childChildIndex++)
{
Transform childChild = child.GetChild(childChildIndex);
int childInstanceID = childChild.GetInstanceID();
string childName;
if (!nameCache.TryGetValue(childInstanceID, out childName))
{
childName = childChild.name;
nameCache.Add(childInstanceID, componentName);
}
if (childName == SteamVR_RenderModel.k_localTransformName)
{
attach = childChild;
}
}
if (attach != null)
{
attach.position =
transform.TransformPoint(SteamVR_Utils.GetPosition(componentState.mTrackingToComponentLocal));
attach.rotation = transform.rotation *
SteamVR_Utils.GetRotation(componentState.mTrackingToComponentLocal);
initializedAttachPoints = true;
}
bool visible = (componentState.uProperties & (uint)EVRComponentProperty.IsVisible) != 0;
if (visible != child.gameObject.activeSelf)
{
child.gameObject.SetActive(visible);
}
}
}
public void Interpolate(RigidTransform to, float t)
{
pos = SteamVR_Utils.Lerp(pos, to.pos, t);
rot = SteamVR_Utils.Slerp(rot, to.rot, t);
}
protected IEnumerator DoRangeOfMotionBlend(EVRSkeletalMotionRange oldRangeOfMotion, EVRSkeletalMotionRange newRangeOfMotion, float overTime)
{
float startTime = Time.time;
float endTime = startTime + overTime;
Vector3[] oldBonePositions;
Quaternion[] oldBoneRotations;
Vector3[] newBonePositions;
Quaternion[] newBoneRotations;
while (Time.time < endTime)
{
yield return(null);
float lerp = (Time.time - startTime) / overTime;
if (skeletonBlend > 0)
{
skeletonAction.SetRangeOfMotion(inputSource, oldRangeOfMotion);
skeletonAction.UpdateValue(inputSource, true);
oldBonePositions = (Vector3[])GetBonePositions(inputSource).Clone();
oldBoneRotations = (Quaternion[])GetBoneRotations(inputSource).Clone();
skeletonAction.SetRangeOfMotion(inputSource, newRangeOfMotion);
skeletonAction.UpdateValue(inputSource, true);
newBonePositions = GetBonePositions(inputSource);
newBoneRotations = GetBoneRotations(inputSource);
for (int boneIndex = 0; boneIndex < bones.Length; boneIndex++)
{
if (bones[boneIndex] == null)
{
continue;
}
if (SteamVR_Utils.IsValid(newBoneRotations[boneIndex]) == false || SteamVR_Utils.IsValid(oldBoneRotations[boneIndex]) == false)
{
continue;
}
Vector3 blendedRangeOfMotionPosition = Vector3.Lerp(oldBonePositions[boneIndex], newBonePositions[boneIndex], lerp);
Quaternion blendedRangeOfMotionRotation = Quaternion.Lerp(oldBoneRotations[boneIndex], newBoneRotations[boneIndex], lerp);
if (skeletonBlend < 1)
{
SetBonePosition(boneIndex, Vector3.Lerp(bones[boneIndex].localPosition, blendedRangeOfMotionPosition, skeletonBlend));
SetBoneRotation(boneIndex, Quaternion.Lerp(bones[boneIndex].localRotation, blendedRangeOfMotionRotation, skeletonBlend));
}
else
{
SetBonePosition(boneIndex, blendedRangeOfMotionPosition);
SetBoneRotation(boneIndex, blendedRangeOfMotionRotation);
}
}
}
}
rangeOfMotionBlendRoutine = null;
}
/// <summary>The last local rotation of the pose relative to the center of the tracked space.</summary>
/// <param name="inputSource">The device you would like to get data from. Any if the action is not device specific.</param>
public Quaternion GetLastLocalRotation(SteamVR_Input_Sources inputSource)
{
return(SteamVR_Utils.GetRotation(lastPoseActionData[inputSource].pose.mDeviceToAbsoluteTracking));
}
public static Mesh CreateHiddenAreaMesh(HiddenAreaMesh_t src, VRTextureBounds_t bounds)
{
if (src.unTriangleCount == 0u)
{
return(null);
}
float[] array = new float[src.unTriangleCount * 3u * 2u];
Marshal.Copy(src.pVertexData, array, 0, array.Length);
Vector3[] array2 = new Vector3[src.unTriangleCount * 3u + 12u];
int[] array3 = new int[src.unTriangleCount * 3u + 24u];
float num = 2f * bounds.uMin - 1f;
float num2 = 2f * bounds.uMax - 1f;
float num3 = 2f * bounds.vMin - 1f;
float num4 = 2f * bounds.vMax - 1f;
int num5 = 0;
int num6 = 0;
while ((long)num5 < (long)((ulong)(src.unTriangleCount * 3u)))
{
float x = SteamVR_Utils.Lerp(num, num2, array[num6++]);
float y = SteamVR_Utils.Lerp(num3, num4, array[num6++]);
array2[num5] = new Vector3(x, y, 0f);
array3[num5] = num5;
num5++;
}
int num7 = (int)(src.unTriangleCount * 3u);
int num8 = num7;
array2[num8++] = new Vector3(-1f, -1f, 0f);
array2[num8++] = new Vector3(num, -1f, 0f);
array2[num8++] = new Vector3(-1f, 1f, 0f);
array2[num8++] = new Vector3(num, 1f, 0f);
array2[num8++] = new Vector3(num2, -1f, 0f);
array2[num8++] = new Vector3(1f, -1f, 0f);
array2[num8++] = new Vector3(num2, 1f, 0f);
array2[num8++] = new Vector3(1f, 1f, 0f);
array2[num8++] = new Vector3(num, num3, 0f);
array2[num8++] = new Vector3(num2, num3, 0f);
array2[num8++] = new Vector3(num, num4, 0f);
array2[num8++] = new Vector3(num2, num4, 0f);
int num9 = num7;
array3[num9++] = num7;
array3[num9++] = num7 + 1;
array3[num9++] = num7 + 2;
array3[num9++] = num7 + 2;
array3[num9++] = num7 + 1;
array3[num9++] = num7 + 3;
array3[num9++] = num7 + 4;
array3[num9++] = num7 + 5;
array3[num9++] = num7 + 6;
array3[num9++] = num7 + 6;
array3[num9++] = num7 + 5;
array3[num9++] = num7 + 7;
array3[num9++] = num7 + 1;
array3[num9++] = num7 + 4;
array3[num9++] = num7 + 8;
array3[num9++] = num7 + 8;
array3[num9++] = num7 + 4;
array3[num9++] = num7 + 9;
array3[num9++] = num7 + 10;
array3[num9++] = num7 + 11;
array3[num9++] = num7 + 3;
array3[num9++] = num7 + 3;
array3[num9++] = num7 + 11;
array3[num9++] = num7 + 6;
return(new Mesh
{
vertices = array2,
triangles = array3,
bounds = new Bounds(Vector3.zero, new Vector3(float.MaxValue, float.MaxValue, float.MaxValue))
});
}
private IEnumerator RenderLoop()
{
while (Application.isPlaying)
{
yield return(waitForEndOfFrame);
if (cameras.Length == 0)
{
continue;
}
if (pauseRendering)
{
continue;
}
var compositor = OpenVR.Compositor;
if (compositor != null)
{
if (!compositor.CanRenderScene())
{
continue;
}
compositor.SetTrackingSpace(SteamVR.settings.trackingSpace);
SteamVR_Utils.QueueEventOnRenderThread(SteamVR.OpenVRMagic.k_nRenderEventID_WaitGetPoses);
// Hack to flush render event that was queued in Update (this ensures WaitGetPoses has returned before we grab the new values).
SteamVR.OpenVRMagic.EventWriteString("[UnityMain] GetNativeTexturePtr - Begin");
SteamVR_Camera.GetSceneTexture(cameras[0].GetComponent <Camera>().allowHDR).GetNativeTexturePtr();
SteamVR.OpenVRMagic.EventWriteString("[UnityMain] GetNativeTexturePtr - End");
compositor.GetLastPoses(poses, gamePoses);
SteamVR_Events.NewPoses.Send(poses);
SteamVR_Events.NewPosesApplied.Send();
}
var overlay = SteamVR_Overlay.instance;
if (overlay != null)
{
overlay.UpdateOverlay();
}
RenderExternalCamera();
var vr = SteamVR.instance;
RenderEye(vr, EVREye.Eye_Left);
RenderEye(vr, EVREye.Eye_Right);
// Move cameras back to head position so they can be tracked reliably
foreach (var c in cameras)
{
c.transform.localPosition = Vector3.zero;
c.transform.localRotation = Quaternion.identity;
}
if (cameraMask != null)
{
cameraMask.Clear();
}
}
}
private void FixedUpdate()
{
SteamVR_Utils.QueueEventOnRenderThread(201510024);
}
void Update()
{
if (cameras.Length == 0)
{
return;
}
this.UpdatePoses();
// If our FixedUpdate rate doesn't match our render framerate, then catch the handoff here.
SteamVR_Utils.QueueEventOnRenderThread(SteamVR.OpenVRMagic.k_nRenderEventID_PostPresentHandoff);
// Force controller update in case no one else called this frame to ensure prevState gets updated.
// Dispatch any OpenVR events.
var system = OpenVR.System;
if (system != null)
{
var vrEvent = new VREvent_t();
var size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t));
for (int i = 0; i < 64; i++)
{
if (!system.PollNextEvent(ref vrEvent, size))
{
break;
}
switch ((EVREventType)vrEvent.eventType)
{
case EVREventType.VREvent_InputFocusCaptured: // another app has taken focus (likely dashboard)
if (vrEvent.data.process.oldPid == 0)
{
SteamVR_Events.InputFocus.Send(false);
}
break;
case EVREventType.VREvent_InputFocusReleased: // that app has released input focus
if (vrEvent.data.process.pid == 0)
{
SteamVR_Events.InputFocus.Send(true);
}
break;
case EVREventType.VREvent_ShowRenderModels:
SteamVR_Events.HideRenderModels.Send(false);
break;
case EVREventType.VREvent_HideRenderModels:
SteamVR_Events.HideRenderModels.Send(true);
break;
default:
SteamVR_Events.System((EVREventType)vrEvent.eventType).Send(vrEvent);
break;
}
}
}
// Ensure various settings to minimize latency.
Application.targetFrameRate = -1;
Application.runInBackground = true; // don't require companion window focus
QualitySettings.maxQueuedFrames = -1;
QualitySettings.vSyncCount = 0; // this applies to the companion window
}
void FixedUpdate()
{
// We want to call this as soon after Present as possible.
SteamVR_Utils.QueueEventOnRenderThread(SteamVR.OpenVRMagic.k_nRenderEventID_PostPresentHandoff);
}
