]>
Dogcows Code - chaz/yoink/blob - src/vector.hh
2 /*******************************************************************************
4 Copyright (c) 2009, Charles McGarvey
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
10 * Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
12 * Redistributions in binary form must reproduce the above copyright notice,
13 this list of conditions and the following disclaimer in the documentation
14 and/or other materials provided with the distribution.
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
20 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *******************************************************************************/
44 // TODO: project, reflect, random, normal (of plane), orthonormal
49 * 2-dimensional vector.
55 vector2(scalar X
, scalar Y
) : x(X
), y(Y
) {}
56 vector2(scalar v
[2]) : x(v
[0]), y(v
[1]) {}
58 const scalar
& operator[](int i
) const
60 assert(i
>= 0 && i
<= 1 && "Index into vector2 out of bounds.");
63 scalar
& operator[](int i
)
65 assert(i
>= 0 && i
<= 1 && "Index into vector2 out of bounds.");
69 vector2
operator+(const vector2
& v
) const
71 return vector2(x
+ v
.x
, y
+ v
.y
);
73 vector2
operator-(const vector2
& v
) const
75 return vector2(x
- v
.x
, y
- v
.y
);
77 vector2
operator*(scalar s
) const
79 return vector2(x
* s
, y
* s
);
81 vector2
operator/(scalar s
) const
83 return vector2(x
/ s
, y
/ s
);
86 vector2
& operator+=(const vector2
& v
)
91 vector2
& operator-=(const vector2
& v
)
96 vector2
& operator*=(scalar s
)
101 vector2
& operator/=(scalar s
)
107 vector2
operator-() const
109 return vector2(-x
, -y
);
112 scalar
dot(const vector2
& v
) const /// dot product
114 return x
* v
.x
+ y
* v
.y
;
116 scalar
angleBetween(const vector2
& v
) const
118 scalar lens
= length() * v
.length();
119 if (lens
== 0.0) { return HUGE_VAL
; }
120 return std::acos(dot(v
) / lens
);
123 void normalize() /// scale such that length is one
125 scalar len
= length();
126 if (len
!= 0.0) { *this /= len
; }
128 vector2
normalized() const
130 scalar len
= length();
131 if (len
!= 0.0) { return *this / len
; }
132 return vector2(0.0, 0.0);
135 scalar
length2() const /// magnitude squared
139 scalar
length() const /// magnitude
141 return std::sqrt(length2());
144 bool operator==(const vector2
& v
) const
146 return equals(x
, v
.x
) && equals(y
, v
.y
);
148 bool operator!=(const vector2
& v
) const
150 return !(*this == v
);
154 static vector2
random()
156 vector2 v
= random(-1.0, 1.0);
161 static vector2
random(scalar lower
, scalar upper
)
163 return vector2(rng::get
<scalar
>(lower
, upper
),
164 rng::get
<scalar
>(lower
, upper
));
172 scalar x
, y
; ///< euler coordinates
174 scalar array
[2]; ///< array
177 static vector2 zero
; ///< zero vector
180 inline vector2
operator*(scalar s
, const vector2
& v
)
184 inline vector2
operator/(scalar s
, const vector2
& v
)
186 return vector2(s
/ v
.x
, s
/ v
.y
);
189 inline std::ostream
& operator<<(std::ostream
& output
, const vector2
& v
)
191 output
<< "(" << v
.x
<< "," << v
.y
<< ")";
196 typedef vector2 point
;
199 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
202 * 3-dimensional vector.
208 vector3(scalar X
, scalar Y
, scalar Z
) : x(X
), y(Y
), z(Z
) {}
209 vector3(scalar v
[3]) : x(v
[0]), y(v
[1]), z(v
[2]) {}
211 const scalar
& operator[](int i
) const
213 assert(i
>= 0 && i
<= 2 && "Index into vector3 out of bounds.");
216 scalar
& operator[](int i
)
218 assert(i
>= 0 && i
<= 2 && "Index into vector3 out of bounds.");
222 vector3
operator+(const vector3
& v
) const
224 return vector3(x
+ v
.x
, y
+ v
.y
, z
+ v
.z
);
226 vector3
operator-(const vector3
& v
) const
228 return vector3(x
- v
.x
, y
- v
.y
, z
- v
.z
);
230 vector3
operator*(scalar s
) const
232 return vector3(x
* s
, y
* s
, z
* s
);
234 vector3
operator/(scalar s
) const
236 return vector3(x
/ s
, y
/ s
, z
/ s
);
239 vector3
& operator+=(const vector3
& v
)
241 x
+= v
.x
; y
+= v
.y
; z
+= v
.z
;
244 vector3
& operator-=(const vector3
& v
)
246 x
-= v
.x
; y
-= v
.y
; z
-= v
.z
;
249 vector3
& operator*=(scalar s
)
251 x
*= s
; y
*= s
; z
*= s
;
254 vector3
& operator/=(scalar s
)
256 x
/= s
; y
/= s
; z
/= s
;
260 vector3
operator-() const
262 return vector3(-x
, -y
, -z
);
265 scalar
dot(const vector3
& v
) const /// dot product
267 return x
* v
.x
+ y
* v
.y
+ z
* v
.z
;
269 vector3
cross(const vector3
& v
) const /// cross product
271 return vector3(y
* v
.z
- z
* v
.y
,
276 scalar
angleBetween(const vector3
& v
) const
278 scalar lens
= length() * v
.length();
279 if (lens
== 0.0) { return HUGE_VAL
; }
280 return std::acos(dot(v
) / lens
);
283 void normalize() /// scale such that length is one
285 scalar len
= length();
286 if (len
!= 0.0) { *this /= len
; }
288 vector3
normalized() const
290 scalar len
= length();
291 if (len
!= 0.0) { return *this / len
; }
292 return vector3(0.0, 0.0, 0.0);
295 scalar
length2() const /// magnitude squared
299 scalar
length() const /// magnitude
301 return std::sqrt(length2());
304 bool operator==(const vector3
& v
) const
306 return equals(x
, v
.x
) && equals(y
, v
.y
) && equals(z
, v
.z
);
308 bool operator!=(const vector3
& v
) const
310 return !(*this == v
);
314 static vector3
random()
316 vector3 v
= random(-1.0, 1.0);
321 static vector3
random(scalar lower
, scalar upper
)
323 return vector3(rng::get
<scalar
>(lower
, upper
),
324 rng::get
<scalar
>(lower
, upper
),
325 rng::get
<scalar
>(lower
, upper
));
333 scalar x
, y
, z
; ///< euler coordinates
337 scalar u
, v
, w
; ///< texture coordinates
341 scalar r
, g
, b
; ///< color intensities
343 scalar array
[3]; ///< array
346 static vector3 zero
; ///< zero vector
349 inline vector3
operator*(scalar s
, const vector3
& v
)
353 inline vector3
operator/(scalar s
, const vector3
& v
)
355 return vector3(s
/ v
.x
, s
/ v
.y
, s
/ v
.z
);
358 inline std::ostream
& operator<<(std::ostream
& output
, const vector3
& v
)
360 output
<< "(" << v
.x
<< "," << v
.y
<< "," << v
.z
<< ")";
365 typedef vector3 color
;
371 #endif // _VECTOR_HH_
This page took 0.047902 seconds and 4 git commands to generate.