home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / include / k3d / k3dsdk / vector4.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-16  |  5.7 KB  |  247 lines
  1. #ifndef K3DSDK_VECTOR4_H
  2. #define K3DSDK_VECTOR4_H
  3.  
  4. // K-3D
  5. // Copyright (c) 1995-2008, Timothy M. Shead
  6. //
  7. // Contact: tshead@k-3d.com
  8. //
  9. // This library is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. //
  14. // This library is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. // General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public
  20. // License along with this library; if not, write to the Free Software
  21. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  
  23. /** \file
  24.     \author Timothy M. Shead (tshead@k-3d.com)
  25. */
  26.  
  27. /****************************************************************
  28. *
  29. * C++ Vector and Matrix Algebra routines
  30. * Author: Jean-Francois DOUE
  31. * Version 3.1 --- October 1993
  32. *
  33. ****************************************************************/
  34.  
  35. //
  36. //    From "Graphics Gems IV / Edited by Paul S. Heckbert
  37. //    Academic Press, 1994, ISBN 0-12-336156-9
  38. //    "You are free to use and modify this code in any way
  39. //    you like." (p. xv)
  40. //
  41. //    Modified by J. Nagle, March 1997
  42. //    -    All functions are inline.
  43. //    -    All functions are const-correct.
  44. //    -    All checking is via the standard "assert" macro.
  45. //
  46.  
  47. // Modified by Tim Shead for use with K-3D, January 1998
  48.  
  49. #include "almost_equal.h"
  50. #include "result.h"
  51.  
  52. #include <boost/io/ios_state.hpp>
  53.  
  54. #include <cmath>
  55. #include <iomanip>
  56.  
  57. namespace k3d
  58. {
  59.  
  60. /////////////////////////////////////////////////////////////////////////////
  61. // vector4
  62.  
  63. /// Encapsulates a direction vector in four-dimensional space
  64. class vector4
  65. {
  66. public:
  67.     /// Stores the vector values
  68.     double_t n[4];
  69.  
  70.     vector4()
  71.     {
  72.         n[0] = n[1] = n[2] = n[3] = 0.0;
  73.     }
  74.  
  75.     vector4(const double_t x, const double_t y, const double_t z, const double_t w)
  76.     {
  77.         n[0] = x;
  78.         n[1] = y;
  79.         n[2] = z;
  80.         n[3] = w;
  81.     }
  82.  
  83.     vector4& operator+=(const vector4& v)
  84.     {
  85.         n[0] += v.n[0];
  86.         n[1] += v.n[1];
  87.         n[2] += v.n[2];
  88.         n[3] += v.n[3];
  89.         return *this;
  90.     }
  91.  
  92.     vector4& operator-=(const vector4& v)
  93.     {
  94.         n[0] -= v.n[0];
  95.         n[1] -= v.n[1];
  96.         n[2] -= v.n[2];
  97.         n[3] -= v.n[3];
  98.         return *this;
  99.     }
  100.  
  101.     vector4& operator*=(const double_t d)
  102.     {
  103.         n[0] *= d;
  104.         n[1] *= d;
  105.         n[2] *= d;
  106.         n[3] *= d;
  107.         return *this;
  108.     }
  109.  
  110.     vector4& operator/=(const double_t d)
  111.     {
  112.         return_val_if_fail(d, *this);
  113.  
  114.         const double_t d_inv = 1.0 / d;
  115.         n[0] *= d_inv;
  116.         n[1] *= d_inv;
  117.         n[2] *= d_inv;
  118.         n[3] *= d_inv;
  119.         return *this;
  120.     }
  121.  
  122.     double_t& operator[](const unsigned int i)
  123.     {
  124.         return n[i];
  125.     }
  126.  
  127.     double_t operator[](const unsigned int i) const
  128.     {
  129.         return n[i];
  130.     }
  131.  
  132.     /// Returns the normal length
  133.     double_t length() const
  134.     {
  135.         return std::sqrt(length2());
  136.     }
  137.  
  138.     /// Returns the squared normal length
  139.     double_t length2() const
  140.     {
  141.         return n[0] * n[0] + n[1] * n[1] + n[2] * n[2] + n[3] * n[3];
  142.     }
  143.  
  144.     friend std::ostream& operator<<(std::ostream& Stream, const vector4& Value)
  145.     {
  146.         boost::io::ios_flags_saver stream_state(Stream);
  147.         Stream << std::setprecision(17) << Value.n[0] << " " << Value.n[1] << " " << Value.n[2] << " " << Value.n[3];
  148.         return Stream;
  149.     }
  150.  
  151.     friend std::istream& operator>>(std::istream& Stream, vector4& Value)
  152.     {
  153.         Stream >> Value.n[0] >> Value.n[1] >> Value.n[2] >> Value.n[3];
  154.         return Stream;
  155.     }
  156. };
  157.  
  158. /// Negation
  159. inline const vector4 operator-(const vector4& v)
  160. {
  161.     return vector4(-v.n[0], -v.n[1], -v.n[2], -v.n[3]);
  162. }
  163.  
  164. /// Addition
  165. inline const vector4 operator+(const vector4& a, const vector4& b)
  166. {
  167.     return vector4(a.n[0] + b.n[0], a.n[1] + b.n[1], a.n[2] + b.n[2], a.n[3] + b.n[3]);
  168. }
  169.  
  170. /// Subtraction
  171. inline const vector4 operator-(const vector4& a, const vector4& b)
  172. {
  173.     return vector4(a.n[0] - b.n[0], a.n[1] - b.n[1], a.n[2] - b.n[2], a.n[3] - b.n[3]);
  174. }
  175.  
  176. /// Multiplication by a constant
  177. inline const vector4 operator*(const vector4& a, const double_t d)
  178. {
  179.     return vector4(a.n[0] * d, a.n[1] * d, a.n[2] * d, a.n[3] * d);
  180. }
  181.  
  182. /// Multiplication by a constant
  183. inline const vector4 operator*(const double_t d, const vector4& a)
  184. {
  185.     return vector4(a.n[0] * d, a.n[1] * d, a.n[2] * d, a.n[3] * d);
  186. }
  187.  
  188. /// Returns the dot product of two vectors
  189. inline const double_t operator*(const vector4& a, const vector4& b)
  190. {
  191.     return a.n[0] * b.n[0] + a.n[1] * b.n[1] + a.n[2] * b.n[2] + a.n[3] * b.n[3];
  192. }
  193.  
  194. /// Division by a constant
  195. inline const vector4 operator/(const vector4& a, const double_t d)
  196. {
  197.     return_val_if_fail(d, vector4());
  198.     return vector4(a.n[0] / d, a.n[1] / d, a.n[2] / d, a.n[3] / d);
  199. }
  200.  
  201. /// Equality
  202. inline const bool operator==(const vector4& a, const vector4& b)
  203. {
  204.     return a.n[0] == b.n[0] && a.n[1] == b.n[1] && a.n[2] == b.n[2] && a.n[3] == b.n[3];
  205. }
  206.  
  207. /// Inequality
  208. inline const bool operator!=(const vector4& a, const vector4& b)
  209. {
  210.     return a.n[0] != b.n[0] || a.n[1] != b.n[1] || a.n[2] != b.n[2] || a.n[3] != b.n[3];
  211. }
  212.  
  213. /// Returns the length of a vector
  214. inline const double_t length(const vector4& Vector)
  215. {
  216.     return Vector.length();
  217. }
  218.  
  219. /// Returns the normalized form of a vector
  220. inline const vector4 normalize(const vector4& Vector)
  221. {
  222.     const double_t length = Vector.length();
  223.     return_val_if_fail(length, Vector);
  224.     return Vector / length;
  225. }
  226.  
  227. /// Specialization of almost_equal that tests two vector4 objects for near-equality
  228. template<>
  229. class almost_equal<vector4>
  230. {
  231.     typedef vector4 T;
  232. public:
  233.     almost_equal(const boost::uint64_t Threshold) : threshold(Threshold) { }
  234.     inline const bool operator()(const T& A, const T& B) const
  235.     {
  236.         return std::equal(A.n, A.n + 4, B.n, almost_equal<double_t>(threshold));
  237.     }
  238.  
  239. private:
  240.     const boost::uint64_t threshold;
  241. };
  242.  
  243. } // namespace k3d
  244.  
  245. #endif // !K3DSDK_VECTOR4_H
  246.  
  247.