Tanoda
LeapSphericalSpace.cs
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright (C) Ultraleap, Inc. 2011-2020. *
3 * *
4 * Use subject to the terms of the Apache License 2.0 available at *
5 * http://www.apache.org/licenses/LICENSE-2.0, or another agreement *
6 * between Ultraleap and you, your company or other organization. *
7 ******************************************************************************/
8
9using System;
10using UnityEngine;
11
12namespace Leap.Unity.Space {
13
15
17 return new Transformer() {
18 space = this,
19 anchor = this,
20 angleXOffset = 0,
21 angleYOffset = 0,
22 radiusOffset = radius,
23 radiansPerMeter = 1.0f / radius
24 };
25 }
26
28 return new Transformer() {
29 space = this,
30 anchor = anchor
31 };
32 }
33
34 protected override void UpdateRadialTransformer(ITransformer transformer, ITransformer parent, Vector3 rectSpaceDelta) {
35 var radialTransformer = transformer as Transformer;
36 var radialParent = parent as Transformer;
37
38 radialTransformer.angleXOffset = radialParent.angleXOffset + rectSpaceDelta.x / radialParent.radiusOffset;
39 radialTransformer.angleYOffset = radialParent.angleYOffset + rectSpaceDelta.y / radialParent.radiusOffset;
40 radialTransformer.radiusOffset = radialParent.radiusOffset + rectSpaceDelta.z;
41 radialTransformer.radiansPerMeter = 1.0f / (radialTransformer.radiusOffset);
42 }
43
45 public LeapSphericalSpace space { get; set; }
46 public LeapSpaceAnchor anchor { get; set; }
47
48 public float angleXOffset;
49 public float angleYOffset;
50 public float radiusOffset;
51 public float radiansPerMeter;
52
53 public Vector3 TransformPoint(Vector3 localRectPos) {
54 Vector3 anchorDelta;
55
56 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
57 anchorDelta = localRectPos - anchorRectPos;
58
59 float angleX = angleXOffset + anchorDelta.x / radiusOffset;
60 float angleY = angleYOffset + anchorDelta.y / radiusOffset;
61 float radius = radiusOffset + anchorDelta.z;
62
63 Vector3 position;
64 position.x = 0;
65 position.y = Mathf.Sin(angleY) * radius;
66 position.z = Mathf.Cos(angleY) * radius;
67
68 Vector3 position2;
69 position2.x = Mathf.Sin(angleX) * position.z;
70 position2.y = position.y;
71 position2.z = Mathf.Cos(angleX) * position.z - space.radius;
72
73 return position2;
74 }
75
76 public Vector3 InverseTransformPoint(Vector3 localWarpedPos) {
77 localWarpedPos.z += space.radius;
78
79 Vector3 preRotatedPos;
80 preRotatedPos.x = 0;
81 preRotatedPos.y = localWarpedPos.y;
82 preRotatedPos.z = new Vector2(localWarpedPos.x, localWarpedPos.z).magnitude;
83
84 float angleX = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
85 float angleY = Mathf.Atan2(preRotatedPos.y, preRotatedPos.z);
86 float radius = new Vector2(preRotatedPos.z, preRotatedPos.y).magnitude;
87
88 Vector3 anchorDelta;
89 anchorDelta.x = (angleX - angleXOffset) * radiusOffset;
90 anchorDelta.y = (angleY - angleYOffset) * radiusOffset;
91 anchorDelta.z = radius - radiusOffset;
92
93 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
94 Vector3 localRectPos = anchorRectPos + anchorDelta;
95
96 return localRectPos;
97 }
98
99 public Quaternion TransformRotation(Vector3 localRectPos, Quaternion localRectRot) {
100 Vector3 anchorDelta;
101
102 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
103 anchorDelta = localRectPos - anchorRectPos;
104
105 float angleX = angleXOffset + anchorDelta.x / radiusOffset;
106 float angleY = angleYOffset + anchorDelta.y / radiusOffset;
107
108 Quaternion rotation = Quaternion.Euler(-angleY * Mathf.Rad2Deg,
109 angleX * Mathf.Rad2Deg,
110 0);
111
112 return rotation * localRectRot;
113 }
114
115 public Quaternion InverseTransformRotation(Vector3 localWarpedPos, Quaternion localWarpedRot) {
116 localWarpedPos.z += space.radius;
117
118 Vector3 preRotatedPos;
119 preRotatedPos.x = 0;
120 preRotatedPos.y = localWarpedPos.y;
121 preRotatedPos.z = new Vector2(localWarpedPos.x, localWarpedPos.z).magnitude;
122
123 float angleX = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
124 float angleY = Mathf.Atan2(preRotatedPos.y, preRotatedPos.z);
125
126 Quaternion baseRot = Quaternion.Euler(-angleY * Mathf.Rad2Deg,
127 angleX * Mathf.Rad2Deg,
128 0);
129 Quaternion invRot = Quaternion.Inverse(baseRot);
130
131 return invRot * localWarpedRot;
132 }
133
134 public Vector3 TransformDirection(Vector3 localRectPos, Vector3 localRectDirection) {
135 Vector3 anchorDelta;
136
137 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
138 anchorDelta = localRectPos - anchorRectPos;
139
140 float angleX = angleXOffset + anchorDelta.x / radiusOffset;
141 float angleY = angleYOffset + anchorDelta.y / radiusOffset;
142
143 Quaternion rotation = Quaternion.Euler(-angleY * Mathf.Rad2Deg,
144 angleX * Mathf.Rad2Deg,
145 0);
146
147 return rotation * localRectDirection;
148 }
149
150 public Vector3 InverseTransformDirection(Vector3 localWarpedPos, Vector3 localWarpedDirection) {
151 localWarpedPos.z += space.radius;
152
153 Vector3 preRotatedPos;
154 preRotatedPos.x = 0;
155 preRotatedPos.y = localWarpedPos.y;
156 preRotatedPos.z = new Vector2(localWarpedPos.x, localWarpedPos.z).magnitude;
157
158 float angleX = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
159 float angleY = Mathf.Atan2(preRotatedPos.y, preRotatedPos.z);
160
161 Quaternion baseRot = Quaternion.Euler(-angleY * Mathf.Rad2Deg,
162 angleX * Mathf.Rad2Deg,
163 0);
164 Quaternion invRot = Quaternion.Inverse(baseRot);
165 return invRot * localWarpedDirection;
166 }
167
168 public Matrix4x4 GetTransformationMatrix(Vector3 localRectPos) {
169 Vector3 anchorDelta;
170
171 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
172 anchorDelta = localRectPos - anchorRectPos;
173
174 float angleX = angleXOffset + anchorDelta.x / radiusOffset;
175 float angleY = angleYOffset + anchorDelta.y / radiusOffset;
176 float radius = radiusOffset + anchorDelta.z;
177
178 Vector3 position;
179 position.x = 0;
180 position.y = Mathf.Sin(angleY) * radius;
181 position.z = Mathf.Cos(angleY) * radius;
182
183 Vector3 position2;
184 position2.x = Mathf.Sin(angleX) * position.z;
185 position2.y = position.y;
186 position2.z = Mathf.Cos(angleX) * position.z - space.radius;
187
188 Quaternion rotation = Quaternion.Euler(-angleY * Mathf.Rad2Deg,
189 angleX * Mathf.Rad2Deg,
190 0);
191
192 return Matrix4x4.TRS(position2, rotation, Vector3.one);
193 }
194
195 public Vector4 GetVectorRepresentation(Transform element) {
196 Vector3 elementRectPos = space.transform.InverseTransformPoint(element.position);
197 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
198 Vector3 delta = elementRectPos - anchorRectPos;
199
200 Vector4 rep;
201 rep.x = angleXOffset + delta.x / radiusOffset;
202 rep.y = angleYOffset + delta.y / radiusOffset;
203 rep.z = radiusOffset + delta.z;
204 rep.w = 1.0f / radiusOffset;
205 return rep;
206 }
207 }
208 }
209}
Quaternion InverseTransformRotation(Vector3 localWarpedPos, Quaternion localWarpedRot)
Transform a rotation from warped space to rect space.
Quaternion TransformRotation(Vector3 localRectPos, Quaternion localRectRot)
Transform a rotation from rect space to warped space.
Vector3 TransformPoint(Vector3 localRectPos)
Transform a point from rect space to warped space.
Vector3 TransformDirection(Vector3 localRectPos, Vector3 localRectDirection)
Transform a direction from rect space to warped space.
Matrix4x4 GetTransformationMatrix(Vector3 localRectPos)
Get a transformation matrix that maps a position in rect space to a position in warped space.
Vector3 InverseTransformDirection(Vector3 localWarpedPos, Vector3 localWarpedDirection)
Transform a direction from warped space to rect space.
Vector3 InverseTransformPoint(Vector3 localWarpedPos)
Transform a point from warped space to rect space.
override void UpdateRadialTransformer(ITransformer transformer, ITransformer parent, Vector3 rectSpaceDelta)
override ITransformer ConstructTransformer(LeapSpaceAnchor anchor)
override ITransformer CosntructBaseTransformer()