binaries/data/mods/public/globalscripts/vector.js

   1 /////////////////////////////////////////////////////////////////////
   2 //      Vector2D
   3 //
   4 //      Class for representing and manipulating 2D vectors
   5 //
   6 /////////////////////////////////////////////////////////////////////
   7
   8 // TODO: Type errors if v not instanceof Vector classes
   9 // TODO: Possibly implement in C++
  10
  11 function Vector2D(x, y)
  12 {
  13         if (arguments.length == 2)
  14                 this.set(x, y);
  15         else
  16                 this.set(0, 0);
  17 }
  18
  19 Vector2D.prototype.clone = function()
  20 {
  21         return new Vector2D(this.x, this.y);
  22 };
  23
  24 // Mutating 2D functions
  25 //
  26 // These functions modify the current object,
  27 // and always return this object to allow chaining
  28
  29 Vector2D.prototype.set = function(x, y)
  30 {
  31         this.x = x;
  32         this.y = y;
  33         return this;
  34 };
  35
  36 Vector2D.prototype.add = function(v)
  37 {
  38         this.x += v.x;
  39         this.y += v.y;
  40         return this;
  41 };
  42
  43 Vector2D.prototype.sub = function(v)
  44 {
  45         this.x -= v.x;
  46         this.y -= v.y;
  47         return this;
  48 };
  49
  50 Vector2D.prototype.mult = function(f)
  51 {
  52         this.x *= f;
  53         this.y *= f;
  54         return this;
  55 };
  56
  57 Vector2D.prototype.div = function(f)
  58 {
  59         this.x /= f;
  60         this.y /= f;
  61         return this;
  62 };
  63
  64 Vector2D.prototype.normalize = function()
  65 {
  66         let magnitude = this.length();
  67         if (!magnitude)
  68                 return this;
  69
  70         return this.div(magnitude);
  71 };
  72
  73 /**
  74  * Rotate a radians anti-clockwise
  75  */
  76 Vector2D.prototype.rotate = function(a)
  77 {
  78         let sin = Math.sin(a);
  79         let cos = Math.cos(a);
  80
  81         let x = this.x * cos + this.y * sin;
  82         let y = this.y * cos - this.x * sin;
  83
  84         this.x = x;
  85         this.y = y;
  86
  87         return this;
  88 };
  89
  90 // Numeric 2D info functions (non-mutating)
  91 //
  92 // These methods serve to get numeric info on the vector, they don't modify the vector
  93
  94 /**
  95  * Return the vector that forms a right angle with this one.
  96  */
  97 Vector2D.prototype.perpendicular = function()
  98 {
  99         return new Vector2D(-this.y, this.x);
 100 };
 101
 102 /**
 103  * Computes the scalar product of the two vectors.
 104  * Geometrically, this is the product of the length of the two vectors and the cosine of the angle between them.
 105  * If the vectors are orthogonal, the product is zero.
 106  */
 107 Vector2D.prototype.dot = function(v)
 108 {
 109         return this.x * v.x + this.y * v.y;
 110 };
 111
 112 /**
 113  * Computes the non-zero coordinate of the cross product of the two vectors.
 114  * Geometrically, the cross of the vectors is the 3D vector perpendicular to the two 2D vectors.
 115  * This returned length of that vector equals the area of the parallelogram that the vectors span.
 116  */
 117 Vector2D.prototype.cross = function(v)
 118 {
 119         return this.x * v.y - this.y * v.x;
 120 };
 121
 122 Vector2D.prototype.lengthSquared = function()
 123 {
 124         return this.dot(this);
 125 };
 126
 127 Vector2D.prototype.length = function()
 128 {
 129         return Math.sqrt(this.lengthSquared());
 130 };
 131
 132 /**
 133  * Compare this length to the length of v,
 134  * @return 0 if the lengths are equal
 135  * @return 1 if this is longer than v
 136  * @return -1 if this is shorter than v
 137  * @return NaN if the vectors aren't comparable
 138  */
 139 Vector2D.prototype.compareLength = function(v)
 140 {
 141         return Math.sign(this.lengthSquared() - v.lengthSquared());
 142 };
 143
 144 Vector2D.prototype.distanceToSquared = function(v)
 145 {
 146         return Math.euclidDistance2DSquared(this.x, this.y, v.x, v.y);
 147 };
 148
 149 Vector2D.prototype.distanceTo = function(v)
 150 {
 151         return Math.euclidDistance2D(this.x, this.y, v.x, v.y);
 152 };
 153
 154 // Static 2D functions
 155 //
 156 // Static functions that return a new vector object.
 157 // Note that object creation is slow in JS, so use them only when necessary
 158
 159 Vector2D.from3D = function(v)
 160 {
 161         return new Vector2D(v.x, v.z);
 162 };
 163
 164 Vector2D.add = function(v1, v2)
 165 {
 166         return new Vector2D(v1.x + v2.x, v1.y + v2.y);
 167 };
 168
 169 Vector2D.sub = function(v1, v2)
 170 {
 171         return new Vector2D(v1.x - v2.x, v1.y - v2.y);
 172 };
 173
 174 Vector2D.mult = function(v, f)
 175 {
 176         return new Vector2D(v.x * f, v.y * f);
 177 };
 178
 179 Vector2D.div = function(v, f)
 180 {
 181         return new Vector2D(v.x / f, v.y / f);
 182 };
 183
 184 Vector2D.avg = function(vectorList)
 185 {
 186         return Vector2D.sum(vectorList).div(vectorList.length);
 187 };
 188
 189 Vector2D.sum = function(vectorList)
 190 {
 191         var sum = new Vector2D();
 192         vectorList.forEach(v => sum.add(v));
 193         return sum;
 194 };
 195
 196 /////////////////////////////////////////////////////////////////////
 197 //      Vector3D
 198 //
 199 //      Class for representing and manipulating 3D vectors
 200 //
 201 /////////////////////////////////////////////////////////////////////
 202
 203 function Vector3D(x, y, z)
 204 {
 205         if (arguments.length == 3)
 206                 this.set(x, y, z);
 207         else
 208                 this.set(0, 0, 0);
 209 }
 210
 211 Vector3D.prototype.clone = function()
 212 {
 213         return new Vector3D(this.x, this.y, this.z);
 214 };
 215
 216 // Mutating 3D functions
 217 //
 218 // These functions modify the current object,
 219 // and always return this object to allow chaining
 220
 221 Vector3D.prototype.set = function(x, y, z)
 222 {
 223         this.x = x;
 224         this.y = y;
 225         this.z = z;
 226         return this;
 227 };
 228
 229 Vector3D.prototype.add = function(v)
 230 {
 231         this.x += v.x;
 232         this.y += v.y;
 233         this.z += v.z;
 234         return this;
 235 };
 236
 237 Vector3D.prototype.sub = function(v)
 238 {
 239         this.x -= v.x;
 240         this.y -= v.y;
 241         this.z -= v.z;
 242         return this;
 243 };
 244
 245 Vector3D.prototype.mult = function(f)
 246 {
 247         this.x *= f;
 248         this.y *= f;
 249         this.z *= f;
 250         return this;
 251 };
 252
 253 Vector3D.prototype.div = function(f)
 254 {
 255         this.x /= f;
 256         this.y /= f;
 257         this.z /= f;
 258         return this;
 259 };
 260
 261 Vector3D.prototype.normalize = function()
 262 {
 263         let magnitude = this.length();
 264         if (!magnitude)
 265                 return this;
 266
 267         return this.div(magnitude);
 268 };
 269
 270 // Numeric 3D info functions (non-mutating)
 271 //
 272 // These methods serve to get numeric info on the vector, they don't modify the vector
 273
 274 Vector3D.prototype.dot = function(v)
 275 {
 276         return this.x * v.x + this.y * v.y + this.z * v.z;
 277 };
 278
 279 /**
 280  * Returns a vector perpendicular to the two given vectors.
 281  * The length of the returned vector corresponds to the area of the parallelogram with the vectors for sides.
 282  */
 283 Vector3D.prototype.cross = function(v)
 284 {
 285         return new Vector3D(
 286                 this.y * v.z - this.z * v.y,
 287                 this.z * v.x - this.x * v.z,
 288                 this.x * v.y - this.y * v.x);
 289 };
 290
 291 Vector3D.prototype.lengthSquared = function()
 292 {
 293         return this.dot(this);
 294 };
 295
 296 Vector3D.prototype.length = function()
 297 {
 298         return Math.sqrt(this.lengthSquared());
 299 };
 300
 301 /**
 302  * Compare this length to the length of v,
 303  * @return 0 if the lengths are equal
 304  * @return 1 if this is longer than v
 305  * @return -1 if this is shorter than v
 306  * @return NaN if the vectors aren't comparable
 307  */
 308 Vector3D.prototype.compareLength = function(v)
 309 {
 310         return Math.sign(this.lengthSquared() - v.lengthSquared());
 311 };
 312
 313 Vector3D.prototype.distanceToSquared = function(v)
 314 {
 315         return Math.euclidDistance3DSquared(this.x, this.y, this.z, v.x, v.y, v.z);
 316 };
 317
 318 Vector3D.prototype.distanceTo = function(v)
 319 {
 320         return Math.euclidDistance3D(this.x, this.y, this.z, v.x, v.y, v.z);
 321 };
 322
 323 Vector3D.prototype.horizDistanceToSquared = function(v)
 324 {
 325         return Math.euclidDistance2DSquared(this.x, this.z, v.x, v.z);
 326 };
 327
 328 Vector3D.prototype.horizDistanceTo = function(v)
 329 {
 330         return Math.sqrt(this.horizDistanceToSquared(v));
 331 };
 332
 333 // Static 3D functions
 334 //
 335 // Static functions that return a new vector object.
 336 // Note that object creation is slow in JS, so use them only when really necessary
 337
 338 Vector3D.add = function(v1, v2)
 339 {
 340         return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 341 };
 342
 343 Vector3D.sub = function(v1, v2)
 344 {
 345         return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 346 };
 347
 348 Vector3D.mult = function(v, f)
 349 {
 350         return new Vector3D(v.x * f, v.y * f, v.z * f);
 351 };
 352
 353 Vector3D.div = function(v, f)
 354 {
 355         return new Vector3D(v.x / f, v.y / f, v.z / f);
 356 };
 357
 358
 359 // make the prototypes easily accessible to C++
 360 const Vector2Dprototype = Vector2D.prototype;
 361 const Vector3Dprototype = Vector3D.prototype;