1 /* Copyright Jukka Jyl�nki
2
3    Licensed under the Apache License, Version 2.0 (the "License");
4    you may not use this file except in compliance with the License.
5    You may obtain a copy of the License at
6
7        http://www.apache.org/licenses/LICENSE-2.0
8
9    Unless required by applicable law or agreed to in writing, software
10    distributed under the License is distributed on an "AS IS" BASIS,
11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12    See the License for the specific language governing permissions and
13    limitations under the License. */
14
15 /** @file AABB2D.h
16         @author Jukka Jyl�nki
17         @brief 2D Axis-Aligned Bounding Box structure. */
18 #pragma once
19
20 #include <stdio.h>
21
22 #include "../Math/float2.h"
23 #include "../Math/float3.h"
24 #include "../Math/MathConstants.h"
25
26 MATH_BEGIN_NAMESPACE
27
28 struct AABB2D
29 {
30         AABB2D() { }
31         AABB2D(const float2 &minPt, const float2 &maxPt)
32         :minPoint(minPt),
33         maxPoint(maxPt)
34         {
35         }
36
37         float2 minPoint;
38         float2 maxPoint;
39
40         float Width() const { return maxPoint.x - minPoint.x; }
41         float Height() const { return maxPoint.y - minPoint.y; }
42
43         float DistanceSq(const float2 &pt) const
44         {
45                 float2 cp = pt.Clamp(minPoint, maxPoint);
46                 return cp.DistanceSq(pt);
47         }
48
49         void SetNegativeInfinity()
50         {
51                 minPoint.SetFromScalar(FLOAT_INF);
52                 maxPoint.SetFromScalar(-FLOAT_INF);
53         }
54
55         void Enclose(const float2 &point)
56         {
57                 minPoint = Min(minPoint, point);
58                 maxPoint = Max(maxPoint, point);
59         }
60
61         bool Intersects(const AABB2D &rhs) const
62         {
63                 return maxPoint.x >= rhs.minPoint.x &&
64                        maxPoint.y >= rhs.minPoint.y &&
65                        rhs.maxPoint.x >= minPoint.x &&
66                        rhs.maxPoint.y >= minPoint.y;
67         }
68
69         bool Contains(const AABB2D &rhs) const
70         {
71                 return rhs.minPoint.x >= minPoint.x && rhs.minPoint.y >= minPoint.y
72                         && rhs.maxPoint.x <= maxPoint.x && rhs.maxPoint.y <= maxPoint.y;
73         }
74
75         bool Contains(const float2 &pt) const
76         {
77                 return pt.x >= minPoint.x && pt.y >= minPoint.y
78                         && pt.x <= maxPoint.x && pt.y <= maxPoint.y;
79         }
80
81         bool Contains(int x, int y) const
82         {
83                 return x >= minPoint.x && y >= minPoint.y
84                         && x <= maxPoint.x && y <= maxPoint.y;
85         }
86
87         bool IsDegenerate() const
88         {
89                 return minPoint.x >= maxPoint.x || minPoint.y >= maxPoint.y;
90         }
91
92         bool HasNegativeVolume() const
93         {
94                 return maxPoint.x < minPoint.x || maxPoint.y < minPoint.y;
95         }
96
97         bool IsFinite() const
98         {
99                 return minPoint.IsFinite() && maxPoint.IsFinite() && minPoint.MinElement() > -1e5f && maxPoint.MaxElement() < 1e5f;
100         }
101
102         float2 PosInside(const float2 &normalizedPos) const
103         {
104                 return minPoint + normalizedPos.Mul(maxPoint - minPoint);
105         }
106
107         float2 ToNormalizedLocalSpace(const float2 &pt) const
108         {
109                 return (pt - minPoint).Div(maxPoint - minPoint);
110         }
111
112         AABB2D operator +(const float2 &pt) const
113         {
114                 AABB2D a;
115                 a.minPoint = minPoint + pt;
116                 a.maxPoint = maxPoint + pt;
117                 return a;
118         }
119
120         AABB2D operator -(const float2 &pt) const
121         {
122                 AABB2D a;
123                 a.minPoint = minPoint - pt;
124                 a.maxPoint = maxPoint - pt;
125                 return a;
126         }
127
128 #ifdef MATH_ENABLE_STL_SUPPORT
129         std::string ToString() const
130         {
131                 char str[256];
132                 sprintf(str, "AABB2D(Min:(%.2f, %.2f) Max:(%.2f, %.2f))", minPoint.x, minPoint.y, maxPoint.x, maxPoint.y);
133                 return str;
134         }
135 #endif
136 };
137
138 inline AABB2D GetAABB2D(const float3 &pt) { return AABB2D(pt.xy(), pt.xy()); }
139
140 inline bool Contains(const AABB2D &aabb, const float3 &pt)
141 {
142         return aabb.minPoint.x <= pt.x &&
143                aabb.minPoint.y <= pt.y &&
144                pt.x <= aabb.maxPoint.x &&
145                pt.y <= aabb.maxPoint.y;
146 }
147
148 MATH_END_NAMESPACE