Tanoda
Rect.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 Leap.Unity.Infix;
11using System;
12using System.Collections;
13using System.Collections.Generic;
14using UnityEngine;
15
16namespace Leap.Unity.Geometry {
17
18 using UnityRect = UnityEngine.Rect;
19
20 public struct Rect {
21
22 public static readonly Vector3 PLANE_NORMAL = new Vector3(0, 0, -1);
23 public static readonly Color DEFAULT_GIZMO_COLOR = LeapColor.cerulean;
24
25 public Vector3 center;
26 public Vector2 radii;
27 public Transform transform;
28 public Matrix4x4? overrideMatrix;
29
30 public Rect(LocalRect localRect, Transform transform)
31 : this(localRect.center, localRect.radii, transform) { }
32
33 public Rect(Vector3 center, Vector2 radii, Transform transform = null) {
34 this.center = center;
35 this.radii = radii;
36 this.transform = transform;
37 overrideMatrix = null;
38 }
39
40 public Rect(Vector3 center, float radius, Transform transform = null) {
41 this.center = center;
42 this.radii = Vector2.one * radius;
43 this.transform = transform;
44 overrideMatrix = null;
45 }
46
47 public Rect(Vector2 radii, Transform transform = null)
48 : this(center: default(Vector3), radii: radii, transform: transform) { }
49
53 public Matrix4x4 matrix {
54 get {
55 if (overrideMatrix.HasValue) {
56 return overrideMatrix.Value * Matrix4x4.Translate(center);
57 }
58 if (transform == null) {
59 return Matrix4x4.Translate(center);
60 }
61 return transform.localToWorldMatrix * Matrix4x4.Translate(center);
62 }
63 }
64
70 public Pose pose {
71 get {
72 return matrix.GetPose();
73 }
74 }
75
76 public Vector3 localCorner00 {
77 get { return new Vector3(-radii.x, -radii.y); }
78 }
79 public Vector3 localCorner01 {
80 get { return new Vector3(-radii.x, radii.y); }
81 }
82 public Vector3 localCorner11 {
83 get { return new Vector3(radii.x, radii.y); }
84 }
85 public Vector3 localCorner10 {
86 get { return new Vector3(radii.x, -radii.y); }
87 }
88
93 public bool ContainsProjectedPoint(Vector3 point) {
94 Vector3 unusedPoint_rect;
95 return ContainsProjectedPoint(point, out unusedPoint_rect);
96 }
101 public bool ContainsProjectedPoint(Vector3 point, out Vector3 point_rect) {
102 point_rect = this.matrix.inverse.MultiplyPoint3x4(point);
103
104 var absPoint_rect = point_rect.Abs();
105 return absPoint_rect.x <= radii.x && absPoint_rect.y <= radii.y;
106 }
107
108 #region Corner Enumerator
109
111 get { return new RectWorldCornerEnumerator(this); }
112 }
114 private int _sideIdx;
115 private Vector3 corner00;
116 private Vector3 corner01;
117 private Vector3 corner11;
118 private Vector3 corner10;
120 //this.rect = rect;
121 _sideIdx = -1;
122 corner00 = rect.matrix.MultiplyPoint3x4(rect.localCorner00);
123 corner01 = rect.matrix.MultiplyPoint3x4(rect.localCorner01);
124 corner11 = rect.matrix.MultiplyPoint3x4(rect.localCorner11);
125 corner10 = rect.matrix.MultiplyPoint3x4(rect.localCorner10);
126 }
127 public RectWorldCornerEnumerator GetEnumerator() { return this; }
128 public Vector3 Current {
129 get {
130 switch (_sideIdx) {
131 case 0: return corner00;
132 case 1: return corner01;
133 case 2: return corner11;
134 case 3: return corner10;
135 default: return default(Vector3);
136 }
137 }
138 }
139 public bool MoveNext() {
140 _sideIdx += 1;
141 return _sideIdx < 4;
142 }
143 }
144
146 get { return new RectLocalCornerEnumerator(this); }
147 }
149 private int _sideIdx;
150 private Vector3 corner00;
151 private Vector3 corner01;
152 private Vector3 corner11;
153 private Vector3 corner10;
155 //this.rect = rect;
156 _sideIdx = -1;
157 corner00 = rect.localCorner00;
158 corner01 = rect.localCorner01;
159 corner11 = rect.localCorner11;
160 corner10 = rect.localCorner10;
161 }
162 public RectLocalCornerEnumerator GetEnumerator() { return this; }
163 public Vector3 Current {
164 get {
165 switch (_sideIdx) {
166 case 0: return corner00;
167 case 1: return corner01;
168 case 2: return corner11;
169 case 3: return corner10;
170 default: return default(Vector3);
171 }
172 }
173 }
174 public bool MoveNext() {
175 _sideIdx += 1;
176 return _sideIdx < 4;
177 }
178 }
179
180 #endregion
181
182 #region Side Enumerator
183
185 get { return new RectWorldSegmentEnumerator(this); }
186 }
188 //Rect rect;
189 private int _sideIdx;
190 private Vector3 corner00;
191 private Vector3 corner01;
192 private Vector3 corner11;
193 private Vector3 corner10;
195 //this.rect = rect;
196 _sideIdx = -1;
197 corner00 = rect.matrix.MultiplyPoint3x4(rect.localCorner00);
198 corner01 = rect.matrix.MultiplyPoint3x4(rect.localCorner01);
199 corner11 = rect.matrix.MultiplyPoint3x4(rect.localCorner11);
200 corner10 = rect.matrix.MultiplyPoint3x4(rect.localCorner10);
201 }
204 get {
205 switch (_sideIdx) {
206 case 0: return new LocalSegment3(corner00, corner01);
207 case 1: return new LocalSegment3(corner01, corner11);
208 case 2: return new LocalSegment3(corner11, corner10);
209 case 3: return new LocalSegment3(corner10, corner00);
210 default: return new LocalSegment3();
211 }
212 }
213 }
214 public bool MoveNext() {
215 _sideIdx += 1;
216 return _sideIdx < 4;
217 }
218 }
219
221 get { return new RectLocalSegmentEnumerator(this); }
222 }
224 //Rect rect;
225 private int _sideIdx;
226 private Vector3 corner00;
227 private Vector3 corner01;
228 private Vector3 corner11;
229 private Vector3 corner10;
231 //this.rect = rect;
232 _sideIdx = -1;
233 corner00 = rect.localCorner00;
234 corner01 = rect.localCorner01;
235 corner11 = rect.localCorner11;
236 corner10 = rect.localCorner10;
237 }
240 get {
241 switch (_sideIdx) {
242 case 0: return new LocalSegment3(corner00, corner01);
243 case 1: return new LocalSegment3(corner01, corner11);
244 case 2: return new LocalSegment3(corner11, corner10);
245 case 3: return new LocalSegment3(corner10, corner00);
246 default: return new LocalSegment3();
247 }
248 }
249 }
250 public bool MoveNext() {
251 _sideIdx += 1;
252 return _sideIdx < 4;
253 }
254 }
255
256 #endregion
257
258 #region Runtime Gizmos
259
260 public void DrawLines(Action<Vector3, Vector3> drawLineFunc,
261 int divisions = 0)
262 {
263 Vector3 b = localCorner01, c = localCorner11,
265
266 a = matrix.MultiplyPoint3x4(a);
267 b = matrix.MultiplyPoint3x4(b);
268 c = matrix.MultiplyPoint3x4(c);
269 d = matrix.MultiplyPoint3x4(d);
270
271 divisions = Mathf.Max(1, divisions);
272 if (divisions > 1) {
273 var frac = 1 / divisions;
274 drawDividedLines(drawLineFunc, step: frac, a: a, b: b);
275 drawDividedLines(drawLineFunc, step: frac, a: b, b: c);
276 drawDividedLines(drawLineFunc, step: frac, a: c, b: d);
277 drawDividedLines(drawLineFunc, step: frac, a: d, b: a);
278 }
279 else {
280 drawLineFunc(a, b);
281 drawLineFunc(b, c);
282 drawLineFunc(c, d);
283 drawLineFunc(d, a);
284 }
285
286 }
287
288 private void drawDividedLines(System.Action<Vector3, Vector3> draw,
289 float step, Vector3 a, Vector3 b)
290 {
291 step = Mathf.Max(0.01f, step);
292 var a_t = a;
293 for (var t = step; t <= 1f; t += step) {
294 var b_t = Vector3.Lerp(a, b, t);
295 draw(a_t, b_t);
296 a_t = b_t;
297 }
298 }
299
301 drawer.PushMatrix();
302 drawer.matrix = this.matrix;
303
304 Vector3 b = localCorner01, c = localCorner11,
306
307 Vector2 shrink;
308 var invRadii = Vector3.one.CompDiv(radii.Abs()).NaNOrInfTo(0f);
309 if (radii == Vector2.zero) {
310 shrink = Vector2.zero;
311 }
312 else {
313 shrink = Vector2.one * (radii * 0.02f).Abs().CompMin();
314 }
315 int numRectLines = 8;
316 for (int i = 0; i < numRectLines; i++) {
317 var shrinkMul = (Vector2.one - shrink.CompMul(invRadii) * i);
318 drawer.DrawLine(shrinkMul.CompMul(a), shrinkMul.CompMul(b));
319 drawer.DrawLine(shrinkMul.CompMul(b), shrinkMul.CompMul(c));
320 drawer.DrawLine(shrinkMul.CompMul(c), shrinkMul.CompMul(d));
321 drawer.DrawLine(shrinkMul.CompMul(d), shrinkMul.CompMul(a));
322 }
323
324 drawer.DrawLine(a, c);
325 drawer.DrawLine(b, d);
326
327 //drawer.matrix = Matrix4x4.Scale(new Vector3(1f, 1f, 0f)) * this.matrix;
328 //drawer.DrawCube(Vector3.zero, new Vector3(radii.x, radii.y, 1f));
329
330 drawer.PopMatrix();
331 }
332
333 #endregion
334
335 }
336
337}
338
UnityEngine.Color Color
Definition: TestScript.cs:32
void PushMatrix()
Saves the current gizmo matrix to the gizmo matrix stack.
void PopMatrix()
Restores the current gizmo matrix from the gizmo matrix stack.
void DrawLine(Vector3 a, Vector3 b)
Draws a gizmo line that connects the two positions.
Matrix4x4 matrix
Sets or gets the matrix used to transform all gizmos.
UnityEngine.Rect UnityRect
Definition: LeapGrid.cs:14
RectLocalCornerEnumerator GetEnumerator()
Definition: Rect.cs:162
RectLocalSegmentEnumerator GetEnumerator()
Definition: Rect.cs:238
RectWorldCornerEnumerator GetEnumerator()
Definition: Rect.cs:127
RectWorldSegmentEnumerator GetEnumerator()
Definition: Rect.cs:202
Vector3 localCorner10
Definition: Rect.cs:85
Rect(LocalRect localRect, Transform transform)
Definition: Rect.cs:30
Vector3 localCorner00
Definition: Rect.cs:76
Rect(Vector2 radii, Transform transform=null)
Definition: Rect.cs:47
Rect(Vector3 center, Vector2 radii, Transform transform=null)
Definition: Rect.cs:33
bool ContainsProjectedPoint(Vector3 point)
Returns whether the given world-space point projects inside this Rect. Optionally also outputs the ca...
Definition: Rect.cs:93
static readonly Vector3 PLANE_NORMAL
Definition: Rect.cs:22
void DrawLines(Action< Vector3, Vector3 > drawLineFunc, int divisions=0)
Definition: Rect.cs:260
RectWorldSegmentEnumerator segments
Definition: Rect.cs:184
Vector3 localCorner11
Definition: Rect.cs:82
Matrix4x4 matrix
Local-to-world matrix for this Rect. (Read only.)
Definition: Rect.cs:53
RectWorldCornerEnumerator corners
Definition: Rect.cs:110
void DrawRuntimeGizmos(RuntimeGizmoDrawer drawer)
Definition: Rect.cs:300
Vector3 localCorner01
Definition: Rect.cs:79
RectLocalCornerEnumerator localCorners
Definition: Rect.cs:145
Transform transform
Definition: Rect.cs:27
Pose pose
Local-to-world pose for the center of this Rect. (Read only.)
Definition: Rect.cs:70
RectLocalSegmentEnumerator localSegments
Definition: Rect.cs:220
Matrix4x4? overrideMatrix
Definition: Rect.cs:28
Rect(Vector3 center, float radius, Transform transform=null)
Definition: Rect.cs:40
static readonly Color DEFAULT_GIZMO_COLOR
Definition: Rect.cs:23
bool ContainsProjectedPoint(Vector3 point, out Vector3 point_rect)
Returns whether the given world-space point projects inside this Rect. Optionally also outputs the ca...
Definition: Rect.cs:101
A position and rotation. You can multiply two poses; this acts like Matrix4x4 multiplication,...
Definition: Pose.cs:21