Tanoda
LeapCylindricalSpace.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 UnityEngine;
10
12
14
16 return new Transformer() {
17 space = this,
18 anchor = this,
19 angleOffset = 0,
20 heightOffset = 0,
21 radiusOffset = radius,
22 radiansPerMeter = 1.0f / radius
23 };
24 }
25
27 return new Transformer() {
28 space = this,
29 anchor = anchor
30 };
31 }
32
33 protected override void UpdateRadialTransformer(ITransformer transformer, ITransformer parent, Vector3 rectSpaceDelta) {
34 var radialTransformer = transformer as Transformer;
35 var radialParent = parent as Transformer;
36
37 radialTransformer.angleOffset = radialParent.angleOffset + rectSpaceDelta.x / radialParent.radiusOffset;
38 radialTransformer.heightOffset = radialParent.heightOffset + rectSpaceDelta.y;
39 radialTransformer.radiusOffset = radialParent.radiusOffset + rectSpaceDelta.z;
40 radialTransformer.radiansPerMeter = 1.0f / (radialTransformer.radiusOffset);
41 }
42
44 public LeapCylindricalSpace space { get; set; }
45 public LeapSpaceAnchor anchor { get; set; }
46
47 public float angleOffset;
48 public float heightOffset;
49 public float radiusOffset;
50 public float radiansPerMeter;
51
52 public Vector3 TransformPoint(Vector3 localRectPos) {
53 Vector3 anchorDelta;
54
55 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
56 anchorDelta = localRectPos - anchorRectPos;
57
58 float angle = angleOffset + anchorDelta.x / radiusOffset;
59 float height = heightOffset + anchorDelta.y;
60 float radius = radiusOffset + anchorDelta.z;
61
62 Vector3 position;
63 position.x = Mathf.Sin(angle) * radius;
64 position.y = height;
65 position.z = Mathf.Cos(angle) * radius - space.radius;
66 return position;
67 }
68
69 public Vector3 InverseTransformPoint(Vector3 localWarpedPos) {
70 localWarpedPos.z += space.radius;
71
72 float angle = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
73 float height = localWarpedPos.y;
74 float radius = new Vector2(localWarpedPos.x, localWarpedPos.z).magnitude;
75
76 Vector3 anchorDelta;
77 anchorDelta.x = (angle - angleOffset) * radiusOffset;
78 anchorDelta.y = height - heightOffset;
79 anchorDelta.z = radius - radiusOffset;
80
81 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
82 Vector3 localRectPos = anchorRectPos + anchorDelta;
83
84 return localRectPos;
85 }
86
87 public Quaternion TransformRotation(Vector3 localRectPos, Quaternion localRectRot) {
88 Vector3 anchorDelta;
89
90 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
91 anchorDelta = localRectPos - anchorRectPos;
92
93 float angle = angleOffset + anchorDelta.x / radiusOffset;
94
95 Quaternion rotation = Quaternion.Euler(0, angle * Mathf.Rad2Deg, 0);
96
97 return rotation * localRectRot;
98 }
99
100 public Quaternion InverseTransformRotation(Vector3 localWarpedPos, Quaternion localWarpedRot) {
101 localWarpedPos.z += space.radius;
102
103 float angle = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
104
105 return Quaternion.Euler(0, -angle * Mathf.Rad2Deg, 0) * localWarpedRot;
106 }
107
108 public Vector3 TransformDirection(Vector3 localRectPos, Vector3 localRectDirection) {
109 Vector3 anchorDelta;
110
111 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
112 anchorDelta = localRectPos - anchorRectPos;
113
114 float angle = angleOffset + anchorDelta.x / radiusOffset;
115
116 Quaternion rotation = Quaternion.Euler(0, angle * Mathf.Rad2Deg, 0);
117
118 return rotation * localRectDirection;
119 }
120
121 public Vector3 InverseTransformDirection(Vector3 localWarpedPos, Vector3 localWarpedDirection) {
122 localWarpedPos.z += space.radius;
123
124 float angle = Mathf.Atan2(localWarpedPos.x, localWarpedPos.z);
125
126 return Quaternion.Euler(0, -angle * Mathf.Rad2Deg, 0) * localWarpedDirection;
127 }
128
129 public Matrix4x4 GetTransformationMatrix(Vector3 localRectPos) {
130 Vector3 anchorDelta;
131
132 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
133 anchorDelta = localRectPos - anchorRectPos;
134
135 float angle = angleOffset + anchorDelta.x / radiusOffset;
136 float height = heightOffset + anchorDelta.y;
137 float radius = radiusOffset + anchorDelta.z;
138
139 Vector3 position;
140 position.x = Mathf.Sin(angle) * radius;
141 position.y = height;
142 position.z = Mathf.Cos(angle) * radius - space.radius;
143
144 Quaternion rotation = Quaternion.Euler(0, angle * Mathf.Rad2Deg, 0);
145
146 return Matrix4x4.TRS(position, rotation, Vector3.one);
147 }
148
149 public Vector4 GetVectorRepresentation(Transform element) {
150 Vector3 elementRectPos = space.transform.InverseTransformPoint(element.position);
151 Vector3 anchorRectPos = space.transform.InverseTransformPoint(anchor.transform.position);
152 Vector3 delta = elementRectPos - anchorRectPos;
153
154 Vector4 rep;
155 rep.x = angleOffset + delta.x / radiusOffset;
156 rep.y = heightOffset + delta.y;
157 rep.z = radiusOffset + delta.z;
158 rep.w = 1.0f / radiusOffset;
159 return rep;
160 }
161 }
162 }
163}
Vector3 InverseTransformPoint(Vector3 localWarpedPos)
Transform a point from warped space to rect space.
Quaternion InverseTransformRotation(Vector3 localWarpedPos, Quaternion localWarpedRot)
Transform a rotation from warped space to rect space.
Matrix4x4 GetTransformationMatrix(Vector3 localRectPos)
Get a transformation matrix that maps a position in rect space to a position in warped space.
Vector3 TransformDirection(Vector3 localRectPos, Vector3 localRectDirection)
Transform a direction from rect space to warped space.
Vector3 TransformPoint(Vector3 localRectPos)
Transform a point from rect space to warped space.
Vector3 InverseTransformDirection(Vector3 localWarpedPos, Vector3 localWarpedDirection)
Transform a direction from warped space to rect space.
Quaternion TransformRotation(Vector3 localRectPos, Quaternion localRectRot)
Transform a rotation from rect space to warped space.
override ITransformer CosntructBaseTransformer()
override void UpdateRadialTransformer(ITransformer transformer, ITransformer parent, Vector3 rectSpaceDelta)
override ITransformer ConstructTransformer(LeapSpaceAnchor anchor)