00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00025 #ifndef AMPLEUTIL_H
00026 #define AMPLEUTIL_H
00028
00029 #include <math.h>
00030
00031 #ifdef _WIN32
00032
00033 #undef min
00034 #undef max
00035
00036 float fminf(float x, float y);
00037 float fmaxf(float x, float y);
00038
00039 #endif
00040
00042
00043 namespace verse
00044 {
00045 namespace ample
00046 {
00047
00048
00049
00050 template <typename T>
00051 class Vector3
00052 {
00053 public:
00054 inline Vector3(void);
00055 inline Vector3(T sx, T sy, T sz);
00056 inline T length(void) const;
00057 inline T lengthSquared(void) const;
00058 inline T dotProduct(const Vector3<T>& vector) const;
00059 inline Vector3 crossProduct(const Vector3<T>& vector) const;
00060 inline void scaleBy(T factor);
00061 inline void scaleTo(T length);
00062 inline void mirrorBy(const Vector3<T>& vector);
00063 inline void invert(void);
00064 inline void normalize(void);
00065 inline operator T* (void);
00066 inline operator const T* (void) const;
00067 inline Vector3 operator - (void) const;
00068 inline Vector3 operator + (T value) const;
00069 inline Vector3 operator - (T value) const;
00070 inline Vector3 operator * (T value) const;
00071 inline Vector3 operator / (T value) const;
00072 inline Vector3 operator += (T value);
00073 inline Vector3<T>& operator -= (T value);
00074 inline Vector3<T>& operator *= (T value);
00075 inline Vector3<T>& operator /= (T value);
00076 inline Vector3 operator + (const Vector3<T>& vector) const;
00077 inline Vector3 operator - (const Vector3<T>& vector) const;
00078 inline Vector3 operator * (const Vector3<T>& vector) const;
00079 inline Vector3 operator / (const Vector3<T>& vector) const;
00080 inline Vector3 operator += (const Vector3<T>& vector);
00081 inline Vector3<T>& operator -= (const Vector3<T>& vector);
00082 inline Vector3<T>& operator *= (const Vector3<T>& vector);
00083 inline Vector3<T>& operator /= (const Vector3<T>& vector);
00084 inline bool operator == (const Vector3<T>& vector) const;
00085 inline bool operator != (const Vector3<T>& vector) const;
00086 inline void set(T sx, T sy, T sz);
00087 T x;
00088 T y;
00089 T z;
00090 };
00091
00092
00093
00094 typedef Vector3<real32> Vector3f;
00095 typedef Vector3<real64> Vector3d;
00096
00097
00098
00099 class ColorRGB
00100 {
00101 public:
00102 inline ColorRGB(void);
00103 inline ColorRGB(real64 sr, real64 sg, real64 sb);
00104 inline void clamp(void);
00105 inline ColorRGB min(const ColorRGB& color) const;
00106 inline ColorRGB max(const ColorRGB& color) const;
00107 inline operator real64* (void);
00108 inline operator const real64* (void) const;
00109 inline ColorRGB operator - (void) const;
00110 inline ColorRGB operator + (real64 value) const;
00111 inline ColorRGB operator - (real64 value) const;
00112 inline ColorRGB operator * (real64 value) const;
00113 inline ColorRGB operator / (real64 value) const;
00114 inline ColorRGB operator += (real64 value);
00115 inline ColorRGB& operator -= (real64 value);
00116 inline ColorRGB& operator *= (real64 value);
00117 inline ColorRGB& operator /= (real64 value);
00118 inline ColorRGB operator + (const ColorRGB& color) const;
00119 inline ColorRGB operator - (const ColorRGB& color) const;
00120 inline ColorRGB operator * (const ColorRGB& color) const;
00121 inline ColorRGB operator / (const ColorRGB& color) const;
00122 inline ColorRGB operator += (const ColorRGB& color);
00123 inline ColorRGB& operator -= (const ColorRGB& color);
00124 inline ColorRGB& operator *= (const ColorRGB& color);
00125 inline ColorRGB& operator /= (const ColorRGB& color);
00126 inline bool operator == (const ColorRGB& color) const;
00127 inline bool operator != (const ColorRGB& color) const;
00128 inline real64 getLength(void) const;
00129 inline real64 getSquaredLength(void) const;
00130 inline void setDefaults(void);
00131 inline void set(real64 sr, real64 sg, real64 sb);
00132 real64 r;
00133 real64 g;
00134 real64 b;
00135 static const ColorRGB WHITE;
00136 static const ColorRGB BLACK;
00137 };
00138
00139
00140
00141 template <typename T>
00142 inline Vector3<T>::Vector3(void)
00143 {
00144 }
00145
00146 template <typename T>
00147 inline Vector3<T>::Vector3(T sx, T sy, T sz):
00148 x(sx),
00149 y(sy),
00150 z(sz)
00151 {
00152 }
00153
00154 template <typename T>
00155 inline T Vector3<T>::length(void) const
00156 {
00157 return sqrtf(x * x + y * y + z * z);
00158 }
00159
00160 template <typename T>
00161 inline T Vector3<T>::lengthSquared(void) const
00162 {
00163 return x * x + y * y + z * z;
00164 }
00165
00166 template <typename T>
00167 inline T Vector3<T>::dotProduct(const Vector3<T>& vector) const
00168 {
00169 return x * vector.x + y * vector.y + z * vector.z;
00170 }
00171
00172 template <typename T>
00173 inline Vector3<T> Vector3<T>::crossProduct(const Vector3<T>& vector) const
00174 {
00175 return Vector3(vector.z * y - vector.y * z, vector.x * z - vector.z * x, vector.y * x - vector.x * y);
00176 }
00177
00178 template <typename T>
00179 inline void Vector3<T>::scaleBy(T factor)
00180 {
00181 x *= factor;
00182 y *= factor;
00183 z *= factor;
00184 }
00185
00186 template <typename T>
00187 inline void Vector3<T>::scaleTo(T len)
00188 {
00189 const T scale = len / length();
00190
00191 x *= scale;
00192 y *= scale;
00193 z *= scale;
00194 }
00195
00196 template <typename T>
00197 inline void Vector3<T>::mirrorBy(const Vector3<T>& vector)
00198 {
00199 const T scale = 2.f * (x * vector.x + y * vector.y + z * vector.z);
00200
00201 x = vector.x * scale - x;
00202 y = vector.y * scale - y;
00203 z = vector.z * scale - z;
00204 }
00205
00206 template <typename T>
00207 inline void Vector3<T>::invert(void)
00208 {
00209 x = -x;
00210 y = -y;
00211 z = -z;
00212 }
00213
00214 template <typename T>
00215 inline void Vector3<T>::normalize(void)
00216 {
00217 const T scale = 1.f / length();
00218
00219 x *= scale;
00220 y *= scale;
00221 z *= scale;
00222 }
00223
00224 template <typename T>
00225 inline Vector3<T>::operator T* (void)
00226 {
00227 return &x;
00228 }
00229
00230 template <typename T>
00231 inline Vector3<T>::operator const T* (void) const
00232 {
00233 return &x;
00234 }
00235
00236 template <typename T>
00237 inline Vector3<T> Vector3<T>::operator - (void) const
00238 {
00239 return Vector3(-x, -y, -z);
00240 }
00241
00242 template <typename T>
00243 inline Vector3<T> Vector3<T>::operator + (T value) const
00244 {
00245 return Vector3(x + value, y + value, z + value);
00246 }
00247
00248 template <typename T>
00249 inline Vector3<T> Vector3<T>::operator - (T value) const
00250 {
00251 return Vector3(x - value, y - value, z - value);
00252 }
00253
00254 template <typename T>
00255 inline Vector3<T> Vector3<T>::operator * (T value) const
00256 {
00257 return Vector3(x * value, y * value, z * value);
00258 }
00259
00260 template <typename T>
00261 inline Vector3<T> Vector3<T>::operator / (T value) const
00262 {
00263 return Vector3(x / value, y / value, z / value);
00264 }
00265
00266 template <typename T>
00267 inline Vector3<T> Vector3<T>::operator += (T value)
00268 {
00269 x += value;
00270 y += value;
00271 z += value;
00272 return *this;
00273 }
00274
00275 template <typename T>
00276 inline Vector3<T>& Vector3<T>::operator -= (T value)
00277 {
00278 x -= value;
00279 y -= value;
00280 z -= value;
00281 return *this;
00282 }
00283
00284 template <typename T>
00285 inline Vector3<T>& Vector3<T>::operator *= (T value)
00286 {
00287 x *= value;
00288 y *= value;
00289 z *= value;
00290 return *this;
00291 }
00292
00293 template <typename T>
00294 inline Vector3<T>& Vector3<T>::operator /= (T value)
00295 {
00296 x /= value;
00297 y /= value;
00298 z /= value;
00299 return *this;
00300 }
00301
00302 template <typename T>
00303 inline Vector3<T> Vector3<T>::operator + (const Vector3<T>& vector) const
00304 {
00305 return Vector3<T>(x + vector.x, y + vector.y, z + vector.z);
00306 }
00307
00308 template <typename T>
00309 inline Vector3<T> Vector3<T>::operator - (const Vector3<T>& vector) const
00310 {
00311 return Vector3<T>(x - vector.x, y - vector.y, z - vector.z);
00312 }
00313
00314 template <typename T>
00315 inline Vector3<T> Vector3<T>::operator * (const Vector3<T>& vector) const
00316 {
00317 return Vector3<T>(x * vector.x, y * vector.y, z * vector.z);
00318 }
00319
00320 template <typename T>
00321 inline Vector3<T> Vector3<T>::operator / (const Vector3<T>& vector) const
00322 {
00323 return Vector3<T>(x / vector.x, y / vector.y, z / vector.z);
00324 }
00325
00326 template <typename T>
00327 inline Vector3<T> Vector3<T>::operator += (const Vector3<T>& vector)
00328 {
00329 x += vector.x;
00330 y += vector.y;
00331 z += vector.z;
00332 return *this;
00333 }
00334
00335 template <typename T>
00336 inline Vector3<T>& Vector3<T>::operator -= (const Vector3<T>& vector)
00337 {
00338 x -= vector.x;
00339 y -= vector.y;
00340 z -= vector.z;
00341 return *this;
00342 }
00343
00344 template <typename T>
00345 inline Vector3<T>& Vector3<T>::operator *= (const Vector3<T>& vector)
00346 {
00347 x *= vector.x;
00348 y *= vector.y;
00349 z *= vector.z;
00350 return *this;
00351 }
00352
00353 template <typename T>
00354 inline Vector3<T>& Vector3<T>::operator /= (const Vector3<T>& vector)
00355 {
00356 x /= vector.x;
00357 y /= vector.y;
00358 z /= vector.z;
00359 return *this;
00360 }
00361
00362 template <typename T>
00363 inline bool Vector3<T>::operator == (const Vector3<T>& vector) const
00364 {
00365 return x == vector.x && y == vector.y && z == vector.z;
00366 }
00367
00368 template <typename T>
00369 inline bool Vector3<T>::operator != (const Vector3<T>& vector) const
00370 {
00371 return x != vector.x || y != vector.y || z != vector.z;
00372 }
00373
00374 template <typename T>
00375 inline void Vector3<T>::set(T sx, T sy, T sz)
00376 {
00377 x = sx;
00378 y = sy;
00379 z = sz;
00380 }
00381
00382
00383
00384 inline ColorRGB::ColorRGB(void)
00385 {
00386 }
00387
00388 inline ColorRGB::ColorRGB(real64 sr, real64 sg, real64 sb):
00389 r(sr),
00390 g(sg),
00391 b(sb)
00392 {
00393 }
00394
00395 inline void ColorRGB::clamp(void)
00396 {
00397 if (r > 1.f)
00398 r = 1.f;
00399 else if (r < 0.f)
00400 r = 0.f;
00401
00402 if (g > 1.f)
00403 g = 1.f;
00404 else if (g < 0.f)
00405 g = 0.f;
00406
00407 if (b > 1.f)
00408 b = 1.f;
00409 else if (b < 0.f)
00410 b = 0.f;
00411 }
00412
00413 inline ColorRGB ColorRGB::min(const ColorRGB& color) const
00414 {
00415 return ColorRGB(fminf(r, color.r), fminf(g, color.g), fminf(b, color.b));
00416 }
00417
00418 inline ColorRGB ColorRGB::max(const ColorRGB& color) const
00419 {
00420 return ColorRGB(fmaxf(r, color.r), fmaxf(g, color.g), fmaxf(b, color.b));
00421 }
00422
00423 inline ColorRGB::operator real64* (void)
00424 {
00425 return &(r);
00426 }
00427
00428 inline ColorRGB::operator const real64* (void) const
00429 {
00430 return &(r);
00431 }
00432
00433 inline ColorRGB ColorRGB::operator - (void) const
00434 {
00435 return ColorRGB(-r, -g, -b);
00436 }
00437
00438 inline ColorRGB ColorRGB::operator + (real64 value) const
00439 {
00440 return ColorRGB(r + value, g + value, b + value);
00441 }
00442
00443 inline ColorRGB ColorRGB::operator - (real64 value) const
00444 {
00445 return ColorRGB(r - value, g - value, b - value);
00446 }
00447
00448 inline ColorRGB ColorRGB::operator * (real64 value) const
00449 {
00450 return ColorRGB(r * value, g * value, b * value);
00451 }
00452
00453 inline ColorRGB ColorRGB::operator / (real64 value) const
00454 {
00455 return ColorRGB(r / value, g / value, b / value);
00456 }
00457
00458 inline ColorRGB ColorRGB::operator += (real64 value)
00459 {
00460 r += value;
00461 g += value;
00462 b += value;
00463 return *this;
00464 }
00465
00466 inline ColorRGB& ColorRGB::operator -= (real64 value)
00467 {
00468 r -= value;
00469 g -= value;
00470 b -= value;
00471 return *this;
00472 }
00473
00474 inline ColorRGB& ColorRGB::operator *= (real64 value)
00475 {
00476 r *= value;
00477 g *= value;
00478 b *= value;
00479 return *this;
00480 }
00481
00482 inline ColorRGB& ColorRGB::operator /= (real64 value)
00483 {
00484 r /= value;
00485 g /= value;
00486 b /= value;
00487 return *this;
00488 }
00489
00490 inline ColorRGB ColorRGB::operator + (const ColorRGB& color) const
00491 {
00492 return ColorRGB(r + color.r, g + color.g, b + color.b);
00493 }
00494
00495 inline ColorRGB ColorRGB::operator - (const ColorRGB& color) const
00496 {
00497 return ColorRGB(r - color.r, g - color.g, b - color.b);
00498 }
00499
00500 inline ColorRGB ColorRGB::operator * (const ColorRGB& color) const
00501 {
00502 return ColorRGB(r * color.r, g * color.g, b * color.b);
00503 }
00504
00505 inline ColorRGB ColorRGB::operator / (const ColorRGB& color) const
00506 {
00507 return ColorRGB(r / color.r, g / color.g, b / color.b);
00508 }
00509
00510 inline ColorRGB ColorRGB::operator += (const ColorRGB& color)
00511 {
00512 r += color.r;
00513 g += color.g;
00514 b += color.b;
00515 return *this;
00516 }
00517
00518 inline ColorRGB& ColorRGB::operator -= (const ColorRGB& color)
00519 {
00520 r -= color.r;
00521 g -= color.g;
00522 b -= color.b;
00523 return *this;
00524 }
00525
00526 inline ColorRGB& ColorRGB::operator *= (const ColorRGB& color)
00527 {
00528 r *= color.r;
00529 g *= color.g;
00530 b *= color.b;
00531 return *this;
00532 }
00533
00534 inline ColorRGB& ColorRGB::operator /= (const ColorRGB& color)
00535 {
00536 r /= color.r;
00537 g /= color.g;
00538 b /= color.b;
00539 return *this;
00540 }
00541
00542 inline bool ColorRGB::operator == (const ColorRGB& color) const
00543 {
00544 return r == color.r && g == color.g && b == color.b;
00545 }
00546
00547 inline bool ColorRGB::operator != (const ColorRGB& color) const
00548 {
00549 return r != color.r || g != color.g || b != color.b;
00550 }
00551
00552 inline real64 ColorRGB::getLength(void) const
00553 {
00554 return r * r + g * g + b * b;
00555 }
00556
00557 inline real64 ColorRGB::getSquaredLength(void) const
00558 {
00559 return sqrtf(r * r + g * g + b * b);
00560 }
00561
00562 inline void ColorRGB::setDefaults(void)
00563 {
00564 r = 0.f;
00565 g = 0.f;
00566 b = 0.f;
00567 }
00568
00569 inline void ColorRGB::set(real64 sr, real64 sg, real64 sb)
00570 {
00571 r = sr;
00572 g = sg;
00573 b = sb;
00574 }
00575
00576
00577
00578 }
00579 }
00580
00582 #endif