Game

- Updating ball moves

site/real_game/class/Map.js

@@ -6,7 +6,7 @@
 /*   By: hubourge <hubourge@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/08/20 14:52:55 by hubourge          #+#    #+#             */
-/*   Updated: 2024/08/20 16:34:25 by hubourge         ###   ########.fr       */
+/*   Updated: 2024/08/20 17:24:15 by hubourge         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -18,15 +18,21 @@ class Map
 {
 	scene = null;
 	arrObject = [];
+	centerPos = {x:-1,y:-1,z:-1}
 
 	constructor(scene, length)
 	{
 		this.scene = scene;
-		scene.add(this.#createPlanes(7.5, length, -(Math.PI / 2), "plane1"));
+		scene.add(this.#createPlanes(7.5, length, -(Math.PI / 2), "planeBottom", true));
-		// scene.add(this.#createWalls(0, 0, 0, "wallLeft"));
+		scene.add(this.#createPlanes(7.5, length, (Math.PI / 2), "planeTop", false));
+		scene.add(this.#createWall(-3.5, 0.15, -length/2, "wallLeft"));
+		scene.add(this.#createWall(3.5, 0.15, -length/2, "wallRight"));
+		this.centerPos.x = 0;
+		this.centerPos.y = 0.15;
+		this.centerPos.z = -length/2;
 	};
 
-	#createPlanes(x, y, rot, name) // passer un materiel
+	#createPlanes(x, y, rot, name, isBottom) // passer un materiel
 	{
 		for (let i = 0; i < this.arrObject.length; i++)
 		{
@@ -38,21 +44,30 @@ class Map
 		const mesh		= new THREE.Mesh(geometry, material);
 
 		mesh.rotateX(rot);
+		if (isBottom)
 			mesh.position.set(0, 0.15, -6);
+		else
+			mesh.position.set(0, 3.05, -6);
 		this.arrObject.push({mesh: mesh, name: name});
+		mesh.receiveShadow = true;
 		return (mesh);
 	};
 
-	// #createWalls(x, y, z, name)
+	#createWall(x, y, z, name)
-	// {
+	{
-	// 	const geometry	= new THREE.BoxGeometry(20, 20, 20);
+		for (let i = 0; i < this.arrObject.length; i++)
-	// 	const material	= new THREE.MeshPhysicalMaterial();
+		{
-	// 	const mesh		= new THREE.Mesh(geometry, material);
+			if (this.arrObject[i].name == name)
+				throw Error("Name already exist.");
+		}
+		const geometry	= new THREE.BoxGeometry(0.05, 1, 1.25);
+		const material	= new THREE.MeshPhysicalMaterial();
+		const mesh		= new THREE.Mesh(geometry, material);
 
-	// 	mesh.position.set(x, y, z);
+		mesh.position.set(x, y, z);
-	// 	this.arrObject.push({mesh: mesh, name: name});
+		this.arrObject.push({mesh: mesh, name: name});
-	// 	return (mesh);
+		return (mesh);
-	// };
+	};
 };
 
 export { Map };

site/real_game/main.js

@@ -6,7 +6,7 @@
 /*   By: hubourge <hubourge@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/08/18 00:53:53 by edbernar          #+#    #+#             */
-/*   Updated: 2024/08/20 16:11:26 by hubourge         ###   ########.fr       */
+/*   Updated: 2024/08/20 17:28:36 by hubourge         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,6 +14,7 @@ import * as THREE from 'three';
 import { Player } from './class/Player'
 import { Map } from './class/Map'
 import { OrbitControls } from 'three/examples/jsm/Addons.js';
+import { update } from 'three/examples/jsm/libs/tween.module.js';
 
 function createBarPlayer(color)
 {
@@ -29,6 +30,9 @@ function loop()
 {
 	player.update();
 	renderer.render(scene, player.camera);
+	
+	// ===== test ball =====
+	updateBall();
 }
 
 function createMap()
@@ -50,6 +54,40 @@ const player		= new Player(bar);
 const spotLight		= new THREE.SpotLight(0xffffff, 10000, 0, Math.PI / 4);
 const ambiantLight	= new THREE.AmbientLight(0xffffff, 1);
 
+// ===== test ball =====
+const geometryBall = new THREE.SphereGeometry(0.15, 32, 32);
+const materialBall = new THREE.MeshPhysicalMaterial({color: 0xff0000});
+const ball = new THREE.Mesh(geometryBall, materialBall);
+ball.position.x = map.centerPos.x;
+ball.position.y = map.centerPos.y + 0.15;
+ball.position.z = map.centerPos.z;
+ball.receiveShadow = true;
+ball.castShadow = true;
+scene.add(ball);
+
+function updateBall()
+{
+	// pressedButton	= [];
+	let i 				= 0;
+	let interval		= null;
+	let speed			= 0.01;
+	const limits = {
+		up : 3,
+		down: 0.2,
+		left: -3,
+		right: 3,
+	}
+
+	document.addEventListener('keypress', (e) => {
+		if (e.key == '9')
+		{
+				ball.position.z += speed;
+				console.log(e.key);
+		}
+	});
+}
+// =====================
+
 scene.add(player.object);
 scene.add(ambiantLight);
 spotLight.position.set(0, 100, 0);

site/real_game/node_modules/.vite/deps/_metadata.json

@@ -2,33 +2,42 @@
   "hash": "fba7eca6",
   "configHash": "345fb419",
   "lockfileHash": "cd36b699",
-  "browserHash": "dfa6d36e",
+  "browserHash": "f591caa1",
   "optimized": {
     "three": {
       "src": "../../three/build/three.module.js",
       "file": "three.js",
-      "fileHash": "4b6b8fed",
+      "fileHash": "c6ea5bd8",
       "needsInterop": false
     },
     "three/examples/jsm/Addons.js": {
       "src": "../../three/examples/jsm/Addons.js",
       "file": "three_examples_jsm_Addons__js.js",
-      "fileHash": "4877cb36",
+      "fileHash": "1caa94cb",
       "needsInterop": false
     },
     "three/examples/jsm/controls/OrbitControls.js": {
       "src": "../../three/examples/jsm/controls/OrbitControls.js",
       "file": "three_examples_jsm_controls_OrbitControls__js.js",
-      "fileHash": "0cee644c",
+      "fileHash": "4512ee18",
+      "needsInterop": false
+    },
+    "three/examples/jsm/libs/tween.module.js": {
+      "src": "../../three/examples/jsm/libs/tween.module.js",
+      "file": "three_examples_jsm_libs_tween__module__js.js",
+      "fileHash": "c5283fd4",
       "needsInterop": false
     }
   },
   "chunks": {
-    "chunk-7WGWDPRB": {
+    "chunk-X4PC2K6Q": {
-      "file": "chunk-7WGWDPRB.js"
+      "file": "chunk-X4PC2K6Q.js"
     },
-    "chunk-33KXLYU5": {
+    "chunk-IS2ZBFBB": {
-      "file": "chunk-33KXLYU5.js"
+      "file": "chunk-IS2ZBFBB.js"
+    },
+    "chunk-PZ5AY32C": {
+      "file": "chunk-PZ5AY32C.js"
     }
   }
 }

site/real_game/node_modules/.vite/deps/chunk-IS2ZBFBB.js

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // node_modules/three/build/three.module.js
 var REVISION = "167";
 var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
@@ -30710,7 +30704,6 @@ if (typeof window !== "undefined") {
 }
 
 export {
-  __export,
   REVISION,
   MOUSE,
   TOUCH,
@@ -31139,4 +31132,4 @@ three/build/three.module.js:
    * SPDX-License-Identifier: MIT
    *)
 */
-//# sourceMappingURL=chunk-33KXLYU5.js.map
+//# sourceMappingURL=chunk-IS2ZBFBB.js.map

site/real_game/node_modules/.vite/deps/chunk-PZ5AY32C.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-PZ5AY32C.js.map

site/real_game/node_modules/.vite/deps/chunk-PZ5AY32C.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

site/real_game/node_modules/.vite/deps/chunk-X4PC2K6Q.js

@@ -9,7 +9,7 @@ import {
   TOUCH,
   Vector2,
   Vector3
-} from "./chunk-33KXLYU5.js";
+} from "./chunk-IS2ZBFBB.js";
 
 // node_modules/three/examples/jsm/controls/OrbitControls.js
 var _changeEvent = { type: "change" };
@@ -788,4 +788,4 @@ var OrbitControls = class extends EventDispatcher {
 export {
   OrbitControls
 };
-//# sourceMappingURL=chunk-7WGWDPRB.js.map
+//# sourceMappingURL=chunk-X4PC2K6Q.js.map

site/real_game/node_modules/.vite/deps/three.js

@@ -417,7 +417,8 @@ import {
   ZeroSlopeEnding,
   ZeroStencilOp,
   createCanvasElement
-} from "./chunk-33KXLYU5.js";
+} from "./chunk-IS2ZBFBB.js";
+import "./chunk-PZ5AY32C.js";
 export {
   ACESFilmicToneMapping,
   AddEquation,

site/real_game/node_modules/.vite/deps/three_examples_jsm_Addons__js.js

@@ -1,6 +1,6 @@
 import {
   OrbitControls
-} from "./chunk-7WGWDPRB.js";
+} from "./chunk-X4PC2K6Q.js";
 import {
   ACESFilmicToneMapping,
   AddEquation,
@@ -209,9 +209,11 @@ import {
   WebGLRenderTarget,
   WebGLRenderer,
   WireframeGeometry,
-  ZeroFactor,
+  ZeroFactor
+} from "./chunk-IS2ZBFBB.js";
+import {
   __export
-} from "./chunk-33KXLYU5.js";
+} from "./chunk-PZ5AY32C.js";
 
 // node_modules/three/examples/jsm/animation/AnimationClipCreator.js
 var AnimationClipCreator = class {

site/real_game/node_modules/.vite/deps/three_examples_jsm_controls_OrbitControls__js.js

@@ -1,7 +1,8 @@
 import {
   OrbitControls
-} from "./chunk-7WGWDPRB.js";
+} from "./chunk-X4PC2K6Q.js";
-import "./chunk-33KXLYU5.js";
+import "./chunk-IS2ZBFBB.js";
+import "./chunk-PZ5AY32C.js";
 export {
   OrbitControls
 };

site/real_game/node_modules/.vite/deps/three_examples_jsm_libs_tween__module__js.js

@@ -0,0 +1,836 @@
+import "./chunk-PZ5AY32C.js";
+
+// node_modules/three/examples/jsm/libs/tween.module.js
+var Easing = Object.freeze({
+  Linear: Object.freeze({
+    None: function(amount) {
+      return amount;
+    },
+    In: function(amount) {
+      return this.None(amount);
+    },
+    Out: function(amount) {
+      return this.None(amount);
+    },
+    InOut: function(amount) {
+      return this.None(amount);
+    }
+  }),
+  Quadratic: Object.freeze({
+    In: function(amount) {
+      return amount * amount;
+    },
+    Out: function(amount) {
+      return amount * (2 - amount);
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount;
+      }
+      return -0.5 * (--amount * (amount - 2) - 1);
+    }
+  }),
+  Cubic: Object.freeze({
+    In: function(amount) {
+      return amount * amount * amount;
+    },
+    Out: function(amount) {
+      return --amount * amount * amount + 1;
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount * amount;
+      }
+      return 0.5 * ((amount -= 2) * amount * amount + 2);
+    }
+  }),
+  Quartic: Object.freeze({
+    In: function(amount) {
+      return amount * amount * amount * amount;
+    },
+    Out: function(amount) {
+      return 1 - --amount * amount * amount * amount;
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount * amount * amount;
+      }
+      return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
+    }
+  }),
+  Quintic: Object.freeze({
+    In: function(amount) {
+      return amount * amount * amount * amount * amount;
+    },
+    Out: function(amount) {
+      return --amount * amount * amount * amount * amount + 1;
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount * amount * amount * amount;
+      }
+      return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
+    }
+  }),
+  Sinusoidal: Object.freeze({
+    In: function(amount) {
+      return 1 - Math.sin((1 - amount) * Math.PI / 2);
+    },
+    Out: function(amount) {
+      return Math.sin(amount * Math.PI / 2);
+    },
+    InOut: function(amount) {
+      return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
+    }
+  }),
+  Exponential: Object.freeze({
+    In: function(amount) {
+      return amount === 0 ? 0 : Math.pow(1024, amount - 1);
+    },
+    Out: function(amount) {
+      return amount === 1 ? 1 : 1 - Math.pow(2, -10 * amount);
+    },
+    InOut: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      if ((amount *= 2) < 1) {
+        return 0.5 * Math.pow(1024, amount - 1);
+      }
+      return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
+    }
+  }),
+  Circular: Object.freeze({
+    In: function(amount) {
+      return 1 - Math.sqrt(1 - amount * amount);
+    },
+    Out: function(amount) {
+      return Math.sqrt(1 - --amount * amount);
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return -0.5 * (Math.sqrt(1 - amount * amount) - 1);
+      }
+      return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
+    }
+  }),
+  Elastic: Object.freeze({
+    In: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      return -Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
+    },
+    Out: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      return Math.pow(2, -10 * amount) * Math.sin((amount - 0.1) * 5 * Math.PI) + 1;
+    },
+    InOut: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      amount *= 2;
+      if (amount < 1) {
+        return -0.5 * Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
+      }
+      return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
+    }
+  }),
+  Back: Object.freeze({
+    In: function(amount) {
+      var s = 1.70158;
+      return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
+    },
+    Out: function(amount) {
+      var s = 1.70158;
+      return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
+    },
+    InOut: function(amount) {
+      var s = 1.70158 * 1.525;
+      if ((amount *= 2) < 1) {
+        return 0.5 * (amount * amount * ((s + 1) * amount - s));
+      }
+      return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
+    }
+  }),
+  Bounce: Object.freeze({
+    In: function(amount) {
+      return 1 - Easing.Bounce.Out(1 - amount);
+    },
+    Out: function(amount) {
+      if (amount < 1 / 2.75) {
+        return 7.5625 * amount * amount;
+      } else if (amount < 2 / 2.75) {
+        return 7.5625 * (amount -= 1.5 / 2.75) * amount + 0.75;
+      } else if (amount < 2.5 / 2.75) {
+        return 7.5625 * (amount -= 2.25 / 2.75) * amount + 0.9375;
+      } else {
+        return 7.5625 * (amount -= 2.625 / 2.75) * amount + 0.984375;
+      }
+    },
+    InOut: function(amount) {
+      if (amount < 0.5) {
+        return Easing.Bounce.In(amount * 2) * 0.5;
+      }
+      return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
+    }
+  }),
+  generatePow: function(power) {
+    if (power === void 0) {
+      power = 4;
+    }
+    power = power < Number.EPSILON ? Number.EPSILON : power;
+    power = power > 1e4 ? 1e4 : power;
+    return {
+      In: function(amount) {
+        return Math.pow(amount, power);
+      },
+      Out: function(amount) {
+        return 1 - Math.pow(1 - amount, power);
+      },
+      InOut: function(amount) {
+        if (amount < 0.5) {
+          return Math.pow(amount * 2, power) / 2;
+        }
+        return (1 - Math.pow(2 - amount * 2, power)) / 2 + 0.5;
+      }
+    };
+  }
+});
+var now = function() {
+  return performance.now();
+};
+var Group = (
+  /** @class */
+  function() {
+    function Group2() {
+      this._tweens = {};
+      this._tweensAddedDuringUpdate = {};
+    }
+    Group2.prototype.getAll = function() {
+      var _this = this;
+      return Object.keys(this._tweens).map(function(tweenId) {
+        return _this._tweens[tweenId];
+      });
+    };
+    Group2.prototype.removeAll = function() {
+      this._tweens = {};
+    };
+    Group2.prototype.add = function(tween) {
+      this._tweens[tween.getId()] = tween;
+      this._tweensAddedDuringUpdate[tween.getId()] = tween;
+    };
+    Group2.prototype.remove = function(tween) {
+      delete this._tweens[tween.getId()];
+      delete this._tweensAddedDuringUpdate[tween.getId()];
+    };
+    Group2.prototype.update = function(time, preserve) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (preserve === void 0) {
+        preserve = false;
+      }
+      var tweenIds = Object.keys(this._tweens);
+      if (tweenIds.length === 0) {
+        return false;
+      }
+      while (tweenIds.length > 0) {
+        this._tweensAddedDuringUpdate = {};
+        for (var i = 0; i < tweenIds.length; i++) {
+          var tween = this._tweens[tweenIds[i]];
+          var autoStart = !preserve;
+          if (tween && tween.update(time, autoStart) === false && !preserve) {
+            delete this._tweens[tweenIds[i]];
+          }
+        }
+        tweenIds = Object.keys(this._tweensAddedDuringUpdate);
+      }
+      return true;
+    };
+    return Group2;
+  }()
+);
+var Interpolation = {
+  Linear: function(v, k) {
+    var m = v.length - 1;
+    var f = m * k;
+    var i = Math.floor(f);
+    var fn = Interpolation.Utils.Linear;
+    if (k < 0) {
+      return fn(v[0], v[1], f);
+    }
+    if (k > 1) {
+      return fn(v[m], v[m - 1], m - f);
+    }
+    return fn(v[i], v[i + 1 > m ? m : i + 1], f - i);
+  },
+  Bezier: function(v, k) {
+    var b = 0;
+    var n = v.length - 1;
+    var pw = Math.pow;
+    var bn = Interpolation.Utils.Bernstein;
+    for (var i = 0; i <= n; i++) {
+      b += pw(1 - k, n - i) * pw(k, i) * v[i] * bn(n, i);
+    }
+    return b;
+  },
+  CatmullRom: function(v, k) {
+    var m = v.length - 1;
+    var f = m * k;
+    var i = Math.floor(f);
+    var fn = Interpolation.Utils.CatmullRom;
+    if (v[0] === v[m]) {
+      if (k < 0) {
+        i = Math.floor(f = m * (1 + k));
+      }
+      return fn(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
+    } else {
+      if (k < 0) {
+        return v[0] - (fn(v[0], v[0], v[1], v[1], -f) - v[0]);
+      }
+      if (k > 1) {
+        return v[m] - (fn(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
+      }
+      return fn(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
+    }
+  },
+  Utils: {
+    Linear: function(p0, p1, t) {
+      return (p1 - p0) * t + p0;
+    },
+    Bernstein: function(n, i) {
+      var fc = Interpolation.Utils.Factorial;
+      return fc(n) / fc(i) / fc(n - i);
+    },
+    Factorial: /* @__PURE__ */ function() {
+      var a = [1];
+      return function(n) {
+        var s = 1;
+        if (a[n]) {
+          return a[n];
+        }
+        for (var i = n; i > 1; i--) {
+          s *= i;
+        }
+        a[n] = s;
+        return s;
+      };
+    }(),
+    CatmullRom: function(p0, p1, p2, p3, t) {
+      var v0 = (p2 - p0) * 0.5;
+      var v1 = (p3 - p1) * 0.5;
+      var t2 = t * t;
+      var t3 = t * t2;
+      return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+    }
+  }
+};
+var Sequence = (
+  /** @class */
+  function() {
+    function Sequence2() {
+    }
+    Sequence2.nextId = function() {
+      return Sequence2._nextId++;
+    };
+    Sequence2._nextId = 0;
+    return Sequence2;
+  }()
+);
+var mainGroup = new Group();
+var Tween = (
+  /** @class */
+  function() {
+    function Tween2(_object, _group) {
+      if (_group === void 0) {
+        _group = mainGroup;
+      }
+      this._object = _object;
+      this._group = _group;
+      this._isPaused = false;
+      this._pauseStart = 0;
+      this._valuesStart = {};
+      this._valuesEnd = {};
+      this._valuesStartRepeat = {};
+      this._duration = 1e3;
+      this._isDynamic = false;
+      this._initialRepeat = 0;
+      this._repeat = 0;
+      this._yoyo = false;
+      this._isPlaying = false;
+      this._reversed = false;
+      this._delayTime = 0;
+      this._startTime = 0;
+      this._easingFunction = Easing.Linear.None;
+      this._interpolationFunction = Interpolation.Linear;
+      this._chainedTweens = [];
+      this._onStartCallbackFired = false;
+      this._onEveryStartCallbackFired = false;
+      this._id = Sequence.nextId();
+      this._isChainStopped = false;
+      this._propertiesAreSetUp = false;
+      this._goToEnd = false;
+    }
+    Tween2.prototype.getId = function() {
+      return this._id;
+    };
+    Tween2.prototype.isPlaying = function() {
+      return this._isPlaying;
+    };
+    Tween2.prototype.isPaused = function() {
+      return this._isPaused;
+    };
+    Tween2.prototype.getDuration = function() {
+      return this._duration;
+    };
+    Tween2.prototype.to = function(target, duration) {
+      if (duration === void 0) {
+        duration = 1e3;
+      }
+      if (this._isPlaying)
+        throw new Error("Can not call Tween.to() while Tween is already started or paused. Stop the Tween first.");
+      this._valuesEnd = target;
+      this._propertiesAreSetUp = false;
+      this._duration = duration < 0 ? 0 : duration;
+      return this;
+    };
+    Tween2.prototype.duration = function(duration) {
+      if (duration === void 0) {
+        duration = 1e3;
+      }
+      this._duration = duration < 0 ? 0 : duration;
+      return this;
+    };
+    Tween2.prototype.dynamic = function(dynamic) {
+      if (dynamic === void 0) {
+        dynamic = false;
+      }
+      this._isDynamic = dynamic;
+      return this;
+    };
+    Tween2.prototype.start = function(time, overrideStartingValues) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (overrideStartingValues === void 0) {
+        overrideStartingValues = false;
+      }
+      if (this._isPlaying) {
+        return this;
+      }
+      this._group && this._group.add(this);
+      this._repeat = this._initialRepeat;
+      if (this._reversed) {
+        this._reversed = false;
+        for (var property in this._valuesStartRepeat) {
+          this._swapEndStartRepeatValues(property);
+          this._valuesStart[property] = this._valuesStartRepeat[property];
+        }
+      }
+      this._isPlaying = true;
+      this._isPaused = false;
+      this._onStartCallbackFired = false;
+      this._onEveryStartCallbackFired = false;
+      this._isChainStopped = false;
+      this._startTime = time;
+      this._startTime += this._delayTime;
+      if (!this._propertiesAreSetUp || overrideStartingValues) {
+        this._propertiesAreSetUp = true;
+        if (!this._isDynamic) {
+          var tmp = {};
+          for (var prop in this._valuesEnd)
+            tmp[prop] = this._valuesEnd[prop];
+          this._valuesEnd = tmp;
+        }
+        this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat, overrideStartingValues);
+      }
+      return this;
+    };
+    Tween2.prototype.startFromCurrentValues = function(time) {
+      return this.start(time, true);
+    };
+    Tween2.prototype._setupProperties = function(_object, _valuesStart, _valuesEnd, _valuesStartRepeat, overrideStartingValues) {
+      for (var property in _valuesEnd) {
+        var startValue = _object[property];
+        var startValueIsArray = Array.isArray(startValue);
+        var propType = startValueIsArray ? "array" : typeof startValue;
+        var isInterpolationList = !startValueIsArray && Array.isArray(_valuesEnd[property]);
+        if (propType === "undefined" || propType === "function") {
+          continue;
+        }
+        if (isInterpolationList) {
+          var endValues = _valuesEnd[property];
+          if (endValues.length === 0) {
+            continue;
+          }
+          var temp = [startValue];
+          for (var i = 0, l = endValues.length; i < l; i += 1) {
+            var value = this._handleRelativeValue(startValue, endValues[i]);
+            if (isNaN(value)) {
+              isInterpolationList = false;
+              console.warn("Found invalid interpolation list. Skipping.");
+              break;
+            }
+            temp.push(value);
+          }
+          if (isInterpolationList) {
+            _valuesEnd[property] = temp;
+          }
+        }
+        if ((propType === "object" || startValueIsArray) && startValue && !isInterpolationList) {
+          _valuesStart[property] = startValueIsArray ? [] : {};
+          var nestedObject = startValue;
+          for (var prop in nestedObject) {
+            _valuesStart[property][prop] = nestedObject[prop];
+          }
+          _valuesStartRepeat[property] = startValueIsArray ? [] : {};
+          var endValues = _valuesEnd[property];
+          if (!this._isDynamic) {
+            var tmp = {};
+            for (var prop in endValues)
+              tmp[prop] = endValues[prop];
+            _valuesEnd[property] = endValues = tmp;
+          }
+          this._setupProperties(nestedObject, _valuesStart[property], endValues, _valuesStartRepeat[property], overrideStartingValues);
+        } else {
+          if (typeof _valuesStart[property] === "undefined" || overrideStartingValues) {
+            _valuesStart[property] = startValue;
+          }
+          if (!startValueIsArray) {
+            _valuesStart[property] *= 1;
+          }
+          if (isInterpolationList) {
+            _valuesStartRepeat[property] = _valuesEnd[property].slice().reverse();
+          } else {
+            _valuesStartRepeat[property] = _valuesStart[property] || 0;
+          }
+        }
+      }
+    };
+    Tween2.prototype.stop = function() {
+      if (!this._isChainStopped) {
+        this._isChainStopped = true;
+        this.stopChainedTweens();
+      }
+      if (!this._isPlaying) {
+        return this;
+      }
+      this._group && this._group.remove(this);
+      this._isPlaying = false;
+      this._isPaused = false;
+      if (this._onStopCallback) {
+        this._onStopCallback(this._object);
+      }
+      return this;
+    };
+    Tween2.prototype.end = function() {
+      this._goToEnd = true;
+      this.update(Infinity);
+      return this;
+    };
+    Tween2.prototype.pause = function(time) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (this._isPaused || !this._isPlaying) {
+        return this;
+      }
+      this._isPaused = true;
+      this._pauseStart = time;
+      this._group && this._group.remove(this);
+      return this;
+    };
+    Tween2.prototype.resume = function(time) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (!this._isPaused || !this._isPlaying) {
+        return this;
+      }
+      this._isPaused = false;
+      this._startTime += time - this._pauseStart;
+      this._pauseStart = 0;
+      this._group && this._group.add(this);
+      return this;
+    };
+    Tween2.prototype.stopChainedTweens = function() {
+      for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
+        this._chainedTweens[i].stop();
+      }
+      return this;
+    };
+    Tween2.prototype.group = function(group) {
+      if (group === void 0) {
+        group = mainGroup;
+      }
+      this._group = group;
+      return this;
+    };
+    Tween2.prototype.delay = function(amount) {
+      if (amount === void 0) {
+        amount = 0;
+      }
+      this._delayTime = amount;
+      return this;
+    };
+    Tween2.prototype.repeat = function(times) {
+      if (times === void 0) {
+        times = 0;
+      }
+      this._initialRepeat = times;
+      this._repeat = times;
+      return this;
+    };
+    Tween2.prototype.repeatDelay = function(amount) {
+      this._repeatDelayTime = amount;
+      return this;
+    };
+    Tween2.prototype.yoyo = function(yoyo) {
+      if (yoyo === void 0) {
+        yoyo = false;
+      }
+      this._yoyo = yoyo;
+      return this;
+    };
+    Tween2.prototype.easing = function(easingFunction) {
+      if (easingFunction === void 0) {
+        easingFunction = Easing.Linear.None;
+      }
+      this._easingFunction = easingFunction;
+      return this;
+    };
+    Tween2.prototype.interpolation = function(interpolationFunction) {
+      if (interpolationFunction === void 0) {
+        interpolationFunction = Interpolation.Linear;
+      }
+      this._interpolationFunction = interpolationFunction;
+      return this;
+    };
+    Tween2.prototype.chain = function() {
+      var tweens = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        tweens[_i] = arguments[_i];
+      }
+      this._chainedTweens = tweens;
+      return this;
+    };
+    Tween2.prototype.onStart = function(callback) {
+      this._onStartCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onEveryStart = function(callback) {
+      this._onEveryStartCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onUpdate = function(callback) {
+      this._onUpdateCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onRepeat = function(callback) {
+      this._onRepeatCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onComplete = function(callback) {
+      this._onCompleteCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onStop = function(callback) {
+      this._onStopCallback = callback;
+      return this;
+    };
+    Tween2.prototype.update = function(time, autoStart) {
+      var _this = this;
+      var _a;
+      if (time === void 0) {
+        time = now();
+      }
+      if (autoStart === void 0) {
+        autoStart = true;
+      }
+      if (this._isPaused)
+        return true;
+      var property;
+      var endTime = this._startTime + this._duration;
+      if (!this._goToEnd && !this._isPlaying) {
+        if (time > endTime)
+          return false;
+        if (autoStart)
+          this.start(time, true);
+      }
+      this._goToEnd = false;
+      if (time < this._startTime) {
+        return true;
+      }
+      if (this._onStartCallbackFired === false) {
+        if (this._onStartCallback) {
+          this._onStartCallback(this._object);
+        }
+        this._onStartCallbackFired = true;
+      }
+      if (this._onEveryStartCallbackFired === false) {
+        if (this._onEveryStartCallback) {
+          this._onEveryStartCallback(this._object);
+        }
+        this._onEveryStartCallbackFired = true;
+      }
+      var elapsedTime = time - this._startTime;
+      var durationAndDelay = this._duration + ((_a = this._repeatDelayTime) !== null && _a !== void 0 ? _a : this._delayTime);
+      var totalTime = this._duration + this._repeat * durationAndDelay;
+      var calculateElapsedPortion = function() {
+        if (_this._duration === 0)
+          return 1;
+        if (elapsedTime > totalTime) {
+          return 1;
+        }
+        var timesRepeated = Math.trunc(elapsedTime / durationAndDelay);
+        var timeIntoCurrentRepeat = elapsedTime - timesRepeated * durationAndDelay;
+        var portion = Math.min(timeIntoCurrentRepeat / _this._duration, 1);
+        if (portion === 0 && elapsedTime === _this._duration) {
+          return 1;
+        }
+        return portion;
+      };
+      var elapsed = calculateElapsedPortion();
+      var value = this._easingFunction(elapsed);
+      this._updateProperties(this._object, this._valuesStart, this._valuesEnd, value);
+      if (this._onUpdateCallback) {
+        this._onUpdateCallback(this._object, elapsed);
+      }
+      if (this._duration === 0 || elapsedTime >= this._duration) {
+        if (this._repeat > 0) {
+          var completeCount = Math.min(Math.trunc((elapsedTime - this._duration) / durationAndDelay) + 1, this._repeat);
+          if (isFinite(this._repeat)) {
+            this._repeat -= completeCount;
+          }
+          for (property in this._valuesStartRepeat) {
+            if (!this._yoyo && typeof this._valuesEnd[property] === "string") {
+              this._valuesStartRepeat[property] = // eslint-disable-next-line
+              // @ts-ignore FIXME?
+              this._valuesStartRepeat[property] + parseFloat(this._valuesEnd[property]);
+            }
+            if (this._yoyo) {
+              this._swapEndStartRepeatValues(property);
+            }
+            this._valuesStart[property] = this._valuesStartRepeat[property];
+          }
+          if (this._yoyo) {
+            this._reversed = !this._reversed;
+          }
+          this._startTime += durationAndDelay * completeCount;
+          if (this._onRepeatCallback) {
+            this._onRepeatCallback(this._object);
+          }
+          this._onEveryStartCallbackFired = false;
+          return true;
+        } else {
+          if (this._onCompleteCallback) {
+            this._onCompleteCallback(this._object);
+          }
+          for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
+            this._chainedTweens[i].start(this._startTime + this._duration, false);
+          }
+          this._isPlaying = false;
+          return false;
+        }
+      }
+      return true;
+    };
+    Tween2.prototype._updateProperties = function(_object, _valuesStart, _valuesEnd, value) {
+      for (var property in _valuesEnd) {
+        if (_valuesStart[property] === void 0) {
+          continue;
+        }
+        var start = _valuesStart[property] || 0;
+        var end = _valuesEnd[property];
+        var startIsArray = Array.isArray(_object[property]);
+        var endIsArray = Array.isArray(end);
+        var isInterpolationList = !startIsArray && endIsArray;
+        if (isInterpolationList) {
+          _object[property] = this._interpolationFunction(end, value);
+        } else if (typeof end === "object" && end) {
+          this._updateProperties(_object[property], start, end, value);
+        } else {
+          end = this._handleRelativeValue(start, end);
+          if (typeof end === "number") {
+            _object[property] = start + (end - start) * value;
+          }
+        }
+      }
+    };
+    Tween2.prototype._handleRelativeValue = function(start, end) {
+      if (typeof end !== "string") {
+        return end;
+      }
+      if (end.charAt(0) === "+" || end.charAt(0) === "-") {
+        return start + parseFloat(end);
+      }
+      return parseFloat(end);
+    };
+    Tween2.prototype._swapEndStartRepeatValues = function(property) {
+      var tmp = this._valuesStartRepeat[property];
+      var endValue = this._valuesEnd[property];
+      if (typeof endValue === "string") {
+        this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(endValue);
+      } else {
+        this._valuesStartRepeat[property] = this._valuesEnd[property];
+      }
+      this._valuesEnd[property] = tmp;
+    };
+    return Tween2;
+  }()
+);
+var VERSION = "23.1.1";
+var nextId = Sequence.nextId;
+var TWEEN = mainGroup;
+var getAll = TWEEN.getAll.bind(TWEEN);
+var removeAll = TWEEN.removeAll.bind(TWEEN);
+var add = TWEEN.add.bind(TWEEN);
+var remove = TWEEN.remove.bind(TWEEN);
+var update = TWEEN.update.bind(TWEEN);
+var exports = {
+  Easing,
+  Group,
+  Interpolation,
+  now,
+  Sequence,
+  nextId,
+  Tween,
+  VERSION,
+  getAll,
+  removeAll,
+  add,
+  remove,
+  update
+};
+export {
+  Easing,
+  Group,
+  Interpolation,
+  Sequence,
+  Tween,
+  VERSION,
+  add,
+  exports as default,
+  getAll,
+  nextId,
+  now,
+  remove,
+  removeAll,
+  update
+};
+//# sourceMappingURL=three_examples_jsm_libs_tween__module__js.js.map