LeapCylindricalSpace.cs
6.1 KB
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
/******************************************************************************
* Copyright (C) Leap Motion, Inc. 2011-2017. *
* 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;
namespace Leap.Unity.Space {
public class LeapCylindricalSpace : LeapRadialSpace {
protected override ITransformer CosntructBaseTransformer() {
return new Transformer() {
space = this,
anchor = this,
angleOffset = 0,
heightOffset = 0,
radiusOffset = radius,
radiansPerMeter = 1.0f / radius
};
}
protected override ITransformer ConstructTransformer(LeapSpaceAnchor anchor) {
return new Transformer() {
space = this,
anchor = anchor
};
}
protected override void UpdateRadialTransformer(ITransformer transformer, ITransformer parent, Vector3 rectSpaceDelta) {
var radialTransformer = transformer as Transformer;
var radialParent = parent as Transformer;
radialTransformer.angleOffset = radialParent.angleOffset + rectSpaceDelta.x / radialParent.radiusOffset;
radialTransformer.heightOffset = radialParent.heightOffset + rectSpaceDelta.y;
radialTransformer.radiusOffset = radialParent.radiusOffset + rectSpaceDelta.z;
radialTransformer.radiansPerMeter = 1.0f / (radialTransformer.radiusOffset);
}
public class Transformer : IRadialTransformer {
public LeapCylindricalSpace space { get; set; }
public LeapSpaceAnchor anchor { get; set; }
public float angleOffset;
public float heightOffset;
public float radiusOffset;
public float radiansPerMeter;
public Vector3 TransformPoint(Vector3 localRectPos) {
Vector3 anchorDelta;
Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
anchorDelta = localRectPos - anchorRectPos;
float angle = angleOffset + anchorDelta.x / radiusOffset;
float height = heightOffset + anchorDelta.y;
float radius = radiusOffset + anchorDelta.z;
Vector3 position;
position.x = Mathf.Sin(angle) * radius;
position.y = height;
position.z = Mathf.Cos(angle) * radius - space.radius;
return position;
}
public Vector3 InverseTransformPoint(Vector3 localWarpedPos) {
localWarpedPos.z += space.radius;
float angle = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
float height = localWarpedPos.y;
float radius = new Vector2(localWarpedPos.x, localWarpedPos.z).magnitude;
Vector3 anchorDelta;
anchorDelta.x = (angle - angleOffset) * radiusOffset;
anchorDelta.y = height - heightOffset;
anchorDelta.z = radius - radiusOffset;
Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
Vector3 localRectPos = anchorRectPos + anchorDelta;
return localRectPos;
}
public Quaternion TransformRotation(Vector3 localRectPos, Quaternion localRectRot) {
Vector3 anchorDelta;
Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
anchorDelta = localRectPos - anchorRectPos;
float angle = angleOffset + anchorDelta.x / radiusOffset;
Quaternion rotation = Quaternion.Euler(0, angle * Mathf.Rad2Deg, 0);
return rotation * localRectRot;
}
public Quaternion InverseTransformRotation(Vector3 localWarpedPos, Quaternion localWarpedRot) {
localWarpedPos.z += space.radius;
float angle = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
return Quaternion.Euler(0, -angle * Mathf.Rad2Deg, 0) * localWarpedRot;
}
public Vector3 TransformDirection(Vector3 localRectPos, Vector3 localRectDirection) {
Vector3 anchorDelta;
Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
anchorDelta = localRectPos - anchorRectPos;
float angle = angleOffset + anchorDelta.x / radiusOffset;
Quaternion rotation = Quaternion.Euler(0, angle * Mathf.Rad2Deg, 0);
return rotation * localRectDirection;
}
public Vector3 InverseTransformDirection(Vector3 localWarpedPos, Vector3 localWarpedDirection) {
localWarpedPos.z += space.radius;
float angle = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
return Quaternion.Euler(0, -angle * Mathf.Rad2Deg, 0) * localWarpedDirection;
}
public Matrix4x4 GetTransformationMatrix(Vector3 localRectPos) {
Vector3 anchorDelta;
Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
anchorDelta = localRectPos - anchorRectPos;
float angle = angleOffset + anchorDelta.x / radiusOffset;
float height = heightOffset + anchorDelta.y;
float radius = radiusOffset + anchorDelta.z;
Vector3 position;
position.x = Mathf.Sin(angle) * radius;
position.y = height;
position.z = Mathf.Cos(angle) * radius - space.radius;
Quaternion rotation = Quaternion.Euler(0, angle * Mathf.Rad2Deg, 0);
return Matrix4x4.TRS(position, rotation, Vector3.one);
}
public Vector4 GetVectorRepresentation(Transform element) {
Vector3 elementRectPos = space.transform.InverseTransformPoint(element.position);
Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
Vector3 delta = elementRectPos - anchorRectPos;
Vector4 rep;
rep.x = angleOffset + delta.x / radiusOffset;
rep.y = heightOffset + delta.y;
rep.z = radiusOffset + delta.z;
rep.w = 1.0f / radiusOffset;
return rep;
}
}
}
}