[80]  1  /********************************************************************** <BR>


 2  This file is part of Crack dot Com's free source code release of


 3  Golgotha. <a href="http://www.crack.com/golgotha_release"> <BR> for


 4  information about compiling & licensing issues visit this URL</a>


 5  <PRE> If that doesn't help, contact Jonathan Clark at


 6  golgotha_source@usa.net (Subject should have "GOLG" in it)


 7  ***********************************************************************/


 8 


 9  #ifndef __VECTOR_HPP_


 10  #define __VECTOR_HPP_


 11 


 12  #include "math/num_type.hh"


 13  #include <math.h>


 14 


 15  #ifdef _WINDOWS


 16  //#define G1_WIN32_VECTOR_ASM


 17  #endif


 18 


 19 


 20  template <class Coord>


 21  class i4_vector3_template


 22  {


 23  public:


 24  Coord x,y,z;


 25 


 26  Coord& operator()(int pos) const { return ((Coord*)&x)[pos]; }


 27  Coord& operator[](int pos) const { return ((Coord*)&x)[pos]; }


 28 


 29  i4_vector3_template() {}


 30  i4_vector3_template(const i4_vector3_template& p) : x(p.x), y(p.y), z(p.z) {}


 31  i4_vector3_template(Coord _x,Coord _y,Coord _z) : x(_x),y(_y),z(_z) {}


 32  i4_vector3_template& set(Coord px,Coord py,Coord pz)


 33  {


 34  x = px;


 35  y = py;


 36  z = pz;


 37 


 38  return *this;


 39  }


 40  i4_vector3_template& operator=(const i4_vector3_template& p)


 41  {


 42  x = p.x;


 43  y = p.y;


 44  z = p.z;


 45 


 46  return *this;


 47  }


 48 


 49  i4_vector3_template& operator+=(const i4_vector3_template& b)


 50  {


 51  x += b.x;


 52  y += b.y;


 53  z += b.z;


 54 


 55  return *this;


 56  }


 57  i4_vector3_template& operator=(const i4_vector3_template& b)


 58  {


 59  x = b.x;


 60  y = b.y;


 61  z = b.z;


 62 


 63  return *this;


 64  }


 65 


 66  i4_vector3_template& operator*=(Coord b)


 67  {


 68  x *= b;


 69  y *= b;


 70  z *= b;


 71 


 72  return *this;


 73  }


 74 


 75  i4_vector3_template operator*(Coord b)


 76  {


 77  i4_vector3_template tmp;


 78  tmp.x = x * b;


 79  tmp.y = y * b;


 80  tmp.z = z * b;


 81 


 82  return tmp;


 83  }


 84 


 85 


 86  i4_vector3_template operator+(Coord b)


 87  {


 88  i4_vector3_template tmp;


 89  tmp.x = x + b;


 90  tmp.y = y + b;


 91  tmp.z = z + b;


 92 


 93  return tmp;


 94  }


 95 


 96  i4_vector3_template operator+(i4_vector3_template v)


 97  {


 98  i4_vector3_template tmp;


 99  tmp.x = x + v.x;


 100  tmp.y = y + v.y;


 101  tmp.z = z + v.z;


 102 


 103  return tmp;


 104  }


 105 


 106  i4_vector3_template operator*(i4_vector3_template v)


 107  {


 108  i4_vector3_template tmp;


 109  tmp.x = x * v.x;


 110  tmp.y = y * v.y;


 111  tmp.z = z * v.z;


 112 


 113  return tmp;


 114  }


 115 


 116  i4_vector3_template& operator/=(Coord b)


 117  {


 118  x /= b;


 119  y /= b;


 120  z /= b;


 121 


 122  return *this;


 123  }


 124 


 125  i4_vector3_template& interpolate(const i4_vector3_template& from, const i4_vector3_template& to,


 126  i4_float ratio)


 127  {


 128  x = i4_interpolate(from.x,to.x,ratio);


 129  y = i4_interpolate(from.y,to.y,ratio);


 130  z = i4_interpolate(from.z,to.z,ratio);


 131  return *this;


 132  }


 133 


 134  Coord length() const


 135  {


 136  return (Coord)sqrt(dot(*this));


 137  }


 138  void normalize()


 139  {


 140  *this /= length();


 141  }


 142 


 143  i4_vector3_template& reverse()


 144  {


 145  x=x; y=y; z=z;


 146 


 147  return *this;


 148  }


 149 


 150  Coord dot(const i4_vector3_template& b) const


 151  {


 152  #ifdef G1_WIN32_VECTOR_ASM


 153  i4_float dotret;


 154  _asm


 155  {


 156  mov ecx, b


 157  mov eax, this


 158 


 159  ;optimized dot product; 15 cycles


 160  fld dword ptr [eax+0] ;starts & ends on cycle 0


 161  fmul dword ptr [ecx+0] ;starts on cycle 1


 162  fld dword ptr [eax+4] ;starts & ends on cycle 2


 163  fmul dword ptr [ecx+4] ;starts on cycle 3


 164  fld dword ptr [eax+8] ;starts & ends on cycle 4


 165  fmul dword ptr [ecx+8] ;starts on cycle 5


 166  fxch st(1) ;no cost


 167  faddp st(2),st(0) ;starts on cycle 6, stalls for cycles 78


 168  faddp st(1),st(0) ;starts on cycle 9, stalls for cycles 1012


 169  fstp dword ptr [dotret] ;starts on cycle 13, ends on cycle 14


 170  }


 171  return dotret;


 172  #else


 173  return x*b.x + y*b.y + z*b.z;


 174  #endif


 175  }


 176 


 177  i4_vector3_template& cross(const i4_vector3_template& a,


 178  const i4_vector3_template& b)


 179  {


 180  #ifdef UNFINISHED_WINDOWS


 181  _asm


 182  {


 183  mov eax,this


 184  mov ecx,a


 185  mov edx,b


 186 


 187  ;optimized cross product; 22 cycles


 188  fld dword ptr [ecx+4] ;starts & ends on cycle 0


 189  fmul dword ptr [edx+8] ;starts on cycle 1


 190  fld dword ptr [ecx+8] ;starts & ends on cycle 2


 191  fmul dword ptr [edx+0] ;starts on cycle 3


 192  fld dword ptr [ecx+0] ;starts & ends on cycle 4


 193  fmul dword ptr [edx+4] ;starts on cycle 5


 194  fld dword ptr [ecx+8] ;starts & ends on cycle 6


 195  fmul dword ptr [edx+4] ;starts on cycle 7


 196  fld dword ptr [ecx+0] ;starts & ends on cycle 8


 197  fmul dword ptr [edx+8] ;starts on cycle 9


 198  fld dword ptr [ecx+4] ;starts & ends on cycle 10


 199  fmul dword ptr [edx+0] ;starts on cycle 11


 200  fxch st(2) ;no cost


 201  fsubrp st(5),st(0) ;starts on cycle 12


 202  fsubrp st(3),st(0) ;starts on cycle 13


 203  fsubrp st(1),st(0) ;starts on cycle 14


 204  fxch st(2) ;no cost, stalls for cycle 15


 205  fstp dword ptr [eax+0] ;starts on cycle 16, ends on cycle 17


 206  fstp dword ptr [eax+4] ;starts on cycle 18, ends on cycle 19


 207  fstp dword ptr [eax+8] ;starts on cycle 20, ends on cycle 21


 208  }


 209  #else


 210  x = a.y*b.z  a.z*b.y;


 211  y = a.z*b.x  a.x*b.z;


 212  z = a.x*b.y  a.y*b.x;


 213  #endif


 214  return *this;


 215  }


 216  };


 217 


 218 


 219  class i4_2d_vector


 220  {


 221  public:


 222  i4_float x,y;


 223 


 224  i4_2d_vector() { ; }


 225 


 226  i4_2d_vector(i4_float x, i4_float y) : x(x), y(y) {}


 227 


 228  i4_float length() const { return sqrt(x*x+y*y); }


 229  i4_float dot(const i4_2d_vector &b) { return x*b.x + y*b.y; }


 230  i4_float perp_dot(const i4_2d_vector &b) { return x*b.yy*b.x; }


 231 


 232  i4_2d_vector& operator=(const i4_2d_vector& b) { x=b.x; y=b.y; return *this; }


 233  i4_2d_vector& operator+=(const i4_2d_vector& b) { x+=b.x; y+=b.y; return *this; }


 234  i4_2d_vector& operator*=(const i4_2d_vector& b) { x*=b.x; y*=b.y; return *this; }


 235  i4_2d_vector& operator/=(const i4_2d_vector& b) { x/=b.x; y/=b.y; return *this; }


 236 


 237  i4_2d_vector operator+(const i4_2d_vector& b) { return i4_2d_vector(x+b.x, y+b.y); }


 238  i4_2d_vector operator(const i4_2d_vector& b) { return i4_2d_vector(xb.x, yb.y); }


 239  i4_2d_vector operator*(const i4_2d_vector& b) { return i4_2d_vector(x*b.x, y*b.y); }


 240  i4_2d_vector operator/(const i4_2d_vector& b) { return i4_2d_vector(x*b.x, y*b.y); }


 241 


 242  void normalize()


 243  {


 244  i4_float ool=1.0/length();


 245  x*=ool;


 246  y*=ool;


 247  }


 248  };


 249 


 250 


 251  typedef i4_vector3_template<i4_float> i4_3d_vector;


 252 


 253  #endif


 254 


 255 

