public static void UpdateTrackableDevicePosition()
{
VRControllerState_t controllerState = new VRControllerState_t();
var size = (uint)Marshal.SizeOf(typeof(VRControllerState_t));
HmdVector3_t position = new HmdVector3_t();
HmdQuaternion_t quaternion = new HmdQuaternion_t();
uint LeftControllerIndex = OpenVR.System.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.LeftHand),
RightControllerIndex = OpenVR.System.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.RightHand);
OpenVR.System.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 1 / Program.DataFrameRate, TrackedDevicePose_t);
if (TrackedDevicePose_t[0].bPoseIsValid)
{
GetPosition(TrackedDevicePose_t[0].mDeviceToAbsoluteTracking, ref position);
GetRotation(TrackedDevicePose_t[0].mDeviceToAbsoluteTracking, ref quaternion);
VREventCallback.NewPoseEvent(VREventCallback.DeviceType.HMD, position, quaternion);
}
OpenVR.System.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, LeftControllerIndex, ref controllerState, size, ref LeftControllerPose);
if (LeftControllerPose.bPoseIsValid)
{
GetPosition(LeftControllerPose.mDeviceToAbsoluteTracking, ref position);
GetRotation(LeftControllerPose.mDeviceToAbsoluteTracking, ref quaternion);
VREventCallback.NewPoseEvent(VREventCallback.DeviceType.LeftController, position, quaternion);
}
OpenVR.System.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, RightControllerIndex, ref controllerState, size, ref RightControllerPose);
if (RightControllerPose.bPoseIsValid)
{
GetPosition(RightControllerPose.mDeviceToAbsoluteTracking, ref position);
GetRotation(RightControllerPose.mDeviceToAbsoluteTracking, ref quaternion);
VREventCallback.NewPoseEvent(VREventCallback.DeviceType.RightController, position, quaternion);
}
}
// Use this for initialization
void Start()
{
var rect = new HmdQuad_t();
if (!SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect))
{
return;
}
// Could do without that
var cornersVR = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
corners = new Vector3[cornersVR.Length];
for (int i = 0; i < cornersVR.Length; i++)
{
var c = cornersVR[i];
corners[i] = new Vector3(c.v0, 0.01f, c.v2);
}
// Make sure this is always the case
minX = -Mathf.Abs(corners[0].x);
maxX = Mathf.Abs(corners[0].x);
minZ = -Mathf.Abs(corners[0].z);
maxZ = Mathf.Abs(corners[0].z);
music = transform.GetComponent <AudioSource>();
mixer = music.outputAudioMixerGroup.audioMixer;
// Debugging
text = GetComponentInChildren <TextMesh>();
}
public HmdVector3_t GetRotationEuler(HmdMatrix34_t matrix)
{
try
{
HmdVector3_t v = new HmdVector3_t();
float r2d = 180 / (float)Math.PI;
if (matrix.m0 == 1 || matrix.m0 == -1)
{
v.v0 = -((-((float)Math.Atan2(matrix.m2, matrix.m11)) * r2d));
v.v1 = 0;
v.v2 = 0;
}
else
{
v.v0 = -(((-(float)Math.Atan2(matrix.m8, matrix.m0)) * r2d));
v.v1 = -(((float)Math.Atan2(matrix.m6, matrix.m5)) * r2d);
v.v2 = (((float)Math.Asin(matrix.m4)) * r2d);
}
return(v);
}
catch (Exception ex)
{
HmdVector3_t vt = new HmdVector3_t();
vt.v0 = 0.0f;
vt.v1 = 0.0f;
vt.v2 = 0.0f;
return(vt);
}
}
void GetCollisionBoundsMesh()
{
List <Vector3> _vertices = new List <Vector3>();
foreach (HmdQuad_t quad in pCollisionQuadsBuffer1)
{
HmdVector3_t vCorners0 = quad.vCorners0;
HmdVector3_t vCorners1 = quad.vCorners1;
HmdVector3_t vCorners2 = quad.vCorners2;
HmdVector3_t vCorners3 = quad.vCorners3;
_vertices.Add(new Vector3(vCorners0.v0, vCorners0.v1, vCorners0.v2));
_vertices.Add(new Vector3(vCorners1.v0, vCorners1.v1, vCorners1.v2));
_vertices.Add(new Vector3(vCorners2.v0, vCorners2.v1, vCorners2.v2));
_vertices.Add(new Vector3(vCorners3.v0, vCorners3.v1, vCorners3.v2));
}
vertices1 = _vertices.ToArray();
_vertices.Clear();
foreach (HmdQuad_t quad in pCollisionQuadsBuffer2)
{
HmdVector3_t vCorners0 = quad.vCorners0;
HmdVector3_t vCorners1 = quad.vCorners1;
HmdVector3_t vCorners2 = quad.vCorners2;
HmdVector3_t vCorners3 = quad.vCorners3;
_vertices.Add(new Vector3(vCorners0.v0, vCorners0.v1, vCorners0.v2));
_vertices.Add(new Vector3(vCorners1.v0, vCorners1.v1, vCorners1.v2));
_vertices.Add(new Vector3(vCorners2.v0, vCorners2.v1, vCorners2.v2));
_vertices.Add(new Vector3(vCorners3.v0, vCorners3.v1, vCorners3.v2));
}
vertices2 = _vertices.ToArray();
}
private Vector3 GetVector3FromHmdVector(HmdVector3_t hmdVector3)
{
Vector3 output = new Vector3(hmdVector3.v0, hmdVector3.v1, hmdVector3.v2);
print(output);
return(output);
}
public static DeviceState GetControllerPose(int controllerIndex, out Matrix pose, out Vector3 velocity, out Vector3 angVelocity)
{
var currentIndex = 0;
pose = Matrix.Identity;
velocity = Vector3.Zero;
angVelocity = Vector3.Zero;
for (uint index = 0; index < DevicePoses.Length; index++)
{
if (Valve.VR.OpenVR.System.GetTrackedDeviceClass(index) == ETrackedDeviceClass.Controller)
{
if (currentIndex == controllerIndex)
{
HmdMatrix34_t openVRPose = DevicePoses[index].mDeviceToAbsoluteTracking;
pose.M11 = openVRPose.m0;
pose.M21 = openVRPose.m1;
pose.M31 = openVRPose.m2;
pose.M41 = openVRPose.m3;
pose.M12 = openVRPose.m4;
pose.M22 = openVRPose.m5;
pose.M32 = openVRPose.m6;
pose.M42 = openVRPose.m7;
pose.M13 = openVRPose.m8;
pose.M23 = openVRPose.m9;
pose.M33 = openVRPose.m10;
pose.M43 = openVRPose.m11;
HmdVector3_t vel = DevicePoses[index].vVelocity;
velocity.X = vel.v0;
velocity.Y = vel.v1;
velocity.Z = vel.v2;
HmdVector3_t avel = DevicePoses[index].vAngularVelocity;
angVelocity.X = avel.v0;
angVelocity.Y = avel.v1;
angVelocity.Z = avel.v2;
var state = DeviceState.Invalid;
if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid)
{
state = DeviceState.Valid;
}
else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange)
{
state = DeviceState.OutOfRange;
}
return(state);
}
currentIndex++;
}
}
return(DeviceState.Invalid);
}
public void ApplyPlacement()
{
var rect = new HmdQuad_t();
if (SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect))
{
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
Bounds playareaBounds = new Bounds(Vector3.zero, new Vector3(Mathf.Abs(corners[0].v0 - corners[1].v0), 0, Mathf.Abs(corners[0].v2 - corners[3].v2)));
Vector3 closestPt = playareaBounds.ClosestPoint(playarea.InverseTransformPoint(transform.position));
transform.position = playarea.TransformPoint(closestPt);
}
}
private void OnNewPoses(TrackedDevicePose_t[] poses)
{
//Obtain hmd IMU position, accelerometer & gyroscope data
HmdMatrix34_t pos = poses [0].mDeviceToAbsoluteTracking;
string position = "Position : " + pos.m0 + ":" + pos.m1 + ":" + pos.m2;
HmdVector3_t gyro = poses [0].vAngularVelocity;
string gyroscope = "Gyro : " + gyro.v0 + ":" + gyro.v1 + ":" + gyro.v2;
HmdVector3_t acc = poses[0].vVelocity;
string acceleration = "Acceleration : " + acc.v0 + ":" + acc.v1 + ":" + acc.v2;
//Debug.Log (position + " " + gyroscope + " " + acceleration);
//------------------------------------------------------------------------------
}
// This will resize the given object to match the player play area
void Start()
{
var rect = new HmdQuad_t();
if (SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect))
{
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
Vector3 scale = transform.localScale;
var width = Mathf.Abs(corners[0].v0 - corners[1].v0) / meshWidth * scale.x;
var length = Mathf.Abs(corners[0].v2 - corners[3].v2) / meshHeight * scale.y;
scale.Set(length, width, scale.z);
transform.localScale = scale;
}
}
public InputPoseActionData_t PoseFetchEventResult()
{
var size = (uint)Marshal.SizeOf(typeof(InputPoseActionData_t));
OpenVR.Input.GetPoseActionData(ActionHandle, ETrackingUniverseOrigin.TrackingUniverseStanding, 1 / Program.DataFrameRate, ref Pose, size, controller.ControllerHandle);
if (Pose.pose.bDeviceIsConnected == true && Pose.pose.bPoseIsValid == true)
{
HmdVector3_t position = new HmdVector3_t();
HmdQuaternion_t quaternion = new HmdQuaternion_t();
TrackableDeviceInfo.GetPosition(Pose.pose.mDeviceToAbsoluteTracking, ref position);
TrackableDeviceInfo.GetRotation(Pose.pose.mDeviceToAbsoluteTracking, ref quaternion);
VREventCallback.NewPoseEvent(controller.ControllerType, (PoseControllerEvent)this, position, quaternion);
}
return(Pose);
}
public ControllerEvent()
{
switch (EventType())
{
case EventTypeEmun.Digital:
Digital = new InputDigitalActionData_t();
break;
case EventTypeEmun.Analog:
Analog = new InputAnalogActionData_t();
break;
case EventTypeEmun.Pose:
Pose = new InputPoseActionData_t();
Position = new HmdVector3_t();
break;
}
}
public static DeviceState GetTrackerPose(int trackerIndex, ref Matrix pose, ref Vector3 velocity, ref Vector3 angVelocity)
{
var index = trackerIndex;
HmdMatrix34_t openVRPose = DevicePoses[index].mDeviceToAbsoluteTracking;
pose.M11 = openVRPose.m0;
pose.M21 = openVRPose.m1;
pose.M31 = openVRPose.m2;
pose.M41 = openVRPose.m3;
pose.M12 = openVRPose.m4;
pose.M22 = openVRPose.m5;
pose.M32 = openVRPose.m6;
pose.M42 = openVRPose.m7;
pose.M13 = openVRPose.m8;
pose.M23 = openVRPose.m9;
pose.M33 = openVRPose.m10;
pose.M43 = openVRPose.m11;
HmdVector3_t vel = DevicePoses[index].vVelocity;
velocity.X = vel.v0;
velocity.Y = vel.v1;
velocity.Z = vel.v2;
HmdVector3_t avel = DevicePoses[index].vAngularVelocity;
angVelocity.X = avel.v0;
angVelocity.Y = avel.v1;
angVelocity.Z = avel.v2;
var state = DeviceState.Invalid;
if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid)
{
state = DeviceState.Valid;
}
else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange)
{
state = DeviceState.OutOfRange;
}
return(state);
}
public void resize()
{
var rect = new HmdQuad_t();
if (!GetBounds(size, ref rect))
{
return;
}
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++)
{
var c = corners[i];
vertices[i] = new Vector3(c.v0, 0.01f, c.v2);
vector3Size.Value = (new Vector3(c.v0, 0f, c.v2));
}
}
private void BuildMesh()
{
var rect = new HmdQuad_t();
GetBounds(ref rect);
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++)
{
var c = corners[i];
vertices[i] = new Vector3(c.v0, 0.01f, c.v2);
}
for (int i = 0; i < corners.Length; i++)
{
vertices[corners.Length + i] = vertices[i];
}
}
public Vector3[] GetRectangle()
{
var rect = new HmdQuad_t();
if (!GetBounds(size, ref rect))
{
return(null);
}
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++)
{
var c = corners[i];
vertices[i] = new Vector3(c.v0, 0.01f, c.v2);
}
return(vertices);
}
public void resizePlatform()
{
var rect = new HmdQuad_t();
if (!SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect))
{
Debug.LogError("VRACMAN ERROR: Failed to get Calibrated Play Area bounds! Make sure you have tracking first, and that your space is calibrated.");
return;
}
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
Vector3 chapScale = transform.localScale;
chapScale.x = Mathf.Abs(corners[0].v0 - corners[1].v0) / 10;
chapScale.z = Mathf.Abs(corners[0].v2 - corners[3].v2) / 10;
transform.localScale = chapScale;
Platform.transform.localScale = chapScale;
bounds = Platform.GetComponentInChildren <MeshFilter>().mesh.bounds;
minx = bounds.min.x;
maxx = bounds.max.x;
miny = bounds.min.y;
minz = bounds.min.z;
maxz = bounds.max.z;
}
private bool generateInterior(HmdQuad_t rect, HmdVector3_t[] corners, List <Vector3> vertices, List <Vector2> uvs, out int[] faces)
{
int vertexOffset = vertices.Count;
for (int i = 0; i < corners.Length; i++)
{
HmdVector3_t c = corners[i];
vertices.Add(new Vector3(c.v0, c.v1, c.v2));
}
faces = new int[]
{
vertexOffset, vertexOffset + 1, vertexOffset + 3,
vertexOffset + 1, vertexOffset + 2, vertexOffset + 3
};
uvs.Add(new Vector2(rect.vCorners0.v0, rect.vCorners0.v2));
uvs.Add(new Vector2(rect.vCorners1.v0, rect.vCorners1.v2));
uvs.Add(new Vector2(rect.vCorners2.v0, rect.vCorners2.v2));
uvs.Add(new Vector2(rect.vCorners3.v0, rect.vCorners3.v2));
return(true);
}
public override bool ComputeOverlayIntersection(ref Compositor_OverlaySettings pSettings,float fAspectRatio,TrackingUniverseOrigin eOrigin,HmdVector3_t vSource,HmdVector3_t vDirection,ref HmdVector2_t pvecIntersectionUV,ref HmdVector3_t pvecIntersectionTrackingSpace)
{
CheckIfUsable();
bool result = VRNativeEntrypoints.VR_IVRCompositor_ComputeOverlayIntersection(m_pVRCompositor,ref pSettings,fAspectRatio,eOrigin,vSource,vDirection,ref pvecIntersectionUV,ref pvecIntersectionTrackingSpace);
return result;
}
public static void ToVector3(ref HmdVector3_t vector, out Vector3 result)
{
result.X = vector.v0;
result.Y = vector.v1;
result.Z = vector.v2;
}
/// Converts from SteamVR axis conventions and units to Unity
static private Vector3 UnityFromSteamVr(HmdVector3_t v)
{
return(new Vector3(v.v0, v.v1, v.v2) * App.METERS_TO_UNITS);
}
public void BuildMesh()
{
var rect = new HmdQuad_t();
if (!GetBounds(size, ref rect))
{
return;
}
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++)
{
var c = corners[i];
vertices[i] = new Vector3(c.v0, 0.01f, c.v2);
}
if (borderThickness == 0.0f)
{
GetComponent <MeshFilter>().mesh = null;
return;
}
for (int i = 0; i < corners.Length; i++)
{
int next = (i + 1) % corners.Length;
int prev = (i + corners.Length - 1) % corners.Length;
var nextSegment = (vertices[next] - vertices[i]).normalized;
var prevSegment = (vertices[prev] - vertices[i]).normalized;
var vert = vertices[i];
vert += Vector3.Cross(nextSegment, Vector3.up) * borderThickness;
vert += Vector3.Cross(prevSegment, Vector3.down) * borderThickness;
vertices[corners.Length + i] = vert;
}
var triangles = new int[]
{
0, 4, 1,
1, 4, 5,
1, 5, 2,
2, 5, 6,
2, 6, 3,
3, 6, 7,
3, 7, 0,
0, 7, 4
};
var uv = new Vector2[]
{
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f)
};
var colors = new Color[]
{
color,
color,
color,
color,
new Color(color.r, color.g, color.b, 0.0f),
new Color(color.r, color.g, color.b, 0.0f),
new Color(color.r, color.g, color.b, 0.0f),
new Color(color.r, color.g, color.b, 0.0f)
};
var mesh = new Mesh();
GetComponent <MeshFilter>().mesh = mesh;
mesh.vertices = vertices;
mesh.uv = uv;
mesh.colors = colors;
mesh.triangles = triangles;
var renderer = GetComponent <MeshRenderer>();
renderer.material = new Material(Shader.Find("Sprites/Default"));
renderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
renderer.lightProbeUsage = LightProbeUsage.Off;
}
public static Vector3 Convert(this HmdVector3_t vec)
{
return(new Vector3(vec.v0, vec.v1, vec.v2));
}
public abstract bool ComputeOverlayIntersection(ref Compositor_OverlaySettings pSettings,float fAspectRatio,TrackingUniverseOrigin eOrigin,HmdVector3_t vSource,HmdVector3_t vDirection,ref HmdVector2_t pvecIntersectionUV,ref HmdVector3_t pvecIntersectionTrackingSpace);
private void Worker()
{
Thread.CurrentThread.IsBackground = true;
// General
var deviceTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform();
var notificationTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform();
var animationTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform();
var width = 1f;
var height = 1f;
var properties = new Payload.CustomProperties();
var anchorIndex = uint.MaxValue;
var useWorldDeviceTransform = false;
// Follow
var follow = new Payload.Follow();
var originTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform();
var targetTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform();
var followLerp = 0.0;
var followTween = Tween.GetFunc(0);
var followIsLerping = false;
// General Animation
var stage = AnimationStage.Idle;
var hz = 60; // This default should never really be used as it reads Hz from headset.
var msPerFrame = 1000 / hz;
long timeStarted;
var animationCount = 0;
float animationSeconds = 0;
// Easing
var transition = new Payload.Transition();
var easeInCount = 0;
var stayCount = 0;
var easeOutCount = 0;
var easeInLimit = 0;
var stayLimit = 0;
var easeOutLimit = 0;
var tween = Tween.GetFunc(0);
// Cycling
var animateYaw = new Cycler();
var animatePitch = new Cycler();
var animateRoll = new Cycler();
var animateZ = new Cycler();
var animateY = new Cycler();
var animateX = new Cycler();
var animateScale = new Cycler();
var animateOpacity = new Cycler();
while (true)
{
timeStarted = DateTime.Now.Ticks;
bool skip = false;
if (_payload == null) // Get new payload
{
_requestForNewPayload?.Invoke();
skip = true;
Thread.Sleep(100);
}
else if (stage == AnimationStage.Idle)
{
#region init
// Initialize things that stay the same during the whole animation
stage = AnimationStage.LoadingImage;
properties = _payload.customProperties;
useWorldDeviceTransform = properties.anchorType != 0 && properties.attachToAnchor && (properties.ignoreAnchorYaw || properties.ignoreAnchorPitch || properties.ignoreAnchorRoll);
follow = properties.follow;
followTween = Tween.GetFunc(follow.tweenType);
var hmdHz = (int)Math.Round(_vr.GetFloatTrackedDeviceProperty(0, ETrackedDeviceProperty.Prop_DisplayFrequency_Float));
hz = properties.animationHz > 0 ? properties.animationHz : hmdHz;
msPerFrame = 1000 / hz;
// Set anchor
switch (properties.anchorType)
{
case 1:
var anchorIndexArr = _vr.GetIndexesForTrackedDeviceClass(ETrackedDeviceClass.HMD);
if (anchorIndexArr.Length > 0)
{
anchorIndex = anchorIndexArr[0];
}
break;
case 2:
anchorIndex = _vr.GetIndexForControllerRole(ETrackedControllerRole.LeftHand);
break;
case 3:
anchorIndex = _vr.GetIndexForControllerRole(ETrackedControllerRole.RightHand);
break;
}
bool LoadImage()
{
Debug.WriteLine($"Creating texture on UI thread with {_payload.customProperties.textAreas.Length} text areas");
if (!(_texture is null))
{
_texture = null;
}
_texture = _payload.imageData?.Length > 0
? Texture.LoadImageBase64(_payload.imageData, _payload.customProperties.textAreas)
: Texture.LoadImageFile(_payload.imagePath);
if (_texture is null)
{
Debug.WriteLine("Failed to load texture");
_responseAtError?.Invoke(_sessionId, _payload.customProperties.nonce, "Failed to load image into texture");
stage = AnimationStage.Idle;
properties = null;
animationCount = 0;
_elapsedTime = 0;
_payload = null;
return(false);
}
else
{
stage = AnimationStage.Animating;
Debug.WriteLine($"[{_texture.TextureId}]: {_texture.TextureDepth}");
Debug.WriteLine($"Texture created on UI thread, {_texture.Width}x{_texture.Height}");
return(true);
}
}
// Size of overlay
var loadedImage = false;
if (Dispatcher.CurrentDispatcher != MainController.UiDispatcher)
{
Debug.WriteLine("Running animator on Dispatcher.");
MainController.UiDispatcher.Invoke(() => { loadedImage = LoadImage(); });
}
else
{
Debug.WriteLine("Running animator on GUI thread already.");
loadedImage = LoadImage();
}
if (!loadedImage)
{
continue;
}
// var size = _texture.Load(_payload.imageData, properties.textAreas);
width = properties.widthM;
// height = width / size.v0 * size.v1;
// Debug.WriteLine($"Texture width: {size.v0}, height: {size.v1}");
// Animation limits
easeInCount = (
properties.transitions.Length > 0
? properties.transitions[0].durationMs
: 100
) / msPerFrame;
stayCount = properties.durationMs / msPerFrame;
easeOutCount = (
properties.transitions.Length >= 2
? properties.transitions[1].durationMs
: properties.transitions.Length > 0
? properties.transitions[0].durationMs
: 100
) / msPerFrame;
easeInLimit = easeInCount;
stayLimit = easeInLimit + stayCount;
easeOutLimit = stayLimit + easeOutCount;
// Debug.WriteLine($"{easeInCount}, {stayCount}, {easeOutCount} - {easeInLimit}, {stayLimit}, {easeOutLimit}");
// Pose
deviceTransform = properties.anchorType == 0
? EasyOpenVRSingleton.Utils.GetEmptyTransform()
: _vr.GetDeviceToAbsoluteTrackingPose()[anchorIndex == uint.MaxValue ? 0 : anchorIndex].mDeviceToAbsoluteTracking;
if (!properties.attachToAnchor)
{
// Restrict rotation if necessary
HmdVector3_t hmdEuler = deviceTransform.EulerAngles();
if (properties.ignoreAnchorYaw)
{
hmdEuler.v1 = 0;
}
if (properties.ignoreAnchorPitch)
{
hmdEuler.v0 = 0;
}
if (properties.ignoreAnchorRoll)
{
hmdEuler.v2 = 0;
}
deviceTransform = deviceTransform.FromEuler(hmdEuler);
}
originTransform = deviceTransform;
targetTransform = deviceTransform;
// Animations
animateYaw.Reset();
animatePitch.Reset();
animateRoll.Reset();
animateZ.Reset();
animateY.Reset();
animateX.Reset();
animateScale.Reset();
animateOpacity.Reset();
if (properties.animations.Length > 0)
{
foreach (var anim in properties.animations)
{
switch (anim.property)
{
case 0: break;
case 1: animateYaw = new Cycler(anim); break;
case 2: animatePitch = new Cycler(anim); break;
case 3: animateRoll = new Cycler(anim); break;
case 4: animateZ = new Cycler(anim); break;
case 5: animateY = new Cycler(anim); break;
case 6: animateX = new Cycler(anim); break;
case 7: animateScale = new Cycler(anim); break;
case 8: animateOpacity = new Cycler(anim); break;
}
}
}
#endregion
}
if (!skip && stage != AnimationStage.Idle && stage != AnimationStage.LoadingImage) // Animate
{
// Animation stage
if (animationCount < easeInLimit)
{
stage = AnimationStage.EasingIn;
}
else if (animationCount >= stayLimit)
{
stage = AnimationStage.EasingOut;
}
else
{
stage = follow.enabled ||
properties.animations.Length > 0 ||
useWorldDeviceTransform
? AnimationStage.Animating
: AnimationStage.Staying;
}
animationSeconds = (float)animationCount / (float)hz;
#region stage inits
if (animationCount == 0)
{ // Init EaseIn
transition = properties.transitions.Length > 0
? properties.transitions[0]
: new Payload.Transition();
tween = Tween.GetFunc(transition.tweenType);
}
if (animationCount == stayLimit)
{ // Init EaseOut
if (properties.transitions.Length >= 2)
{
transition = properties.transitions[1];
tween = Tween.GetFunc(transition.tweenType);
}
}
#endregion
// Setup and normalized progression ratio
var transitionRatio = 1f;
if (stage == AnimationStage.EasingIn)
{
transitionRatio = ((float)animationCount / easeInCount);
}
else if (stage == AnimationStage.EasingOut)
{
transitionRatio = 1f - ((float)animationCount - stayLimit + 1) / easeOutCount; // +1 because we moved where we increment animationCount
}
transitionRatio = tween(transitionRatio);
var ratioReversed = 1f - transitionRatio;
// Transform
if (stage != AnimationStage.Staying || animationCount == easeInLimit) // Only performs animation on first frame of Staying stage.
// Debug.WriteLine($"{animationCount} - {Enum.GetName(typeof(AnimationStage), stage)} - {Math.Round(ratio*100)/100}");
{
var translate = new HmdVector3_t()
{
v0 = properties.xDistanceM + (transition.xDistanceM * ratioReversed) + animateX.GetRatio(animationSeconds),
v1 = properties.yDistanceM + (transition.yDistanceM * ratioReversed) + animateY.GetRatio(animationSeconds),
v2 = -properties.zDistanceM - (transition.zDistanceM * ratioReversed) - animateZ.GetRatio(animationSeconds)
};
#region Follow
// Follow
if (follow.enabled && follow.durationMs > 0 && properties.anchorType != 0 && !properties.attachToAnchor)
{
var currentPose = properties.anchorType == 0
? EasyOpenVRSingleton.Utils.GetEmptyTransform()
: _vr.GetDeviceToAbsoluteTrackingPose()[anchorIndex == uint.MaxValue ? 0 : anchorIndex].mDeviceToAbsoluteTracking;
var angleBetween = EasyOpenVRSingleton.Utils.AngleBetween(deviceTransform, currentPose);
if (angleBetween > follow.triggerAngle && !followIsLerping)
{
followIsLerping = true;
if (!properties.attachToAnchor)
{
// Restrict rotation if necessary
HmdVector3_t hmdEuler = currentPose.EulerAngles();
if (properties.ignoreAnchorYaw)
{
hmdEuler.v1 = 0;
}
if (properties.ignoreAnchorRoll)
{
hmdEuler.v2 = 0;
}
if (properties.ignoreAnchorPitch)
{
hmdEuler.v0 = 0;
}
currentPose = currentPose.FromEuler(hmdEuler);
}
targetTransform = currentPose;
}
if (followIsLerping)
{
followLerp += msPerFrame / follow.durationMs;
if (followLerp > 1.0)
{
deviceTransform = targetTransform;
originTransform = targetTransform;
followLerp = 0.0;
followIsLerping = false;
}
else
{
deviceTransform = originTransform.Lerp(targetTransform, followTween((float)followLerp));
}
}
}
#endregion
// Build transform with origin, transitions and animations
animationTransform = (properties.attachToAnchor || properties.anchorType == 0)
? EasyOpenVRSingleton.Utils.GetEmptyTransform()
: deviceTransform;
if (properties.anchorType == 0)
{
// World related, so all rotations are local to the overlay
animationTransform = animationTransform
.Translate(translate)
.RotateY(-properties.yawDeg + transition.yawDeg * ratioReversed + animateYaw.GetRatio(animationSeconds))
.RotateX(properties.pitchDeg + transition.pitchDeg * ratioReversed + animatePitch.GetRatio(animationSeconds))
.RotateZ(properties.rollDeg + transition.rollDeg * ratioReversed + animateRoll.GetRatio(animationSeconds));
}
else if (useWorldDeviceTransform)
{
// Device related but using world coordinates, local overlay rotation and allows for rotation cancellation
var anchorTransform = _vr.GetDeviceToAbsoluteTrackingPose()[anchorIndex == uint.MaxValue ? 0 : anchorIndex].mDeviceToAbsoluteTracking;
HmdVector3_t hmdAnchorEuler = anchorTransform.EulerAngles();
if (properties.ignoreAnchorYaw)
{
hmdAnchorEuler.v1 = 0;
}
if (properties.ignoreAnchorPitch)
{
hmdAnchorEuler.v0 = 0;
}
if (properties.ignoreAnchorRoll)
{
hmdAnchorEuler.v2 = 0;
}
animationTransform = anchorTransform.FromEuler(hmdAnchorEuler)
.Translate(translate)
.RotateY(-properties.yawDeg + transition.yawDeg * ratioReversed + animateYaw.GetRatio(animationSeconds))
.RotateX(properties.pitchDeg + transition.pitchDeg * ratioReversed + animatePitch.GetRatio(animationSeconds))
.RotateZ(properties.rollDeg + transition.rollDeg * ratioReversed + animateRoll.GetRatio(animationSeconds));
}
else
{
// Device related, so all rotations are at the origin of the device
animationTransform = animationTransform
// Properties
.RotateY(-properties.yawDeg)
.RotateX(properties.pitchDeg)
.RotateZ(properties.rollDeg)
.Translate(translate)
// Transitions
.RotateY(transition.yawDeg * ratioReversed + animateYaw.GetRatio(animationSeconds))
.RotateX(transition.pitchDeg * ratioReversed + animatePitch.GetRatio(animationSeconds))
.RotateZ(transition.rollDeg * ratioReversed + animateRoll.GetRatio(animationSeconds));
}
_vr.SetOverlayTransform(
_overlayHandle,
animationTransform,
(properties.attachToAnchor && !useWorldDeviceTransform)
? anchorIndex
: uint.MaxValue
);
var transitionOpacityRatio = (transition.opacityPer + (transitionRatio * (1f - transition.opacityPer)));
_vr.SetOverlayAlpha(_overlayHandle,
// the transition part becomes 0-1, times the property that sets the maximum, and we just add the animation value.
(transitionOpacityRatio) * properties.opacityPer + animateOpacity.GetRatio(animationSeconds)
);
var transitionWidthRatio = (transition.scalePer + (transitionRatio * (1f - transition.scalePer)));
_vr.SetOverlayWidth(_overlayHandle,
Math.Max(0, width * transitionWidthRatio + (animateScale.GetRatio(animationSeconds) * width))
);
}
// Do not make overlay visible until we have applied all the movements etc, only needs to happen the first frame.
if (animationCount == 0)
{
_vr.SetOverlayVisibility(_overlayHandle, true);
}
animationCount++;
// We're done
if (animationCount >= easeOutLimit)
{
stage = AnimationStage.Finished;
}
if (stage == AnimationStage.Finished)
{
Debug.WriteLine("DONE!");
_vr.SetOverlayVisibility(_overlayHandle, false);
stage = AnimationStage.Idle;
_responseAtCompletion?.Invoke(_sessionId, properties.nonce);
properties = null;
animationCount = 0;
_elapsedTime = 0;
_payload = null;
_texture = null;
}
}
if (_shouldShutdown) // Finish
// _texture.Delete(); // TODO: Watch for possible instability here depending on what is going on timing-wise...
{
_texture = null;
OpenVR.Overlay.DestroyOverlay(_overlayHandle);
Thread.CurrentThread.Abort();
}
var timeSpent = (int)Math.Round((double)(DateTime.Now.Ticks - timeStarted) / TimeSpan.TicksPerMillisecond);
Thread.Sleep(Math.Max(1, msPerFrame - timeSpent)); // Animation time per frame adjusted by the time it took to animate.
}
}
Vector3 fromHmdVector3_t(HmdVector3_t hmdVector3_T)
{
return(new Vector3(hmdVector3_T.v0, hmdVector3_T.v1, hmdVector3_T.v2));
}
private async void ParseTrackingFrame()
{
try
{
for (uint id = 0; id < OpenVR.k_unMaxTrackedDeviceCount; id++)
{
if (vr_pointer != null)
{
TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
if (!vr_pointer.IsTrackedDeviceConnected(id))
{
continue;
}
VRControllerState_t controllState = new VRControllerState_t();
ETrackedDeviceClass trackedDeviceClass = vr_pointer.GetTrackedDeviceClass(id);
switch (trackedDeviceClass)
{
case ETrackedDeviceClass.Controller:
vr_pointer.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, id, ref controllState, OpenVR.k_unMaxTrackedDeviceCount, ref trackedDevicePose[id]);
HmdVector3_t position = GetPosition(trackedDevicePose[id].mDeviceToAbsoluteTracking); // devicePose->mDeviceToAbsoluteTracking);
HmdVector3_t rotation = GetRotationEuler(trackedDevicePose[id].mDeviceToAbsoluteTracking);
int positionControllerX = (int)position.v0;
int positionControllerY = (int)position.v1;
int positionControllerZ = (int)position.v2 * (-1);
int rotationControllerX = (int)rotation.v0 + 180;
int rotationControllerY = (int)rotation.v1;
int rotationControllerZ = (int)rotation.v2;
if (ControlViewModel.teleporOffset[0] != -1)
{
ControlViewModel.transOffSetControllerX = ControlViewModel.teleporOffset[0];
ControlViewModel.transOffSetControllerY = ControlViewModel.teleporOffset[1];
ControlViewModel.transOffSetControllerZ = ControlViewModel.teleporOffset[2];
ControlViewModel.rotOffSetControllerZ = ControlViewModel.teleporOffset[3];
}
ETrackedControllerRole result = vr_pointer.GetControllerRoleForTrackedDeviceIndex(id);
if (result != ETrackedControllerRole.LeftHand && lastController != ETrackedControllerRole.LeftHand)
{
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.LeftController);
}
if (result != ETrackedControllerRole.RightHand && lastController != ETrackedControllerRole.RightHand)
{
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.RightController);
}
switch (result)
{
case ETrackedControllerRole.Invalid:
break;
case ETrackedControllerRole.LeftHand:
if (communicationProtocolUdp == false)
{
MessageBuffer mb2 = new MessageBuffer();
someThingTracked = true;
int type = 101;
mb2.add(type);
mb2.add(userId);
int handid = 1;
mb2.add(handid);
mb2.add(positionControllerX + ControlViewModel.transOffSetControllerX);
mb2.add(positionControllerY + ControlViewModel.transOffSetControllerY);
mb2.add(positionControllerZ + ControlViewModel.transOffSetControllerZ);
mb2.add(rotationControllerX);
mb2.add(rotationControllerY);
mb2.add(rotationControllerZ);
mb2.add(ControlViewModel.rotOffSetControllerZ);
RaiseControllerEvent(new TrackingChangedEventArgs(true), Tracker.LeftController);
Message msg = new Message(mb2, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
Thread.Sleep(20);
break;
}
break;
case ETrackedControllerRole.RightHand:
if (communicationProtocolUdp == false)
{
MessageBuffer mb2 = new MessageBuffer();
someThingTracked = true;
int type = 101;
mb2.add(type);
mb2.add(userId);
int handid = 2;
mb2.add(handid);
mb2.add(positionControllerX + ControlViewModel.transOffSetControllerX);
mb2.add(positionControllerY + ControlViewModel.transOffSetControllerY);
mb2.add(positionControllerZ + ControlViewModel.transOffSetControllerZ);
mb2.add(rotationControllerX);
mb2.add(rotationControllerY);
mb2.add(rotationControllerZ);
mb2.add(ControlViewModel.rotOffSetControllerZ);
Message msg = new Message(mb2, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
RaiseControllerEvent(new TrackingChangedEventArgs(true), Tracker.RightController);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
Thread.Sleep(20);
break;
}
break;
}
break;
}
}
}
}
catch (Exception e)
{
log.Warn("ParseTrackingFrame in Controller Tracking wurde beendet!" + e);
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.LeftController);
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.RightController);
}
}
public void BuildMesh()
{
HmdQuad_t rect = new HmdQuad_t();
if (!GetBounds(size, ref rect))
{
return;
}
HmdVector3_t[] corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[4];
for (int i = 0; i < corners.Length; i++)
{
HmdVector3_t c = corners[i];
vertices[i] = new Vector3(c.v0, c.v1, c.v2);
}
List <Vector3> verticesList = new List <Vector3>();
List <Vector2> uvList = new List <Vector2>();
int[] facesInterior;
int[] facesExterior;
int[] facesBoundaryTop;
int[] facesBoundarySides;
generateInterior(rect, corners, verticesList, uvList, out facesInterior);
generateExterior(rect, corners, verticesList, uvList, out facesExterior);
generateBoundaryTop(rect, corners, verticesList, uvList, out facesBoundaryTop);
generateBoundarySides(rect, corners, verticesList, uvList, out facesBoundarySides);
Mesh mesh = new Mesh();
GetComponent <MeshFilter>().mesh = mesh;
mesh.vertices = verticesList.ToArray();
mesh.uv = uvList.ToArray();
mesh.subMeshCount = 4;
mesh.SetTriangles(facesInterior, 0);
mesh.SetTriangles(facesExterior, 1);
mesh.SetTriangles(facesBoundaryTop, 2);
mesh.SetTriangles(facesBoundarySides, 3);
Material matDefault = null;
if (interiorMaterial == null || exteriorMaterial == null ||
boundarySidesMaterial == null || boundaryTopMaterial == null)
{
matDefault = getDefaultMaterial();
}
Material matInterior = interiorMaterial != null ? interiorMaterial : matDefault;
Material matExterior = exteriorMaterial != null ? exteriorMaterial : matDefault;
Material matBoundaryTop = boundaryTopMaterial != null ? boundaryTopMaterial : matDefault;
Material matBoundarySides = boundarySidesMaterial != null ? boundarySidesMaterial : matDefault;
MeshRenderer renderer = GetComponent <MeshRenderer>();
renderer.materials = new Material[] {
matInterior,
matExterior,
matBoundaryTop,
matBoundarySides
};
}
public void BuildAreaMesh()
{
var rect = new HmdQuad_t();
if (!GetBounds(playAreaSize, ref rect))
{
return;
}
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
Vector3[] vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++)
{
var c = corners[i];
vertices[i] = new Vector3(c.v0, 0.01f, c.v2);
}
if (borderThickness == 0.0f)
{
GetComponent <MeshFilter>().mesh = null;
return;
}
for (int i = 0; i < corners.Length; i++)
{
int next = (i + 1) % corners.Length;
int prev = (i + corners.Length - 1) % corners.Length;
var nextSegment = (vertices[next] - vertices[i]).normalized;
var prevSegment = (vertices[prev] - vertices[i]).normalized;
var vert = vertices[i];
vert += Vector3.Cross(nextSegment, Vector3.up) * borderThickness;
vert += Vector3.Cross(prevSegment, Vector3.down) * borderThickness;
vertices[corners.Length + i] = vert;
}
var triangles = new int[]
{
0, 1, 4,
1, 5, 4,
1, 2, 5,
2, 6, 5,
2, 3, 6,
3, 7, 6,
3, 0, 7,
0, 4, 7
};
var uv = new Vector2[]
{
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f)
};
var colors = new Color[]
{
Color.white,
Color.white,
Color.white,
Color.white,
new Color(1.0f, 1.0f, 1.0f, 0.0f),
new Color(1.0f, 1.0f, 1.0f, 0.0f),
new Color(1.0f, 1.0f, 1.0f, 0.0f),
new Color(1.0f, 1.0f, 1.0f, 0.0f)
};
var mesh = new Mesh();
GetComponent <MeshFilter>().mesh = mesh;
mesh.vertices = vertices;
mesh.uv = uv;
mesh.colors = colors;
mesh.triangles = triangles;
var renderer = GetComponent <MeshRenderer>();
renderer.sharedMaterial = _material;
renderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
#if !(UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
renderer.lightProbeUsage = LightProbeUsage.Off;
#else
renderer.useLightProbes = false;
#endif
}
public void BuildMesh()
{
HmdQuad_t hmdQuad_t = default(HmdQuad_t);
if (!SteamVR_PlayArea.GetBounds(this.size, ref hmdQuad_t))
{
return;
}
HmdVector3_t[] array = new HmdVector3_t[]
{
hmdQuad_t.vCorners0,
hmdQuad_t.vCorners1,
hmdQuad_t.vCorners2,
hmdQuad_t.vCorners3
};
this.vertices = new Vector3[array.Length * 2];
for (int i = 0; i < array.Length; i++)
{
HmdVector3_t hmdVector3_t = array[i];
this.vertices[i] = new Vector3(hmdVector3_t.v0, 0.01f, hmdVector3_t.v2);
}
if (this.borderThickness == 0f)
{
base.GetComponent <MeshFilter>().mesh = null;
return;
}
for (int j = 0; j < array.Length; j++)
{
int num = (j + 1) % array.Length;
int num2 = (j + array.Length - 1) % array.Length;
Vector3 normalized = (this.vertices[num] - this.vertices[j]).normalized;
Vector3 normalized2 = (this.vertices[num2] - this.vertices[j]).normalized;
Vector3 vector = this.vertices[j];
vector += Vector3.Cross(normalized, Vector3.up) * this.borderThickness;
vector += Vector3.Cross(normalized2, Vector3.down) * this.borderThickness;
this.vertices[array.Length + j] = vector;
}
int[] triangles = new int[]
{
0,
4,
1,
1,
4,
5,
1,
5,
2,
2,
5,
6,
2,
6,
3,
3,
6,
7,
3,
7,
0,
0,
7,
4
};
Vector2[] uv = new Vector2[]
{
new Vector2(0f, 0f),
new Vector2(1f, 0f),
new Vector2(0f, 0f),
new Vector2(1f, 0f),
new Vector2(0f, 1f),
new Vector2(1f, 1f),
new Vector2(0f, 1f),
new Vector2(1f, 1f)
};
Color[] colors = new Color[]
{
this.color,
this.color,
this.color,
this.color,
new Color(this.color.r, this.color.g, this.color.b, 0f),
new Color(this.color.r, this.color.g, this.color.b, 0f),
new Color(this.color.r, this.color.g, this.color.b, 0f),
new Color(this.color.r, this.color.g, this.color.b, 0f)
};
Mesh mesh = new Mesh();
base.GetComponent <MeshFilter>().mesh = mesh;
mesh.vertices = this.vertices;
mesh.uv = uv;
mesh.colors = colors;
mesh.triangles = triangles;
MeshRenderer component = base.GetComponent <MeshRenderer>();
component.material = new Material(Shader.Find("Sprites/Default"));
component.reflectionProbeUsage = ReflectionProbeUsage.Off;
component.shadowCastingMode = ShadowCastingMode.Off;
component.receiveShadows = false;
component.lightProbeUsage = LightProbeUsage.Off;
}
public Vec3(HmdVector3_t point = new HmdVector3_t())
{
x = point.v0;
y = point.v1;
z = point.v2;
}
private Vector3 ToVector3(HmdVector3_t vector)
{
return(new Vector3(vector.v0, vector.v1, vector.v2));
}
public static Vector3 ToVelocityVector(this HmdVector3_t hmdVector)
{
return(new Vector3(hmdVector.v0, hmdVector.v1, hmdVector.v2));
}
