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 = 0, y = 0)
  12 {
  13         this.set(x, y);
  14 }
  15
  16 Vector2D.prototype.clone = function()
  17 {
  18         return new Vector2D(this.x, this.y);
  19 };
  20
  21 // Mutating 2D functions
  22 //
  23 // These functions modify the current object,
  24 // and always return this object to allow chaining
  25
  26 Vector2D.prototype.set = function(x, y)
  27 {
  28         this.x = x;
  29         this.y = y;
  30         return this;
  31 };
  32
  33 Vector2D.prototype.setFrom = function(v)
  34 {
  35         this.x = v.x;
  36         this.y = v.y;
  37         return this;
  38 };
  39
  40 Vector2D.prototype.add = function(v)
  41 {
  42         this.x += v.x;
  43         this.y += v.y;
  44         return this;
  45 };
  46
  47 Vector2D.prototype.sub = function(v)
  48 {
  49         this.x -= v.x;
  50         this.y -= v.y;
  51         return this;
  52 };
  53
  54 Vector2D.prototype.mult = function(f)
  55 {
  56         this.x *= f;
  57         this.y *= f;
  58         return this;
  59 };
  60
  61 Vector2D.prototype.div = function(f)
  62 {
  63         this.x /= f;
  64         this.y /= f;
  65         return this;
  66 };
  67
  68 Vector2D.prototype.normalize = function()
  69 {
  70         let magnitude = this.length();
  71         if (!magnitude)
  72                 return this;
  73
  74         return this.div(magnitude);
  75 };
  76
  77 /**
  78  * Rotate a radians anti-clockwise
  79  */
  80 Vector2D.prototype.rotate = function(angle)
  81 {
  82         let sin = Math.sin(angle);
  83         let cos = Math.cos(angle);
  84
  85         return this.set(
  86                 this.x * cos + this.y * sin,
  87                 -this.x * sin + this.y * cos);
  88 };
  89
  90 /**
  91  * Rotate radians anti-clockwise around the specified rotation center.
  92  */
  93 Vector2D.prototype.rotateAround = function(angle, center)
  94 {
  95         return this.sub(center).rotate(angle).add(center);
  96 };
  97
  98 /**
  99  * Convert to integer coordinates.
 100  */
 101 Vector2D.prototype.round = function()
 102 {
 103         return this.set(Math.round(this.x), Math.round(this.y));
 104 };
 105
 106 Vector2D.prototype.floor = function()
 107 {
 108         return this.set(Math.floor(this.x), Math.floor(this.y));
 109 };
 110
 111 Vector2D.prototype.toFixed = function(digits)
 112 {
 113         return this.set(this.x.toFixed(digits), this.y.toFixed(digits));
 114 };
 115
 116 // Numeric 2D info functions (non-mutating)
 117 //
 118 // These methods serve to get numeric info on the vector, they don't modify the vector
 119
 120 /**
 121  * Returns a vector that forms a right angle with this one.
 122  */
 123 Vector2D.prototype.perpendicular = function()
 124 {
 125         return new Vector2D(-this.y, this.x);
 126 };
 127
 128 /**
 129  * Computes the scalar product of the two vectors.
 130  * Geometrically, this is the product of the length of the two vectors and the cosine of the angle between them.
 131  * If the vectors are orthogonal, the product is zero.
 132  */
 133 Vector2D.prototype.dot = function(v)
 134 {
 135         return this.x * v.x + this.y * v.y;
 136 };
 137
 138 /**
 139  * Computes the non-zero coordinate of the cross product of the two vectors.
 140  * Geometrically, the cross of the vectors is a 3D vector perpendicular to the two 2D vectors.
 141  * The returned number corresponds to the area of the parallelogram with the vectors for sides.
 142  */
 143 Vector2D.prototype.cross = function(v)
 144 {
 145         return this.x * v.y - this.y * v.x;
 146 };
 147
 148 Vector2D.prototype.lengthSquared = function()
 149 {
 150         return this.dot(this);
 151 };
 152
 153 Vector2D.prototype.length = function()
 154 {
 155         return Math.sqrt(this.lengthSquared());
 156 };
 157
 158 /**
 159  * Compare this length to the length of v.
 160  * @return 0 if the lengths are equal
 161  * @return 1 if this is longer than v
 162  * @return -1 if this is shorter than v
 163  * @return NaN if the vectors aren't comparable
 164  */
 165 Vector2D.prototype.compareLength = function(v)
 166 {
 167         return Math.sign(this.lengthSquared() - v.lengthSquared());
 168 };
 169
 170 Vector2D.prototype.distanceToSquared = function(v)
 171 {
 172         return Math.euclidDistance2DSquared(this.x, this.y, v.x, v.y);
 173 };
 174
 175 Vector2D.prototype.distanceTo = function(v)
 176 {
 177         return Math.euclidDistance2D(this.x, this.y, v.x, v.y);
 178 };
 179
 180 /**
 181  * Returns the angle going from this position to v.
 182  * Angles are between -PI and PI. E.g., north is 0, east is PI/2.
 183  */
 184 Vector2D.prototype.angleTo = function(v)
 185 {
 186         return Math.atan2(v.x - this.x, v.y - this.y);
 187 };
 188
 189 // Static 2D functions
 190 //
 191 // Static functions that return a new vector object.
 192 // Note that object creation is slow in JS, so use them only when necessary
 193
 194 Vector2D.from3D = function(v)
 195 {
 196         return new Vector2D(v.x, v.z);
 197 };
 198
 199 Vector2D.add = function(v1, v2)
 200 {
 201         return new Vector2D(v1.x + v2.x, v1.y + v2.y);
 202 };
 203
 204 Vector2D.sub = function(v1, v2)
 205 {
 206         return new Vector2D(v1.x - v2.x, v1.y - v2.y);
 207 };
 208
 209 Vector2D.isEqualTo = function(v1, v2)
 210 {
 211         return v1.x == v2.x && v1.y == v2.y;
 212 };
 213
 214 Vector2D.mult = function(v, f)
 215 {
 216         return new Vector2D(v.x * f, v.y * f);
 217 };
 218
 219 Vector2D.div = function(v, f)
 220 {
 221         return new Vector2D(v.x / f, v.y / f);
 222 };
 223
 224 Vector2D.min = function(v1, v2)
 225 {
 226         return new Vector2D(Math.min(v1.x, v2.x), Math.min(v1.y, v2.y));
 227 };
 228
 229 Vector2D.max = function(v1, v2)
 230 {
 231         return new Vector2D(Math.max(v1.x, v2.x), Math.max(v1.y, v2.y));
 232 };
 233
 234 Vector2D.average = function(vectorList)
 235 {
 236         return Vector2D.sum(vectorList).div(vectorList.length);
 237 };
 238
 239 Vector2D.sum = function(vectorList)
 240 {
 241         // Do not use for...of nor array functions for performance
 242         let sum = new Vector2D();
 243
 244         for (let i = 0; i < vectorList.length; ++i)
 245                 sum.add(vectorList[i]);
 246
 247         return sum;
 248 };
 249
 250 Vector2D.dot = function(v1, v2)
 251 {
 252         return v1.x * v2.x + v1.y * v2.y;
 253 };
 254
 255 /////////////////////////////////////////////////////////////////////
 256 //      Vector3D
 257 //
 258 //      Class for representing and manipulating 3D vectors
 259 //
 260 /////////////////////////////////////////////////////////////////////
 261
 262 function Vector3D(x = 0, y = 0, z = 0)
 263 {
 264         this.set(x, y, z);
 265 }
 266
 267 Vector3D.prototype.clone = function()
 268 {
 269         return new Vector3D(this.x, this.y, this.z);
 270 };
 271
 272 // Mutating 3D functions
 273 //
 274 // These functions modify the current object,
 275 // and always return this object to allow chaining
 276
 277 Vector3D.prototype.set = function(x, y, z)
 278 {
 279         this.x = x;
 280         this.y = y;
 281         this.z = z;
 282         return this;
 283 };
 284
 285 Vector3D.prototype.add = function(v)
 286 {
 287         this.x += v.x;
 288         this.y += v.y;
 289         this.z += v.z;
 290         return this;
 291 };
 292
 293 Vector3D.prototype.sub = function(v)
 294 {
 295         this.x -= v.x;
 296         this.y -= v.y;
 297         this.z -= v.z;
 298         return this;
 299 };
 300
 301 Vector3D.prototype.mult = function(f)
 302 {
 303         this.x *= f;
 304         this.y *= f;
 305         this.z *= f;
 306         return this;
 307 };
 308
 309 Vector3D.prototype.div = function(f)
 310 {
 311         this.x /= f;
 312         this.y /= f;
 313         this.z /= f;
 314         return this;
 315 };
 316
 317 Vector3D.prototype.normalize = function()
 318 {
 319         let magnitude = this.length();
 320         if (!magnitude)
 321                 return this;
 322
 323         return this.div(magnitude);
 324 };
 325
 326 /**
 327  * Convert to integer coordinates.
 328  */
 329 Vector3D.prototype.round = function()
 330 {
 331         return this.set(Math.round(this.x), Math.round(this.y), Math.round(this.z));
 332 };
 333
 334 Vector3D.prototype.floor = function()
 335 {
 336         return this.set(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z));
 337 };
 338
 339 Vector3D.prototype.toFixed = function(digits)
 340 {
 341         return this.set(this.x.toFixed(digits), this.y.toFixed(digits), this.z.toFixed(digits));
 342 };
 343
 344 // Numeric 3D info functions (non-mutating)
 345 //
 346 // These methods serve to get numeric info on the vector, they don't modify the vector
 347
 348 Vector3D.prototype.dot = function(v)
 349 {
 350         return this.x * v.x + this.y * v.y + this.z * v.z;
 351 };
 352
 353 /**
 354  * Returns a vector perpendicular to the two given vectors.
 355  * The length of the returned vector corresponds to the area of the parallelogram with the vectors for sides.
 356  */
 357 Vector3D.prototype.cross = function(v)
 358 {
 359         return new Vector3D(
 360                 this.y * v.z - this.z * v.y,
 361                 this.z * v.x - this.x * v.z,
 362                 this.x * v.y - this.y * v.x);
 363 };
 364
 365 Vector3D.prototype.lengthSquared = function()
 366 {
 367         return this.dot(this);
 368 };
 369
 370 Vector3D.prototype.length = function()
 371 {
 372         return Math.sqrt(this.lengthSquared());
 373 };
 374
 375 /**
 376  * Compare this length to the length of v,
 377  * @return 0 if the lengths are equal
 378  * @return 1 if this is longer than v
 379  * @return -1 if this is shorter than v
 380  * @return NaN if the vectors aren't comparable
 381  */
 382 Vector3D.prototype.compareLength = function(v)
 383 {
 384         return Math.sign(this.lengthSquared() - v.lengthSquared());
 385 };
 386
 387 Vector3D.prototype.distanceToSquared = function(v)
 388 {
 389         return Math.euclidDistance3DSquared(this.x, this.y, this.z, v.x, v.y, v.z);
 390 };
 391
 392 Vector3D.prototype.distanceTo = function(v)
 393 {
 394         return Math.euclidDistance3D(this.x, this.y, this.z, v.x, v.y, v.z);
 395 };
 396
 397 Vector3D.prototype.horizDistanceToSquared = function(v)
 398 {
 399         return Math.euclidDistance2DSquared(this.x, this.z, v.x, v.z);
 400 };
 401
 402 Vector3D.prototype.horizDistanceTo = function(v)
 403 {
 404         return Math.sqrt(this.horizDistanceToSquared(v));
 405 };
 406
 407 /**
 408  * Returns the angle going from this position to v.
 409  */
 410 Vector3D.prototype.horizAngleTo = function(v)
 411 {
 412         return Math.atan2(v.x - this.x, v.z - this.z);
 413 };
 414
 415 // Static 3D functions
 416 //
 417 // Static functions that return a new vector object.
 418 // Note that object creation is slow in JS, so use them only when really necessary
 419
 420 Vector3D.add = function(v1, v2)
 421 {
 422         return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 423 };
 424
 425 Vector3D.sub = function(v1, v2)
 426 {
 427         return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 428 };
 429
 430 Vector3D.isEqualTo = function(v1, v2)
 431 {
 432         return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;
 433 };
 434
 435 Vector3D.mult = function(v, f)
 436 {
 437         return new Vector3D(v.x * f, v.y * f, v.z * f);
 438 };
 439
 440 Vector3D.div = function(v, f)
 441 {
 442         return new Vector3D(v.x / f, v.y / f, v.z / f);
 443 };