/
LeapServiceProviderEditor.cs
134 lines (107 loc) · 5.85 KB
/
LeapServiceProviderEditor.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/******************************************************************************
* Copyright (C) Leap Motion, Inc. 2011-2018. *
* Leap Motion proprietary and confidential. *
* *
* Use subject to the terms of the Leap Motion SDK Agreement available at *
* https://developer.leapmotion.com/sdk_agreement, or another agreement *
* between Leap Motion and you, your company or other organization. *
******************************************************************************/
using UnityEngine;
using UnityEditor;
namespace Leap.Unity {
[CustomEditor(typeof(LeapServiceProvider))]
public class LeapServiceProviderEditor : CustomEditorBase<LeapServiceProvider> {
protected Vector3 arcDirection = -Vector3.forward;
protected Quaternion deviceRotation = Quaternion.identity;
protected bool isVRProvider = false;
protected Vector3 controllerOffset = Vector3.zero;
private const float BOX_RADIUS = 0.45f;
private const float BOX_WIDTH = 0.965f;
private const float BOX_DEPTH = 0.6671f;
protected override void OnEnable() {
base.OnEnable();
specifyCustomDecorator("_frameOptimization", frameOptimizationWarning);
specifyConditionalDrawing("_frameOptimization",
(int)LeapServiceProvider.FrameOptimizationMode.None,
"_physicsExtrapolation",
"_physicsExtrapolationTime");
specifyConditionalDrawing("_physicsExtrapolation",
(int)LeapServiceProvider.PhysicsExtrapolationMode.Manual,
"_physicsExtrapolationTime");
deferProperty("_enableDllProfiling");
}
private void frameOptimizationWarning(SerializedProperty property) {
var mode = (LeapServiceProvider.FrameOptimizationMode)property.intValue;
string warningText;
switch (mode) {
case LeapServiceProvider.FrameOptimizationMode.ReuseUpdateForPhysics:
warningText = "Reusing update frames for physics introduces a frame of latency "
+ "for physics interactions.";
break;
case LeapServiceProvider.FrameOptimizationMode.ReusePhysicsForUpdate:
warningText = "This optimization REQUIRES physics framerate to match your "
+ "target framerate EXACTLY.";
break;
default:
return;
}
EditorGUILayout.HelpBox(warningText, MessageType.Warning);
}
public override void OnInspectorGUI() {
if (UnityEditor.PlayerSettings.virtualRealitySupported && !isVRProvider) {
EditorGUILayout.HelpBox(
"VR support is enabled. If your Leap is mounted to your headset, you should be "
+ "using LeapXRServiceProvider instead of LeapServiceProvider. (If your Leap "
+ "is not mounted to your headset, you can safely ignore this warning.)",
MessageType.Warning);
}
base.OnInspectorGUI();
}
public virtual void OnSceneGUI() {
Vector3 origin = target.transform.TransformPoint(controllerOffset);
Vector3 local_top_left, top_left, local_top_right, top_right,
local_bottom_left, bottom_left, local_bottom_right, bottom_right;
getLocalGlobalPoint(-1, 1, 1, out local_top_left, out top_left);
getLocalGlobalPoint(1, 1, 1, out local_top_right, out top_right);
getLocalGlobalPoint(-1, 1, -1, out local_bottom_left, out bottom_left);
getLocalGlobalPoint(1, 1, -1, out local_bottom_right, out bottom_right);
Handles.DrawLine(origin, top_left);
Handles.DrawLine(origin, top_right);
Handles.DrawLine(origin, bottom_left);
Handles.DrawLine(origin, bottom_right);
drawControllerEdge(origin, local_top_left, local_top_right);
drawControllerEdge(origin, local_bottom_left, local_top_left);
drawControllerEdge(origin, local_bottom_left, local_bottom_right);
drawControllerEdge(origin, local_bottom_right, local_top_right);
drawControllerArc(origin, local_top_left, local_bottom_left, local_top_right,
local_bottom_right, arcDirection);
drawControllerArc(origin, local_top_left, local_top_right, local_bottom_left,
local_bottom_right, -Vector3.right);
}
private void getLocalGlobalPoint(int x, int y, int z,
out Vector3 local, out Vector3 global) {
local = deviceRotation * new Vector3(x * BOX_WIDTH, y * BOX_RADIUS, z * BOX_DEPTH);
global = target.transform.TransformPoint(controllerOffset
+ BOX_RADIUS * local.normalized);
}
private void drawControllerEdge(Vector3 origin,
Vector3 edge0, Vector3 edge1) {
Vector3 right_normal = target.transform
.TransformDirection(Vector3.Cross(edge0, edge1));
float right_angle = Vector3.Angle(edge0, edge1);
Handles.DrawWireArc(origin, right_normal, target.transform.TransformDirection(edge0),
right_angle, target.transform.lossyScale.x * BOX_RADIUS);
}
private void drawControllerArc(Vector3 origin,
Vector3 edgeA0, Vector3 edgeA1,
Vector3 edgeB0, Vector3 edgeB1,
Vector3 direction) {
Vector3 faceA = Vector3.Lerp(edgeA0, edgeA1, 0.5f);
Vector3 faceB = Vector3.Lerp(edgeB0, edgeB1, 0.5f);
Vector3 depth_normal = target.transform.TransformDirection(direction);
float angle = Vector3.Angle(faceA, faceB);
Handles.DrawWireArc(origin, depth_normal, target.transform.TransformDirection(faceA),
angle, target.transform.lossyScale.x * BOX_RADIUS);
}
}
}