Tanoda
TransformInterpolators.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.Animation {
13 using Internal;
14
15 public partial struct Tween {
16 public TransformSelector Target(Transform transform) {
17 return new TransformSelector(transform, this);
18 }
19 }
20}
21
23
24 public struct TransformSelector {
25 private Transform _target;
26 private Tween _tween;
27
28 public TransformSelector(Transform target, Tween tween) {
29 _target = target;
30 _tween = tween;
31 }
32
33 #region POSITION
34 public Tween Position(Vector3 a, Vector3 b) {
35 return _tween.AddInterpolator(Pool<TransformPositionValueInterpolator>.Spawn().Init(a, b, _target));
36 }
37
38 public Tween ToPosition(Vector3 b) {
39 return _tween.AddInterpolator(Pool<TransformPositionValueInterpolator>.Spawn().Init(_target.position, b, _target));
40 }
41
42 public Tween ByPosition(Vector3 delta) {
43 return _tween.AddInterpolator(Pool<TransformPositionValueInterpolator>.Spawn().Init(_target.position, _target.position + delta, _target));
44 }
45
46 public Tween Position(Transform a, Transform b) {
47 return _tween.AddInterpolator(Pool<TransformPositionReferenceInterpolator>.Spawn().Init(a, b, _target));
48 }
49
50 public Tween LocalPosition(Vector3 a, Vector3 b) {
51 return _tween.AddInterpolator(Pool<TransformLocalPositionValueInterpolator>.Spawn().Init(a, b, _target));
52 }
53
54 public Tween ToLocalPosition(Vector3 b) {
55 return _tween.AddInterpolator(Pool<TransformLocalPositionValueInterpolator>.Spawn().Init(_target.localPosition, b, _target));
56 }
57
58 public Tween ByLocalPosition(Vector3 delta) {
59 return _tween.AddInterpolator(Pool<TransformLocalPositionValueInterpolator>.Spawn().Init(_target.localPosition, _target.localPosition + delta, _target));
60 }
61
62 public Tween LocalPosition(Transform a, Transform b) {
63 return _tween.AddInterpolator(Pool<TransformLocalPositionReferenceInterpolator>.Spawn().Init(a, b, _target));
64 }
65
66 private class TransformPositionValueInterpolator : Vector3InterpolatorBase<Transform> {
67 public override void Interpolate(float percent) {
68 _target.position = _a + _b * percent;
69 }
70
71 public override void Dispose() {
72 _target = null;
73 Pool<TransformPositionValueInterpolator>.Recycle(this);
74 }
75
76 public override bool isValid { get { return _target != null; } }
77 }
78
79 private class TransformPositionReferenceInterpolator : InterpolatorBase<Transform, Transform> {
80 public override float length {
81 get {
82 return Vector3.Distance(_a.position, _b.position);
83 }
84 }
85
86 public override void Interpolate(float percent) {
87 _target.position = Vector3.Lerp(_a.position, _b.position, percent);
88 }
89
90 public override void Dispose() {
91 _target = null;
92 Pool<TransformPositionReferenceInterpolator>.Recycle(this);
93 }
94
95 public override bool isValid { get { return _target != null; } }
96 }
97
98 private class TransformLocalPositionValueInterpolator : Vector3InterpolatorBase<Transform> {
99 public override void Interpolate(float percent) {
100 _target.localPosition = _a + _b * percent;
101 }
102
103 public override void Dispose() {
104 _target = null;
105 Pool<TransformLocalPositionValueInterpolator>.Recycle(this);
106 }
107
108 public override bool isValid { get { return _target != null; } }
109 }
110
111 private class TransformLocalPositionReferenceInterpolator : InterpolatorBase<Transform, Transform> {
112 public override float length {
113 get {
114 return Vector3.Distance(_a.localPosition, _b.localPosition);
115 }
116 }
117
118 public override void Interpolate(float percent) {
119 _target.localPosition = Vector3.Lerp(_a.localPosition, _b.localPosition, percent);
120 }
121
122 public override void Dispose() {
123 _target = null;
124 Pool<TransformLocalPositionReferenceInterpolator>.Recycle(this);
125 }
126
127 public override bool isValid { get { return _target != null; } }
128 }
129 #endregion
130
131 #region ROTATION
132 public Tween Rotation(Quaternion a, Quaternion b) {
133 return _tween.AddInterpolator(Pool<TransformRotationValueInterpolator>.Spawn().Init(a, b, _target));
134 }
135
136 public Tween ToRotation(Quaternion b) {
137 return _tween.AddInterpolator(Pool<TransformRotationValueInterpolator>.Spawn().Init(_target.rotation, b, _target));
138 }
139
140 public Tween ByRotation(Quaternion delta) {
141 return _tween.AddInterpolator(Pool<TransformRotationValueInterpolator>.Spawn().Init(_target.rotation, _target.rotation * delta, _target));
142 }
143
144 public Tween Rotation(Transform a, Transform b) {
145 return _tween.AddInterpolator(Pool<TransformRotationReferenceInterpolator>.Spawn().Init(a, b, _target));
146 }
147
148 public Tween LocalRotation(Quaternion a, Quaternion b) {
149 return _tween.AddInterpolator(Pool<TransformLocalRotationValueInterpolator>.Spawn().Init(a, b, _target));
150 }
151
152 public Tween ToLocalRotation(Quaternion b) {
153 return _tween.AddInterpolator(Pool<TransformLocalRotationValueInterpolator>.Spawn().Init(_target.localRotation, b, _target));
154 }
155
156 public Tween ByLocalRotation(Quaternion delta) {
157 return _tween.AddInterpolator(Pool<TransformLocalRotationValueInterpolator>.Spawn().Init(_target.localRotation, _target.localRotation * delta, _target));
158 }
159
160 public Tween LocalRotation(Transform a, Transform b) {
161 return _tween.AddInterpolator(Pool<TransformLocalRotationReferenceInterpolator>.Spawn().Init(a, b, _target));
162 }
163
164 private class TransformRotationValueInterpolator : QuaternionInterpolatorBase<Transform> {
165 public override void Interpolate(float percent) {
166 _target.rotation = Quaternion.Slerp(_a, _b, percent);
167 }
168
169 public override void Dispose() {
170 _target = null;
171 Pool<TransformRotationValueInterpolator>.Recycle(this);
172 }
173
174 public override bool isValid { get { return _target != null; } }
175 }
176
177 private class TransformRotationReferenceInterpolator : InterpolatorBase<Transform, Transform> {
178 public override float length {
179 get {
180 return Quaternion.Angle(_a.rotation, _b.rotation);
181 }
182 }
183
184 public override void Interpolate(float percent) {
185 _target.rotation = Quaternion.Slerp(_a.rotation, _b.rotation, percent);
186 }
187
188 public override void Dispose() {
189 _target = null;
190 Pool<TransformRotationReferenceInterpolator>.Recycle(this);
191 }
192
193 public override bool isValid { get { return _target != null; } }
194 }
195
196 private class TransformLocalRotationValueInterpolator : QuaternionInterpolatorBase<Transform> {
197 public override void Interpolate(float percent) {
198 _target.localRotation = Quaternion.Slerp(_a, _b, percent);
199 }
200
201 public override void Dispose() {
202 _target = null;
203 Pool<TransformLocalRotationValueInterpolator>.Recycle(this);
204 }
205
206 public override bool isValid { get { return _target != null; } }
207 }
208
209 private class TransformLocalRotationReferenceInterpolator : InterpolatorBase<Transform, Transform> {
210 public override float length {
211 get {
212 return Quaternion.Angle(_a.localRotation, _b.localRotation);
213 }
214 }
215
216 public override void Interpolate(float percent) {
217 _target.localRotation = Quaternion.Slerp(_a.localRotation, _b.localRotation, percent);
218 }
219
220 public override void Dispose() {
221 _target = null;
222 Pool<TransformLocalRotationReferenceInterpolator>.Recycle(this);
223 }
224
225 public override bool isValid { get { return _target != null; } }
226 }
227 #endregion
228
229 #region SCALE
230 public Tween LocalScale(Vector3 a, Vector3 b) {
231 return _tween.AddInterpolator(Pool<TransformLocalScaleValueInterpolator>.Spawn().Init(a, b, _target));
232 }
233
234 public Tween LocalScale(float a, float b) {
235 return _tween.AddInterpolator(Pool<TransformLocalScaleValueInterpolator>.Spawn().Init(Vector3.one * a, Vector3.one * b, _target));
236 }
237
238 public Tween ToLocalScale(Vector3 b) {
239 return _tween.AddInterpolator(Pool<TransformLocalScaleValueInterpolator>.Spawn().Init(_target.localScale, b, _target));
240 }
241
242 public Tween ToLocalScale(float b) {
243 return _tween.AddInterpolator(Pool<TransformLocalScaleValueInterpolator>.Spawn().Init(_target.localScale, Vector3.one * b, _target));
244 }
245
246 public Tween ByLocalScale(float b) {
247 return _tween.AddInterpolator(Pool<TransformLocalScaleValueInterpolator>.Spawn().Init(_target.localScale, _target.localScale * b, _target));
248 }
249
250 public Tween LocalScale(Transform a, Transform b) {
251 return _tween.AddInterpolator(Pool<TransformLocalScaleReferenceInterpolator>.Spawn().Init(a, b, _target));
252 }
253
254 private class TransformLocalScaleValueInterpolator : Vector3InterpolatorBase<Transform> {
255 public override void Interpolate(float percent) {
256 _target.localScale = _a + _b * percent;
257 }
258
259 public override void Dispose() {
260 _target = null;
261 Pool<TransformLocalScaleValueInterpolator>.Recycle(this);
262 }
263
264 public override bool isValid { get { return _target != null; } }
265 }
266
267 private class TransformLocalScaleReferenceInterpolator : InterpolatorBase<Transform, Transform> {
268 public override float length {
269 get {
270 return Quaternion.Angle(_a.localRotation, _b.localRotation);
271 }
272 }
273
274 public override void Interpolate(float percent) {
275 _target.localScale = Vector3.Lerp(_a.localScale, _b.localScale, percent);
276 }
277
278 public override void Dispose() {
279 _target = null;
280 Pool<TransformLocalScaleReferenceInterpolator>.Recycle(this);
281 }
282
283 public override bool isValid { get { return _target != null; } }
284 }
285 #endregion
286 }
287}
TransformSelector Target(Transform transform)