home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 3 / RISC_DISC_3.iso / resources / etexts / gems / gemsiii / luminaire / utility.h < prev   
C/C++ Source or Header  |  1992-03-20  |  4KB  |  187 lines
  1. // ******************************************************************
  2. //
  3. // Physically Correct Direct Lighting For Distribution Ray Tracing
  4. //             by Changyaw Wang
  5. //
  6. // utility.h
  7. //
  8. // ******************************************************************
  9.  
  10. #include <math.h>
  11. #include <stream.h>
  12.  
  13. class point;
  14. class vector;
  15. class rotation_matrix;
  16.  
  17. class point {
  18. public:
  19.     double data[3];
  20.     point();
  21.     point(double, double, double);
  22.     point& operator=(const point&);
  23. };
  24.  
  25. class vector {
  26. public:
  27.     double data[3];
  28.     vector();
  29.     vector(double,double,double);
  30.     vector& operator=(const vector&);
  31.     void normalize();
  32.     friend vector operator*(double, const vector&);
  33. };
  34.  
  35. class rotation_matrix {
  36. protected:
  37.     double data[4][4];
  38. public:
  39.     void set_identity();
  40.     void set_xyz_to_uvw(const vector&, const vector&, const vector&);
  41.     friend vector operator*(const rotation_matrix&, const vector&);
  42. };
  43.  
  44. inline point::point() {}
  45.  
  46. inline vector::vector() {}
  47.  
  48. inline point& point::operator=(const point& v)
  49. {
  50.    data[0] = v.data[0];
  51.    data[1] = v.data[1];
  52.    data[2] = v.data[2];
  53.    return *this;
  54. }
  55.  
  56. inline point::point(double a, double b, double c)
  57. {
  58.    data[0] = a; data[1] = b; data[2] = c;
  59.  }
  60.  
  61. inline vector::vector(double a, double b, double c)
  62. {
  63.    data[0] = a; data[1] = b; data[2] = c;
  64. }
  65.  
  66. inline vector& vector::operator=(const vector& v)
  67. {
  68.    data[0] = v.data[0];
  69.    data[1] = v.data[1];
  70.    data[2] = v.data[2];
  71.    return *this;
  72. }
  73.  
  74. inline vector operator*(double d, const vector& v)
  75. {
  76.    return vector(d * v.data[0], 
  77.          d * v.data[1],
  78.          d * v.data[2] );
  79.  }
  80.  
  81. inline void vector::normalize()
  82. {
  83.     double length;
  84.  
  85.     length = sqrt(data[0]*data[0] + data[1]*data[1] + data[2]*data[2]);
  86.     if (length <= 1.0e-6)
  87.     {
  88.         data[0] = 1.0; data[1] = 0.0; data[2] = 0.0;
  89.     }
  90.     else
  91.     {
  92.         length = 1.0 / length;
  93.         data[0] *= length; data[1] *= length; data[2] *= length;
  94.     }
  95. }
  96.  
  97. inline void rotation_matrix::set_identity()
  98. {
  99.     data[0][0] = data[1][1] = data[2][2] = data[3][3] = 1.0;
  100.     data[0][1] = data[0][2] = data[0][3] = 0.0;
  101.     data[1][0] = data[1][2] = data[1][3] = 0.0;
  102.     data[2][0] = data[2][1] = data[2][3] = 0.0;
  103.     data[3][0] = data[3][1] = data[3][2] = 0.0;
  104. }
  105.  
  106. void rotation_matrix::set_xyz_to_uvw(const vector& u, const vector& v,
  107.                                      const vector& w)
  108. {
  109.       this->set_identity();
  110.       data[0][0] = u.data[0];
  111.       data[1][0] = u.data[1];
  112.       data[2][0] = u.data[2];
  113.  
  114.       data[0][1] = v.data[0];
  115.       data[1][1] = v.data[1];
  116.       data[2][1] = v.data[2];
  117.  
  118.  
  119.       data[0][2] = w.data[0];
  120.       data[1][2] = w.data[1];
  121.       data[2][2] = w.data[2];
  122. }
  123.  
  124. inline point operator+(const point& p, const vector& v)
  125. {
  126.     return  point(p.data[0] + v.data[0], p.data[1] + v.data[1], 
  127.           p.data[2] + v.data[2]);
  128. }
  129.  
  130. inline vector operator*(const rotation_matrix& r, const vector& v)
  131. {
  132.   return vector(r.data[0][0]*v.data[0] + r.data[0][1]*v.data[1] +
  133.                    r.data[0][2]*v.data[2] + r.data[0][3],
  134.                 r.data[1][0]*v.data[0] + r.data[1][1]*v.data[1] +
  135.                    r.data[1][2]*v.data[2] + r.data[1][3],
  136.                 r.data[2][0]*v.data[0] + r.data[2][1]*v.data[1] +
  137.                    r.data[2][2]*v.data[2] + r.data[2][3]);
  138. }
  139.  
  140. inline vector operator-(const point& u, const point& v)
  141. {
  142.     return vector(u.data[0]-v.data[0], u.data[1]-v.data[1], 
  143.           u.data[2]-v.data[2]);
  144. }
  145.  
  146. inline double dot(const vector& a, const vector& b)
  147. {
  148.    return ( a.data[0]*b.data[0] + a.data[1]*b.data[1] + 
  149.        a.data[2] * b.data[2] );
  150. }
  151.  
  152. inline double distance_squared(const point& a, const point& b)
  153. {
  154.    double x,y,z;
  155.    x = a.data[0] - b.data[0];
  156.    y = a.data[1] - b.data[1];
  157.    z = a.data[2] - b.data[2];
  158.    return x*x + y*y + z*z;
  159. }
  160.  
  161. inline double distance(const point& a, const point& b)
  162. {
  163.    double t;
  164.    t = distance_squared(a,b);
  165.    return sqrt(t);
  166. }
  167.  
  168. inline vector spherical_to_vector(double theta, double phi)
  169. {
  170.     return vector(sin(theta)*cos(phi),
  171.                   sin(theta)*sin(phi),
  172.                   cos(theta));
  173. }
  174.  
  175. inline vector cross(const vector& a, const vector &b)
  176. {
  177.     return vector(a.data[1]*b.data[2] - a.data[2]*b.data[1],
  178.                   a.data[2]*b.data[0] - a.data[0]*b.data[2],
  179.                   a.data[0]*b.data[1] - a.data[1]*b.data[0]);
  180.  
  181. }
  182.  
  183. #include "geometry_object.h"
  184. #include "sphere_luminaire.h"
  185. #include "triangle_luminaire.h"
  186.  
  187.