src/vec.h

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** vec.h                        **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 #ifndef VEC_H
   8 #define VEC_H
   9
  10 /**
  11  * Virtual integer coordinate.
  12  *
  13  * x and y are the same as a physical integer coordinate.
  14  * z is a virtual layer depth within an Area.
  15  */
  16 struct vicoord
  17 {
  18         vicoord() {}
  19         vicoord(int x, int y, double z): x(x), y(y), z(z) {}
  20
  21         int x, y;
  22         double z;
  23 };
  24
  25 struct icube {
  26         icube(int x1, int y1, int z1, int x2, int y2, int z2)
  27                 : x1(x1), y1(y1), z1(z1), x2(x2), y2(y2), z2(z2) {}
  28
  29         int x1, y1, z1;
  30         int x2, y2, z2;
  31 };
  32
  33 template<class T>
  34 class vec2
  35 {
  36 public:
  37         T x, y;
  38
  39         vec2()
  40         {
  41         }
  42
  43         vec2(const vec2<T>& other)
  44                 : x(other.x), y(other.y)
  45         {
  46         }
  47
  48         vec2(T x, T y)
  49                 : x(x), y(y)
  50         {
  51         }
  52
  53         vec2<T>& operator +=(const vec2<T>& other)
  54         {
  55                 x += other.x;
  56                 y += other.y;
  57                 return *this;
  58         }
  59
  60         vec2<T>& operator -=(const vec2<T>& other)
  61         {
  62                 x -= other.x;
  63                 y -= other.y;
  64                 return *this;
  65         }
  66
  67         vec2<T>& operator *=(const vec2<T>& other)
  68         {
  69                 x *= other.x;
  70                 y *= other.y;
  71                 return *this;
  72         }
  73
  74         vec2<T>& operator *=(T coefficient)
  75         {
  76                 x *= coefficient;
  77                 y *= coefficient;
  78                 return *this;
  79         }
  80
  81         vec2<T>& operator /=(const vec2<T>& other)
  82         {
  83                 x /= other.x;
  84                 y /= other.y;
  85                 return *this;
  86         }
  87
  88         vec2<T>& operator /=(T coefficient)
  89         {
  90                 x /= coefficient;
  91                 y /= coefficient;
  92                 return *this;
  93         }
  94
  95         operator bool()
  96         {
  97                 return x || y;
  98         }
  99 };
 100
 101
 102 template<class T>
 103 class vec3
 104 {
 105 public:
 106         T x, y, z;
 107
 108         vec3()
 109         {
 110         }
 111
 112         vec3(const vec3<T>& other)
 113                 : x(other.x), y(other.y), z(other.z)
 114         {
 115         }
 116
 117         vec3(T x, T y, T z)
 118                 : x(x), y(y), z(z)
 119         {
 120         }
 121
 122         vec3<T>& operator +=(const vec3<T>& other)
 123         {
 124                 x += other.x;
 125                 y += other.y;
 126                 z += other.z;
 127                 return *this;
 128         }
 129
 130         vec3<T>& operator -=(const vec3<T>& other)
 131         {
 132                 x -= other.x;
 133                 y -= other.y;
 134                 z -= other.z;
 135                 return *this;
 136         }
 137
 138         vec3<T>& operator *=(const vec3<T>& other)
 139         {
 140                 x *= other.x;
 141                 y *= other.y;
 142                 z *= other.z;
 143                 return *this;
 144         }
 145
 146         vec3<T>& operator *=(T coefficient)
 147         {
 148                 x *= coefficient;
 149                 y *= coefficient;
 150                 z *= coefficient;
 151                 return *this;
 152         }
 153
 154         vec3<T>& operator /=(const vec3<T>& other)
 155         {
 156                 x /= other.x;
 157                 y /= other.y;
 158                 z /= other.z;
 159                 return *this;
 160         }
 161
 162         vec3<T>& operator /=(T coefficient)
 163         {
 164                 x /= coefficient;
 165                 y /= coefficient;
 166                 z /= coefficient;
 167                 return *this;
 168         }
 169
 170         operator bool()
 171         {
 172                 return x || y || z;
 173         }
 174 };
 175
 176 template<class T>
 177 vec2<T> operator+(const vec2<T>& a, const vec2<T>& b)
 178 {
 179         vec2<T> c;
 180         c.x = a.x + b.x;
 181         c.y = a.y + b.y;
 182         return c;
 183 }
 184
 185 template<class T>
 186 vec3<T> operator+(const vec3<T>& a, const vec3<T>& b)
 187 {
 188         vec3<T> c;
 189         c.x = a.x + b.x;
 190         c.y = a.y + b.y;
 191         c.z = a.z + b.z;
 192         return c;
 193 }
 194
 195 template<class T>
 196 vec2<T> operator-(const vec2<T>& a, const vec2<T>& b)
 197 {
 198         vec2<T> c;
 199         c.x = a.x - b.x;
 200         c.y = a.y - b.y;
 201         return c;
 202 }
 203
 204 template<class T>
 205 vec3<T> operator-(const vec3<T>& a, const vec3<T>& b)
 206 {
 207         vec3<T> c;
 208         c.x = a.x - b.x;
 209         c.y = a.y - b.y;
 210         c.z = a.z - b.z;
 211         return c;
 212 }
 213
 214 template<class T>
 215 vec2<T> operator*(const vec2<T>& a, const vec2<T>& b)
 216 {
 217         vec2<T> c;
 218         c.x = a.x * b.x;
 219         c.y = a.y * b.y;
 220         return c;
 221 }
 222
 223 template<class T>
 224 vec3<T> operator*(const vec3<T>& a, const vec3<T>& b)
 225 {
 226         vec3<T> c;
 227         c.x = a.x * b.x;
 228         c.y = a.y * b.y;
 229         c.z = a.z * b.z;
 230         return c;
 231 }
 232
 233 template<class T, class CO>
 234 vec2<T> operator*(const vec2<T>& a, CO co)
 235 {
 236         vec2<T> c;
 237         c.x = a.x * (T)co;
 238         c.y = a.y * (T)co;
 239         return c;
 240 }
 241
 242 template<class T, class CO>
 243 vec3<T> operator*(const vec3<T>& a, CO co)
 244 {
 245         vec3<T> c;
 246         c.x = a.x * (T)co;
 247         c.y = a.y * (T)co;
 248         c.z = a.z * (T)co;
 249         return c;
 250 }
 251
 252 template<class T, class CO>
 253 vec2<T> operator*(CO co, const vec2<T>& a)
 254 {
 255         return a * co;
 256 }
 257
 258 template<class T, class CO>
 259 vec3<T> operator*(CO co, const vec3<T>& a)
 260 {
 261         return a * co;
 262 }
 263
 264 template<class T>
 265 vec2<T> operator/(const vec2<T>& a, const vec2<T>& b)
 266 {
 267         vec2<T> c;
 268         c.x = a.x / b.x;
 269         c.y = a.y / b.y;
 270         return c;
 271 }
 272
 273 template<class T>
 274 vec3<T> operator/(const vec3<T>& a, const vec3<T>& b)
 275 {
 276         vec3<T> c;
 277         c.x = a.x / b.x;
 278         c.y = a.y / b.y;
 279         c.z = a.z / b.z;
 280         return c;
 281 }
 282
 283 template<class T, class CO>
 284 vec2<T> operator/(const vec2<T>& a, CO co)
 285 {
 286         vec2<T> c;
 287         c.x = a.x / (T)co;
 288         c.y = a.y / (T)co;
 289         return c;
 290 }
 291
 292 template<class T, class CO>
 293 vec3<T> operator/(const vec3<T>& a, CO co)
 294 {
 295         vec3<T> c;
 296         c.x = a.x / (T)co;
 297         c.y = a.y / (T)co;
 298         c.z = a.z / (T)co;
 299         return c;
 300 }
 301
 302 template<class T, class CO>
 303 vec2<T> operator/(CO co, const vec2<T>& a)
 304 {
 305         vec2<T> c;
 306         c.x = (T)co / a.x;
 307         c.y = (T)co / a.y;
 308         return c;
 309 }
 310
 311 template<class T, class CO>
 312 vec3<T> operator/(CO co, const vec3<T>& a)
 313 {
 314         vec3<T> c;
 315         c.x = (T)co / a.x;
 316         c.y = (T)co / a.y;
 317         c.z = (T)co / a.z;
 318         return c;
 319 }
 320
 321 template<class T>
 322 bool operator==(const vec2<T>& a, const vec2<T>& b)
 323 {
 324         return a.x == b.x && a.y == b.y;
 325 }
 326
 327 template<class T>
 328 bool operator==(const vec3<T>& a, const vec3<T>& b)
 329 {
 330         return a.x == b.x && a.y == b.y && a.z == b.z;
 331 }
 332
 333 //! Integer vector.
 334 typedef vec2<int> ivec2;
 335 typedef vec3<int> ivec3;
 336
 337 //! Real vector.
 338 typedef vec2<double> rvec2;
 339 typedef vec3<double> rvec3;
 340
 341 //! Coordinates.
 342 typedef ivec3 icoord;
 343 typedef rvec3 rcoord;
 344
 345
 346 void exportVecs();
 347
 348 #endif
 349