liberty.math.traits source code

1 /**
2  * Copyright:       Copyright (C) 2018 Gabriel Gheorghe, All Rights Reserved
3  * Authors:         $(Gabriel Gheorghe)
4  * License:         $(LINK2 https://www.gnu.org/licenses/gpl-3.0.txt, GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007)
5  * Source:          $(LINK2 https://github.com/GabyForceQ/LibertyEngine/blob/master/source/liberty/math/traits.d)
6  * Documentation:
7  * Coverage:
8 **/
9 module liberty.math.traits;
10 
11 import liberty.math.matrix;
12 import liberty.math.quaternion;
13 import liberty.math.box;
14 import liberty.math.vector;
15 import liberty.math.shapes; 
16 
17 /**
18  * True if T is some kind of Vector.
19 **/
20 enum isVector(T) = is(T : Vector!U, U...);
21 
22 /**
23  *
24 **/
25   unittest {
26   static assert(isVector!Vector2F);
27   static assert(isVector!Vector3I);
28   static assert(isVector!(Vector4!uint));
29   static assert(!isVector!real);
30 }
31 
32 /**
33  * The numeric type used to measure coordinates of a vector.
34 **/
35 alias DimensionType(T : Vector!U, U...) = U[0];
36 
37 /**
38  *
39 **/
40   unittest {
41   static assert(is(DimensionType!Vector2F == float));
42   static assert(is(DimensionType!Vector3D == double));
43   static assert(is(DimensionType!Vector4U == uint));
44 }
45 
46 /**
47  *
48 **/
49 template isMatrixInstance(U) {
50 	private static void isMatrix(T, int R, int C)(Matrix!(T, R, C) x) {}
51 	enum bool isMatrixInstance = is(typeof(isMatrix(U.init)));
52 }
53 
54 /**
55  *
56 **/
57 template isQuaternionInstance(U) {
58 	private static void isQuaternion(T)(Quaternion!T x) {}
59 	enum bool isQuaternionInstance = is(typeof(isQuaternion(U.init)));
60 }
61 
62 /**
63  *
64 **/
65 alias DimensionType(T : Box!U, U...) = U[0];
66 
67 /**
68  *
69 **/
70   unittest {
71 	static assert(is(DimensionType!Box2F == float));
72 	static assert(is(DimensionType!Box3D == double));
73 }
74 
75 /**
76  *
77 **/
78 enum isBox(T) = is(T : Box!U, U...);
79 
80 /**
81  *
82 **/
83   unittest {
84 	static assert(isBox!Box2F);
85 	static assert(isBox!Box3I);
86 	static assert(isBox!(Box!(double, 2)));
87 	static assert(!isBox!(Vector!(float, 3)));
88 }
89 
90 /**
91  *
92 **/
93 enum isSegment(T) = is(T : Segment!U, U...);
94 
95 /**
96  *
97 **/
98 enum isTriangle(T) = is(T : Triangle!U, U...);
99 
100 /**
101  *
102 **/
103 enum isSphere(T) = is(T : Sphere!U, U...);
104 
105 /**
106  *
107 **/
108 enum isRay(T) = is(T : Ray!U, U...);
109 
110 /**
111  *
112 **/
113 enum isPlane(T) = is(T : Plane!U, U);
114 
115 /**
116  *
117 **/
118 enum isFrustum(T) = is(T : Frustum!U, U);
119 
120 /**
121  *
122 **/
123 enum isSegment2D(T) = is(T : Segment!(U, 2), U);
124 
125 /**
126  *
127 **/
128 enum isTriangle2D(T) = is(T : Triangle!(U, 2), U);
129 
130 /**
131  *
132 **/
133 enum isSphere2D(T) = is(T : Sphere!(U, 2), U);
134 
135 /**
136  *
137 **/
138 enum isRay2D(T) = is(T : Ray!(U, 2), U);
139 
140 /**
141  *
142 **/
143 enum isSegment3D(T) = is(T : Segment!(U, 3), U);
144 
145 /**
146  *
147 **/
148 enum isTriangle3D(T) = is(T : Triangle!(U, 3), U);
149 
150 /**
151  *
152 **/
153 enum isSphere3D(T) = is(T : Sphere!(U, 3), U);
154 
155 /**
156  *
157 **/
158 enum isRay3D(T) = is(T : Ray!(U, 3), U);
159 
160 /**
161  *
162 **/
163 alias DimensionType(T : Segment!U, U...) = U[0];
164 
165 /**
166  *
167 **/
168 alias DimensionType(T : Triangle!U, U...) = U[0];
169 
170 /**
171  *
172 **/
173 alias DimensionType(T : Sphere!U, U...) = U[0];
174 
175 /**
176  *
177 **/
178 alias DimensionType(T : Ray!U, U...) = U[0];
179 
180 /**
181  *
182 **/
183 alias DimensionType(T : Plane!U, U) = U;
184 
185 /**
186  *
187 **/
188 alias DimensionType(T : Frustum!U, U) = U;
189 
190 /**
191  *
192 **/
193   unittest {
194 	static assert(is(DimensionType!Segment2I == int));
195 	static assert(is(DimensionType!Triangle3F == float));
196 	static assert(is(DimensionType!Sphere2D == double));
197 	static assert(is(DimensionType!Ray3F == float));
198 	static assert(is(DimensionType!PlaneD == double));
199 	static assert(is(DimensionType!(Frustum!float) == float));
200 }