00001 /*
00002 File: Vec3.h
00003
00004 Function: Defines a length-3 vector.
00005
00006 Author(s): Andrew Willmott
00007
00008 Copyright: (c) 1995-2000, Andrew Willmott
00009 */
00010
00011 #ifndef __Vec3__
00012 #define __Vec3__
00013
00014 #include "vl/VL.h"
00015 // Defines the actual type for TVec3 etc.
00016
00017
00018 // --- Vec3 Class -------------------------------------------------------------
00019
00020
00021 class TVec2;
00022
00023 class TVec3
00024 {
00025 public:
00026
00027 // Constructors
00028
00029 inline TVec3();
00030 inline TVec3(TVReal x, TVReal y, TVReal z);// [x, y, z]
00031 inline TVec3(const TVec3 &v); // Copy constructor
00032 inline TVec3(const TVec2 &v, TVReal w); // Hom. 2D vector
00033 inline TVec3(ZeroOrOne k);
00034 inline TVec3(Axis a);
00035
00036 // Accessor functions
00037
00038 inline Int Elts() const { return(3); };
00039
00040 inline TVReal &operator [] (Int i);
00041 inline const TVReal &operator [] (Int i) const;
00042
00043 inline TVReal *Ref() const;
00044 // Return pointer to data
00045
00046 // Assignment operators
00047
00048 inline TVec3 &operator = (const TVec3 &a);
00049 inline TVec3 &operator = (ZeroOrOne k);
00050 inline TVec3 &operator += (const TVec3 &a);
00051 inline TVec3 &operator -= (const TVec3 &a);
00052 inline TVec3 &operator *= (const TVec3 &a);
00053 inline TVec3 &operator *= (TVReal s);
00054 inline TVec3 &operator /= (const TVec3 &a);
00055 inline TVec3 &operator /= (TVReal s);
00056
00057 // Comparison operators
00058
00059 inline Bool operator == (const TVec3 &a) const; // v == a?
00060 inline Bool operator != (const TVec3 &a) const; // v != a?
00061 inline Bool operator < (const TVec3 &a) const; // v < a?
00062 inline Bool operator >= (const TVec3 &a) const; // v >= a?
00063
00064 // Arithmetic operators
00065
00066 inline TVec3 operator + (const TVec3 &a) const; // v + a
00067 inline TVec3 operator - (const TVec3 &a) const; // v - a
00068 inline TVec3 operator - () const; // -v
00069 inline TVec3 operator * (const TVec3 &a) const; // v * a (vx * ax, ...)
00070 inline TVec3 operator * (TVReal s) const; // v * s
00071 inline TVec3 operator / (const TVec3 &a) const; // v / a (vx / ax, ...)
00072 inline TVec3 operator / (TVReal s) const; // v / s
00073
00074 // Initialisers
00075
00076 inline TVec3 &MakeZero(); // Zero vector
00077 inline TVec3 &MakeUnit(Int i, TVReal k = vl_one);// I[i]
00078 inline TVec3 &MakeBlock(TVReal k = vl_one); // All-k vector
00079
00080 inline TVec3 &Normalise(); // normalise vector
00081
00082 // Private...
00083
00084 protected:
00085
00086 TVReal elt[3];
00087 };
00088
00089
00090 // --- Vec operators ----------------------------------------------------------
00091
00092 inline TVec3 operator * (TVReal s, const TVec3 &v);// s * v
00093 inline TVReal dot(const TVec3 &a, const TVec3 &b);// v . a
00094 inline TVReal len(const TVec3 &v); // || v ||
00095 inline TVReal sqrlen(const TVec3 &v); // v . v
00096 inline TVec3 norm(const TVec3 &v); // v / || v ||
00097 inline Void normalise(TVec3 &v); // v = norm(v)
00098 inline TVec3 cross(const TVec3 &a, const TVec3 &b);// a x b
00099 inline TVec2 proj(const TVec3 &v); // hom. projection
00100
00101 ostream &operator << (ostream &s, const TVec3 &v);
00102 istream &operator >> (istream &s, TVec3 &v);
00103
00104
00105 // --- Inlines ----------------------------------------------------------------
00106
00107 #include "vl/Vec2.h"
00108
00109 inline TVReal &TVec3::operator [] (Int i)
00110 {
00111 CheckRange(i, 0, 3, "(Vec3::[i]) index out of range");
00112 return(elt[i]);
00113 }
00114
00115 inline const TVReal &TVec3::operator [] (Int i) const
00116 {
00117 CheckRange(i, 0, 3, "(Vec3::[i]) index out of range");
00118 return(elt[i]);
00119 }
00120
00121 inline TVec3::TVec3()
00122 {
00123 }
00124
00125 inline TVec3::TVec3(TVReal x, TVReal y, TVReal z)
00126 {
00127 elt[0] = x;
00128 elt[1] = y;
00129 elt[2] = z;
00130 }
00131
00132 inline TVec3::TVec3(const TVec3 &v)
00133 {
00134 elt[0] = v[0];
00135 elt[1] = v[1];
00136 elt[2] = v[2];
00137 }
00138
00139 inline TVec3::TVec3(const TVec2 &v, TVReal w)
00140 {
00141 elt[0] = v[0];
00142 elt[1] = v[1];
00143 elt[2] = w;
00144 }
00145
00146 inline TVReal *TVec3::Ref() const
00147 {
00148 return((TVReal *) elt);
00149 }
00150
00151 inline TVec3 &TVec3::operator = (const TVec3 &v)
00152 {
00153 elt[0] = v[0];
00154 elt[1] = v[1];
00155 elt[2] = v[2];
00156
00157 return(SELF);
00158 }
00159
00160 inline TVec3 &TVec3::operator += (const TVec3 &v)
00161 {
00162 elt[0] += v[0];
00163 elt[1] += v[1];
00164 elt[2] += v[2];
00165
00166 return(SELF);
00167 }
00168
00169 inline TVec3 &TVec3::operator -= (const TVec3 &v)
00170 {
00171 elt[0] -= v[0];
00172 elt[1] -= v[1];
00173 elt[2] -= v[2];
00174
00175 return(SELF);
00176 }
00177
00178 inline TVec3 &TVec3::operator *= (const TVec3 &a)
00179 {
00180 elt[0] *= a[0];
00181 elt[1] *= a[1];
00182 elt[2] *= a[2];
00183
00184 return(SELF);
00185 }
00186
00187 inline TVec3 &TVec3::operator *= (TVReal s)
00188 {
00189 elt[0] *= s;
00190 elt[1] *= s;
00191 elt[2] *= s;
00192
00193 return(SELF);
00194 }
00195
00196 inline TVec3 &TVec3::operator /= (const TVec3 &a)
00197 {
00198 elt[0] /= a[0];
00199 elt[1] /= a[1];
00200 elt[2] /= a[2];
00201
00202 return(SELF);
00203 }
00204
00205 inline TVec3 &TVec3::operator /= (TVReal s)
00206 {
00207 elt[0] /= s;
00208 elt[1] /= s;
00209 elt[2] /= s;
00210
00211 return(SELF);
00212 }
00213
00214 inline TVec3 TVec3::operator + (const TVec3 &a) const
00215 {
00216 TVec3 result;
00217
00218 result[0] = elt[0] + a[0];
00219 result[1] = elt[1] + a[1];
00220 result[2] = elt[2] + a[2];
00221
00222 return(result);
00223 }
00224
00225 inline TVec3 TVec3::operator - (const TVec3 &a) const
00226 {
00227 TVec3 result;
00228
00229 result[0] = elt[0] - a[0];
00230 result[1] = elt[1] - a[1];
00231 result[2] = elt[2] - a[2];
00232
00233 return(result);
00234 }
00235
00236 inline TVec3 TVec3::operator - () const
00237 {
00238 TVec3 result;
00239
00240 result[0] = -elt[0];
00241 result[1] = -elt[1];
00242 result[2] = -elt[2];
00243
00244 return(result);
00245 }
00246
00247 inline TVec3 TVec3::operator * (const TVec3 &a) const
00248 {
00249 TVec3 result;
00250
00251 result[0] = elt[0] * a[0];
00252 result[1] = elt[1] * a[1];
00253 result[2] = elt[2] * a[2];
00254
00255 return(result);
00256 }
00257
00258 inline TVec3 TVec3::operator * (TVReal s) const
00259 {
00260 TVec3 result;
00261
00262 result[0] = elt[0] * s;
00263 result[1] = elt[1] * s;
00264 result[2] = elt[2] * s;
00265
00266 return(result);
00267 }
00268
00269 inline TVec3 TVec3::operator / (const TVec3 &a) const
00270 {
00271 TVec3 result;
00272
00273 result[0] = elt[0] / a[0];
00274 result[1] = elt[1] / a[1];
00275 result[2] = elt[2] / a[2];
00276
00277 return(result);
00278 }
00279
00280 inline TVec3 TVec3::operator / (TVReal s) const
00281 {
00282 TVec3 result;
00283
00284 result[0] = elt[0] / s;
00285 result[1] = elt[1] / s;
00286 result[2] = elt[2] / s;
00287
00288 return(result);
00289 }
00290
00291 inline TVec3 operator * (TVReal s, const TVec3 &v)
00292 {
00293 return(v * s);
00294 }
00295
00296 inline TVec3 &TVec3::MakeUnit(Int n, TVReal k)
00297 {
00298 if (n == 0)
00299 { elt[0] = k; elt[1] = vl_zero; elt[2] = vl_zero; }
00300 else if (n == 1)
00301 { elt[0] = vl_zero; elt[1] = k; elt[2] = vl_zero; }
00302 else if (n == 2)
00303 { elt[0] = vl_zero; elt[1] = vl_zero; elt[2] = k; }
00304 else
00305 _Error("(Vec3::Unit) illegal unit vector");
00306 return(SELF);
00307 }
00308
00309 inline TVec3 &TVec3::MakeZero()
00310 {
00311 elt[0] = vl_zero; elt[1] = vl_zero; elt[2] = vl_zero;
00312 return(SELF);
00313 }
00314
00315 inline TVec3 &TVec3::MakeBlock(TVReal k)
00316 {
00317 elt[0] = k; elt[1] = k; elt[2] = k;
00318 return(SELF);
00319 }
00320
00321 inline TVec3 &TVec3::Normalise()
00322 {
00323 Assert(sqrlen(SELF) > 0.0, "normalising length-zero vector");
00324 SELF /= len(SELF);
00325 return(SELF);
00326 }
00327
00328
00329 inline TVec3::TVec3(ZeroOrOne k)
00330 {
00331 elt[0] = k; elt[1] = k; elt[2] = k;
00332 }
00333
00334 inline TVec3 &TVec3::operator = (ZeroOrOne k)
00335 {
00336 elt[0] = k; elt[1] = k; elt[2] = k;
00337
00338 return(SELF);
00339 }
00340
00341 inline TVec3::TVec3(Axis a)
00342 {
00343 MakeUnit(a, vl_one);
00344 }
00345
00346
00347 inline Bool TVec3::operator == (const TVec3 &a) const
00348 {
00349 return(elt[0] == a[0] && elt[1] == a[1] && elt[2] == a[2]);
00350 }
00351
00352 inline Bool TVec3::operator != (const TVec3 &a) const
00353 {
00354 return(elt[0] != a[0] || elt[1] != a[1] || elt[2] != a[2]);
00355 }
00356
00357 inline Bool TVec3::operator < (const TVec3 &a) const
00358 {
00359 return(elt[0] < a[0] && elt[1] < a[1] && elt[2] < a[2]);
00360 }
00361
00362 inline Bool TVec3::operator >= (const TVec3 &a) const
00363 {
00364 return(elt[0] >= a[0] && elt[1] >= a[1] && elt[2] >= a[2]);
00365 }
00366
00367
00368 inline TVReal dot(const TVec3 &a, const TVec3 &b)
00369 {
00370 return(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
00371 }
00372
00373 inline TVReal len(const TVec3 &v)
00374 {
00375 return(sqrt(dot(v, v)));
00376 }
00377
00378 inline TVReal sqrlen(const TVec3 &v)
00379 {
00380 return(dot(v, v));
00381 }
00382
00383 inline TVec3 norm(const TVec3 &v)
00384 {
00385 Assert(sqrlen(v) > 0.0, "normalising length-zero vector");
00386 return(v / len(v));
00387 }
00388
00389 inline Void normalise(TVec3 &v)
00390 {
00391 v /= len(v);
00392 }
00393
00394 inline TVec3 cross(const TVec3 &a, const TVec3 &b)
00395 {
00396 TVec3 result;
00397
00398 result[0] = a[1] * b[2] - a[2] * b[1];
00399 result[1] = a[2] * b[0] - a[0] * b[2];
00400 result[2] = a[0] * b[1] - a[1] * b[0];
00401
00402 return(result);
00403 }
00404
00405 inline TVec2 proj(const TVec3 &v)
00406 {
00407 TVec2 result;
00408
00409 Assert(v[2] != 0, "(Vec3/proj) last elt. is zero");
00410
00411 result[0] = v[0] / v[2];
00412 result[1] = v[1] / v[2];
00413
00414 return(result);
00415 }
00416
00417 #endif
